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  */
28 
29 /*
30  * set-up for relocations
31  */
32 
33 #define	ELF_TARGET_AMD64
34 #define	ELF_TARGET_SPARC
35 
36 #include	<string.h>
37 #include	<stdio.h>
38 #include	<alloca.h>
39 #include	<debug.h>
40 #include	"msg.h"
41 #include	"_libld.h"
42 
43 /*
44  * Set up the relocation table flag test macros so that they use the
45  * relocation table for the current target machine.
46  */
47 #define	IS_PLT(X)	RELTAB_IS_PLT(X, ld_targ.t_mr.mr_reloc_table)
48 #define	IS_GOT_RELATIVE(X) \
49 	RELTAB_IS_GOT_RELATIVE(X, ld_targ.t_mr.mr_reloc_table)
50 #define	IS_GOT_PC(X)	RELTAB_IS_GOT_PC(X, ld_targ.t_mr.mr_reloc_table)
51 #define	IS_GOTPCREL(X)	RELTAB_IS_GOTPCREL(X, ld_targ.t_mr.mr_reloc_table)
52 #define	IS_GOT_BASED(X)	RELTAB_IS_GOT_BASED(X, ld_targ.t_mr.mr_reloc_table)
53 #define	IS_GOT_OPINS(X)	RELTAB_IS_GOT_OPINS(X, ld_targ.t_mr.mr_reloc_table)
54 #define	IS_GOT_REQUIRED(X) \
55 	RELTAB_IS_GOT_REQUIRED(X, ld_targ.t_mr.mr_reloc_table)
56 #define	IS_PC_RELATIVE(X) RELTAB_IS_PC_RELATIVE(X, ld_targ.t_mr.mr_reloc_table)
57 #define	IS_ADD_RELATIVE(X) \
58 	RELTAB_IS_ADD_RELATIVE(X, ld_targ.t_mr.mr_reloc_table)
59 #define	IS_REGISTER(X)	RELTAB_IS_REGISTER(X, ld_targ.t_mr.mr_reloc_table)
60 #define	IS_NOTSUP(X)	RELTAB_IS_NOTSUP(X, ld_targ.t_mr.mr_reloc_table)
61 #define	IS_SEG_RELATIVE(X) \
62 	RELTAB_IS_SEG_RELATIVE(X, ld_targ.t_mr.mr_reloc_table)
63 #define	IS_EXTOFFSET(X)	RELTAB_IS_EXTOFFSET(X, ld_targ.t_mr.mr_reloc_table)
64 #define	IS_SEC_RELATIVE(X) \
65 	RELTAB_IS_SEC_RELATIVE(X, ld_targ.t_mr.mr_reloc_table)
66 #define	IS_TLS_INS(X)	RELTAB_IS_TLS_INS(X, ld_targ.t_mr.mr_reloc_table)
67 #define	IS_TLS_GD(X)	RELTAB_IS_TLS_GD(X, ld_targ.t_mr.mr_reloc_table)
68 #define	IS_TLS_LD(X)	RELTAB_IS_TLS_LD(X, ld_targ.t_mr.mr_reloc_table)
69 #define	IS_TLS_IE(X)	RELTAB_IS_TLS_IE(X, ld_targ.t_mr.mr_reloc_table)
70 #define	IS_TLS_LE(X)	RELTAB_IS_TLS_LE(X, ld_targ.t_mr.mr_reloc_table)
71 #define	IS_LOCALBND(X)	RELTAB_IS_LOCALBND(X, ld_targ.t_mr.mr_reloc_table)
72 #define	IS_SIZE(X)	RELTAB_IS_SIZE(X, ld_targ.t_mr.mr_reloc_table)
73 
74 /*
75  * Structure to hold copy relocation items.
76  */
77 typedef struct copy_rel {
78 	Sym_desc	*c_sdp;		/* symbol descriptor to be copied */
79 	Addr		c_val;		/* original symbol value */
80 } Copy_rel;
81 
82 /*
83  * For each copy relocation symbol, determine if the symbol is:
84  *	1) to be *disp* relocated at runtime
85  *	2) a reference symbol for *disp* relocation
86  *	3) possibly *disp* relocated at ld time.
87  *
88  * The first and the second are serious errors.
89  */
90 static void
is_disp_copied(Ofl_desc * ofl,Copy_rel * crp)91 is_disp_copied(Ofl_desc *ofl, Copy_rel *crp)
92 {
93 	Ifl_desc	*ifl = crp->c_sdp->sd_file;
94 	Sym_desc	*sdp = crp->c_sdp;
95 	Addr		symaddr = crp->c_val;
96 	Is_desc		*irel;
97 	Aliste		idx;
98 	Conv_inv_buf_t	inv_buf;
99 
100 	/*
101 	 * This symbol may not be *disp* relocated at run time, but could
102 	 * already have been *disp* relocated when the shared object was
103 	 * created.  Warn the user.
104 	 */
105 	if ((ifl->ifl_flags & FLG_IF_DISPDONE) &&
106 	    (ofl->ofl_flags & FLG_OF_VERBOSE))
107 		ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_REL_DISPREL2),
108 		    conv_reloc_type(ifl->ifl_ehdr->e_machine,
109 		    ld_targ.t_m.m_r_copy, 0, &inv_buf),
110 		    ifl->ifl_name, demangle(sdp->sd_name));
111 
112 	if ((ifl->ifl_flags & FLG_IF_DISPPEND) == 0)
113 		return;
114 
115 	/*
116 	 * Traverse the input relocation sections.
117 	 */
118 	for (APLIST_TRAVERSE(ifl->ifl_relsect, idx, irel)) {
119 		Sym_desc	*rsdp;
120 		Is_desc		*trel;
121 		Rel		*rend, *reloc;
122 		Xword		rsize, entsize;
123 
124 		trel = ifl->ifl_isdesc[irel->is_shdr->sh_info];
125 		rsize = irel->is_shdr->sh_size;
126 		entsize = irel->is_shdr->sh_entsize;
127 		reloc = (Rel *)irel->is_indata->d_buf;
128 
129 		/*
130 		 * Decide entry size
131 		 */
132 		if ((entsize == 0) || (entsize > rsize)) {
133 			if (irel->is_shdr->sh_type == SHT_RELA)
134 				entsize = sizeof (Rela);
135 			else
136 				entsize = sizeof (Rel);
137 		}
138 
139 		/*
140 		 * Traverse the relocation entries.
141 		 */
142 		for (rend = (Rel *)((uintptr_t)reloc + (uintptr_t)rsize);
143 		    reloc < rend;
144 		    reloc = (Rel *)((uintptr_t)reloc + (uintptr_t)entsize)) {
145 			const char	*str;
146 			Word		rstndx;
147 
148 			if (IS_PC_RELATIVE(ELF_R_TYPE(reloc->r_info,
149 			    ld_targ.t_m.m_mach)) == 0)
150 				continue;
151 
152 			/*
153 			 * Determine if symbol is referenced from a relocation.
154 			 */
155 			rstndx = (Word) ELF_R_SYM(reloc->r_info);
156 			rsdp = ifl->ifl_oldndx[rstndx];
157 			if (rsdp == sdp) {
158 				if ((str = demangle(rsdp->sd_name)) !=
159 				    rsdp->sd_name) {
160 					char	*_str = alloca(strlen(str) + 1);
161 					(void) strcpy(_str, str);
162 					str = (const char *)_str;
163 				}
164 				ld_eprintf(ofl, ERR_WARNING,
165 				    MSG_INTL(MSG_REL_DISPREL1),
166 				    conv_reloc_type(ifl->ifl_ehdr->e_machine,
167 				    (uint_t)ELF_R_TYPE(reloc->r_info,
168 				    ld_targ.t_m.m_mach),
169 				    0, &inv_buf), ifl->ifl_name, str,
170 				    MSG_INTL(MSG_STR_UNKNOWN),
171 				    EC_XWORD(reloc->r_offset),
172 				    demangle(sdp->sd_name));
173 			}
174 
175 			/*
176 			 * Determine whether the relocation entry is relocating
177 			 * this symbol.
178 			 */
179 			if ((sdp->sd_isc != trel) ||
180 			    (reloc->r_offset < symaddr) ||
181 			    (reloc->r_offset >=
182 			    (symaddr + sdp->sd_sym->st_size)))
183 				continue;
184 
185 			/*
186 			 * This symbol is truely *disp* relocated, so should
187 			 * really be fixed by user.
188 			 */
189 			if ((str = demangle(sdp->sd_name)) != sdp->sd_name) {
190 				char	*_str = alloca(strlen(str) + 1);
191 				(void) strcpy(_str, str);
192 				str = (const char *)_str;
193 			}
194 			ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_REL_DISPREL1),
195 			    conv_reloc_type(ifl->ifl_ehdr->e_machine,
196 			    (uint_t)ELF_R_TYPE(reloc->r_info,
197 			    ld_targ.t_m.m_mach), 0, &inv_buf),
198 			    ifl->ifl_name, demangle(rsdp->sd_name), str,
199 			    EC_XWORD(reloc->r_offset), str);
200 		}
201 	}
202 }
203 
204 /*
205  * The number of symbols provided by some objects can be very large.  Use a
206  * binary search to match the associated value to a symbol table entry.
207  */
208 static int
disp_bsearch(const void * key,const void * array)209 disp_bsearch(const void *key, const void *array)
210 {
211 	Addr		kvalue, avalue;
212 	Ssv_desc	*ssvp = (Ssv_desc *)array;
213 
214 	kvalue = *((Addr *)key);
215 	avalue = ssvp->ssv_value;
216 
217 	if (avalue > kvalue)
218 		return (-1);
219 	if ((avalue < kvalue) &&
220 	    ((avalue + ssvp->ssv_sdp->sd_sym->st_size) <= kvalue))
221 		return (1);
222 	return (0);
223 }
224 
225 /*
226  * Given a sorted list of symbols, look for a symbol in which the relocation
227  * offset falls between the [sym.st_value - sym.st_value + sym.st_size].  Since
228  * the symbol list is maintained in sorted order,  we can bail once the
229  * relocation offset becomes less than the symbol values.  The symbol is
230  * returned for use in error diagnostics.
231  */
232 static Sym_desc *
disp_scansyms(Ifl_desc * ifl,Rel_desc * rld,Boolean rlocal,int inspect,Ofl_desc * ofl)233 disp_scansyms(Ifl_desc * ifl, Rel_desc *rld, Boolean rlocal, int inspect,
234     Ofl_desc *ofl)
235 {
236 	Sym_desc	*tsdp, *rsdp;
237 	Sym		*rsym, *tsym;
238 	Ssv_desc	*ssvp;
239 	uchar_t		rtype, ttype;
240 	Addr		value;
241 
242 	/*
243 	 * Sorted symbol values have been uniquified by adding their associated
244 	 * section offset.  Uniquify the relocation offset by adding its
245 	 * associated section offset, and search for the symbol.
246 	 */
247 	value = rld->rel_roffset;
248 	if (rld->rel_isdesc->is_shdr)
249 		value += rld->rel_isdesc->is_shdr->sh_offset;
250 
251 	if ((ssvp = bsearch((void *)&value, (void *)ifl->ifl_sortsyms,
252 	    ifl->ifl_sortcnt, sizeof (Ssv_desc), &disp_bsearch)) != 0)
253 		tsdp = ssvp->ssv_sdp;
254 	else
255 		tsdp = 0;
256 
257 	if (inspect)
258 		return (tsdp);
259 
260 	/*
261 	 * Determine the relocation reference symbol and its type.
262 	 */
263 	rsdp = rld->rel_sym;
264 	rsym = rsdp->sd_sym;
265 	rtype = ELF_ST_TYPE(rsym->st_info);
266 
267 	/*
268 	 * If there is no target symbol to match the relocation offset, then the
269 	 * offset is effectively local data.  If the relocation symbol is global
270 	 * data we have a potential for this displacement relocation to be
271 	 * invalidated should the global symbol be copied.
272 	 */
273 	if (tsdp == 0) {
274 		if ((rlocal == TRUE) ||
275 		    ((rtype != STT_OBJECT) && (rtype != STT_SECTION)))
276 		return (tsdp);
277 	} else {
278 		/*
279 		 * If both symbols are local, no copy relocations can occur to
280 		 * either symbol.  Note, this test is very similar to the test
281 		 * used in ld_sym_adjust_vis().
282 		 */
283 		if ((rlocal == TRUE) && (SYM_IS_HIDDEN(tsdp) ||
284 		    (ELF_ST_BIND(tsdp->sd_sym->st_info) != STB_GLOBAL) ||
285 		    ((ofl->ofl_flags & (FLG_OF_AUTOLCL | FLG_OF_AUTOELM)) &&
286 		    ((tsdp->sd_flags & MSK_SY_NOAUTO) == 0))))
287 			return (tsdp);
288 
289 		/*
290 		 * Determine the relocation target symbols type.
291 		 */
292 		tsym = tsdp->sd_sym;
293 		ttype = ELF_ST_TYPE(tsym->st_info);
294 
295 		/*
296 		 * If the reference symbol is local, and the target isn't a
297 		 * data element, then no copy relocations can occur to either
298 		 * symbol.  Note, this catches pc-relative relocations against
299 		 * the _GLOBAL_OFFSET_TABLE_, which is effectively treated as
300 		 * a local symbol.
301 		 */
302 		if ((rlocal == TRUE) && (ttype != STT_OBJECT) &&
303 		    (ttype != STT_SECTION))
304 			return (tsdp);
305 
306 		/*
307 		 * Finally, one of the symbols must reference a data element.
308 		 */
309 		if ((rtype != STT_OBJECT) && (rtype != STT_SECTION) &&
310 		    (ttype != STT_OBJECT) && (ttype != STT_SECTION))
311 			return (tsdp);
312 	}
313 
314 	/*
315 	 * We have two global symbols, at least one of which is a data item.
316 	 * The last case where a displacement relocation can be ignored, is
317 	 * if the reference symbol is included in the target symbol.
318 	 */
319 	value = rsym->st_value;
320 	if ((rld->rel_flags & FLG_REL_RELA) == FLG_REL_RELA)
321 		value += rld->rel_raddend;
322 
323 	if ((rld->rel_roffset >= value) &&
324 	    (rld->rel_roffset < (value + rsym->st_size)))
325 		return (tsdp);
326 
327 	/*
328 	 * We have a displacement relocation that could be compromised by a
329 	 * copy relocation of one of the associated data items.
330 	 */
331 	rld->rel_flags |= FLG_REL_DISP;
332 	return (tsdp);
333 }
334 
335 void
ld_disp_errmsg(const char * msg,Rel_desc * rsp,Ofl_desc * ofl)336 ld_disp_errmsg(const char *msg, Rel_desc *rsp, Ofl_desc *ofl)
337 {
338 	Sym_desc	*sdp;
339 	const char	*str;
340 	Ifl_desc	*ifl = rsp->rel_isdesc->is_file;
341 	Conv_inv_buf_t	inv_buf;
342 
343 	if ((sdp = disp_scansyms(ifl, rsp, 0, 1, ofl)) != 0)
344 		str = demangle(sdp->sd_name);
345 	else
346 		str = MSG_INTL(MSG_STR_UNKNOWN);
347 
348 	ld_eprintf(ofl, ERR_WARNING, msg,
349 	    conv_reloc_type(ifl->ifl_ehdr->e_machine, rsp->rel_rtype,
350 	    0, &inv_buf), ifl->ifl_name, ld_reloc_sym_name(rsp), str,
351 	    EC_OFF(rsp->rel_roffset));
352 }
353 
354 /*
355  * qsort(3C) comparison routine used for the disp_sortsyms().
356  */
357 static int
disp_qsort(const void * s1,const void * s2)358 disp_qsort(const void * s1, const void * s2)
359 {
360 	Ssv_desc	*ssvp1 = ((Ssv_desc *)s1);
361 	Ssv_desc	*ssvp2 = ((Ssv_desc *)s2);
362 	Addr		val1 = ssvp1->ssv_value;
363 	Addr		val2 = ssvp2->ssv_value;
364 
365 	if (val1 > val2)
366 		return (1);
367 	if (val1 < val2)
368 		return (-1);
369 	return (0);
370 }
371 
372 /*
373  * Determine whether a displacement relocation is between a local and global
374  * symbol pair.  One symbol is used to perform the relocation, and the other
375  * is the destination offset of the relocation.
376  */
377 static uintptr_t
disp_inspect(Ofl_desc * ofl,Rel_desc * rld,Boolean rlocal)378 disp_inspect(Ofl_desc *ofl, Rel_desc *rld, Boolean rlocal)
379 {
380 	Is_desc		*isp = rld->rel_isdesc;
381 	Ifl_desc	*ifl = rld->rel_isdesc->is_file;
382 
383 	/*
384 	 * If the input files symbols haven't been sorted yet, do so.
385 	 */
386 	if (ifl->ifl_sortsyms == 0) {
387 		Word	ondx, nndx;
388 
389 		if ((ifl->ifl_sortsyms = libld_malloc((ifl->ifl_symscnt + 1) *
390 		    sizeof (Ssv_desc))) == 0)
391 			return (S_ERROR);
392 
393 		for (ondx = 0, nndx = 0; ondx < ifl->ifl_symscnt; ondx++) {
394 			Sym_desc	*sdp;
395 			Addr		value;
396 
397 			/*
398 			 * As symbol resolution has already occurred, various
399 			 * symbols from this object may have been satisfied
400 			 * from other objects.  Only select symbols from this
401 			 * object.  For the displacement test, we only really
402 			 * need to observe data definitions, however, later as
403 			 * part of providing warning disgnostics, relating the
404 			 * relocation offset to a symbol is desirable.  Thus,
405 			 * collect all symbols that define a memory area.
406 			 */
407 			if (((sdp = ifl->ifl_oldndx[ondx]) == 0) ||
408 			    (sdp->sd_sym->st_shndx == SHN_UNDEF) ||
409 			    (sdp->sd_sym->st_shndx >= SHN_LORESERVE) ||
410 			    (sdp->sd_ref != REF_REL_NEED) ||
411 			    (sdp->sd_file != ifl) ||
412 			    (sdp->sd_sym->st_size == 0))
413 				continue;
414 
415 			/*
416 			 * As a further optimization for later checking, mark
417 			 * this section if this a global data definition.
418 			 */
419 			if (sdp->sd_isc && (ondx >= ifl->ifl_locscnt))
420 				sdp->sd_isc->is_flags |= FLG_IS_GDATADEF;
421 
422 			/*
423 			 * Capture the symbol.  Within relocatable objects, a
424 			 * symbols value is its offset within its associated
425 			 * section.  Add the section offset to this value to
426 			 * uniquify the symbol.
427 			 */
428 			value = sdp->sd_sym->st_value;
429 			if (sdp->sd_isc && sdp->sd_isc->is_shdr)
430 				value += sdp->sd_isc->is_shdr->sh_offset;
431 
432 			ifl->ifl_sortsyms[nndx].ssv_value = value;
433 			ifl->ifl_sortsyms[nndx].ssv_sdp = sdp;
434 			nndx++;
435 		}
436 
437 		/*
438 		 * Sort the list based on the symbols value (address).
439 		 */
440 		if ((ifl->ifl_sortcnt = nndx) != 0)
441 			qsort(ifl->ifl_sortsyms, nndx, sizeof (Ssv_desc),
442 			    &disp_qsort);
443 	}
444 
445 	/*
446 	 * If the reference symbol is local, and the section being relocated
447 	 * contains no global definitions, neither can be the target of a copy
448 	 * relocation.
449 	 */
450 	if ((rlocal == FALSE) && ((isp->is_flags & FLG_IS_GDATADEF) == 0))
451 		return (1);
452 
453 	/*
454 	 * Otherwise determine whether this relocation symbol and its offset
455 	 * could be candidates for a copy relocation.
456 	 */
457 	if (ifl->ifl_sortcnt)
458 		(void) disp_scansyms(ifl, rld, rlocal, 0, ofl);
459 	return (1);
460 }
461 
462 /*
463  * Return a Rel_cachebuf with an available Rel_desc entry from the
464  * specified cache, allocating a cache buffer if necessary.
465  *
466  * entry:
467  *	ofl - Output file descriptor
468  *	rcp - Relocation cache to allocate the descriptor from.
469  *		One of &ofl->ofl_actrels or &ofl->ofl_outrels.
470  *
471  * exit:
472  *	Returns the allocated descriptor, or NULL if the allocation fails.
473  */
474 static Rel_cachebuf *
ld_add_rel_cache(Ofl_desc * ofl,Rel_cache * rcp)475 ld_add_rel_cache(Ofl_desc *ofl, Rel_cache *rcp)
476 {
477 	Rel_cachebuf	*rcbp;
478 	size_t		nelts, size, alloc_cnt;
479 
480 	/*
481 	 * If there is space available in the present cache bucket, return the
482 	 * next free entry.
483 	 */
484 	alloc_cnt = aplist_nitems(rcp->rc_list);
485 	if (rcp->rc_list &&
486 	    ((rcbp = rcp->rc_list->apl_data[alloc_cnt - 1]) != NULL) &&
487 	    (rcbp->rc_free < rcbp->rc_end))
488 		return (rcbp);
489 
490 	/*
491 	 * Allocate a new bucket. As we cannot know the number of relocations
492 	 * we'll have in the active and output cache until after the link is
493 	 * complete, the size of the bucket is a heuristic.
494 	 *
495 	 * In general, if the output object is an executable, or a sharable
496 	 * object, then the size of the active relocation list will be nearly
497 	 * the same as the number of input relocations, and the output
498 	 * relocation list will be very short. If the output object is a
499 	 * relocatable object, then the reverse is true. Therefore, the initial
500 	 * allocation for the appropriate list is sized to fit all the input
501 	 * allocations in a single shot.
502 	 *
503 	 * All other allocations are done in units of REL_CACHEBUF_ALLOC,
504 	 * which is chosen to be large enough to cover most common cases,
505 	 * but small enough that not using it fully is inconsequential.
506 	 *
507 	 * In an ideal scenario, this results in one allocation on each list.
508 	 */
509 	nelts = REL_CACHEBUF_ALLOC;
510 	if ((alloc_cnt == 0) && (ofl->ofl_relocincnt > REL_CACHEBUF_ALLOC)) {
511 		Boolean is_rel = (ofl->ofl_flags & FLG_OF_RELOBJ) != 0;
512 
513 		if (((rcp == &ofl->ofl_actrels) && !is_rel) ||
514 		    ((rcp == &ofl->ofl_outrels) && is_rel))
515 			nelts = ofl->ofl_relocincnt;
516 	}
517 
518 	/*
519 	 * Compute the total number of bytes to allocate. The first element
520 	 * of the array is built into the Rel_cachebuf header, so we subtract
521 	 * one from nelts.
522 	 */
523 	size = sizeof (Rel_cachebuf) + ((nelts - 1) * sizeof (Rel_desc));
524 
525 	if (((rcbp = libld_malloc(size)) == NULL) ||
526 	    (aplist_append(&rcp->rc_list, rcbp, AL_CNT_OFL_RELS) == NULL))
527 		return (NULL);
528 
529 	rcbp->rc_free = rcbp->rc_arr;
530 	rcbp->rc_end = rcbp->rc_arr + nelts;
531 
532 	return (rcbp);
533 }
534 
535 /*
536  * Allocate a Rel_aux descriptor and attach it to the given Rel_desc,
537  * allocating an auxiliary cache buffer if necessary.
538  *
539  * entry:
540  *	ofl - Output file descriptor
541  *	rdp - Rel_desc descriptor that requires an auxiliary block
542  *
543  * exit:
544  *	Returns TRUE on success, and FALSE if the allocation fails.
545  *	On success, the caller is responsible for initializing the
546  *	auxiliary block properly.
547  */
548 static Boolean
ld_add_rel_aux(Ofl_desc * ofl,Rel_desc * rdesc)549 ld_add_rel_aux(Ofl_desc *ofl, Rel_desc *rdesc)
550 {
551 	Rel_aux_cachebuf	*racp = NULL;
552 	size_t			size;
553 
554 	/*
555 	 * If there is space available in the present cache bucket, use it.
556 	 * Otherwise, allocate a new bucket.
557 	 */
558 	if (ofl->ofl_relaux) {
559 		racp = ofl->ofl_relaux->apl_data[
560 		    ofl->ofl_relaux->apl_nitems - 1];
561 
562 		if (racp && (racp->rac_free >= racp->rac_end))
563 			racp = NULL;
564 	}
565 	if (racp == NULL) {
566 		/*
567 		 * Compute the total number of bytes to allocate. The first
568 		 * element of the array is built into the Rel_aux_cachebuf
569 		 * header, so we subtract one from the number of elements.
570 		 */
571 		size = sizeof (Rel_aux_cachebuf) +
572 		    ((RELAUX_CACHEBUF_ALLOC - 1) * sizeof (Rel_aux));
573 		if (((racp = libld_malloc(size)) == NULL) ||
574 		    (aplist_append(&ofl->ofl_relaux, racp, AL_CNT_OFL_RELS) ==
575 		    NULL))
576 			return (FALSE);
577 
578 		racp->rac_free = racp->rac_arr;
579 		racp->rac_end = racp->rac_arr + RELAUX_CACHEBUF_ALLOC;
580 	}
581 
582 	/* Take an auxiliary descriptor from the cache and add it to rdesc */
583 	rdesc->rel_aux = racp->rac_free++;
584 
585 	return (TRUE);
586 }
587 
588 /*
589  * Enter a copy of the given Rel_desc relocation descriptor, and
590  * any associated auxiliary Rel_aux it may reference, into the
591  * specified relocation cache.
592  *
593  * entry:
594  *	ofl - Output file descriptor
595  *	rcp - Relocation descriptor cache to recieve relocation
596  *	rdesc - Rel_desc image to be inserted
597  *	flags - Flags to add to rdest->rel_flags in the inserted descriptor
598  *
599  * exit:
600  *	Returns the pointer to the inserted descriptor on success.
601  *	Returns NULL if an allocation error occurs.
602  */
603 Rel_desc *
ld_reloc_enter(Ofl_desc * ofl,Rel_cache * rcp,Rel_desc * rdesc,Word flags)604 ld_reloc_enter(Ofl_desc *ofl, Rel_cache *rcp, Rel_desc *rdesc, Word flags)
605 {
606 	Rel_desc	*arsp;
607 	Rel_aux		*auxp;
608 	Rel_cachebuf	*rcbp;
609 
610 
611 	/*
612 	 * If no relocation cache structures are available, allocate a new
613 	 * one and link it to the buffer list.
614 	 */
615 	rcbp = ld_add_rel_cache(ofl, rcp);
616 	if (rcbp == NULL)
617 		return (NULL);
618 	arsp = rcbp->rc_free;
619 
620 	/*
621 	 * If there is an auxiliary block on the original, allocate
622 	 * one for the clone. Save the pointer, because the struct copy
623 	 * below will crush it.
624 	 */
625 	if (rdesc->rel_aux != NULL) {
626 		if (!ld_add_rel_aux(ofl, arsp))
627 			return (NULL);
628 		auxp = arsp->rel_aux;
629 	}
630 
631 	/* Copy contents of the original into the clone */
632 	*arsp = *rdesc;
633 
634 	/*
635 	 * If there is an auxiliary block, restore the clone's pointer to
636 	 * it, and copy the auxiliary contents.
637 	 */
638 	if (rdesc->rel_aux != NULL) {
639 		arsp->rel_aux = auxp;
640 		*auxp = *rdesc->rel_aux;
641 	}
642 	arsp->rel_flags |= flags;
643 
644 	rcbp->rc_free++;
645 	rcp->rc_cnt++;
646 
647 	return (arsp);
648 }
649 
650 /*
651  * Initialize a relocation descriptor auxiliary block to default
652  * values.
653  *
654  * entry:
655  *	rdesc - Relocation descriptor, with a non-NULL rel_aux field
656  *		pointing at the auxiliary block to be initialized.
657  *
658  * exit:
659  *	Each field in rdesc->rel_aux has been set to its default value
660  */
661 static void
ld_init_rel_aux(Rel_desc * rdesc)662 ld_init_rel_aux(Rel_desc *rdesc)
663 {
664 	Rel_aux	*rap = rdesc->rel_aux;
665 
666 	/*
667 	 * The default output section is the one the input section
668 	 * is assigned to, assuming that there is an input section.
669 	 * Failing that, NULL is the only possibility, and we expect
670 	 * that the caller will assign an explicit value.
671 	 */
672 	rap->ra_osdesc = (rdesc->rel_isdesc == NULL) ? NULL :
673 	    rdesc->rel_isdesc->is_osdesc;
674 
675 	/* The ra_usym defaults to the value in rel_sym */
676 	rap->ra_usym = rdesc->rel_sym;
677 
678 	/* Remaining fields are zeroed */
679 	rap->ra_move = NULL;
680 	rap->ra_typedata = 0;
681 }
682 
683 /*
684  * The ld_reloc_set_aux_XXX() functions are used to set the value of an
685  * auxiliary relocation item on a relocation descriptor that exists in
686  * the active or output relocation cache. These descriptors are created
687  * via a call to ld_reloc_enter().
688  *
689  * These functions preserve the illusion that every relocation descriptor
690  * has a non-NULL auxiliary block into which values can be set, while
691  * only creating an auxiliary block if one is actually necessary, preventing
692  * the large memory allocations that would otherwise occur. They operate
693  * as follows:
694  *
695  * -	If an auxiliary block already exists, set the desired value and
696  *	and return TRUE.
697  *
698  * -	If no auxiliary block exists, but the desired value is the default
699  *	value for the specified item, then no auxiliary block is needed,
700  *	and TRUE is returned.
701  *
702  * -	If no auxiliary block exists, and the desired value is not the
703  *	default for the specified item, allocate an auxiliary block for
704  *	the descriptor, initialize its contents to default values for all
705  *	items, set the specified value, and return TRUE.
706  *
707  * -	If an auxiliary block needs to be added, but the allocation fails,
708  *	an error is issued, and FALSE is returned.
709  *
710  * Note that we only provide an ld_reloc_set_aux_XXX() function for those
711  * auxiliary items that libld actually modifies in Rel_desc descriptors
712  * in the active or output caches. If another one is needed, add it here.
713  *
714  * The PROCESS_NULL_REL_AUX macro is used to provide a single implementation
715  * for the logic that determines if an auxiliary block is needed or not,
716  * and handles the details of allocating and initializing it. It accepts
717  * one argument, _isdefault_predicate, which should be a call to the
718  * RELAUX_ISDEFAULT_xxx() macro appropriate for the auxiliary item
719  */
720 
721 #define	PROCESS_NULL_REL_AUX(_isdefault_predicate) \
722 	if (rdesc->rel_aux == NULL) { \
723 		/* If requested value is the default, no need for aux block */ \
724 		if (_isdefault_predicate) \
725 			return (TRUE); \
726 		/* Allocate and attach an auxiliary block */ \
727 		if (!ld_add_rel_aux(ofl, rdesc)) \
728 			return (FALSE); \
729 		/* Initialize the auxiliary block with default values */ \
730 		ld_init_rel_aux(rdesc); \
731 	}
732 
733 Boolean
ld_reloc_set_aux_osdesc(Ofl_desc * ofl,Rel_desc * rdesc,Os_desc * osp)734 ld_reloc_set_aux_osdesc(Ofl_desc *ofl, Rel_desc *rdesc, Os_desc *osp)
735 {
736 	PROCESS_NULL_REL_AUX(RELAUX_ISDEFAULT_OSDESC(rdesc, osp))
737 	rdesc->rel_aux->ra_osdesc = osp;
738 	return (TRUE);
739 }
740 
741 Boolean
ld_reloc_set_aux_usym(Ofl_desc * ofl,Rel_desc * rdesc,Sym_desc * sdp)742 ld_reloc_set_aux_usym(Ofl_desc *ofl, Rel_desc *rdesc, Sym_desc *sdp)
743 {
744 	PROCESS_NULL_REL_AUX(RELAUX_ISDEFAULT_USYM(rdesc, sdp))
745 	rdesc->rel_aux->ra_usym = sdp;
746 	return (TRUE);
747 }
748 
749 #undef PROCESS_NULL_REL_AUX
750 
751 /*
752  * Return a descriptive name for the symbol associated with the
753  * given relocation descriptor. This will be the actual symbol
754  * name if one exists, or a suitable alternative otherwise.
755  *
756  * entry:
757  *	rsp - Relocation descriptor
758  */
759 const char *
ld_reloc_sym_name(Rel_desc * rsp)760 ld_reloc_sym_name(Rel_desc *rsp)
761 {
762 	Sym_desc	*sdp = rsp->rel_sym;
763 
764 	if (sdp != NULL) {
765 		/* If the symbol has a valid name use it */
766 		if (sdp->sd_name && *sdp->sd_name)
767 			return (demangle(sdp->sd_name));
768 
769 		/*
770 		 * If the symbol is STT_SECTION, and the corresponding
771 		 * section symbol has the specially prepared string intended
772 		 * for this use, use that string. The string is of the form
773 		 *	secname (section)
774 		 */
775 		if ((ELF_ST_TYPE(sdp->sd_sym->st_info) == STT_SECTION) &&
776 		    (sdp->sd_isc != NULL) && (sdp->sd_isc->is_sym_name != NULL))
777 			return (demangle(sdp->sd_isc->is_sym_name));
778 	} else {
779 		/*
780 		 * Use an empty name for a register relocation with
781 		 * no symbol.
782 		 */
783 		if (IS_REGISTER(rsp->rel_rtype))
784 			return (MSG_ORIG(MSG_STR_EMPTY));
785 	}
786 
787 	/* If all else fails, report it as <unknown> */
788 	return (MSG_INTL(MSG_STR_UNKNOWN));
789 }
790 
791 /*
792  * Add an active relocation record.
793  */
794 uintptr_t
ld_add_actrel(Word flags,Rel_desc * rsp,Ofl_desc * ofl)795 ld_add_actrel(Word flags, Rel_desc *rsp, Ofl_desc *ofl)
796 {
797 	Rel_desc	*arsp;
798 
799 	if ((arsp = ld_reloc_enter(ofl, &ofl->ofl_actrels, rsp, flags)) == NULL)
800 		return (S_ERROR);
801 
802 	/*
803 	 * Any GOT relocation reference requires the creation of a .got table.
804 	 * Most references to a .got require a .got entry,  which is accounted
805 	 * for with the ofl_gotcnt counter.  However, some references are
806 	 * relative to the .got table, but require no .got entry.  This test
807 	 * insures a .got is created regardless of the type of reference.
808 	 */
809 	if (IS_GOT_REQUIRED(arsp->rel_rtype))
810 		ofl->ofl_flags |= FLG_OF_BLDGOT;
811 
812 	/*
813 	 * If this is a displacement relocation generate a warning.
814 	 */
815 	if (arsp->rel_flags & FLG_REL_DISP) {
816 		ofl->ofl_dtflags_1 |= DF_1_DISPRELDNE;
817 
818 		if (ofl->ofl_flags & FLG_OF_VERBOSE)
819 			ld_disp_errmsg(MSG_INTL(MSG_REL_DISPREL3), arsp, ofl);
820 	}
821 
822 	DBG_CALL(Dbg_reloc_ars_entry(ofl->ofl_lml, ELF_DBG_LD,
823 	    arsp->rel_isdesc->is_shdr->sh_type, ld_targ.t_m.m_mach, arsp));
824 	return (1);
825 }
826 
827 /*
828  * In the platform specific machrel.XXX.c files, we sometimes write
829  * a value directly into the got/plt. These function can be used when
830  * the running linker has the opposite byte order of the object being
831  * produced.
832  */
833 Word
ld_bswap_Word(Word v)834 ld_bswap_Word(Word v)
835 {
836 	return (BSWAP_WORD(v));
837 }
838 
839 
840 Xword
ld_bswap_Xword(Xword v)841 ld_bswap_Xword(Xword v)
842 {
843 	return (BSWAP_XWORD(v));
844 }
845 
846 
847 uintptr_t
ld_reloc_GOT_relative(Boolean local,Rel_desc * rsp,Ofl_desc * ofl)848 ld_reloc_GOT_relative(Boolean local, Rel_desc *rsp, Ofl_desc *ofl)
849 {
850 	Sym_desc	*sdp = rsp->rel_sym;
851 	ofl_flag_t	flags = ofl->ofl_flags;
852 	Gotndx		*gnp;
853 
854 	/*
855 	 * If this is the first time we've seen this symbol in a GOT
856 	 * relocation we need to assign it a GOT token.  Once we've got
857 	 * all of the GOT's assigned we can assign the actual indexes.
858 	 */
859 	if ((gnp = (*ld_targ.t_mr.mr_find_got_ndx)(sdp->sd_GOTndxs,
860 	    GOT_REF_GENERIC, ofl, rsp)) == 0) {
861 		Word	rtype = rsp->rel_rtype;
862 
863 		if ((*ld_targ.t_mr.mr_assign_got_ndx)(&(sdp->sd_GOTndxs), NULL,
864 		    GOT_REF_GENERIC, ofl, rsp, sdp) == S_ERROR)
865 			return (S_ERROR);
866 
867 		/*
868 		 * Initialize the GOT table entry.
869 		 *
870 		 * For global symbols, we clear the GOT table entry and create
871 		 * a GLOB_DAT relocation against the symbol.
872 		 *
873 		 * For local symbols, we enter the symbol value into a GOT
874 		 * table entry and create a relative relocation if all of
875 		 * the following hold:
876 		 *
877 		 * -	Output is a shared object
878 		 * -	Symbol is not ABS
879 		 * -	Relocation is not against one of the special sections
880 		 *	(COMMON, ...)
881 		 * -	This is not one of the generated symbols we have
882 		 *	to update after the output object has been fully
883 		 *	laid out (_START_, _END_, ...)
884 		 *
885 		 * Local symbols that don't meet the above requirements
886 		 * are processed as is.
887 		 */
888 		if (local == TRUE) {
889 			if ((flags & FLG_OF_SHAROBJ) &&
890 			    (((sdp->sd_flags & FLG_SY_SPECSEC) == 0) ||
891 			    ((sdp->sd_sym->st_shndx != SHN_ABS)) ||
892 			    (sdp->sd_aux && sdp->sd_aux->sa_symspec))) {
893 				if (ld_add_actrel((FLG_REL_GOT | FLG_REL_GOTCL),
894 				    rsp, ofl) == S_ERROR)
895 					return (S_ERROR);
896 
897 				rsp->rel_rtype = ld_targ.t_m.m_r_relative;
898 
899 				if ((*ld_targ.t_mr.mr_add_outrel)
900 				    ((FLG_REL_GOT | FLG_REL_ADVAL),
901 				    rsp, ofl) == S_ERROR)
902 					return (S_ERROR);
903 
904 				rsp->rel_rtype = rtype;
905 			} else {
906 				if (ld_add_actrel(FLG_REL_GOT, rsp,
907 				    ofl) == S_ERROR)
908 					return (S_ERROR);
909 			}
910 		} else {
911 			rsp->rel_rtype = ld_targ.t_m.m_r_glob_dat;
912 			if ((*ld_targ.t_mr.mr_add_outrel)(FLG_REL_GOT,
913 			    rsp, ofl) == S_ERROR)
914 				return (S_ERROR);
915 			rsp->rel_rtype = rtype;
916 		}
917 	} else {
918 		if ((*ld_targ.t_mr.mr_assign_got_ndx)(&(sdp->sd_GOTndxs), gnp,
919 		    GOT_REF_GENERIC, ofl, rsp, sdp) == S_ERROR)
920 			return (S_ERROR);
921 	}
922 
923 	/*
924 	 * Perform relocation to GOT table entry.
925 	 */
926 	return (ld_add_actrel(0, rsp, ofl));
927 }
928 
929 /*
930  * Perform relocations for PLT's
931  */
932 uintptr_t
ld_reloc_plt(Rel_desc * rsp,Ofl_desc * ofl)933 ld_reloc_plt(Rel_desc *rsp, Ofl_desc *ofl)
934 {
935 	Sym_desc	*sdp = rsp->rel_sym;
936 
937 	switch (ld_targ.t_m.m_mach) {
938 	case EM_AMD64:
939 		/*
940 		 * AMD64 TLS code sequences do not use a unique TLS
941 		 * relocation to reference the __tls_get_addr() function call.
942 		 */
943 		if ((ofl->ofl_flags & FLG_OF_EXEC) &&
944 		    (strcmp(sdp->sd_name, MSG_ORIG(MSG_SYM_TLSGETADDR_U)) ==
945 		    0))
946 			return (ld_add_actrel(FLG_REL_TLSFIX, rsp, ofl));
947 		break;
948 
949 	case EM_386:
950 		/*
951 		 * GNUC IA32 TLS code sequences do not use a unique TLS
952 		 * relocation to reference the ___tls_get_addr() function call.
953 		 */
954 		if ((ofl->ofl_flags & FLG_OF_EXEC) &&
955 		    (strcmp(sdp->sd_name, MSG_ORIG(MSG_SYM_TLSGETADDR_UU)) ==
956 		    0))
957 			return (ld_add_actrel(FLG_REL_TLSFIX, rsp, ofl));
958 		break;
959 	}
960 
961 	/*
962 	 * if (not PLT yet assigned)
963 	 * then
964 	 *	assign PLT index to symbol
965 	 *	build output JMP_SLOT relocation
966 	 * fi
967 	 */
968 	if (sdp->sd_aux->sa_PLTndx == 0) {
969 		Word	ortype = rsp->rel_rtype;
970 
971 		(*ld_targ.t_mr.mr_assign_plt_ndx)(sdp, ofl);
972 
973 		/*
974 		 * If this symbol is binding to a lazy loadable, or deferred
975 		 * dependency, then identify the symbol.
976 		 */
977 		if (sdp->sd_file) {
978 			if (sdp->sd_file->ifl_flags & FLG_IF_LAZYLD)
979 				sdp->sd_flags |= FLG_SY_LAZYLD;
980 			if (sdp->sd_file->ifl_flags & FLG_IF_DEFERRED)
981 				sdp->sd_flags |= FLG_SY_DEFERRED;
982 		}
983 
984 		rsp->rel_rtype = ld_targ.t_m.m_r_jmp_slot;
985 		if ((*ld_targ.t_mr.mr_add_outrel)(FLG_REL_PLT, rsp, ofl) ==
986 		    S_ERROR)
987 			return (S_ERROR);
988 		rsp->rel_rtype = ortype;
989 	}
990 
991 	/*
992 	 * Perform relocation to PLT table entry.
993 	 */
994 	if ((ofl->ofl_flags & FLG_OF_SHAROBJ) &&
995 	    IS_ADD_RELATIVE(rsp->rel_rtype)) {
996 		Word	ortype	= rsp->rel_rtype;
997 
998 		rsp->rel_rtype = ld_targ.t_m.m_r_relative;
999 		if ((*ld_targ.t_mr.mr_add_outrel)(FLG_REL_ADVAL, rsp, ofl) ==
1000 		    S_ERROR)
1001 			return (S_ERROR);
1002 		rsp->rel_rtype = ortype;
1003 		return (1);
1004 	} else
1005 		return (ld_add_actrel(0, rsp, ofl));
1006 }
1007 
1008 /*
1009  * Round up to the next power of 2.  Used to ensure section alignments that can
1010  * be used for copy relocation symbol alignments are sane values.
1011  */
1012 static Word
nlpo2(Word val)1013 nlpo2(Word val)
1014 {
1015 	val--;
1016 	val |= (val >> 1);
1017 	val |= (val >> 2);
1018 	val |= (val >> 4);
1019 	val |= (val >> 8);
1020 	val |= (val >> 16);
1021 	return (++val);
1022 }
1023 
1024 /*
1025  * process GLOBAL undefined and ref_dyn_need symbols.
1026  */
1027 static uintptr_t
reloc_exec(Rel_desc * rsp,Ofl_desc * ofl)1028 reloc_exec(Rel_desc *rsp, Ofl_desc *ofl)
1029 {
1030 	Sym_desc	*_sdp, *sdp = rsp->rel_sym;
1031 	Sym_aux		*sap = sdp->sd_aux;
1032 	Sym		*sym = sdp->sd_sym;
1033 	Addr		stval;
1034 
1035 	/*
1036 	 * Reference is to a function so simply create a plt entry for it.
1037 	 */
1038 	if (ELF_ST_TYPE(sym->st_info) == STT_FUNC)
1039 		return (ld_reloc_plt(rsp, ofl));
1040 
1041 	/*
1042 	 * Catch absolutes - these may cause a text relocation.
1043 	 */
1044 	if ((sdp->sd_flags & FLG_SY_SPECSEC) && (sym->st_shndx == SHN_ABS)) {
1045 		if ((ofl->ofl_flags1 & FLG_OF1_ABSEXEC) == 0)
1046 			return ((*ld_targ.t_mr.mr_add_outrel)(0, rsp, ofl));
1047 
1048 		/*
1049 		 * If -zabsexec is set then promote the ABSOLUTE symbol to
1050 		 * current the current object and perform the relocation now.
1051 		 */
1052 		sdp->sd_ref = REF_REL_NEED;
1053 		return (ld_add_actrel(0, rsp, ofl));
1054 	}
1055 
1056 	/*
1057 	 * If the relocation is against a writable section simply compute the
1058 	 * necessary output relocation.  As an optimization, if the symbol has
1059 	 * already been transformed into a copy relocation then we can perform
1060 	 * the relocation directly (copy relocations should only be generated
1061 	 * for references from the text segment and these relocations are
1062 	 * normally carried out before we get to the data segment relocations).
1063 	 */
1064 	if ((ELF_ST_TYPE(sym->st_info) == STT_OBJECT) &&
1065 	    (RELAUX_GET_OSDESC(rsp)->os_shdr->sh_flags & SHF_WRITE)) {
1066 		if (sdp->sd_flags & FLG_SY_MVTOCOMM)
1067 			return (ld_add_actrel(0, rsp, ofl));
1068 		else
1069 			return ((*ld_targ.t_mr.mr_add_outrel)(0, rsp, ofl));
1070 	}
1071 
1072 	/*
1073 	 * If the reference isn't to an object (normally because a .type
1074 	 * directive wasn't defined in some assembler source), then apply
1075 	 * a generic relocation (this has a tendency to result in text
1076 	 * relocations).
1077 	 */
1078 	if (ELF_ST_TYPE(sym->st_info) != STT_OBJECT) {
1079 		Conv_inv_buf_t inv_buf;
1080 
1081 		ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_REL_UNEXPSYM),
1082 		    conv_sym_info_type(sdp->sd_file->ifl_ehdr->e_machine,
1083 		    ELF_ST_TYPE(sym->st_info), 0, &inv_buf),
1084 		    rsp->rel_isdesc->is_file->ifl_name,
1085 		    ld_reloc_sym_name(rsp), sdp->sd_file->ifl_name);
1086 		return ((*ld_targ.t_mr.mr_add_outrel)(0, rsp, ofl));
1087 	}
1088 
1089 	/*
1090 	 * Prepare for generating a copy relocation.
1091 	 *
1092 	 * If this symbol is one of an alias pair, we need to ensure both
1093 	 * symbols become part of the output (the strong symbol will be used to
1094 	 * maintain the symbols state).  And, if we did raise the precedence of
1095 	 * a symbol we need to check and see if this is a weak symbol.  If it is
1096 	 * we want to use it's strong counter part.
1097 	 *
1098 	 * The results of this logic should be:
1099 	 *	ra_usym: assigned to strong
1100 	 *	rel_sym: assigned to symbol to perform
1101 	 *		copy_reloc against (weak or strong).
1102 	 */
1103 	if (sap->sa_linkndx) {
1104 		_sdp = sdp->sd_file->ifl_oldndx[sap->sa_linkndx];
1105 
1106 		if (_sdp->sd_ref < sdp->sd_ref) {
1107 			_sdp->sd_ref = sdp->sd_ref;
1108 			_sdp->sd_flags |= FLG_SY_REFRSD;
1109 
1110 			/*
1111 			 * As we're going to replicate a symbol from a shared
1112 			 * object, retain its correct binding status.
1113 			 */
1114 			if (ELF_ST_BIND(_sdp->sd_sym->st_info) == STB_GLOBAL)
1115 				_sdp->sd_flags |= FLG_SY_GLOBREF;
1116 
1117 		} else if (_sdp->sd_ref > sdp->sd_ref) {
1118 			sdp->sd_ref = _sdp->sd_ref;
1119 			sdp->sd_flags |= FLG_SY_REFRSD;
1120 
1121 			/*
1122 			 * As we're going to replicate a symbol from a shared
1123 			 * object, retain its correct binding status.
1124 			 */
1125 			if (ELF_ST_BIND(sym->st_info) == STB_GLOBAL)
1126 				sdp->sd_flags |= FLG_SY_GLOBREF;
1127 		}
1128 
1129 		/*
1130 		 * If this is a weak symbol then we want to move the strong
1131 		 * symbol into local .bss.  If there is a copy_reloc to be
1132 		 * performed, that should still occur against the WEAK symbol.
1133 		 */
1134 		if (((ELF_ST_BIND(sdp->sd_sym->st_info) == STB_WEAK) ||
1135 		    (sdp->sd_flags & FLG_SY_WEAKDEF)) &&
1136 		    !ld_reloc_set_aux_usym(ofl, rsp, _sdp))
1137 			return (S_ERROR);
1138 	} else
1139 		_sdp = 0;
1140 
1141 	/*
1142 	 * If the reference is to an object then allocate space for the object
1143 	 * within the executables .bss.  Relocations will now be performed from
1144 	 * this new location.  If the original shared objects data is
1145 	 * initialized, then generate a copy relocation that will copy the data
1146 	 * to the executables .bss at runtime.
1147 	 */
1148 	if (!(RELAUX_GET_USYM(rsp)->sd_flags & FLG_SY_MVTOCOMM)) {
1149 		Word		rtype = rsp->rel_rtype, w2align;
1150 		Copy_rel	cr;
1151 
1152 		/*
1153 		 * Diagnose the original copy reference, as this symbol
1154 		 * information will be overridden with the new destination.
1155 		 */
1156 		DBG_CALL(Dbg_syms_copy_reloc(ofl, sdp, 0));
1157 
1158 		/*
1159 		 * Indicate that the symbol(s) against which we're relocating
1160 		 * have been moved to the executables common.  Also, insure that
1161 		 * the symbol(s) remain marked as global, as the shared object
1162 		 * from which they are copied must be able to relocate to the
1163 		 * new common location within the executable.
1164 		 *
1165 		 * Note that even though a new symbol has been generated in the
1166 		 * output files' .bss, the symbol must remain REF_DYN_NEED and
1167 		 * not be promoted to REF_REL_NEED.  sym_validate() still needs
1168 		 * to carry out a number of checks against the symbols binding
1169 		 * that are triggered by the REF_DYN_NEED state.
1170 		 */
1171 		sdp->sd_flags |=
1172 		    (FLG_SY_MVTOCOMM | FLG_SY_DEFAULT | FLG_SY_EXPDEF);
1173 		sdp->sd_flags &= ~MSK_SY_LOCAL;
1174 		sdp->sd_sym->st_other &= ~MSK_SYM_VISIBILITY;
1175 		if (_sdp) {
1176 			_sdp->sd_flags |= (FLG_SY_MVTOCOMM |
1177 			    FLG_SY_DEFAULT | FLG_SY_EXPDEF);
1178 			_sdp->sd_flags &= ~MSK_SY_LOCAL;
1179 			_sdp->sd_sym->st_other &= ~MSK_SYM_VISIBILITY;
1180 
1181 			/*
1182 			 * Make sure the symbol has a reference in case of any
1183 			 * error diagnostics against it (perhaps this belongs
1184 			 * to a version that isn't allowable for this build).
1185 			 * The resulting diagnostic (see sym_undef_entry())
1186 			 * might seem a little bogus, as the symbol hasn't
1187 			 * really been referenced by this file, but has been
1188 			 * promoted as a consequence of its alias reference.
1189 			 */
1190 			if (!(_sdp->sd_aux->sa_rfile))
1191 				_sdp->sd_aux->sa_rfile = sdp->sd_aux->sa_rfile;
1192 		}
1193 
1194 		/*
1195 		 * Assign the symbol to the bss.
1196 		 */
1197 		_sdp = RELAUX_GET_USYM(rsp);
1198 		stval = _sdp->sd_sym->st_value;
1199 		if (ld_sym_copy(_sdp) == S_ERROR)
1200 			return (S_ERROR);
1201 		_sdp->sd_shndx = _sdp->sd_sym->st_shndx = SHN_COMMON;
1202 		_sdp->sd_flags |= FLG_SY_SPECSEC;
1203 
1204 		/*
1205 		 * Ensure the symbol has sufficient alignment.  The symbol
1206 		 * definition has no alignment information that can be used,
1207 		 * hence we use a heuristic.  Historically, twice the native
1208 		 * word alignment was sufficient for any data type, however,
1209 		 * the developer may have requested larger alignments (pragma
1210 		 * align).  The most conservative approach is to use a power
1211 		 * of two alignment, determined from the alignment of the
1212 		 * section containing the symbol definition.  Note that this
1213 		 * can result in some bloat to the .bss as the not every item
1214 		 * of copied data might need the section alignment.
1215 		 *
1216 		 * COMMON symbols carry their alignment requirements in the
1217 		 * symbols st_value field.  This alignment is applied to the
1218 		 * symbol when it is eventually transformed into .bss.
1219 		 */
1220 		w2align = ld_targ.t_m.m_word_align * 2;
1221 		if (_sdp->sd_sym->st_size < w2align)
1222 			_sdp->sd_sym->st_value = ld_targ.t_m.m_word_align;
1223 		else {
1224 			Shdr	*shdr;
1225 			Word	isalign;
1226 
1227 			if (_sdp->sd_isc &&
1228 			    ((shdr = _sdp->sd_isc->is_shdr) != NULL) &&
1229 			    ((isalign = shdr->sh_addralign) != 0))
1230 				_sdp->sd_sym->st_value = nlpo2(isalign);
1231 			else
1232 				_sdp->sd_sym->st_value = w2align;
1233 		}
1234 
1235 		/*
1236 		 * Whether or not the symbol references initialized data we
1237 		 * generate a copy relocation - this differs from the past
1238 		 * where we would not create the COPY_RELOC if we were binding
1239 		 * against .bss.  This is done for *two* reasons.
1240 		 *
1241 		 *  -	If the symbol in the shared object changes to a
1242 		 *	initialized data - we need the COPY to pick it up.
1243 		 *  -	Without the COPY RELOC we can't tell that the symbol
1244 		 *	from the COPY'd object has been moved and all bindings
1245 		 *	to it should bind here.
1246 		 *
1247 		 * Keep this symbol in the copy relocation list to check the
1248 		 * validity later.
1249 		 */
1250 		cr.c_sdp = _sdp;
1251 		cr.c_val = stval;
1252 		if (alist_append(&ofl->ofl_copyrels, &cr, sizeof (Copy_rel),
1253 		    AL_CNT_OFL_COPYRELS) == NULL)
1254 			return (S_ERROR);
1255 
1256 		rsp->rel_rtype = ld_targ.t_m.m_r_copy;
1257 		if ((*ld_targ.t_mr.mr_add_outrel)(FLG_REL_BSS, rsp, ofl) ==
1258 		    S_ERROR)
1259 			return (S_ERROR);
1260 		rsp->rel_rtype = rtype;
1261 
1262 		/*
1263 		 * If this symbol is a protected symbol, warn the user.  A
1264 		 * potential issue exists as the copy relocated symbol within
1265 		 * the executable can be visible to others, whereas the shared
1266 		 * object that defined the original copy data symbol is pre-
1267 		 * bound to reference it's own definition.  Any modification
1268 		 * of the symbols data could lead to inconsistencies for the
1269 		 * various users.
1270 		 */
1271 		if (_sdp->sd_flags & FLG_SY_PROT) {
1272 			Conv_inv_buf_t inv_buf;
1273 
1274 			ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_REL_COPY),
1275 			    conv_reloc_type(_sdp->sd_file->ifl_ehdr->e_machine,
1276 			    ld_targ.t_m.m_r_copy, 0, &inv_buf),
1277 			    _sdp->sd_file->ifl_name, _sdp->sd_name);
1278 		}
1279 		DBG_CALL(Dbg_syms_copy_reloc(ofl, _sdp,
1280 		    _sdp->sd_sym->st_value));
1281 	}
1282 	return (ld_add_actrel(0, rsp, ofl));
1283 }
1284 
1285 /*
1286  * All relocations should have been handled by the other routines.  This
1287  * routine is here as a catch all, if we do enter it we've goofed - but
1288  * we'll try and do the best we can.
1289  */
1290 static uintptr_t
reloc_generic(Rel_desc * rsp,Ofl_desc * ofl)1291 reloc_generic(Rel_desc *rsp, Ofl_desc *ofl)
1292 {
1293 	Ifl_desc	*ifl = rsp->rel_isdesc->is_file;
1294 	Conv_inv_buf_t	inv_buf;
1295 
1296 	ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_REL_UNEXPREL),
1297 	    conv_reloc_type(ifl->ifl_ehdr->e_machine, rsp->rel_rtype,
1298 	    0, &inv_buf), ifl->ifl_name, ld_reloc_sym_name(rsp));
1299 
1300 	/*
1301 	 * If building a shared object then put the relocation off
1302 	 * until runtime.
1303 	 */
1304 	if (ofl->ofl_flags & FLG_OF_SHAROBJ)
1305 		return ((*ld_targ.t_mr.mr_add_outrel)(0, rsp, ofl));
1306 
1307 	/*
1308 	 * Otherwise process relocation now.
1309 	 */
1310 	return (ld_add_actrel(0, rsp, ofl));
1311 }
1312 
1313 /*
1314  * Process relocations when building a relocatable object.  Typically, there
1315  * aren't many relocations that can be caught at this point, most are simply
1316  * passed through to the output relocatable object.
1317  */
1318 static uintptr_t
reloc_relobj(Boolean local,Rel_desc * rsp,Ofl_desc * ofl)1319 reloc_relobj(Boolean local, Rel_desc *rsp, Ofl_desc *ofl)
1320 {
1321 	Word		rtype = rsp->rel_rtype;
1322 	Sym_desc	*sdp = rsp->rel_sym;
1323 	Is_desc		*isp = rsp->rel_isdesc;
1324 	Word		oflags = 0;
1325 
1326 	/*
1327 	 * Determine if we can do any relocations at this point.  We can if:
1328 	 *
1329 	 *	this is local_symbol and a non-GOT relocation, and
1330 	 *	the relocation is pc-relative, and
1331 	 *	the relocation is against a symbol in same section
1332 	 */
1333 	if (local && !IS_GOT_RELATIVE(rtype) &&
1334 	    !IS_GOT_BASED(rtype) && !IS_GOT_PC(rtype) &&
1335 	    IS_PC_RELATIVE(rtype) &&
1336 	    ((sdp->sd_isc) && (sdp->sd_isc->is_osdesc == isp->is_osdesc)))
1337 		return (ld_add_actrel(0, rsp, ofl));
1338 
1339 	/*
1340 	 * If -zredlocsym is in effect, translate all local symbol relocations
1341 	 * to be against section symbols, since section symbols are the only
1342 	 * local symbols which will be added to the .symtab.
1343 	 */
1344 	if (local && (((ofl->ofl_flags & FLG_OF_REDLSYM) &&
1345 	    (ELF_ST_BIND(sdp->sd_sym->st_info) == STB_LOCAL)) ||
1346 	    ((sdp->sd_flags & FLG_SY_ELIM) &&
1347 	    (ofl->ofl_flags & FLG_OF_PROCRED)))) {
1348 		/*
1349 		 * But if this is PIC code, don't allow it for now.
1350 		 */
1351 		if (IS_GOT_RELATIVE(rsp->rel_rtype)) {
1352 			Ifl_desc	*ifl = rsp->rel_isdesc->is_file;
1353 			Conv_inv_buf_t inv_buf;
1354 
1355 			ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_REL_PICREDLOC),
1356 			    ld_reloc_sym_name(rsp), ifl->ifl_name,
1357 			    conv_reloc_type(ifl->ifl_ehdr->e_machine,
1358 			    rsp->rel_rtype, 0, &inv_buf));
1359 			return (S_ERROR);
1360 		}
1361 
1362 		/*
1363 		 * Indicate that this relocation should be processed the same
1364 		 * as a section symbol.  For RELA, indicate that the addend
1365 		 * also needs to be applied to this relocation.
1366 		 */
1367 		if ((rsp->rel_flags & FLG_REL_RELA) == FLG_REL_RELA)
1368 			oflags = FLG_REL_SCNNDX | FLG_REL_ADVAL;
1369 		else
1370 			oflags = FLG_REL_SCNNDX;
1371 	}
1372 
1373 	if ((rsp->rel_flags & FLG_REL_RELA) == 0) {
1374 		/*
1375 		 * Intel (Rel) relocations do not contain an addend.  Any
1376 		 * addend is contained within the file at the location
1377 		 * identified by the relocation offset.  Therefore, if we're
1378 		 * processing a section symbol, or a -zredlocsym relocation
1379 		 * (that basically transforms a local symbol reference into
1380 		 * a section reference), perform an active relocation to
1381 		 * propagate any addend.
1382 		 */
1383 		if ((ELF_ST_TYPE(sdp->sd_sym->st_info) == STT_SECTION) ||
1384 		    (oflags == FLG_REL_SCNNDX))
1385 			if (ld_add_actrel(0, rsp, ofl) == S_ERROR)
1386 				return (S_ERROR);
1387 	}
1388 	return ((*ld_targ.t_mr.mr_add_outrel)(oflags, rsp, ofl));
1389 }
1390 
1391 /*
1392  * Perform any generic TLS validations before passing control to machine
1393  * specific routines.  At this point we know we are dealing with an executable
1394  * or shared object - relocatable objects have already been processed.
1395  */
1396 static uintptr_t
reloc_TLS(Boolean local,Rel_desc * rsp,Ofl_desc * ofl)1397 reloc_TLS(Boolean local, Rel_desc *rsp, Ofl_desc *ofl)
1398 {
1399 	Word		rtype = rsp->rel_rtype;
1400 	ofl_flag_t	flags = ofl->ofl_flags;
1401 	Ifl_desc	*ifl = rsp->rel_isdesc->is_file;
1402 	Half		mach = ifl->ifl_ehdr->e_machine;
1403 	Sym_desc	*sdp = rsp->rel_sym;
1404 	unsigned char	type;
1405 	Conv_inv_buf_t	inv_buf1, inv_buf2;
1406 
1407 	/*
1408 	 * All TLS relocations are illegal in a static executable.
1409 	 */
1410 	if (OFL_IS_STATIC_EXEC(ofl)) {
1411 		ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_REL_TLSSTAT),
1412 		    conv_reloc_type(mach, rtype, 0, &inv_buf1), ifl->ifl_name,
1413 		    ld_reloc_sym_name(rsp));
1414 		return (S_ERROR);
1415 	}
1416 
1417 	/*
1418 	 * Any TLS relocation must be against a STT_TLS symbol, all others
1419 	 * are illegal.
1420 	 */
1421 	if ((type = ELF_ST_TYPE(sdp->sd_sym->st_info)) != STT_TLS) {
1422 		ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_REL_TLSBADSYM),
1423 		    conv_reloc_type(mach, rtype, 0, &inv_buf1), ifl->ifl_name,
1424 		    ld_reloc_sym_name(rsp),
1425 		    conv_sym_info_type(mach, type, 0, &inv_buf2));
1426 		return (S_ERROR);
1427 	}
1428 
1429 	/*
1430 	 * A dynamic executable can not use the LD or LE reference models to
1431 	 * reference an external symbol.  A shared object can not use the LD
1432 	 * reference model to reference an external symbol.
1433 	 */
1434 	if (!local && (IS_TLS_LD(rtype) ||
1435 	    ((flags & FLG_OF_EXEC) && IS_TLS_LE(rtype)))) {
1436 		ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_REL_TLSBND),
1437 		    conv_reloc_type(mach, rtype, 0, &inv_buf1), ifl->ifl_name,
1438 		    ld_reloc_sym_name(rsp), sdp->sd_file->ifl_name);
1439 		return (S_ERROR);
1440 	}
1441 
1442 	/*
1443 	 * The TLS LE model is only allowed for dynamic executables.  The TLS IE
1444 	 * model is allowed for shared objects, but this model has restrictions.
1445 	 * This model can only be used freely in dependencies that are loaded
1446 	 * immediately as part of process initialization.  However, during the
1447 	 * initial runtime handshake with libc that establishes the thread
1448 	 * pointer, a small backup TLS reservation is created.  This area can
1449 	 * be used by objects that are loaded after threads are initialized.
1450 	 * However, this area is limited in size and may have already been
1451 	 * used.  This area is intended for specialized applications, and does
1452 	 * not provide the degree of flexibility dynamic TLS can offer.  Under
1453 	 * -z verbose indicate this restriction to the user.
1454 	 */
1455 	if ((flags & FLG_OF_EXEC) == 0) {
1456 		if (IS_TLS_LE(rtype)) {
1457 			ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_REL_TLSLE),
1458 			    conv_reloc_type(mach, rtype, 0, &inv_buf1),
1459 			    ifl->ifl_name, ld_reloc_sym_name(rsp));
1460 			return (S_ERROR);
1461 
1462 		} else if ((IS_TLS_IE(rtype)) &&
1463 		    (flags & FLG_OF_VERBOSE)) {
1464 			ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_REL_TLSIE),
1465 			    conv_reloc_type(mach, rtype, 0, &inv_buf1),
1466 			    ifl->ifl_name, ld_reloc_sym_name(rsp));
1467 		}
1468 	}
1469 
1470 	return ((*ld_targ.t_mr.mr_reloc_TLS)(local, rsp, ofl));
1471 }
1472 
1473 uintptr_t
ld_process_sym_reloc(Ofl_desc * ofl,Rel_desc * reld,Rel * reloc,Is_desc * isp,const char * isname,Word isscnndx)1474 ld_process_sym_reloc(Ofl_desc *ofl, Rel_desc *reld, Rel *reloc, Is_desc *isp,
1475     const char *isname, Word isscnndx)
1476 {
1477 	Word		rtype = reld->rel_rtype;
1478 	ofl_flag_t	flags = ofl->ofl_flags;
1479 	Sym_desc	*sdp = reld->rel_sym;
1480 	Sym_aux		*sap;
1481 	Boolean		local;
1482 	Conv_inv_buf_t	inv_buf;
1483 
1484 	DBG_CALL(Dbg_reloc_in(ofl->ofl_lml, ELF_DBG_LD, ld_targ.t_m.m_mach,
1485 	    ld_targ.t_m.m_rel_sht_type, (void *)reloc, isname, isscnndx,
1486 	    ld_reloc_sym_name(reld)));
1487 
1488 	/*
1489 	 * Indicate this symbol is being used for relocation and therefore must
1490 	 * have its output address updated accordingly (refer to update_osym()).
1491 	 */
1492 	sdp->sd_flags |= FLG_SY_UPREQD;
1493 
1494 	/*
1495 	 * Indicate the section this symbol is defined in has been referenced,
1496 	 * therefor it *is not* a candidate for elimination.
1497 	 */
1498 	if (sdp->sd_isc) {
1499 		sdp->sd_isc->is_flags |= FLG_IS_SECTREF;
1500 		sdp->sd_isc->is_file->ifl_flags |= FLG_IF_FILEREF;
1501 	}
1502 
1503 	if (!ld_reloc_set_aux_usym(ofl, reld, sdp))
1504 		return (S_ERROR);
1505 
1506 	/*
1507 	 * Determine if this symbol is actually an alias to another symbol.  If
1508 	 * so, and the alias is not REF_DYN_SEEN, set ra_usym to point to the
1509 	 * weak symbols strong counter-part.  The one exception is if the
1510 	 * FLG_SY_MVTOCOMM flag is set on the weak symbol.  If this is the case,
1511 	 * the strong is only here because of its promotion, and the weak symbol
1512 	 * should still be used for the relocation reference (see reloc_exec()).
1513 	 */
1514 	sap = sdp->sd_aux;
1515 	if (sap && sap->sa_linkndx &&
1516 	    ((ELF_ST_BIND(sdp->sd_sym->st_info) == STB_WEAK) ||
1517 	    (sdp->sd_flags & FLG_SY_WEAKDEF)) &&
1518 	    (!(sdp->sd_flags & FLG_SY_MVTOCOMM))) {
1519 		Sym_desc	*_sdp;
1520 
1521 		_sdp = sdp->sd_file->ifl_oldndx[sap->sa_linkndx];
1522 		if ((_sdp->sd_ref != REF_DYN_SEEN) &&
1523 		    !ld_reloc_set_aux_usym(ofl, reld, _sdp))
1524 			return (S_ERROR);
1525 	}
1526 
1527 	/*
1528 	 * Determine whether this symbol should be bound locally or not.
1529 	 * Symbols are bound locally if one of the following is true:
1530 	 *
1531 	 *  -	the symbol is of type STB_LOCAL.
1532 	 *
1533 	 *  -	the output image is not a relocatable object and the relocation
1534 	 *	is relative to the .got.
1535 	 *
1536 	 *  -	the section being relocated is of type SHT_SUNW_dof.  These
1537 	 *	sections must be bound to the functions in the containing
1538 	 *	object and can not be interposed upon.
1539 	 *
1540 	 *  -	the symbol has been reduced (scoped to a local or symbolic) and
1541 	 *	reductions are being processed.
1542 	 *
1543 	 *  -	the -Bsymbolic flag is in use when building a shared object,
1544 	 *	and the symbol hasn't explicitly been defined as nodirect.
1545 	 *
1546 	 *  -	an executable (fixed address) is being created, and the symbol
1547 	 *	is defined in the executable.
1548 	 *
1549 	 *  -	the relocation is against a segment which will not be loaded
1550 	 *	into memory.  In this case, the relocation must be resolved
1551 	 *	now, as ld.so.1 can not process relocations against unmapped
1552 	 *	segments.
1553 	 */
1554 	local = FALSE;
1555 	if (ELF_ST_BIND(sdp->sd_sym->st_info) == STB_LOCAL) {
1556 		local = TRUE;
1557 	} else if (!(reld->rel_flags & FLG_REL_LOAD)) {
1558 		local = TRUE;
1559 	} else if (sdp->sd_sym->st_shndx != SHN_UNDEF) {
1560 		if (reld->rel_isdesc &&
1561 		    reld->rel_isdesc->is_shdr->sh_type == SHT_SUNW_dof) {
1562 			local = TRUE;
1563 		} else if (!(flags & FLG_OF_RELOBJ) &&
1564 		    (IS_LOCALBND(rtype) || IS_SEG_RELATIVE(rtype))) {
1565 			local = TRUE;
1566 		} else if ((sdp->sd_ref == REF_REL_NEED) &&
1567 		    ((sdp->sd_flags & FLG_SY_CAP) == 0)) {
1568 			/*
1569 			 * Global symbols may have been individually reduced in
1570 			 * scope.  If the whole object is to be self contained,
1571 			 * such as when generating an executable or a symbolic
1572 			 * shared object, make sure all relocation symbol
1573 			 * references (sections too) are treated locally.  Note,
1574 			 * explicit no-direct symbols should not be bound to
1575 			 * locally.
1576 			 */
1577 			if ((sdp->sd_flags &
1578 			    (FLG_SY_HIDDEN | FLG_SY_PROTECT)))
1579 				local = TRUE;
1580 			else if ((flags & FLG_OF_EXEC) ||
1581 			    ((flags & FLG_OF_SYMBOLIC) &&
1582 			    ((sdp->sd_flags & FLG_SY_NDIR) == 0))) {
1583 				local = TRUE;
1584 			}
1585 		}
1586 	}
1587 
1588 	/*
1589 	 * If this is a PC_RELATIVE relocation, the relocation could be
1590 	 * compromised if the relocated address is later used as a copy
1591 	 * relocated symbol (PSARC 1999/636, bugid 4187211).  Scan the input
1592 	 * files symbol table to cross reference this relocation offset.
1593 	 */
1594 	if ((ofl->ofl_flags & FLG_OF_SHAROBJ) &&
1595 	    IS_PC_RELATIVE(rtype) &&
1596 	    (IS_GOT_PC(rtype) == 0) &&
1597 	    (IS_PLT(rtype) == 0)) {
1598 		if (disp_inspect(ofl, reld, local) == S_ERROR)
1599 			return (S_ERROR);
1600 	}
1601 
1602 	/*
1603 	 * GOT based relocations must bind to the object being built - since
1604 	 * they are relevant to the current GOT.  If not building a relocatable
1605 	 * object - give a appropriate error message.
1606 	 */
1607 	if (!local && !(flags & FLG_OF_RELOBJ) &&
1608 	    IS_GOT_BASED(rtype)) {
1609 		Ifl_desc	*ifl = reld->rel_isdesc->is_file;
1610 
1611 		ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_REL_BADGOTBASED),
1612 		    conv_reloc_type(ifl->ifl_ehdr->e_machine, rtype,
1613 		    0, &inv_buf), ifl->ifl_name, demangle(sdp->sd_name));
1614 		return (S_ERROR);
1615 	}
1616 
1617 	/*
1618 	 * TLS symbols can only have TLS relocations.
1619 	 */
1620 	if ((ELF_ST_TYPE(sdp->sd_sym->st_info) == STT_TLS) &&
1621 	    (IS_TLS_INS(rtype) == 0)) {
1622 		/*
1623 		 * The above test is relaxed if the target section is
1624 		 * non-allocable.
1625 		 */
1626 		if (RELAUX_GET_OSDESC(reld)->os_shdr->sh_flags & SHF_ALLOC) {
1627 			Ifl_desc	*ifl = reld->rel_isdesc->is_file;
1628 
1629 			ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_REL_BADTLS),
1630 			    conv_reloc_type(ifl->ifl_ehdr->e_machine,
1631 			    rtype, 0, &inv_buf), ifl->ifl_name,
1632 			    demangle(sdp->sd_name));
1633 			return (S_ERROR);
1634 		}
1635 	}
1636 
1637 	/*
1638 	 * Select the relocation to perform.
1639 	 */
1640 	if (IS_REGISTER(rtype)) {
1641 		if (ld_targ.t_mr.mr_reloc_register == NULL) {
1642 			ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_REL_NOREG));
1643 			return (S_ERROR);
1644 		}
1645 		return ((*ld_targ.t_mr.mr_reloc_register)(reld, isp, ofl));
1646 	}
1647 
1648 	if (flags & FLG_OF_RELOBJ)
1649 		return (reloc_relobj(local, reld, ofl));
1650 
1651 	if (IS_TLS_INS(rtype))
1652 		return (reloc_TLS(local, reld, ofl));
1653 
1654 	if (IS_GOT_OPINS(rtype)) {
1655 		if (ld_targ.t_mr.mr_reloc_GOTOP == NULL) {
1656 			assert(0);
1657 			return (S_ERROR);
1658 		}
1659 		return ((*ld_targ.t_mr.mr_reloc_GOTOP)(local, reld, ofl));
1660 	}
1661 
1662 	if (IS_GOT_RELATIVE(rtype))
1663 		return (ld_reloc_GOT_relative(local, reld, ofl));
1664 
1665 	if (local)
1666 		return ((*ld_targ.t_mr.mr_reloc_local)(reld, ofl));
1667 
1668 	if ((IS_PLT(rtype) || ((sdp->sd_flags & FLG_SY_CAP) &&
1669 	    (ELF_ST_TYPE(sdp->sd_sym->st_info) == STT_FUNC))) &&
1670 	    ((flags & FLG_OF_BFLAG) == 0))
1671 		return (ld_reloc_plt(reld, ofl));
1672 
1673 	if ((sdp->sd_ref == REF_REL_NEED) ||
1674 	    (flags & FLG_OF_BFLAG) || (flags & FLG_OF_SHAROBJ) ||
1675 	    (ELF_ST_TYPE(sdp->sd_sym->st_info) == STT_NOTYPE))
1676 		return ((*ld_targ.t_mr.mr_add_outrel)(0, reld, ofl));
1677 
1678 	if (sdp->sd_ref == REF_DYN_NEED)
1679 		return (reloc_exec(reld, ofl));
1680 
1681 	/*
1682 	 * IS_NOT_REL(rtype)
1683 	 */
1684 	return (reloc_generic(reld, ofl));
1685 }
1686 
1687 /*
1688  * Given a relocation that references a local symbol from a discarded COMDAT
1689  * section, replace the symbol with the corresponding symbol from the section
1690  * that was kept.
1691  *
1692  * entry:
1693  *	reld - Relocation
1694  *	sdp - Symbol to be replaced. Must be a local symbol (STB_LOCAL).
1695  *	reject - Address of variable to receive rejection code
1696  *		if no replacement symbol is found.
1697  *
1698  * exit:
1699  *	Returns address of replacement symbol descriptor if one was
1700  *	found, and NULL otherwise. The result is also cached in
1701  *	ofl->ofl_sr_cache as an optimization to speed following calls
1702  *	for the same value of sdp.
1703  *
1704  *	On success (non-NULL result), *reject is set to RLXREL_REJ_NONE.
1705  *	On failure (NULL result), *reject is filled in with a code
1706  *	describing the underlying reason.
1707  *
1708  * note:
1709  *	The word "COMDAT" is used to refer to actual COMDAT sections, COMDAT
1710  *	groups tied together with an SHF_GROUP section, and .gnu.linkonce
1711  *	sections which provide a simplified COMDAT requirement.  COMDAT
1712  *	sections are identified with the FLG_IS_COMDAT section flag.
1713  *
1714  *	In principle, this sort of sloppy relocation remapping is
1715  *	a questionable practice. All self-referential sections should
1716  *	be in a common SHF_GROUP so that they are all kept or removed
1717  *	together. The problem is that there is no way to ensure that the
1718  *	two sections are similar enough that the replacement section will
1719  *	really supply the correct information. However, we see a couple of
1720  *	situations where it is useful to do this: (1) Older Sun C compilers
1721  *	generated DWARF sections that would refer to one of the COMDAT
1722  *	sections, and (2) gcc, when its GNU linkonce COMDAT feature is enabled.
1723  *	It turns out that the GNU ld does these sloppy remappings.
1724  *
1725  *	The GNU ld takes an approach that hard wires special section
1726  *	names and treats them specially. We avoid that practice and
1727  *	try to get the necessary work done relying only on the ELF
1728  *	attributes of the sections and symbols involved. This means
1729  *	that our heuristic is somewhat different than theirs, but the
1730  *	end result is close enough to solve the same problem.
1731  *
1732  *	gcc is in the process of converting to SHF_GROUP. This will
1733  *	eventually phase out the need for sloppy relocations, and
1734  *	then this logic won't be needed. In the meantime, relaxed relocation
1735  *	processing allows us to interoperate.
1736  */
1737 static Sym_desc *
sloppy_comdat_reloc(Ofl_desc * ofl,Rel_desc * reld,Sym_desc * sdp,Rlxrel_rej * reject)1738 sloppy_comdat_reloc(Ofl_desc *ofl, Rel_desc *reld, Sym_desc *sdp,
1739     Rlxrel_rej *reject)
1740 {
1741 	Is_desc		*rep_isp;
1742 	Sym		*sym, *rep_sym;
1743 	Is_desc		*isp;
1744 	Ifl_desc	*ifl;
1745 	Conv_inv_buf_t	inv_buf;
1746 	Word		scnndx, symscnt;
1747 	Sym_desc	**oldndx, *rep_sdp;
1748 	const char	*is_name;
1749 
1750 
1751 	/*
1752 	 * Sloppy relocations are never applied to .eh_frame or
1753 	 * .gcc_except_table sections. The entries in these sections
1754 	 * for discarded sections are better left uninitialized.
1755 	 *
1756 	 * We match these sections by name, because on most platforms they
1757 	 * are SHT_PROGBITS, and cannot be identified otherwise. On amd64
1758 	 * architectures, .eh_frame is SHT_AMD64_UNWIND, but that is ambiguous
1759 	 * (.eh_frame_hdr is also SHT_AMD64_UNWIND), so we still match it by
1760 	 * name.
1761 	 */
1762 	is_name = reld->rel_isdesc->is_name;
1763 	if (((is_name[1] == 'e') &&
1764 	    (strcmp(is_name, MSG_ORIG(MSG_SCN_EHFRAME)) == 0)) ||
1765 	    ((is_name[1] == 'g') &&
1766 	    (strcmp(is_name, MSG_ORIG(MSG_SCN_GCC_X_TBL)) == 0))) {
1767 		*reject = RLXREL_REJ_TARGET;
1768 		return (NULL);
1769 	}
1770 
1771 	/*
1772 	 * If we looked up the same symbol on the previous call, we can
1773 	 * return the cached value.
1774 	 */
1775 	if (sdp == ofl->ofl_sr_cache.sr_osdp) {
1776 		*reject = ofl->ofl_sr_cache.sr_rej;
1777 		return (ofl->ofl_sr_cache.sr_rsdp);
1778 	}
1779 
1780 	ofl->ofl_sr_cache.sr_osdp = sdp;
1781 	sym = sdp->sd_sym;
1782 	isp = sdp->sd_isc;
1783 	ifl = sdp->sd_file;
1784 
1785 	/*
1786 	 * When a COMDAT section is discarded in favor of another COMDAT
1787 	 * section, the replacement is recorded in its section descriptor
1788 	 * (is_comdatkeep). We must validate the replacement before using
1789 	 * it. The replacement section must:
1790 	 *	- Not have been discarded
1791 	 *	- Have the same size (*)
1792 	 *	- Have the same section type
1793 	 *	- Have the same SHF_GROUP flag setting (either on or off)
1794 	 *	- Must be a COMDAT section of one form or the other.
1795 	 *
1796 	 * (*) One might imagine that the replacement section could be
1797 	 * larger than the original, rather than the exact size. However,
1798 	 * we have verified that this is the same policy used by the GNU
1799 	 * ld. If the sections are not the same size, the chance of them
1800 	 * being interchangeable drops significantly.
1801 	 */
1802 	if (((rep_isp = isp->is_comdatkeep) == NULL) ||
1803 	    ((rep_isp->is_flags & FLG_IS_DISCARD) != 0) ||
1804 	    ((rep_isp->is_flags & FLG_IS_COMDAT) == 0) ||
1805 	    (isp->is_indata->d_size != rep_isp->is_indata->d_size) ||
1806 	    (isp->is_shdr->sh_type != rep_isp->is_shdr->sh_type) ||
1807 	    ((isp->is_shdr->sh_flags & SHF_GROUP) !=
1808 	    (rep_isp->is_shdr->sh_flags & SHF_GROUP))) {
1809 		*reject = ofl->ofl_sr_cache.sr_rej = RLXREL_REJ_SECTION;
1810 		return (ofl->ofl_sr_cache.sr_rsdp = NULL);
1811 	}
1812 
1813 	/*
1814 	 * We found the kept COMDAT section. Now, look at all of the
1815 	 * symbols from the input file that contains it to find the
1816 	 * symbol that corresponds to the one we started with:
1817 	 *	- Hasn't been discarded
1818 	 *	- Has section index of kept section
1819 	 *	- If one symbol has a name, the other must have
1820 	 *		the same name. The st_name field of a symbol
1821 	 *		is 0 if there is no name, and is a string
1822 	 *		table offset otherwise. The string table
1823 	 *		offsets may well not agree --- it is the
1824 	 *		actual string that matters.
1825 	 *	- Type and binding attributes match (st_info)
1826 	 *	- Values match (st_value)
1827 	 *	- Sizes match (st_size)
1828 	 *	- Visibility matches (st_other)
1829 	 */
1830 	scnndx = rep_isp->is_scnndx;
1831 	oldndx = rep_isp->is_file->ifl_oldndx;
1832 	symscnt = rep_isp->is_file->ifl_symscnt;
1833 	while (symscnt--) {
1834 		rep_sdp = *oldndx++;
1835 		if ((rep_sdp == NULL) || (rep_sdp->sd_flags & FLG_SY_ISDISC) ||
1836 		    ((rep_sym = rep_sdp->sd_sym)->st_shndx != scnndx) ||
1837 		    ((sym->st_name == 0) != (rep_sym->st_name == 0)) ||
1838 		    ((sym->st_name != 0) &&
1839 		    (strcmp(sdp->sd_name, rep_sdp->sd_name) != 0)) ||
1840 		    (sym->st_info != rep_sym->st_info) ||
1841 		    (sym->st_value != rep_sym->st_value) ||
1842 		    (sym->st_size != rep_sym->st_size) ||
1843 		    (sym->st_other != rep_sym->st_other))
1844 			continue;
1845 
1846 
1847 		if (ofl->ofl_flags & FLG_OF_VERBOSE) {
1848 			if (sym->st_name != 0) {
1849 				ld_eprintf(ofl, ERR_WARNING,
1850 				    MSG_INTL(MSG_REL_SLOPCDATNAM),
1851 				    conv_reloc_type(ifl->ifl_ehdr->e_machine,
1852 				    reld->rel_rtype, 0, &inv_buf),
1853 				    ifl->ifl_name,
1854 				    EC_WORD(reld->rel_isdesc->is_scnndx),
1855 				    reld->rel_isdesc->is_name,
1856 				    rep_sdp->sd_name,
1857 				    EC_WORD(isp->is_scnndx), isp->is_name,
1858 				    rep_sdp->sd_file->ifl_name);
1859 			} else {
1860 				ld_eprintf(ofl, ERR_WARNING,
1861 				    MSG_INTL(MSG_REL_SLOPCDATNONAM),
1862 				    conv_reloc_type(ifl->ifl_ehdr->e_machine,
1863 				    reld->rel_rtype, 0, &inv_buf),
1864 				    ifl->ifl_name,
1865 				    EC_WORD(reld->rel_isdesc->is_scnndx),
1866 				    reld->rel_isdesc->is_name,
1867 				    EC_WORD(isp->is_scnndx), isp->is_name,
1868 				    rep_sdp->sd_file->ifl_name);
1869 			}
1870 		}
1871 		DBG_CALL(Dbg_reloc_sloppycomdat(ofl->ofl_lml, rep_sdp));
1872 		*reject = ofl->ofl_sr_cache.sr_rej = RLXREL_REJ_NONE;
1873 		return (ofl->ofl_sr_cache.sr_rsdp = rep_sdp);
1874 	}
1875 
1876 	/* If didn't return above, we didn't find it */
1877 	*reject = ofl->ofl_sr_cache.sr_rej = RLXREL_REJ_SYMBOL;
1878 	return (ofl->ofl_sr_cache.sr_rsdp = NULL);
1879 }
1880 
1881 /*
1882  * Generate relocation descriptor and dispatch
1883  */
1884 static uintptr_t
process_reld(Ofl_desc * ofl,Is_desc * isp,Rel_desc * reld,Word rsndx,Rel * reloc)1885 process_reld(Ofl_desc *ofl, Is_desc *isp, Rel_desc *reld, Word rsndx,
1886     Rel *reloc)
1887 {
1888 	Ifl_desc	*ifl = isp->is_file;
1889 	Word		rtype = reld->rel_rtype;
1890 	Sym_desc	*sdp;
1891 	Conv_inv_buf_t	inv_buf;
1892 
1893 	/*
1894 	 * Make sure the relocation is in the valid range.
1895 	 */
1896 	if (rtype >= ld_targ.t_m.m_r_num) {
1897 		ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_REL_INVALRELT),
1898 		    ifl->ifl_name, EC_WORD(isp->is_scnndx), isp->is_name,
1899 		    rtype);
1900 		return (S_ERROR);
1901 	}
1902 
1903 	ofl->ofl_entrelscnt++;
1904 
1905 	/*
1906 	 * Special case: a register symbol associated with symbol index 0 is
1907 	 * initialized (i.e., relocated) to a constant from the r_addend field
1908 	 * rather than from a symbol value.
1909 	 */
1910 	if (IS_REGISTER(rtype) && (rsndx == 0)) {
1911 		reld->rel_sym = NULL;
1912 		DBG_CALL(Dbg_reloc_in(ofl->ofl_lml, ELF_DBG_LD,
1913 		    ld_targ.t_m.m_mach, isp->is_shdr->sh_type,
1914 		    (void *)reloc, isp->is_name, isp->is_scnndx,
1915 		    ld_reloc_sym_name(reld)));
1916 		if (ld_targ.t_mr.mr_reloc_register == NULL) {
1917 			ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_REL_NOREG));
1918 			return (S_ERROR);
1919 		}
1920 		return ((*ld_targ.t_mr.mr_reloc_register)(reld, isp, ofl));
1921 	}
1922 
1923 	/*
1924 	 * If this is a STT_SECTION symbol, make sure the associated
1925 	 * section has a descriptive non-NULL is_sym_name field that can
1926 	 * be accessed by ld_reloc_sym_name() to satisfy debugging output
1927 	 * and errors.
1928 	 *
1929 	 * In principle, we could add this string to every input section
1930 	 * as it is created, but we defer it until we see a relocation
1931 	 * symbol that might need it. Not every section will have such
1932 	 * a relocation, so we create fewer of them this way.
1933 	 */
1934 	sdp = reld->rel_sym = ifl->ifl_oldndx[rsndx];
1935 	if ((sdp != NULL) &&
1936 	    (ELF_ST_TYPE(sdp->sd_sym->st_info) == STT_SECTION) &&
1937 	    (sdp->sd_isc != NULL) && (sdp->sd_isc->is_name != NULL) &&
1938 	    (sdp->sd_isc->is_sym_name == NULL) &&
1939 	    (ld_stt_section_sym_name(sdp->sd_isc) == NULL))
1940 		return (S_ERROR);
1941 
1942 	/*
1943 	 * If for some reason we have a null relocation record issue a
1944 	 * warning and continue (the compiler folks can get into this
1945 	 * state some time).  Normal users should never see this error.
1946 	 */
1947 	if (rtype == ld_targ.t_m.m_r_none) {
1948 		DBG_CALL(Dbg_reloc_in(ofl->ofl_lml, ELF_DBG_LD,
1949 		    ld_targ.t_m.m_mach, ld_targ.t_m.m_rel_sht_type,
1950 		    (void *)reloc, isp->is_name, isp->is_scnndx,
1951 		    ld_reloc_sym_name(reld)));
1952 		ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_REL_NULL),
1953 		    ifl->ifl_name, EC_WORD(isp->is_scnndx), isp->is_name);
1954 		return (1);
1955 	}
1956 
1957 	if (((ofl->ofl_flags & FLG_OF_RELOBJ) == 0) &&
1958 	    IS_NOTSUP(rtype)) {
1959 		ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_REL_NOTSUP),
1960 		    conv_reloc_type(ifl->ifl_ehdr->e_machine, rtype,
1961 		    0, &inv_buf), ifl->ifl_name, EC_WORD(isp->is_scnndx),
1962 		    isp->is_name);
1963 		return (S_ERROR);
1964 	}
1965 
1966 	/*
1967 	 * If we are here, we know that the relocation requires reference
1968 	 * symbol. If no symbol is assigned, this is a fatal error.
1969 	 */
1970 	if (sdp == NULL) {
1971 		ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_REL_NOSYMBOL),
1972 		    conv_reloc_type(ifl->ifl_ehdr->e_machine, rtype,
1973 		    0, &inv_buf), ifl->ifl_name, EC_WORD(isp->is_scnndx),
1974 		    isp->is_name, EC_XWORD(reloc->r_offset));
1975 		return (S_ERROR);
1976 	}
1977 
1978 	if (sdp->sd_flags & FLG_SY_IGNORE)
1979 		return (1);
1980 
1981 	/*
1982 	 * If this symbol is part of a DISCARDED section attempt to find another
1983 	 * definition.
1984 	 */
1985 	if (sdp->sd_flags & FLG_SY_ISDISC) {
1986 		Sym_desc	*nsdp = NULL;
1987 		Rlxrel_rej	reject;
1988 
1989 		if (ELF_ST_BIND(sdp->sd_sym->st_info) == STB_LOCAL) {
1990 			/*
1991 			 * If "-z relaxreloc", and the input section is COMDAT
1992 			 * that has been assigned to an output section, then
1993 			 * determine if this is a reference to a discarded
1994 			 * COMDAT section that can be replaced with a COMDAT
1995 			 * that has been kept.
1996 			 */
1997 			if ((ofl->ofl_flags1 & FLG_OF1_RLXREL) &&
1998 			    sdp->sd_isc->is_osdesc &&
1999 			    (sdp->sd_isc->is_flags & FLG_IS_COMDAT) &&
2000 			    ((nsdp = sloppy_comdat_reloc(ofl, reld,
2001 			    sdp, &reject)) == NULL)) {
2002 				Shdr	*is_shdr = reld->rel_isdesc->is_shdr;
2003 
2004 				/*
2005 				 * A matching symbol was not found. We will
2006 				 * ignore this relocation.  Determine whether
2007 				 * or not to issue a warning.
2008 				 * Warnings are always issued under -z verbose,
2009 				 * but otherwise, we will follow the lead of
2010 				 * the GNU ld and suppress them for certain
2011 				 * cases:
2012 				 *
2013 				 *  -	It is a non-allocable debug section.
2014 				 *	The GNU ld tests for these by name,
2015 				 *	but we are willing to extend it to
2016 				 *	any non-allocable section.
2017 				 *  -	The target section is excluded from
2018 				 *	sloppy relocations by policy.
2019 				 */
2020 				if (((ofl->ofl_flags & FLG_OF_VERBOSE) != 0) ||
2021 				    ((is_shdr->sh_flags & SHF_ALLOC) &&
2022 				    (reject != RLXREL_REJ_TARGET)))
2023 					ld_eprintf(ofl, ERR_WARNING,
2024 					    MSG_INTL(MSG_REL_SLOPCDATNOSYM),
2025 					    conv_reloc_type(
2026 					    ifl->ifl_ehdr->e_machine,
2027 					    reld->rel_rtype, 0, &inv_buf),
2028 					    ifl->ifl_name,
2029 					    EC_WORD(isp->is_scnndx),
2030 					    isp->is_name,
2031 					    ld_reloc_sym_name(reld),
2032 					    EC_WORD(sdp->sd_isc->is_scnndx),
2033 					    sdp->sd_isc->is_name);
2034 				return (1);
2035 			}
2036 		} else if ((sdp != NULL) && sdp->sd_name && *sdp->sd_name)
2037 			nsdp = ld_sym_find(sdp->sd_name, SYM_NOHASH, NULL, ofl);
2038 
2039 		if (nsdp == NULL) {
2040 			ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_REL_SYMDISC),
2041 			    conv_reloc_type(ifl->ifl_ehdr->e_machine,
2042 			    reld->rel_rtype, 0, &inv_buf), ifl->ifl_name,
2043 			    EC_WORD(isp->is_scnndx), isp->is_name,
2044 			    ld_reloc_sym_name(reld),
2045 			    EC_WORD(sdp->sd_isc->is_scnndx),
2046 			    sdp->sd_isc->is_name);
2047 			return (S_ERROR);
2048 		}
2049 		ifl->ifl_oldndx[rsndx] = sdp = nsdp;
2050 		if ((ELF_ST_TYPE(sdp->sd_sym->st_info) == STT_SECTION) &&
2051 		    (sdp->sd_isc != NULL) && (sdp->sd_isc->is_name != NULL) &&
2052 		    (sdp->sd_isc->is_sym_name == NULL) &&
2053 		    (ld_stt_section_sym_name(sdp->sd_isc) == NULL))
2054 			return (S_ERROR);
2055 	}
2056 
2057 	/*
2058 	 * If this is a global symbol, determine whether its visibility needs
2059 	 * adjusting.
2060 	 */
2061 	if (sdp->sd_aux && ((sdp->sd_flags & FLG_SY_VISIBLE) == 0))
2062 		ld_sym_adjust_vis(sdp, ofl);
2063 
2064 	/*
2065 	 * Ignore any relocation against a section that will not be in the
2066 	 * output file (has been stripped).
2067 	 */
2068 	if ((sdp->sd_isc == 0) &&
2069 	    (ELF_ST_TYPE(sdp->sd_sym->st_info) == STT_SECTION))
2070 		return (1);
2071 
2072 	/*
2073 	 * If the input section exists, but the section has not been associated
2074 	 * to an output section, then this is a little suspicious.
2075 	 */
2076 	if (sdp->sd_isc && (sdp->sd_isc->is_osdesc == 0) &&
2077 	    (ELF_ST_TYPE(sdp->sd_sym->st_info) == STT_SECTION)) {
2078 		ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_RELINVSEC),
2079 		    conv_reloc_type(ifl->ifl_ehdr->e_machine, rtype,
2080 		    0, &inv_buf), ifl->ifl_name, EC_WORD(isp->is_scnndx),
2081 		    isp->is_name, EC_WORD(sdp->sd_isc->is_scnndx),
2082 		    sdp->sd_isc->is_name);
2083 		return (1);
2084 	}
2085 
2086 	/*
2087 	 * If the symbol for this relocation is invalid (which should have
2088 	 * generated a message during symbol processing), or the relocation
2089 	 * record's symbol reference is in any other way invalid, then it's
2090 	 * about time we gave up.
2091 	 */
2092 	if ((sdp->sd_flags & FLG_SY_INVALID) || (rsndx == 0) ||
2093 	    (rsndx >= ifl->ifl_symscnt)) {
2094 		ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_REL_UNKNWSYM),
2095 		    conv_reloc_type(ifl->ifl_ehdr->e_machine, rtype,
2096 		    0, &inv_buf), ifl->ifl_name, EC_WORD(isp->is_scnndx),
2097 		    isp->is_name, ld_reloc_sym_name(reld),
2098 		    EC_XWORD(reloc->r_offset), EC_WORD(rsndx));
2099 		return (S_ERROR);
2100 	}
2101 
2102 	/*
2103 	 * Size relocations against section symbols are presently unsupported.
2104 	 * There is a question as to whether the input section size, or output
2105 	 * section size would be used.  Until an explicit requirement is
2106 	 * established for either case, we'll punt.
2107 	 */
2108 	if (IS_SIZE(rtype) &&
2109 	    (ELF_ST_TYPE(sdp->sd_sym->st_info) == STT_SECTION)) {
2110 		ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_REL_UNSUPSIZE),
2111 		    conv_reloc_type(ifl->ifl_ehdr->e_machine, rtype,
2112 		    0, &inv_buf), ifl->ifl_name, EC_WORD(isp->is_scnndx),
2113 		    isp->is_name);
2114 		return (S_ERROR);
2115 	}
2116 
2117 	reld->rel_sym = sdp;
2118 	if (reld->rel_aux)
2119 		reld->rel_aux->ra_usym = sdp;
2120 	return (ld_process_sym_reloc(ofl, reld, reloc, isp, isp->is_name,
2121 	    isp->is_scnndx));
2122 }
2123 
2124 static uintptr_t
reloc_section(Ofl_desc * ofl,Is_desc * isect,Is_desc * rsect,Os_desc * osect)2125 reloc_section(Ofl_desc *ofl, Is_desc *isect, Is_desc *rsect, Os_desc *osect)
2126 {
2127 	Rel		*rend;		/* end of relocation section data */
2128 	Rel		*reloc;		/* current relocation entry */
2129 	Xword		rsize;		/* size of relocation section data */
2130 	Xword		entsize;	/* size of relocation entry */
2131 	Rel_desc	reld;		/* relocation descriptor */
2132 	Rel_aux	rel_aux;
2133 	Shdr *		shdr;
2134 	Word		flags = 0;
2135 	uintptr_t	ret = 1;
2136 
2137 	shdr = rsect->is_shdr;
2138 	rsize = shdr->sh_size;
2139 	reloc = (Rel *)rsect->is_indata->d_buf;
2140 
2141 	/*
2142 	 * Decide entry size.
2143 	 */
2144 	if (((entsize = shdr->sh_entsize) == 0) || (entsize > rsize)) {
2145 		if (shdr->sh_type == SHT_RELA)
2146 			entsize = sizeof (Rela);
2147 		else
2148 			entsize = sizeof (Rel);
2149 	}
2150 
2151 	/*
2152 	 * Build up the basic information in for the Rel_desc structure.
2153 	 */
2154 	reld.rel_isdesc = isect;
2155 	reld.rel_aux = &rel_aux;
2156 	ld_init_rel_aux(&reld);
2157 	rel_aux.ra_osdesc = osect;
2158 
2159 	if ((ofl->ofl_flags & FLG_OF_RELOBJ) ||
2160 	    (osect && (osect->os_sgdesc->sg_phdr.p_type == PT_LOAD)))
2161 		flags |= FLG_REL_LOAD;
2162 
2163 	if (shdr->sh_info == 0)
2164 		flags |= FLG_REL_NOINFO;
2165 
2166 	DBG_CALL(Dbg_reloc_proc(ofl->ofl_lml, osect, isect, rsect));
2167 
2168 	for (rend = (Rel *)((uintptr_t)reloc + (uintptr_t)rsize);
2169 	    reloc < rend;
2170 	    reloc = (Rel *)((uintptr_t)reloc + (uintptr_t)entsize)) {
2171 		Word	rsndx;
2172 
2173 		/*
2174 		 * Initialize the relocation record information and process
2175 		 * the individual relocation.  Reinitialize the flags to
2176 		 * insure we don't carry any state over from the previous
2177 		 * relocation records processing.
2178 		 */
2179 		reld.rel_flags = flags;
2180 		rsndx = (*ld_targ.t_mr.mr_init_rel)(&reld,
2181 		    &rel_aux.ra_typedata, (void *)reloc);
2182 
2183 		/*
2184 		 * Determine whether or not to pass an auxiliary block
2185 		 * in with this Rel_desc. It is not needed if both the
2186 		 * osdesc and typedata fields have default values.
2187 		 */
2188 		reld.rel_aux =
2189 		    (RELAUX_ISDEFAULT_OSDESC(&reld, rel_aux.ra_osdesc) &&
2190 		    RELAUX_ISDEFAULT_TYPEDATA(&reld, rel_aux.ra_typedata)) ?
2191 		    NULL : &rel_aux;
2192 
2193 		if (process_reld(ofl, rsect, &reld, rsndx, reloc) == S_ERROR)
2194 			ret = S_ERROR;
2195 	}
2196 	return (ret);
2197 }
2198 
2199 static uintptr_t
reloc_segments(int wr_flag,Ofl_desc * ofl)2200 reloc_segments(int wr_flag, Ofl_desc *ofl)
2201 {
2202 	Aliste		idx1;
2203 	Sg_desc		*sgp;
2204 	Is_desc		*isp;
2205 
2206 	for (APLIST_TRAVERSE(ofl->ofl_segs, idx1, sgp)) {
2207 		Os_desc	*osp;
2208 		Aliste	idx2;
2209 
2210 		if ((sgp->sg_phdr.p_flags & PF_W) != wr_flag)
2211 			continue;
2212 
2213 		for (APLIST_TRAVERSE(sgp->sg_osdescs, idx2, osp)) {
2214 			Is_desc	*risp;
2215 			Aliste	idx3;
2216 
2217 			osp->os_szoutrels = 0;
2218 			for (APLIST_TRAVERSE(osp->os_relisdescs, idx3, risp)) {
2219 				Word	indx;
2220 
2221 				/*
2222 				 * Determine the input section that this
2223 				 * relocation information refers to.
2224 				 */
2225 				indx = risp->is_shdr->sh_info;
2226 				isp = risp->is_file->ifl_isdesc[indx];
2227 
2228 				/*
2229 				 * Do not process relocations against sections
2230 				 * which are being discarded (COMDAT)
2231 				 */
2232 				if (isp->is_flags & FLG_IS_DISCARD)
2233 					continue;
2234 
2235 				if (reloc_section(ofl, isp, risp, osp) ==
2236 				    S_ERROR)
2237 					return (S_ERROR);
2238 			}
2239 
2240 			/*
2241 			 * Check for relocations against non-writable
2242 			 * allocatable sections.
2243 			 */
2244 			if (osp->os_szoutrels &&
2245 			    (sgp->sg_phdr.p_type == PT_LOAD) &&
2246 			    ((sgp->sg_phdr.p_flags & PF_W) == 0)) {
2247 				ofl->ofl_flags |= FLG_OF_TEXTREL;
2248 				ofl->ofl_dtflags |= DF_TEXTREL;
2249 			}
2250 		}
2251 	}
2252 
2253 	return (1);
2254 }
2255 
2256 /*
2257  * Move Section related function
2258  * Get move entry
2259  */
2260 static Move *
get_move_entry(Is_desc * rsect,Xword roffset)2261 get_move_entry(Is_desc *rsect, Xword roffset)
2262 {
2263 	Ifl_desc	*ifile = rsect->is_file;
2264 	Shdr		*rshdr = rsect->is_shdr;
2265 	Is_desc		*misp;
2266 	Shdr		*mshdr;
2267 	Xword		midx;
2268 	Move		*mvp;
2269 
2270 	/*
2271 	 * Set info for the target move section
2272 	 */
2273 	misp = ifile->ifl_isdesc[rshdr->sh_info];
2274 	mshdr = misp->is_shdr;
2275 
2276 	if (mshdr->sh_entsize == 0)
2277 		return (NULL);
2278 
2279 	/*
2280 	 * If this is an invalid entry, return NULL.
2281 	 */
2282 	midx = roffset / mshdr->sh_entsize;
2283 	if ((midx * mshdr->sh_entsize) >= mshdr->sh_size)
2284 		return (NULL);
2285 
2286 	mvp = (Move *)misp->is_indata->d_buf;
2287 	mvp += midx;
2288 	return (mvp);
2289 }
2290 
2291 /*
2292  * Relocation against Move Table.
2293  */
2294 static uintptr_t
process_movereloc(Ofl_desc * ofl,Is_desc * rsect)2295 process_movereloc(Ofl_desc *ofl, Is_desc *rsect)
2296 {
2297 	Ifl_desc	*file = rsect->is_file;
2298 	Rel		*rend, *reloc;
2299 	Xword		rsize, entsize;
2300 	Rel_desc	reld;
2301 	Rel_aux	rel_aux;
2302 
2303 	rsize = rsect->is_shdr->sh_size;
2304 	reloc = (Rel *)rsect->is_indata->d_buf;
2305 
2306 	/*
2307 	 * Decide entry size.
2308 	 */
2309 	entsize = rsect->is_shdr->sh_entsize;
2310 	if ((entsize == 0) ||
2311 	    (entsize > rsect->is_shdr->sh_size)) {
2312 		if (rsect->is_shdr->sh_type == SHT_RELA)
2313 			entsize = sizeof (Rela);
2314 		else
2315 			entsize = sizeof (Rel);
2316 	}
2317 
2318 	/*
2319 	 * The requirement for move data ensures that we have to supply a
2320 	 * Rel_aux auxiliary block.
2321 	 */
2322 	reld.rel_aux = &rel_aux;
2323 	ld_init_rel_aux(&reld);
2324 
2325 	/*
2326 	 * Go through the relocation entries.
2327 	 */
2328 	for (rend = (Rel *)((uintptr_t)reloc + (uintptr_t)rsize);
2329 	    reloc < rend;
2330 	    reloc = (Rel *)((uintptr_t)reloc + (uintptr_t)entsize)) {
2331 		Sym_desc	*psdp;
2332 		Move		*mvp;
2333 		Word		rsndx;
2334 
2335 		/*
2336 		 * Initialize the relocation record information.
2337 		 */
2338 		reld.rel_flags = FLG_REL_LOAD;
2339 		rsndx = (*ld_targ.t_mr.mr_init_rel)(&reld,
2340 		    &rel_aux.ra_typedata, (void *)reloc);
2341 
2342 		if (((mvp = get_move_entry(rsect, reloc->r_offset)) == NULL) ||
2343 		    ((rel_aux.ra_move =
2344 		    libld_malloc(sizeof (Mv_reloc))) == NULL))
2345 			return (S_ERROR);
2346 
2347 		psdp = file->ifl_oldndx[ELF_M_SYM(mvp->m_info)];
2348 		rel_aux.ra_move->mr_move = mvp;
2349 		rel_aux.ra_move->mr_sym = psdp;
2350 
2351 		if (psdp->sd_flags & FLG_SY_PAREXPN) {
2352 			int	_num, num = mvp->m_repeat;
2353 
2354 			rel_aux.ra_osdesc = ofl->ofl_isparexpn->is_osdesc;
2355 			reld.rel_isdesc = ofl->ofl_isparexpn;
2356 			reld.rel_roffset = mvp->m_poffset;
2357 
2358 			for (_num = 0; _num < num; _num++) {
2359 				reld.rel_roffset +=
2360 				    /* LINTED */
2361 				    (_num * ELF_M_SIZE(mvp->m_info));
2362 
2363 				/*
2364 				 * Generate Reld
2365 				 */
2366 				if (process_reld(ofl,
2367 				    rsect, &reld, rsndx, reloc) == S_ERROR)
2368 					return (S_ERROR);
2369 			}
2370 		} else {
2371 			/*
2372 			 * Generate Reld
2373 			 */
2374 			reld.rel_flags |= FLG_REL_MOVETAB;
2375 			rel_aux.ra_osdesc = ofl->ofl_osmove;
2376 			reld.rel_isdesc = ld_os_first_isdesc(ofl->ofl_osmove);
2377 
2378 			if (process_reld(ofl,
2379 			    rsect, &reld, rsndx, reloc) == S_ERROR)
2380 				return (S_ERROR);
2381 		}
2382 	}
2383 	return (1);
2384 }
2385 
2386 /*
2387  * This function is similar to reloc_init().
2388  *
2389  * This function is called when the SHT_SUNW_move table is expanded and there
2390  * are relocations against the SHT_SUNW_move section.
2391  */
2392 static uintptr_t
reloc_movesections(Ofl_desc * ofl)2393 reloc_movesections(Ofl_desc *ofl)
2394 {
2395 	Aliste		idx;
2396 	Is_desc		*risp;
2397 	uintptr_t	ret = 1;
2398 
2399 	/*
2400 	 * Generate/Expand relocation entries
2401 	 */
2402 	for (APLIST_TRAVERSE(ofl->ofl_ismoverel, idx, risp)) {
2403 		if (process_movereloc(ofl, risp) == S_ERROR)
2404 			ret = S_ERROR;
2405 	}
2406 
2407 	return (ret);
2408 }
2409 
2410 /*
2411  * Count the number of output relocation entries, global offset table entries,
2412  * and procedure linkage table entries.  This function searches the segment and
2413  * outsect lists and passes each input reloc section to process_reloc().
2414  * It allocates space for any output relocations needed.  And builds up
2415  * the relocation structures for later processing.
2416  */
2417 uintptr_t
ld_reloc_init(Ofl_desc * ofl)2418 ld_reloc_init(Ofl_desc *ofl)
2419 {
2420 	Aliste		idx;
2421 	Is_desc		*isp;
2422 	Sym_desc	*sdp;
2423 
2424 	DBG_CALL(Dbg_basic_collect(ofl->ofl_lml));
2425 
2426 	/*
2427 	 * At this point we have finished processing all input symbols.  Make
2428 	 * sure we add any absolute (internal) symbols before continuing with
2429 	 * any relocation processing.
2430 	 */
2431 	if (ld_sym_spec(ofl) == S_ERROR)
2432 		return (S_ERROR);
2433 
2434 	ofl->ofl_gotcnt = ld_targ.t_m.m_got_xnumber;
2435 
2436 	/*
2437 	 * Process all of the relocations against NON-writable segments
2438 	 * followed by relocations against the writable segments.
2439 	 *
2440 	 * This separation is so that when the writable segments are processed
2441 	 * we know whether or not a COPYRELOC will be produced for any symbols.
2442 	 * If relocations aren't processed in this order, a COPYRELOC and a
2443 	 * regular relocation can be produced against the same symbol.  The
2444 	 * regular relocation would be redundant.
2445 	 */
2446 	if (reloc_segments(0, ofl) == S_ERROR)
2447 		return (S_ERROR);
2448 
2449 	if (reloc_segments(PF_W, ofl) == S_ERROR)
2450 		return (S_ERROR);
2451 
2452 	/*
2453 	 * Process any extra relocations.  These are relocation sections that
2454 	 * have a NULL sh_info.
2455 	 */
2456 	for (APLIST_TRAVERSE(ofl->ofl_extrarels, idx, isp)) {
2457 		if (reloc_section(ofl, NULL, isp, NULL) == S_ERROR)
2458 			return (S_ERROR);
2459 	}
2460 
2461 	/*
2462 	 * If there were relocation against move table,
2463 	 * process the relocation sections.
2464 	 */
2465 	if (reloc_movesections(ofl) == S_ERROR)
2466 		return (S_ERROR);
2467 
2468 	/*
2469 	 * Now all the relocations are pre-processed,
2470 	 * check the validity of copy relocations.
2471 	 */
2472 	if (ofl->ofl_copyrels) {
2473 		Copy_rel	*crp;
2474 
2475 		for (ALIST_TRAVERSE(ofl->ofl_copyrels, idx, crp)) {
2476 			/*
2477 			 * If there were no displacement relocation
2478 			 * in this file, don't worry about it.
2479 			 */
2480 			if (crp->c_sdp->sd_file->ifl_flags &
2481 			    (FLG_IF_DISPPEND | FLG_IF_DISPDONE))
2482 				is_disp_copied(ofl, crp);
2483 		}
2484 	}
2485 
2486 	/*
2487 	 * GOT sections are created for dynamic executables and shared objects
2488 	 * if the FLG_OF_BLDGOT is set, or explicit reference has been made to
2489 	 * a GOT symbol.
2490 	 */
2491 	if (((ofl->ofl_flags & FLG_OF_RELOBJ) == 0) &&
2492 	    ((ofl->ofl_flags & FLG_OF_BLDGOT) ||
2493 	    ((((sdp = ld_sym_find(MSG_ORIG(MSG_SYM_GOFTBL),
2494 	    SYM_NOHASH, NULL, ofl)) != NULL) ||
2495 	    ((sdp = ld_sym_find(MSG_ORIG(MSG_SYM_GOFTBL_U),
2496 	    SYM_NOHASH, NULL, ofl)) != NULL)) &&
2497 	    (sdp->sd_ref != REF_DYN_SEEN)))) {
2498 		if (ld_make_got(ofl) == S_ERROR)
2499 			return (S_ERROR);
2500 
2501 		/* Allocate the GOT if required by target */
2502 		if ((ld_targ.t_mr.mr_allocate_got != NULL) &&
2503 		    ((*ld_targ.t_mr.mr_allocate_got)(ofl) == S_ERROR))
2504 			return (S_ERROR);
2505 	}
2506 
2507 	return (1);
2508 }
2509 
2510 /*
2511  * Simple comparison routine to be used by qsort() for
2512  * the sorting of the output relocation list.
2513  *
2514  * The reloc_compare() routine results in a relocation
2515  * table which is located on:
2516  *
2517  *	file referenced (NEEDED NDX)
2518  *	referenced symbol
2519  *	relocation offset
2520  *
2521  * This provides the most efficient traversal of the relocation
2522  * table at run-time.
2523  */
2524 static int
reloc_compare(Reloc_list * i,Reloc_list * j)2525 reloc_compare(Reloc_list *i, Reloc_list *j)
2526 {
2527 
2528 	/*
2529 	 * first - sort on neededndx
2530 	 */
2531 	if (i->rl_key1 > j->rl_key1)
2532 		return (1);
2533 	if (i->rl_key1 < j->rl_key1)
2534 		return (-1);
2535 
2536 	/*
2537 	 * Then sort on symbol
2538 	 */
2539 	if ((uintptr_t)i->rl_key2 > (uintptr_t)j->rl_key2)
2540 		return (1);
2541 	if ((uintptr_t)i->rl_key2 < (uintptr_t)j->rl_key2)
2542 		return (-1);
2543 
2544 	/*
2545 	 * i->key2 == j->key2
2546 	 *
2547 	 * At this point we fall back to key2 (offsets) to
2548 	 * sort the output relocations.  Ideally this will
2549 	 * make for the most efficient processing of these
2550 	 * relocations at run-time.
2551 	 */
2552 	if (i->rl_key3 > j->rl_key3)
2553 		return (1);
2554 	if (i->rl_key3 < j->rl_key3)
2555 		return (-1);
2556 	return (0);
2557 }
2558 
2559 static uintptr_t
do_sorted_outrelocs(Ofl_desc * ofl)2560 do_sorted_outrelocs(Ofl_desc *ofl)
2561 {
2562 	Rel_desc	*orsp;
2563 	Rel_cachebuf	*rcbp;
2564 	Aliste		idx;
2565 	Reloc_list	*sorted_list;
2566 	Word		index = 0;
2567 	int		debug = 0;
2568 	uintptr_t	error = 1;
2569 	Boolean		remain_seen = FALSE;
2570 
2571 	if ((sorted_list = libld_malloc((size_t)(sizeof (Reloc_list) *
2572 	    ofl->ofl_reloccnt))) == NULL)
2573 		return (S_ERROR);
2574 
2575 	/*
2576 	 * All but the PLT output relocations are sorted in the output file
2577 	 * based upon their sym_desc.  By doing this multiple relocations
2578 	 * against the same symbol are grouped together, thus when the object
2579 	 * is later relocated by ld.so.1 it will take advantage of the symbol
2580 	 * cache that ld.so.1 has.  This can significantly reduce the runtime
2581 	 * relocation cost of a dynamic object.
2582 	 *
2583 	 * PLT relocations are not sorted because the order of the PLT
2584 	 * relocations is used by ld.so.1 to determine what symbol a PLT
2585 	 * relocation is against.
2586 	 */
2587 	REL_CACHE_TRAVERSE(&ofl->ofl_outrels, idx, rcbp, orsp) {
2588 		if (debug == 0) {
2589 			DBG_CALL(Dbg_reloc_dooutrel(ofl->ofl_lml,
2590 			    ld_targ.t_m.m_rel_sht_type));
2591 			debug = 1;
2592 		}
2593 
2594 		/*
2595 		 * If it's a PLT relocation we output it now in the
2596 		 * order that it was originally processed.
2597 		 */
2598 		if (orsp->rel_flags & FLG_REL_PLT) {
2599 			if ((*ld_targ.t_mr.mr_perform_outreloc)
2600 			    (orsp, ofl, &remain_seen) == S_ERROR)
2601 				error = S_ERROR;
2602 			continue;
2603 		}
2604 
2605 		if ((orsp->rel_rtype == ld_targ.t_m.m_r_relative) ||
2606 		    (orsp->rel_rtype == ld_targ.t_m.m_r_register)) {
2607 			sorted_list[index].rl_key1 = 0;
2608 			sorted_list[index].rl_key2 =
2609 			    /* LINTED */
2610 			    (Sym_desc *)(uintptr_t)orsp->rel_rtype;
2611 		} else {
2612 			sorted_list[index].rl_key1 =
2613 			    orsp->rel_sym->sd_file->ifl_neededndx;
2614 			sorted_list[index].rl_key2 = orsp->rel_sym;
2615 		}
2616 
2617 		if (orsp->rel_flags & FLG_REL_GOT) {
2618 			sorted_list[index].rl_key3 =
2619 			    (*ld_targ.t_mr.mr_calc_got_offset)(orsp, ofl);
2620 		} else {
2621 			if (orsp->rel_rtype == ld_targ.t_m.m_r_register) {
2622 					sorted_list[index].rl_key3 = 0;
2623 			} else {
2624 				sorted_list[index].rl_key3 = orsp->rel_roffset +
2625 				    (Xword)_elf_getxoff(orsp->
2626 				    rel_isdesc->is_indata) +
2627 				    orsp->rel_isdesc->is_osdesc->
2628 				    os_shdr->sh_addr;
2629 			}
2630 		}
2631 
2632 		sorted_list[index++].rl_rsp = orsp;
2633 	}
2634 
2635 	qsort(sorted_list, (size_t)ofl->ofl_reloccnt, sizeof (Reloc_list),
2636 	    (int (*)(const void *, const void *))reloc_compare);
2637 
2638 	/*
2639 	 * All output relocations have now been sorted, go through
2640 	 * and process each relocation.
2641 	 */
2642 	for (index = 0; index < ofl->ofl_reloccnt; index++) {
2643 		if ((*ld_targ.t_mr.mr_perform_outreloc)
2644 		    (sorted_list[index].rl_rsp, ofl, &remain_seen) == S_ERROR)
2645 			error = S_ERROR;
2646 	}
2647 
2648 	/* Guidance: Use -z text when building shared objects */
2649 	if (remain_seen && OFL_GUIDANCE(ofl, FLG_OFG_NO_TEXT))
2650 		ld_eprintf(ofl, ERR_GUIDANCE, MSG_INTL(MSG_GUIDE_TEXT));
2651 
2652 	return (error);
2653 }
2654 
2655 /*
2656  * Process relocations.  Finds every input relocation section for each output
2657  * section and invokes reloc_section() to relocate that section.
2658  */
2659 uintptr_t
ld_reloc_process(Ofl_desc * ofl)2660 ld_reloc_process(Ofl_desc *ofl)
2661 {
2662 	Sg_desc		*sgp;
2663 	Os_desc		*osp;
2664 	Word		ndx = 0;
2665 	ofl_flag_t	flags = ofl->ofl_flags;
2666 	Shdr		*shdr;
2667 
2668 	DBG_CALL(Dbg_basic_relocate(ofl->ofl_lml));
2669 
2670 	/*
2671 	 * Determine the index of the symbol table that will be referenced by
2672 	 * the relocation entries.
2673 	 */
2674 	if (OFL_ALLOW_DYNSYM(ofl))
2675 		/* LINTED */
2676 		ndx = (Word)elf_ndxscn(ofl->ofl_osdynsym->os_scn);
2677 	else if (!(flags & FLG_OF_STRIP) || (flags & FLG_OF_RELOBJ))
2678 		/* LINTED */
2679 		ndx = (Word)elf_ndxscn(ofl->ofl_ossymtab->os_scn);
2680 
2681 	/*
2682 	 * Re-initialize counters. These are used to provide relocation
2683 	 * offsets within the output buffers.
2684 	 */
2685 	ofl->ofl_relocpltsz = 0;
2686 	ofl->ofl_relocgotsz = 0;
2687 	ofl->ofl_relocbsssz = 0;
2688 
2689 	/*
2690 	 * Now that the output file is created and symbol update has occurred,
2691 	 * process the relocations collected in process_reloc().
2692 	 */
2693 	if (do_sorted_outrelocs(ofl) == S_ERROR)
2694 		return (S_ERROR);
2695 
2696 	if ((*ld_targ.t_mr.mr_do_activerelocs)(ofl) == S_ERROR)
2697 		return (S_ERROR);
2698 
2699 	if ((flags & FLG_OF_COMREL) == 0) {
2700 		Aliste	idx1;
2701 
2702 		/*
2703 		 * Process the relocation sections.  For each relocation
2704 		 * section generated for the output image update its shdr
2705 		 * information to reflect the symbol table it needs (sh_link)
2706 		 * and the section to which the relocation must be applied
2707 		 * (sh_info).
2708 		 */
2709 		for (APLIST_TRAVERSE(ofl->ofl_segs, idx1, sgp)) {
2710 			Os_desc *osp;
2711 			Aliste	idx2;
2712 
2713 			for (APLIST_TRAVERSE(sgp->sg_osdescs, idx2, osp)) {
2714 				if (osp->os_relosdesc == 0)
2715 					continue;
2716 
2717 				shdr = osp->os_relosdesc->os_shdr;
2718 				shdr->sh_link = ndx;
2719 				/* LINTED */
2720 				shdr->sh_info = (Word)elf_ndxscn(osp->os_scn);
2721 			}
2722 		}
2723 
2724 		/*
2725 		 * Since the .rel[a] section is not tied to any specific
2726 		 * section, we'd not have found it above.
2727 		 */
2728 		if ((osp = ofl->ofl_osrel) != NULL) {
2729 			shdr = osp->os_shdr;
2730 			shdr->sh_link = ndx;
2731 			shdr->sh_info = 0;
2732 		}
2733 	} else {
2734 		/*
2735 		 * We only have two relocation sections here, (PLT's,
2736 		 * coalesced) so just hit them directly instead of stepping
2737 		 * over the output sections.
2738 		 */
2739 		if ((osp = ofl->ofl_osrelhead) != NULL) {
2740 			shdr = osp->os_shdr;
2741 			shdr->sh_link = ndx;
2742 			shdr->sh_info = 0;
2743 		}
2744 		if (((osp = ofl->ofl_osplt) != NULL) && osp->os_relosdesc) {
2745 			shdr = osp->os_relosdesc->os_shdr;
2746 			shdr->sh_link = ndx;
2747 			/* LINTED */
2748 			shdr->sh_info = (Word)elf_ndxscn(osp->os_scn);
2749 		}
2750 	}
2751 
2752 	/*
2753 	 * If the -z text option was given, and we have output relocations
2754 	 * against a non-writable, allocatable section, issue a diagnostic and
2755 	 * return (the actual entries that caused this error would have been
2756 	 * output during the relocating section phase).
2757 	 */
2758 	if ((flags & (FLG_OF_PURETXT | FLG_OF_TEXTREL)) ==
2759 	    (FLG_OF_PURETXT | FLG_OF_TEXTREL)) {
2760 		ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_REL_REMAIN_3));
2761 		return (S_ERROR);
2762 	}
2763 
2764 	/*
2765 	 * Finally, initialize the first got entry with the address of the
2766 	 * .dynamic section (_DYNAMIC).
2767 	 */
2768 	if (flags & FLG_OF_DYNAMIC) {
2769 		if ((*ld_targ.t_mr.mr_fillin_gotplt)(ofl) == S_ERROR)
2770 			return (S_ERROR);
2771 	}
2772 
2773 	/*
2774 	 * Now that any GOT information has been written, display the debugging
2775 	 * information if required.
2776 	 */
2777 	if ((osp = ofl->ofl_osgot) != NULL)
2778 		DBG_CALL(Dbg_got_display(ofl, osp->os_shdr->sh_addr, 1,
2779 		    ld_targ.t_m.m_got_xnumber, ld_targ.t_m.m_got_entsize));
2780 
2781 	return (1);
2782 }
2783 
2784 /*
2785  * If the -z text option was given, and we have output relocations against a
2786  * non-writable, allocatable section, issue a diagnostic. Print offending
2787  * symbols in tabular form similar to the way undefined symbols are presented.
2788  * Called from reloc_count().  The actual fatal error condition is triggered on
2789  * in reloc_process() above.
2790  *
2791  * Note.  For historic reasons -ztext is not a default option (however all OS
2792  * shared object builds use this option).  It can be argued that this option
2793  * should also be default when generating an a.out (see 1163979).  However, if
2794  * an a.out contains text relocations it is either because the user is creating
2795  * something pretty weird (they've used the -b or -znodefs options), or because
2796  * the library against which they're building wasn't constructed correctly (ie.
2797  * a function has a NOTYPE type, in which case the a.out won't generate an
2798  * associated plt).  In the latter case the builder of the a.out can't do
2799  * anything to fix the error - thus we've chosen not to give the user an error,
2800  * or warning, for this case.
2801  */
2802 void
ld_reloc_remain_entry(Rel_desc * orsp,Os_desc * osp,Ofl_desc * ofl,Boolean * remain_seen)2803 ld_reloc_remain_entry(Rel_desc *orsp, Os_desc *osp, Ofl_desc *ofl,
2804     Boolean *remain_seen)
2805 {
2806 
2807 	/*
2808 	 * -ztextoff
2809 	 */
2810 	if (ofl->ofl_flags1 & FLG_OF1_TEXTOFF)
2811 		return;
2812 
2813 	/*
2814 	 * Only give relocation errors against loadable read-only segments.
2815 	 */
2816 	if ((orsp->rel_rtype == ld_targ.t_m.m_r_register) || (!osp) ||
2817 	    (osp->os_sgdesc->sg_phdr.p_type != PT_LOAD) ||
2818 	    (osp->os_sgdesc->sg_phdr.p_flags & PF_W))
2819 		return;
2820 
2821 	/*
2822 	 * If we are in -ztextwarn mode, it's a silent error if a relocation is
2823 	 * due to a 'WEAK REFERENCE'.  This is because if the symbol is not
2824 	 * provided at run-time we will not perform a text-relocation.
2825 	 */
2826 	if (((ofl->ofl_flags & FLG_OF_PURETXT) == 0) &&
2827 	    (ELF_ST_BIND(orsp->rel_sym->sd_sym->st_info) == STB_WEAK) &&
2828 	    (orsp->rel_sym->sd_sym->st_shndx == SHN_UNDEF))
2829 		return;
2830 
2831 	if (*remain_seen == FALSE) {
2832 		/*
2833 		 * If building with '-ztext' then emit a fatal error.  If
2834 		 * building a executable then only emit a 'warning'.
2835 		 */
2836 		const char *str1 = (ofl->ofl_flags & FLG_OF_PURETXT) ?
2837 		    MSG_INTL(MSG_REL_RMN_ITM_11) : MSG_INTL(MSG_REL_RMN_ITM_13);
2838 
2839 		ld_eprintf(ofl, ERR_NONE, MSG_INTL(MSG_REL_REMAIN_FMT_1), str1,
2840 		    MSG_INTL(MSG_REL_RMN_ITM_31), MSG_INTL(MSG_REL_RMN_ITM_12),
2841 		    MSG_INTL(MSG_REL_RMN_ITM_2), MSG_INTL(MSG_REL_RMN_ITM_32));
2842 
2843 		*remain_seen = TRUE;
2844 	}
2845 
2846 	ld_eprintf(ofl, ERR_NONE, MSG_INTL(MSG_REL_REMAIN_2),
2847 	    ld_reloc_sym_name(orsp), EC_OFF(orsp->rel_roffset),
2848 	    orsp->rel_isdesc->is_file->ifl_name);
2849 }
2850 
2851 /*
2852  * Generic encapsulation for generating a TLS got index.
2853  */
2854 uintptr_t
ld_assign_got_TLS(Boolean local,Rel_desc * rsp,Ofl_desc * ofl,Sym_desc * sdp,Gotndx * gnp,Gotref gref,Word rflag,Word ortype,Word rtype1,Word rtype2)2855 ld_assign_got_TLS(Boolean local, Rel_desc *rsp, Ofl_desc *ofl, Sym_desc *sdp,
2856     Gotndx *gnp, Gotref gref, Word rflag, Word ortype, Word rtype1, Word rtype2)
2857 {
2858 	Word	rflags;
2859 
2860 	if ((*ld_targ.t_mr.mr_assign_got_ndx)(&(sdp->sd_GOTndxs), gnp,
2861 	    gref, ofl, rsp, sdp) == S_ERROR)
2862 		return (S_ERROR);
2863 
2864 	rflags = FLG_REL_GOT | rflag;
2865 	if (local)
2866 		rflags |= FLG_REL_SCNNDX;
2867 	rsp->rel_rtype = rtype1;
2868 
2869 	if ((*ld_targ.t_mr.mr_add_outrel)(rflags, rsp, ofl) == S_ERROR)
2870 		return (S_ERROR);
2871 
2872 	if (local && (gref == GOT_REF_TLSIE)) {
2873 		/*
2874 		 * If this is a local LE TLS symbol, then the symbol won't be
2875 		 * available at runtime.  The value of the local symbol will
2876 		 * be placed in the associated got entry, and the got
2877 		 * relocation is reassigned to a section symbol.
2878 		 */
2879 		if (ld_add_actrel(rflags, rsp, ofl) == S_ERROR)
2880 			return (S_ERROR);
2881 	}
2882 
2883 	if (rtype2) {
2884 		rflags = FLG_REL_GOT | rflag;
2885 		rsp->rel_rtype = rtype2;
2886 
2887 		if (local) {
2888 			if (ld_add_actrel(rflags, rsp, ofl) == S_ERROR)
2889 				return (S_ERROR);
2890 		} else {
2891 			if ((*ld_targ.t_mr.mr_add_outrel)(rflags, rsp, ofl) ==
2892 			    S_ERROR)
2893 				return (S_ERROR);
2894 		}
2895 	}
2896 
2897 	rsp->rel_rtype = ortype;
2898 
2899 	return (1);
2900 }
2901 
2902 /*
2903  * Move Section related function
2904  */
2905 static void
newroffset_for_move(Sym_desc * sdp,Move * mvp,Xword offset1,Xword * offset2)2906 newroffset_for_move(Sym_desc *sdp, Move *mvp, Xword offset1, Xword *offset2)
2907 {
2908 	Mv_desc		*mdp;
2909 	Aliste		idx;
2910 
2911 	/*
2912 	 * Search for matching move entry.
2913 	 */
2914 	for (ALIST_TRAVERSE(sdp->sd_move, idx, mdp)) {
2915 		if (mdp->md_move == mvp) {
2916 			/*
2917 			 * Update r_offset
2918 			 */
2919 			*offset2 = (Xword)((mdp->md_oidx - 1) * sizeof (Move) +
2920 			    offset1 % sizeof (Move));
2921 			return;
2922 		}
2923 	}
2924 }
2925 
2926 void
ld_adj_movereloc(Ofl_desc * ofl,Rel_desc * arsp)2927 ld_adj_movereloc(Ofl_desc *ofl, Rel_desc *arsp)
2928 {
2929 	Move		*move = arsp->rel_aux->ra_move->mr_move;
2930 	Sym_desc	*psdp = arsp->rel_aux->ra_move->mr_sym;
2931 	Xword		newoffset;
2932 
2933 	if (arsp->rel_flags & FLG_REL_MOVETAB) {
2934 		/*
2935 		 * We are relocating the move table itself.
2936 		 */
2937 		newroffset_for_move(psdp, move, arsp->rel_roffset,
2938 		    &newoffset);
2939 		DBG_CALL(Dbg_move_adjmovereloc(ofl->ofl_lml, arsp->rel_roffset,
2940 		    newoffset, psdp->sd_name));
2941 		arsp->rel_roffset = newoffset;
2942 	} else {
2943 		/*
2944 		 * We are expanding the partial symbol.  So we are generating
2945 		 * the relocation entry relocating the expanded partial symbol.
2946 		 */
2947 		arsp->rel_roffset += psdp->sd_sym->st_value -
2948 		    ofl->ofl_isparexpn->is_osdesc->os_shdr->sh_addr;
2949 		DBG_CALL(Dbg_move_adjexpandreloc(ofl->ofl_lml,
2950 		    arsp->rel_roffset, psdp->sd_name));
2951 	}
2952 }
2953 
2954 /*
2955  * Partially Initialized Symbol Handling routines
2956  * For RELA architecture, the second argument is reld->rel_raddend.  For REL
2957  * architecure, the second argument is the value stored at the relocation
2958  * target address.
2959  */
2960 Sym_desc *
ld_am_I_partial(Rel_desc * reld,Xword val)2961 ld_am_I_partial(Rel_desc *reld, Xword val)
2962 {
2963 	Ifl_desc	*ifile = reld->rel_sym->sd_isc->is_file;
2964 	int		nlocs = ifile->ifl_locscnt, i;
2965 
2966 	for (i = 1; i < nlocs; i++) {
2967 		Sym		*osym;
2968 		Sym_desc	*symd = ifile->ifl_oldndx[i];
2969 
2970 		if ((osym = symd->sd_osym) == 0)
2971 			continue;
2972 		if ((symd->sd_flags & FLG_SY_PAREXPN) == 0)
2973 			continue;
2974 		if ((osym->st_value <= val) &&
2975 		    (osym->st_value + osym->st_size > val))
2976 			return (symd);
2977 	}
2978 	return (NULL);
2979 }
2980 
2981 /*
2982  * Return True (1) if the code processing the given relocation
2983  * needs to perform byte swapping when accessing the section data.
2984  */
2985 int
ld_swap_reloc_data(Ofl_desc * ofl,Rel_desc * rsp)2986 ld_swap_reloc_data(Ofl_desc *ofl, Rel_desc *rsp)
2987 {
2988 	/*
2989 	 * In a cross-link situation where the linker host and target
2990 	 * have opposite byte orders, it can be necessary to swap bytes
2991 	 * when doing relocation processing. This is indicated by the
2992 	 * presence of the FLG_OF1_ENCDIFF flag bit. However, swapping
2993 	 * is only needed for the section types that libelf doesn't
2994 	 * automatically xlate.
2995 	 */
2996 	if ((ofl->ofl_flags1 & FLG_OF1_ENCDIFF) != 0) {
2997 		switch (RELAUX_GET_OSDESC(rsp)->os_shdr->sh_type) {
2998 		case SHT_PROGBITS:
2999 			return (1);
3000 
3001 		case SHT_SPARC_GOTDATA:
3002 			if (ld_targ.t_m.m_mach ==
3003 			    LD_TARG_BYCLASS(EM_SPARC, EM_SPARCV9))
3004 				return (1);
3005 			break;
3006 
3007 		case SHT_AMD64_UNWIND:
3008 			if (ld_targ.t_m.m_mach == EM_AMD64)
3009 				return (1);
3010 			break;
3011 		}
3012 	}
3013 
3014 	/*
3015 	 * If FLG_OF1_ENCDIFF isn't set, or the section isn't
3016 	 * progbits (or similar), then no swapping is needed.
3017 	 */
3018 	return (0);
3019 }
3020 
3021 
3022 
3023 /*
3024  * Obtain the current value at the given relocation target.
3025  *
3026  * entry:
3027  *	ofl - Output file descriptor
3028  *	rsp - Relocation record
3029  *	data - Pointer to relocation target
3030  *	value - Address of variable to recieve value
3031  *
3032  * exit:
3033  *	The value of the data at the relocation target has
3034  *	been stored in value.
3035  */
3036 int
ld_reloc_targval_get(Ofl_desc * ofl,Rel_desc * rsp,uchar_t * data,Xword * value)3037 ld_reloc_targval_get(Ofl_desc *ofl, Rel_desc *rsp, uchar_t *data, Xword *value)
3038 {
3039 	const Rel_entry	*rep;
3040 
3041 	rep = &ld_targ.t_mr.mr_reloc_table[rsp->rel_rtype];
3042 
3043 	switch (rep->re_fsize) {
3044 	case 1:
3045 		/* LINTED */
3046 		*value = (Xword) *((uchar_t *)data);
3047 		break;
3048 	case 2:
3049 		{
3050 			Half	v;
3051 			uchar_t	*v_bytes = (uchar_t *)&v;
3052 
3053 			if (OFL_SWAP_RELOC_DATA(ofl, rsp)) {
3054 				UL_ASSIGN_BSWAP_HALF(v_bytes, data);
3055 			} else {
3056 				UL_ASSIGN_HALF(v_bytes, data);
3057 			}
3058 			*value = (Xword) v;
3059 		}
3060 		break;
3061 	case 4:
3062 		{
3063 			Word	v;
3064 			uchar_t	*v_bytes = (uchar_t *)&v;
3065 
3066 			if (OFL_SWAP_RELOC_DATA(ofl, rsp)) {
3067 				UL_ASSIGN_BSWAP_WORD(v_bytes, data);
3068 			} else {
3069 				UL_ASSIGN_WORD(v_bytes, data);
3070 			}
3071 			*value = (Xword) v;
3072 		}
3073 		break;
3074 	default:
3075 		{
3076 			Conv_inv_buf_t inv_buf;
3077 			ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_REL_UNSUPSZ),
3078 			    conv_reloc_type(ld_targ.t_m.m_mach, rsp->rel_rtype,
3079 			    0, &inv_buf), rsp->rel_isdesc->is_file->ifl_name,
3080 			    ld_reloc_sym_name(rsp), (int)rep->re_fsize);
3081 		}
3082 		return (0);
3083 	}
3084 	return (1);
3085 }
3086 
3087 
3088 /*
3089  * Set the value at the given relocation target.
3090  *
3091  * entry:
3092  *	ofl - Output file descriptor
3093  *	rsp - Relocation record
3094  *	data - Pointer to relocation target
3095  *	value - Address of variable to recieve value
3096  *
3097  * exit:
3098  *	The value of the data at the relocation target has
3099  *	been stored in value.
3100  */
3101 int
ld_reloc_targval_set(Ofl_desc * ofl,Rel_desc * rsp,uchar_t * data,Xword value)3102 ld_reloc_targval_set(Ofl_desc *ofl, Rel_desc *rsp, uchar_t *data, Xword value)
3103 {
3104 	const Rel_entry	*rep;
3105 
3106 	rep = &ld_targ.t_mr.mr_reloc_table[rsp->rel_rtype];
3107 
3108 	switch (rep->re_fsize) {
3109 	case 1:
3110 		/* LINTED */
3111 		*((uchar_t *)data) = (uchar_t)value;
3112 		break;
3113 	case 2:
3114 		{
3115 			Half	v = (Half)value;
3116 			uchar_t	*v_bytes = (uchar_t *)&v;
3117 
3118 			if (OFL_SWAP_RELOC_DATA(ofl, rsp)) {
3119 				UL_ASSIGN_BSWAP_HALF(data, v_bytes);
3120 			} else {
3121 				UL_ASSIGN_HALF(data, v_bytes);
3122 			}
3123 		}
3124 		break;
3125 	case 4:
3126 		{
3127 			Word	v = (Word)value;
3128 			uchar_t	*v_bytes = (uchar_t *)&v;
3129 
3130 			if (OFL_SWAP_RELOC_DATA(ofl, rsp)) {
3131 				UL_ASSIGN_BSWAP_WORD(data, v_bytes);
3132 			} else {
3133 				UL_ASSIGN_WORD(data, v_bytes);
3134 			}
3135 		}
3136 		break;
3137 	default:
3138 		{
3139 			Conv_inv_buf_t inv_buf;
3140 			ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_REL_UNSUPSZ),
3141 			    conv_reloc_type(ld_targ.t_m.m_mach, rsp->rel_rtype,
3142 			    0, &inv_buf), rsp->rel_isdesc->is_file->ifl_name,
3143 			    ld_reloc_sym_name(rsp), (int)rep->re_fsize);
3144 		}
3145 		return (0);
3146 	}
3147 	return (1);
3148 }
3149 
3150 
3151 /*
3152  * Because of the combinations of 32-bit lib providing 64-bit support, and
3153  * visa-versa, the use of krtld's dorelocs can result in differing message
3154  * requirements that make msg.c/msg.h creation and chkmsg "interesting".
3155  * Thus the actual message files contain a couple of entries to satisfy
3156  * each architectures build.  Here we add dummy calls to quieten chkmsg.
3157  *
3158  * chkmsg: MSG_INTL(MSG_REL_NOFIT)
3159  * chkmsg: MSG_INTL(MSG_REL_NONALIGN)
3160  */
3161