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
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
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 *
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
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
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
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 *
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
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 *
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
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
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
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 *
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
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
834 ld_bswap_Word(Word v)
835 {
836 return (BSWAP_WORD(v));
837 }
838
839
840 Xword
841 ld_bswap_Xword(Xword v)
842 {
843 return (BSWAP_XWORD(v));
844 }
845
846
847 uintptr_t
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(NULL, rsp, ofl));
927 }
928
929 /*
930 * Perform relocations for PLT's
931 */
932 uintptr_t
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(NULL, 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
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
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)(NULL, 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(NULL, 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(NULL, rsp, ofl));
1068 else
1069 return ((*ld_targ.t_mr.mr_add_outrel)(NULL, 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)(NULL, 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(NULL, 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
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)(NULL, rsp, ofl));
1306
1307 /*
1308 * Otherwise process relocation now.
1309 */
1310 return (ld_add_actrel(NULL, 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
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 = NULL;
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(NULL, 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(NULL, 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
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
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)(NULL, 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 *
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
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
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
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 *
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
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
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
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
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
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
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
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
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
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
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 *
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
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
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
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 */