Print this page
10366 ld(1) should support GNU-style linker sets
10367 ld(1) tests should be a real test suite
10368 want an ld(1) regression test for i386 LD tls transition (10267)
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/cmd/sgs/libld/common/update.c
+++ new/usr/src/cmd/sgs/libld/common/update.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
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 27 */
28 28
29 29 /*
30 30 * Update the new output file image, perform virtual address, offset and
31 31 * displacement calculations on the program headers and sections headers,
32 32 * and generate any new output section information.
33 33 */
34 34
35 35 #define ELF_TARGET_AMD64
36 36
37 37 #include <stdio.h>
38 38 #include <string.h>
39 39 #include <unistd.h>
40 40 #include <debug.h>
41 41 #include "msg.h"
42 42 #include "_libld.h"
43 43
44 44 /*
45 45 * Comparison routine used by qsort() for sorting of the global symbol list
46 46 * based off of the hashbuckets the symbol will eventually be deposited in.
47 47 */
48 48 static int
49 49 sym_hash_compare(Sym_s_list * s1, Sym_s_list * s2)
50 50 {
51 51 return (s1->sl_hval - s2->sl_hval);
52 52 }
53 53
54 54 /*
55 55 * Comparison routine used by qsort() for sorting of dyn[sym|tls]sort section
56 56 * indices based on the address of the symbols they reference. The
57 57 * use of the global dynsort_compare_syms variable is needed because
58 58 * we need to examine the symbols the indices reference. It is safe, because
59 59 * the linker is single threaded.
60 60 */
61 61 Sym *dynsort_compare_syms;
62 62
63 63 static int
64 64 dynsort_compare(const void *idx1, const void *idx2)
65 65 {
66 66 Sym *s1 = dynsort_compare_syms + *((const Word *) idx1);
67 67 Sym *s2 = dynsort_compare_syms + *((const Word *) idx2);
68 68
69 69 /*
70 70 * Note: the logical computation for this is
71 71 * (st_value1 - st_value2)
72 72 * However, that is only correct if the address type is smaller
73 73 * than a pointer. Writing it this way makes it immune to the
74 74 * class (32 or 64-bit) of the linker.
75 75 */
76 76 return ((s1->st_value < s2->st_value) ? -1 :
77 77 (s1->st_value > s2->st_value));
78 78 }
79 79
80 80 /*
81 81 * Scan the sorted symbols, and issue warnings if there are any duplicate
82 82 * values in the list. We only do this if -zverbose is set, or we are
83 83 * running with LD_DEBUG defined
84 84 *
85 85 * entry:
86 86 * ofl - Output file descriptor
87 87 * ldynsym - Pointer to start of .SUNW_ldynsym section that the
88 88 * sort section indexes reference.
89 89 * symsort - Pointer to start of .SUNW_dynsymsort or .SUNW_dyntlssort
90 90 * section.
91 91 * n - # of indices in symsort array
92 92 * secname - Name of the symsort section.
93 93 *
94 94 * exit:
95 95 * If the symsort section contains indexes to more than one
96 96 * symbol with the same address value, a warning is issued.
97 97 */
98 98 static void
99 99 dynsort_dupwarn(Ofl_desc *ofl, Sym *ldynsym, const char *str,
100 100 Word *symsort, Word n, const char *secname)
101 101 {
102 102 int zverbose = (ofl->ofl_flags & FLG_OF_VERBOSE) != 0;
103 103 Word ndx, cmp_ndx;
104 104 Addr addr, cmp_addr;
105 105
106 106 /* Nothing to do if -zverbose or LD_DEBUG are not active */
107 107 if (!(zverbose || DBG_ENABLED))
108 108 return;
109 109
110 110 cmp_ndx = 0;
111 111 cmp_addr = ldynsym[symsort[cmp_ndx]].st_value;
112 112 for (ndx = 1; ndx < n; ndx++) {
113 113 addr = ldynsym[symsort[ndx]].st_value;
114 114 if (cmp_addr == addr) {
115 115 if (zverbose)
116 116 ld_eprintf(ofl, ERR_WARNING,
117 117 MSG_INTL(MSG_SYM_DUPSORTADDR), secname,
118 118 str + ldynsym[symsort[cmp_ndx]].st_name,
119 119 str + ldynsym[symsort[ndx]].st_name,
120 120 EC_ADDR(addr));
121 121 DBG_CALL(Dbg_syms_dup_sort_addr(ofl->ofl_lml, secname,
122 122 str + ldynsym[symsort[cmp_ndx]].st_name,
123 123 str + ldynsym[symsort[ndx]].st_name,
124 124 EC_ADDR(addr)));
125 125 } else { /* Not a dup. Move reference up */
126 126 cmp_ndx = ndx;
127 127 cmp_addr = addr;
128 128 }
129 129 }
130 130 }
131 131
132 132 /*
133 133 * Build and update any output symbol tables. Here we work on all the symbol
134 134 * tables at once to reduce the duplication of symbol and string manipulation.
135 135 * Symbols and their associated strings are copied from the read-only input
136 136 * file images to the output image and their values and index's updated in the
137 137 * output image.
138 138 */
139 139 static Addr
140 140 update_osym(Ofl_desc *ofl)
141 141 {
142 142 /*
143 143 * There are several places in this function where we wish
144 144 * to insert a symbol index to the combined .SUNW_ldynsym/.dynsym
145 145 * symbol table into one of the two sort sections (.SUNW_dynsymsort
146 146 * or .SUNW_dyntlssort), if that symbol has the right attributes.
147 147 * This macro is used to generate the necessary code from a single
148 148 * specification.
149 149 *
150 150 * entry:
151 151 * _sdp, _sym, _type - As per DYNSORT_COUNT. See _libld.h
152 152 * _sym_ndx - Index that _sym will have in the combined
153 153 * .SUNW_ldynsym/.dynsym symbol table.
154 154 */
155 155 #define ADD_TO_DYNSORT(_sdp, _sym, _type, _sym_ndx) \
156 156 { \
157 157 Word *_dynsort_arr, *_dynsort_ndx; \
158 158 \
159 159 if (dynsymsort_symtype[_type]) { \
160 160 _dynsort_arr = dynsymsort; \
161 161 _dynsort_ndx = &dynsymsort_ndx; \
162 162 } else if (_type == STT_TLS) { \
163 163 _dynsort_arr = dyntlssort; \
164 164 _dynsort_ndx = &dyntlssort_ndx; \
165 165 } else { \
166 166 _dynsort_arr = NULL; \
167 167 } \
168 168 if ((_dynsort_arr != NULL) && DYNSORT_TEST_ATTR(_sdp, _sym)) \
169 169 _dynsort_arr[(*_dynsort_ndx)++] = _sym_ndx; \
170 170 }
171 171
172 172 Sym_desc *sdp;
173 173 Sym_avlnode *sav;
174 174 Sg_desc *sgp, *tsgp = NULL, *dsgp = NULL, *esgp = NULL;
175 175 Os_desc *osp, *iosp = NULL, *fosp = NULL;
176 176 Is_desc *isc;
|
↓ open down ↓ |
176 lines elided |
↑ open up ↑ |
177 177 Ifl_desc *ifl;
178 178 Word bssndx, etext_ndx, edata_ndx = 0, end_ndx, start_ndx;
179 179 Word end_abs = 0, etext_abs = 0, edata_abs;
180 180 Word tlsbssndx = 0, parexpnndx;
181 181 #if defined(_ELF64)
182 182 Word lbssndx = 0;
183 183 Addr lbssaddr = 0;
184 184 #endif
185 185 Addr bssaddr, etext = 0, edata = 0, end = 0, start = 0;
186 186 Addr tlsbssaddr = 0;
187 - Addr parexpnbase, parexpnaddr;
187 + Addr parexpnbase, parexpnaddr;
188 188 int start_set = 0;
189 189 Sym _sym = {0}, *sym, *symtab = NULL;
190 190 Sym *dynsym = NULL, *ldynsym = NULL;
191 191 Word symtab_ndx = 0; /* index into .symtab */
192 192 Word symtab_gbl_bndx; /* .symtab ndx 1st global */
193 193 Word ldynsym_ndx = 0; /* index into .SUNW_ldynsym */
194 194 Word dynsym_ndx = 0; /* index into .dynsym */
195 195 Word scopesym_ndx = 0; /* index into scoped symbols */
196 196 Word scopesym_bndx = 0; /* .symtab ndx 1st scoped sym */
197 197 Word ldynscopesym_ndx = 0; /* index to ldynsym scoped */
198 198 /* symbols */
199 199 Word *dynsymsort = NULL; /* SUNW_dynsymsort index */
200 200 /* vector */
201 201 Word *dyntlssort = NULL; /* SUNW_dyntlssort index */
202 202 /* vector */
203 203 Word dynsymsort_ndx; /* index dynsymsort array */
204 204 Word dyntlssort_ndx; /* index dyntlssort array */
205 205 Word *symndx; /* symbol index (for */
206 206 /* relocation use) */
207 207 Word *symshndx = NULL; /* .symtab_shndx table */
208 208 Word *dynshndx = NULL; /* .dynsym_shndx table */
209 209 Word *ldynshndx = NULL; /* .SUNW_ldynsym_shndx table */
210 210 Word ldynsym_cnt = NULL; /* number of items in */
211 211 /* .SUNW_ldynsym */
212 212 Str_tbl *shstrtab;
213 213 Str_tbl *strtab;
214 214 Str_tbl *dynstr;
215 215 Word *hashtab; /* hash table pointer */
216 216 Word *hashbkt; /* hash table bucket pointer */
217 217 Word *hashchain; /* hash table chain pointer */
218 218 Wk_desc *wkp;
219 219 Alist *weak = NULL;
220 220 ofl_flag_t flags = ofl->ofl_flags;
221 221 Versym *versym;
222 222 Gottable *gottable; /* used for display got debugging */
223 223 /* information */
224 224 Syminfo *syminfo;
225 225 Sym_s_list *sorted_syms; /* table to hold sorted symbols */
226 226 Word ssndx; /* global index into sorted_syms */
227 227 Word scndx; /* scoped index into sorted_syms */
228 228 size_t stoff; /* string offset */
229 229 Aliste idx1;
230 230
231 231 /*
232 232 * Initialize pointers to the symbol table entries and the symbol
233 233 * table strings. Skip the first symbol entry and the first string
234 234 * table byte. Note that if we are not generating any output symbol
235 235 * tables we must still generate and update internal copies so
236 236 * that the relocation phase has the correct information.
237 237 */
238 238 if (!(flags & FLG_OF_STRIP) || (flags & FLG_OF_RELOBJ) ||
239 239 ((flags & FLG_OF_STATIC) && ofl->ofl_osversym)) {
240 240 symtab = (Sym *)ofl->ofl_ossymtab->os_outdata->d_buf;
241 241 symtab[symtab_ndx++] = _sym;
242 242 if (ofl->ofl_ossymshndx)
243 243 symshndx =
244 244 (Word *)ofl->ofl_ossymshndx->os_outdata->d_buf;
245 245 }
246 246 if (OFL_ALLOW_DYNSYM(ofl)) {
247 247 dynsym = (Sym *)ofl->ofl_osdynsym->os_outdata->d_buf;
248 248 dynsym[dynsym_ndx++] = _sym;
249 249 /*
250 250 * If we are also constructing a .SUNW_ldynsym section
251 251 * to contain local function symbols, then set it up too.
252 252 */
253 253 if (ofl->ofl_osldynsym) {
254 254 ldynsym = (Sym *)ofl->ofl_osldynsym->os_outdata->d_buf;
255 255 ldynsym[ldynsym_ndx++] = _sym;
256 256 ldynsym_cnt = 1 + ofl->ofl_dynlocscnt +
257 257 ofl->ofl_dynscopecnt;
258 258
259 259 /*
260 260 * If there is a SUNW_ldynsym, then there may also
261 261 * be a .SUNW_dynsymsort and/or .SUNW_dyntlssort
262 262 * sections, used to collect indices of function
263 263 * and data symbols sorted by address order.
264 264 */
265 265 if (ofl->ofl_osdynsymsort) { /* .SUNW_dynsymsort */
266 266 dynsymsort = (Word *)
267 267 ofl->ofl_osdynsymsort->os_outdata->d_buf;
268 268 dynsymsort_ndx = 0;
269 269 }
270 270 if (ofl->ofl_osdyntlssort) { /* .SUNW_dyntlssort */
271 271 dyntlssort = (Word *)
272 272 ofl->ofl_osdyntlssort->os_outdata->d_buf;
273 273 dyntlssort_ndx = 0;
274 274 }
275 275 }
276 276
277 277 /*
278 278 * Initialize the hash table.
279 279 */
280 280 hashtab = (Word *)(ofl->ofl_oshash->os_outdata->d_buf);
281 281 hashbkt = &hashtab[2];
282 282 hashchain = &hashtab[2 + ofl->ofl_hashbkts];
283 283 hashtab[0] = ofl->ofl_hashbkts;
284 284 hashtab[1] = DYNSYM_ALL_CNT(ofl);
285 285 if (ofl->ofl_osdynshndx)
286 286 dynshndx =
287 287 (Word *)ofl->ofl_osdynshndx->os_outdata->d_buf;
288 288 if (ofl->ofl_osldynshndx)
289 289 ldynshndx =
290 290 (Word *)ofl->ofl_osldynshndx->os_outdata->d_buf;
291 291 }
292 292
293 293 /*
294 294 * symndx is the symbol index to be used for relocation processing. It
295 295 * points to the relevant symtab's (.dynsym or .symtab) symbol ndx.
296 296 */
297 297 if (dynsym)
298 298 symndx = &dynsym_ndx;
299 299 else
300 300 symndx = &symtab_ndx;
301 301
302 302 /*
303 303 * If we have version definitions initialize the version symbol index
304 304 * table. There is one entry for each symbol which contains the symbols
305 305 * version index.
306 306 */
307 307 if (!(flags & FLG_OF_NOVERSEC) &&
308 308 (flags & (FLG_OF_VERNEED | FLG_OF_VERDEF))) {
309 309 versym = (Versym *)ofl->ofl_osversym->os_outdata->d_buf;
310 310 versym[0] = NULL;
311 311 } else
312 312 versym = NULL;
313 313
314 314 /*
315 315 * If syminfo section exists be prepared to fill it in.
316 316 */
317 317 if (ofl->ofl_ossyminfo) {
318 318 syminfo = ofl->ofl_ossyminfo->os_outdata->d_buf;
319 319 syminfo[0].si_flags = SYMINFO_CURRENT;
320 320 } else
321 321 syminfo = NULL;
322 322
323 323 /*
324 324 * Setup our string tables.
325 325 */
326 326 shstrtab = ofl->ofl_shdrsttab;
327 327 strtab = ofl->ofl_strtab;
328 328 dynstr = ofl->ofl_dynstrtab;
329 329
330 330 DBG_CALL(Dbg_syms_sec_title(ofl->ofl_lml));
331 331
332 332 /*
333 333 * Put output file name to the first .symtab and .SUNW_ldynsym symbol.
334 334 */
335 335 if (symtab) {
336 336 (void) st_setstring(strtab, ofl->ofl_name, &stoff);
337 337 sym = &symtab[symtab_ndx++];
338 338 /* LINTED */
339 339 sym->st_name = stoff;
340 340 sym->st_value = 0;
341 341 sym->st_size = 0;
342 342 sym->st_info = ELF_ST_INFO(STB_LOCAL, STT_FILE);
343 343 sym->st_other = 0;
344 344 sym->st_shndx = SHN_ABS;
345 345
346 346 if (versym && !dynsym)
347 347 versym[1] = 0;
348 348 }
349 349 if (ldynsym) {
350 350 (void) st_setstring(dynstr, ofl->ofl_name, &stoff);
351 351 sym = &ldynsym[ldynsym_ndx];
352 352 /* LINTED */
353 353 sym->st_name = stoff;
354 354 sym->st_value = 0;
355 355 sym->st_size = 0;
356 356 sym->st_info = ELF_ST_INFO(STB_LOCAL, STT_FILE);
357 357 sym->st_other = 0;
358 358 sym->st_shndx = SHN_ABS;
359 359
360 360 /* Scoped symbols get filled in global loop below */
361 361 ldynscopesym_ndx = ldynsym_ndx + 1;
362 362 ldynsym_ndx += ofl->ofl_dynscopecnt;
363 363 }
364 364
365 365 /*
366 366 * If we are to display GOT summary information, then allocate
367 367 * the buffer to 'cache' the GOT symbols into now.
368 368 */
369 369 if (DBG_ENABLED) {
370 370 if ((ofl->ofl_gottable = gottable =
371 371 libld_calloc(ofl->ofl_gotcnt, sizeof (Gottable))) == NULL)
372 372 return ((Addr)S_ERROR);
373 373 }
374 374
375 375 /*
376 376 * Traverse the program headers. Determine the last executable segment
377 377 * and the last data segment so that we can update etext and edata. If
378 378 * we have empty segments (reservations) record them for setting _end.
379 379 */
380 380 for (APLIST_TRAVERSE(ofl->ofl_segs, idx1, sgp)) {
381 381 Phdr *phd = &(sgp->sg_phdr);
382 382 Os_desc *osp;
383 383 Aliste idx2;
384 384
385 385 if (phd->p_type == PT_LOAD) {
386 386 if (sgp->sg_osdescs != NULL) {
387 387 Word _flags = phd->p_flags & (PF_W | PF_R);
388 388
389 389 if (_flags == PF_R)
390 390 tsgp = sgp;
391 391 else if (_flags == (PF_W | PF_R))
392 392 dsgp = sgp;
393 393 } else if (sgp->sg_flags & FLG_SG_EMPTY)
394 394 esgp = sgp;
395 395 }
396 396
397 397 /*
398 398 * Generate a section symbol for each output section.
399 399 */
400 400 for (APLIST_TRAVERSE(sgp->sg_osdescs, idx2, osp)) {
401 401 Word sectndx;
402 402
403 403 sym = &_sym;
404 404 sym->st_value = osp->os_shdr->sh_addr;
405 405 sym->st_info = ELF_ST_INFO(STB_LOCAL, STT_SECTION);
406 406 /* LINTED */
407 407 sectndx = elf_ndxscn(osp->os_scn);
408 408
409 409 if (symtab) {
410 410 if (sectndx >= SHN_LORESERVE) {
411 411 symshndx[symtab_ndx] = sectndx;
412 412 sym->st_shndx = SHN_XINDEX;
413 413 } else {
414 414 /* LINTED */
415 415 sym->st_shndx = (Half)sectndx;
416 416 }
417 417 symtab[symtab_ndx++] = *sym;
418 418 }
419 419
420 420 if (dynsym && (osp->os_flags & FLG_OS_OUTREL))
421 421 dynsym[dynsym_ndx++] = *sym;
422 422
423 423 if ((dynsym == NULL) ||
424 424 (osp->os_flags & FLG_OS_OUTREL)) {
425 425 if (versym)
426 426 versym[*symndx - 1] = 0;
427 427 osp->os_identndx = *symndx - 1;
428 428 DBG_CALL(Dbg_syms_sec_entry(ofl->ofl_lml,
429 429 osp->os_identndx, sgp, osp));
430 430 }
431 431
432 432 /*
433 433 * Generate the .shstrtab for this section.
434 434 */
435 435 (void) st_setstring(shstrtab, osp->os_name, &stoff);
436 436 osp->os_shdr->sh_name = (Word)stoff;
437 437
438 438 /*
439 439 * Find the section index for our special symbols.
440 440 */
441 441 if (sgp == tsgp) {
442 442 /* LINTED */
443 443 etext_ndx = elf_ndxscn(osp->os_scn);
444 444 } else if (dsgp == sgp) {
445 445 if (osp->os_shdr->sh_type != SHT_NOBITS) {
446 446 /* LINTED */
447 447 edata_ndx = elf_ndxscn(osp->os_scn);
448 448 }
449 449 }
450 450
451 451 if (start_set == 0) {
452 452 start = sgp->sg_phdr.p_vaddr;
453 453 /* LINTED */
454 454 start_ndx = elf_ndxscn(osp->os_scn);
455 455 start_set++;
456 456 }
457 457
458 458 /*
459 459 * While we're here, determine whether a .init or .fini
460 460 * section exist.
461 461 */
462 462 if ((iosp == NULL) && (strcmp(osp->os_name,
463 463 MSG_ORIG(MSG_SCN_INIT)) == 0))
464 464 iosp = osp;
465 465 if ((fosp == NULL) && (strcmp(osp->os_name,
466 466 MSG_ORIG(MSG_SCN_FINI)) == 0))
467 467 fosp = osp;
468 468 }
469 469 }
470 470
471 471 /*
472 472 * Add local register symbols to the .dynsym. These are required as
473 473 * DT_REGISTER .dynamic entries must have a symbol to reference.
474 474 */
475 475 if (ofl->ofl_regsyms && dynsym) {
476 476 int ndx;
477 477
478 478 for (ndx = 0; ndx < ofl->ofl_regsymsno; ndx++) {
479 479 Sym_desc *rsdp;
480 480
481 481 if ((rsdp = ofl->ofl_regsyms[ndx]) == NULL)
482 482 continue;
483 483
484 484 if (!SYM_IS_HIDDEN(rsdp) &&
485 485 (ELF_ST_BIND(rsdp->sd_sym->st_info) != STB_LOCAL))
486 486 continue;
487 487
488 488 dynsym[dynsym_ndx] = *(rsdp->sd_sym);
489 489 rsdp->sd_symndx = *symndx;
490 490
491 491 if (dynsym[dynsym_ndx].st_name) {
492 492 (void) st_setstring(dynstr, rsdp->sd_name,
493 493 &stoff);
494 494 dynsym[dynsym_ndx].st_name = stoff;
495 495 }
496 496 dynsym_ndx++;
497 497 }
498 498 }
499 499
500 500 /*
501 501 * Having traversed all the output segments, warn the user if the
502 502 * traditional text or data segments don't exist. Otherwise from these
503 503 * segments establish the values for `etext', `edata', `end', `END',
504 504 * and `START'.
505 505 */
506 506 if (!(flags & FLG_OF_RELOBJ)) {
507 507 Sg_desc *sgp;
508 508
509 509 if (tsgp)
510 510 etext = tsgp->sg_phdr.p_vaddr + tsgp->sg_phdr.p_filesz;
511 511 else {
512 512 etext = (Addr)0;
513 513 etext_ndx = SHN_ABS;
514 514 etext_abs = 1;
515 515 if (flags & FLG_OF_VERBOSE)
516 516 ld_eprintf(ofl, ERR_WARNING,
517 517 MSG_INTL(MSG_UPD_NOREADSEG));
518 518 }
519 519 if (dsgp) {
520 520 edata = dsgp->sg_phdr.p_vaddr + dsgp->sg_phdr.p_filesz;
521 521 } else {
522 522 edata = (Addr)0;
523 523 edata_ndx = SHN_ABS;
524 524 edata_abs = 1;
525 525 if (flags & FLG_OF_VERBOSE)
526 526 ld_eprintf(ofl, ERR_WARNING,
527 527 MSG_INTL(MSG_UPD_NORDWRSEG));
528 528 }
529 529
530 530 if (dsgp == NULL) {
531 531 if (tsgp)
532 532 sgp = tsgp;
533 533 else
534 534 sgp = 0;
535 535 } else if (tsgp == NULL)
536 536 sgp = dsgp;
537 537 else if (dsgp->sg_phdr.p_vaddr > tsgp->sg_phdr.p_vaddr)
538 538 sgp = dsgp;
539 539 else if (dsgp->sg_phdr.p_vaddr < tsgp->sg_phdr.p_vaddr)
540 540 sgp = tsgp;
541 541 else {
542 542 /*
543 543 * One of the segments must be of zero size.
544 544 */
545 545 if (tsgp->sg_phdr.p_memsz)
546 546 sgp = tsgp;
547 547 else
548 548 sgp = dsgp;
549 549 }
550 550
551 551 if (esgp && (esgp->sg_phdr.p_vaddr > sgp->sg_phdr.p_vaddr))
552 552 sgp = esgp;
553 553
554 554 if (sgp) {
555 555 end = sgp->sg_phdr.p_vaddr + sgp->sg_phdr.p_memsz;
556 556
557 557 /*
558 558 * If the last loadable segment is a read-only segment,
559 559 * then the application which uses the symbol _end to
560 560 * find the beginning of writable heap area may cause
561 561 * segmentation violation. We adjust the value of the
562 562 * _end to skip to the next page boundary.
563 563 *
564 564 * 6401812 System interface which returs beginning
565 565 * heap would be nice.
566 566 * When the above RFE is implemented, the changes below
567 567 * could be changed in a better way.
568 568 */
569 569 if ((sgp->sg_phdr.p_flags & PF_W) == 0)
570 570 end = (Addr)S_ROUND(end, sysconf(_SC_PAGESIZE));
571 571
572 572 /*
573 573 * If we're dealing with a memory reservation there are
574 574 * no sections to establish an index for _end, so assign
575 575 * it as an absolute.
576 576 */
577 577 if (sgp->sg_osdescs != NULL) {
578 578 /*
579 579 * Determine the last section for this segment.
580 580 */
581 581 Os_desc *osp = sgp->sg_osdescs->apl_data
582 582 [sgp->sg_osdescs->apl_nitems - 1];
583 583
584 584 /* LINTED */
585 585 end_ndx = elf_ndxscn(osp->os_scn);
586 586 } else {
587 587 end_ndx = SHN_ABS;
588 588 end_abs = 1;
589 589 }
590 590 } else {
591 591 end = (Addr) 0;
592 592 end_ndx = SHN_ABS;
593 593 end_abs = 1;
594 594 ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_UPD_NOSEG));
595 595 }
596 596 }
597 597
598 598 /*
599 599 * Initialize the scoped symbol table entry point. This is for all
600 600 * the global symbols that have been scoped to locals and will be
601 601 * filled in during global symbol processing so that we don't have
602 602 * to traverse the globals symbol hash array more than once.
603 603 */
604 604 if (symtab) {
605 605 scopesym_bndx = symtab_ndx;
606 606 scopesym_ndx = scopesym_bndx;
607 607 symtab_ndx += ofl->ofl_scopecnt;
608 608 }
609 609
610 610 /*
611 611 * If expanding partially expanded symbols under '-z nopartial',
612 612 * prepare to do that.
613 613 */
614 614 if (ofl->ofl_isparexpn) {
615 615 osp = ofl->ofl_isparexpn->is_osdesc;
616 616 parexpnbase = parexpnaddr = (Addr)(osp->os_shdr->sh_addr +
617 617 ofl->ofl_isparexpn->is_indata->d_off);
618 618 /* LINTED */
619 619 parexpnndx = elf_ndxscn(osp->os_scn);
620 620 ofl->ofl_parexpnndx = osp->os_identndx;
621 621 }
622 622
623 623 /*
624 624 * If we are generating a .symtab collect all the local symbols,
625 625 * assigning a new virtual address or displacement (value).
626 626 */
627 627 for (APLIST_TRAVERSE(ofl->ofl_objs, idx1, ifl)) {
628 628 Xword lndx, local = ifl->ifl_locscnt;
629 629 Cap_desc *cdp = ifl->ifl_caps;
630 630
631 631 for (lndx = 1; lndx < local; lndx++) {
632 632 Gotndx *gnp;
633 633 uchar_t type;
634 634 Word *_symshndx;
635 635 int enter_in_symtab, enter_in_ldynsym;
636 636 int update_done;
637 637
638 638 sdp = ifl->ifl_oldndx[lndx];
639 639 sym = sdp->sd_sym;
640 640
641 641 /*
642 642 * Assign a got offset if necessary.
643 643 */
644 644 if ((ld_targ.t_mr.mr_assign_got != NULL) &&
645 645 (*ld_targ.t_mr.mr_assign_got)(ofl, sdp) == S_ERROR)
646 646 return ((Addr)S_ERROR);
647 647
648 648 if (DBG_ENABLED) {
649 649 Aliste idx2;
650 650
651 651 for (ALIST_TRAVERSE(sdp->sd_GOTndxs,
652 652 idx2, gnp)) {
653 653 gottable->gt_sym = sdp;
654 654 gottable->gt_gndx.gn_gotndx =
655 655 gnp->gn_gotndx;
656 656 gottable->gt_gndx.gn_addend =
657 657 gnp->gn_addend;
658 658 gottable++;
659 659 }
660 660 }
661 661
662 662 if ((type = ELF_ST_TYPE(sym->st_info)) == STT_SECTION)
663 663 continue;
664 664
665 665 /*
666 666 * Ignore any symbols that have been marked as invalid
667 667 * during input processing. Providing these aren't used
668 668 * for relocation they'll just be dropped from the
669 669 * output image.
670 670 */
671 671 if (sdp->sd_flags & FLG_SY_INVALID)
672 672 continue;
673 673
674 674 /*
675 675 * If the section that this symbol was associated
676 676 * with has been discarded - then we discard
677 677 * the local symbol along with it.
678 678 */
679 679 if (sdp->sd_flags & FLG_SY_ISDISC)
680 680 continue;
681 681
682 682 /*
683 683 * If this symbol is from a different file
684 684 * than the input descriptor we are processing,
685 685 * treat it as if it has FLG_SY_ISDISC set.
686 686 * This happens when sloppy_comdat_reloc()
687 687 * replaces a symbol to a discarded comdat section
688 688 * with an equivalent symbol from a different
689 689 * file. We only want to enter such a symbol
690 690 * once --- as part of the file that actually
691 691 * supplies it.
692 692 */
693 693 if (ifl != sdp->sd_file)
694 694 continue;
695 695
696 696 /*
697 697 * Generate an output symbol to represent this input
698 698 * symbol. Even if the symbol table is to be stripped
699 699 * we still need to update any local symbols that are
700 700 * used during relocation.
701 701 */
702 702 enter_in_symtab = symtab &&
703 703 (!(ofl->ofl_flags & FLG_OF_REDLSYM) ||
704 704 sdp->sd_move);
705 705 enter_in_ldynsym = ldynsym && sdp->sd_name &&
706 706 ldynsym_symtype[type] &&
707 707 !(ofl->ofl_flags & FLG_OF_REDLSYM);
708 708 _symshndx = NULL;
709 709
710 710 if (enter_in_symtab) {
711 711 if (!dynsym)
712 712 sdp->sd_symndx = *symndx;
713 713 symtab[symtab_ndx] = *sym;
714 714
715 715 /*
716 716 * Provided this isn't an unnamed register
717 717 * symbol, update its name.
718 718 */
719 719 if (((sdp->sd_flags & FLG_SY_REGSYM) == 0) ||
720 720 symtab[symtab_ndx].st_name) {
721 721 (void) st_setstring(strtab,
722 722 sdp->sd_name, &stoff);
723 723 symtab[symtab_ndx].st_name = stoff;
724 724 }
725 725 sdp->sd_flags &= ~FLG_SY_CLEAN;
726 726 if (symshndx)
727 727 _symshndx = &symshndx[symtab_ndx];
728 728 sdp->sd_sym = sym = &symtab[symtab_ndx++];
729 729
730 730 if ((sdp->sd_flags & FLG_SY_SPECSEC) &&
731 731 (sym->st_shndx == SHN_ABS) &&
732 732 !enter_in_ldynsym)
733 733 continue;
734 734 } else if (enter_in_ldynsym) {
735 735 /*
736 736 * Not using symtab, but we do have ldynsym
737 737 * available.
738 738 */
739 739 ldynsym[ldynsym_ndx] = *sym;
740 740 (void) st_setstring(dynstr, sdp->sd_name,
741 741 &stoff);
742 742 ldynsym[ldynsym_ndx].st_name = stoff;
743 743
744 744 sdp->sd_flags &= ~FLG_SY_CLEAN;
745 745 if (ldynshndx)
746 746 _symshndx = &ldynshndx[ldynsym_ndx];
747 747 sdp->sd_sym = sym = &ldynsym[ldynsym_ndx];
748 748 /* Add it to sort section if it qualifies */
749 749 ADD_TO_DYNSORT(sdp, sym, type, ldynsym_ndx);
750 750 ldynsym_ndx++;
751 751 } else { /* Not using symtab or ldynsym */
752 752 /*
753 753 * If this symbol requires modifying to provide
754 754 * for a relocation or move table update, make
755 755 * a copy of it.
756 756 */
757 757 if (!(sdp->sd_flags & FLG_SY_UPREQD) &&
758 758 !(sdp->sd_move))
759 759 continue;
760 760 if ((sdp->sd_flags & FLG_SY_SPECSEC) &&
761 761 (sym->st_shndx == SHN_ABS))
762 762 continue;
763 763
764 764 if (ld_sym_copy(sdp) == S_ERROR)
765 765 return ((Addr)S_ERROR);
766 766 sym = sdp->sd_sym;
767 767 }
768 768
769 769 /*
770 770 * Update the symbols contents if necessary.
771 771 */
772 772 update_done = 0;
773 773 if (type == STT_FILE) {
774 774 sdp->sd_shndx = sym->st_shndx = SHN_ABS;
775 775 sdp->sd_flags |= FLG_SY_SPECSEC;
776 776 update_done = 1;
777 777 }
778 778
779 779 /*
780 780 * If we are expanding the locally bound partially
781 781 * initialized symbols, then update the address here.
782 782 */
783 783 if (ofl->ofl_isparexpn &&
784 784 (sdp->sd_flags & FLG_SY_PAREXPN) && !update_done) {
785 785 sym->st_shndx = parexpnndx;
786 786 sdp->sd_isc = ofl->ofl_isparexpn;
787 787 sym->st_value = parexpnaddr;
788 788 parexpnaddr += sym->st_size;
789 789 if ((flags & FLG_OF_RELOBJ) == 0)
790 790 sym->st_value -= parexpnbase;
791 791 }
792 792
793 793 /*
794 794 * If this isn't an UNDEF symbol (ie. an input section
795 795 * is associated), update the symbols value and index.
796 796 */
797 797 if (((isc = sdp->sd_isc) != NULL) && !update_done) {
798 798 Word sectndx;
799 799
800 800 osp = isc->is_osdesc;
801 801 /* LINTED */
802 802 sym->st_value +=
803 803 (Off)_elf_getxoff(isc->is_indata);
804 804 if ((flags & FLG_OF_RELOBJ) == 0) {
805 805 sym->st_value += osp->os_shdr->sh_addr;
806 806 /*
807 807 * TLS symbols are relative to
808 808 * the TLS segment.
809 809 */
810 810 if ((type == STT_TLS) &&
811 811 (ofl->ofl_tlsphdr)) {
812 812 sym->st_value -=
813 813 ofl->ofl_tlsphdr->p_vaddr;
814 814 }
815 815 }
816 816 /* LINTED */
817 817 if ((sdp->sd_shndx = sectndx =
818 818 elf_ndxscn(osp->os_scn)) >= SHN_LORESERVE) {
819 819 if (_symshndx) {
820 820 *_symshndx = sectndx;
821 821 }
822 822 sym->st_shndx = SHN_XINDEX;
823 823 } else {
824 824 /* LINTED */
825 825 sym->st_shndx = sectndx;
826 826 }
827 827 }
828 828
829 829 /*
830 830 * If entering the symbol in both the symtab and the
831 831 * ldynsym, then the one in symtab needs to be
832 832 * copied to ldynsym. If it is only in the ldynsym,
833 833 * then the code above already set it up and we have
834 834 * nothing more to do here.
835 835 */
836 836 if (enter_in_symtab && enter_in_ldynsym) {
837 837 ldynsym[ldynsym_ndx] = *sym;
838 838 (void) st_setstring(dynstr, sdp->sd_name,
839 839 &stoff);
840 840 ldynsym[ldynsym_ndx].st_name = stoff;
841 841
842 842 if (_symshndx && ldynshndx)
843 843 ldynshndx[ldynsym_ndx] = *_symshndx;
844 844
845 845 /* Add it to sort section if it qualifies */
846 846 ADD_TO_DYNSORT(sdp, sym, type, ldynsym_ndx);
847 847
848 848 ldynsym_ndx++;
849 849 }
850 850 }
851 851
852 852 /*
853 853 * If this input file has undergone object to symbol
854 854 * capabilities conversion, supply any new capabilities symbols.
855 855 * These symbols are copies of the original global symbols, and
856 856 * follow the existing local symbols that are supplied from this
857 857 * input file (which are identified with a preceding STT_FILE).
858 858 */
859 859 if (symtab && cdp && cdp->ca_syms) {
860 860 Aliste idx2;
861 861 Cap_sym *csp;
862 862
863 863 for (APLIST_TRAVERSE(cdp->ca_syms, idx2, csp)) {
864 864 Is_desc *isp;
865 865
866 866 sdp = csp->cs_sdp;
867 867 sym = sdp->sd_sym;
868 868
869 869 if ((isp = sdp->sd_isc) != NULL) {
870 870 Os_desc *osp = isp->is_osdesc;
871 871
872 872 /*
873 873 * Update the symbols value.
874 874 */
875 875 /* LINTED */
876 876 sym->st_value +=
877 877 (Off)_elf_getxoff(isp->is_indata);
878 878 if ((flags & FLG_OF_RELOBJ) == 0)
879 879 sym->st_value +=
880 880 osp->os_shdr->sh_addr;
881 881
882 882 /*
883 883 * Update the symbols section index.
884 884 */
885 885 sdp->sd_shndx = sym->st_shndx =
886 886 elf_ndxscn(osp->os_scn);
887 887 }
888 888
889 889 symtab[symtab_ndx] = *sym;
890 890 (void) st_setstring(strtab, sdp->sd_name,
891 891 &stoff);
892 892 symtab[symtab_ndx].st_name = stoff;
893 893 sdp->sd_symndx = symtab_ndx++;
894 894 }
895 895 }
896 896 }
897 897
898 898 symtab_gbl_bndx = symtab_ndx; /* .symtab index of 1st global entry */
899 899
900 900 /*
901 901 * Two special symbols are `_init' and `_fini'. If these are supplied
902 902 * by crti.o then they are used to represent the total concatenation of
903 903 * the `.init' and `.fini' sections.
904 904 *
905 905 * Determine whether any .init or .fini sections exist. If these
906 906 * sections exist and a dynamic object is being built, but no `_init'
907 907 * or `_fini' symbols are found, then the user is probably building
908 908 * this object directly from ld(1) rather than using a compiler driver
909 909 * that provides the symbols via crt's.
910 910 *
911 911 * If the .init or .fini section exist, and their associated symbols,
912 912 * determine the size of the sections and updated the symbols value
913 913 * accordingly.
914 914 */
915 915 if (((sdp = ld_sym_find(MSG_ORIG(MSG_SYM_INIT_U), SYM_NOHASH, 0,
916 916 ofl)) != NULL) && (sdp->sd_ref == REF_REL_NEED) && sdp->sd_isc &&
917 917 (sdp->sd_isc->is_osdesc == iosp)) {
918 918 if (ld_sym_copy(sdp) == S_ERROR)
919 919 return ((Addr)S_ERROR);
920 920 sdp->sd_sym->st_size = sdp->sd_isc->is_osdesc->os_shdr->sh_size;
921 921
922 922 } else if (iosp && !(flags & FLG_OF_RELOBJ)) {
923 923 ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_SYM_NOCRT),
924 924 MSG_ORIG(MSG_SYM_INIT_U), MSG_ORIG(MSG_SCN_INIT));
925 925 }
926 926
927 927 if (((sdp = ld_sym_find(MSG_ORIG(MSG_SYM_FINI_U), SYM_NOHASH, 0,
928 928 ofl)) != NULL) && (sdp->sd_ref == REF_REL_NEED) && sdp->sd_isc &&
929 929 (sdp->sd_isc->is_osdesc == fosp)) {
930 930 if (ld_sym_copy(sdp) == S_ERROR)
931 931 return ((Addr)S_ERROR);
932 932 sdp->sd_sym->st_size = sdp->sd_isc->is_osdesc->os_shdr->sh_size;
933 933
934 934 } else if (fosp && !(flags & FLG_OF_RELOBJ)) {
935 935 ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_SYM_NOCRT),
936 936 MSG_ORIG(MSG_SYM_FINI_U), MSG_ORIG(MSG_SCN_FINI));
937 937 }
938 938
939 939 /*
940 940 * Assign .bss information for use with updating COMMON symbols.
941 941 */
942 942 if (ofl->ofl_isbss) {
943 943 isc = ofl->ofl_isbss;
944 944 osp = isc->is_osdesc;
945 945
946 946 bssaddr = osp->os_shdr->sh_addr +
947 947 (Off)_elf_getxoff(isc->is_indata);
948 948 /* LINTED */
949 949 bssndx = elf_ndxscn(osp->os_scn);
950 950 }
951 951
952 952 #if defined(_ELF64)
953 953 /*
954 954 * For amd64 target, assign .lbss information for use
955 955 * with updating LCOMMON symbols.
956 956 */
957 957 if ((ld_targ.t_m.m_mach == EM_AMD64) && ofl->ofl_islbss) {
958 958 osp = ofl->ofl_islbss->is_osdesc;
959 959
960 960 lbssaddr = osp->os_shdr->sh_addr +
961 961 (Off)_elf_getxoff(ofl->ofl_islbss->is_indata);
962 962 /* LINTED */
963 963 lbssndx = elf_ndxscn(osp->os_scn);
964 964 }
965 965 #endif
966 966 /*
967 967 * Assign .tlsbss information for use with updating COMMON symbols.
968 968 */
969 969 if (ofl->ofl_istlsbss) {
970 970 osp = ofl->ofl_istlsbss->is_osdesc;
971 971 tlsbssaddr = osp->os_shdr->sh_addr +
972 972 (Off)_elf_getxoff(ofl->ofl_istlsbss->is_indata);
973 973 /* LINTED */
974 974 tlsbssndx = elf_ndxscn(osp->os_scn);
975 975 }
976 976
977 977 if ((sorted_syms = libld_calloc(ofl->ofl_globcnt +
978 978 ofl->ofl_elimcnt + ofl->ofl_scopecnt,
979 979 sizeof (*sorted_syms))) == NULL)
980 980 return ((Addr)S_ERROR);
981 981
982 982 scndx = 0;
983 983 ssndx = ofl->ofl_scopecnt + ofl->ofl_elimcnt;
984 984
985 985 DBG_CALL(Dbg_syms_up_title(ofl->ofl_lml));
986 986
987 987 /*
988 988 * Traverse the internal symbol table updating global symbol information
989 989 * and allocating common.
990 990 */
991 991 for (sav = avl_first(&ofl->ofl_symavl); sav;
992 992 sav = AVL_NEXT(&ofl->ofl_symavl, sav)) {
993 993 Sym *symptr;
994 994 int local;
995 995 int restore;
996 996
997 997 sdp = sav->sav_sdp;
998 998
999 999 /*
1000 1000 * Ignore any symbols that have been marked as invalid during
1001 1001 * input processing. Providing these aren't used for
1002 1002 * relocation, they will be dropped from the output image.
1003 1003 */
1004 1004 if (sdp->sd_flags & FLG_SY_INVALID) {
1005 1005 DBG_CALL(Dbg_syms_old(ofl, sdp));
1006 1006 DBG_CALL(Dbg_syms_ignore(ofl, sdp));
1007 1007 continue;
1008 1008 }
1009 1009
1010 1010 /*
1011 1011 * Only needed symbols are copied to the output symbol table.
1012 1012 */
1013 1013 if (sdp->sd_ref == REF_DYN_SEEN)
1014 1014 continue;
1015 1015
1016 1016 if (SYM_IS_HIDDEN(sdp) && (flags & FLG_OF_PROCRED))
1017 1017 local = 1;
1018 1018 else
1019 1019 local = 0;
1020 1020
1021 1021 if (local || (ofl->ofl_hashbkts == 0)) {
1022 1022 sorted_syms[scndx++].sl_sdp = sdp;
1023 1023 } else {
1024 1024 sorted_syms[ssndx].sl_hval = sdp->sd_aux->sa_hash %
1025 1025 ofl->ofl_hashbkts;
1026 1026 sorted_syms[ssndx].sl_sdp = sdp;
1027 1027 ssndx++;
1028 1028 }
1029 1029
1030 1030 /*
1031 1031 * Note - expand the COMMON symbols here because an address
1032 1032 * must be assigned to them in the same order that space was
1033 1033 * calculated in sym_validate(). If this ordering isn't
1034 1034 * followed differing alignment requirements can throw us all
1035 1035 * out of whack.
1036 1036 *
1037 1037 * The expanded .bss global symbol is handled here as well.
1038 1038 *
1039 1039 * The actual adding entries into the symbol table still occurs
1040 1040 * below in hashbucket order.
1041 1041 */
1042 1042 symptr = sdp->sd_sym;
1043 1043 restore = 0;
1044 1044 if ((sdp->sd_flags & FLG_SY_PAREXPN) ||
1045 1045 ((sdp->sd_flags & FLG_SY_SPECSEC) &&
1046 1046 (sdp->sd_shndx = symptr->st_shndx) == SHN_COMMON)) {
1047 1047
1048 1048 /*
1049 1049 * An expanded symbol goes to a special .data section
1050 1050 * prepared for that purpose (ofl->ofl_isparexpn).
1051 1051 * Assign COMMON allocations to .bss.
1052 1052 * Otherwise leave it as is.
1053 1053 */
1054 1054 if (sdp->sd_flags & FLG_SY_PAREXPN) {
1055 1055 restore = 1;
1056 1056 sdp->sd_shndx = parexpnndx;
1057 1057 sdp->sd_flags &= ~FLG_SY_SPECSEC;
1058 1058 symptr->st_value = (Xword) S_ROUND(
1059 1059 parexpnaddr, symptr->st_value);
1060 1060 parexpnaddr = symptr->st_value +
1061 1061 symptr->st_size;
1062 1062 sdp->sd_isc = ofl->ofl_isparexpn;
1063 1063 sdp->sd_flags |= FLG_SY_COMMEXP;
1064 1064
1065 1065 } else if (ELF_ST_TYPE(symptr->st_info) != STT_TLS &&
1066 1066 (local || !(flags & FLG_OF_RELOBJ))) {
1067 1067 restore = 1;
1068 1068 sdp->sd_shndx = bssndx;
1069 1069 sdp->sd_flags &= ~FLG_SY_SPECSEC;
1070 1070 symptr->st_value = (Xword)S_ROUND(bssaddr,
1071 1071 symptr->st_value);
1072 1072 bssaddr = symptr->st_value + symptr->st_size;
1073 1073 sdp->sd_isc = ofl->ofl_isbss;
1074 1074 sdp->sd_flags |= FLG_SY_COMMEXP;
1075 1075
1076 1076 } else if (ELF_ST_TYPE(symptr->st_info) == STT_TLS &&
1077 1077 (local || !(flags & FLG_OF_RELOBJ))) {
1078 1078 restore = 1;
1079 1079 sdp->sd_shndx = tlsbssndx;
1080 1080 sdp->sd_flags &= ~FLG_SY_SPECSEC;
1081 1081 symptr->st_value = (Xword)S_ROUND(tlsbssaddr,
1082 1082 symptr->st_value);
1083 1083 tlsbssaddr = symptr->st_value + symptr->st_size;
1084 1084 sdp->sd_isc = ofl->ofl_istlsbss;
1085 1085 sdp->sd_flags |= FLG_SY_COMMEXP;
1086 1086 /*
1087 1087 * TLS symbols are relative to the TLS segment.
1088 1088 */
1089 1089 symptr->st_value -= ofl->ofl_tlsphdr->p_vaddr;
1090 1090 }
1091 1091 #if defined(_ELF64)
1092 1092 } else if ((ld_targ.t_m.m_mach == EM_AMD64) &&
1093 1093 (sdp->sd_flags & FLG_SY_SPECSEC) &&
1094 1094 ((sdp->sd_shndx = symptr->st_shndx) ==
1095 1095 SHN_X86_64_LCOMMON) &&
1096 1096 ((local || !(flags & FLG_OF_RELOBJ)))) {
1097 1097 restore = 1;
1098 1098 sdp->sd_shndx = lbssndx;
1099 1099 sdp->sd_flags &= ~FLG_SY_SPECSEC;
1100 1100 symptr->st_value = (Xword)S_ROUND(lbssaddr,
1101 1101 symptr->st_value);
1102 1102 lbssaddr = symptr->st_value + symptr->st_size;
1103 1103 sdp->sd_isc = ofl->ofl_islbss;
1104 1104 sdp->sd_flags |= FLG_SY_COMMEXP;
1105 1105 #endif
1106 1106 }
1107 1107
1108 1108 if (restore != 0) {
1109 1109 uchar_t type, bind;
1110 1110
1111 1111 /*
1112 1112 * Make sure this COMMON symbol is returned to the same
1113 1113 * binding as was defined in the original relocatable
1114 1114 * object reference.
1115 1115 */
1116 1116 type = ELF_ST_TYPE(symptr->st_info);
1117 1117 if (sdp->sd_flags & FLG_SY_GLOBREF)
1118 1118 bind = STB_GLOBAL;
1119 1119 else
1120 1120 bind = STB_WEAK;
1121 1121
1122 1122 symptr->st_info = ELF_ST_INFO(bind, type);
1123 1123 }
1124 1124 }
1125 1125
1126 1126 /*
1127 1127 * If this is a dynamic object then add any local capabilities symbols.
1128 1128 */
1129 1129 if (dynsym && ofl->ofl_capfamilies) {
1130 1130 Cap_avlnode *cav;
1131 1131
1132 1132 for (cav = avl_first(ofl->ofl_capfamilies); cav;
1133 1133 cav = AVL_NEXT(ofl->ofl_capfamilies, cav)) {
1134 1134 Cap_sym *csp;
1135 1135 Aliste idx;
1136 1136
1137 1137 for (APLIST_TRAVERSE(cav->cn_members, idx, csp)) {
1138 1138 sdp = csp->cs_sdp;
1139 1139
1140 1140 DBG_CALL(Dbg_syms_created(ofl->ofl_lml,
1141 1141 sdp->sd_name));
1142 1142 DBG_CALL(Dbg_syms_entered(ofl, sdp->sd_sym,
1143 1143 sdp));
1144 1144
1145 1145 dynsym[dynsym_ndx] = *sdp->sd_sym;
1146 1146
1147 1147 (void) st_setstring(dynstr, sdp->sd_name,
1148 1148 &stoff);
1149 1149 dynsym[dynsym_ndx].st_name = stoff;
1150 1150
1151 1151 sdp->sd_sym = &dynsym[dynsym_ndx];
1152 1152 sdp->sd_symndx = dynsym_ndx;
1153 1153
1154 1154 /*
1155 1155 * Indicate that this is a capabilities symbol.
1156 1156 * Note, that this identification only provides
1157 1157 * information regarding the symbol that is
1158 1158 * visible from elfdump(1) -y. The association
1159 1159 * of a symbol to its capabilities is derived
1160 1160 * from a .SUNW_capinfo entry.
1161 1161 */
1162 1162 if (syminfo) {
1163 1163 syminfo[dynsym_ndx].si_flags |=
1164 1164 SYMINFO_FLG_CAP;
1165 1165 }
1166 1166
1167 1167 dynsym_ndx++;
1168 1168 }
1169 1169 }
1170 1170 }
1171 1171
1172 1172 if (ofl->ofl_hashbkts) {
1173 1173 qsort(sorted_syms + ofl->ofl_scopecnt + ofl->ofl_elimcnt,
1174 1174 ofl->ofl_globcnt, sizeof (Sym_s_list),
1175 1175 (int (*)(const void *, const void *))sym_hash_compare);
1176 1176 }
1177 1177
1178 1178 for (ssndx = 0; ssndx < (ofl->ofl_elimcnt + ofl->ofl_scopecnt +
1179 1179 ofl->ofl_globcnt); ssndx++) {
1180 1180 const char *name;
1181 1181 Sym *sym;
1182 1182 Sym_aux *sap;
1183 1183 Half spec;
1184 1184 int local = 0, dynlocal = 0, enter_in_symtab;
1185 1185 Gotndx *gnp;
1186 1186 Word sectndx;
1187 1187
1188 1188 sdp = sorted_syms[ssndx].sl_sdp;
1189 1189 sectndx = 0;
1190 1190
1191 1191 if (symtab)
1192 1192 enter_in_symtab = 1;
1193 1193 else
1194 1194 enter_in_symtab = 0;
1195 1195
1196 1196 /*
1197 1197 * Assign a got offset if necessary.
1198 1198 */
1199 1199 if ((ld_targ.t_mr.mr_assign_got != NULL) &&
1200 1200 (*ld_targ.t_mr.mr_assign_got)(ofl, sdp) == S_ERROR)
1201 1201 return ((Addr)S_ERROR);
1202 1202
1203 1203 if (DBG_ENABLED) {
1204 1204 Aliste idx2;
1205 1205
1206 1206 for (ALIST_TRAVERSE(sdp->sd_GOTndxs, idx2, gnp)) {
1207 1207 gottable->gt_sym = sdp;
1208 1208 gottable->gt_gndx.gn_gotndx = gnp->gn_gotndx;
1209 1209 gottable->gt_gndx.gn_addend = gnp->gn_addend;
1210 1210 gottable++;
1211 1211 }
1212 1212
1213 1213 if (sdp->sd_aux && sdp->sd_aux->sa_PLTGOTndx) {
1214 1214 gottable->gt_sym = sdp;
1215 1215 gottable->gt_gndx.gn_gotndx =
1216 1216 sdp->sd_aux->sa_PLTGOTndx;
1217 1217 gottable++;
1218 1218 }
1219 1219 }
1220 1220
1221 1221 /*
1222 1222 * If this symbol has been marked as being reduced to local
1223 1223 * scope then it will have to be placed in the scoped portion
1224 1224 * of the .symtab. Retain the appropriate index for use in
1225 1225 * version symbol indexing and relocation.
1226 1226 */
1227 1227 if (SYM_IS_HIDDEN(sdp) && (flags & FLG_OF_PROCRED)) {
1228 1228 local = 1;
1229 1229 if (!(sdp->sd_flags & FLG_SY_ELIM) && !dynsym)
1230 1230 sdp->sd_symndx = scopesym_ndx;
1231 1231 else
1232 1232 sdp->sd_symndx = 0;
1233 1233
1234 1234 if (sdp->sd_flags & FLG_SY_ELIM) {
1235 1235 enter_in_symtab = 0;
1236 1236 } else if (ldynsym && sdp->sd_sym->st_name &&
1237 1237 ldynsym_symtype[
1238 1238 ELF_ST_TYPE(sdp->sd_sym->st_info)]) {
1239 1239 dynlocal = 1;
1240 1240 }
1241 1241 } else {
1242 1242 sdp->sd_symndx = *symndx;
1243 1243 }
1244 1244
1245 1245 /*
1246 1246 * Copy basic symbol and string information.
1247 1247 */
1248 1248 name = sdp->sd_name;
1249 1249 sap = sdp->sd_aux;
1250 1250
1251 1251 /*
1252 1252 * If we require to record version symbol indexes, update the
1253 1253 * associated version symbol information for all defined
1254 1254 * symbols. If a version definition is required any zero value
1255 1255 * symbol indexes would have been flagged as undefined symbol
1256 1256 * errors, however if we're just scoping these need to fall into
1257 1257 * the base of global symbols.
1258 1258 */
1259 1259 if (sdp->sd_symndx && versym) {
1260 1260 Half vndx = 0;
1261 1261
1262 1262 if (sdp->sd_flags & FLG_SY_MVTOCOMM) {
1263 1263 vndx = VER_NDX_GLOBAL;
1264 1264 } else if (sdp->sd_ref == REF_REL_NEED) {
1265 1265 vndx = sap->sa_overndx;
1266 1266
1267 1267 if ((vndx == 0) &&
1268 1268 (sdp->sd_sym->st_shndx != SHN_UNDEF)) {
1269 1269 if (SYM_IS_HIDDEN(sdp))
1270 1270 vndx = VER_NDX_LOCAL;
1271 1271 else
1272 1272 vndx = VER_NDX_GLOBAL;
1273 1273 }
1274 1274 } else if ((sdp->sd_ref == REF_DYN_NEED) &&
1275 1275 (sap->sa_dverndx > 0) &&
1276 1276 (sap->sa_dverndx <= sdp->sd_file->ifl_vercnt) &&
1277 1277 (sdp->sd_file->ifl_verndx != NULL)) {
1278 1278 /* Use index of verneed record */
1279 1279 vndx = sdp->sd_file->ifl_verndx
1280 1280 [sap->sa_dverndx].vi_overndx;
1281 1281 }
1282 1282 versym[sdp->sd_symndx] = vndx;
1283 1283 }
1284 1284
1285 1285 /*
1286 1286 * If we are creating the .syminfo section then set per symbol
1287 1287 * flags here.
1288 1288 */
1289 1289 if (sdp->sd_symndx && syminfo &&
1290 1290 !(sdp->sd_flags & FLG_SY_NOTAVAIL)) {
1291 1291 int ndx = sdp->sd_symndx;
1292 1292 APlist **alpp = &(ofl->ofl_symdtent);
1293 1293
1294 1294 if (sdp->sd_flags & FLG_SY_MVTOCOMM)
1295 1295 /*
1296 1296 * Identify a copy relocation symbol.
1297 1297 */
1298 1298 syminfo[ndx].si_flags |= SYMINFO_FLG_COPY;
1299 1299
1300 1300 if (sdp->sd_ref == REF_DYN_NEED) {
1301 1301 /*
1302 1302 * A reference is bound to a needed dependency.
1303 1303 * Save the syminfo entry, so that when the
1304 1304 * .dynamic section has been updated, a
1305 1305 * DT_NEEDED entry can be associated
1306 1306 * (see update_osyminfo()).
1307 1307 */
1308 1308 if (aplist_append(alpp, sdp,
1309 1309 AL_CNT_OFL_SYMINFOSYMS) == NULL)
1310 1310 return (0);
1311 1311
1312 1312 /*
1313 1313 * Flag that the symbol has a direct association
1314 1314 * with the external reference (this is an old
1315 1315 * tagging, that has no real effect by itself).
1316 1316 */
1317 1317 syminfo[ndx].si_flags |= SYMINFO_FLG_DIRECT;
1318 1318
1319 1319 /*
1320 1320 * Flag any lazy or deferred reference.
1321 1321 */
1322 1322 if (sdp->sd_flags & FLG_SY_LAZYLD)
1323 1323 syminfo[ndx].si_flags |=
1324 1324 SYMINFO_FLG_LAZYLOAD;
1325 1325 if (sdp->sd_flags & FLG_SY_DEFERRED)
|
↓ open down ↓ |
1128 lines elided |
↑ open up ↑ |
1326 1326 syminfo[ndx].si_flags |=
1327 1327 SYMINFO_FLG_DEFERRED;
1328 1328
1329 1329 /*
1330 1330 * Enable direct symbol bindings if:
1331 1331 *
1332 1332 * - Symbol was identified with the DIRECT
1333 1333 * keyword in a mapfile.
1334 1334 *
1335 1335 * - Symbol reference has been bound to a
1336 - * dependency which was specified as
1336 + * dependency which was specified as
1337 1337 * requiring direct bindings with -zdirect.
1338 1338 *
1339 1339 * - All symbol references are required to
1340 1340 * use direct bindings via -Bdirect.
1341 1341 */
1342 1342 if (sdp->sd_flags & FLG_SY_DIR)
1343 1343 syminfo[ndx].si_flags |=
1344 1344 SYMINFO_FLG_DIRECTBIND;
1345 1345
1346 1346 } else if ((sdp->sd_flags & FLG_SY_EXTERN) &&
1347 1347 (sdp->sd_sym->st_shndx == SHN_UNDEF)) {
1348 1348 /*
1349 1349 * If this symbol has been explicitly defined
1350 1350 * as external, and remains unresolved, mark
1351 1351 * it as external.
1352 1352 */
1353 1353 syminfo[ndx].si_boundto = SYMINFO_BT_EXTERN;
1354 1354
1355 1355 } else if ((sdp->sd_flags & FLG_SY_PARENT) &&
1356 1356 (sdp->sd_sym->st_shndx == SHN_UNDEF)) {
1357 1357 /*
1358 1358 * If this symbol has been explicitly defined
1359 1359 * to be a reference to a parent object,
1360 1360 * indicate whether a direct binding should be
1361 1361 * established.
1362 1362 */
1363 1363 syminfo[ndx].si_flags |= SYMINFO_FLG_DIRECT;
1364 1364 syminfo[ndx].si_boundto = SYMINFO_BT_PARENT;
1365 1365 if (sdp->sd_flags & FLG_SY_DIR)
1366 1366 syminfo[ndx].si_flags |=
1367 1367 SYMINFO_FLG_DIRECTBIND;
1368 1368
1369 1369 } else if (sdp->sd_flags & FLG_SY_STDFLTR) {
1370 1370 /*
1371 1371 * A filter definition. Although this symbol
1372 1372 * can only be a stub, it might be necessary to
1373 1373 * prevent external direct bindings.
1374 1374 */
1375 1375 syminfo[ndx].si_flags |= SYMINFO_FLG_FILTER;
1376 1376 if (sdp->sd_flags & FLG_SY_NDIR)
1377 1377 syminfo[ndx].si_flags |=
1378 1378 SYMINFO_FLG_NOEXTDIRECT;
1379 1379
1380 1380 } else if (sdp->sd_flags & FLG_SY_AUXFLTR) {
1381 1381 /*
1382 1382 * An auxiliary filter definition. By nature,
1383 1383 * this definition is direct, in that should the
1384 1384 * filtee lookup fail, we'll fall back to this
1385 1385 * object. It may still be necessary to
1386 1386 * prevent external direct bindings.
1387 1387 */
1388 1388 syminfo[ndx].si_flags |= SYMINFO_FLG_AUXILIARY;
1389 1389 if (sdp->sd_flags & FLG_SY_NDIR)
1390 1390 syminfo[ndx].si_flags |=
1391 1391 SYMINFO_FLG_NOEXTDIRECT;
1392 1392
1393 1393 } else if ((sdp->sd_ref == REF_REL_NEED) &&
1394 1394 (sdp->sd_sym->st_shndx != SHN_UNDEF)) {
1395 1395 /*
1396 1396 * This definition exists within the object
1397 1397 * being created. Provide a default boundto
1398 1398 * definition, which may be overridden later.
1399 1399 */
1400 1400 syminfo[ndx].si_boundto = SYMINFO_BT_NONE;
1401 1401
1402 1402 /*
1403 1403 * Indicate whether it is necessary to prevent
1404 1404 * external direct bindings.
1405 1405 */
1406 1406 if (sdp->sd_flags & FLG_SY_NDIR) {
1407 1407 syminfo[ndx].si_flags |=
1408 1408 SYMINFO_FLG_NOEXTDIRECT;
1409 1409 }
1410 1410
1411 1411 /*
1412 1412 * Indicate that this symbol is acting as an
1413 1413 * individual interposer.
1414 1414 */
1415 1415 if (sdp->sd_flags & FLG_SY_INTPOSE) {
1416 1416 syminfo[ndx].si_flags |=
1417 1417 SYMINFO_FLG_INTERPOSE;
1418 1418 }
1419 1419
1420 1420 /*
1421 1421 * Indicate that this symbol is deferred, and
1422 1422 * hence should not be bound to during BIND_NOW
1423 1423 * relocations.
1424 1424 */
1425 1425 if (sdp->sd_flags & FLG_SY_DEFERRED) {
1426 1426 syminfo[ndx].si_flags |=
1427 1427 SYMINFO_FLG_DEFERRED;
1428 1428 }
1429 1429
1430 1430 /*
1431 1431 * If external bindings are allowed, indicate
1432 1432 * the binding, and a direct binding if
1433 1433 * necessary.
1434 1434 */
1435 1435 if ((sdp->sd_flags & FLG_SY_NDIR) == 0) {
1436 1436 syminfo[ndx].si_flags |=
1437 1437 SYMINFO_FLG_DIRECT;
1438 1438
1439 1439 if (sdp->sd_flags & FLG_SY_DIR)
1440 1440 syminfo[ndx].si_flags |=
1441 1441 SYMINFO_FLG_DIRECTBIND;
1442 1442
1443 1443 /*
1444 1444 * Provide a default boundto definition,
1445 1445 * which may be overridden later.
1446 1446 */
1447 1447 syminfo[ndx].si_boundto =
1448 1448 SYMINFO_BT_SELF;
1449 1449 }
1450 1450
1451 1451 /*
1452 1452 * Indicate that this is a capabilities symbol.
1453 1453 * Note, that this identification only provides
1454 1454 * information regarding the symbol that is
1455 1455 * visible from elfdump(1) -y. The association
1456 1456 * of a symbol to its capabilities is derived
1457 1457 * from a .SUNW_capinfo entry.
1458 1458 */
1459 1459 if ((sdp->sd_flags & FLG_SY_CAP) &&
1460 1460 ofl->ofl_oscapinfo) {
1461 1461 syminfo[ndx].si_flags |=
1462 1462 SYMINFO_FLG_CAP;
1463 1463 }
1464 1464 }
1465 1465 }
1466 1466
1467 1467 /*
1468 1468 * Note that the `sym' value is reset to be one of the new
1469 1469 * symbol table entries. This symbol will be updated further
1470 1470 * depending on the type of the symbol. Process the .symtab
1471 1471 * first, followed by the .dynsym, thus the `sym' value will
1472 1472 * remain as the .dynsym value when the .dynsym is present.
1473 1473 * This ensures that any versioning symbols st_name value will
1474 1474 * be appropriate for the string table used by version
1475 1475 * entries.
1476 1476 */
1477 1477 if (enter_in_symtab) {
1478 1478 Word _symndx;
1479 1479
1480 1480 if (local)
1481 1481 _symndx = scopesym_ndx;
1482 1482 else
1483 1483 _symndx = symtab_ndx;
1484 1484
1485 1485 symtab[_symndx] = *sdp->sd_sym;
1486 1486 sdp->sd_sym = sym = &symtab[_symndx];
1487 1487 (void) st_setstring(strtab, name, &stoff);
1488 1488 sym->st_name = stoff;
1489 1489 }
1490 1490 if (dynlocal) {
1491 1491 ldynsym[ldynscopesym_ndx] = *sdp->sd_sym;
1492 1492 sdp->sd_sym = sym = &ldynsym[ldynscopesym_ndx];
1493 1493 (void) st_setstring(dynstr, name, &stoff);
1494 1494 ldynsym[ldynscopesym_ndx].st_name = stoff;
1495 1495 /* Add it to sort section if it qualifies */
1496 1496 ADD_TO_DYNSORT(sdp, sym, ELF_ST_TYPE(sym->st_info),
1497 1497 ldynscopesym_ndx);
1498 1498 }
1499 1499
1500 1500 if (dynsym && !local) {
1501 1501 dynsym[dynsym_ndx] = *sdp->sd_sym;
1502 1502
1503 1503 /*
1504 1504 * Provided this isn't an unnamed register symbol,
1505 1505 * update the symbols name and hash value.
1506 1506 */
1507 1507 if (((sdp->sd_flags & FLG_SY_REGSYM) == 0) ||
1508 1508 dynsym[dynsym_ndx].st_name) {
1509 1509 (void) st_setstring(dynstr, name, &stoff);
1510 1510 dynsym[dynsym_ndx].st_name = stoff;
1511 1511
1512 1512 if (stoff) {
1513 1513 Word hashval, _hashndx;
1514 1514
1515 1515 hashval =
1516 1516 sap->sa_hash % ofl->ofl_hashbkts;
1517 1517
1518 1518 /* LINTED */
1519 1519 if (_hashndx = hashbkt[hashval]) {
1520 1520 while (hashchain[_hashndx]) {
1521 1521 _hashndx =
1522 1522 hashchain[_hashndx];
1523 1523 }
1524 1524 hashchain[_hashndx] =
1525 1525 sdp->sd_symndx;
1526 1526 } else {
1527 1527 hashbkt[hashval] =
1528 1528 sdp->sd_symndx;
1529 1529 }
1530 1530 }
1531 1531 }
1532 1532 sdp->sd_sym = sym = &dynsym[dynsym_ndx];
1533 1533
1534 1534 /*
1535 1535 * Add it to sort section if it qualifies.
1536 1536 * The indexes in that section are relative to the
1537 1537 * the adjacent SUNW_ldynsym/dymsym pair, so we
1538 1538 * add the number of items in SUNW_ldynsym to the
1539 1539 * dynsym index.
1540 1540 */
1541 1541 ADD_TO_DYNSORT(sdp, sym, ELF_ST_TYPE(sym->st_info),
1542 1542 ldynsym_cnt + dynsym_ndx);
1543 1543 }
1544 1544
1545 1545 if (!enter_in_symtab && (!dynsym || (local && !dynlocal))) {
1546 1546 if (!(sdp->sd_flags & FLG_SY_UPREQD))
1547 1547 continue;
1548 1548 sym = sdp->sd_sym;
1549 1549 } else
1550 1550 sdp->sd_flags &= ~FLG_SY_CLEAN;
1551 1551
1552 1552 /*
1553 1553 * If we have a weak data symbol for which we need the real
1554 1554 * symbol also, save this processing until later.
1555 1555 *
1556 1556 * The exception to this is if the weak/strong have PLT's
1557 1557 * assigned to them. In that case we don't do the post-weak
1558 1558 * processing because the PLT's must be maintained so that we
1559 1559 * can do 'interpositioning' on both of the symbols.
1560 1560 */
1561 1561 if ((sap->sa_linkndx) &&
1562 1562 (ELF_ST_BIND(sym->st_info) == STB_WEAK) &&
1563 1563 (!sap->sa_PLTndx)) {
1564 1564 Sym_desc *_sdp;
1565 1565
1566 1566 _sdp = sdp->sd_file->ifl_oldndx[sap->sa_linkndx];
1567 1567
1568 1568 if (_sdp->sd_ref != REF_DYN_SEEN) {
1569 1569 Wk_desc wk;
1570 1570
1571 1571 if (enter_in_symtab) {
1572 1572 if (local) {
1573 1573 wk.wk_symtab =
1574 1574 &symtab[scopesym_ndx];
1575 1575 scopesym_ndx++;
1576 1576 } else {
1577 1577 wk.wk_symtab =
1578 1578 &symtab[symtab_ndx];
1579 1579 symtab_ndx++;
1580 1580 }
1581 1581 } else {
1582 1582 wk.wk_symtab = NULL;
1583 1583 }
1584 1584 if (dynsym) {
1585 1585 if (!local) {
1586 1586 wk.wk_dynsym =
1587 1587 &dynsym[dynsym_ndx];
1588 1588 dynsym_ndx++;
1589 1589 } else if (dynlocal) {
1590 1590 wk.wk_dynsym =
1591 1591 &ldynsym[ldynscopesym_ndx];
1592 1592 ldynscopesym_ndx++;
1593 1593 }
1594 1594 } else {
1595 1595 wk.wk_dynsym = NULL;
1596 1596 }
1597 1597 wk.wk_weak = sdp;
1598 1598 wk.wk_alias = _sdp;
1599 1599
1600 1600 if (alist_append(&weak, &wk,
1601 1601 sizeof (Wk_desc), AL_CNT_WEAK) == NULL)
1602 1602 return ((Addr)S_ERROR);
1603 1603
1604 1604 continue;
1605 1605 }
1606 1606 }
1607 1607
1608 1608 DBG_CALL(Dbg_syms_old(ofl, sdp));
1609 1609
1610 1610 spec = NULL;
1611 1611 /*
1612 1612 * assign new symbol value.
1613 1613 */
1614 1614 sectndx = sdp->sd_shndx;
1615 1615 if (sectndx == SHN_UNDEF) {
1616 1616 if (((sdp->sd_flags & FLG_SY_REGSYM) == 0) &&
1617 1617 (sym->st_value != 0)) {
1618 1618 ld_eprintf(ofl, ERR_WARNING,
1619 1619 MSG_INTL(MSG_SYM_NOTNULL),
1620 1620 demangle(name), sdp->sd_file->ifl_name);
1621 1621 }
1622 1622
1623 1623 /*
1624 1624 * Undefined weak global, if we are generating a static
1625 1625 * executable, output as an absolute zero. Otherwise
1626 1626 * leave it as is, ld.so.1 will skip symbols of this
1627 1627 * type (this technique allows applications and
1628 1628 * libraries to test for the existence of a symbol as an
1629 1629 * indication of the presence or absence of certain
1630 1630 * functionality).
1631 1631 */
1632 1632 if (OFL_IS_STATIC_EXEC(ofl) &&
1633 1633 (ELF_ST_BIND(sym->st_info) == STB_WEAK)) {
1634 1634 sdp->sd_flags |= FLG_SY_SPECSEC;
1635 1635 sdp->sd_shndx = sectndx = SHN_ABS;
1636 1636 }
1637 1637 } else if ((sdp->sd_flags & FLG_SY_SPECSEC) &&
1638 1638 (sectndx == SHN_COMMON)) {
1639 1639 /* COMMONs have already been processed */
1640 1640 /* EMPTY */
1641 1641 ;
1642 1642 } else {
1643 1643 if ((sdp->sd_flags & FLG_SY_SPECSEC) &&
1644 1644 (sectndx == SHN_ABS))
1645 1645 spec = sdp->sd_aux->sa_symspec;
1646 1646
1647 1647 /* LINTED */
1648 1648 if (sdp->sd_flags & FLG_SY_COMMEXP) {
1649 1649 /*
1650 1650 * This is (or was) a COMMON symbol which was
1651 1651 * processed above - no processing
1652 1652 * required here.
1653 1653 */
1654 1654 ;
1655 1655 } else if (sdp->sd_ref == REF_DYN_NEED) {
1656 1656 uchar_t type, bind;
1657 1657
1658 1658 sectndx = SHN_UNDEF;
1659 1659 sym->st_value = 0;
1660 1660 sym->st_size = 0;
1661 1661
1662 1662 /*
1663 1663 * Make sure this undefined symbol is returned
1664 1664 * to the same binding as was defined in the
1665 1665 * original relocatable object reference.
1666 1666 */
1667 1667 type = ELF_ST_TYPE(sym-> st_info);
1668 1668 if (sdp->sd_flags & FLG_SY_GLOBREF)
1669 1669 bind = STB_GLOBAL;
1670 1670 else
1671 1671 bind = STB_WEAK;
1672 1672
1673 1673 sym->st_info = ELF_ST_INFO(bind, type);
1674 1674
1675 1675 } else if (((sdp->sd_flags & FLG_SY_SPECSEC) == 0) &&
1676 1676 (sdp->sd_ref == REF_REL_NEED)) {
1677 1677 osp = sdp->sd_isc->is_osdesc;
1678 1678 /* LINTED */
1679 1679 sectndx = elf_ndxscn(osp->os_scn);
1680 1680
1681 1681 /*
1682 1682 * In an executable, the new symbol value is the
1683 1683 * old value (offset into defining section) plus
1684 1684 * virtual address of defining section. In a
1685 1685 * relocatable, the new value is the old value
1686 1686 * plus the displacement of the section within
1687 1687 * the file.
1688 1688 */
1689 1689 /* LINTED */
1690 1690 sym->st_value +=
1691 1691 (Off)_elf_getxoff(sdp->sd_isc->is_indata);
1692 1692
1693 1693 if (!(flags & FLG_OF_RELOBJ)) {
1694 1694 sym->st_value += osp->os_shdr->sh_addr;
1695 1695 /*
1696 1696 * TLS symbols are relative to
1697 1697 * the TLS segment.
1698 1698 */
1699 1699 if ((ELF_ST_TYPE(sym->st_info) ==
1700 1700 STT_TLS) && (ofl->ofl_tlsphdr))
1701 1701 sym->st_value -=
1702 1702 ofl->ofl_tlsphdr->p_vaddr;
1703 1703 }
1704 1704 }
1705 1705 }
1706 1706
1707 1707 if (spec) {
1708 1708 switch (spec) {
1709 1709 case SDAUX_ID_ETEXT:
1710 1710 sym->st_value = etext;
1711 1711 sectndx = etext_ndx;
1712 1712 if (etext_abs)
1713 1713 sdp->sd_flags |= FLG_SY_SPECSEC;
1714 1714 else
1715 1715 sdp->sd_flags &= ~FLG_SY_SPECSEC;
1716 1716 break;
1717 1717 case SDAUX_ID_EDATA:
1718 1718 sym->st_value = edata;
1719 1719 sectndx = edata_ndx;
1720 1720 if (edata_abs)
1721 1721 sdp->sd_flags |= FLG_SY_SPECSEC;
1722 1722 else
1723 1723 sdp->sd_flags &= ~FLG_SY_SPECSEC;
1724 1724 break;
1725 1725 case SDAUX_ID_END:
1726 1726 sym->st_value = end;
1727 1727 sectndx = end_ndx;
1728 1728 if (end_abs)
1729 1729 sdp->sd_flags |= FLG_SY_SPECSEC;
1730 1730 else
1731 1731 sdp->sd_flags &= ~FLG_SY_SPECSEC;
1732 1732 break;
1733 1733 case SDAUX_ID_START:
1734 1734 sym->st_value = start;
1735 1735 sectndx = start_ndx;
1736 1736 sdp->sd_flags &= ~FLG_SY_SPECSEC;
1737 1737 break;
1738 1738 case SDAUX_ID_DYN:
1739 1739 if (flags & FLG_OF_DYNAMIC) {
1740 1740 sym->st_value = ofl->
1741 1741 ofl_osdynamic->os_shdr->sh_addr;
1742 1742 /* LINTED */
1743 1743 sectndx = elf_ndxscn(
1744 1744 ofl->ofl_osdynamic->os_scn);
1745 1745 sdp->sd_flags &= ~FLG_SY_SPECSEC;
1746 1746 }
1747 1747 break;
1748 1748 case SDAUX_ID_PLT:
1749 1749 if (ofl->ofl_osplt) {
1750 1750 sym->st_value = ofl->
1751 1751 ofl_osplt->os_shdr->sh_addr;
1752 1752 /* LINTED */
1753 1753 sectndx = elf_ndxscn(
1754 1754 ofl->ofl_osplt->os_scn);
1755 1755 sdp->sd_flags &= ~FLG_SY_SPECSEC;
1756 1756 }
1757 1757 break;
1758 1758 case SDAUX_ID_GOT:
1759 1759 /*
1760 1760 * Symbol bias for negative growing tables is
|
↓ open down ↓ |
414 lines elided |
↑ open up ↑ |
1761 1761 * stored in symbol's value during
1762 1762 * allocate_got().
1763 1763 */
1764 1764 sym->st_value += ofl->
1765 1765 ofl_osgot->os_shdr->sh_addr;
1766 1766 /* LINTED */
1767 1767 sectndx = elf_ndxscn(ofl->
1768 1768 ofl_osgot->os_scn);
1769 1769 sdp->sd_flags &= ~FLG_SY_SPECSEC;
1770 1770 break;
1771 + case SDAUX_ID_SECBOUND_START:
1772 + sym->st_value = sap->sa_boundsec->
1773 + os_shdr->sh_addr;
1774 + sectndx = elf_ndxscn(sap->sa_boundsec->os_scn);
1775 + sdp->sd_flags &= ~FLG_SY_SPECSEC;
1776 + break;
1777 + case SDAUX_ID_SECBOUND_STOP:
1778 + sym->st_value = sap->sa_boundsec->
1779 + os_shdr->sh_addr +
1780 + sap->sa_boundsec->os_shdr->sh_size;
1781 + sectndx = elf_ndxscn(sap->sa_boundsec->os_scn);
1782 + sdp->sd_flags &= ~FLG_SY_SPECSEC;
1783 + break;
1771 1784 default:
1772 1785 /* NOTHING */
1773 1786 ;
1774 1787 }
1775 1788 }
1776 1789
1777 1790 /*
1778 1791 * If a plt index has been assigned to an undefined function,
1779 1792 * update the symbols value to the appropriate .plt address.
1780 1793 */
1781 1794 if ((flags & FLG_OF_DYNAMIC) && (flags & FLG_OF_EXEC) &&
1782 1795 (sdp->sd_file) &&
1783 1796 (sdp->sd_file->ifl_ehdr->e_type == ET_DYN) &&
1784 1797 (ELF_ST_TYPE(sym->st_info) == STT_FUNC) &&
1785 1798 !(flags & FLG_OF_BFLAG)) {
1786 1799 if (sap->sa_PLTndx)
1787 1800 sym->st_value =
1788 1801 (*ld_targ.t_mr.mr_calc_plt_addr)(sdp, ofl);
1789 1802 }
1790 1803
1791 1804 /*
1792 1805 * Finish updating the symbols.
1793 1806 */
1794 1807
1795 1808 /*
1796 1809 * Sym Update: if scoped local - set local binding
1797 1810 */
1798 1811 if (local)
1799 1812 sym->st_info = ELF_ST_INFO(STB_LOCAL,
1800 1813 ELF_ST_TYPE(sym->st_info));
1801 1814
1802 1815 /*
1803 1816 * Sym Updated: If both the .symtab and .dynsym
1804 1817 * are present then we've actually updated the information in
1805 1818 * the .dynsym, therefore copy this same information to the
1806 1819 * .symtab entry.
1807 1820 */
1808 1821 sdp->sd_shndx = sectndx;
1809 1822 if (enter_in_symtab && dynsym && (!local || dynlocal)) {
1810 1823 Word _symndx = dynlocal ? scopesym_ndx : symtab_ndx;
1811 1824
1812 1825 symtab[_symndx].st_value = sym->st_value;
1813 1826 symtab[_symndx].st_size = sym->st_size;
1814 1827 symtab[_symndx].st_info = sym->st_info;
1815 1828 symtab[_symndx].st_other = sym->st_other;
1816 1829 }
1817 1830
1818 1831 if (enter_in_symtab) {
1819 1832 Word _symndx;
1820 1833
1821 1834 if (local)
1822 1835 _symndx = scopesym_ndx++;
1823 1836 else
1824 1837 _symndx = symtab_ndx++;
1825 1838 if (((sdp->sd_flags & FLG_SY_SPECSEC) == 0) &&
1826 1839 (sectndx >= SHN_LORESERVE)) {
1827 1840 assert(symshndx != NULL);
1828 1841 symshndx[_symndx] = sectndx;
1829 1842 symtab[_symndx].st_shndx = SHN_XINDEX;
1830 1843 } else {
1831 1844 /* LINTED */
1832 1845 symtab[_symndx].st_shndx = (Half)sectndx;
1833 1846 }
1834 1847 }
1835 1848
1836 1849 if (dynsym && (!local || dynlocal)) {
1837 1850 /*
1838 1851 * dynsym and ldynsym are distinct tables, so
1839 1852 * we use indirection to access the right one
1840 1853 * and the related extended section index array.
1841 1854 */
1842 1855 Word _symndx;
1843 1856 Sym *_dynsym;
1844 1857 Word *_dynshndx;
1845 1858
1846 1859 if (!local) {
1847 1860 _symndx = dynsym_ndx++;
1848 1861 _dynsym = dynsym;
1849 1862 _dynshndx = dynshndx;
1850 1863 } else {
1851 1864 _symndx = ldynscopesym_ndx++;
1852 1865 _dynsym = ldynsym;
1853 1866 _dynshndx = ldynshndx;
1854 1867 }
1855 1868 if (((sdp->sd_flags & FLG_SY_SPECSEC) == 0) &&
1856 1869 (sectndx >= SHN_LORESERVE)) {
1857 1870 assert(_dynshndx != NULL);
1858 1871 _dynshndx[_symndx] = sectndx;
1859 1872 _dynsym[_symndx].st_shndx = SHN_XINDEX;
1860 1873 } else {
1861 1874 /* LINTED */
1862 1875 _dynsym[_symndx].st_shndx = (Half)sectndx;
1863 1876 }
1864 1877 }
1865 1878
1866 1879 DBG_CALL(Dbg_syms_new(ofl, sym, sdp));
1867 1880 }
1868 1881
1869 1882 /*
1870 1883 * Now that all the symbols have been processed update any weak symbols
1871 1884 * information (ie. copy all information except `st_name'). As both
1872 1885 * symbols will be represented in the output, return the weak symbol to
1873 1886 * its correct type.
1874 1887 */
1875 1888 for (ALIST_TRAVERSE(weak, idx1, wkp)) {
1876 1889 Sym_desc *sdp, *_sdp;
1877 1890 Sym *sym, *_sym, *__sym;
1878 1891 uchar_t bind;
1879 1892
1880 1893 sdp = wkp->wk_weak;
1881 1894 _sdp = wkp->wk_alias;
1882 1895 _sym = __sym = _sdp->sd_sym;
1883 1896
1884 1897 sdp->sd_flags |= FLG_SY_WEAKDEF;
1885 1898
1886 1899 /*
1887 1900 * If the symbol definition has been scoped then assign it to
1888 1901 * be local, otherwise if it's from a shared object then we need
1889 1902 * to maintain the binding of the original reference.
1890 1903 */
1891 1904 if (SYM_IS_HIDDEN(sdp)) {
1892 1905 if (flags & FLG_OF_PROCRED)
1893 1906 bind = STB_LOCAL;
1894 1907 else
1895 1908 bind = STB_WEAK;
1896 1909 } else if ((sdp->sd_ref == REF_DYN_NEED) &&
1897 1910 (sdp->sd_flags & FLG_SY_GLOBREF))
1898 1911 bind = STB_GLOBAL;
1899 1912 else
1900 1913 bind = STB_WEAK;
1901 1914
1902 1915 DBG_CALL(Dbg_syms_old(ofl, sdp));
1903 1916 if ((sym = wkp->wk_symtab) != NULL) {
1904 1917 sym->st_value = _sym->st_value;
1905 1918 sym->st_size = _sym->st_size;
1906 1919 sym->st_other = _sym->st_other;
1907 1920 sym->st_shndx = _sym->st_shndx;
1908 1921 sym->st_info = ELF_ST_INFO(bind,
1909 1922 ELF_ST_TYPE(sym->st_info));
1910 1923 __sym = sym;
1911 1924 }
1912 1925 if ((sym = wkp->wk_dynsym) != NULL) {
1913 1926 sym->st_value = _sym->st_value;
1914 1927 sym->st_size = _sym->st_size;
1915 1928 sym->st_other = _sym->st_other;
1916 1929 sym->st_shndx = _sym->st_shndx;
1917 1930 sym->st_info = ELF_ST_INFO(bind,
1918 1931 ELF_ST_TYPE(sym->st_info));
1919 1932 __sym = sym;
1920 1933 }
1921 1934 DBG_CALL(Dbg_syms_new(ofl, __sym, sdp));
1922 1935 }
1923 1936
1924 1937 /*
1925 1938 * Now display GOT debugging information if required.
1926 1939 */
1927 1940 DBG_CALL(Dbg_got_display(ofl, 0, 0,
1928 1941 ld_targ.t_m.m_got_xnumber, ld_targ.t_m.m_got_entsize));
1929 1942
1930 1943 /*
1931 1944 * Update the section headers information. sh_info is
1932 1945 * supposed to contain the offset at which the first
1933 1946 * global symbol resides in the symbol table, while
1934 1947 * sh_link contains the section index of the associated
1935 1948 * string table.
1936 1949 */
1937 1950 if (symtab) {
1938 1951 Shdr *shdr = ofl->ofl_ossymtab->os_shdr;
1939 1952
1940 1953 shdr->sh_info = symtab_gbl_bndx;
1941 1954 /* LINTED */
1942 1955 shdr->sh_link = (Word)elf_ndxscn(ofl->ofl_osstrtab->os_scn);
1943 1956 if (symshndx)
1944 1957 ofl->ofl_ossymshndx->os_shdr->sh_link =
1945 1958 (Word)elf_ndxscn(ofl->ofl_ossymtab->os_scn);
1946 1959
1947 1960 /*
1948 1961 * Ensure that the expected number of symbols
1949 1962 * were entered into the right spots:
1950 1963 * - Scoped symbols in the right range
1951 1964 * - Globals start at the right spot
1952 1965 * (correct number of locals entered)
1953 1966 * - The table is exactly filled
1954 1967 * (correct number of globals entered)
1955 1968 */
1956 1969 assert((scopesym_bndx + ofl->ofl_scopecnt) == scopesym_ndx);
1957 1970 assert(shdr->sh_info == SYMTAB_LOC_CNT(ofl));
1958 1971 assert((shdr->sh_info + ofl->ofl_globcnt) == symtab_ndx);
1959 1972 }
1960 1973 if (dynsym) {
1961 1974 Shdr *shdr = ofl->ofl_osdynsym->os_shdr;
1962 1975
1963 1976 shdr->sh_info = DYNSYM_LOC_CNT(ofl);
1964 1977 /* LINTED */
1965 1978 shdr->sh_link = (Word)elf_ndxscn(ofl->ofl_osdynstr->os_scn);
1966 1979
1967 1980 ofl->ofl_oshash->os_shdr->sh_link =
1968 1981 /* LINTED */
1969 1982 (Word)elf_ndxscn(ofl->ofl_osdynsym->os_scn);
1970 1983 if (dynshndx) {
1971 1984 shdr = ofl->ofl_osdynshndx->os_shdr;
1972 1985 shdr->sh_link =
1973 1986 (Word)elf_ndxscn(ofl->ofl_osdynsym->os_scn);
1974 1987 }
1975 1988 }
1976 1989 if (ldynsym) {
1977 1990 Shdr *shdr = ofl->ofl_osldynsym->os_shdr;
1978 1991
1979 1992 /* ldynsym has no globals, so give index one past the end */
1980 1993 shdr->sh_info = ldynsym_ndx;
1981 1994
1982 1995 /*
1983 1996 * The ldynsym and dynsym must be adjacent. The
1984 1997 * idea is that rtld should be able to start with
1985 1998 * the ldynsym and march straight through the end
1986 1999 * of dynsym, seeing them as a single symbol table,
1987 2000 * despite the fact that they are in distinct sections.
1988 2001 * Ensure that this happened correctly.
1989 2002 *
1990 2003 * Note that I use ldynsym_ndx here instead of the
1991 2004 * computation I used to set the section size
1992 2005 * (found in ldynsym_cnt). The two will agree, unless
1993 2006 * we somehow miscounted symbols or failed to insert them
1994 2007 * all. Using ldynsym_ndx here catches that error in
1995 2008 * addition to checking for adjacency.
1996 2009 */
1997 2010 assert(dynsym == (ldynsym + ldynsym_ndx));
1998 2011
1999 2012
2000 2013 /* LINTED */
2001 2014 shdr->sh_link = (Word)elf_ndxscn(ofl->ofl_osdynstr->os_scn);
2002 2015
2003 2016 if (ldynshndx) {
2004 2017 shdr = ofl->ofl_osldynshndx->os_shdr;
2005 2018 shdr->sh_link =
2006 2019 (Word)elf_ndxscn(ofl->ofl_osldynsym->os_scn);
2007 2020 }
2008 2021
2009 2022 /*
2010 2023 * The presence of .SUNW_ldynsym means that there may be
2011 2024 * associated sort sections, one for regular symbols
2012 2025 * and the other for TLS. Each sort section needs the
2013 2026 * following done:
2014 2027 * - Section header link references .SUNW_ldynsym
2015 2028 * - Should have received the expected # of items
2016 2029 * - Sorted by increasing address
2017 2030 */
2018 2031 if (ofl->ofl_osdynsymsort) { /* .SUNW_dynsymsort */
2019 2032 ofl->ofl_osdynsymsort->os_shdr->sh_link =
2020 2033 (Word)elf_ndxscn(ofl->ofl_osldynsym->os_scn);
2021 2034 assert(ofl->ofl_dynsymsortcnt == dynsymsort_ndx);
2022 2035
2023 2036 if (dynsymsort_ndx > 1) {
2024 2037 dynsort_compare_syms = ldynsym;
2025 2038 qsort(dynsymsort, dynsymsort_ndx,
2026 2039 sizeof (*dynsymsort), dynsort_compare);
2027 2040 dynsort_dupwarn(ofl, ldynsym,
2028 2041 st_getstrbuf(dynstr),
2029 2042 dynsymsort, dynsymsort_ndx,
2030 2043 MSG_ORIG(MSG_SCN_DYNSYMSORT));
2031 2044 }
2032 2045 }
2033 2046 if (ofl->ofl_osdyntlssort) { /* .SUNW_dyntlssort */
2034 2047 ofl->ofl_osdyntlssort->os_shdr->sh_link =
2035 2048 (Word)elf_ndxscn(ofl->ofl_osldynsym->os_scn);
2036 2049 assert(ofl->ofl_dyntlssortcnt == dyntlssort_ndx);
2037 2050
2038 2051 if (dyntlssort_ndx > 1) {
2039 2052 dynsort_compare_syms = ldynsym;
2040 2053 qsort(dyntlssort, dyntlssort_ndx,
2041 2054 sizeof (*dyntlssort), dynsort_compare);
2042 2055 dynsort_dupwarn(ofl, ldynsym,
2043 2056 st_getstrbuf(dynstr),
2044 2057 dyntlssort, dyntlssort_ndx,
2045 2058 MSG_ORIG(MSG_SCN_DYNTLSSORT));
2046 2059 }
2047 2060 }
2048 2061 }
2049 2062
2050 2063 /*
2051 2064 * Used by ld.so.1 only.
2052 2065 */
2053 2066 return (etext);
2054 2067
2055 2068 #undef ADD_TO_DYNSORT
2056 2069 }
2057 2070
2058 2071 /*
2059 2072 * Build the dynamic section.
2060 2073 *
2061 2074 * This routine must be maintained in parallel with make_dynamic()
2062 2075 * in sections.c
2063 2076 */
2064 2077 static int
2065 2078 update_odynamic(Ofl_desc *ofl)
2066 2079 {
2067 2080 Aliste idx;
2068 2081 Ifl_desc *ifl;
2069 2082 Sym_desc *sdp;
2070 2083 Shdr *shdr;
2071 2084 Dyn *_dyn = (Dyn *)ofl->ofl_osdynamic->os_outdata->d_buf;
2072 2085 Dyn *dyn;
2073 2086 Os_desc *symosp, *strosp;
2074 2087 Str_tbl *strtbl;
2075 2088 size_t stoff;
2076 2089 ofl_flag_t flags = ofl->ofl_flags;
2077 2090 int not_relobj = !(flags & FLG_OF_RELOBJ);
2078 2091 Word cnt;
2079 2092
2080 2093 /*
2081 2094 * Relocatable objects can be built with -r and -dy to trigger the
2082 2095 * creation of a .dynamic section. This model is used to create kernel
2083 2096 * device drivers. The .dynamic section provides a subset of userland
2084 2097 * .dynamic entries, typically entries such as DT_NEEDED and DT_RUNPATH.
2085 2098 *
2086 2099 * Within a dynamic object, any .dynamic string references are to the
2087 2100 * .dynstr table. Within a relocatable object, these strings can reside
2088 2101 * within the .strtab.
2089 2102 */
2090 2103 if (OFL_IS_STATIC_OBJ(ofl)) {
2091 2104 symosp = ofl->ofl_ossymtab;
2092 2105 strosp = ofl->ofl_osstrtab;
2093 2106 strtbl = ofl->ofl_strtab;
2094 2107 } else {
2095 2108 symosp = ofl->ofl_osdynsym;
2096 2109 strosp = ofl->ofl_osdynstr;
2097 2110 strtbl = ofl->ofl_dynstrtab;
2098 2111 }
2099 2112
2100 2113 /* LINTED */
2101 2114 ofl->ofl_osdynamic->os_shdr->sh_link = (Word)elf_ndxscn(strosp->os_scn);
2102 2115
2103 2116 dyn = _dyn;
2104 2117
2105 2118 for (APLIST_TRAVERSE(ofl->ofl_sos, idx, ifl)) {
2106 2119 if ((ifl->ifl_flags &
2107 2120 (FLG_IF_IGNORE | FLG_IF_DEPREQD)) == FLG_IF_IGNORE)
2108 2121 continue;
2109 2122
2110 2123 /*
2111 2124 * Create and set up the DT_POSFLAG_1 entry here if required.
2112 2125 */
2113 2126 if ((ifl->ifl_flags & MSK_IF_POSFLAG1) &&
2114 2127 (ifl->ifl_flags & FLG_IF_NEEDED) && not_relobj) {
2115 2128 dyn->d_tag = DT_POSFLAG_1;
2116 2129 if (ifl->ifl_flags & FLG_IF_LAZYLD)
2117 2130 dyn->d_un.d_val = DF_P1_LAZYLOAD;
2118 2131 if (ifl->ifl_flags & FLG_IF_GRPPRM)
2119 2132 dyn->d_un.d_val |= DF_P1_GROUPPERM;
2120 2133 if (ifl->ifl_flags & FLG_IF_DEFERRED)
2121 2134 dyn->d_un.d_val |= DF_P1_DEFERRED;
2122 2135 dyn++;
2123 2136 }
2124 2137
2125 2138 if (ifl->ifl_flags & (FLG_IF_NEEDED | FLG_IF_NEEDSTR))
2126 2139 dyn->d_tag = DT_NEEDED;
2127 2140 else
2128 2141 continue;
2129 2142
2130 2143 (void) st_setstring(strtbl, ifl->ifl_soname, &stoff);
2131 2144 dyn->d_un.d_val = stoff;
2132 2145 /* LINTED */
2133 2146 ifl->ifl_neededndx = (Half)(((uintptr_t)dyn - (uintptr_t)_dyn) /
2134 2147 sizeof (Dyn));
2135 2148 dyn++;
2136 2149 }
2137 2150
2138 2151 if (not_relobj) {
2139 2152 if (ofl->ofl_dtsfltrs != NULL) {
2140 2153 Dfltr_desc *dftp;
2141 2154
2142 2155 for (ALIST_TRAVERSE(ofl->ofl_dtsfltrs, idx, dftp)) {
2143 2156 if (dftp->dft_flag == FLG_SY_AUXFLTR)
2144 2157 dyn->d_tag = DT_SUNW_AUXILIARY;
2145 2158 else
2146 2159 dyn->d_tag = DT_SUNW_FILTER;
2147 2160
2148 2161 (void) st_setstring(strtbl, dftp->dft_str,
2149 2162 &stoff);
2150 2163 dyn->d_un.d_val = stoff;
2151 2164 dftp->dft_ndx = (Half)(((uintptr_t)dyn -
2152 2165 (uintptr_t)_dyn) / sizeof (Dyn));
2153 2166 dyn++;
2154 2167 }
2155 2168 }
2156 2169 if (((sdp = ld_sym_find(MSG_ORIG(MSG_SYM_INIT_U),
2157 2170 SYM_NOHASH, 0, ofl)) != NULL) &&
2158 2171 (sdp->sd_ref == REF_REL_NEED) &&
2159 2172 (sdp->sd_sym->st_shndx != SHN_UNDEF)) {
2160 2173 dyn->d_tag = DT_INIT;
2161 2174 dyn->d_un.d_ptr = sdp->sd_sym->st_value;
2162 2175 dyn++;
2163 2176 }
2164 2177 if (((sdp = ld_sym_find(MSG_ORIG(MSG_SYM_FINI_U),
2165 2178 SYM_NOHASH, 0, ofl)) != NULL) &&
2166 2179 (sdp->sd_ref == REF_REL_NEED) &&
2167 2180 (sdp->sd_sym->st_shndx != SHN_UNDEF)) {
2168 2181 dyn->d_tag = DT_FINI;
2169 2182 dyn->d_un.d_ptr = sdp->sd_sym->st_value;
2170 2183 dyn++;
2171 2184 }
2172 2185 if (ofl->ofl_soname) {
2173 2186 dyn->d_tag = DT_SONAME;
2174 2187 (void) st_setstring(strtbl, ofl->ofl_soname, &stoff);
2175 2188 dyn->d_un.d_val = stoff;
2176 2189 dyn++;
2177 2190 }
2178 2191 if (ofl->ofl_filtees) {
2179 2192 if (flags & FLG_OF_AUX) {
2180 2193 dyn->d_tag = DT_AUXILIARY;
2181 2194 } else {
2182 2195 dyn->d_tag = DT_FILTER;
2183 2196 }
2184 2197 (void) st_setstring(strtbl, ofl->ofl_filtees, &stoff);
2185 2198 dyn->d_un.d_val = stoff;
2186 2199 dyn++;
2187 2200 }
2188 2201 }
2189 2202
2190 2203 if (ofl->ofl_rpath) {
2191 2204 (void) st_setstring(strtbl, ofl->ofl_rpath, &stoff);
2192 2205 dyn->d_tag = DT_RUNPATH;
2193 2206 dyn->d_un.d_val = stoff;
2194 2207 dyn++;
2195 2208 dyn->d_tag = DT_RPATH;
2196 2209 dyn->d_un.d_val = stoff;
2197 2210 dyn++;
2198 2211 }
2199 2212
2200 2213 if (not_relobj) {
2201 2214 Aliste idx;
2202 2215 Sg_desc *sgp;
2203 2216
2204 2217 if (ofl->ofl_config) {
2205 2218 dyn->d_tag = DT_CONFIG;
2206 2219 (void) st_setstring(strtbl, ofl->ofl_config, &stoff);
2207 2220 dyn->d_un.d_val = stoff;
2208 2221 dyn++;
2209 2222 }
2210 2223 if (ofl->ofl_depaudit) {
2211 2224 dyn->d_tag = DT_DEPAUDIT;
2212 2225 (void) st_setstring(strtbl, ofl->ofl_depaudit, &stoff);
2213 2226 dyn->d_un.d_val = stoff;
2214 2227 dyn++;
2215 2228 }
2216 2229 if (ofl->ofl_audit) {
2217 2230 dyn->d_tag = DT_AUDIT;
2218 2231 (void) st_setstring(strtbl, ofl->ofl_audit, &stoff);
2219 2232 dyn->d_un.d_val = stoff;
2220 2233 dyn++;
2221 2234 }
2222 2235
2223 2236 dyn->d_tag = DT_HASH;
2224 2237 dyn->d_un.d_ptr = ofl->ofl_oshash->os_shdr->sh_addr;
2225 2238 dyn++;
2226 2239
2227 2240 shdr = strosp->os_shdr;
2228 2241 dyn->d_tag = DT_STRTAB;
2229 2242 dyn->d_un.d_ptr = shdr->sh_addr;
2230 2243 dyn++;
2231 2244
2232 2245 dyn->d_tag = DT_STRSZ;
2233 2246 dyn->d_un.d_ptr = shdr->sh_size;
2234 2247 dyn++;
2235 2248
2236 2249 /*
2237 2250 * Note, the shdr is set and used in the ofl->ofl_osldynsym case
2238 2251 * that follows.
2239 2252 */
2240 2253 shdr = symosp->os_shdr;
2241 2254 dyn->d_tag = DT_SYMTAB;
2242 2255 dyn->d_un.d_ptr = shdr->sh_addr;
2243 2256 dyn++;
2244 2257
2245 2258 dyn->d_tag = DT_SYMENT;
2246 2259 dyn->d_un.d_ptr = shdr->sh_entsize;
2247 2260 dyn++;
2248 2261
2249 2262 if (ofl->ofl_osldynsym) {
2250 2263 Shdr *lshdr = ofl->ofl_osldynsym->os_shdr;
2251 2264
2252 2265 /*
2253 2266 * We have arranged for the .SUNW_ldynsym data to be
2254 2267 * immediately in front of the .dynsym data.
2255 2268 * This means that you could start at the top
2256 2269 * of .SUNW_ldynsym and see the data for both tables
2257 2270 * without a break. This is the view we want to
2258 2271 * provide for DT_SUNW_SYMTAB, which is why we
2259 2272 * add the lengths together.
2260 2273 */
2261 2274 dyn->d_tag = DT_SUNW_SYMTAB;
2262 2275 dyn->d_un.d_ptr = lshdr->sh_addr;
2263 2276 dyn++;
2264 2277
2265 2278 dyn->d_tag = DT_SUNW_SYMSZ;
2266 2279 dyn->d_un.d_val = lshdr->sh_size + shdr->sh_size;
2267 2280 dyn++;
2268 2281 }
2269 2282
2270 2283 if (ofl->ofl_osdynsymsort || ofl->ofl_osdyntlssort) {
2271 2284 dyn->d_tag = DT_SUNW_SORTENT;
2272 2285 dyn->d_un.d_val = sizeof (Word);
2273 2286 dyn++;
2274 2287 }
2275 2288
2276 2289 if (ofl->ofl_osdynsymsort) {
2277 2290 shdr = ofl->ofl_osdynsymsort->os_shdr;
2278 2291
2279 2292 dyn->d_tag = DT_SUNW_SYMSORT;
2280 2293 dyn->d_un.d_ptr = shdr->sh_addr;
2281 2294 dyn++;
2282 2295
2283 2296 dyn->d_tag = DT_SUNW_SYMSORTSZ;
2284 2297 dyn->d_un.d_val = shdr->sh_size;
2285 2298 dyn++;
2286 2299 }
2287 2300
2288 2301 if (ofl->ofl_osdyntlssort) {
2289 2302 shdr = ofl->ofl_osdyntlssort->os_shdr;
2290 2303
2291 2304 dyn->d_tag = DT_SUNW_TLSSORT;
2292 2305 dyn->d_un.d_ptr = shdr->sh_addr;
2293 2306 dyn++;
2294 2307
2295 2308 dyn->d_tag = DT_SUNW_TLSSORTSZ;
2296 2309 dyn->d_un.d_val = shdr->sh_size;
2297 2310 dyn++;
2298 2311 }
2299 2312
2300 2313 /*
2301 2314 * Reserve the DT_CHECKSUM entry. Its value will be filled in
2302 2315 * after the complete image is built.
2303 2316 */
2304 2317 dyn->d_tag = DT_CHECKSUM;
2305 2318 ofl->ofl_checksum = &dyn->d_un.d_val;
2306 2319 dyn++;
2307 2320
2308 2321 /*
2309 2322 * Versioning sections: DT_VERDEF and DT_VERNEED.
2310 2323 *
2311 2324 * The Solaris ld does not produce DT_VERSYM, but the GNU ld
2312 2325 * does, in order to support their style of versioning, which
2313 2326 * differs from ours:
2314 2327 *
2315 2328 * - The top bit of the 16-bit Versym index is
2316 2329 * not part of the version, but is interpreted
2317 2330 * as a "hidden bit".
2318 2331 *
2319 2332 * - External (SHN_UNDEF) symbols can have non-zero
2320 2333 * Versym values, which specify versions in
2321 2334 * referenced objects, via the Verneed section.
2322 2335 *
2323 2336 * - The vna_other field of the Vernaux structures
2324 2337 * found in the Verneed section are not zero as
2325 2338 * with Solaris, but instead contain the version
2326 2339 * index to be used by Versym indices to reference
2327 2340 * the given external version.
2328 2341 *
2329 2342 * The Solaris ld, rtld, and elfdump programs all interpret the
2330 2343 * presence of DT_VERSYM as meaning that GNU versioning rules
2331 2344 * apply to the given file. If DT_VERSYM is not present,
2332 2345 * then Solaris versioning rules apply. If we should ever need
2333 2346 * to change our ld so that it does issue DT_VERSYM, then
2334 2347 * this rule for detecting GNU versioning will no longer work.
2335 2348 * In that case, we will have to invent a way to explicitly
2336 2349 * specify the style of versioning in use, perhaps via a
2337 2350 * new dynamic entry named something like DT_SUNW_VERSIONSTYLE,
2338 2351 * where the d_un.d_val value specifies which style is to be
2339 2352 * used.
2340 2353 */
2341 2354 if ((flags & (FLG_OF_VERDEF | FLG_OF_NOVERSEC)) ==
2342 2355 FLG_OF_VERDEF) {
2343 2356 shdr = ofl->ofl_osverdef->os_shdr;
2344 2357
2345 2358 dyn->d_tag = DT_VERDEF;
2346 2359 dyn->d_un.d_ptr = shdr->sh_addr;
2347 2360 dyn++;
2348 2361 dyn->d_tag = DT_VERDEFNUM;
2349 2362 dyn->d_un.d_ptr = shdr->sh_info;
2350 2363 dyn++;
2351 2364 }
2352 2365 if ((flags & (FLG_OF_VERNEED | FLG_OF_NOVERSEC)) ==
2353 2366 FLG_OF_VERNEED) {
2354 2367 shdr = ofl->ofl_osverneed->os_shdr;
2355 2368
2356 2369 dyn->d_tag = DT_VERNEED;
2357 2370 dyn->d_un.d_ptr = shdr->sh_addr;
2358 2371 dyn++;
2359 2372 dyn->d_tag = DT_VERNEEDNUM;
2360 2373 dyn->d_un.d_ptr = shdr->sh_info;
2361 2374 dyn++;
2362 2375 }
2363 2376
2364 2377 if ((flags & FLG_OF_COMREL) && ofl->ofl_relocrelcnt) {
2365 2378 dyn->d_tag = ld_targ.t_m.m_rel_dt_count;
2366 2379 dyn->d_un.d_val = ofl->ofl_relocrelcnt;
2367 2380 dyn++;
2368 2381 }
2369 2382 if (flags & FLG_OF_TEXTREL) {
2370 2383 /*
2371 2384 * Only the presence of this entry is used in this
2372 2385 * implementation, not the value stored.
2373 2386 */
2374 2387 dyn->d_tag = DT_TEXTREL;
2375 2388 dyn->d_un.d_val = 0;
2376 2389 dyn++;
2377 2390 }
2378 2391
2379 2392 if (ofl->ofl_osfiniarray) {
2380 2393 shdr = ofl->ofl_osfiniarray->os_shdr;
2381 2394
2382 2395 dyn->d_tag = DT_FINI_ARRAY;
2383 2396 dyn->d_un.d_ptr = shdr->sh_addr;
2384 2397 dyn++;
2385 2398
2386 2399 dyn->d_tag = DT_FINI_ARRAYSZ;
2387 2400 dyn->d_un.d_val = shdr->sh_size;
2388 2401 dyn++;
2389 2402 }
2390 2403
2391 2404 if (ofl->ofl_osinitarray) {
2392 2405 shdr = ofl->ofl_osinitarray->os_shdr;
2393 2406
2394 2407 dyn->d_tag = DT_INIT_ARRAY;
2395 2408 dyn->d_un.d_ptr = shdr->sh_addr;
2396 2409 dyn++;
2397 2410
2398 2411 dyn->d_tag = DT_INIT_ARRAYSZ;
2399 2412 dyn->d_un.d_val = shdr->sh_size;
2400 2413 dyn++;
2401 2414 }
2402 2415
2403 2416 if (ofl->ofl_ospreinitarray) {
2404 2417 shdr = ofl->ofl_ospreinitarray->os_shdr;
2405 2418
2406 2419 dyn->d_tag = DT_PREINIT_ARRAY;
2407 2420 dyn->d_un.d_ptr = shdr->sh_addr;
2408 2421 dyn++;
2409 2422
2410 2423 dyn->d_tag = DT_PREINIT_ARRAYSZ;
2411 2424 dyn->d_un.d_val = shdr->sh_size;
2412 2425 dyn++;
2413 2426 }
2414 2427
2415 2428 if (ofl->ofl_pltcnt) {
2416 2429 shdr = ofl->ofl_osplt->os_relosdesc->os_shdr;
2417 2430
2418 2431 dyn->d_tag = DT_PLTRELSZ;
2419 2432 dyn->d_un.d_ptr = shdr->sh_size;
2420 2433 dyn++;
2421 2434 dyn->d_tag = DT_PLTREL;
2422 2435 dyn->d_un.d_ptr = ld_targ.t_m.m_rel_dt_type;
2423 2436 dyn++;
2424 2437 dyn->d_tag = DT_JMPREL;
2425 2438 dyn->d_un.d_ptr = shdr->sh_addr;
2426 2439 dyn++;
2427 2440 }
2428 2441 if (ofl->ofl_pltpad) {
2429 2442 shdr = ofl->ofl_osplt->os_shdr;
2430 2443
2431 2444 dyn->d_tag = DT_PLTPAD;
2432 2445 if (ofl->ofl_pltcnt) {
2433 2446 dyn->d_un.d_ptr = shdr->sh_addr +
2434 2447 ld_targ.t_m.m_plt_reservsz +
2435 2448 ofl->ofl_pltcnt * ld_targ.t_m.m_plt_entsize;
2436 2449 } else
2437 2450 dyn->d_un.d_ptr = shdr->sh_addr;
2438 2451 dyn++;
2439 2452 dyn->d_tag = DT_PLTPADSZ;
2440 2453 dyn->d_un.d_val = ofl->ofl_pltpad *
2441 2454 ld_targ.t_m.m_plt_entsize;
2442 2455 dyn++;
2443 2456 }
2444 2457 if (ofl->ofl_relocsz) {
2445 2458 shdr = ofl->ofl_osrelhead->os_shdr;
2446 2459
2447 2460 dyn->d_tag = ld_targ.t_m.m_rel_dt_type;
2448 2461 dyn->d_un.d_ptr = shdr->sh_addr;
2449 2462 dyn++;
2450 2463 dyn->d_tag = ld_targ.t_m.m_rel_dt_size;
2451 2464 dyn->d_un.d_ptr = ofl->ofl_relocsz;
2452 2465 dyn++;
2453 2466 dyn->d_tag = ld_targ.t_m.m_rel_dt_ent;
2454 2467 if (shdr->sh_type == SHT_REL)
2455 2468 dyn->d_un.d_ptr = sizeof (Rel);
2456 2469 else
2457 2470 dyn->d_un.d_ptr = sizeof (Rela);
2458 2471 dyn++;
2459 2472 }
2460 2473 if (ofl->ofl_ossyminfo) {
2461 2474 shdr = ofl->ofl_ossyminfo->os_shdr;
2462 2475
2463 2476 dyn->d_tag = DT_SYMINFO;
2464 2477 dyn->d_un.d_ptr = shdr->sh_addr;
2465 2478 dyn++;
2466 2479 dyn->d_tag = DT_SYMINSZ;
2467 2480 dyn->d_un.d_val = shdr->sh_size;
2468 2481 dyn++;
2469 2482 dyn->d_tag = DT_SYMINENT;
2470 2483 dyn->d_un.d_val = sizeof (Syminfo);
2471 2484 dyn++;
2472 2485 }
2473 2486 if (ofl->ofl_osmove) {
2474 2487 shdr = ofl->ofl_osmove->os_shdr;
2475 2488
2476 2489 dyn->d_tag = DT_MOVETAB;
2477 2490 dyn->d_un.d_val = shdr->sh_addr;
2478 2491 dyn++;
2479 2492 dyn->d_tag = DT_MOVESZ;
2480 2493 dyn->d_un.d_val = shdr->sh_size;
2481 2494 dyn++;
2482 2495 dyn->d_tag = DT_MOVEENT;
2483 2496 dyn->d_un.d_val = shdr->sh_entsize;
2484 2497 dyn++;
2485 2498 }
2486 2499 if (ofl->ofl_regsymcnt) {
2487 2500 int ndx;
2488 2501
2489 2502 for (ndx = 0; ndx < ofl->ofl_regsymsno; ndx++) {
2490 2503 if ((sdp = ofl->ofl_regsyms[ndx]) == NULL)
2491 2504 continue;
2492 2505
2493 2506 dyn->d_tag = ld_targ.t_m.m_dt_register;
2494 2507 dyn->d_un.d_val = sdp->sd_symndx;
2495 2508 dyn++;
2496 2509 }
2497 2510 }
2498 2511
2499 2512 for (APLIST_TRAVERSE(ofl->ofl_rtldinfo, idx, sdp)) {
2500 2513 dyn->d_tag = DT_SUNW_RTLDINF;
2501 2514 dyn->d_un.d_ptr = sdp->sd_sym->st_value;
2502 2515 dyn++;
2503 2516 }
2504 2517
2505 2518 if (((sgp = ofl->ofl_osdynamic->os_sgdesc) != NULL) &&
2506 2519 (sgp->sg_phdr.p_flags & PF_W) && ofl->ofl_osinterp) {
2507 2520 dyn->d_tag = DT_DEBUG;
2508 2521 dyn->d_un.d_ptr = 0;
2509 2522 dyn++;
2510 2523 }
2511 2524
2512 2525 if (ofl->ofl_oscap) {
2513 2526 dyn->d_tag = DT_SUNW_CAP;
2514 2527 dyn->d_un.d_val = ofl->ofl_oscap->os_shdr->sh_addr;
2515 2528 dyn++;
2516 2529 }
2517 2530 if (ofl->ofl_oscapinfo) {
2518 2531 dyn->d_tag = DT_SUNW_CAPINFO;
2519 2532 dyn->d_un.d_val = ofl->ofl_oscapinfo->os_shdr->sh_addr;
2520 2533 dyn++;
2521 2534 }
2522 2535 if (ofl->ofl_oscapchain) {
2523 2536 shdr = ofl->ofl_oscapchain->os_shdr;
2524 2537
2525 2538 dyn->d_tag = DT_SUNW_CAPCHAIN;
2526 2539 dyn->d_un.d_val = shdr->sh_addr;
2527 2540 dyn++;
2528 2541 dyn->d_tag = DT_SUNW_CAPCHAINSZ;
2529 2542 dyn->d_un.d_val = shdr->sh_size;
2530 2543 dyn++;
2531 2544 dyn->d_tag = DT_SUNW_CAPCHAINENT;
2532 2545 dyn->d_un.d_val = shdr->sh_entsize;
2533 2546 dyn++;
2534 2547 }
2535 2548
2536 2549 if (ofl->ofl_aslr != 0) {
2537 2550 dyn->d_tag = DT_SUNW_ASLR;
2538 2551 dyn->d_un.d_val = (ofl->ofl_aslr == 1);
2539 2552 dyn++;
2540 2553 }
2541 2554
2542 2555 if (flags & FLG_OF_SYMBOLIC) {
2543 2556 dyn->d_tag = DT_SYMBOLIC;
2544 2557 dyn->d_un.d_val = 0;
2545 2558 dyn++;
2546 2559 }
2547 2560 }
2548 2561
2549 2562 dyn->d_tag = DT_FLAGS;
2550 2563 dyn->d_un.d_val = ofl->ofl_dtflags;
2551 2564 dyn++;
2552 2565
2553 2566 /*
2554 2567 * If -Bdirect was specified, but some NODIRECT symbols were specified
2555 2568 * via a mapfile, or -znodirect was used on the command line, then
2556 2569 * clear the DF_1_DIRECT flag. The resultant object will use per-symbol
2557 2570 * direct bindings rather than be enabled for global direct bindings.
2558 2571 *
2559 2572 * If any no-direct bindings exist within this object, set the
2560 2573 * DF_1_NODIRECT flag. ld(1) recognizes this flag when processing
2561 2574 * dependencies, and performs extra work to ensure that no direct
2562 2575 * bindings are established to the no-direct symbols that exist
2563 2576 * within these dependencies.
2564 2577 */
2565 2578 if (ofl->ofl_flags1 & FLG_OF1_NGLBDIR)
2566 2579 ofl->ofl_dtflags_1 &= ~DF_1_DIRECT;
2567 2580 if (ofl->ofl_flags1 & FLG_OF1_NDIRECT)
2568 2581 ofl->ofl_dtflags_1 |= DF_1_NODIRECT;
2569 2582
2570 2583 dyn->d_tag = DT_FLAGS_1;
2571 2584 dyn->d_un.d_val = ofl->ofl_dtflags_1;
2572 2585 dyn++;
2573 2586
2574 2587 dyn->d_tag = DT_SUNW_STRPAD;
2575 2588 dyn->d_un.d_val = DYNSTR_EXTRA_PAD;
2576 2589 dyn++;
2577 2590
2578 2591 dyn->d_tag = DT_SUNW_LDMACH;
2579 2592 dyn->d_un.d_val = ld_sunw_ldmach();
2580 2593 dyn++;
2581 2594
2582 2595 (*ld_targ.t_mr.mr_mach_update_odynamic)(ofl, &dyn);
2583 2596
2584 2597 for (cnt = 1 + DYNAMIC_EXTRA_ELTS; cnt--; dyn++) {
2585 2598 dyn->d_tag = DT_NULL;
2586 2599 dyn->d_un.d_val = 0;
2587 2600 }
2588 2601
2589 2602 /*
2590 2603 * Ensure that we wrote the right number of entries. If not, we either
2591 2604 * miscounted in make_dynamic(), or we did something wrong in this
2592 2605 * function.
2593 2606 */
2594 2607 assert((ofl->ofl_osdynamic->os_shdr->sh_size /
2595 2608 ofl->ofl_osdynamic->os_shdr->sh_entsize) ==
2596 2609 ((uintptr_t)dyn - (uintptr_t)_dyn) / sizeof (*dyn));
2597 2610
2598 2611 return (1);
2599 2612 }
2600 2613
2601 2614 /*
2602 2615 * Build the version definition section
2603 2616 */
2604 2617 static int
2605 2618 update_overdef(Ofl_desc *ofl)
2606 2619 {
2607 2620 Aliste idx1;
2608 2621 Ver_desc *vdp, *_vdp;
2609 2622 Verdef *vdf, *_vdf;
2610 2623 int num = 0;
2611 2624 Os_desc *strosp;
2612 2625 Str_tbl *strtbl;
2613 2626
2614 2627 /*
2615 2628 * Determine which string table to use.
2616 2629 */
2617 2630 if (OFL_IS_STATIC_OBJ(ofl)) {
2618 2631 strtbl = ofl->ofl_strtab;
2619 2632 strosp = ofl->ofl_osstrtab;
2620 2633 } else {
2621 2634 strtbl = ofl->ofl_dynstrtab;
2622 2635 strosp = ofl->ofl_osdynstr;
2623 2636 }
2624 2637
2625 2638 /*
2626 2639 * Traverse the version descriptors and update the version structures
2627 2640 * to point to the dynstr name in preparation for building the version
2628 2641 * section structure.
2629 2642 */
2630 2643 for (APLIST_TRAVERSE(ofl->ofl_verdesc, idx1, vdp)) {
2631 2644 Sym_desc *sdp;
2632 2645
2633 2646 if (vdp->vd_flags & VER_FLG_BASE) {
2634 2647 const char *name = vdp->vd_name;
2635 2648 size_t stoff;
2636 2649
2637 2650 /*
2638 2651 * Create a new string table entry to represent the base
2639 2652 * version name (there is no corresponding symbol for
2640 2653 * this).
2641 2654 */
2642 2655 (void) st_setstring(strtbl, name, &stoff);
2643 2656 /* LINTED */
2644 2657 vdp->vd_name = (const char *)stoff;
2645 2658 } else {
2646 2659 sdp = ld_sym_find(vdp->vd_name, vdp->vd_hash, 0, ofl);
2647 2660 /* LINTED */
2648 2661 vdp->vd_name = (const char *)
2649 2662 (uintptr_t)sdp->sd_sym->st_name;
2650 2663 }
2651 2664 }
2652 2665
2653 2666 _vdf = vdf = (Verdef *)ofl->ofl_osverdef->os_outdata->d_buf;
2654 2667
2655 2668 /*
2656 2669 * Traverse the version descriptors and update the version section to
2657 2670 * reflect each version and its associated dependencies.
2658 2671 */
2659 2672 for (APLIST_TRAVERSE(ofl->ofl_verdesc, idx1, vdp)) {
2660 2673 Aliste idx2;
2661 2674 Half cnt = 1;
2662 2675 Verdaux *vdap, *_vdap;
2663 2676
2664 2677 _vdap = vdap = (Verdaux *)(vdf + 1);
2665 2678
2666 2679 vdf->vd_version = VER_DEF_CURRENT;
2667 2680 vdf->vd_flags = vdp->vd_flags & MSK_VER_USER;
2668 2681 vdf->vd_ndx = vdp->vd_ndx;
2669 2682 vdf->vd_hash = vdp->vd_hash;
2670 2683
2671 2684 /* LINTED */
2672 2685 vdap->vda_name = (uintptr_t)vdp->vd_name;
2673 2686 vdap++;
2674 2687 /* LINTED */
2675 2688 _vdap->vda_next = (Word)((uintptr_t)vdap - (uintptr_t)_vdap);
2676 2689
2677 2690 /*
2678 2691 * Traverse this versions dependency list generating the
2679 2692 * appropriate version dependency entries.
2680 2693 */
2681 2694 for (APLIST_TRAVERSE(vdp->vd_deps, idx2, _vdp)) {
2682 2695 /* LINTED */
2683 2696 vdap->vda_name = (uintptr_t)_vdp->vd_name;
2684 2697 _vdap = vdap;
2685 2698 vdap++, cnt++;
2686 2699 /* LINTED */
2687 2700 _vdap->vda_next = (Word)((uintptr_t)vdap -
2688 2701 (uintptr_t)_vdap);
2689 2702 }
2690 2703 _vdap->vda_next = 0;
2691 2704
2692 2705 /*
2693 2706 * Record the versions auxiliary array offset and the associated
2694 2707 * dependency count.
2695 2708 */
2696 2709 /* LINTED */
2697 2710 vdf->vd_aux = (Word)((uintptr_t)(vdf + 1) - (uintptr_t)vdf);
2698 2711 vdf->vd_cnt = cnt;
2699 2712
2700 2713 /*
2701 2714 * Record the next versions offset and update the version
2702 2715 * pointer. Remember the previous version offset as the very
2703 2716 * last structures next pointer should be null.
2704 2717 */
2705 2718 _vdf = vdf;
2706 2719 vdf = (Verdef *)vdap, num++;
2707 2720 /* LINTED */
2708 2721 _vdf->vd_next = (Word)((uintptr_t)vdf - (uintptr_t)_vdf);
2709 2722 }
2710 2723 _vdf->vd_next = 0;
2711 2724
2712 2725 /*
2713 2726 * Record the string table association with the version definition
2714 2727 * section, and the symbol table associated with the version symbol
2715 2728 * table (the actual contents of the version symbol table are filled
2716 2729 * in during symbol update).
2717 2730 */
2718 2731 /* LINTED */
2719 2732 ofl->ofl_osverdef->os_shdr->sh_link = (Word)elf_ndxscn(strosp->os_scn);
2720 2733
2721 2734 /*
2722 2735 * The version definition sections `info' field is used to indicate the
2723 2736 * number of entries in this section.
2724 2737 */
2725 2738 ofl->ofl_osverdef->os_shdr->sh_info = num;
2726 2739
2727 2740 return (1);
2728 2741 }
2729 2742
2730 2743 /*
2731 2744 * Finish the version symbol index section
2732 2745 */
2733 2746 static void
2734 2747 update_oversym(Ofl_desc *ofl)
2735 2748 {
2736 2749 Os_desc *osp;
2737 2750
2738 2751 /*
2739 2752 * Record the symbol table associated with the version symbol table.
2740 2753 * The contents of the version symbol table are filled in during
2741 2754 * symbol update.
2742 2755 */
2743 2756 if (OFL_IS_STATIC_OBJ(ofl))
2744 2757 osp = ofl->ofl_ossymtab;
2745 2758 else
2746 2759 osp = ofl->ofl_osdynsym;
2747 2760
2748 2761 /* LINTED */
2749 2762 ofl->ofl_osversym->os_shdr->sh_link = (Word)elf_ndxscn(osp->os_scn);
2750 2763 }
2751 2764
2752 2765 /*
2753 2766 * Build the version needed section
2754 2767 */
2755 2768 static int
2756 2769 update_overneed(Ofl_desc *ofl)
2757 2770 {
2758 2771 Aliste idx1;
2759 2772 Ifl_desc *ifl;
2760 2773 Verneed *vnd, *_vnd;
2761 2774 Os_desc *strosp;
2762 2775 Str_tbl *strtbl;
2763 2776 Word num = 0;
2764 2777
2765 2778 _vnd = vnd = (Verneed *)ofl->ofl_osverneed->os_outdata->d_buf;
2766 2779
2767 2780 /*
2768 2781 * Determine which string table is appropriate.
2769 2782 */
2770 2783 if (OFL_IS_STATIC_OBJ(ofl)) {
2771 2784 strosp = ofl->ofl_osstrtab;
2772 2785 strtbl = ofl->ofl_strtab;
2773 2786 } else {
2774 2787 strosp = ofl->ofl_osdynstr;
2775 2788 strtbl = ofl->ofl_dynstrtab;
2776 2789 }
2777 2790
2778 2791 /*
2779 2792 * Traverse the shared object list looking for dependencies that have
2780 2793 * versions defined within them.
2781 2794 */
2782 2795 for (APLIST_TRAVERSE(ofl->ofl_sos, idx1, ifl)) {
2783 2796 Half _cnt;
2784 2797 Word cnt = 0;
2785 2798 Vernaux *_vnap, *vnap;
2786 2799 size_t stoff;
2787 2800
2788 2801 if (!(ifl->ifl_flags & FLG_IF_VERNEED))
2789 2802 continue;
2790 2803
2791 2804 vnd->vn_version = VER_NEED_CURRENT;
2792 2805
2793 2806 (void) st_setstring(strtbl, ifl->ifl_soname, &stoff);
2794 2807 vnd->vn_file = stoff;
2795 2808
2796 2809 _vnap = vnap = (Vernaux *)(vnd + 1);
2797 2810
2798 2811 /*
2799 2812 * Traverse the version index list recording
2800 2813 * each version as a needed dependency.
2801 2814 */
2802 2815 for (_cnt = 0; _cnt <= ifl->ifl_vercnt; _cnt++) {
2803 2816 Ver_index *vip = &ifl->ifl_verndx[_cnt];
2804 2817
2805 2818 if (vip->vi_flags & FLG_VER_REFER) {
2806 2819 (void) st_setstring(strtbl, vip->vi_name,
2807 2820 &stoff);
2808 2821 vnap->vna_name = stoff;
2809 2822
2810 2823 if (vip->vi_desc) {
2811 2824 vnap->vna_hash = vip->vi_desc->vd_hash;
2812 2825 vnap->vna_flags =
2813 2826 vip->vi_desc->vd_flags;
2814 2827 } else {
2815 2828 vnap->vna_hash = 0;
2816 2829 vnap->vna_flags = 0;
2817 2830 }
2818 2831 vnap->vna_other = vip->vi_overndx;
2819 2832
2820 2833 /*
2821 2834 * If version A inherits version B, then
2822 2835 * B is implicit in A. It suffices for ld.so.1
2823 2836 * to verify A at runtime and skip B. The
2824 2837 * version normalization process sets the INFO
2825 2838 * flag for the versions we want ld.so.1 to
2826 2839 * skip.
2827 2840 */
2828 2841 if (vip->vi_flags & VER_FLG_INFO)
2829 2842 vnap->vna_flags |= VER_FLG_INFO;
2830 2843
2831 2844 _vnap = vnap;
2832 2845 vnap++, cnt++;
2833 2846 _vnap->vna_next =
2834 2847 /* LINTED */
2835 2848 (Word)((uintptr_t)vnap - (uintptr_t)_vnap);
2836 2849 }
2837 2850 }
2838 2851
2839 2852 _vnap->vna_next = 0;
2840 2853
2841 2854 /*
2842 2855 * Record the versions auxiliary array offset and
2843 2856 * the associated dependency count.
2844 2857 */
2845 2858 /* LINTED */
2846 2859 vnd->vn_aux = (Word)((uintptr_t)(vnd + 1) - (uintptr_t)vnd);
2847 2860 /* LINTED */
2848 2861 vnd->vn_cnt = (Half)cnt;
2849 2862
2850 2863 /*
2851 2864 * Record the next versions offset and update the version
2852 2865 * pointer. Remember the previous version offset as the very
2853 2866 * last structures next pointer should be null.
2854 2867 */
2855 2868 _vnd = vnd;
2856 2869 vnd = (Verneed *)vnap, num++;
2857 2870 /* LINTED */
2858 2871 _vnd->vn_next = (Word)((uintptr_t)vnd - (uintptr_t)_vnd);
2859 2872 }
2860 2873 _vnd->vn_next = 0;
2861 2874
2862 2875 /*
2863 2876 * Use sh_link to record the associated string table section, and
2864 2877 * sh_info to indicate the number of entries contained in the section.
2865 2878 */
2866 2879 /* LINTED */
2867 2880 ofl->ofl_osverneed->os_shdr->sh_link = (Word)elf_ndxscn(strosp->os_scn);
2868 2881 ofl->ofl_osverneed->os_shdr->sh_info = num;
2869 2882
2870 2883 return (1);
2871 2884 }
2872 2885
2873 2886 /*
2874 2887 * Update syminfo section.
2875 2888 */
2876 2889 static uintptr_t
2877 2890 update_osyminfo(Ofl_desc *ofl)
2878 2891 {
2879 2892 Os_desc *symosp, *infosp = ofl->ofl_ossyminfo;
2880 2893 Syminfo *sip = infosp->os_outdata->d_buf;
2881 2894 Shdr *shdr = infosp->os_shdr;
2882 2895 char *strtab;
2883 2896 Aliste idx;
2884 2897 Sym_desc *sdp;
2885 2898 Sfltr_desc *sftp;
2886 2899
2887 2900 if (ofl->ofl_flags & FLG_OF_RELOBJ) {
2888 2901 symosp = ofl->ofl_ossymtab;
2889 2902 strtab = ofl->ofl_osstrtab->os_outdata->d_buf;
2890 2903 } else {
2891 2904 symosp = ofl->ofl_osdynsym;
2892 2905 strtab = ofl->ofl_osdynstr->os_outdata->d_buf;
2893 2906 }
2894 2907
2895 2908 /* LINTED */
2896 2909 infosp->os_shdr->sh_link = (Word)elf_ndxscn(symosp->os_scn);
2897 2910 if (ofl->ofl_osdynamic)
2898 2911 infosp->os_shdr->sh_info =
2899 2912 /* LINTED */
2900 2913 (Word)elf_ndxscn(ofl->ofl_osdynamic->os_scn);
2901 2914
2902 2915 /*
2903 2916 * Update any references with the index into the dynamic table.
2904 2917 */
2905 2918 for (APLIST_TRAVERSE(ofl->ofl_symdtent, idx, sdp))
2906 2919 sip[sdp->sd_symndx].si_boundto = sdp->sd_file->ifl_neededndx;
2907 2920
2908 2921 /*
2909 2922 * Update any filtee references with the index into the dynamic table.
2910 2923 */
2911 2924 for (ALIST_TRAVERSE(ofl->ofl_symfltrs, idx, sftp)) {
2912 2925 Dfltr_desc *dftp;
2913 2926
2914 2927 dftp = alist_item(ofl->ofl_dtsfltrs, sftp->sft_idx);
2915 2928 sip[sftp->sft_sdp->sd_symndx].si_boundto = dftp->dft_ndx;
2916 2929 }
2917 2930
2918 2931 /*
2919 2932 * Display debugging information about section.
2920 2933 */
2921 2934 DBG_CALL(Dbg_syminfo_title(ofl->ofl_lml));
2922 2935 if (DBG_ENABLED) {
2923 2936 Word _cnt, cnt = shdr->sh_size / shdr->sh_entsize;
2924 2937 Sym *symtab = symosp->os_outdata->d_buf;
2925 2938 Dyn *dyn;
2926 2939
2927 2940 if (ofl->ofl_osdynamic)
2928 2941 dyn = ofl->ofl_osdynamic->os_outdata->d_buf;
2929 2942 else
2930 2943 dyn = NULL;
2931 2944
2932 2945 for (_cnt = 1; _cnt < cnt; _cnt++) {
2933 2946 if (sip[_cnt].si_flags || sip[_cnt].si_boundto)
2934 2947 /* LINTED */
2935 2948 DBG_CALL(Dbg_syminfo_entry(ofl->ofl_lml, _cnt,
2936 2949 &sip[_cnt], &symtab[_cnt], strtab, dyn));
2937 2950 }
2938 2951 }
2939 2952 return (1);
2940 2953 }
2941 2954
2942 2955 /*
2943 2956 * Build the output elf header.
2944 2957 */
2945 2958 static uintptr_t
2946 2959 update_oehdr(Ofl_desc * ofl)
2947 2960 {
2948 2961 Ehdr *ehdr = ofl->ofl_nehdr;
2949 2962
2950 2963 /*
2951 2964 * If an entry point symbol has already been established (refer
2952 2965 * sym_validate()) simply update the elf header entry point with the
2953 2966 * symbols value. If no entry point is defined it will have been filled
2954 2967 * with the start address of the first section within the text segment
2955 2968 * (refer update_outfile()).
2956 2969 */
2957 2970 if (ofl->ofl_entry)
2958 2971 ehdr->e_entry =
2959 2972 ((Sym_desc *)(ofl->ofl_entry))->sd_sym->st_value;
2960 2973
2961 2974 ehdr->e_ident[EI_DATA] = ld_targ.t_m.m_data;
2962 2975 ehdr->e_version = ofl->ofl_dehdr->e_version;
2963 2976
2964 2977 /*
2965 2978 * When generating a relocatable object under -z symbolcap, set the
2966 2979 * e_machine to be generic, and remove any e_flags. Input relocatable
2967 2980 * objects may identify alternative e_machine (m.machplus) and e_flags
2968 2981 * values. However, the functions within the created output object
2969 2982 * are selected at runtime using the capabilities mechanism, which
2970 2983 * supersedes the e-machine and e_flags information. Therefore,
2971 2984 * e_machine and e_flag values are not propagated to the output object,
2972 2985 * as these values might prevent the kernel from loading the object
2973 2986 * before the runtime linker gets control.
2974 2987 */
2975 2988 if (ofl->ofl_flags & FLG_OF_OTOSCAP) {
2976 2989 ehdr->e_machine = ld_targ.t_m.m_mach;
2977 2990 ehdr->e_flags = 0;
2978 2991 } else {
2979 2992 /*
2980 2993 * Note. it may be necessary to update the e_flags field in the
2981 2994 * machine dependent section.
2982 2995 */
2983 2996 ehdr->e_machine = ofl->ofl_dehdr->e_machine;
2984 2997 ehdr->e_flags = ofl->ofl_dehdr->e_flags;
2985 2998
2986 2999 if (ehdr->e_machine != ld_targ.t_m.m_mach) {
2987 3000 if (ehdr->e_machine != ld_targ.t_m.m_machplus)
2988 3001 return (S_ERROR);
2989 3002 if ((ehdr->e_flags & ld_targ.t_m.m_flagsplus) == 0)
2990 3003 return (S_ERROR);
2991 3004 }
2992 3005 }
2993 3006
2994 3007 if (ofl->ofl_flags & FLG_OF_SHAROBJ)
2995 3008 ehdr->e_type = ET_DYN;
2996 3009 else if (ofl->ofl_flags & FLG_OF_RELOBJ)
2997 3010 ehdr->e_type = ET_REL;
2998 3011 else
2999 3012 ehdr->e_type = ET_EXEC;
3000 3013
3001 3014 return (1);
3002 3015 }
3003 3016
3004 3017 /*
3005 3018 * Perform move table expansion.
3006 3019 */
3007 3020 static void
3008 3021 expand_move(Ofl_desc *ofl, Sym_desc *sdp, Move *mvp)
3009 3022 {
3010 3023 Os_desc *osp;
3011 3024 uchar_t *taddr, *taddr0;
3012 3025 Sxword offset;
3013 3026 Half cnt;
3014 3027 uint_t stride;
3015 3028
3016 3029 osp = ofl->ofl_isparexpn->is_osdesc;
3017 3030 offset = sdp->sd_sym->st_value - osp->os_shdr->sh_addr;
3018 3031
3019 3032 taddr0 = taddr = osp->os_outdata->d_buf;
3020 3033 taddr += offset;
3021 3034 taddr = taddr + mvp->m_poffset;
3022 3035
3023 3036 for (cnt = 0; cnt < mvp->m_repeat; cnt++) {
3024 3037 /* LINTED */
3025 3038 DBG_CALL(Dbg_move_expand(ofl->ofl_lml, mvp,
3026 3039 (Addr)(taddr - taddr0)));
3027 3040 stride = (uint_t)mvp->m_stride + 1;
3028 3041
3029 3042 /*
3030 3043 * Update the target address based upon the move entry size.
3031 3044 * This size was validated in ld_process_move().
3032 3045 */
3033 3046 /* LINTED */
3034 3047 switch (ELF_M_SIZE(mvp->m_info)) {
3035 3048 case 1:
3036 3049 /* LINTED */
3037 3050 *taddr = (uchar_t)mvp->m_value;
3038 3051 taddr += stride;
3039 3052 break;
3040 3053 case 2:
3041 3054 /* LINTED */
3042 3055 *((Half *)taddr) = (Half)mvp->m_value;
3043 3056 taddr += 2 * stride;
3044 3057 break;
3045 3058 case 4:
3046 3059 /* LINTED */
3047 3060 *((Word *)taddr) = (Word)mvp->m_value;
3048 3061 taddr += 4 * stride;
3049 3062 break;
3050 3063 case 8:
3051 3064 /* LINTED */
3052 3065 *((u_longlong_t *)taddr) = mvp->m_value;
3053 3066 taddr += 8 * stride;
3054 3067 break;
3055 3068 }
3056 3069 }
3057 3070 }
3058 3071
3059 3072 /*
3060 3073 * Update Move sections.
3061 3074 */
3062 3075 static void
3063 3076 update_move(Ofl_desc *ofl)
3064 3077 {
3065 3078 Word ndx = 0;
3066 3079 ofl_flag_t flags = ofl->ofl_flags;
3067 3080 Move *omvp;
3068 3081 Aliste idx1;
3069 3082 Sym_desc *sdp;
3070 3083
3071 3084 /*
3072 3085 * Determine the index of the symbol table that will be referenced by
3073 3086 * the Move section.
3074 3087 */
3075 3088 if (OFL_ALLOW_DYNSYM(ofl))
3076 3089 /* LINTED */
3077 3090 ndx = (Word) elf_ndxscn(ofl->ofl_osdynsym->os_scn);
3078 3091 else if (!(flags & FLG_OF_STRIP) || (flags & FLG_OF_RELOBJ))
3079 3092 /* LINTED */
3080 3093 ndx = (Word) elf_ndxscn(ofl->ofl_ossymtab->os_scn);
3081 3094
3082 3095 /*
3083 3096 * Update sh_link of the Move section, and point to the new Move data.
3084 3097 */
3085 3098 if (ofl->ofl_osmove) {
3086 3099 ofl->ofl_osmove->os_shdr->sh_link = ndx;
3087 3100 omvp = (Move *)ofl->ofl_osmove->os_outdata->d_buf;
3088 3101 }
3089 3102
3090 3103 /*
3091 3104 * Update symbol entry index
3092 3105 */
3093 3106 for (APLIST_TRAVERSE(ofl->ofl_parsyms, idx1, sdp)) {
3094 3107 Aliste idx2;
3095 3108 Mv_desc *mdp;
3096 3109
3097 3110 /*
3098 3111 * Expand move table
3099 3112 */
3100 3113 if (sdp->sd_flags & FLG_SY_PAREXPN) {
3101 3114 const char *str;
3102 3115
3103 3116 if (flags & FLG_OF_STATIC)
3104 3117 str = MSG_INTL(MSG_PSYM_EXPREASON1);
3105 3118 else if (ofl->ofl_flags1 & FLG_OF1_NOPARTI)
3106 3119 str = MSG_INTL(MSG_PSYM_EXPREASON2);
3107 3120 else
3108 3121 str = MSG_INTL(MSG_PSYM_EXPREASON3);
3109 3122
3110 3123 DBG_CALL(Dbg_move_parexpn(ofl->ofl_lml,
3111 3124 sdp->sd_name, str));
3112 3125
3113 3126 for (ALIST_TRAVERSE(sdp->sd_move, idx2, mdp)) {
3114 3127 DBG_CALL(Dbg_move_entry1(ofl->ofl_lml, 0,
3115 3128 mdp->md_move, sdp));
3116 3129 expand_move(ofl, sdp, mdp->md_move);
3117 3130 }
3118 3131 continue;
3119 3132 }
3120 3133
3121 3134 /*
3122 3135 * Process move table
3123 3136 */
3124 3137 DBG_CALL(Dbg_move_outmove(ofl->ofl_lml, sdp->sd_name));
3125 3138
3126 3139 for (ALIST_TRAVERSE(sdp->sd_move, idx2, mdp)) {
3127 3140 Move *imvp;
3128 3141 int idx = 1;
3129 3142 Sym *sym;
3130 3143
3131 3144 imvp = mdp->md_move;
3132 3145 sym = sdp->sd_sym;
3133 3146
3134 3147 DBG_CALL(Dbg_move_entry1(ofl->ofl_lml, 1, imvp, sdp));
3135 3148
3136 3149 *omvp = *imvp;
3137 3150 if ((flags & FLG_OF_RELOBJ) == 0) {
3138 3151 if (ELF_ST_BIND(sym->st_info) == STB_LOCAL) {
3139 3152 Os_desc *osp = sdp->sd_isc->is_osdesc;
3140 3153 Word ndx = osp->os_identndx;
3141 3154
3142 3155 omvp->m_info =
3143 3156 /* LINTED */
3144 3157 ELF_M_INFO(ndx, imvp->m_info);
3145 3158
3146 3159 if (ELF_ST_TYPE(sym->st_info) !=
3147 3160 STT_SECTION) {
3148 3161 omvp->m_poffset =
3149 3162 sym->st_value -
|
↓ open down ↓ |
1369 lines elided |
↑ open up ↑ |
3150 3163 osp->os_shdr->sh_addr +
3151 3164 imvp->m_poffset;
3152 3165 }
3153 3166 } else {
3154 3167 omvp->m_info =
3155 3168 /* LINTED */
3156 3169 ELF_M_INFO(sdp->sd_symndx,
3157 3170 imvp->m_info);
3158 3171 }
3159 3172 } else {
3160 - Boolean isredloc = FALSE;
3173 + Boolean isredloc = FALSE;
3161 3174
3162 3175 if ((ELF_ST_BIND(sym->st_info) == STB_LOCAL) &&
3163 3176 (ofl->ofl_flags & FLG_OF_REDLSYM))
3164 3177 isredloc = TRUE;
3165 3178
3166 3179 if (isredloc && !(sdp->sd_move)) {
3167 3180 Os_desc *osp = sdp->sd_isc->is_osdesc;
3168 3181 Word ndx = osp->os_identndx;
3169 3182
3170 3183 omvp->m_info =
3171 3184 /* LINTED */
3172 3185 ELF_M_INFO(ndx, imvp->m_info);
3173 3186
3174 3187 omvp->m_poffset += sym->st_value;
3175 3188 } else {
3176 3189 if (isredloc)
3177 3190 DBG_CALL(Dbg_syms_reduce(ofl,
3178 3191 DBG_SYM_REDUCE_RETAIN,
3179 3192 sdp, idx,
3180 3193 ofl->ofl_osmove->os_name));
3181 3194
3182 3195 omvp->m_info =
3183 3196 /* LINTED */
3184 3197 ELF_M_INFO(sdp->sd_symndx,
3185 3198 imvp->m_info);
3186 3199 }
3187 3200 }
3188 3201
3189 3202 DBG_CALL(Dbg_move_entry1(ofl->ofl_lml, 0, omvp, sdp));
3190 3203 omvp++;
3191 3204 idx++;
3192 3205 }
3193 3206 }
3194 3207 }
3195 3208
3196 3209 /*
3197 3210 * Scan through the SHT_GROUP output sections. Update their sh_link/sh_info
3198 3211 * fields as well as the section contents.
3199 3212 */
3200 3213 static uintptr_t
3201 3214 update_ogroup(Ofl_desc *ofl)
3202 3215 {
3203 3216 Aliste idx;
3204 3217 Os_desc *osp;
3205 3218 uintptr_t error = 0;
3206 3219
3207 3220 for (APLIST_TRAVERSE(ofl->ofl_osgroups, idx, osp)) {
3208 3221 Is_desc *isp;
3209 3222 Ifl_desc *ifl;
3210 3223 Shdr *shdr = osp->os_shdr;
3211 3224 Sym_desc *sdp;
3212 3225 Xword i, grpcnt;
3213 3226 Word *gdata;
3214 3227
3215 3228 /*
3216 3229 * Since input GROUP sections always create unique
3217 3230 * output GROUP sections - we know there is only one
3218 3231 * item on the list.
3219 3232 */
3220 3233 isp = ld_os_first_isdesc(osp);
3221 3234
3222 3235 ifl = isp->is_file;
3223 3236 sdp = ifl->ifl_oldndx[isp->is_shdr->sh_info];
3224 3237 shdr->sh_link = (Word)elf_ndxscn(ofl->ofl_ossymtab->os_scn);
3225 3238 shdr->sh_info = sdp->sd_symndx;
3226 3239
3227 3240 /*
3228 3241 * Scan through the group data section and update
3229 3242 * all of the links to new values.
3230 3243 */
3231 3244 grpcnt = shdr->sh_size / shdr->sh_entsize;
3232 3245 gdata = (Word *)osp->os_outdata->d_buf;
3233 3246
3234 3247 for (i = 1; i < grpcnt; i++) {
3235 3248 Os_desc *_osp;
3236 3249 Is_desc *_isp = ifl->ifl_isdesc[gdata[i]];
3237 3250
3238 3251 /*
3239 3252 * If the referenced section didn't make it to the
3240 3253 * output file - just zero out the entry.
3241 3254 */
3242 3255 if ((_osp = _isp->is_osdesc) == NULL)
3243 3256 gdata[i] = 0;
3244 3257 else
3245 3258 gdata[i] = (Word)elf_ndxscn(_osp->os_scn);
3246 3259 }
3247 3260 }
3248 3261 return (error);
3249 3262 }
3250 3263
3251 3264 static void
3252 3265 update_ostrtab(Os_desc *osp, Str_tbl *stp, uint_t extra)
3253 3266 {
3254 3267 Elf_Data *data;
3255 3268
3256 3269 if (osp == NULL)
3257 3270 return;
3258 3271
3259 3272 data = osp->os_outdata;
3260 3273 assert(data->d_size == (st_getstrtab_sz(stp) + extra));
3261 3274 (void) st_setstrbuf(stp, data->d_buf, data->d_size - extra);
3262 3275 /* If leaving an extra hole at the end, zero it */
3263 3276 if (extra > 0)
3264 3277 (void) memset((char *)data->d_buf + data->d_size - extra,
3265 3278 0x0, extra);
3266 3279 }
3267 3280
3268 3281 /*
3269 3282 * Update capabilities information.
3270 3283 *
3271 3284 * If string table capabilities exist, then the associated string must be
3272 3285 * translated into an offset into the string table.
3273 3286 */
3274 3287 static void
3275 3288 update_oscap(Ofl_desc *ofl)
3276 3289 {
3277 3290 Os_desc *strosp, *cosp;
3278 3291 Cap *cap;
3279 3292 Str_tbl *strtbl;
3280 3293 Capstr *capstr;
3281 3294 size_t stoff;
3282 3295 Aliste idx1;
3283 3296
3284 3297 /*
3285 3298 * Determine which symbol table or string table is appropriate.
3286 3299 */
3287 3300 if (OFL_IS_STATIC_OBJ(ofl)) {
3288 3301 strosp = ofl->ofl_osstrtab;
3289 3302 strtbl = ofl->ofl_strtab;
3290 3303 } else {
3291 3304 strosp = ofl->ofl_osdynstr;
3292 3305 strtbl = ofl->ofl_dynstrtab;
3293 3306 }
3294 3307
3295 3308 /*
3296 3309 * If symbol capabilities exist, set the sh_link field of the .SUNW_cap
3297 3310 * section to the .SUNW_capinfo section.
3298 3311 */
3299 3312 if (ofl->ofl_oscapinfo) {
3300 3313 cosp = ofl->ofl_oscap;
3301 3314 cosp->os_shdr->sh_link =
3302 3315 (Word)elf_ndxscn(ofl->ofl_oscapinfo->os_scn);
3303 3316 }
3304 3317
3305 3318 /*
3306 3319 * If there are capability strings to process, set the sh_info
3307 3320 * field of the .SUNW_cap section to the associated string table, and
3308 3321 * proceed to process any CA_SUNW_PLAT entries.
3309 3322 */
3310 3323 if ((ofl->ofl_flags & FLG_OF_CAPSTRS) == 0)
3311 3324 return;
3312 3325
3313 3326 cosp = ofl->ofl_oscap;
3314 3327 cosp->os_shdr->sh_info = (Word)elf_ndxscn(strosp->os_scn);
3315 3328
3316 3329 cap = ofl->ofl_oscap->os_outdata->d_buf;
3317 3330
3318 3331 /*
3319 3332 * Determine whether an object capability identifier, or object
3320 3333 * machine/platform capabilities exists.
3321 3334 */
3322 3335 capstr = &ofl->ofl_ocapset.oc_id;
3323 3336 if (capstr->cs_str) {
3324 3337 (void) st_setstring(strtbl, capstr->cs_str, &stoff);
3325 3338 cap[capstr->cs_ndx].c_un.c_ptr = stoff;
3326 3339 }
3327 3340 for (ALIST_TRAVERSE(ofl->ofl_ocapset.oc_plat.cl_val, idx1, capstr)) {
3328 3341 (void) st_setstring(strtbl, capstr->cs_str, &stoff);
3329 3342 cap[capstr->cs_ndx].c_un.c_ptr = stoff;
3330 3343 }
3331 3344 for (ALIST_TRAVERSE(ofl->ofl_ocapset.oc_mach.cl_val, idx1, capstr)) {
3332 3345 (void) st_setstring(strtbl, capstr->cs_str, &stoff);
3333 3346 cap[capstr->cs_ndx].c_un.c_ptr = stoff;
3334 3347 }
3335 3348
3336 3349 /*
3337 3350 * Determine any symbol capability identifiers, or machine/platform
3338 3351 * capabilities.
3339 3352 */
3340 3353 if (ofl->ofl_capgroups) {
3341 3354 Cap_group *cgp;
3342 3355
3343 3356 for (APLIST_TRAVERSE(ofl->ofl_capgroups, idx1, cgp)) {
3344 3357 Objcapset *ocapset = &cgp->cg_set;
3345 3358 Aliste idx2;
3346 3359
3347 3360 capstr = &ocapset->oc_id;
3348 3361 if (capstr->cs_str) {
3349 3362 (void) st_setstring(strtbl, capstr->cs_str,
3350 3363 &stoff);
3351 3364 cap[capstr->cs_ndx].c_un.c_ptr = stoff;
3352 3365 }
3353 3366 for (ALIST_TRAVERSE(ocapset->oc_plat.cl_val, idx2,
3354 3367 capstr)) {
3355 3368 (void) st_setstring(strtbl, capstr->cs_str,
3356 3369 &stoff);
3357 3370 cap[capstr->cs_ndx].c_un.c_ptr = stoff;
3358 3371 }
3359 3372 for (ALIST_TRAVERSE(ocapset->oc_mach.cl_val, idx2,
3360 3373 capstr)) {
3361 3374 (void) st_setstring(strtbl, capstr->cs_str,
3362 3375 &stoff);
3363 3376 cap[capstr->cs_ndx].c_un.c_ptr = stoff;
3364 3377 }
3365 3378 }
3366 3379 }
3367 3380 }
3368 3381
3369 3382 /*
3370 3383 * Update the .SUNW_capinfo, and possibly the .SUNW_capchain sections.
3371 3384 */
3372 3385 static void
3373 3386 update_oscapinfo(Ofl_desc *ofl)
3374 3387 {
3375 3388 Os_desc *symosp, *ciosp, *ccosp = NULL;
3376 3389 Capinfo *ocapinfo;
3377 3390 Capchain *ocapchain;
3378 3391 Cap_avlnode *cav;
3379 3392 Word chainndx = 0;
3380 3393
3381 3394 /*
3382 3395 * Determine which symbol table is appropriate.
3383 3396 */
3384 3397 if (OFL_IS_STATIC_OBJ(ofl))
3385 3398 symosp = ofl->ofl_ossymtab;
3386 3399 else
3387 3400 symosp = ofl->ofl_osdynsym;
3388 3401
3389 3402 /*
3390 3403 * Update the .SUNW_capinfo sh_link to point to the appropriate symbol
3391 3404 * table section. If we're creating a dynamic object, the
3392 3405 * .SUNW_capinfo sh_info is updated to point to the .SUNW_capchain
3393 3406 * section.
3394 3407 */
3395 3408 ciosp = ofl->ofl_oscapinfo;
3396 3409 ciosp->os_shdr->sh_link = (Word)elf_ndxscn(symosp->os_scn);
3397 3410
3398 3411 if (OFL_IS_STATIC_OBJ(ofl) == 0) {
3399 3412 ccosp = ofl->ofl_oscapchain;
3400 3413 ciosp->os_shdr->sh_info = (Word)elf_ndxscn(ccosp->os_scn);
3401 3414 }
3402 3415
3403 3416 /*
3404 3417 * Establish the data for each section. The first element of each
3405 3418 * section defines the section's version number.
3406 3419 */
3407 3420 ocapinfo = ciosp->os_outdata->d_buf;
3408 3421 ocapinfo[0] = CAPINFO_CURRENT;
3409 3422 if (ccosp) {
3410 3423 ocapchain = ccosp->os_outdata->d_buf;
3411 3424 ocapchain[chainndx++] = CAPCHAIN_CURRENT;
3412 3425 }
3413 3426
3414 3427 /*
3415 3428 * Traverse all capabilities families. Each member has a .SUNW_capinfo
3416 3429 * assignment. The .SUNW_capinfo entry differs for relocatable objects
3417 3430 * and dynamic objects.
3418 3431 *
3419 3432 * Relocatable objects:
3420 3433 * ELF_C_GROUP ELF_C_SYM
3421 3434 *
3422 3435 * Family lead: CAPINFO_SUNW_GLOB lead symbol index
3423 3436 * Family lead alias: CAPINFO_SUNW_GLOB lead symbol index
3424 3437 * Family member: .SUNW_cap index lead symbol index
3425 3438 *
3426 3439 * Dynamic objects:
3427 3440 * ELF_C_GROUP ELF_C_SYM
3428 3441 *
3429 3442 * Family lead: CAPINFO_SUNW_GLOB .SUNW_capchain index
3430 3443 * Family lead alias: CAPINFO_SUNW_GLOB .SUNW_capchain index
3431 3444 * Family member: .SUNW_cap index lead symbol index
3432 3445 *
3433 3446 * The ELF_C_GROUP field identifies a capabilities symbol. Lead
3434 3447 * capability symbols, and lead capability aliases are identified by
3435 3448 * a CAPINFO_SUNW_GLOB group identifier. For family members, the
3436 3449 * ELF_C_GROUP provides an index to the associate capabilities group
3437 3450 * (i.e, an index into the SUNW_cap section that defines a group).
3438 3451 *
3439 3452 * For relocatable objects, the ELF_C_SYM field identifies the lead
3440 3453 * capability symbol. For the lead symbol itself, the .SUNW_capinfo
3441 3454 * index is the same as the ELF_C_SYM value. For lead alias symbols,
3442 3455 * the .SUNW_capinfo index differs from the ELF_C_SYM value. This
3443 3456 * differentiation of CAPINFO_SUNW_GLOB symbols allows ld(1) to
3444 3457 * identify, and propagate lead alias symbols. For example, the lead
3445 3458 * capability symbol memcpy() would have the ELF_C_SYM for memcpy(),
3446 3459 * and the lead alias _memcpy() would also have the ELF_C_SYM for
3447 3460 * memcpy().
3448 3461 *
3449 3462 * For dynamic objects, both a lead capability symbol, and alias symbol
3450 3463 * would have a ELF_C_SYM value that represents the same capability
3451 3464 * chain index. The capability chain allows ld.so.1 to traverse a
3452 3465 * family chain for a given lead symbol, and select the most appropriate
3453 3466 * family member. The .SUNW_capchain array contains a series of symbol
3454 3467 * indexes for each family member:
3455 3468 *
3456 3469 * chaincap[n] chaincap[n + 1] chaincap[n + 2] chaincap[n + x]
3457 3470 * foo() ndx foo%x() ndx foo%y() ndx 0
3458 3471 *
3459 3472 * For family members, the ELF_C_SYM value associates the capability
3460 3473 * members with their family lead symbol. This association, although
3461 3474 * unused within a dynamic object, allows ld(1) to identify, and
3462 3475 * propagate family members when processing relocatable objects.
3463 3476 */
3464 3477 for (cav = avl_first(ofl->ofl_capfamilies); cav;
3465 3478 cav = AVL_NEXT(ofl->ofl_capfamilies, cav)) {
3466 3479 Cap_sym *csp;
3467 3480 Aliste idx;
3468 3481 Sym_desc *asdp, *lsdp = cav->cn_symavlnode.sav_sdp;
3469 3482
3470 3483 if (ccosp) {
3471 3484 /*
3472 3485 * For a dynamic object, identify this lead symbol, and
3473 3486 * point it to the head of a capability chain. Set the
3474 3487 * head of the capability chain to the same lead symbol.
3475 3488 */
3476 3489 ocapinfo[lsdp->sd_symndx] =
3477 3490 ELF_C_INFO(chainndx, CAPINFO_SUNW_GLOB);
3478 3491 ocapchain[chainndx] = lsdp->sd_symndx;
3479 3492 } else {
3480 3493 /*
3481 3494 * For a relocatable object, identify this lead symbol,
3482 3495 * and set the lead symbol index to itself.
3483 3496 */
3484 3497 ocapinfo[lsdp->sd_symndx] =
3485 3498 ELF_C_INFO(lsdp->sd_symndx, CAPINFO_SUNW_GLOB);
3486 3499 }
3487 3500
3488 3501 /*
3489 3502 * Gather any lead symbol aliases.
3490 3503 */
3491 3504 for (APLIST_TRAVERSE(cav->cn_aliases, idx, asdp)) {
3492 3505 if (ccosp) {
3493 3506 /*
3494 3507 * For a dynamic object, identify this lead
3495 3508 * alias symbol, and point it to the same
3496 3509 * capability chain index as the lead symbol.
3497 3510 */
3498 3511 ocapinfo[asdp->sd_symndx] =
3499 3512 ELF_C_INFO(chainndx, CAPINFO_SUNW_GLOB);
3500 3513 } else {
3501 3514 /*
3502 3515 * For a relocatable object, identify this lead
3503 3516 * alias symbol, and set the lead symbol index
3504 3517 * to the lead symbol.
3505 3518 */
3506 3519 ocapinfo[asdp->sd_symndx] =
3507 3520 ELF_C_INFO(lsdp->sd_symndx,
3508 3521 CAPINFO_SUNW_GLOB);
3509 3522 }
3510 3523 }
3511 3524
3512 3525 chainndx++;
3513 3526
3514 3527 /*
3515 3528 * Gather the family members.
3516 3529 */
3517 3530 for (APLIST_TRAVERSE(cav->cn_members, idx, csp)) {
3518 3531 Sym_desc *msdp = csp->cs_sdp;
3519 3532
3520 3533 /*
3521 3534 * Identify the members capability group, and the lead
3522 3535 * symbol of the family this symbol is a member of.
3523 3536 */
3524 3537 ocapinfo[msdp->sd_symndx] =
3525 3538 ELF_C_INFO(lsdp->sd_symndx, csp->cs_group->cg_ndx);
3526 3539 if (ccosp) {
3527 3540 /*
3528 3541 * For a dynamic object, set the next capability
3529 3542 * chain to point to this family member.
3530 3543 */
3531 3544 ocapchain[chainndx++] = msdp->sd_symndx;
3532 3545 }
3533 3546 }
3534 3547
3535 3548 /*
3536 3549 * Any chain of family members is terminated with a 0 element.
3537 3550 */
3538 3551 if (ccosp)
3539 3552 ocapchain[chainndx++] = 0;
3540 3553 }
3541 3554 }
3542 3555
3543 3556 /*
3544 3557 * Translate the shdr->sh_{link, info} from its input section value to that
3545 3558 * of the corresponding shdr->sh_{link, info} output section value.
3546 3559 */
3547 3560 static Word
3548 3561 translate_link(Ofl_desc *ofl, Os_desc *osp, Word link, const char *msg)
3549 3562 {
3550 3563 Is_desc *isp;
3551 3564 Ifl_desc *ifl;
3552 3565
3553 3566 /*
3554 3567 * Don't translate the special section numbers.
3555 3568 */
3556 3569 if (link >= SHN_LORESERVE)
3557 3570 return (link);
3558 3571
3559 3572 /*
3560 3573 * Does this output section translate back to an input file. If not
3561 3574 * then there is no translation to do. In this case we will assume that
3562 3575 * if sh_link has a value, it's the right value.
3563 3576 */
3564 3577 isp = ld_os_first_isdesc(osp);
3565 3578 if ((ifl = isp->is_file) == NULL)
3566 3579 return (link);
3567 3580
3568 3581 /*
3569 3582 * Sanity check to make sure that the sh_{link, info} value
3570 3583 * is within range for the input file.
3571 3584 */
3572 3585 if (link >= ifl->ifl_shnum) {
3573 3586 ld_eprintf(ofl, ERR_WARNING, msg, ifl->ifl_name,
3574 3587 EC_WORD(isp->is_scnndx), isp->is_name, EC_XWORD(link));
3575 3588 return (link);
3576 3589 }
3577 3590
3578 3591 /*
3579 3592 * Follow the link to the input section.
3580 3593 */
3581 3594 if ((isp = ifl->ifl_isdesc[link]) == NULL)
3582 3595 return (0);
3583 3596 if ((osp = isp->is_osdesc) == NULL)
3584 3597 return (0);
3585 3598
3586 3599 /* LINTED */
3587 3600 return ((Word)elf_ndxscn(osp->os_scn));
3588 3601 }
3589 3602
3590 3603 /*
3591 3604 * Having created all of the necessary sections, segments, and associated
3592 3605 * headers, fill in the program headers and update any other data in the
3593 3606 * output image. Some general rules:
3594 3607 *
3595 3608 * - If an interpreter is required always generate a PT_PHDR entry as
3596 3609 * well. It is this entry that triggers the kernel into passing the
3597 3610 * interpreter an aux vector instead of just a file descriptor.
3598 3611 *
3599 3612 * - When generating an image that will be interpreted (ie. a dynamic
3600 3613 * executable, a shared object, or a static executable that has been
3601 3614 * provided with an interpreter - weird, but possible), make the initial
3602 3615 * loadable segment include both the ehdr and phdr[]. Both of these
3603 3616 * tables are used by the interpreter therefore it seems more intuitive
3604 3617 * to explicitly defined them as part of the mapped image rather than
3605 3618 * relying on page rounding by the interpreter to allow their access.
3606 3619 *
3607 3620 * - When generating a static image that does not require an interpreter
3608 3621 * have the first loadable segment indicate the address of the first
3609 3622 * .section as the start address (things like /kernel/unix and ufsboot
3610 3623 * expect this behavior).
3611 3624 */
3612 3625 uintptr_t
3613 3626 ld_update_outfile(Ofl_desc *ofl)
3614 3627 {
3615 3628 Addr size, etext, vaddr;
3616 3629 Sg_desc *sgp;
3617 3630 Sg_desc *dtracesgp = NULL, *capsgp = NULL, *intpsgp = NULL;
3618 3631 Os_desc *osp;
3619 3632 int phdrndx = 0, segndx = -1, secndx, intppndx, intpsndx;
3620 3633 int dtracepndx, dtracesndx, cappndx, capsndx;
3621 3634 Ehdr *ehdr = ofl->ofl_nehdr;
3622 3635 Shdr *hshdr;
3623 3636 Phdr *_phdr = NULL;
3624 3637 Word phdrsz = (ehdr->e_phnum * ehdr->e_phentsize), shscnndx;
3625 3638 ofl_flag_t flags = ofl->ofl_flags;
3626 3639 Word ehdrsz = ehdr->e_ehsize;
3627 3640 Boolean nobits;
3628 3641 Off offset;
3629 3642 Aliste idx1;
3630 3643
3631 3644 /*
3632 3645 * Initialize the starting address for the first segment. Executables
3633 3646 * have different starting addresses depending upon the target ABI,
3634 3647 * where as shared objects have a starting address of 0. If this is
3635 3648 * a 64-bit executable that is being constructed to run in a restricted
3636 3649 * address space, use an alternative origin that will provide more free
3637 3650 * address space for the the eventual process.
3638 3651 */
3639 3652 if (ofl->ofl_flags & FLG_OF_EXEC) {
3640 3653 #if defined(_ELF64)
3641 3654 if (ofl->ofl_ocapset.oc_sf_1.cm_val & SF1_SUNW_ADDR32)
3642 3655 vaddr = ld_targ.t_m.m_segm_aorigin;
3643 3656 else
3644 3657 #endif
|
↓ open down ↓ |
474 lines elided |
↑ open up ↑ |
3645 3658 vaddr = ld_targ.t_m.m_segm_origin;
3646 3659 } else
3647 3660 vaddr = 0;
3648 3661
3649 3662 /*
3650 3663 * Loop through the segment descriptors and pick out what we need.
3651 3664 */
3652 3665 DBG_CALL(Dbg_seg_title(ofl->ofl_lml));
3653 3666 for (APLIST_TRAVERSE(ofl->ofl_segs, idx1, sgp)) {
3654 3667 Phdr *phdr = &(sgp->sg_phdr);
3655 - Xword p_align;
3668 + Xword p_align;
3656 3669 Aliste idx2;
3657 3670 Sym_desc *sdp;
3658 3671
3659 3672 segndx++;
3660 3673
3661 3674 /*
3662 3675 * If an interpreter is required generate a PT_INTERP and
3663 3676 * PT_PHDR program header entry. The PT_PHDR entry describes
3664 3677 * the program header table itself. This information will be
3665 3678 * passed via the aux vector to the interpreter (ld.so.1).
3666 3679 * The program header array is actually part of the first
3667 3680 * loadable segment (and the PT_PHDR entry is the first entry),
3668 3681 * therefore its virtual address isn't known until the first
3669 3682 * loadable segment is processed.
3670 3683 */
3671 3684 if (phdr->p_type == PT_PHDR) {
3672 3685 if (ofl->ofl_osinterp) {
3673 3686 phdr->p_offset = ehdr->e_phoff;
3674 3687 phdr->p_filesz = phdr->p_memsz = phdrsz;
3675 3688
3676 3689 DBG_CALL(Dbg_seg_entry(ofl, segndx, sgp));
3677 3690 ofl->ofl_phdr[phdrndx++] = *phdr;
3678 3691 }
3679 3692 continue;
3680 3693 }
3681 3694 if (phdr->p_type == PT_INTERP) {
3682 3695 if (ofl->ofl_osinterp) {
3683 3696 intpsgp = sgp;
3684 3697 intpsndx = segndx;
3685 3698 intppndx = phdrndx++;
3686 3699 }
3687 3700 continue;
3688 3701 }
3689 3702
3690 3703 /*
3691 3704 * If we are creating a PT_SUNWDTRACE segment, remember where
3692 3705 * the program header is. The header values are assigned after
3693 3706 * update_osym() has completed and the symbol table addresses
3694 3707 * have been updated.
3695 3708 */
3696 3709 if (phdr->p_type == PT_SUNWDTRACE) {
3697 3710 if (ofl->ofl_dtracesym &&
3698 3711 ((flags & FLG_OF_RELOBJ) == 0)) {
3699 3712 dtracesgp = sgp;
3700 3713 dtracesndx = segndx;
3701 3714 dtracepndx = phdrndx++;
3702 3715 }
3703 3716 continue;
3704 3717 }
3705 3718
3706 3719 /*
3707 3720 * If a hardware/software capabilities section is required,
3708 3721 * generate the PT_SUNWCAP header. Note, as this comes before
3709 3722 * the first loadable segment, we don't yet know its real
3710 3723 * virtual address. This is updated later.
3711 3724 */
3712 3725 if (phdr->p_type == PT_SUNWCAP) {
3713 3726 if (ofl->ofl_oscap && (ofl->ofl_flags & FLG_OF_PTCAP) &&
3714 3727 ((flags & FLG_OF_RELOBJ) == 0)) {
3715 3728 capsgp = sgp;
3716 3729 capsndx = segndx;
3717 3730 cappndx = phdrndx++;
3718 3731 }
3719 3732 continue;
3720 3733 }
3721 3734
3722 3735 /*
3723 3736 * As the dynamic program header occurs after the loadable
3724 3737 * headers in the segment descriptor table, all the address
3725 3738 * information for the .dynamic output section will have been
3726 3739 * figured out by now.
3727 3740 */
3728 3741 if (phdr->p_type == PT_DYNAMIC) {
3729 3742 if (OFL_ALLOW_DYNSYM(ofl)) {
3730 3743 Shdr *shdr = ofl->ofl_osdynamic->os_shdr;
3731 3744
3732 3745 phdr->p_vaddr = shdr->sh_addr;
3733 3746 phdr->p_offset = shdr->sh_offset;
3734 3747 phdr->p_filesz = shdr->sh_size;
3735 3748 phdr->p_flags = ld_targ.t_m.m_dataseg_perm;
3736 3749
3737 3750 DBG_CALL(Dbg_seg_entry(ofl, segndx, sgp));
3738 3751 ofl->ofl_phdr[phdrndx++] = *phdr;
3739 3752 }
3740 3753 continue;
3741 3754 }
3742 3755
3743 3756 /*
3744 3757 * As the unwind (.eh_frame_hdr) program header occurs after
3745 3758 * the loadable headers in the segment descriptor table, all
3746 3759 * the address information for the .eh_frame output section
3747 3760 * will have been figured out by now.
3748 3761 */
3749 3762 if (phdr->p_type == PT_SUNW_UNWIND) {
3750 3763 Shdr *shdr;
3751 3764
3752 3765 if (ofl->ofl_unwindhdr == NULL)
3753 3766 continue;
3754 3767
3755 3768 shdr = ofl->ofl_unwindhdr->os_shdr;
3756 3769
3757 3770 phdr->p_flags = PF_R;
3758 3771 phdr->p_vaddr = shdr->sh_addr;
3759 3772 phdr->p_memsz = shdr->sh_size;
3760 3773 phdr->p_filesz = shdr->sh_size;
3761 3774 phdr->p_offset = shdr->sh_offset;
3762 3775 phdr->p_align = shdr->sh_addralign;
3763 3776 phdr->p_paddr = 0;
3764 3777 ofl->ofl_phdr[phdrndx++] = *phdr;
3765 3778 continue;
3766 3779 }
3767 3780
3768 3781 /*
3769 3782 * The sunwstack program is used to convey non-default
3770 3783 * flags for the process stack. Only emit it if it would
3771 3784 * change the default.
3772 3785 */
3773 3786 if (phdr->p_type == PT_SUNWSTACK) {
3774 3787 if (((flags & FLG_OF_RELOBJ) == 0) &&
3775 3788 ((sgp->sg_flags & FLG_SG_DISABLED) == 0))
3776 3789 ofl->ofl_phdr[phdrndx++] = *phdr;
3777 3790 continue;
3778 3791 }
3779 3792
3780 3793 /*
3781 3794 * As the TLS program header occurs after the loadable
3782 3795 * headers in the segment descriptor table, all the address
3783 3796 * information for the .tls output section will have been
3784 3797 * figured out by now.
3785 3798 */
3786 3799 if (phdr->p_type == PT_TLS) {
3787 3800 Os_desc *tlsosp;
3788 3801 Shdr *lastfileshdr = NULL;
3789 3802 Shdr *firstshdr = NULL, *lastshdr;
3790 3803 Aliste idx;
3791 3804
3792 3805 if (ofl->ofl_ostlsseg == NULL)
3793 3806 continue;
3794 3807
3795 3808 /*
3796 3809 * Scan the output sections that have contributed TLS.
3797 3810 * Remember the first and last so as to determine the
3798 3811 * TLS memory size requirement. Remember the last
3799 3812 * progbits section to determine the TLS data
3800 3813 * contribution, which determines the TLS program
3801 3814 * header filesz.
3802 3815 */
3803 3816 for (APLIST_TRAVERSE(ofl->ofl_ostlsseg, idx, tlsosp)) {
3804 3817 Shdr *tlsshdr = tlsosp->os_shdr;
3805 3818
3806 3819 if (firstshdr == NULL)
3807 3820 firstshdr = tlsshdr;
3808 3821 if (tlsshdr->sh_type != SHT_NOBITS)
3809 3822 lastfileshdr = tlsshdr;
3810 3823 lastshdr = tlsshdr;
3811 3824 }
3812 3825
3813 3826 phdr->p_flags = PF_R | PF_W;
3814 3827 phdr->p_vaddr = firstshdr->sh_addr;
3815 3828 phdr->p_offset = firstshdr->sh_offset;
3816 3829 phdr->p_align = firstshdr->sh_addralign;
3817 3830
3818 3831 /*
3819 3832 * Determine the initialized TLS data size. This
3820 3833 * address range is from the start of the TLS segment
3821 3834 * to the end of the last piece of initialized data.
3822 3835 */
3823 3836 if (lastfileshdr)
3824 3837 phdr->p_filesz = lastfileshdr->sh_offset +
3825 3838 lastfileshdr->sh_size - phdr->p_offset;
3826 3839 else
3827 3840 phdr->p_filesz = 0;
3828 3841
3829 3842 /*
3830 3843 * Determine the total TLS memory size. This includes
3831 3844 * all TLS data and TLS uninitialized data. This
3832 3845 * address range is from the start of the TLS segment
3833 3846 * to the memory address of the last piece of
3834 3847 * uninitialized data.
3835 3848 */
3836 3849 phdr->p_memsz = lastshdr->sh_addr +
3837 3850 lastshdr->sh_size - phdr->p_vaddr;
3838 3851
3839 3852 DBG_CALL(Dbg_seg_entry(ofl, segndx, sgp));
3840 3853 ofl->ofl_phdr[phdrndx] = *phdr;
3841 3854 ofl->ofl_tlsphdr = &ofl->ofl_phdr[phdrndx++];
3842 3855 continue;
3843 3856 }
3844 3857
3845 3858 /*
3846 3859 * If this is an empty segment declaration, it will occur after
3847 3860 * all other loadable segments. As empty segments can be
3848 3861 * defined with fixed addresses, make sure that no loadable
3849 3862 * segments overlap. This might occur as the object evolves
3850 3863 * and the loadable segments grow, thus encroaching upon an
3851 3864 * existing segment reservation.
3852 3865 *
3853 3866 * Segments are only created for dynamic objects, thus this
3854 3867 * checking can be skipped when building a relocatable object.
3855 3868 */
3856 3869 if (!(flags & FLG_OF_RELOBJ) &&
3857 3870 (sgp->sg_flags & FLG_SG_EMPTY)) {
3858 3871 int i;
3859 3872 Addr v_e;
3860 3873
3861 3874 vaddr = phdr->p_vaddr;
3862 3875 phdr->p_memsz = sgp->sg_length;
3863 3876 DBG_CALL(Dbg_seg_entry(ofl, segndx, sgp));
3864 3877 ofl->ofl_phdr[phdrndx++] = *phdr;
|
↓ open down ↓ |
199 lines elided |
↑ open up ↑ |
3865 3878
3866 3879 if (phdr->p_type != PT_LOAD)
3867 3880 continue;
3868 3881
3869 3882 v_e = vaddr + phdr->p_memsz;
3870 3883
3871 3884 /*
3872 3885 * Check overlaps
3873 3886 */
3874 3887 for (i = 0; i < phdrndx - 1; i++) {
3875 - Addr p_s = (ofl->ofl_phdr[i]).p_vaddr;
3876 - Addr p_e;
3888 + Addr p_s = (ofl->ofl_phdr[i]).p_vaddr;
3889 + Addr p_e;
3877 3890
3878 3891 if ((ofl->ofl_phdr[i]).p_type != PT_LOAD)
3879 3892 continue;
3880 3893
3881 3894 p_e = p_s + (ofl->ofl_phdr[i]).p_memsz;
3882 3895 if (((p_s <= vaddr) && (p_e > vaddr)) ||
3883 3896 ((vaddr <= p_s) && (v_e > p_s)))
3884 3897 ld_eprintf(ofl, ERR_WARNING,
3885 3898 MSG_INTL(MSG_UPD_SEGOVERLAP),
3886 3899 ofl->ofl_name, EC_ADDR(p_e),
3887 3900 sgp->sg_name, EC_ADDR(vaddr));
3888 3901 }
3889 3902 continue;
3890 3903 }
3891 3904
3892 3905 /*
3893 3906 * Having processed any of the special program headers any
3894 3907 * remaining headers will be built to express individual
3895 3908 * segments. Segments are only built if they have output
3896 3909 * section descriptors associated with them (ie. some form of
3897 3910 * input section has been matched to this segment).
3898 3911 */
3899 3912 if (sgp->sg_osdescs == NULL)
3900 3913 continue;
3901 3914
3902 3915 /*
3903 3916 * Determine the segments offset and size from the section
3904 3917 * information provided from elf_update().
3905 3918 * Allow for multiple NOBITS sections.
3906 3919 */
3907 3920 osp = sgp->sg_osdescs->apl_data[0];
3908 3921 hshdr = osp->os_shdr;
3909 3922
3910 3923 phdr->p_filesz = 0;
3911 3924 phdr->p_memsz = 0;
3912 3925 phdr->p_offset = offset = hshdr->sh_offset;
3913 3926
3914 3927 nobits = ((hshdr->sh_type == SHT_NOBITS) &&
3915 3928 ((sgp->sg_flags & FLG_SG_PHREQ) == 0));
3916 3929
3917 3930 for (APLIST_TRAVERSE(sgp->sg_osdescs, idx2, osp)) {
3918 3931 Shdr *shdr = osp->os_shdr;
3919 3932
3920 3933 p_align = 0;
3921 3934 if (shdr->sh_addralign > p_align)
3922 3935 p_align = shdr->sh_addralign;
3923 3936
3924 3937 offset = (Off)S_ROUND(offset, shdr->sh_addralign);
3925 3938 offset += shdr->sh_size;
3926 3939
3927 3940 if (shdr->sh_type != SHT_NOBITS) {
3928 3941 if (nobits) {
3929 3942 ld_eprintf(ofl, ERR_FATAL,
3930 3943 MSG_INTL(MSG_UPD_NOBITS));
3931 3944 return (S_ERROR);
3932 3945 }
3933 3946 phdr->p_filesz = offset - phdr->p_offset;
3934 3947 } else if ((sgp->sg_flags & FLG_SG_PHREQ) == 0)
3935 3948 nobits = TRUE;
3936 3949 }
3937 3950 phdr->p_memsz = offset - hshdr->sh_offset;
3938 3951
3939 3952 /*
3940 3953 * If this is the first loadable segment of a dynamic object,
3941 3954 * or an interpreter has been specified (a static object built
3942 3955 * with an interpreter will still be given a PT_HDR entry), then
3943 3956 * compensate for the elf header and program header array. Both
3944 3957 * of these are actually part of the loadable segment as they
3945 3958 * may be inspected by the interpreter. Adjust the segments
3946 3959 * size and offset accordingly.
3947 3960 */
3948 3961 if ((_phdr == NULL) && (phdr->p_type == PT_LOAD) &&
3949 3962 ((ofl->ofl_osinterp) || (flags & FLG_OF_DYNAMIC)) &&
3950 3963 (!(ofl->ofl_dtflags_1 & DF_1_NOHDR))) {
3951 3964 size = (Addr)S_ROUND((phdrsz + ehdrsz),
3952 3965 hshdr->sh_addralign);
3953 3966 phdr->p_offset -= size;
3954 3967 phdr->p_filesz += size;
3955 3968 phdr->p_memsz += size;
3956 3969 }
3957 3970
3958 3971 /*
3959 3972 * If segment size symbols are required (specified via a
3960 3973 * mapfile) update their value.
3961 3974 */
3962 3975 for (APLIST_TRAVERSE(sgp->sg_sizesym, idx2, sdp))
3963 3976 sdp->sd_sym->st_value = phdr->p_memsz;
3964 3977
3965 3978 /*
3966 3979 * If no file content has been assigned to this segment (it
3967 3980 * only contains no-bits sections), then reset the offset for
3968 3981 * consistency.
3969 3982 */
3970 3983 if (phdr->p_filesz == 0)
3971 3984 phdr->p_offset = 0;
3972 3985
3973 3986 /*
3974 3987 * If a virtual address has been specified for this segment
3975 3988 * from a mapfile use it and make sure the previous segment
3976 3989 * does not run into this segment.
3977 3990 */
3978 3991 if (phdr->p_type == PT_LOAD) {
3979 3992 if ((sgp->sg_flags & FLG_SG_P_VADDR)) {
3980 3993 if (_phdr && (vaddr > phdr->p_vaddr) &&
3981 3994 (phdr->p_type == PT_LOAD))
3982 3995 ld_eprintf(ofl, ERR_WARNING,
3983 3996 MSG_INTL(MSG_UPD_SEGOVERLAP),
3984 3997 ofl->ofl_name, EC_ADDR(vaddr),
3985 3998 sgp->sg_name,
3986 3999 EC_ADDR(phdr->p_vaddr));
3987 4000 vaddr = phdr->p_vaddr;
3988 4001 phdr->p_align = 0;
3989 4002 } else {
3990 4003 vaddr = phdr->p_vaddr =
3991 4004 (Addr)S_ROUND(vaddr, phdr->p_align);
3992 4005 }
3993 4006 }
3994 4007
3995 4008 /*
3996 4009 * Adjust the address offset and p_align if needed.
3997 4010 */
3998 4011 if (((sgp->sg_flags & FLG_SG_P_VADDR) == 0) &&
3999 4012 ((ofl->ofl_dtflags_1 & DF_1_NOHDR) == 0)) {
4000 4013 if (phdr->p_align != 0)
4001 4014 vaddr += phdr->p_offset % phdr->p_align;
4002 4015 else
4003 4016 vaddr += phdr->p_offset;
4004 4017 phdr->p_vaddr = vaddr;
4005 4018 }
4006 4019
4007 4020 /*
4008 4021 * If an interpreter is required set the virtual address of the
4009 4022 * PT_PHDR program header now that we know the virtual address
4010 4023 * of the loadable segment that contains it. Update the
4011 4024 * PT_SUNWCAP header similarly.
4012 4025 */
4013 4026 if ((_phdr == NULL) && (phdr->p_type == PT_LOAD)) {
4014 4027 _phdr = phdr;
4015 4028
4016 4029 if ((ofl->ofl_dtflags_1 & DF_1_NOHDR) == 0) {
4017 4030 if (ofl->ofl_osinterp)
4018 4031 ofl->ofl_phdr[0].p_vaddr =
4019 4032 vaddr + ehdrsz;
4020 4033
4021 4034 /*
4022 4035 * Finally, if we're creating a dynamic object
4023 4036 * (or a static object in which an interpreter
4024 4037 * is specified) update the vaddr to reflect
4025 4038 * the address of the first section within this
4026 4039 * segment.
4027 4040 */
4028 4041 if ((ofl->ofl_osinterp) ||
4029 4042 (flags & FLG_OF_DYNAMIC))
4030 4043 vaddr += size;
4031 4044 } else {
4032 4045 /*
4033 4046 * If the DF_1_NOHDR flag was set, and an
4034 4047 * interpreter is being generated, the PT_PHDR
4035 4048 * will not be part of any loadable segment.
4036 4049 */
4037 4050 if (ofl->ofl_osinterp) {
4038 4051 ofl->ofl_phdr[0].p_vaddr = 0;
4039 4052 ofl->ofl_phdr[0].p_memsz = 0;
4040 4053 ofl->ofl_phdr[0].p_flags = 0;
4041 4054 }
4042 4055 }
4043 4056 }
4044 4057
4045 4058 /*
4046 4059 * Ensure the ELF entry point defaults to zero. Typically, this
4047 4060 * value is overridden in update_oehdr() to one of the standard
4048 4061 * entry points. Historically, this default was set to the
4049 4062 * address of first executable section, but this has since been
4050 4063 * found to be more confusing than it is helpful.
4051 4064 */
4052 4065 ehdr->e_entry = 0;
4053 4066
4054 4067 DBG_CALL(Dbg_seg_entry(ofl, segndx, sgp));
4055 4068
4056 4069 /*
4057 4070 * Traverse the output section descriptors for this segment so
4058 4071 * that we can update the section headers addresses. We've
4059 4072 * calculated the virtual address of the initial section within
4060 4073 * this segment, so each successive section can be calculated
4061 4074 * based on their offsets from each other.
4062 4075 */
4063 4076 secndx = 0;
4064 4077 hshdr = 0;
4065 4078 for (APLIST_TRAVERSE(sgp->sg_osdescs, idx2, osp)) {
4066 4079 Shdr *shdr = osp->os_shdr;
4067 4080
4068 4081 if (shdr->sh_link)
4069 4082 shdr->sh_link = translate_link(ofl, osp,
4070 4083 shdr->sh_link, MSG_INTL(MSG_FIL_INVSHLINK));
4071 4084
4072 4085 if (shdr->sh_info && (shdr->sh_flags & SHF_INFO_LINK))
4073 4086 shdr->sh_info = translate_link(ofl, osp,
4074 4087 shdr->sh_info, MSG_INTL(MSG_FIL_INVSHINFO));
4075 4088
4076 4089 if (!(flags & FLG_OF_RELOBJ) &&
4077 4090 (phdr->p_type == PT_LOAD)) {
4078 4091 if (hshdr)
4079 4092 vaddr += (shdr->sh_offset -
4080 4093 hshdr->sh_offset);
4081 4094
4082 4095 shdr->sh_addr = vaddr;
4083 4096 hshdr = shdr;
4084 4097 }
4085 4098
4086 4099 DBG_CALL(Dbg_seg_os(ofl, osp, secndx));
4087 4100 secndx++;
4088 4101 }
4089 4102
4090 4103 /*
4091 4104 * Establish the virtual address of the end of the last section
4092 4105 * in this segment so that the next segments offset can be
4093 4106 * calculated from this.
4094 4107 */
4095 4108 if (hshdr)
4096 4109 vaddr += hshdr->sh_size;
4097 4110
4098 4111 /*
4099 4112 * Output sections for this segment complete. Adjust the
4100 4113 * virtual offset for the last sections size, and make sure we
4101 4114 * haven't exceeded any maximum segment length specification.
4102 4115 */
4103 4116 if ((sgp->sg_length != 0) && (sgp->sg_length < phdr->p_memsz)) {
4104 4117 ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_UPD_LARGSIZE),
4105 4118 ofl->ofl_name, sgp->sg_name,
4106 4119 EC_XWORD(phdr->p_memsz), EC_XWORD(sgp->sg_length));
4107 4120 return (S_ERROR);
4108 4121 }
4109 4122
4110 4123 if (phdr->p_type == PT_NOTE) {
4111 4124 phdr->p_vaddr = 0;
4112 4125 phdr->p_paddr = 0;
4113 4126 phdr->p_align = 0;
4114 4127 phdr->p_memsz = 0;
4115 4128 }
4116 4129
4117 4130 if ((phdr->p_type != PT_NULL) && !(flags & FLG_OF_RELOBJ))
4118 4131 ofl->ofl_phdr[phdrndx++] = *phdr;
4119 4132 }
4120 4133
4121 4134 /*
4122 4135 * Update any new output sections. When building the initial output
4123 4136 * image, a number of sections were created but left uninitialized (eg.
4124 4137 * .dynsym, .dynstr, .symtab, .symtab, etc.). Here we update these
4125 4138 * sections with the appropriate data. Other sections may still be
4126 4139 * modified via reloc_process().
4127 4140 *
4128 4141 * Copy the interpreter name into the .interp section.
4129 4142 */
4130 4143 if (ofl->ofl_interp)
4131 4144 (void) strcpy((char *)ofl->ofl_osinterp->os_outdata->d_buf,
4132 4145 ofl->ofl_interp);
4133 4146
4134 4147 /*
4135 4148 * Update the .shstrtab, .strtab and .dynstr sections.
4136 4149 */
4137 4150 update_ostrtab(ofl->ofl_osshstrtab, ofl->ofl_shdrsttab, 0);
4138 4151 update_ostrtab(ofl->ofl_osstrtab, ofl->ofl_strtab, 0);
4139 4152 update_ostrtab(ofl->ofl_osdynstr, ofl->ofl_dynstrtab, DYNSTR_EXTRA_PAD);
4140 4153
4141 4154 /*
4142 4155 * Build any output symbol tables, the symbols information is copied
4143 4156 * and updated into the new output image.
4144 4157 */
4145 4158 if ((etext = update_osym(ofl)) == (Addr)S_ERROR)
4146 4159 return (S_ERROR);
4147 4160
4148 4161 /*
4149 4162 * If we have an PT_INTERP phdr, update it now from the associated
4150 4163 * section information.
4151 4164 */
4152 4165 if (intpsgp) {
4153 4166 Phdr *phdr = &(intpsgp->sg_phdr);
4154 4167 Shdr *shdr = ofl->ofl_osinterp->os_shdr;
4155 4168
4156 4169 phdr->p_vaddr = shdr->sh_addr;
4157 4170 phdr->p_offset = shdr->sh_offset;
4158 4171 phdr->p_memsz = phdr->p_filesz = shdr->sh_size;
4159 4172 phdr->p_flags = PF_R;
4160 4173
4161 4174 DBG_CALL(Dbg_seg_entry(ofl, intpsndx, intpsgp));
4162 4175 ofl->ofl_phdr[intppndx] = *phdr;
4163 4176 }
4164 4177
4165 4178 /*
4166 4179 * If we have a PT_SUNWDTRACE phdr, update it now with the address of
4167 4180 * the symbol. It's only now been updated via update_sym().
4168 4181 */
4169 4182 if (dtracesgp) {
4170 4183 Phdr *aphdr, *phdr = &(dtracesgp->sg_phdr);
4171 4184 Sym_desc *sdp = ofl->ofl_dtracesym;
4172 4185
4173 4186 phdr->p_vaddr = sdp->sd_sym->st_value;
4174 4187 phdr->p_memsz = sdp->sd_sym->st_size;
4175 4188
4176 4189 /*
4177 4190 * Take permissions from the segment that the symbol is
4178 4191 * associated with.
4179 4192 */
4180 4193 aphdr = &sdp->sd_isc->is_osdesc->os_sgdesc->sg_phdr;
4181 4194 assert(aphdr);
4182 4195 phdr->p_flags = aphdr->p_flags;
4183 4196
4184 4197 DBG_CALL(Dbg_seg_entry(ofl, dtracesndx, dtracesgp));
4185 4198 ofl->ofl_phdr[dtracepndx] = *phdr;
4186 4199 }
4187 4200
4188 4201 /*
4189 4202 * If we have a PT_SUNWCAP phdr, update it now from the associated
4190 4203 * section information.
4191 4204 */
4192 4205 if (capsgp) {
4193 4206 Phdr *phdr = &(capsgp->sg_phdr);
4194 4207 Shdr *shdr = ofl->ofl_oscap->os_shdr;
4195 4208
4196 4209 phdr->p_vaddr = shdr->sh_addr;
4197 4210 phdr->p_offset = shdr->sh_offset;
4198 4211 phdr->p_memsz = phdr->p_filesz = shdr->sh_size;
4199 4212 phdr->p_flags = PF_R;
4200 4213
4201 4214 DBG_CALL(Dbg_seg_entry(ofl, capsndx, capsgp));
4202 4215 ofl->ofl_phdr[cappndx] = *phdr;
4203 4216 }
4204 4217
4205 4218 /*
4206 4219 * Update the GROUP sections.
4207 4220 */
4208 4221 if (update_ogroup(ofl) == S_ERROR)
4209 4222 return (S_ERROR);
4210 4223
4211 4224 /*
4212 4225 * Update Move Table.
4213 4226 */
4214 4227 if (ofl->ofl_osmove || ofl->ofl_isparexpn)
4215 4228 update_move(ofl);
4216 4229
4217 4230 /*
4218 4231 * Build any output headers, version information, dynamic structure and
4219 4232 * syminfo structure.
4220 4233 */
4221 4234 if (update_oehdr(ofl) == S_ERROR)
4222 4235 return (S_ERROR);
4223 4236 if (!(flags & FLG_OF_NOVERSEC)) {
4224 4237 if ((flags & FLG_OF_VERDEF) &&
4225 4238 (update_overdef(ofl) == S_ERROR))
4226 4239 return (S_ERROR);
4227 4240 if ((flags & FLG_OF_VERNEED) &&
4228 4241 (update_overneed(ofl) == S_ERROR))
4229 4242 return (S_ERROR);
4230 4243 if (flags & (FLG_OF_VERNEED | FLG_OF_VERDEF))
4231 4244 update_oversym(ofl);
4232 4245 }
4233 4246 if (flags & FLG_OF_DYNAMIC) {
4234 4247 if (update_odynamic(ofl) == S_ERROR)
4235 4248 return (S_ERROR);
4236 4249 }
4237 4250 if (ofl->ofl_ossyminfo) {
4238 4251 if (update_osyminfo(ofl) == S_ERROR)
4239 4252 return (S_ERROR);
4240 4253 }
4241 4254
4242 4255 /*
4243 4256 * Update capabilities information if required.
4244 4257 */
4245 4258 if (ofl->ofl_oscap)
4246 4259 update_oscap(ofl);
4247 4260 if (ofl->ofl_oscapinfo)
4248 4261 update_oscapinfo(ofl);
4249 4262
4250 4263 /*
4251 4264 * Sanity test: the first and last data byte of a string table
4252 4265 * must be NULL.
4253 4266 */
4254 4267 assert((ofl->ofl_osshstrtab == NULL) ||
4255 4268 (*((char *)ofl->ofl_osshstrtab->os_outdata->d_buf) == '\0'));
4256 4269 assert((ofl->ofl_osshstrtab == NULL) ||
4257 4270 (*(((char *)ofl->ofl_osshstrtab->os_outdata->d_buf) +
4258 4271 ofl->ofl_osshstrtab->os_outdata->d_size - 1) == '\0'));
4259 4272
4260 4273 assert((ofl->ofl_osstrtab == NULL) ||
4261 4274 (*((char *)ofl->ofl_osstrtab->os_outdata->d_buf) == '\0'));
4262 4275 assert((ofl->ofl_osstrtab == NULL) ||
4263 4276 (*(((char *)ofl->ofl_osstrtab->os_outdata->d_buf) +
4264 4277 ofl->ofl_osstrtab->os_outdata->d_size - 1) == '\0'));
4265 4278
4266 4279 assert((ofl->ofl_osdynstr == NULL) ||
4267 4280 (*((char *)ofl->ofl_osdynstr->os_outdata->d_buf) == '\0'));
4268 4281 assert((ofl->ofl_osdynstr == NULL) ||
4269 4282 (*(((char *)ofl->ofl_osdynstr->os_outdata->d_buf) +
4270 4283 ofl->ofl_osdynstr->os_outdata->d_size - DYNSTR_EXTRA_PAD - 1) ==
4271 4284 '\0'));
4272 4285
4273 4286 /*
4274 4287 * Emit Strtab diagnostics.
4275 4288 */
4276 4289 DBG_CALL(Dbg_sec_strtab(ofl->ofl_lml, ofl->ofl_osshstrtab,
4277 4290 ofl->ofl_shdrsttab));
4278 4291 DBG_CALL(Dbg_sec_strtab(ofl->ofl_lml, ofl->ofl_osstrtab,
4279 4292 ofl->ofl_strtab));
4280 4293 DBG_CALL(Dbg_sec_strtab(ofl->ofl_lml, ofl->ofl_osdynstr,
4281 4294 ofl->ofl_dynstrtab));
4282 4295
4283 4296 /*
4284 4297 * Initialize the section headers string table index within the elf
4285 4298 * header.
4286 4299 */
4287 4300 /* LINTED */
4288 4301 if ((shscnndx = elf_ndxscn(ofl->ofl_osshstrtab->os_scn)) <
4289 4302 SHN_LORESERVE) {
4290 4303 ofl->ofl_nehdr->e_shstrndx =
4291 4304 /* LINTED */
4292 4305 (Half)shscnndx;
4293 4306 } else {
4294 4307 /*
4295 4308 * If the STRTAB section index doesn't fit into
4296 4309 * e_shstrndx, then we store it in 'shdr[0].st_link'.
4297 4310 */
4298 4311 Elf_Scn *scn;
4299 4312 Shdr *shdr0;
4300 4313
4301 4314 if ((scn = elf_getscn(ofl->ofl_elf, 0)) == NULL) {
4302 4315 ld_eprintf(ofl, ERR_ELF, MSG_INTL(MSG_ELF_GETSCN),
4303 4316 ofl->ofl_name);
4304 4317 return (S_ERROR);
4305 4318 }
4306 4319 if ((shdr0 = elf_getshdr(scn)) == NULL) {
4307 4320 ld_eprintf(ofl, ERR_ELF, MSG_INTL(MSG_ELF_GETSHDR),
4308 4321 ofl->ofl_name);
4309 4322 return (S_ERROR);
4310 4323 }
4311 4324 ofl->ofl_nehdr->e_shstrndx = SHN_XINDEX;
4312 4325 shdr0->sh_link = shscnndx;
4313 4326 }
4314 4327
4315 4328 return ((uintptr_t)etext);
4316 4329 }
|
↓ open down ↓ |
430 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX