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