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