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 * Module sections. Initialize special sections
31 */
32
33 #define ELF_TARGET_AMD64
34
35 #include <string.h>
36 #include <strings.h>
37 #include <stdio.h>
38 #include <link.h>
39 #include <debug.h>
40 #include "msg.h"
41 #include "_libld.h"
42
43 inline static void
44 remove_local(Ofl_desc *ofl, Sym_desc *sdp, int allow_ldynsym)
45 {
46 Sym *sym = sdp->sd_sym;
47 uchar_t type = ELF_ST_TYPE(sym->st_info);
48 /* LINTED - only used for assert() */
49 int err;
50
51 if ((ofl->ofl_flags & FLG_OF_REDLSYM) == 0) {
52 ofl->ofl_locscnt--;
53
54 err = st_delstring(ofl->ofl_strtab, sdp->sd_name);
55 assert(err != -1);
56
57 if (allow_ldynsym && ldynsym_symtype[type]) {
58 ofl->ofl_dynlocscnt--;
59
60 err = st_delstring(ofl->ofl_dynstrtab, sdp->sd_name);
61 assert(err != -1);
62 /* Remove from sort section? */
63 DYNSORT_COUNT(sdp, sym, type, --);
64 }
65 }
66 sdp->sd_flags |= FLG_SY_ISDISC;
67 }
68
69 inline static void
70 remove_scoped(Ofl_desc *ofl, Sym_desc *sdp, int allow_ldynsym)
71 {
72 Sym *sym = sdp->sd_sym;
73 uchar_t type = ELF_ST_TYPE(sym->st_info);
74 /* LINTED - only used for assert() */
75 int err;
76
77 ofl->ofl_scopecnt--;
78 ofl->ofl_elimcnt++;
79
80 err = st_delstring(ofl->ofl_strtab, sdp->sd_name);
81 assert(err != -1);
82
83 if (allow_ldynsym && ldynsym_symtype[type]) {
84 ofl->ofl_dynscopecnt--;
85
86 err = st_delstring(ofl->ofl_dynstrtab, sdp->sd_name);
87 assert(err != -1);
88 /* Remove from sort section? */
89 DYNSORT_COUNT(sdp, sym, type, --);
90 }
91 sdp->sd_flags |= FLG_SY_ELIM;
92 }
93
94 inline static void
95 ignore_sym(Ofl_desc *ofl, Ifl_desc *ifl, Sym_desc *sdp, int allow_ldynsym)
96 {
97 Os_desc *osp;
98 Is_desc *isp = sdp->sd_isc;
99 uchar_t bind = ELF_ST_BIND(sdp->sd_sym->st_info);
100
101 if (bind == STB_LOCAL) {
102 uchar_t type = ELF_ST_TYPE(sdp->sd_sym->st_info);
103
104 /*
105 * Skip section symbols, these were never collected in the
106 * first place.
107 */
108 if (type == STT_SECTION)
109 return;
110
111 /*
112 * Determine if the whole file is being removed. Remove any
113 * file symbol, and any symbol that is not associated with a
114 * section, provided the symbol has not been identified as
115 * (update) required.
116 */
117 if (((ifl->ifl_flags & FLG_IF_FILEREF) == 0) &&
118 ((type == STT_FILE) || ((isp == NULL) &&
119 ((sdp->sd_flags & FLG_SY_UPREQD) == 0)))) {
120 DBG_CALL(Dbg_syms_discarded(ofl->ofl_lml, sdp));
121 if (ifl->ifl_flags & FLG_IF_IGNORE)
122 remove_local(ofl, sdp, allow_ldynsym);
123 return;
124 }
125
126 } else {
127 /*
128 * Global symbols can only be eliminated when the interfaces of
129 * an object have been defined via versioning/scoping.
130 */
131 if (!SYM_IS_HIDDEN(sdp))
132 return;
133
134 /*
135 * Remove any unreferenced symbols that are not associated with
136 * a section.
137 */
138 if ((isp == NULL) && ((sdp->sd_flags & FLG_SY_UPREQD) == 0)) {
139 DBG_CALL(Dbg_syms_discarded(ofl->ofl_lml, sdp));
140 if (ifl->ifl_flags & FLG_IF_IGNORE)
141 remove_scoped(ofl, sdp, allow_ldynsym);
142 return;
143 }
144 }
145
146 /*
147 * Do not discard any symbols that are associated with non-allocable
148 * segments.
149 */
150 if (isp && ((isp->is_flags & FLG_IS_SECTREF) == 0) &&
151 ((osp = isp->is_osdesc) != 0) &&
152 (osp->os_sgdesc->sg_phdr.p_type == PT_LOAD)) {
153 DBG_CALL(Dbg_syms_discarded(ofl->ofl_lml, sdp));
154 if (ifl->ifl_flags & FLG_IF_IGNORE) {
155 if (bind == STB_LOCAL)
156 remove_local(ofl, sdp, allow_ldynsym);
157 else
158 remove_scoped(ofl, sdp, allow_ldynsym);
159 }
160 }
161 }
162
163 static Boolean
164 isdesc_discarded(Is_desc *isp)
165 {
166 Ifl_desc *ifl = isp->is_file;
167 Os_desc *osp = isp->is_osdesc;
168 Word ptype = osp->os_sgdesc->sg_phdr.p_type;
169
170 if (isp->is_flags & FLG_IS_DISCARD)
171 return TRUE;
172
173 /*
174 * If the file is discarded, it will take
175 * the section with it.
176 */
177 if (ifl &&
178 (((ifl->ifl_flags & FLG_IF_FILEREF) == 0) ||
179 ((ptype == PT_LOAD) &&
180 ((isp->is_flags & FLG_IS_SECTREF) == 0) &&
181 (isp->is_shdr->sh_size > 0))) &&
182 (ifl->ifl_flags & FLG_IF_IGNORE))
183 return TRUE;
184
185 return FALSE;
186 }
187
188 /*
189 * There are situations where we may count output sections (ofl_shdrcnt)
190 * that are subsequently eliminated from the output object. Whether or
191 * not this happens cannot be known until all input has been seen and
192 * section elimination code has run. However, the situations where this
193 * outcome is possible are known, and are flagged by setting FLG_OF_ADJOSCNT.
194 *
195 * If FLG_OF_ADJOSCNT is set, this routine makes a pass over the output
196 * sections. If an unused output section is encountered, we decrement
197 * ofl->ofl_shdrcnt and remove the section name from the .shstrtab string
198 * table (ofl->ofl_shdrsttab).
199 *
200 * This code must be kept in sync with the similar code
201 * found in outfile.c:ld_create_outfile().
202 */
203 static void
204 adjust_os_count(Ofl_desc *ofl)
205 {
206 Sg_desc *sgp;
207 Is_desc *isp;
208 Os_desc *osp;
209 Aliste idx1;
210
211 if ((ofl->ofl_flags & FLG_OF_ADJOSCNT) == 0)
212 return;
213
214 /*
215 * For each output section, look at the input sections to find at least
216 * one input section that has not been eliminated. If none are found,
217 * the -z ignore processing above has eliminated that output section.
218 */
219 for (APLIST_TRAVERSE(ofl->ofl_segs, idx1, sgp)) {
220 Aliste idx2;
221
222 for (APLIST_TRAVERSE(sgp->sg_osdescs, idx2, osp)) {
223 Aliste idx3;
224 int keep = 0, os_isdescs_idx;
225
226 OS_ISDESCS_TRAVERSE(os_isdescs_idx, osp, idx3, isp) {
227 /*
228 * We have found a kept input section,
229 * so the output section will be created.
230 */
231 if (!isdesc_discarded(isp)) {
232 keep = 1;
233 break;
234 }
235 }
236 /*
237 * If no section of this name was kept, decrement
238 * the count and remove the name from .shstrtab.
239 */
240 if (keep == 0) {
241 /* LINTED - only used for assert() */
242 int err;
243
244 ofl->ofl_shdrcnt--;
245 err = st_delstring(ofl->ofl_shdrsttab,
246 osp->os_name);
247 assert(err != -1);
248 }
249 }
250 }
251 }
252
253 /*
254 * If -zignore has been in effect, scan all input files to determine if the
255 * file, or sections from the file, have been referenced. If not, the file or
256 * some of the files sections can be discarded. If sections are to be
257 * discarded, rescan the output relocations and the symbol table and remove
258 * the relocations and symbol entries that are no longer required.
259 *
260 * Note: It's possible that a section which is being discarded has contributed
261 * to the GOT table or the PLT table. However, we can't at this point
262 * eliminate the corresponding entries. This is because there could well
263 * be other sections referencing those same entries, but we don't have
264 * the infrastructure to determine this. So, keep the PLT and GOT
265 * entries in the table in case someone wants them.
266 * Note: The section to be affected needs to be allocatable.
267 * So even if -zignore is in effect, if the section is not allocatable,
268 * we do not eliminate it.
269 */
270 static uintptr_t
271 ignore_section_processing(Ofl_desc *ofl)
272 {
273 Sg_desc *sgp;
274 Is_desc *isp;
275 Os_desc *osp;
276 Ifl_desc *ifl;
277 Rel_cachebuf *rcbp;
278 Rel_desc *rsp;
279 int allow_ldynsym = OFL_ALLOW_LDYNSYM(ofl);
280 Aliste idx1;
281
282 for (APLIST_TRAVERSE(ofl->ofl_objs, idx1, ifl)) {
283 uint_t num, discard;
284
285 /*
286 * Diagnose (-D unused) a completely unreferenced file.
287 */
288 if ((ifl->ifl_flags & FLG_IF_FILEREF) == 0)
289 DBG_CALL(Dbg_unused_file(ofl->ofl_lml,
290 ifl->ifl_name, 0, 0));
291 if (((ofl->ofl_flags1 & FLG_OF1_IGNPRC) == 0) ||
292 ((ifl->ifl_flags & FLG_IF_IGNORE) == 0))
293 continue;
294
295 /*
296 * Before scanning the whole symbol table to determine if
297 * symbols should be discard - quickly (relatively) scan the
298 * sections to determine if any are to be discarded.
299 */
300 discard = 0;
301 if (ifl->ifl_flags & FLG_IF_FILEREF) {
302 for (num = 1; num < ifl->ifl_shnum; num++) {
303 if (((isp = ifl->ifl_isdesc[num]) != NULL) &&
304 ((isp->is_flags & FLG_IS_SECTREF) == 0) &&
305 ((osp = isp->is_osdesc) != NULL) &&
306 ((sgp = osp->os_sgdesc) != NULL) &&
307 (sgp->sg_phdr.p_type == PT_LOAD)) {
308 discard++;
309 break;
310 }
311 }
312 }
313
314 /*
315 * No sections are to be 'ignored'
316 */
317 if ((discard == 0) && (ifl->ifl_flags & FLG_IF_FILEREF))
318 continue;
319
320 /*
321 * We know that we have discarded sections. Scan the symbol
322 * table for this file to determine if symbols need to be
323 * discarded that are associated with the 'ignored' sections.
324 */
325 for (num = 1; num < ifl->ifl_symscnt; num++) {
326 Sym_desc *sdp;
327
328 /*
329 * If the symbol definition has been resolved to another
330 * file, or the symbol has already been discarded or
331 * eliminated, skip it.
332 */
333 sdp = ifl->ifl_oldndx[num];
334 if ((sdp->sd_file != ifl) ||
335 (sdp->sd_flags &
336 (FLG_SY_ISDISC | FLG_SY_INVALID | FLG_SY_ELIM)))
337 continue;
338
339 /*
340 * Complete the investigation of the symbol.
341 */
342 ignore_sym(ofl, ifl, sdp, allow_ldynsym);
343 }
344 }
345
346 /*
347 * If we were only here to solicit debugging diagnostics, we're done.
348 */
349 if ((ofl->ofl_flags1 & FLG_OF1_IGNPRC) == 0)
350 return (1);
351
352 /*
353 * Scan all output relocations searching for those against discarded or
354 * ignored sections. If one is found, decrement the total outrel count.
355 */
356 REL_CACHE_TRAVERSE(&ofl->ofl_outrels, idx1, rcbp, rsp) {
357 Is_desc *isc = rsp->rel_isdesc;
358 uint_t flags, entsize;
359 Shdr *shdr;
360
361 if ((isc == NULL) || ((isc->is_flags & (FLG_IS_SECTREF))) ||
362 ((ifl = isc->is_file) == NULL) ||
363 ((ifl->ifl_flags & FLG_IF_IGNORE) == 0) ||
364 ((shdr = isc->is_shdr) == NULL) ||
365 ((shdr->sh_flags & SHF_ALLOC) == 0))
366 continue;
367
368 flags = rsp->rel_flags;
369
370 if (flags & (FLG_REL_GOT | FLG_REL_BSS |
371 FLG_REL_NOINFO | FLG_REL_PLT))
372 continue;
373
374 osp = RELAUX_GET_OSDESC(rsp);
375
376 if (rsp->rel_flags & FLG_REL_RELA)
377 entsize = sizeof (Rela);
378 else
379 entsize = sizeof (Rel);
380
381 assert(osp->os_szoutrels > 0);
382 osp->os_szoutrels -= entsize;
383
384 if (!(flags & FLG_REL_PLT))
385 ofl->ofl_reloccntsub++;
386
387 if (rsp->rel_rtype == ld_targ.t_m.m_r_relative)
388 ofl->ofl_relocrelcnt--;
389 }
390
391 /*
392 * As a result of our work here, the number of output sections may
393 * have decreased. Trigger a call to adjust_os_count().
394 */
395 ofl->ofl_flags |= FLG_OF_ADJOSCNT;
396
397 return (1);
398 }
399
400 /*
401 * Allocate Elf_Data, Shdr, and Is_desc structures for a new
402 * section.
403 *
404 * entry:
405 * ofl - Output file descriptor
406 * shtype - SHT_ type code for section.
407 * shname - String giving the name for the new section.
408 * entcnt - # of items contained in the data part of the new section.
409 * This value is multiplied against the known element size
410 * for the section type to determine the size of the data
411 * area for the section. It is only meaningful in cases where
412 * the section type has a non-zero element size. In other cases,
413 * the caller must set the size fields in the *ret_data and
414 * *ret_shdr structs manually.
415 * ret_isec, ret_shdr, ret_data - Address of pointers to
416 * receive address of newly allocated structs.
417 *
418 * exit:
419 * On error, returns S_ERROR. On success, returns (1), and the
420 * ret_ pointers have been updated to point at the new structures,
421 * which have been filled in. To finish the task, the caller must
422 * update any fields within the supplied descriptors that differ
423 * from its needs, and then call ld_place_section().
424 */
425 static uintptr_t
426 new_section(Ofl_desc *ofl, Word shtype, const char *shname, Xword entcnt,
427 Is_desc **ret_isec, Shdr **ret_shdr, Elf_Data **ret_data)
428 {
429 typedef struct sec_info {
430 Word d_type;
431 Word align; /* Used in both data and section header */
432 Word sh_flags;
433 Word sh_entsize;
434 } SEC_INFO_T;
435
436 const SEC_INFO_T *sec_info;
437
438 Shdr *shdr;
439 Elf_Data *data;
440 Is_desc *isec;
441 size_t size;
442
443 /*
444 * For each type of section, we have a distinct set of
445 * SEC_INFO_T values. This macro defines a static structure
446 * containing those values and generates code to set the sec_info
447 * pointer to refer to it. The pointer in sec_info remains valid
448 * outside of the declaration scope because the info_s struct is static.
449 *
450 * We can't determine the value of M_WORD_ALIGN at compile time, so
451 * a different variant is used for those cases.
452 */
453 #define SET_SEC_INFO(d_type, d_align, sh_flags, sh_entsize) \
454 { \
455 static const SEC_INFO_T info_s = { d_type, d_align, sh_flags, \
456 sh_entsize}; \
457 sec_info = &info_s; \
458 }
459 #define SET_SEC_INFO_WORD_ALIGN(d_type, sh_flags, sh_entsize) \
460 { \
461 static SEC_INFO_T info_s = { d_type, 0, sh_flags, \
462 sh_entsize}; \
463 info_s.align = ld_targ.t_m.m_word_align; \
464 sec_info = &info_s; \
465 }
466
467 switch (shtype) {
468 case SHT_PROGBITS:
469 /*
470 * SHT_PROGBITS sections contain are used for many
471 * different sections. Alignments and flags differ.
472 * Some have a standard entsize, and others don't.
473 * We set some defaults here, but there is no expectation
474 * that they are correct or complete for any specific
475 * purpose. The caller must provide the correct values.
476 */
477 SET_SEC_INFO_WORD_ALIGN(ELF_T_BYTE, SHF_ALLOC, 0)
478 break;
479
480 case SHT_SYMTAB:
481 SET_SEC_INFO_WORD_ALIGN(ELF_T_SYM, 0, sizeof (Sym))
482 break;
483
484 case SHT_DYNSYM:
485 SET_SEC_INFO_WORD_ALIGN(ELF_T_SYM, SHF_ALLOC, sizeof (Sym))
486 break;
487
488 case SHT_SUNW_LDYNSYM:
489 ofl->ofl_flags |= FLG_OF_OSABI;
490 SET_SEC_INFO_WORD_ALIGN(ELF_T_SYM, SHF_ALLOC, sizeof (Sym))
491 break;
492
493 case SHT_STRTAB:
494 /*
495 * A string table may or may not be allocable, depending
496 * on context, so we leave that flag unset and leave it to
497 * the caller to add it if necessary.
498 *
499 * String tables do not have a standard entsize, so
500 * we set it to 0.
501 */
502 SET_SEC_INFO(ELF_T_BYTE, 1, SHF_STRINGS, 0)
503 break;
504
505 case SHT_RELA:
506 /*
507 * Relocations with an addend (Everything except 32-bit X86).
508 * The caller is expected to set all section header flags.
509 */
510 SET_SEC_INFO_WORD_ALIGN(ELF_T_RELA, 0, sizeof (Rela))
511 break;
512
513 case SHT_REL:
514 /*
515 * Relocations without an addend (32-bit X86 only).
516 * The caller is expected to set all section header flags.
517 */
518 SET_SEC_INFO_WORD_ALIGN(ELF_T_REL, 0, sizeof (Rel))
519 break;
520
521 case SHT_HASH:
522 SET_SEC_INFO_WORD_ALIGN(ELF_T_WORD, SHF_ALLOC, sizeof (Word))
523 break;
524
525 case SHT_SUNW_symsort:
526 case SHT_SUNW_tlssort:
527 ofl->ofl_flags |= FLG_OF_OSABI;
528 SET_SEC_INFO_WORD_ALIGN(ELF_T_WORD, SHF_ALLOC, sizeof (Word))
529 break;
530
531 case SHT_DYNAMIC:
532 /*
533 * A dynamic section may or may not be allocable, and may or
534 * may not be writable, depending on context, so we leave the
535 * flags unset and leave it to the caller to add them if
536 * necessary.
537 */
538 SET_SEC_INFO_WORD_ALIGN(ELF_T_DYN, 0, sizeof (Dyn))
539 break;
540
541 case SHT_NOBITS:
542 /*
543 * SHT_NOBITS is used for BSS-type sections. The size and
544 * alignment depend on the specific use and must be adjusted
545 * by the caller.
546 */
547 SET_SEC_INFO(ELF_T_BYTE, 0, SHF_ALLOC | SHF_WRITE, 0)
548 break;
549
550 case SHT_INIT_ARRAY:
551 case SHT_FINI_ARRAY:
552 case SHT_PREINIT_ARRAY:
553 SET_SEC_INFO(ELF_T_ADDR, sizeof (Addr), SHF_ALLOC | SHF_WRITE,
554 sizeof (Addr))
555 break;
556
557 case SHT_SYMTAB_SHNDX:
558 /*
559 * Note that these sections are created to be associated
560 * with both symtab and dynsym symbol tables. However, they
561 * are non-allocable in all cases, because the runtime
562 * linker has no need for this information. It is purely
563 * informational, used by elfdump(1), debuggers, etc.
564 */
565 SET_SEC_INFO_WORD_ALIGN(ELF_T_WORD, 0, sizeof (Word));
566 break;
567
568 case SHT_SUNW_cap:
569 ofl->ofl_flags |= FLG_OF_OSABI;
570 SET_SEC_INFO_WORD_ALIGN(ELF_T_CAP, SHF_ALLOC, sizeof (Cap));
571 break;
572
573 case SHT_SUNW_capchain:
574 ofl->ofl_flags |= FLG_OF_OSABI;
575 SET_SEC_INFO_WORD_ALIGN(ELF_T_WORD, SHF_ALLOC,
576 sizeof (Capchain));
577 break;
578
579 case SHT_SUNW_capinfo:
580 ofl->ofl_flags |= FLG_OF_OSABI;
581 #if _ELF64
582 SET_SEC_INFO(ELF_T_XWORD, sizeof (Xword), SHF_ALLOC,
583 sizeof (Capinfo));
584 #else
585 SET_SEC_INFO(ELF_T_WORD, sizeof (Word), SHF_ALLOC,
586 sizeof (Capinfo));
587 #endif
588 break;
589
590 case SHT_SUNW_move:
591 ofl->ofl_flags |= FLG_OF_OSABI;
592 SET_SEC_INFO(ELF_T_BYTE, sizeof (Lword),
593 SHF_ALLOC | SHF_WRITE, sizeof (Move));
594 break;
595
596 case SHT_SUNW_syminfo:
597 ofl->ofl_flags |= FLG_OF_OSABI;
598 /*
599 * The sh_info field of the SHT_*_syminfo section points
600 * to the header index of the associated .dynamic section,
601 * so we also set SHF_INFO_LINK.
602 */
603 SET_SEC_INFO_WORD_ALIGN(ELF_T_BYTE,
604 SHF_ALLOC | SHF_INFO_LINK, sizeof (Syminfo));
605 break;
606
607 case SHT_SUNW_verneed:
608 case SHT_SUNW_verdef:
609 ofl->ofl_flags |= FLG_OF_OSABI;
610 /*
611 * The info for verneed and versym happen to be the same.
612 * The entries in these sections are not of uniform size,
613 * so we set the entsize to 0.
614 */
615 SET_SEC_INFO_WORD_ALIGN(ELF_T_BYTE, SHF_ALLOC, 0);
616 break;
617
618 case SHT_SUNW_versym:
619 ofl->ofl_flags |= FLG_OF_OSABI;
620 SET_SEC_INFO_WORD_ALIGN(ELF_T_BYTE, SHF_ALLOC,
621 sizeof (Versym));
622 break;
623
624 default:
625 /* Should not happen: fcn called with unknown section type */
626 assert(0);
627 return (S_ERROR);
628 }
629 #undef SET_SEC_INFO
630 #undef SET_SEC_INFO_WORD_ALIGN
631
632 size = entcnt * sec_info->sh_entsize;
633
634 /*
635 * Allocate and initialize the Elf_Data structure.
636 */
637 if ((data = libld_calloc(sizeof (Elf_Data), 1)) == NULL)
638 return (S_ERROR);
639 data->d_type = sec_info->d_type;
640 data->d_size = size;
641 data->d_align = sec_info->align;
642 data->d_version = ofl->ofl_dehdr->e_version;
643
644 /*
645 * Allocate and initialize the Shdr structure.
646 */
647 if ((shdr = libld_calloc(sizeof (Shdr), 1)) == NULL)
648 return (S_ERROR);
649 shdr->sh_type = shtype;
650 shdr->sh_size = size;
651 shdr->sh_flags = sec_info->sh_flags;
652 shdr->sh_addralign = sec_info->align;
653 shdr->sh_entsize = sec_info->sh_entsize;
654
655 /*
656 * Allocate and initialize the Is_desc structure.
657 */
658 if ((isec = libld_calloc(1, sizeof (Is_desc))) == NULL)
659 return (S_ERROR);
660 isec->is_name = shname;
661 isec->is_shdr = shdr;
662 isec->is_indata = data;
663
664
665 *ret_isec = isec;
666 *ret_shdr = shdr;
667 *ret_data = data;
668 return (1);
669 }
670
671 /*
672 * Use an existing input section as a template to create a new
673 * input section with the same values as the original, other than
674 * the size of the data area which is supplied by the caller.
675 *
676 * entry:
677 * ofl - Output file descriptor
678 * ifl - Input file section to use as a template
679 * size - Size of data area for new section
680 * ret_isec, ret_shdr, ret_data - Address of pointers to
681 * receive address of newly allocated structs.
682 *
683 * exit:
684 * On error, returns S_ERROR. On success, returns (1), and the
685 * ret_ pointers have been updated to point at the new structures,
686 * which have been filled in. To finish the task, the caller must
687 * update any fields within the supplied descriptors that differ
688 * from its needs, and then call ld_place_section().
689 */
690 static uintptr_t
691 new_section_from_template(Ofl_desc *ofl, Is_desc *tmpl_isp, size_t size,
692 Is_desc **ret_isec, Shdr **ret_shdr, Elf_Data **ret_data)
693 {
694 Shdr *shdr;
695 Elf_Data *data;
696 Is_desc *isec;
697
698 /*
699 * Allocate and initialize the Elf_Data structure.
700 */
701 if ((data = libld_calloc(sizeof (Elf_Data), 1)) == NULL)
702 return (S_ERROR);
703 data->d_type = tmpl_isp->is_indata->d_type;
704 data->d_size = size;
705 data->d_align = tmpl_isp->is_shdr->sh_addralign;
706 data->d_version = ofl->ofl_dehdr->e_version;
707
708 /*
709 * Allocate and initialize the Shdr structure.
710 */
711 if ((shdr = libld_malloc(sizeof (Shdr))) == NULL)
712 return (S_ERROR);
713 *shdr = *tmpl_isp->is_shdr;
714 shdr->sh_addr = 0;
715 shdr->sh_offset = 0;
716 shdr->sh_size = size;
717
718 /*
719 * Allocate and initialize the Is_desc structure.
720 */
721 if ((isec = libld_calloc(1, sizeof (Is_desc))) == NULL)
722 return (S_ERROR);
723 isec->is_name = tmpl_isp->is_name;
724 isec->is_shdr = shdr;
725 isec->is_indata = data;
726
727
728 *ret_isec = isec;
729 *ret_shdr = shdr;
730 *ret_data = data;
731 return (1);
732 }
733
734 /*
735 * Build a .bss section for allocation of tentative definitions. Any `static'
736 * .bss definitions would have been associated to their own .bss sections and
737 * thus collected from the input files. `global' .bss definitions are tagged
738 * as COMMON and do not cause any associated .bss section elements to be
739 * generated. Here we add up all these COMMON symbols and generate the .bss
740 * section required to represent them.
741 */
742 uintptr_t
743 ld_make_bss(Ofl_desc *ofl, Xword size, Xword align, uint_t ident)
744 {
745 Shdr *shdr;
746 Elf_Data *data;
747 Is_desc *isec;
748 Os_desc *osp;
749 Xword rsize = (Xword)ofl->ofl_relocbsssz;
750
751 /*
752 * Allocate header structs. We will set the name ourselves below,
753 * and there is no entcnt for a BSS. So, the shname and entcnt
754 * arguments are 0.
755 */
756 if (new_section(ofl, SHT_NOBITS, NULL, 0,
757 &isec, &shdr, &data) == S_ERROR)
758 return (S_ERROR);
759
760 data->d_size = (size_t)size;
761 data->d_align = (size_t)align;
762
763 shdr->sh_size = size;
764 shdr->sh_addralign = align;
765
766 if (ident == ld_targ.t_id.id_tlsbss) {
767 isec->is_name = MSG_ORIG(MSG_SCN_TBSS);
768 ofl->ofl_istlsbss = isec;
769 shdr->sh_flags |= SHF_TLS;
770
771 } else if (ident == ld_targ.t_id.id_bss) {
772 isec->is_name = MSG_ORIG(MSG_SCN_BSS);
773 ofl->ofl_isbss = isec;
774
775 #if defined(_ELF64)
776 } else if ((ld_targ.t_m.m_mach == EM_AMD64) &&
777 (ident == ld_targ.t_id.id_lbss)) {
778 isec->is_name = MSG_ORIG(MSG_SCN_LBSS);
779 ofl->ofl_islbss = isec;
780 shdr->sh_flags |= SHF_AMD64_LARGE;
781 #endif
782 }
783
784 /*
785 * Retain this .*bss input section as this will be where global symbol
786 * references are added.
787 */
788 if ((osp = ld_place_section(ofl, isec, NULL, ident, NULL)) ==
789 (Os_desc *)S_ERROR)
790 return (S_ERROR);
791
792 /*
793 * If relocations exist against a .*bss section, a section symbol must
794 * be created for the section in the .dynsym symbol table.
795 */
796 if (!(osp->os_flags & FLG_OS_OUTREL)) {
797 ofl_flag_t flagtotest;
798
799 if (ident == ld_targ.t_id.id_tlsbss)
800 flagtotest = FLG_OF1_TLSOREL;
801 else
802 flagtotest = FLG_OF1_BSSOREL;
803
804 if (ofl->ofl_flags1 & flagtotest) {
805 ofl->ofl_dynshdrcnt++;
806 osp->os_flags |= FLG_OS_OUTREL;
807 }
808 }
809
810 osp->os_szoutrels = rsize;
811 return (1);
812 }
813
814 /*
815 * Build a SHT_{INIT|FINI|PREINIT}ARRAY section (specified via
816 * ld -z *array=name).
817 */
818 static uintptr_t
819 make_array(Ofl_desc *ofl, Word shtype, const char *sectname, APlist *alp)
820 {
821 uint_t entcount;
822 Aliste idx;
823 Elf_Data *data;
824 Is_desc *isec;
825 Shdr *shdr;
826 Sym_desc *sdp;
827 Rel_desc reld;
828 Rela reloc;
829 Os_desc *osp;
830 uintptr_t ret = 1;
831
832 if (alp == NULL)
833 return (1);
834
835 entcount = 0;
836 for (APLIST_TRAVERSE(alp, idx, sdp))
837 entcount++;
838
839 if (new_section(ofl, shtype, sectname, entcount, &isec, &shdr, &data) ==
840 S_ERROR)
841 return (S_ERROR);
842
843 if ((data->d_buf = libld_calloc(sizeof (Addr), entcount)) == NULL)
844 return (S_ERROR);
845
846 if (ld_place_section(ofl, isec, NULL, ld_targ.t_id.id_array, NULL) ==
847 (Os_desc *)S_ERROR)
848 return (S_ERROR);
849
850 osp = isec->is_osdesc;
851
852 if ((ofl->ofl_osinitarray == NULL) && (shtype == SHT_INIT_ARRAY))
853 ofl->ofl_osinitarray = osp;
854 if ((ofl->ofl_ospreinitarray == NULL) && (shtype == SHT_PREINIT_ARRAY))
855 ofl->ofl_ospreinitarray = osp;
856 else if ((ofl->ofl_osfiniarray == NULL) && (shtype == SHT_FINI_ARRAY))
857 ofl->ofl_osfiniarray = osp;
858
859 /*
860 * Create relocations against this section to initialize it to the
861 * function addresses.
862 */
863 reld.rel_isdesc = isec;
864 reld.rel_aux = NULL;
865 reld.rel_flags = FLG_REL_LOAD;
866
867 /*
868 * Fabricate the relocation information (as if a relocation record had
869 * been input - see init_rel()).
870 */
871 reld.rel_rtype = ld_targ.t_m.m_r_arrayaddr;
872 reld.rel_roffset = 0;
873 reld.rel_raddend = 0;
874
875 /*
876 * Create a minimal relocation record to satisfy process_sym_reloc()
877 * debugging requirements.
878 */
879 reloc.r_offset = 0;
880 reloc.r_info = ELF_R_INFO(0, ld_targ.t_m.m_r_arrayaddr);
881 reloc.r_addend = 0;
882
883 DBG_CALL(Dbg_reloc_generate(ofl->ofl_lml, osp,
884 ld_targ.t_m.m_rel_sht_type));
885 for (APLIST_TRAVERSE(alp, idx, sdp)) {
886 reld.rel_sym = sdp;
887
888 if (ld_process_sym_reloc(ofl, &reld, (Rel *)&reloc, isec,
889 MSG_INTL(MSG_STR_COMMAND), 0) == S_ERROR) {
890 ret = S_ERROR;
891 continue;
892 }
893
894 reld.rel_roffset += (Xword)sizeof (Addr);
895 reloc.r_offset = reld.rel_roffset;
896 }
897
898 return (ret);
899 }
900
901 /*
902 * Build a comment section (-Qy option).
903 */
904 static uintptr_t
905 make_comment(Ofl_desc *ofl)
906 {
907 Shdr *shdr;
908 Elf_Data *data;
909 Is_desc *isec;
910
911 if (new_section(ofl, SHT_PROGBITS, MSG_ORIG(MSG_SCN_COMMENT), 0,
912 &isec, &shdr, &data) == S_ERROR)
913 return (S_ERROR);
914
915 data->d_buf = (void *)ofl->ofl_sgsid;
916 data->d_size = strlen(ofl->ofl_sgsid) + 1;
917 data->d_align = 1;
918
919 shdr->sh_size = (Xword)data->d_size;
920 shdr->sh_flags = 0;
921 shdr->sh_addralign = 1;
922
923 return ((uintptr_t)ld_place_section(ofl, isec, NULL,
924 ld_targ.t_id.id_note, NULL));
925 }
926
927 /*
928 * Make the dynamic section. Calculate the size of any strings referenced
929 * within this structure, they will be added to the global string table
930 * (.dynstr). This routine should be called before make_dynstr().
931 *
932 * This routine must be maintained in parallel with update_odynamic()
933 * in update.c
934 */
935 static uintptr_t
936 make_dynamic(Ofl_desc *ofl)
937 {
938 Shdr *shdr;
939 Os_desc *osp;
940 Elf_Data *data;
941 Is_desc *isec;
942 size_t cnt = 0;
943 Aliste idx;
944 Ifl_desc *ifl;
945 Sym_desc *sdp;
946 size_t size;
947 Str_tbl *strtbl;
948 ofl_flag_t flags = ofl->ofl_flags;
949 int not_relobj = !(flags & FLG_OF_RELOBJ);
950 int unused = 0;
951
952 /*
953 * Select the required string table.
954 */
955 if (OFL_IS_STATIC_OBJ(ofl))
956 strtbl = ofl->ofl_strtab;
957 else
958 strtbl = ofl->ofl_dynstrtab;
959
960 /*
961 * Only a limited subset of DT_ entries apply to relocatable
962 * objects. See the comment at the head of update_odynamic() in
963 * update.c for details.
964 */
965 if (new_section(ofl, SHT_DYNAMIC, MSG_ORIG(MSG_SCN_DYNAMIC), 0,
966 &isec, &shdr, &data) == S_ERROR)
967 return (S_ERROR);
968
969 /*
970 * new_section() does not set SHF_ALLOC. If we're building anything
971 * besides a relocatable object, then the .dynamic section should
972 * reside in allocatable memory.
973 */
974 if (not_relobj)
975 shdr->sh_flags |= SHF_ALLOC;
976
977 /*
978 * new_section() does not set SHF_WRITE. If we're building an object
979 * that specifies an interpretor, then a DT_DEBUG entry is created,
980 * which is initialized to the applications link-map list at runtime.
981 */
982 if (ofl->ofl_osinterp)
983 shdr->sh_flags |= SHF_WRITE;
984
985 osp = ofl->ofl_osdynamic =
986 ld_place_section(ofl, isec, NULL, ld_targ.t_id.id_dynamic, NULL);
987
988 /*
989 * Reserve entries for any needed dependencies.
990 */
991 for (APLIST_TRAVERSE(ofl->ofl_sos, idx, ifl)) {
992 if (!(ifl->ifl_flags & (FLG_IF_NEEDED | FLG_IF_NEEDSTR)))
993 continue;
994
995 /*
996 * If this dependency didn't satisfy any symbol references,
997 * generate a debugging diagnostic (ld(1) -Dunused can be used
998 * to display these). If this is a standard needed dependency,
999 * and -z ignore is in effect, drop the dependency. Explicitly
1000 * defined dependencies (i.e., -N dep) don't get dropped, and
1001 * are flagged as being required to simplify update_odynamic()
1002 * processing.
1003 */
1004 if ((ifl->ifl_flags & FLG_IF_NEEDSTR) ||
1005 ((ifl->ifl_flags & FLG_IF_DEPREQD) == 0)) {
1006 if (unused++ == 0)
1007 DBG_CALL(Dbg_util_nl(ofl->ofl_lml, DBG_NL_STD));
1008 DBG_CALL(Dbg_unused_file(ofl->ofl_lml, ifl->ifl_soname,
1009 (ifl->ifl_flags & FLG_IF_NEEDSTR), 0));
1010
1011 /*
1012 * Guidance: Remove unused dependency.
1013 *
1014 * If -z ignore is in effect, this warning is not
1015 * needed because we will quietly remove the unused
1016 * dependency.
1017 */
1018 if (OFL_GUIDANCE(ofl, FLG_OFG_NO_UNUSED) &&
1019 ((ifl->ifl_flags & FLG_IF_IGNORE) == 0))
1020 ld_eprintf(ofl, ERR_GUIDANCE,
1021 MSG_INTL(MSG_GUIDE_UNUSED),
1022 ifl->ifl_soname);
1023
1024 if (ifl->ifl_flags & FLG_IF_NEEDSTR)
1025 ifl->ifl_flags |= FLG_IF_DEPREQD;
1026 else if (ifl->ifl_flags & FLG_IF_IGNORE)
1027 continue;
1028 }
1029
1030 /*
1031 * If this object requires a DT_POSFLAG_1 entry, reserve it.
1032 */
1033 if ((ifl->ifl_flags & MSK_IF_POSFLAG1) && not_relobj)
1034 cnt++;
1035
1036 if (st_insert(strtbl, ifl->ifl_soname) == -1)
1037 return (S_ERROR);
1038 cnt++;
1039
1040 /*
1041 * If the needed entry contains the $ORIGIN token make sure
1042 * the associated DT_1_FLAGS entry is created.
1043 */
1044 if (strstr(ifl->ifl_soname, MSG_ORIG(MSG_STR_ORIGIN))) {
1045 ofl->ofl_dtflags_1 |= DF_1_ORIGIN;
1046 ofl->ofl_dtflags |= DF_ORIGIN;
1047 }
1048 }
1049
1050 if (unused)
1051 DBG_CALL(Dbg_util_nl(ofl->ofl_lml, DBG_NL_STD));
1052
1053 if (not_relobj) {
1054 /*
1055 * Reserve entries for any per-symbol auxiliary/filter strings.
1056 */
1057 cnt += alist_nitems(ofl->ofl_dtsfltrs);
1058
1059 /*
1060 * Reserve entries for _init() and _fini() section addresses.
1061 */
1062 if (((sdp = ld_sym_find(MSG_ORIG(MSG_SYM_INIT_U),
1063 SYM_NOHASH, NULL, ofl)) != NULL) &&
1064 (sdp->sd_ref == REF_REL_NEED) &&
1065 (sdp->sd_sym->st_shndx != SHN_UNDEF)) {
1066 sdp->sd_flags |= FLG_SY_UPREQD;
1067 cnt++;
1068 }
1069 if (((sdp = ld_sym_find(MSG_ORIG(MSG_SYM_FINI_U),
1070 SYM_NOHASH, NULL, ofl)) != NULL) &&
1071 (sdp->sd_ref == REF_REL_NEED) &&
1072 (sdp->sd_sym->st_shndx != SHN_UNDEF)) {
1073 sdp->sd_flags |= FLG_SY_UPREQD;
1074 cnt++;
1075 }
1076
1077 /*
1078 * Reserve entries for any soname, filter name (shared libs
1079 * only), run-path pointers, cache names and audit requirements.
1080 */
1081 if (ofl->ofl_soname) {
1082 cnt++;
1083 if (st_insert(strtbl, ofl->ofl_soname) == -1)
1084 return (S_ERROR);
1085 }
1086 if (ofl->ofl_filtees) {
1087 cnt++;
1088 if (st_insert(strtbl, ofl->ofl_filtees) == -1)
1089 return (S_ERROR);
1090
1091 /*
1092 * If the filtees entry contains the $ORIGIN token
1093 * make sure the associated DT_1_FLAGS entry is created.
1094 */
1095 if (strstr(ofl->ofl_filtees,
1096 MSG_ORIG(MSG_STR_ORIGIN))) {
1097 ofl->ofl_dtflags_1 |= DF_1_ORIGIN;
1098 ofl->ofl_dtflags |= DF_ORIGIN;
1099 }
1100 }
1101 }
1102
1103 if (ofl->ofl_rpath) {
1104 cnt += 2; /* DT_RPATH & DT_RUNPATH */
1105 if (st_insert(strtbl, ofl->ofl_rpath) == -1)
1106 return (S_ERROR);
1107
1108 /*
1109 * If the rpath entry contains the $ORIGIN token make sure
1110 * the associated DT_1_FLAGS entry is created.
1111 */
1112 if (strstr(ofl->ofl_rpath, MSG_ORIG(MSG_STR_ORIGIN))) {
1113 ofl->ofl_dtflags_1 |= DF_1_ORIGIN;
1114 ofl->ofl_dtflags |= DF_ORIGIN;
1115 }
1116 }
1117
1118 if (not_relobj) {
1119 Aliste idx;
1120 Sg_desc *sgp;
1121
1122 if (ofl->ofl_config) {
1123 cnt++;
1124 if (st_insert(strtbl, ofl->ofl_config) == -1)
1125 return (S_ERROR);
1126
1127 /*
1128 * If the config entry contains the $ORIGIN token
1129 * make sure the associated DT_1_FLAGS entry is created.
1130 */
1131 if (strstr(ofl->ofl_config, MSG_ORIG(MSG_STR_ORIGIN))) {
1132 ofl->ofl_dtflags_1 |= DF_1_ORIGIN;
1133 ofl->ofl_dtflags |= DF_ORIGIN;
1134 }
1135 }
1136 if (ofl->ofl_depaudit) {
1137 cnt++;
1138 if (st_insert(strtbl, ofl->ofl_depaudit) == -1)
1139 return (S_ERROR);
1140 }
1141 if (ofl->ofl_audit) {
1142 cnt++;
1143 if (st_insert(strtbl, ofl->ofl_audit) == -1)
1144 return (S_ERROR);
1145 }
1146
1147 /*
1148 * Reserve entries for the DT_HASH, DT_STRTAB, DT_STRSZ,
1149 * DT_SYMTAB, DT_SYMENT, and DT_CHECKSUM.
1150 */
1151 cnt += 6;
1152
1153 /*
1154 * If we are including local functions at the head of
1155 * the dynsym, then also reserve entries for DT_SUNW_SYMTAB
1156 * and DT_SUNW_SYMSZ.
1157 */
1158 if (OFL_ALLOW_LDYNSYM(ofl))
1159 cnt += 2;
1160
1161 if ((ofl->ofl_dynsymsortcnt > 0) ||
1162 (ofl->ofl_dyntlssortcnt > 0))
1163 cnt++; /* DT_SUNW_SORTENT */
1164
1165 if (ofl->ofl_dynsymsortcnt > 0)
1166 cnt += 2; /* DT_SUNW_[SYMSORT|SYMSORTSZ] */
1167
1168 if (ofl->ofl_dyntlssortcnt > 0)
1169 cnt += 2; /* DT_SUNW_[TLSSORT|TLSSORTSZ] */
1170
1171 if ((flags & (FLG_OF_VERDEF | FLG_OF_NOVERSEC)) ==
1172 FLG_OF_VERDEF)
1173 cnt += 2; /* DT_VERDEF & DT_VERDEFNUM */
1174
1175 if ((flags & (FLG_OF_VERNEED | FLG_OF_NOVERSEC)) ==
1176 FLG_OF_VERNEED)
1177 cnt += 2; /* DT_VERNEED & DT_VERNEEDNUM */
1178
1179 if ((flags & FLG_OF_COMREL) && ofl->ofl_relocrelcnt)
1180 cnt++; /* DT_RELACOUNT */
1181
1182 if (flags & FLG_OF_TEXTREL) /* DT_TEXTREL */
1183 cnt++;
1184
1185 if (ofl->ofl_osfiniarray) /* DT_FINI_ARRAY */
1186 cnt += 2; /* DT_FINI_ARRAYSZ */
1187
1188 if (ofl->ofl_osinitarray) /* DT_INIT_ARRAY */
1189 cnt += 2; /* DT_INIT_ARRAYSZ */
1190
1191 if (ofl->ofl_ospreinitarray) /* DT_PREINIT_ARRAY & */
1192 cnt += 2; /* DT_PREINIT_ARRAYSZ */
1193
1194 /*
1195 * If we have plt's reserve a DT_PLTRELSZ, DT_PLTREL and
1196 * DT_JMPREL.
1197 */
1198 if (ofl->ofl_pltcnt)
1199 cnt += 3;
1200
1201 /*
1202 * If plt padding is needed (Sparcv9).
1203 */
1204 if (ofl->ofl_pltpad)
1205 cnt += 2; /* DT_PLTPAD & DT_PLTPADSZ */
1206
1207 /*
1208 * If we have any relocations reserve a DT_REL, DT_RELSZ and
1209 * DT_RELENT entry.
1210 */
1211 if (ofl->ofl_relocsz)
1212 cnt += 3;
1213
1214 /*
1215 * If a syminfo section is required create DT_SYMINFO,
1216 * DT_SYMINSZ, and DT_SYMINENT entries.
1217 */
1218 if (flags & FLG_OF_SYMINFO)
1219 cnt += 3;
1220
1221 /*
1222 * If there are any partially initialized sections allocate
1223 * DT_MOVETAB, DT_MOVESZ and DT_MOVEENT.
1224 */
1225 if (ofl->ofl_osmove)
1226 cnt += 3;
1227
1228 /*
1229 * Allocate one DT_REGISTER entry for every register symbol.
1230 */
1231 cnt += ofl->ofl_regsymcnt;
1232
1233 /*
1234 * Reserve a entry for each '-zrtldinfo=...' specified
1235 * on the command line.
1236 */
1237 for (APLIST_TRAVERSE(ofl->ofl_rtldinfo, idx, sdp))
1238 cnt++;
1239
1240 /*
1241 * The following entry should only be placed in a segment that
1242 * is writable.
1243 */
1244 if (((sgp = osp->os_sgdesc) != NULL) &&
1245 (sgp->sg_phdr.p_flags & PF_W) && ofl->ofl_osinterp)
1246 cnt++; /* DT_DEBUG */
1247
1248 /*
1249 * Capabilities require a .dynamic entry for the .SUNW_cap
1250 * section.
1251 */
1252 if (ofl->ofl_oscap)
1253 cnt++; /* DT_SUNW_CAP */
1254
1255 /*
1256 * Symbol capabilities require a .dynamic entry for the
1257 * .SUNW_capinfo section.
1258 */
1259 if (ofl->ofl_oscapinfo)
1260 cnt++; /* DT_SUNW_CAPINFO */
1261
1262 /*
1263 * Capabilities chain information requires a .SUNW_capchain
1264 * entry (DT_SUNW_CAPCHAIN), entry size (DT_SUNW_CAPCHAINENT),
1265 * and total size (DT_SUNW_CAPCHAINSZ).
1266 */
1267 if (ofl->ofl_oscapchain)
1268 cnt += 3;
1269
1270 if (flags & FLG_OF_SYMBOLIC)
1271 cnt++; /* DT_SYMBOLIC */
1272 }
1273
1274 /*
1275 * Account for Architecture dependent .dynamic entries, and defaults.
1276 */
1277 (*ld_targ.t_mr.mr_mach_make_dynamic)(ofl, &cnt);
1278
1279 /*
1280 * DT_FLAGS, DT_FLAGS_1, DT_SUNW_STRPAD, and DT_NULL. Also,
1281 * allow room for the unused extra DT_NULLs. These are included
1282 * to allow an ELF editor room to add items later.
1283 */
1284 cnt += 4 + DYNAMIC_EXTRA_ELTS;
1285
1286 /*
1287 * DT_SUNW_LDMACH. Used to hold the ELF machine code of the
1288 * linker that produced the output object. This information
1289 * allows us to determine whether a given object was linked
1290 * natively, or by a linker running on a different type of
1291 * system. This information can be valuable if one suspects
1292 * that a problem might be due to alignment or byte order issues.
1293 */
1294 cnt++;
1295
1296 /*
1297 * Determine the size of the section from the number of entries.
1298 */
1299 size = cnt * (size_t)shdr->sh_entsize;
1300
1301 shdr->sh_size = (Xword)size;
1302 data->d_size = size;
1303
1304 /*
1305 * There are several tags that are specific to the Solaris osabi
1306 * range which we unconditionally put into any dynamic section
1307 * we create (e.g. DT_SUNW_STRPAD or DT_SUNW_LDMACH). As such,
1308 * any Solaris object with a dynamic section should be tagged as
1309 * ELFOSABI_SOLARIS.
1310 */
1311 ofl->ofl_flags |= FLG_OF_OSABI;
1312
1313 return ((uintptr_t)ofl->ofl_osdynamic);
1314 }
1315
1316 /*
1317 * Build the GOT section and its associated relocation entries.
1318 */
1319 uintptr_t
1320 ld_make_got(Ofl_desc *ofl)
1321 {
1322 Elf_Data *data;
1323 Shdr *shdr;
1324 Is_desc *isec;
1325 size_t size = (size_t)ofl->ofl_gotcnt * ld_targ.t_m.m_got_entsize;
1326 size_t rsize = (size_t)ofl->ofl_relocgotsz;
1327
1328 if (new_section(ofl, SHT_PROGBITS, MSG_ORIG(MSG_SCN_GOT), 0,
1329 &isec, &shdr, &data) == S_ERROR)
1330 return (S_ERROR);
1331
1332 data->d_size = size;
1333
1334 shdr->sh_flags |= SHF_WRITE;
1335 shdr->sh_size = (Xword)size;
1336 shdr->sh_entsize = ld_targ.t_m.m_got_entsize;
1337
1338 ofl->ofl_osgot = ld_place_section(ofl, isec, NULL,
1339 ld_targ.t_id.id_got, NULL);
1340 if (ofl->ofl_osgot == (Os_desc *)S_ERROR)
1341 return (S_ERROR);
1342
1343 ofl->ofl_osgot->os_szoutrels = (Xword)rsize;
1344
1345 return (1);
1346 }
1347
1348 /*
1349 * Build an interpreter section.
1350 */
1351 static uintptr_t
1352 make_interp(Ofl_desc *ofl)
1353 {
1354 Shdr *shdr;
1355 Elf_Data *data;
1356 Is_desc *isec;
1357 const char *iname = ofl->ofl_interp;
1358 size_t size;
1359
1360 /*
1361 * If -z nointerp is in effect, don't create an interpreter section.
1362 */
1363 if (ofl->ofl_flags1 & FLG_OF1_NOINTRP)
1364 return (1);
1365
1366 /*
1367 * An .interp section is always created for a dynamic executable.
1368 * A user can define the interpreter to use. This definition overrides
1369 * the default that would be recorded in an executable, and triggers
1370 * the creation of an .interp section in any other object. Presumably
1371 * the user knows what they are doing. Refer to the generic ELF ABI
1372 * section 5-4, and the ld(1) -I option.
1373 */
1374 if (((ofl->ofl_flags & (FLG_OF_DYNAMIC | FLG_OF_EXEC |
1375 FLG_OF_RELOBJ)) != (FLG_OF_DYNAMIC | FLG_OF_EXEC)) && !iname)
1376 return (1);
1377
1378 /*
1379 * In the case of a dynamic executable, supply a default interpreter
1380 * if the user has not specified their own.
1381 */
1382 if (iname == NULL)
1383 iname = ofl->ofl_interp = ld_targ.t_m.m_def_interp;
1384
1385 size = strlen(iname) + 1;
1386
1387 if (new_section(ofl, SHT_PROGBITS, MSG_ORIG(MSG_SCN_INTERP), 0,
1388 &isec, &shdr, &data) == S_ERROR)
1389 return (S_ERROR);
1390
1391 data->d_size = size;
1392 shdr->sh_size = (Xword)size;
1393 data->d_align = shdr->sh_addralign = 1;
1394
1395 ofl->ofl_osinterp =
1396 ld_place_section(ofl, isec, NULL, ld_targ.t_id.id_interp, NULL);
1397 return ((uintptr_t)ofl->ofl_osinterp);
1398 }
1399
1400 /*
1401 * Common function used to build the SHT_SUNW_versym section, SHT_SUNW_syminfo
1402 * section, and SHT_SUNW_capinfo section. Each of these sections provide
1403 * additional symbol information, and their size parallels the associated
1404 * symbol table.
1405 */
1406 static Os_desc *
1407 make_sym_sec(Ofl_desc *ofl, const char *sectname, Word stype, int ident)
1408 {
1409 Shdr *shdr;
1410 Elf_Data *data;
1411 Is_desc *isec;
1412
1413 /*
1414 * We don't know the size of this section yet, so set it to 0. The
1415 * size gets filled in after the associated symbol table is sized.
1416 */
1417 if (new_section(ofl, stype, sectname, 0, &isec, &shdr, &data) ==
1418 S_ERROR)
1419 return ((Os_desc *)S_ERROR);
1420
1421 return (ld_place_section(ofl, isec, NULL, ident, NULL));
1422 }
1423
1424 /*
1425 * Determine whether a symbol capability is redundant because the object
1426 * capabilities are more restrictive.
1427 */
1428 inline static int
1429 is_cap_redundant(Objcapset *ocapset, Objcapset *scapset)
1430 {
1431 Alist *oalp, *salp;
1432 elfcap_mask_t omsk, smsk;
1433
1434 /*
1435 * Inspect any platform capabilities. If the object defines platform
1436 * capabilities, then the object will only be loaded for those
1437 * platforms. A symbol capability set that doesn't define the same
1438 * platforms is redundant, and a symbol capability that does not provide
1439 * at least one platform name that matches a platform name in the object
1440 * capabilities will never execute (as the object wouldn't have been
1441 * loaded).
1442 */
1443 oalp = ocapset->oc_plat.cl_val;
1444 salp = scapset->oc_plat.cl_val;
1445 if (oalp && ((salp == NULL) || cap_names_match(oalp, salp)))
1446 return (1);
1447
1448 /*
1449 * If the symbol capability set defines platforms, and the object
1450 * doesn't, then the symbol set is more restrictive.
1451 */
1452 if (salp && (oalp == NULL))
1453 return (0);
1454
1455 /*
1456 * Next, inspect any machine name capabilities. If the object defines
1457 * machine name capabilities, then the object will only be loaded for
1458 * those machines. A symbol capability set that doesn't define the same
1459 * machine names is redundant, and a symbol capability that does not
1460 * provide at least one machine name that matches a machine name in the
1461 * object capabilities will never execute (as the object wouldn't have
1462 * been loaded).
1463 */
1464 oalp = ocapset->oc_plat.cl_val;
1465 salp = scapset->oc_plat.cl_val;
1466 if (oalp && ((salp == NULL) || cap_names_match(oalp, salp)))
1467 return (1);
1468
1469 /*
1470 * If the symbol capability set defines machine names, and the object
1471 * doesn't, then the symbol set is more restrictive.
1472 */
1473 if (salp && (oalp == NULL))
1474 return (0);
1475
1476 /*
1477 * Next, inspect any hardware capabilities. If the objects hardware
1478 * capabilities are greater than or equal to that of the symbols
1479 * capabilities, then the symbol capability set is redundant. If the
1480 * symbols hardware capabilities are greater that the objects, then the
1481 * symbol set is more restrictive.
1482 *
1483 * Note that this is a somewhat arbitrary definition, as each capability
1484 * bit is independent of the others, and some of the higher order bits
1485 * could be considered to be less important than lower ones. However,
1486 * this is the only reasonable non-subjective definition.
1487 */
1488 omsk = ocapset->oc_hw_2.cm_val;
1489 smsk = scapset->oc_hw_2.cm_val;
1490 if ((omsk > smsk) || (omsk && (omsk == smsk)))
1491 return (1);
1492 if (omsk < smsk)
1493 return (0);
1494
1495 /*
1496 * Finally, inspect the remaining hardware capabilities.
1497 */
1498 omsk = ocapset->oc_hw_1.cm_val;
1499 smsk = scapset->oc_hw_1.cm_val;
1500 if ((omsk > smsk) || (omsk && (omsk == smsk)))
1501 return (1);
1502
1503 return (0);
1504 }
1505
1506 /*
1507 * Capabilities values might have been assigned excluded values. These
1508 * excluded values should be removed before calculating any capabilities
1509 * sections size.
1510 */
1511 static void
1512 capmask_value(Lm_list *lml, Word type, Capmask *capmask, int *title)
1513 {
1514 /*
1515 * First determine whether any bits should be excluded.
1516 */
1517 if ((capmask->cm_val & capmask->cm_exc) == 0)
1518 return;
1519
1520 DBG_CALL(Dbg_cap_post_title(lml, title));
1521
1522 DBG_CALL(Dbg_cap_val_entry(lml, DBG_STATE_CURRENT, type,
1523 capmask->cm_val, ld_targ.t_m.m_mach));
1524 DBG_CALL(Dbg_cap_val_entry(lml, DBG_STATE_EXCLUDE, type,
1525 capmask->cm_exc, ld_targ.t_m.m_mach));
1526
1527 capmask->cm_val &= ~capmask->cm_exc;
1528
1529 DBG_CALL(Dbg_cap_val_entry(lml, DBG_STATE_RESOLVED, type,
1530 capmask->cm_val, ld_targ.t_m.m_mach));
1531 }
1532
1533 static void
1534 capstr_value(Lm_list *lml, Word type, Caplist *caplist, int *title)
1535 {
1536 Aliste idx1, idx2;
1537 char *estr;
1538 Capstr *capstr;
1539 Boolean found = FALSE;
1540
1541 /*
1542 * First determine whether any strings should be excluded.
1543 */
1544 for (APLIST_TRAVERSE(caplist->cl_exc, idx1, estr)) {
1545 for (ALIST_TRAVERSE(caplist->cl_val, idx2, capstr)) {
1546 if (strcmp(estr, capstr->cs_str) == 0) {
1547 found = TRUE;
1548 break;
1549 }
1550 }
1551 }
1552
1553 if (found == FALSE)
1554 return;
1555
1556 /*
1557 * Traverse the current strings, then delete the excluded strings,
1558 * and finally display the resolved strings.
1559 */
1560 if (DBG_ENABLED) {
1561 Dbg_cap_post_title(lml, title);
1562 for (ALIST_TRAVERSE(caplist->cl_val, idx2, capstr)) {
1563 Dbg_cap_ptr_entry(lml, DBG_STATE_CURRENT, type,
1564 capstr->cs_str);
1565 }
1566 }
1567 for (APLIST_TRAVERSE(caplist->cl_exc, idx1, estr)) {
1568 for (ALIST_TRAVERSE(caplist->cl_val, idx2, capstr)) {
1569 if (strcmp(estr, capstr->cs_str) == 0) {
1570 DBG_CALL(Dbg_cap_ptr_entry(lml,
1571 DBG_STATE_EXCLUDE, type, capstr->cs_str));
1572 alist_delete(caplist->cl_val, &idx2);
1573 break;
1574 }
1575 }
1576 }
1577 if (DBG_ENABLED) {
1578 for (ALIST_TRAVERSE(caplist->cl_val, idx2, capstr)) {
1579 Dbg_cap_ptr_entry(lml, DBG_STATE_RESOLVED, type,
1580 capstr->cs_str);
1581 }
1582 }
1583 }
1584
1585 /*
1586 * Build a capabilities section.
1587 */
1588 #define CAP_UPDATE(cap, capndx, tag, val) \
1589 cap->c_tag = tag; \
1590 cap->c_un.c_val = val; \
1591 cap++, capndx++;
1592
1593 static uintptr_t
1594 make_cap(Ofl_desc *ofl, Word shtype, const char *shname, int ident)
1595 {
1596 Shdr *shdr;
1597 Elf_Data *data;
1598 Is_desc *isec;
1599 Cap *cap;
1600 size_t size = 0;
1601 Word capndx = 0;
1602 Str_tbl *strtbl;
1603 Objcapset *ocapset = &ofl->ofl_ocapset;
1604 Aliste idx1;
1605 Capstr *capstr;
1606 int title = 0;
1607
1608 /*
1609 * Determine which string table to use for any CA_SUNW_MACH,
1610 * CA_SUNW_PLAT, or CA_SUNW_ID strings.
1611 */
1612 if (OFL_IS_STATIC_OBJ(ofl))
1613 strtbl = ofl->ofl_strtab;
1614 else
1615 strtbl = ofl->ofl_dynstrtab;
1616
1617 /*
1618 * If symbol capabilities have been requested, but none have been
1619 * created, warn the user. This scenario can occur if none of the
1620 * input relocatable objects defined any object capabilities.
1621 */
1622 if ((ofl->ofl_flags & FLG_OF_OTOSCAP) && (ofl->ofl_capsymcnt == 0))
1623 ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_CAP_NOSYMSFOUND));
1624
1625 /*
1626 * If symbol capabilities have been collected, but no symbols are left
1627 * referencing these capabilities, promote the capability groups back
1628 * to an object capability definition.
1629 */
1630 if ((ofl->ofl_flags & FLG_OF_OTOSCAP) && ofl->ofl_capsymcnt &&
1631 (ofl->ofl_capfamilies == NULL)) {
1632 ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_CAP_NOSYMSFOUND));
1633 ld_cap_move_symtoobj(ofl);
1634 ofl->ofl_capsymcnt = 0;
1635 ofl->ofl_capgroups = NULL;
1636 ofl->ofl_flags &= ~FLG_OF_OTOSCAP;
1637 }
1638
1639 /*
1640 * Remove any excluded capabilities.
1641 */
1642 capstr_value(ofl->ofl_lml, CA_SUNW_PLAT, &ocapset->oc_plat, &title);
1643 capstr_value(ofl->ofl_lml, CA_SUNW_MACH, &ocapset->oc_mach, &title);
1644 capmask_value(ofl->ofl_lml, CA_SUNW_HW_2, &ocapset->oc_hw_2, &title);
1645 capmask_value(ofl->ofl_lml, CA_SUNW_HW_1, &ocapset->oc_hw_1, &title);
1646 capmask_value(ofl->ofl_lml, CA_SUNW_SF_1, &ocapset->oc_sf_1, &title);
1647
1648 /*
1649 * Determine how many entries are required for any object capabilities.
1650 */
1651 size += alist_nitems(ocapset->oc_plat.cl_val);
1652 size += alist_nitems(ocapset->oc_mach.cl_val);
1653 if (ocapset->oc_hw_2.cm_val)
1654 size++;
1655 if (ocapset->oc_hw_1.cm_val)
1656 size++;
1657 if (ocapset->oc_sf_1.cm_val)
1658 size++;
1659
1660 /*
1661 * Only identify a capabilities group if the group has content. If a
1662 * capabilities identifier exists, and no other capabilities have been
1663 * supplied, remove the identifier. This scenario could exist if a
1664 * user mistakenly defined a lone identifier, or if an identified group
1665 * was overridden so as to clear the existing capabilities and the
1666 * identifier was not also cleared.
1667 */
1668 if (ocapset->oc_id.cs_str) {
1669 if (size)
1670 size++;
1671 else
1672 ocapset->oc_id.cs_str = NULL;
1673 }
1674 if (size)
1675 size++; /* Add CA_SUNW_NULL */
1676
1677 /*
1678 * Determine how many entries are required for any symbol capabilities.
1679 */
1680 if (ofl->ofl_capsymcnt) {
1681 /*
1682 * If there are no object capabilities, a CA_SUNW_NULL entry
1683 * is required before any symbol capabilities.
1684 */
1685 if (size == 0)
1686 size++;
1687 size += ofl->ofl_capsymcnt;
1688 }
1689
1690 if (size == 0)
1691 return (NULL);
1692
1693 if (new_section(ofl, shtype, shname, size, &isec,
1694 &shdr, &data) == S_ERROR)
1695 return (S_ERROR);
1696
1697 if ((data->d_buf = libld_malloc(shdr->sh_size)) == NULL)
1698 return (S_ERROR);
1699
1700 cap = (Cap *)data->d_buf;
1701
1702 /*
1703 * Fill in any object capabilities. If there is an identifier, then the
1704 * identifier comes first. The remaining items follow in precedence
1705 * order, although the order isn't important for runtime verification.
1706 */
1707 if (ocapset->oc_id.cs_str) {
1708 ofl->ofl_flags |= FLG_OF_CAPSTRS;
1709 if (st_insert(strtbl, ocapset->oc_id.cs_str) == -1)
1710 return (S_ERROR);
1711 ocapset->oc_id.cs_ndx = capndx;
1712 CAP_UPDATE(cap, capndx, CA_SUNW_ID, 0);
1713 }
1714 if (ocapset->oc_plat.cl_val) {
1715 ofl->ofl_flags |= (FLG_OF_PTCAP | FLG_OF_CAPSTRS);
1716
1717 /*
1718 * Insert any platform name strings in the appropriate string
1719 * table. The capability value can't be filled in yet, as the
1720 * final offset of the strings isn't known until later.
1721 */
1722 for (ALIST_TRAVERSE(ocapset->oc_plat.cl_val, idx1, capstr)) {
1723 if (st_insert(strtbl, capstr->cs_str) == -1)
1724 return (S_ERROR);
1725 capstr->cs_ndx = capndx;
1726 CAP_UPDATE(cap, capndx, CA_SUNW_PLAT, 0);
1727 }
1728 }
1729 if (ocapset->oc_mach.cl_val) {
1730 ofl->ofl_flags |= (FLG_OF_PTCAP | FLG_OF_CAPSTRS);
1731
1732 /*
1733 * Insert the machine name strings in the appropriate string
1734 * table. The capability value can't be filled in yet, as the
1735 * final offset of the strings isn't known until later.
1736 */
1737 for (ALIST_TRAVERSE(ocapset->oc_mach.cl_val, idx1, capstr)) {
1738 if (st_insert(strtbl, capstr->cs_str) == -1)
1739 return (S_ERROR);
1740 capstr->cs_ndx = capndx;
1741 CAP_UPDATE(cap, capndx, CA_SUNW_MACH, 0);
1742 }
1743 }
1744 if (ocapset->oc_hw_2.cm_val) {
1745 ofl->ofl_flags |= FLG_OF_PTCAP;
1746 CAP_UPDATE(cap, capndx, CA_SUNW_HW_2, ocapset->oc_hw_2.cm_val);
1747 }
1748 if (ocapset->oc_hw_1.cm_val) {
1749 ofl->ofl_flags |= FLG_OF_PTCAP;
1750 CAP_UPDATE(cap, capndx, CA_SUNW_HW_1, ocapset->oc_hw_1.cm_val);
1751 }
1752 if (ocapset->oc_sf_1.cm_val) {
1753 ofl->ofl_flags |= FLG_OF_PTCAP;
1754 CAP_UPDATE(cap, capndx, CA_SUNW_SF_1, ocapset->oc_sf_1.cm_val);
1755 }
1756 CAP_UPDATE(cap, capndx, CA_SUNW_NULL, 0);
1757
1758 /*
1759 * Fill in any symbol capabilities.
1760 */
1761 if (ofl->ofl_capgroups) {
1762 Cap_group *cgp;
1763
1764 for (APLIST_TRAVERSE(ofl->ofl_capgroups, idx1, cgp)) {
1765 Objcapset *scapset = &cgp->cg_set;
1766 Aliste idx2;
1767 Is_desc *isp;
1768
1769 cgp->cg_ndx = capndx;
1770
1771 if (scapset->oc_id.cs_str) {
1772 ofl->ofl_flags |= FLG_OF_CAPSTRS;
1773 /*
1774 * Insert the identifier string in the
1775 * appropriate string table. The capability
1776 * value can't be filled in yet, as the final
1777 * offset of the string isn't known until later.
1778 */
1779 if (st_insert(strtbl,
1780 scapset->oc_id.cs_str) == -1)
1781 return (S_ERROR);
1782 scapset->oc_id.cs_ndx = capndx;
1783 CAP_UPDATE(cap, capndx, CA_SUNW_ID, 0);
1784 }
1785
1786 if (scapset->oc_plat.cl_val) {
1787 ofl->ofl_flags |= FLG_OF_CAPSTRS;
1788
1789 /*
1790 * Insert the platform name string in the
1791 * appropriate string table. The capability
1792 * value can't be filled in yet, as the final
1793 * offset of the string isn't known until later.
1794 */
1795 for (ALIST_TRAVERSE(scapset->oc_plat.cl_val,
1796 idx2, capstr)) {
1797 if (st_insert(strtbl,
1798 capstr->cs_str) == -1)
1799 return (S_ERROR);
1800 capstr->cs_ndx = capndx;
1801 CAP_UPDATE(cap, capndx,
1802 CA_SUNW_PLAT, 0);
1803 }
1804 }
1805 if (scapset->oc_mach.cl_val) {
1806 ofl->ofl_flags |= FLG_OF_CAPSTRS;
1807
1808 /*
1809 * Insert the machine name string in the
1810 * appropriate string table. The capability
1811 * value can't be filled in yet, as the final
1812 * offset of the string isn't known until later.
1813 */
1814 for (ALIST_TRAVERSE(scapset->oc_mach.cl_val,
1815 idx2, capstr)) {
1816 if (st_insert(strtbl,
1817 capstr->cs_str) == -1)
1818 return (S_ERROR);
1819 capstr->cs_ndx = capndx;
1820 CAP_UPDATE(cap, capndx,
1821 CA_SUNW_MACH, 0);
1822 }
1823 }
1824 if (scapset->oc_hw_2.cm_val) {
1825 CAP_UPDATE(cap, capndx, CA_SUNW_HW_2,
1826 scapset->oc_hw_2.cm_val);
1827 }
1828 if (scapset->oc_hw_1.cm_val) {
1829 CAP_UPDATE(cap, capndx, CA_SUNW_HW_1,
1830 scapset->oc_hw_1.cm_val);
1831 }
1832 if (scapset->oc_sf_1.cm_val) {
1833 CAP_UPDATE(cap, capndx, CA_SUNW_SF_1,
1834 scapset->oc_sf_1.cm_val);
1835 }
1836 CAP_UPDATE(cap, capndx, CA_SUNW_NULL, 0);
1837
1838 /*
1839 * If any object capabilities are available, determine
1840 * whether these symbol capabilities are less
1841 * restrictive, and hence redundant.
1842 */
1843 if (((ofl->ofl_flags & FLG_OF_PTCAP) == 0) ||
1844 (is_cap_redundant(ocapset, scapset) == 0))
1845 continue;
1846
1847 /*
1848 * Indicate any files that provide redundant symbol
1849 * capabilities.
1850 */
1851 for (APLIST_TRAVERSE(cgp->cg_secs, idx2, isp)) {
1852 ld_eprintf(ofl, ERR_WARNING,
1853 MSG_INTL(MSG_CAP_REDUNDANT),
1854 isp->is_file->ifl_name,
1855 EC_WORD(isp->is_scnndx), isp->is_name);
1856 }
1857 }
1858 }
1859
1860 /*
1861 * If capabilities strings are required, the sh_info field of the
1862 * section header will be set to the associated string table.
1863 */
1864 if (ofl->ofl_flags & FLG_OF_CAPSTRS)
1865 shdr->sh_flags |= SHF_INFO_LINK;
1866
1867 /*
1868 * Place these capabilities in the output file.
1869 */
1870 if ((ofl->ofl_oscap = ld_place_section(ofl, isec,
1871 NULL, ident, NULL)) == (Os_desc *)S_ERROR)
1872 return (S_ERROR);
1873
1874 /*
1875 * If symbol capabilities are required, then a .SUNW_capinfo section is
1876 * also created. This table will eventually be sized to match the
1877 * associated symbol table.
1878 */
1879 if (ofl->ofl_capfamilies) {
1880 if ((ofl->ofl_oscapinfo = make_sym_sec(ofl,
1881 MSG_ORIG(MSG_SCN_SUNWCAPINFO), SHT_SUNW_capinfo,
1882 ld_targ.t_id.id_capinfo)) == (Os_desc *)S_ERROR)
1883 return (S_ERROR);
1884
1885 /*
1886 * If we're generating a dynamic object, capabilities family
1887 * members are maintained in a .SUNW_capchain section.
1888 */
1889 if (ofl->ofl_capchaincnt &&
1890 ((ofl->ofl_flags & FLG_OF_RELOBJ) == 0)) {
1891 if (new_section(ofl, SHT_SUNW_capchain,
1892 MSG_ORIG(MSG_SCN_SUNWCAPCHAIN),
1893 ofl->ofl_capchaincnt, &isec, &shdr,
1894 &data) == S_ERROR)
1895 return (S_ERROR);
1896
1897 ofl->ofl_oscapchain = ld_place_section(ofl, isec,
1898 NULL, ld_targ.t_id.id_capchain, NULL);
1899 if (ofl->ofl_oscapchain == (Os_desc *)S_ERROR)
1900 return (S_ERROR);
1901
1902 }
1903 }
1904 return (1);
1905 }
1906 #undef CAP_UPDATE
1907
1908 /*
1909 * Build the PLT section and its associated relocation entries.
1910 */
1911 static uintptr_t
1912 make_plt(Ofl_desc *ofl)
1913 {
1914 Shdr *shdr;
1915 Elf_Data *data;
1916 Is_desc *isec;
1917 size_t size = ld_targ.t_m.m_plt_reservsz +
1918 (((size_t)ofl->ofl_pltcnt + (size_t)ofl->ofl_pltpad) *
1919 ld_targ.t_m.m_plt_entsize);
1920 size_t rsize = (size_t)ofl->ofl_relocpltsz;
1921
1922 /*
1923 * On sparc, account for the NOP at the end of the plt.
1924 */
1925 if (ld_targ.t_m.m_mach == LD_TARG_BYCLASS(EM_SPARC, EM_SPARCV9))
1926 size += sizeof (Word);
1927
1928 if (new_section(ofl, SHT_PROGBITS, MSG_ORIG(MSG_SCN_PLT), 0,
1929 &isec, &shdr, &data) == S_ERROR)
1930 return (S_ERROR);
1931
1932 data->d_size = size;
1933 data->d_align = ld_targ.t_m.m_plt_align;
1934
1935 shdr->sh_flags = ld_targ.t_m.m_plt_shf_flags;
1936 shdr->sh_size = (Xword)size;
1937 shdr->sh_addralign = ld_targ.t_m.m_plt_align;
1938 shdr->sh_entsize = ld_targ.t_m.m_plt_entsize;
1939
1940 ofl->ofl_osplt = ld_place_section(ofl, isec, NULL,
1941 ld_targ.t_id.id_plt, NULL);
1942 if (ofl->ofl_osplt == (Os_desc *)S_ERROR)
1943 return (S_ERROR);
1944
1945 ofl->ofl_osplt->os_szoutrels = (Xword)rsize;
1946
1947 return (1);
1948 }
1949
1950 /*
1951 * Make the hash table. Only built for dynamic executables and shared
1952 * libraries, and provides hashed lookup into the global symbol table
1953 * (.dynsym) for the run-time linker to resolve symbol lookups.
1954 */
1955 static uintptr_t
1956 make_hash(Ofl_desc *ofl)
1957 {
1958 Shdr *shdr;
1959 Elf_Data *data;
1960 Is_desc *isec;
1961 size_t size;
1962 Word nsyms = ofl->ofl_globcnt;
1963 size_t cnt;
1964
1965 /*
1966 * Allocate section header structures. We set entcnt to 0
1967 * because it's going to change after we place this section.
1968 */
1969 if (new_section(ofl, SHT_HASH, MSG_ORIG(MSG_SCN_HASH), 0,
1970 &isec, &shdr, &data) == S_ERROR)
1971 return (S_ERROR);
1972
1973 /*
1974 * Place the section first since it will affect the local symbol
1975 * count.
1976 */
1977 ofl->ofl_oshash =
1978 ld_place_section(ofl, isec, NULL, ld_targ.t_id.id_hash, NULL);
1979 if (ofl->ofl_oshash == (Os_desc *)S_ERROR)
1980 return (S_ERROR);
1981
1982 /*
1983 * Calculate the number of output hash buckets.
1984 */
1985 ofl->ofl_hashbkts = findprime(nsyms);
1986
1987 /*
1988 * The size of the hash table is determined by
1989 *
1990 * i. the initial nbucket and nchain entries (2)
1991 * ii. the number of buckets (calculated above)
1992 * iii. the number of chains (this is based on the number of
1993 * symbols in the .dynsym array).
1994 */
1995 cnt = 2 + ofl->ofl_hashbkts + DYNSYM_ALL_CNT(ofl);
1996 size = cnt * shdr->sh_entsize;
1997
1998 /*
1999 * Finalize the section header and data buffer initialization.
2000 */
2001 if ((data->d_buf = libld_calloc(size, 1)) == NULL)
2002 return (S_ERROR);
2003 data->d_size = size;
2004 shdr->sh_size = (Xword)size;
2005
2006 return (1);
2007 }
2008
2009 /*
2010 * Generate the standard symbol table. Contains all locals and globals,
2011 * and resides in a non-allocatable section (ie. it can be stripped).
2012 */
2013 static uintptr_t
2014 make_symtab(Ofl_desc *ofl)
2015 {
2016 Shdr *shdr;
2017 Elf_Data *data;
2018 Is_desc *isec;
2019 Is_desc *xisec = 0;
2020 size_t size;
2021 Word symcnt;
2022
2023 /*
2024 * Create the section headers. Note that we supply an ent_cnt
2025 * of 0. We won't know the count until the section has been placed.
2026 */
2027 if (new_section(ofl, SHT_SYMTAB, MSG_ORIG(MSG_SCN_SYMTAB), 0,
2028 &isec, &shdr, &data) == S_ERROR)
2029 return (S_ERROR);
2030
2031 /*
2032 * Place the section first since it will affect the local symbol
2033 * count.
2034 */
2035 if ((ofl->ofl_ossymtab = ld_place_section(ofl, isec, NULL,
2036 ld_targ.t_id.id_symtab, NULL)) == (Os_desc *)S_ERROR)
2037 return (S_ERROR);
2038
2039 /*
2040 * At this point we've created all but the 'shstrtab' section.
2041 * Determine if we have to use 'Extended Sections'. If so - then
2042 * also create a SHT_SYMTAB_SHNDX section.
2043 */
2044 if ((ofl->ofl_shdrcnt + 1) >= SHN_LORESERVE) {
2045 Shdr *xshdr;
2046 Elf_Data *xdata;
2047
2048 if (new_section(ofl, SHT_SYMTAB_SHNDX,
2049 MSG_ORIG(MSG_SCN_SYMTAB_SHNDX), 0, &xisec,
2050 &xshdr, &xdata) == S_ERROR)
2051 return (S_ERROR);
2052
2053 if ((ofl->ofl_ossymshndx = ld_place_section(ofl, xisec, NULL,
2054 ld_targ.t_id.id_symtab_ndx, NULL)) == (Os_desc *)S_ERROR)
2055 return (S_ERROR);
2056 }
2057
2058 /*
2059 * Calculated number of symbols, which need to be augmented by
2060 * the (yet to be created) .shstrtab entry.
2061 */
2062 symcnt = (size_t)(1 + SYMTAB_ALL_CNT(ofl));
2063 size = symcnt * shdr->sh_entsize;
2064
2065 /*
2066 * Finalize the section header and data buffer initialization.
2067 */
2068 data->d_size = size;
2069 shdr->sh_size = (Xword)size;
2070
2071 /*
2072 * If we created a SHT_SYMTAB_SHNDX - then set it's sizes too.
2073 */
2074 if (xisec) {
2075 size_t xsize = symcnt * sizeof (Word);
2076
2077 xisec->is_indata->d_size = xsize;
2078 xisec->is_shdr->sh_size = (Xword)xsize;
2079 }
2080
2081 return (1);
2082 }
2083
2084 /*
2085 * Build a dynamic symbol table. These tables reside in the text
2086 * segment of a dynamic executable or shared library.
2087 *
2088 * .SUNW_ldynsym contains local function symbols
2089 * .dynsym contains only globals symbols
2090 *
2091 * The two tables are created adjacent to each other, with .SUNW_ldynsym
2092 * coming first.
2093 */
2094 static uintptr_t
2095 make_dynsym(Ofl_desc *ofl)
2096 {
2097 Shdr *shdr, *lshdr;
2098 Elf_Data *data, *ldata;
2099 Is_desc *isec, *lisec;
2100 size_t size;
2101 Xword cnt;
2102 int allow_ldynsym;
2103
2104 /*
2105 * Unless explicitly disabled, always produce a .SUNW_ldynsym section
2106 * when it is allowed by the file type, even if the resulting
2107 * table only ends up with a single STT_FILE in it. There are
2108 * two reasons: (1) It causes the generation of the DT_SUNW_SYMTAB
2109 * entry in the .dynamic section, which is something we would
2110 * like to encourage, and (2) Without it, we cannot generate
2111 * the associated .SUNW_dyn[sym|tls]sort sections, which are of
2112 * value to DTrace.
2113 *
2114 * In practice, it is extremely rare for an object not to have
2115 * local symbols for .SUNW_ldynsym, so 99% of the time, we'd be
2116 * doing it anyway.
2117 */
2118 allow_ldynsym = OFL_ALLOW_LDYNSYM(ofl);
2119
2120 /*
2121 * Create the section headers. Note that we supply an ent_cnt
2122 * of 0. We won't know the count until the section has been placed.
2123 */
2124 if (allow_ldynsym && new_section(ofl, SHT_SUNW_LDYNSYM,
2125 MSG_ORIG(MSG_SCN_LDYNSYM), 0, &lisec, &lshdr, &ldata) == S_ERROR)
2126 return (S_ERROR);
2127
2128 if (new_section(ofl, SHT_DYNSYM, MSG_ORIG(MSG_SCN_DYNSYM), 0,
2129 &isec, &shdr, &data) == S_ERROR)
2130 return (S_ERROR);
2131
2132 /*
2133 * Place the section(s) first since it will affect the local symbol
2134 * count.
2135 */
2136 if (allow_ldynsym &&
2137 ((ofl->ofl_osldynsym = ld_place_section(ofl, lisec, NULL,
2138 ld_targ.t_id.id_ldynsym, NULL)) == (Os_desc *)S_ERROR))
2139 return (S_ERROR);
2140 ofl->ofl_osdynsym =
2141 ld_place_section(ofl, isec, NULL, ld_targ.t_id.id_dynsym, NULL);
2142 if (ofl->ofl_osdynsym == (Os_desc *)S_ERROR)
2143 return (S_ERROR);
2144
2145 cnt = DYNSYM_ALL_CNT(ofl);
2146 size = (size_t)cnt * shdr->sh_entsize;
2147
2148 /*
2149 * Finalize the section header and data buffer initialization.
2150 */
2151 data->d_size = size;
2152 shdr->sh_size = (Xword)size;
2153
2154 /*
2155 * An ldynsym contains local function symbols. It is not
2156 * used for linking, but if present, serves to allow better
2157 * stack traces to be generated in contexts where the symtab
2158 * is not available. (dladdr(), or stripped executable/library files).
2159 */
2160 if (allow_ldynsym) {
2161 cnt = 1 + ofl->ofl_dynlocscnt + ofl->ofl_dynscopecnt;
2162 size = (size_t)cnt * shdr->sh_entsize;
2163
2164 ldata->d_size = size;
2165 lshdr->sh_size = (Xword)size;
2166 }
2167
2168 return (1);
2169 }
2170
2171 /*
2172 * Build .SUNW_dynsymsort and/or .SUNW_dyntlssort sections. These are
2173 * index sections for the .SUNW_ldynsym/.dynsym pair that present data
2174 * and function symbols sorted by address.
2175 */
2176 static uintptr_t
2177 make_dynsort(Ofl_desc *ofl)
2178 {
2179 Shdr *shdr;
2180 Elf_Data *data;
2181 Is_desc *isec;
2182
2183 /* Only do it if the .SUNW_ldynsym section is present */
2184 if (!OFL_ALLOW_LDYNSYM(ofl))
2185 return (1);
2186
2187 /* .SUNW_dynsymsort */
2188 if (ofl->ofl_dynsymsortcnt > 0) {
2189 if (new_section(ofl, SHT_SUNW_symsort,
2190 MSG_ORIG(MSG_SCN_DYNSYMSORT), ofl->ofl_dynsymsortcnt,
2191 &isec, &shdr, &data) == S_ERROR)
2192 return (S_ERROR);
2193
2194 if ((ofl->ofl_osdynsymsort = ld_place_section(ofl, isec, NULL,
2195 ld_targ.t_id.id_dynsort, NULL)) == (Os_desc *)S_ERROR)
2196 return (S_ERROR);
2197 }
2198
2199 /* .SUNW_dyntlssort */
2200 if (ofl->ofl_dyntlssortcnt > 0) {
2201 if (new_section(ofl, SHT_SUNW_tlssort,
2202 MSG_ORIG(MSG_SCN_DYNTLSSORT),
2203 ofl->ofl_dyntlssortcnt, &isec, &shdr, &data) == S_ERROR)
2204 return (S_ERROR);
2205
2206 if ((ofl->ofl_osdyntlssort = ld_place_section(ofl, isec, NULL,
2207 ld_targ.t_id.id_dynsort, NULL)) == (Os_desc *)S_ERROR)
2208 return (S_ERROR);
2209 }
2210
2211 return (1);
2212 }
2213
2214 /*
2215 * Helper routine for make_dynsym_shndx. Builds a
2216 * a SHT_SYMTAB_SHNDX for .dynsym or .SUNW_ldynsym, without knowing
2217 * which one it is.
2218 */
2219 static uintptr_t
2220 make_dyn_shndx(Ofl_desc *ofl, const char *shname, Os_desc *symtab,
2221 Os_desc **ret_os)
2222 {
2223 Is_desc *isec;
2224 Is_desc *dynsymisp;
2225 Shdr *shdr, *dynshdr;
2226 Elf_Data *data;
2227
2228 dynsymisp = ld_os_first_isdesc(symtab);
2229 dynshdr = dynsymisp->is_shdr;
2230
2231 if (new_section(ofl, SHT_SYMTAB_SHNDX, shname,
2232 (dynshdr->sh_size / dynshdr->sh_entsize),
2233 &isec, &shdr, &data) == S_ERROR)
2234 return (S_ERROR);
2235
2236 if ((*ret_os = ld_place_section(ofl, isec, NULL,
2237 ld_targ.t_id.id_dynsym_ndx, NULL)) == (Os_desc *)S_ERROR)
2238 return (S_ERROR);
2239
2240 assert(*ret_os);
2241
2242 return (1);
2243 }
2244
2245 /*
2246 * Build a SHT_SYMTAB_SHNDX for the .dynsym, and .SUNW_ldynsym
2247 */
2248 static uintptr_t
2249 make_dynsym_shndx(Ofl_desc *ofl)
2250 {
2251 /*
2252 * If there is a .SUNW_ldynsym, generate a section for its extended
2253 * index section as well.
2254 */
2255 if (OFL_ALLOW_LDYNSYM(ofl)) {
2256 if (make_dyn_shndx(ofl, MSG_ORIG(MSG_SCN_LDYNSYM_SHNDX),
2257 ofl->ofl_osldynsym, &ofl->ofl_osldynshndx) == S_ERROR)
2258 return (S_ERROR);
2259 }
2260
2261 /* The Generate a section for the dynsym */
2262 if (make_dyn_shndx(ofl, MSG_ORIG(MSG_SCN_DYNSYM_SHNDX),
2263 ofl->ofl_osdynsym, &ofl->ofl_osdynshndx) == S_ERROR)
2264 return (S_ERROR);
2265
2266 return (1);
2267 }
2268
2269
2270 /*
2271 * Build a string table for the section headers.
2272 */
2273 static uintptr_t
2274 make_shstrtab(Ofl_desc *ofl)
2275 {
2276 Shdr *shdr;
2277 Elf_Data *data;
2278 Is_desc *isec;
2279 size_t size;
2280
2281 if (new_section(ofl, SHT_STRTAB, MSG_ORIG(MSG_SCN_SHSTRTAB),
2282 0, &isec, &shdr, &data) == S_ERROR)
2283 return (S_ERROR);
2284
2285 /*
2286 * Place the section first, as it may effect the number of section
2287 * headers to account for.
2288 */
2289 ofl->ofl_osshstrtab =
2290 ld_place_section(ofl, isec, NULL, ld_targ.t_id.id_note, NULL);
2291 if (ofl->ofl_osshstrtab == (Os_desc *)S_ERROR)
2292 return (S_ERROR);
2293
2294 size = st_getstrtab_sz(ofl->ofl_shdrsttab);
2295 assert(size > 0);
2296
2297 data->d_size = size;
2298 shdr->sh_size = (Xword)size;
2299
2300 return (1);
2301 }
2302
2303 /*
2304 * Build a string section for the standard symbol table.
2305 */
2306 static uintptr_t
2307 make_strtab(Ofl_desc *ofl)
2308 {
2309 Shdr *shdr;
2310 Elf_Data *data;
2311 Is_desc *isec;
2312 size_t size;
2313
2314 /*
2315 * This string table consists of all the global and local symbols.
2316 * Account for null bytes at end of the file name and the beginning
2317 * of section.
2318 */
2319 if (st_insert(ofl->ofl_strtab, ofl->ofl_name) == -1)
2320 return (S_ERROR);
2321
2322 size = st_getstrtab_sz(ofl->ofl_strtab);
2323 assert(size > 0);
2324
2325 if (new_section(ofl, SHT_STRTAB, MSG_ORIG(MSG_SCN_STRTAB),
2326 0, &isec, &shdr, &data) == S_ERROR)
2327 return (S_ERROR);
2328
2329 /* Set the size of the data area */
2330 data->d_size = size;
2331 shdr->sh_size = (Xword)size;
2332
2333 ofl->ofl_osstrtab =
2334 ld_place_section(ofl, isec, NULL, ld_targ.t_id.id_strtab, NULL);
2335 return ((uintptr_t)ofl->ofl_osstrtab);
2336 }
2337
2338 /*
2339 * Build a string table for the dynamic symbol table.
2340 */
2341 static uintptr_t
2342 make_dynstr(Ofl_desc *ofl)
2343 {
2344 Shdr *shdr;
2345 Elf_Data *data;
2346 Is_desc *isec;
2347 size_t size;
2348
2349 /*
2350 * If producing a .SUNW_ldynsym, account for the initial STT_FILE
2351 * symbol that precedes the scope reduced global symbols.
2352 */
2353 if (OFL_ALLOW_LDYNSYM(ofl)) {
2354 if (st_insert(ofl->ofl_dynstrtab, ofl->ofl_name) == -1)
2355 return (S_ERROR);
2356 ofl->ofl_dynscopecnt++;
2357 }
2358
2359 /*
2360 * Account for any local, named register symbols. These locals are
2361 * required for reference from DT_REGISTER .dynamic entries.
2362 */
2363 if (ofl->ofl_regsyms) {
2364 int ndx;
2365
2366 for (ndx = 0; ndx < ofl->ofl_regsymsno; ndx++) {
2367 Sym_desc *sdp;
2368
2369 if ((sdp = ofl->ofl_regsyms[ndx]) == NULL)
2370 continue;
2371
2372 if (!SYM_IS_HIDDEN(sdp) &&
2373 (ELF_ST_BIND(sdp->sd_sym->st_info) != STB_LOCAL))
2374 continue;
2375
2376 if (sdp->sd_sym->st_name == NULL)
2377 continue;
2378
2379 if (st_insert(ofl->ofl_dynstrtab, sdp->sd_name) == -1)
2380 return (S_ERROR);
2381 }
2382 }
2383
2384 /*
2385 * Reserve entries for any per-symbol auxiliary/filter strings.
2386 */
2387 if (ofl->ofl_dtsfltrs != NULL) {
2388 Dfltr_desc *dftp;
2389 Aliste idx;
2390
2391 for (ALIST_TRAVERSE(ofl->ofl_dtsfltrs, idx, dftp))
2392 if (st_insert(ofl->ofl_dynstrtab, dftp->dft_str) == -1)
2393 return (S_ERROR);
2394 }
2395
2396 size = st_getstrtab_sz(ofl->ofl_dynstrtab);
2397 assert(size > 0);
2398
2399 if (new_section(ofl, SHT_STRTAB, MSG_ORIG(MSG_SCN_DYNSTR),
2400 0, &isec, &shdr, &data) == S_ERROR)
2401 return (S_ERROR);
2402
2403 /* Make it allocable if necessary */
2404 if (!(ofl->ofl_flags & FLG_OF_RELOBJ))
2405 shdr->sh_flags |= SHF_ALLOC;
2406
2407 /* Set the size of the data area */
2408 data->d_size = size + DYNSTR_EXTRA_PAD;
2409
2410 shdr->sh_size = (Xword)size;
2411
2412 ofl->ofl_osdynstr =
2413 ld_place_section(ofl, isec, NULL, ld_targ.t_id.id_dynstr, NULL);
2414 return ((uintptr_t)ofl->ofl_osdynstr);
2415 }
2416
2417 /*
2418 * Generate an output relocation section which will contain the relocation
2419 * information to be applied to the `osp' section.
2420 *
2421 * If (osp == NULL) then we are creating the coalesced relocation section
2422 * for an executable and/or a shared object.
2423 */
2424 static uintptr_t
2425 make_reloc(Ofl_desc *ofl, Os_desc *osp)
2426 {
2427 Shdr *shdr;
2428 Elf_Data *data;
2429 Is_desc *isec;
2430 size_t size;
2431 Xword sh_flags;
2432 char *sectname;
2433 Os_desc *rosp;
2434 Word relsize;
2435 const char *rel_prefix;
2436
2437 /* LINTED */
2438 if (ld_targ.t_m.m_rel_sht_type == SHT_REL) {
2439 /* REL */
2440 relsize = sizeof (Rel);
2441 rel_prefix = MSG_ORIG(MSG_SCN_REL);
2442 } else {
2443 /* RELA */
2444 relsize = sizeof (Rela);
2445 rel_prefix = MSG_ORIG(MSG_SCN_RELA);
2446 }
2447
2448 if (osp) {
2449 size = osp->os_szoutrels;
2450 sh_flags = osp->os_shdr->sh_flags;
2451 if ((sectname = libld_malloc(strlen(rel_prefix) +
2452 strlen(osp->os_name) + 1)) == 0)
2453 return (S_ERROR);
2454 (void) strcpy(sectname, rel_prefix);
2455 (void) strcat(sectname, osp->os_name);
2456 } else if (ofl->ofl_flags & FLG_OF_COMREL) {
2457 size = (ofl->ofl_reloccnt - ofl->ofl_reloccntsub) * relsize;
2458 sh_flags = SHF_ALLOC;
2459 sectname = (char *)MSG_ORIG(MSG_SCN_SUNWRELOC);
2460 } else {
2461 size = ofl->ofl_relocrelsz;
2462 sh_flags = SHF_ALLOC;
2463 sectname = (char *)rel_prefix;
2464 }
2465
2466 /*
2467 * Keep track of total size of 'output relocations' (to be stored
2468 * in .dynamic)
2469 */
2470 /* LINTED */
2471 ofl->ofl_relocsz += (Xword)size;
2472
2473 if (new_section(ofl, ld_targ.t_m.m_rel_sht_type, sectname, 0, &isec,
2474 &shdr, &data) == S_ERROR)
2475 return (S_ERROR);
2476
2477 data->d_size = size;
2478
2479 shdr->sh_size = (Xword)size;
2480 if (OFL_ALLOW_DYNSYM(ofl) && (sh_flags & SHF_ALLOC))
2481 shdr->sh_flags = SHF_ALLOC;
2482
2483 if (osp) {
2484 /*
2485 * The sh_info field of the SHT_REL* sections points to the
2486 * section the relocations are to be applied to.
2487 */
2488 shdr->sh_flags |= SHF_INFO_LINK;
2489 }
2490
2491 rosp = ld_place_section(ofl, isec, NULL, ld_targ.t_id.id_rel, NULL);
2492 if (rosp == (Os_desc *)S_ERROR)
2493 return (S_ERROR);
2494
2495 /*
2496 * Associate this relocation section to the section its going to
2497 * relocate.
2498 */
2499 if (osp) {
2500 Aliste idx;
2501 Is_desc *risp;
2502
2503 /*
2504 * This is used primarily so that we can update
2505 * SHT_GROUP[sect_no] entries to point to the
2506 * created output relocation sections.
2507 */
2508 for (APLIST_TRAVERSE(osp->os_relisdescs, idx, risp)) {
2509 risp->is_osdesc = rosp;
2510
2511 /*
2512 * If the input relocation section had the SHF_GROUP
2513 * flag set - propagate it to the output relocation
2514 * section.
2515 */
2516 if (risp->is_shdr->sh_flags & SHF_GROUP) {
2517 rosp->os_shdr->sh_flags |= SHF_GROUP;
2518 break;
2519 }
2520 }
2521 osp->os_relosdesc = rosp;
2522 } else
2523 ofl->ofl_osrel = rosp;
2524
2525 /*
2526 * If this is the first relocation section we've encountered save it
2527 * so that the .dynamic entry can be initialized accordingly.
2528 */
2529 if (ofl->ofl_osrelhead == (Os_desc *)0)
2530 ofl->ofl_osrelhead = rosp;
2531
2532 return (1);
2533 }
2534
2535 /*
2536 * Generate version needed section.
2537 */
2538 static uintptr_t
2539 make_verneed(Ofl_desc *ofl)
2540 {
2541 Shdr *shdr;
2542 Elf_Data *data;
2543 Is_desc *isec;
2544
2545 /*
2546 * verneed sections do not have a constant element size, so the
2547 * value of ent_cnt specified here (0) is meaningless.
2548 */
2549 if (new_section(ofl, SHT_SUNW_verneed, MSG_ORIG(MSG_SCN_SUNWVERSION),
2550 0, &isec, &shdr, &data) == S_ERROR)
2551 return (S_ERROR);
2552
2553 /* During version processing we calculated the total size. */
2554 data->d_size = ofl->ofl_verneedsz;
2555 shdr->sh_size = (Xword)ofl->ofl_verneedsz;
2556
2557 ofl->ofl_osverneed =
2558 ld_place_section(ofl, isec, NULL, ld_targ.t_id.id_version, NULL);
2559 return ((uintptr_t)ofl->ofl_osverneed);
2560 }
2561
2562 /*
2563 * Generate a version definition section.
2564 *
2565 * o the SHT_SUNW_verdef section defines the versions that exist within this
2566 * image.
2567 */
2568 static uintptr_t
2569 make_verdef(Ofl_desc *ofl)
2570 {
2571 Shdr *shdr;
2572 Elf_Data *data;
2573 Is_desc *isec;
2574 Ver_desc *vdp;
2575 Str_tbl *strtab;
2576
2577 /*
2578 * Reserve a string table entry for the base version dependency (other
2579 * dependencies have symbol representations, which will already be
2580 * accounted for during symbol processing).
2581 */
2582 vdp = (Ver_desc *)ofl->ofl_verdesc->apl_data[0];
2583
2584 if (OFL_IS_STATIC_OBJ(ofl))
2585 strtab = ofl->ofl_strtab;
2586 else
2587 strtab = ofl->ofl_dynstrtab;
2588
2589 if (st_insert(strtab, vdp->vd_name) == -1)
2590 return (S_ERROR);
2591
2592 /*
2593 * verdef sections do not have a constant element size, so the
2594 * value of ent_cnt specified here (0) is meaningless.
2595 */
2596 if (new_section(ofl, SHT_SUNW_verdef, MSG_ORIG(MSG_SCN_SUNWVERSION),
2597 0, &isec, &shdr, &data) == S_ERROR)
2598 return (S_ERROR);
2599
2600 /* During version processing we calculated the total size. */
2601 data->d_size = ofl->ofl_verdefsz;
2602 shdr->sh_size = (Xword)ofl->ofl_verdefsz;
2603
2604 ofl->ofl_osverdef =
2605 ld_place_section(ofl, isec, NULL, ld_targ.t_id.id_version, NULL);
2606 return ((uintptr_t)ofl->ofl_osverdef);
2607 }
2608
2609 /*
2610 * This routine is called when -z nopartial is in effect.
2611 */
2612 uintptr_t
2613 ld_make_parexpn_data(Ofl_desc *ofl, size_t size, Xword align)
2614 {
2615 Shdr *shdr;
2616 Elf_Data *data;
2617 Is_desc *isec;
2618 Os_desc *osp;
2619
2620 if (new_section(ofl, SHT_PROGBITS, MSG_ORIG(MSG_SCN_DATA), 0,
2621 &isec, &shdr, &data) == S_ERROR)
2622 return (S_ERROR);
2623
2624 shdr->sh_flags |= SHF_WRITE;
2625 data->d_size = size;
2626 shdr->sh_size = (Xword)size;
2627 if (align != 0) {
2628 data->d_align = align;
2629 shdr->sh_addralign = align;
2630 }
2631
2632 if ((data->d_buf = libld_calloc(size, 1)) == NULL)
2633 return (S_ERROR);
2634
2635 /*
2636 * Retain handle to this .data input section. Variables using move
2637 * sections (partial initialization) will be redirected here when
2638 * such global references are added and '-z nopartial' is in effect.
2639 */
2640 ofl->ofl_isparexpn = isec;
2641 osp = ld_place_section(ofl, isec, NULL, ld_targ.t_id.id_data, NULL);
2642 if (osp == (Os_desc *)S_ERROR)
2643 return (S_ERROR);
2644
2645 if (!(osp->os_flags & FLG_OS_OUTREL)) {
2646 ofl->ofl_dynshdrcnt++;
2647 osp->os_flags |= FLG_OS_OUTREL;
2648 }
2649 return (1);
2650 }
2651
2652 /*
2653 * Make .sunwmove section
2654 */
2655 uintptr_t
2656 ld_make_sunwmove(Ofl_desc *ofl, int mv_nums)
2657 {
2658 Shdr *shdr;
2659 Elf_Data *data;
2660 Is_desc *isec;
2661 Aliste idx;
2662 Sym_desc *sdp;
2663 int cnt = 1;
2664
2665
2666 if (new_section(ofl, SHT_SUNW_move, MSG_ORIG(MSG_SCN_SUNWMOVE),
2667 mv_nums, &isec, &shdr, &data) == S_ERROR)
2668 return (S_ERROR);
2669
2670 if ((data->d_buf = libld_calloc(data->d_size, 1)) == NULL)
2671 return (S_ERROR);
2672
2673 /*
2674 * Copy move entries
2675 */
2676 for (APLIST_TRAVERSE(ofl->ofl_parsyms, idx, sdp)) {
2677 Aliste idx2;
2678 Mv_desc *mdp;
2679
2680 if (sdp->sd_flags & FLG_SY_PAREXPN)
2681 continue;
2682
2683 for (ALIST_TRAVERSE(sdp->sd_move, idx2, mdp))
2684 mdp->md_oidx = cnt++;
2685 }
2686
2687 if ((ofl->ofl_osmove = ld_place_section(ofl, isec, NULL, 0, NULL)) ==
2688 (Os_desc *)S_ERROR)
2689 return (S_ERROR);
2690
2691 return (1);
2692 }
2693
2694 /*
2695 * Given a relocation descriptor that references a string table
2696 * input section, locate the string referenced and return a pointer
2697 * to it.
2698 */
2699 static const char *
2700 strmerge_get_reloc_str(Ofl_desc *ofl, Rel_desc *rsp)
2701 {
2702 Sym_desc *sdp = rsp->rel_sym;
2703 Xword str_off;
2704
2705 /*
2706 * In the case of an STT_SECTION symbol, the addend of the
2707 * relocation gives the offset into the string section. For
2708 * other symbol types, the symbol value is the offset.
2709 */
2710
2711 if (ELF_ST_TYPE(sdp->sd_sym->st_info) != STT_SECTION) {
2712 str_off = sdp->sd_sym->st_value;
2713 } else if ((rsp->rel_flags & FLG_REL_RELA) == FLG_REL_RELA) {
2714 /*
2715 * For SHT_RELA, the addend value is found in the
2716 * rel_raddend field of the relocation.
2717 */
2718 str_off = rsp->rel_raddend;
2719 } else { /* REL and STT_SECTION */
2720 /*
2721 * For SHT_REL, the "addend" is not part of the relocation
2722 * record. Instead, it is found at the relocation target
2723 * address.
2724 */
2725 uchar_t *addr = (uchar_t *)((uintptr_t)rsp->rel_roffset +
2726 (uintptr_t)rsp->rel_isdesc->is_indata->d_buf);
2727
2728 if (ld_reloc_targval_get(ofl, rsp, addr, &str_off) == 0)
2729 return (0);
2730 }
2731
2732 return (str_off + (char *)sdp->sd_isc->is_indata->d_buf);
2733 }
2734
2735 /*
2736 * First pass over the relocation records for string table merging.
2737 * Build lists of relocations and symbols that will need modification,
2738 * and insert the strings they reference into the mstrtab string table.
2739 *
2740 * entry:
2741 * ofl, osp - As passed to ld_make_strmerge().
2742 * mstrtab - String table to receive input strings. This table
2743 * must be in its first (initialization) pass and not
2744 * yet cooked (st_getstrtab_sz() not yet called).
2745 * rel_alpp - APlist to receive pointer to any relocation
2746 * descriptors with STT_SECTION symbols that reference
2747 * one of the input sections being merged.
2748 * sym_alpp - APlist to receive pointer to any symbols that reference
2749 * one of the input sections being merged.
2750 * rcp - Pointer to cache of relocation descriptors to examine.
2751 * Either &ofl->ofl_actrels (active relocations)
2752 * or &ofl->ofl_outrels (output relocations).
2753 *
2754 * exit:
2755 * On success, rel_alpp and sym_alpp are updated, and
2756 * any strings in the mergeable input sections referenced by
2757 * a relocation has been entered into mstrtab. True (1) is returned.
2758 *
2759 * On failure, False (0) is returned.
2760 */
2761 static int
2762 strmerge_pass1(Ofl_desc *ofl, Os_desc *osp, Str_tbl *mstrtab,
2763 APlist **rel_alpp, APlist **sym_alpp, Rel_cache *rcp)
2764 {
2765 Aliste idx;
2766 Rel_cachebuf *rcbp;
2767 Sym_desc *sdp;
2768 Sym_desc *last_sdp = NULL;
2769 Rel_desc *rsp;
2770 const char *name;
2771
2772 REL_CACHE_TRAVERSE(rcp, idx, rcbp, rsp) {
2773 sdp = rsp->rel_sym;
2774 if ((sdp->sd_isc == NULL) || ((sdp->sd_isc->is_flags &
2775 (FLG_IS_DISCARD | FLG_IS_INSTRMRG)) != FLG_IS_INSTRMRG) ||
2776 (sdp->sd_isc->is_osdesc != osp))
2777 continue;
2778
2779 /*
2780 * Remember symbol for use in the third pass. There is no
2781 * reason to save a given symbol more than once, so we take
2782 * advantage of the fact that relocations to a given symbol
2783 * tend to cluster in the list. If this is the same symbol
2784 * we saved last time, don't bother.
2785 */
2786 if (last_sdp != sdp) {
2787 if (aplist_append(sym_alpp, sdp, AL_CNT_STRMRGSYM) ==
2788 NULL)
2789 return (0);
2790 last_sdp = sdp;
2791 }
2792
2793 /* Enter the string into our new string table */
2794 name = strmerge_get_reloc_str(ofl, rsp);
2795 if (st_insert(mstrtab, name) == -1)
2796 return (0);
2797
2798 /*
2799 * If this is an STT_SECTION symbol, then the second pass
2800 * will need to modify this relocation, so hang on to it.
2801 */
2802 if ((ELF_ST_TYPE(sdp->sd_sym->st_info) == STT_SECTION) &&
2803 (aplist_append(rel_alpp, rsp, AL_CNT_STRMRGREL) == NULL))
2804 return (0);
2805 }
2806
2807 return (1);
2808 }
2809
2810 /*
2811 * If the output section has any SHF_MERGE|SHF_STRINGS input sections,
2812 * replace them with a single merged/compressed input section.
2813 *
2814 * entry:
2815 * ofl - Output file descriptor
2816 * osp - Output section descriptor
2817 * rel_alpp, sym_alpp, - Address of 2 APlists, to be used
2818 * for internal processing. On the initial call to
2819 * ld_make_strmerge, these list pointers must be NULL.
2820 * The caller is encouraged to pass the same lists back for
2821 * successive calls to this function without freeing
2822 * them in between calls. This causes a single pair of
2823 * memory allocations to be reused multiple times.
2824 *
2825 * exit:
2826 * If section merging is possible, it is done. If no errors are
2827 * encountered, True (1) is returned. On error, S_ERROR.
2828 *
2829 * The contents of rel_alpp and sym_alpp on exit are
2830 * undefined. The caller can free them, or pass them back to a subsequent
2831 * call to this routine, but should not examine their contents.
2832 */
2833 static uintptr_t
2834 ld_make_strmerge(Ofl_desc *ofl, Os_desc *osp, APlist **rel_alpp,
2835 APlist **sym_alpp)
2836 {
2837 Str_tbl *mstrtab; /* string table for string merge secs */
2838 Is_desc *mstrsec; /* Generated string merge section */
2839 Is_desc *isp;
2840 Shdr *mstr_shdr;
2841 Elf_Data *mstr_data;
2842 Sym_desc *sdp;
2843 Rel_desc *rsp;
2844 Aliste idx;
2845 size_t data_size;
2846 int st_setstring_status;
2847 size_t stoff;
2848
2849 /* If string table compression is disabled, there's nothing to do */
2850 if ((ofl->ofl_flags1 & FLG_OF1_NCSTTAB) != 0)
2851 return (1);
2852
2853 /*
2854 * Pass over the mergeable input sections, and if they haven't
2855 * all been discarded, create a string table.
2856 */
2857 mstrtab = NULL;
2858 for (APLIST_TRAVERSE(osp->os_mstrisdescs, idx, isp)) {
2859 if (isdesc_discarded(isp))
2860 continue;
2861
2862 /*
2863 * Input sections of 0 size are dubiously valid since they do
2864 * not even contain the NUL string. Ignore them.
2865 */
2866 if (isp->is_shdr->sh_size == 0)
2867 continue;
2868
2869 /*
2870 * We have at least one non-discarded section.
2871 * Create a string table descriptor.
2872 */
2873 if ((mstrtab = st_new(FLG_STNEW_COMPRESS)) == NULL)
2874 return (S_ERROR);
2875 break;
2876 }
2877
2878 /* If no string table was created, we have no mergeable sections */
2879 if (mstrtab == NULL)
2880 return (1);
2881
2882 /*
2883 * This routine has to make 3 passes:
2884 *
2885 * 1) Examine all relocations, insert strings from relocations
2886 * to the mergeable input sections into the string table.
2887 * 2) Modify the relocation values to be correct for the
2888 * new merged section.
2889 * 3) Modify the symbols used by the relocations to reference
2890 * the new section.
2891 *
2892 * These passes cannot be combined:
2893 * - The string table code works in two passes, and all
2894 * strings have to be loaded in pass one before the
2895 * offset of any strings can be determined.
2896 * - Multiple relocations reference a single symbol, so the
2897 * symbol cannot be modified until all relocations are
2898 * fixed.
2899 *
2900 * The number of relocations related to section merging is usually
2901 * a mere fraction of the overall active and output relocation lists,
2902 * and the number of symbols is usually a fraction of the number
2903 * of related relocations. We therefore build APlists for the
2904 * relocations and symbols in the first pass, and then use those
2905 * lists to accelerate the operation of pass 2 and 3.
2906 *
2907 * Reinitialize the lists to a completely empty state.
2908 */
2909 aplist_reset(*rel_alpp);
2910 aplist_reset(*sym_alpp);
2911
2912 /*
2913 * Pass 1:
2914 *
2915 * Every relocation related to this output section (and the input
2916 * sections that make it up) is found in either the active, or the
2917 * output relocation list, depending on whether the relocation is to
2918 * be processed by this invocation of the linker, or inserted into the
2919 * output object.
2920 *
2921 * Build lists of relocations and symbols that will need modification,
2922 * and insert the strings they reference into the mstrtab string table.
2923 */
2924 if (strmerge_pass1(ofl, osp, mstrtab, rel_alpp, sym_alpp,
2925 &ofl->ofl_actrels) == 0)
2926 goto return_s_error;
2927 if (strmerge_pass1(ofl, osp, mstrtab, rel_alpp, sym_alpp,
2928 &ofl->ofl_outrels) == 0)
2929 goto return_s_error;
2930
2931 /*
2932 * Get the size of the new input section. Requesting the
2933 * string table size "cooks" the table, and finalizes its contents.
2934 */
2935 data_size = st_getstrtab_sz(mstrtab);
2936
2937 /* Create a new input section to hold the merged strings */
2938 if (new_section_from_template(ofl, isp, data_size,
2939 &mstrsec, &mstr_shdr, &mstr_data) == S_ERROR)
2940 goto return_s_error;
2941 mstrsec->is_flags |= FLG_IS_GNSTRMRG;
2942
2943 /*
2944 * Allocate a data buffer for the new input section.
2945 * Then, associate the buffer with the string table descriptor.
2946 */
2947 if ((mstr_data->d_buf = libld_malloc(data_size)) == NULL)
2948 goto return_s_error;
2949 if (st_setstrbuf(mstrtab, mstr_data->d_buf, data_size) == -1)
2950 goto return_s_error;
2951
2952 /* Add the new section to the output image */
2953 if (ld_place_section(ofl, mstrsec, NULL, osp->os_identndx, NULL) ==
2954 (Os_desc *)S_ERROR)
2955 goto return_s_error;
2956
2957 /*
2958 * Pass 2:
2959 *
2960 * Revisit the relocation descriptors with STT_SECTION symbols
2961 * that were saved by the first pass. Update each relocation
2962 * record so that the offset it contains is for the new section
2963 * instead of the original.
2964 */
2965 for (APLIST_TRAVERSE(*rel_alpp, idx, rsp)) {
2966 const char *name;
2967
2968 /* Put the string into the merged string table */
2969 name = strmerge_get_reloc_str(ofl, rsp);
2970 st_setstring_status = st_setstring(mstrtab, name, &stoff);
2971 if (st_setstring_status == -1) {
2972 /*
2973 * A failure to insert at this point means that
2974 * something is corrupt. This isn't a resource issue.
2975 */
2976 assert(st_setstring_status != -1);
2977 goto return_s_error;
2978 }
2979
2980 /*
2981 * Alter the relocation to access the string at the
2982 * new offset in our new string table.
2983 *
2984 * For SHT_RELA platforms, it suffices to simply
2985 * update the rel_raddend field of the relocation.
2986 *
2987 * For SHT_REL platforms, the new "addend" value
2988 * needs to be written at the address being relocated.
2989 * However, we can't alter the input sections which
2990 * are mapped readonly, and the output image has not
2991 * been created yet. So, we defer this operation,
2992 * using the rel_raddend field of the relocation
2993 * which is normally 0 on a REL platform, to pass the
2994 * new "addend" value to ld_perform_outreloc() or
2995 * ld_do_activerelocs(). The FLG_REL_NADDEND flag
2996 * tells them that this is the case.
2997 */
2998 if ((rsp->rel_flags & FLG_REL_RELA) == 0) /* REL */
2999 rsp->rel_flags |= FLG_REL_NADDEND;
3000 rsp->rel_raddend = (Sxword)stoff;
3001
3002 /*
3003 * Generate a symbol name string for STT_SECTION symbols
3004 * that might reference our merged section. This shows up
3005 * in debug output and helps show how the relocation has
3006 * changed from its original input section to our merged one.
3007 */
3008 if (ld_stt_section_sym_name(mstrsec) == NULL)
3009 goto return_s_error;
3010 }
3011
3012 /*
3013 * Pass 3:
3014 *
3015 * Modify the symbols referenced by the relocation descriptors
3016 * so that they reference the new input section containing the
3017 * merged strings instead of the original input sections.
3018 */
3019 for (APLIST_TRAVERSE(*sym_alpp, idx, sdp)) {
3020 /*
3021 * If we've already processed this symbol, don't do it
3022 * twice. strmerge_pass1() uses a heuristic (relocations to
3023 * the same symbol clump together) to avoid inserting a
3024 * given symbol more than once, but repeat symbols in
3025 * the list can occur.
3026 */
3027 if ((sdp->sd_isc->is_flags & FLG_IS_INSTRMRG) == 0)
3028 continue;
3029
3030 if (ELF_ST_TYPE(sdp->sd_sym->st_info) != STT_SECTION) {
3031 /*
3032 * This is not an STT_SECTION symbol, so its
3033 * value is the offset of the string within the
3034 * input section. Update the address to reflect
3035 * the address in our new merged section.
3036 */
3037 const char *name = sdp->sd_sym->st_value +
3038 (char *)sdp->sd_isc->is_indata->d_buf;
3039
3040 st_setstring_status =
3041 st_setstring(mstrtab, name, &stoff);
3042 if (st_setstring_status == -1) {
3043 /*
3044 * A failure to insert at this point means
3045 * something is corrupt. This isn't a
3046 * resource issue.
3047 */
3048 assert(st_setstring_status != -1);
3049 goto return_s_error;
3050 }
3051
3052 if (ld_sym_copy(sdp) == S_ERROR)
3053 goto return_s_error;
3054 sdp->sd_sym->st_value = (Word)stoff;
3055 }
3056
3057 /* Redirect the symbol to our new merged section */
3058 sdp->sd_isc = mstrsec;
3059 }
3060
3061 /*
3062 * There are no references left to the original input string sections.
3063 * Mark them as discarded so they don't go into the output image.
3064 * At the same time, add up the sizes of the replaced sections.
3065 */
3066 data_size = 0;
3067 for (APLIST_TRAVERSE(osp->os_mstrisdescs, idx, isp)) {
3068 if (isp->is_flags & (FLG_IS_DISCARD | FLG_IS_GNSTRMRG))
3069 continue;
3070
3071 data_size += isp->is_indata->d_size;
3072
3073 isp->is_flags |= FLG_IS_DISCARD;
3074 DBG_CALL(Dbg_sec_discarded(ofl->ofl_lml, isp, mstrsec));
3075 }
3076
3077 /* Report how much space we saved in the output section */
3078 DBG_CALL(Dbg_sec_genstr_compress(ofl->ofl_lml, osp->os_name, data_size,
3079 mstr_data->d_size));
3080
3081 st_destroy(mstrtab);
3082 return (1);
3083
3084 return_s_error:
3085 st_destroy(mstrtab);
3086 return (S_ERROR);
3087 }
3088
3089 /*
3090 * Update a data buffers size. A number of sections have to be created, and
3091 * the sections header contributes to the size of the eventual section. Thus,
3092 * a section may be created, and once all associated sections have been created,
3093 * we return to establish the required section size.
3094 */
3095 inline static void
3096 update_data_size(Os_desc *osp, ulong_t cnt)
3097 {
3098 Is_desc *isec = ld_os_first_isdesc(osp);
3099 Elf_Data *data = isec->is_indata;
3100 Shdr *shdr = osp->os_shdr;
3101 size_t size = cnt * shdr->sh_entsize;
3102
3103 shdr->sh_size = (Xword)size;
3104 data->d_size = size;
3105 }
3106
3107 /*
3108 * The following sections are built after all input file processing and symbol
3109 * validation has been carried out. The order is important (because the
3110 * addition of a section adds a new symbol there is a chicken and egg problem
3111 * of maintaining the appropriate counts). By maintaining a known order the
3112 * individual routines can compensate for later, known, additions.
3113 */
3114 uintptr_t
3115 ld_make_sections(Ofl_desc *ofl)
3116 {
3117 ofl_flag_t flags = ofl->ofl_flags;
3118 Sg_desc *sgp;
3119
3120 /*
3121 * Generate any special sections.
3122 */
3123 if (flags & FLG_OF_ADDVERS)
3124 if (make_comment(ofl) == S_ERROR)
3125 return (S_ERROR);
3126
3127 if (make_interp(ofl) == S_ERROR)
3128 return (S_ERROR);
3129
3130 /*
3131 * Create a capabilities section if required.
3132 */
3133 if (make_cap(ofl, SHT_SUNW_cap, MSG_ORIG(MSG_SCN_SUNWCAP),
3134 ld_targ.t_id.id_cap) == S_ERROR)
3135 return (S_ERROR);
3136
3137 /*
3138 * Create any init/fini array sections.
3139 */
3140 if (make_array(ofl, SHT_INIT_ARRAY, MSG_ORIG(MSG_SCN_INITARRAY),
3141 ofl->ofl_initarray) == S_ERROR)
3142 return (S_ERROR);
3143
3144 if (make_array(ofl, SHT_FINI_ARRAY, MSG_ORIG(MSG_SCN_FINIARRAY),
3145 ofl->ofl_finiarray) == S_ERROR)
3146 return (S_ERROR);
3147
3148 if (make_array(ofl, SHT_PREINIT_ARRAY, MSG_ORIG(MSG_SCN_PREINITARRAY),
3149 ofl->ofl_preiarray) == S_ERROR)
3150 return (S_ERROR);
3151
3152 /*
3153 * Make the .plt section. This occurs after any other relocation
3154 * sections are generated (see reloc_init()) to ensure that the
3155 * associated relocation section is after all the other relocation
3156 * sections.
3157 */
3158 if ((ofl->ofl_pltcnt) || (ofl->ofl_pltpad))
3159 if (make_plt(ofl) == S_ERROR)
3160 return (S_ERROR);
3161
3162 /*
3163 * Determine whether any sections or files are not referenced. Under
3164 * -Dunused a diagnostic for any unused components is generated, under
3165 * -zignore the component is removed from the final output.
3166 */
3167 if (DBG_ENABLED || (ofl->ofl_flags1 & FLG_OF1_IGNPRC)) {
3168 if (ignore_section_processing(ofl) == S_ERROR)
3169 return (S_ERROR);
3170 }
3171
3172 /*
3173 * If we have detected a situation in which previously placed
3174 * output sections may have been discarded, perform the necessary
3175 * readjustment.
3176 */
3177 if (ofl->ofl_flags & FLG_OF_ADJOSCNT)
3178 adjust_os_count(ofl);
3179
3180 /*
3181 * Do any of the output sections contain input sections that
3182 * are candidates for string table merging? For each such case,
3183 * we create a replacement section, insert it, and discard the
3184 * originals.
3185 *
3186 * rel_alpp and sym_alpp are used by ld_make_strmerge()
3187 * for its internal processing. We are responsible for the
3188 * initialization and cleanup, and ld_make_strmerge() handles the rest.
3189 * This allows us to reuse a single pair of memory buffers, allocated
3190 * for this processing, for all the output sections.
3191 */
3192 if ((ofl->ofl_flags1 & FLG_OF1_NCSTTAB) == 0) {
3193 int error_seen = 0;
3194 APlist *rel_alpp = NULL;
3195 APlist *sym_alpp = NULL;
3196 Aliste idx1;
3197
3198 for (APLIST_TRAVERSE(ofl->ofl_segs, idx1, sgp)) {
3199 Os_desc *osp;
3200 Aliste idx2;
3201
3202 for (APLIST_TRAVERSE(sgp->sg_osdescs, idx2, osp))
3203 if ((osp->os_mstrisdescs != NULL) &&
3204 (ld_make_strmerge(ofl, osp,
3205 &rel_alpp, &sym_alpp) ==
3206 S_ERROR)) {
3207 error_seen = 1;
3208 break;
3209 }
3210 }
3211 if (rel_alpp != NULL)
3212 libld_free(rel_alpp);
3213 if (sym_alpp != NULL)
3214 libld_free(sym_alpp);
3215 if (error_seen != 0)
3216 return (S_ERROR);
3217 }
3218
3219 /*
3220 * Add any necessary versioning information.
3221 */
3222 if (!(flags & FLG_OF_NOVERSEC)) {
3223 if ((flags & FLG_OF_VERNEED) &&
3224 (make_verneed(ofl) == S_ERROR))
3225 return (S_ERROR);
3226 if ((flags & FLG_OF_VERDEF) &&
3227 (make_verdef(ofl) == S_ERROR))
3228 return (S_ERROR);
3229 if ((flags & (FLG_OF_VERNEED | FLG_OF_VERDEF)) &&
3230 ((ofl->ofl_osversym = make_sym_sec(ofl,
3231 MSG_ORIG(MSG_SCN_SUNWVERSYM), SHT_SUNW_versym,
3232 ld_targ.t_id.id_version)) == (Os_desc*)S_ERROR))
3233 return (S_ERROR);
3234 }
3235
3236 /*
3237 * Create a syminfo section if necessary.
3238 */
3239 if (flags & FLG_OF_SYMINFO) {
3240 if ((ofl->ofl_ossyminfo = make_sym_sec(ofl,
3241 MSG_ORIG(MSG_SCN_SUNWSYMINFO), SHT_SUNW_syminfo,
3242 ld_targ.t_id.id_syminfo)) == (Os_desc *)S_ERROR)
3243 return (S_ERROR);
3244 }
3245
3246 if (flags & FLG_OF_COMREL) {
3247 /*
3248 * If -zcombreloc is enabled then all relocations (except for
3249 * the PLT's) are coalesced into a single relocation section.
3250 */
3251 if (ofl->ofl_reloccnt) {
3252 if (make_reloc(ofl, NULL) == S_ERROR)
3253 return (S_ERROR);
3254 }
3255 } else {
3256 Aliste idx1;
3257
3258 /*
3259 * Create the required output relocation sections. Note, new
3260 * sections may be added to the section list that is being
3261 * traversed. These insertions can move the elements of the
3262 * Alist such that a section descriptor is re-read. Recursion
3263 * is prevented by maintaining a previous section pointer and
3264 * insuring that this pointer isn't re-examined.
3265 */
3266 for (APLIST_TRAVERSE(ofl->ofl_segs, idx1, sgp)) {
3267 Os_desc *osp, *posp = 0;
3268 Aliste idx2;
3269
3270 for (APLIST_TRAVERSE(sgp->sg_osdescs, idx2, osp)) {
3271 if ((osp != posp) && osp->os_szoutrels &&
3272 (osp != ofl->ofl_osplt)) {
3273 if (make_reloc(ofl, osp) == S_ERROR)
3274 return (S_ERROR);
3275 }
3276 posp = osp;
3277 }
3278 }
3279
3280 /*
3281 * If we're not building a combined relocation section, then
3282 * build a .rel[a] section as required.
3283 */
3284 if (ofl->ofl_relocrelsz) {
3285 if (make_reloc(ofl, NULL) == S_ERROR)
3286 return (S_ERROR);
3287 }
3288 }
3289
3290 /*
3291 * The PLT relocations are always in their own section, and we try to
3292 * keep them at the end of the PLT table. We do this to keep the hot
3293 * "data" PLT's at the head of the table nearer the .dynsym & .hash.
3294 */
3295 if (ofl->ofl_osplt && ofl->ofl_relocpltsz) {
3296 if (make_reloc(ofl, ofl->ofl_osplt) == S_ERROR)
3297 return (S_ERROR);
3298 }
3299
3300 /*
3301 * Finally build the symbol and section header sections.
3302 */
3303 if (flags & FLG_OF_DYNAMIC) {
3304 if (make_dynamic(ofl) == S_ERROR)
3305 return (S_ERROR);
3306
3307 /*
3308 * A number of sections aren't necessary within a relocatable
3309 * object, even if -dy has been used.
3310 */
3311 if (!(flags & FLG_OF_RELOBJ)) {
3312 if (make_hash(ofl) == S_ERROR)
3313 return (S_ERROR);
3314 if (make_dynstr(ofl) == S_ERROR)
3315 return (S_ERROR);
3316 if (make_dynsym(ofl) == S_ERROR)
3317 return (S_ERROR);
3318 if (ld_unwind_make_hdr(ofl) == S_ERROR)
3319 return (S_ERROR);
3320 if (make_dynsort(ofl) == S_ERROR)
3321 return (S_ERROR);
3322 }
3323 }
3324
3325 if (!(flags & FLG_OF_STRIP) || (flags & FLG_OF_RELOBJ) ||
3326 ((flags & FLG_OF_STATIC) && ofl->ofl_osversym)) {
3327 /*
3328 * Do we need to make a SHT_SYMTAB_SHNDX section
3329 * for the dynsym. If so - do it now.
3330 */
3331 if (ofl->ofl_osdynsym &&
3332 ((ofl->ofl_shdrcnt + 3) >= SHN_LORESERVE)) {
3333 if (make_dynsym_shndx(ofl) == S_ERROR)
3334 return (S_ERROR);
3335 }
3336
3337 if (make_strtab(ofl) == S_ERROR)
3338 return (S_ERROR);
3339 if (make_symtab(ofl) == S_ERROR)
3340 return (S_ERROR);
3341 } else {
3342 /*
3343 * Do we need to make a SHT_SYMTAB_SHNDX section
3344 * for the dynsym. If so - do it now.
3345 */
3346 if (ofl->ofl_osdynsym &&
3347 ((ofl->ofl_shdrcnt + 1) >= SHN_LORESERVE)) {
3348 if (make_dynsym_shndx(ofl) == S_ERROR)
3349 return (S_ERROR);
3350 }
3351 }
3352
3353 if (make_shstrtab(ofl) == S_ERROR)
3354 return (S_ERROR);
3355
3356 /*
3357 * Now that we've created all output sections, adjust the size of the
3358 * SHT_SUNW_versym and SHT_SUNW_syminfo section, which are dependent on
3359 * the associated symbol table sizes.
3360 */
3361 if (ofl->ofl_osversym || ofl->ofl_ossyminfo) {
3362 ulong_t cnt;
3363 Is_desc *isp;
3364 Os_desc *osp;
3365
3366 if (OFL_IS_STATIC_OBJ(ofl))
3367 osp = ofl->ofl_ossymtab;
3368 else
3369 osp = ofl->ofl_osdynsym;
3370
3371 isp = ld_os_first_isdesc(osp);
3372 cnt = (isp->is_shdr->sh_size / isp->is_shdr->sh_entsize);
3373
3374 if (ofl->ofl_osversym)
3375 update_data_size(ofl->ofl_osversym, cnt);
3376
3377 if (ofl->ofl_ossyminfo)
3378 update_data_size(ofl->ofl_ossyminfo, cnt);
3379 }
3380
3381 /*
3382 * Now that we've created all output sections, adjust the size of the
3383 * SHT_SUNW_capinfo, which is dependent on the associated symbol table
3384 * size.
3385 */
3386 if (ofl->ofl_oscapinfo) {
3387 ulong_t cnt;
3388
3389 /*
3390 * Symbol capabilities symbols are placed directly after the
3391 * STT_FILE symbol, section symbols, and any register symbols.
3392 * Effectively these are the first of any series of demoted
3393 * (scoped) symbols.
3394 */
3395 if (OFL_IS_STATIC_OBJ(ofl))
3396 cnt = SYMTAB_ALL_CNT(ofl);
3397 else
3398 cnt = DYNSYM_ALL_CNT(ofl);
3399
3400 update_data_size(ofl->ofl_oscapinfo, cnt);
3401 }
3402 return (1);
3403 }
3404
3405 /*
3406 * Build an additional data section - used to back OBJT symbol definitions
3407 * added with a mapfile.
3408 */
3409 Is_desc *
3410 ld_make_data(Ofl_desc *ofl, size_t size)
3411 {
3412 Shdr *shdr;
3413 Elf_Data *data;
3414 Is_desc *isec;
3415
3416 if (new_section(ofl, SHT_PROGBITS, MSG_ORIG(MSG_SCN_DATA), 0,
3417 &isec, &shdr, &data) == S_ERROR)
3418 return ((Is_desc *)S_ERROR);
3419
3420 data->d_size = size;
3421 shdr->sh_size = (Xword)size;
3422 shdr->sh_flags |= SHF_WRITE;
3423
3424 if (aplist_append(&ofl->ofl_mapdata, isec, AL_CNT_OFL_MAPSECS) == NULL)
3425 return ((Is_desc *)S_ERROR);
3426
3427 return (isec);
3428 }
3429
3430 /*
3431 * Build an additional text section - used to back FUNC symbol definitions
3432 * added with a mapfile.
3433 */
3434 Is_desc *
3435 ld_make_text(Ofl_desc *ofl, size_t size)
3436 {
3437 Shdr *shdr;
3438 Elf_Data *data;
3439 Is_desc *isec;
3440
3441 /*
3442 * Insure the size is sufficient to contain the minimum return
3443 * instruction.
3444 */
3445 if (size < ld_targ.t_nf.nf_size)
3446 size = ld_targ.t_nf.nf_size;
3447
3448 if (new_section(ofl, SHT_PROGBITS, MSG_ORIG(MSG_SCN_TEXT), 0,
3449 &isec, &shdr, &data) == S_ERROR)
3450 return ((Is_desc *)S_ERROR);
3451
3452 data->d_size = size;
3453 shdr->sh_size = (Xword)size;
3454 shdr->sh_flags |= SHF_EXECINSTR;
3455
3456 /*
3457 * Fill the buffer with the appropriate return instruction.
3458 * Note that there is no need to swap bytes on a non-native,
3459 * link, as the data being copied is given in bytes.
3460 */
3461 if ((data->d_buf = libld_calloc(size, 1)) == NULL)
3462 return ((Is_desc *)S_ERROR);
3463 (void) memcpy(data->d_buf, ld_targ.t_nf.nf_template,
3464 ld_targ.t_nf.nf_size);
3465
3466 /*
3467 * If size was larger than required, and the target supplies
3468 * a fill function, use it to fill the balance. If there is no
3469 * fill function, we accept the 0-fill supplied by libld_calloc().
3470 */
3471 if ((ld_targ.t_ff.ff_execfill != NULL) && (size > ld_targ.t_nf.nf_size))
3472 ld_targ.t_ff.ff_execfill(data->d_buf, ld_targ.t_nf.nf_size,
3473 size - ld_targ.t_nf.nf_size);
3474
3475 if (aplist_append(&ofl->ofl_maptext, isec, AL_CNT_OFL_MAPSECS) == NULL)
3476 return ((Is_desc *)S_ERROR);
3477
3478 return (isec);
3479 }
3480
3481 void
3482 ld_comdat_validate(Ofl_desc *ofl, Ifl_desc *ifl)
3483 {
3484 int i;
3485
3486 for (i = 0; i < ifl->ifl_shnum; i++) {
3487 Is_desc *isp = ifl->ifl_isdesc[i];
3488 int types = 0;
3489 char buf[1024] = "";
3490 Group_desc *gr = NULL;
3491
3492 if ((isp == NULL) || (isp->is_flags & FLG_IS_COMDAT) == 0)
3493 continue;
3494
3495 if (isp->is_shdr->sh_type == SHT_SUNW_COMDAT) {
3496 types++;
3497 (void) strlcpy(buf, MSG_ORIG(MSG_STR_SUNW_COMDAT),
3498 sizeof (buf));
3499 }
3500
3501 if (strncmp(MSG_ORIG(MSG_SCN_GNU_LINKONCE), isp->is_name,
3502 MSG_SCN_GNU_LINKONCE_SIZE) == 0) {
3503 types++;
3504 if (types > 1)
3505 (void) strlcat(buf, ", ", sizeof (buf));
3506 (void) strlcat(buf, MSG_ORIG(MSG_SCN_GNU_LINKONCE),
3507 sizeof (buf));
3508 }
3509
3510 if ((isp->is_shdr->sh_flags & SHF_GROUP) &&
3511 ((gr = ld_get_group(ofl, isp)) != NULL) &&
3512 (gr->gd_data[0] & GRP_COMDAT)) {
3513 types++;
3514 if (types > 1)
3515 (void) strlcat(buf, ", ", sizeof (buf));
3516 (void) strlcat(buf, MSG_ORIG(MSG_STR_GROUP),
3517 sizeof (buf));
3518 }
3519
3520 if (types > 1)
3521 ld_eprintf(ofl, ERR_FATAL,
3522 MSG_INTL(MSG_SCN_MULTICOMDAT), ifl->ifl_name,
3523 EC_WORD(isp->is_scnndx), isp->is_name, buf);
3524 }
3525 }