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 if (ofl->ofl_aslr != 0) /* DT_SUNW_ASLR */
1274 cnt++;
1275 }
1276
1277 /* DT_SUNW_KMOD */
1278 if (ofl->ofl_flags & FLG_OF_KMOD)
1279 cnt++;
1280
1281 /*
1282 * Account for Architecture dependent .dynamic entries, and defaults.
1283 */
1284 (*ld_targ.t_mr.mr_mach_make_dynamic)(ofl, &cnt);
1285
1286 /*
1287 * DT_FLAGS, DT_FLAGS_1, DT_SUNW_STRPAD, and DT_NULL. Also,
1288 * allow room for the unused extra DT_NULLs. These are included
1289 * to allow an ELF editor room to add items later.
1290 */
1291 cnt += 4 + DYNAMIC_EXTRA_ELTS;
1292
1293 /*
1294 * DT_SUNW_LDMACH. Used to hold the ELF machine code of the
1295 * linker that produced the output object. This information
1296 * allows us to determine whether a given object was linked
1297 * natively, or by a linker running on a different type of
1298 * system. This information can be valuable if one suspects
1299 * that a problem might be due to alignment or byte order issues.
1300 */
1301 cnt++;
1302
1303 /*
1304 * Determine the size of the section from the number of entries.
1305 */
1306 size = cnt * (size_t)shdr->sh_entsize;
1307
1308 shdr->sh_size = (Xword)size;
1309 data->d_size = size;
1310
1311 /*
1312 * There are several tags that are specific to the Solaris osabi
1313 * range which we unconditionally put into any dynamic section
1314 * we create (e.g. DT_SUNW_STRPAD or DT_SUNW_LDMACH). As such,
1315 * any Solaris object with a dynamic section should be tagged as
1316 * ELFOSABI_SOLARIS.
1317 */
1318 ofl->ofl_flags |= FLG_OF_OSABI;
1319
1320 return ((uintptr_t)ofl->ofl_osdynamic);
1321 }
1322
1323 /*
1324 * Build the GOT section and its associated relocation entries.
1325 */
1326 uintptr_t
1327 ld_make_got(Ofl_desc *ofl)
1328 {
1329 Elf_Data *data;
1330 Shdr *shdr;
1331 Is_desc *isec;
1332 size_t size = (size_t)ofl->ofl_gotcnt * ld_targ.t_m.m_got_entsize;
1333 size_t rsize = (size_t)ofl->ofl_relocgotsz;
1334
1335 if (new_section(ofl, SHT_PROGBITS, MSG_ORIG(MSG_SCN_GOT), 0,
1336 &isec, &shdr, &data) == S_ERROR)
1337 return (S_ERROR);
1338
1339 data->d_size = size;
1340
1341 shdr->sh_flags |= SHF_WRITE;
1342 shdr->sh_size = (Xword)size;
1343 shdr->sh_entsize = ld_targ.t_m.m_got_entsize;
1344
1345 ofl->ofl_osgot = ld_place_section(ofl, isec, NULL,
1346 ld_targ.t_id.id_got, NULL);
1347 if (ofl->ofl_osgot == (Os_desc *)S_ERROR)
1348 return (S_ERROR);
1349
1350 ofl->ofl_osgot->os_szoutrels = (Xword)rsize;
1351
1352 return (1);
1353 }
1354
1355 /*
1356 * Build an interpreter section.
1357 */
1358 static uintptr_t
1359 make_interp(Ofl_desc *ofl)
1360 {
1361 Shdr *shdr;
1362 Elf_Data *data;
1363 Is_desc *isec;
1364 const char *iname = ofl->ofl_interp;
1365 size_t size;
1366
1367 /*
1368 * If -z nointerp is in effect, don't create an interpreter section.
1369 */
1370 if (ofl->ofl_flags1 & FLG_OF1_NOINTRP)
1371 return (1);
1372
1373 /*
1374 * An .interp section is always created for a dynamic executable.
1375 * A user can define the interpreter to use. This definition overrides
1376 * the default that would be recorded in an executable, and triggers
1377 * the creation of an .interp section in any other object. Presumably
1378 * the user knows what they are doing. Refer to the generic ELF ABI
1379 * section 5-4, and the ld(1) -I option.
1380 */
1381 if (((ofl->ofl_flags & (FLG_OF_DYNAMIC | FLG_OF_EXEC |
1382 FLG_OF_RELOBJ)) != (FLG_OF_DYNAMIC | FLG_OF_EXEC)) && !iname)
1383 return (1);
1384
1385 /*
1386 * In the case of a dynamic executable, supply a default interpreter
1387 * if the user has not specified their own.
1388 */
1389 if (iname == NULL)
1390 iname = ofl->ofl_interp = ld_targ.t_m.m_def_interp;
1391
1392 size = strlen(iname) + 1;
1393
1394 if (new_section(ofl, SHT_PROGBITS, MSG_ORIG(MSG_SCN_INTERP), 0,
1395 &isec, &shdr, &data) == S_ERROR)
1396 return (S_ERROR);
1397
1398 data->d_size = size;
1399 shdr->sh_size = (Xword)size;
1400 data->d_align = shdr->sh_addralign = 1;
1401
1402 ofl->ofl_osinterp =
1403 ld_place_section(ofl, isec, NULL, ld_targ.t_id.id_interp, NULL);
1404 return ((uintptr_t)ofl->ofl_osinterp);
1405 }
1406
1407 /*
1408 * Common function used to build the SHT_SUNW_versym section, SHT_SUNW_syminfo
1409 * section, and SHT_SUNW_capinfo section. Each of these sections provide
1410 * additional symbol information, and their size parallels the associated
1411 * symbol table.
1412 */
1413 static Os_desc *
1414 make_sym_sec(Ofl_desc *ofl, const char *sectname, Word stype, int ident)
1415 {
1416 Shdr *shdr;
1417 Elf_Data *data;
1418 Is_desc *isec;
1419
1420 /*
1421 * We don't know the size of this section yet, so set it to 0. The
1422 * size gets filled in after the associated symbol table is sized.
1423 */
1424 if (new_section(ofl, stype, sectname, 0, &isec, &shdr, &data) ==
1425 S_ERROR)
1426 return ((Os_desc *)S_ERROR);
1427
1428 return (ld_place_section(ofl, isec, NULL, ident, NULL));
1429 }
1430
1431 /*
1432 * Determine whether a symbol capability is redundant because the object
1433 * capabilities are more restrictive.
1434 */
1435 inline static int
1436 is_cap_redundant(Objcapset *ocapset, Objcapset *scapset)
1437 {
1438 Alist *oalp, *salp;
1439 elfcap_mask_t omsk, smsk;
1440
1441 /*
1442 * Inspect any platform capabilities. If the object defines platform
1443 * capabilities, then the object will only be loaded for those
1444 * platforms. A symbol capability set that doesn't define the same
1445 * platforms is redundant, and a symbol capability that does not provide
1446 * at least one platform name that matches a platform name in the object
1447 * capabilities will never execute (as the object wouldn't have been
1448 * loaded).
1449 */
1450 oalp = ocapset->oc_plat.cl_val;
1451 salp = scapset->oc_plat.cl_val;
1452 if (oalp && ((salp == NULL) || cap_names_match(oalp, salp)))
1453 return (1);
1454
1455 /*
1456 * If the symbol capability set defines platforms, and the object
1457 * doesn't, then the symbol set is more restrictive.
1458 */
1459 if (salp && (oalp == NULL))
1460 return (0);
1461
1462 /*
1463 * Next, inspect any machine name capabilities. If the object defines
1464 * machine name capabilities, then the object will only be loaded for
1465 * those machines. A symbol capability set that doesn't define the same
1466 * machine names is redundant, and a symbol capability that does not
1467 * provide at least one machine name that matches a machine name in the
1468 * object capabilities will never execute (as the object wouldn't have
1469 * been loaded).
1470 */
1471 oalp = ocapset->oc_plat.cl_val;
1472 salp = scapset->oc_plat.cl_val;
1473 if (oalp && ((salp == NULL) || cap_names_match(oalp, salp)))
1474 return (1);
1475
1476 /*
1477 * If the symbol capability set defines machine names, and the object
1478 * doesn't, then the symbol set is more restrictive.
1479 */
1480 if (salp && (oalp == NULL))
1481 return (0);
1482
1483 /*
1484 * Next, inspect any hardware capabilities. If the objects hardware
1485 * capabilities are greater than or equal to that of the symbols
1486 * capabilities, then the symbol capability set is redundant. If the
1487 * symbols hardware capabilities are greater that the objects, then the
1488 * symbol set is more restrictive.
1489 *
1490 * Note that this is a somewhat arbitrary definition, as each capability
1491 * bit is independent of the others, and some of the higher order bits
1492 * could be considered to be less important than lower ones. However,
1493 * this is the only reasonable non-subjective definition.
1494 */
1495 omsk = ocapset->oc_hw_2.cm_val;
1496 smsk = scapset->oc_hw_2.cm_val;
1497 if ((omsk > smsk) || (omsk && (omsk == smsk)))
1498 return (1);
1499 if (omsk < smsk)
1500 return (0);
1501
1502 /*
1503 * Finally, inspect the remaining hardware capabilities.
1504 */
1505 omsk = ocapset->oc_hw_1.cm_val;
1506 smsk = scapset->oc_hw_1.cm_val;
1507 if ((omsk > smsk) || (omsk && (omsk == smsk)))
1508 return (1);
1509
1510 return (0);
1511 }
1512
1513 /*
1514 * Capabilities values might have been assigned excluded values. These
1515 * excluded values should be removed before calculating any capabilities
1516 * sections size.
1517 */
1518 static void
1519 capmask_value(Lm_list *lml, Word type, Capmask *capmask, int *title)
1520 {
1521 /*
1522 * First determine whether any bits should be excluded.
1523 */
1524 if ((capmask->cm_val & capmask->cm_exc) == 0)
1525 return;
1526
1527 DBG_CALL(Dbg_cap_post_title(lml, title));
1528
1529 DBG_CALL(Dbg_cap_val_entry(lml, DBG_STATE_CURRENT, type,
1530 capmask->cm_val, ld_targ.t_m.m_mach));
1531 DBG_CALL(Dbg_cap_val_entry(lml, DBG_STATE_EXCLUDE, type,
1532 capmask->cm_exc, ld_targ.t_m.m_mach));
1533
1534 capmask->cm_val &= ~capmask->cm_exc;
1535
1536 DBG_CALL(Dbg_cap_val_entry(lml, DBG_STATE_RESOLVED, type,
1537 capmask->cm_val, ld_targ.t_m.m_mach));
1538 }
1539
1540 static void
1541 capstr_value(Lm_list *lml, Word type, Caplist *caplist, int *title)
1542 {
1543 Aliste idx1, idx2;
1544 char *estr;
1545 Capstr *capstr;
1546 Boolean found = FALSE;
1547
1548 /*
1549 * First determine whether any strings should be excluded.
1550 */
1551 for (APLIST_TRAVERSE(caplist->cl_exc, idx1, estr)) {
1552 for (ALIST_TRAVERSE(caplist->cl_val, idx2, capstr)) {
1553 if (strcmp(estr, capstr->cs_str) == 0) {
1554 found = TRUE;
1555 break;
1556 }
1557 }
1558 }
1559
1560 if (found == FALSE)
1561 return;
1562
1563 /*
1564 * Traverse the current strings, then delete the excluded strings,
1565 * and finally display the resolved strings.
1566 */
1567 if (DBG_ENABLED) {
1568 Dbg_cap_post_title(lml, title);
1569 for (ALIST_TRAVERSE(caplist->cl_val, idx2, capstr)) {
1570 Dbg_cap_ptr_entry(lml, DBG_STATE_CURRENT, type,
1571 capstr->cs_str);
1572 }
1573 }
1574 for (APLIST_TRAVERSE(caplist->cl_exc, idx1, estr)) {
1575 for (ALIST_TRAVERSE(caplist->cl_val, idx2, capstr)) {
1576 if (strcmp(estr, capstr->cs_str) == 0) {
1577 DBG_CALL(Dbg_cap_ptr_entry(lml,
1578 DBG_STATE_EXCLUDE, type, capstr->cs_str));
1579 alist_delete(caplist->cl_val, &idx2);
1580 break;
1581 }
1582 }
1583 }
1584 if (DBG_ENABLED) {
1585 for (ALIST_TRAVERSE(caplist->cl_val, idx2, capstr)) {
1586 Dbg_cap_ptr_entry(lml, DBG_STATE_RESOLVED, type,
1587 capstr->cs_str);
1588 }
1589 }
1590 }
1591
1592 /*
1593 * Build a capabilities section.
1594 */
1595 #define CAP_UPDATE(cap, capndx, tag, val) \
1596 cap->c_tag = tag; \
1597 cap->c_un.c_val = val; \
1598 cap++, capndx++;
1599
1600 static uintptr_t
1601 make_cap(Ofl_desc *ofl, Word shtype, const char *shname, int ident)
1602 {
1603 Shdr *shdr;
1604 Elf_Data *data;
1605 Is_desc *isec;
1606 Cap *cap;
1607 size_t size = 0;
1608 Word capndx = 0;
1609 Str_tbl *strtbl;
1610 Objcapset *ocapset = &ofl->ofl_ocapset;
1611 Aliste idx1;
1612 Capstr *capstr;
1613 int title = 0;
1614
1615 /*
1616 * Determine which string table to use for any CA_SUNW_MACH,
1617 * CA_SUNW_PLAT, or CA_SUNW_ID strings.
1618 */
1619 if (OFL_IS_STATIC_OBJ(ofl))
1620 strtbl = ofl->ofl_strtab;
1621 else
1622 strtbl = ofl->ofl_dynstrtab;
1623
1624 /*
1625 * If symbol capabilities have been requested, but none have been
1626 * created, warn the user. This scenario can occur if none of the
1627 * input relocatable objects defined any object capabilities.
1628 */
1629 if ((ofl->ofl_flags & FLG_OF_OTOSCAP) && (ofl->ofl_capsymcnt == 0))
1630 ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_CAP_NOSYMSFOUND));
1631
1632 /*
1633 * If symbol capabilities have been collected, but no symbols are left
1634 * referencing these capabilities, promote the capability groups back
1635 * to an object capability definition.
1636 */
1637 if ((ofl->ofl_flags & FLG_OF_OTOSCAP) && ofl->ofl_capsymcnt &&
1638 (ofl->ofl_capfamilies == NULL)) {
1639 ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_CAP_NOSYMSFOUND));
1640 ld_cap_move_symtoobj(ofl);
1641 ofl->ofl_capsymcnt = 0;
1642 ofl->ofl_capgroups = NULL;
1643 ofl->ofl_flags &= ~FLG_OF_OTOSCAP;
1644 }
1645
1646 /*
1647 * Remove any excluded capabilities.
1648 */
1649 capstr_value(ofl->ofl_lml, CA_SUNW_PLAT, &ocapset->oc_plat, &title);
1650 capstr_value(ofl->ofl_lml, CA_SUNW_MACH, &ocapset->oc_mach, &title);
1651 capmask_value(ofl->ofl_lml, CA_SUNW_HW_2, &ocapset->oc_hw_2, &title);
1652 capmask_value(ofl->ofl_lml, CA_SUNW_HW_1, &ocapset->oc_hw_1, &title);
1653 capmask_value(ofl->ofl_lml, CA_SUNW_SF_1, &ocapset->oc_sf_1, &title);
1654
1655 /*
1656 * Determine how many entries are required for any object capabilities.
1657 */
1658 size += alist_nitems(ocapset->oc_plat.cl_val);
1659 size += alist_nitems(ocapset->oc_mach.cl_val);
1660 if (ocapset->oc_hw_2.cm_val)
1661 size++;
1662 if (ocapset->oc_hw_1.cm_val)
1663 size++;
1664 if (ocapset->oc_sf_1.cm_val)
1665 size++;
1666
1667 /*
1668 * Only identify a capabilities group if the group has content. If a
1669 * capabilities identifier exists, and no other capabilities have been
1670 * supplied, remove the identifier. This scenario could exist if a
1671 * user mistakenly defined a lone identifier, or if an identified group
1672 * was overridden so as to clear the existing capabilities and the
1673 * identifier was not also cleared.
1674 */
1675 if (ocapset->oc_id.cs_str) {
1676 if (size)
1677 size++;
1678 else
1679 ocapset->oc_id.cs_str = NULL;
1680 }
1681 if (size)
1682 size++; /* Add CA_SUNW_NULL */
1683
1684 /*
1685 * Determine how many entries are required for any symbol capabilities.
1686 */
1687 if (ofl->ofl_capsymcnt) {
1688 /*
1689 * If there are no object capabilities, a CA_SUNW_NULL entry
1690 * is required before any symbol capabilities.
1691 */
1692 if (size == 0)
1693 size++;
1694 size += ofl->ofl_capsymcnt;
1695 }
1696
1697 if (size == 0)
1698 return (NULL);
1699
1700 if (new_section(ofl, shtype, shname, size, &isec,
1701 &shdr, &data) == S_ERROR)
1702 return (S_ERROR);
1703
1704 if ((data->d_buf = libld_malloc(shdr->sh_size)) == NULL)
1705 return (S_ERROR);
1706
1707 cap = (Cap *)data->d_buf;
1708
1709 /*
1710 * Fill in any object capabilities. If there is an identifier, then the
1711 * identifier comes first. The remaining items follow in precedence
1712 * order, although the order isn't important for runtime verification.
1713 */
1714 if (ocapset->oc_id.cs_str) {
1715 ofl->ofl_flags |= FLG_OF_CAPSTRS;
1716 if (st_insert(strtbl, ocapset->oc_id.cs_str) == -1)
1717 return (S_ERROR);
1718 ocapset->oc_id.cs_ndx = capndx;
1719 CAP_UPDATE(cap, capndx, CA_SUNW_ID, 0);
1720 }
1721 if (ocapset->oc_plat.cl_val) {
1722 ofl->ofl_flags |= (FLG_OF_PTCAP | FLG_OF_CAPSTRS);
1723
1724 /*
1725 * Insert any platform name strings in the appropriate string
1726 * table. The capability value can't be filled in yet, as the
1727 * final offset of the strings isn't known until later.
1728 */
1729 for (ALIST_TRAVERSE(ocapset->oc_plat.cl_val, idx1, capstr)) {
1730 if (st_insert(strtbl, capstr->cs_str) == -1)
1731 return (S_ERROR);
1732 capstr->cs_ndx = capndx;
1733 CAP_UPDATE(cap, capndx, CA_SUNW_PLAT, 0);
1734 }
1735 }
1736 if (ocapset->oc_mach.cl_val) {
1737 ofl->ofl_flags |= (FLG_OF_PTCAP | FLG_OF_CAPSTRS);
1738
1739 /*
1740 * Insert the machine name strings in the appropriate string
1741 * table. The capability value can't be filled in yet, as the
1742 * final offset of the strings isn't known until later.
1743 */
1744 for (ALIST_TRAVERSE(ocapset->oc_mach.cl_val, idx1, capstr)) {
1745 if (st_insert(strtbl, capstr->cs_str) == -1)
1746 return (S_ERROR);
1747 capstr->cs_ndx = capndx;
1748 CAP_UPDATE(cap, capndx, CA_SUNW_MACH, 0);
1749 }
1750 }
1751 if (ocapset->oc_hw_2.cm_val) {
1752 ofl->ofl_flags |= FLG_OF_PTCAP;
1753 CAP_UPDATE(cap, capndx, CA_SUNW_HW_2, ocapset->oc_hw_2.cm_val);
1754 }
1755 if (ocapset->oc_hw_1.cm_val) {
1756 ofl->ofl_flags |= FLG_OF_PTCAP;
1757 CAP_UPDATE(cap, capndx, CA_SUNW_HW_1, ocapset->oc_hw_1.cm_val);
1758 }
1759 if (ocapset->oc_sf_1.cm_val) {
1760 ofl->ofl_flags |= FLG_OF_PTCAP;
1761 CAP_UPDATE(cap, capndx, CA_SUNW_SF_1, ocapset->oc_sf_1.cm_val);
1762 }
1763 CAP_UPDATE(cap, capndx, CA_SUNW_NULL, 0);
1764
1765 /*
1766 * Fill in any symbol capabilities.
1767 */
1768 if (ofl->ofl_capgroups) {
1769 Cap_group *cgp;
1770
1771 for (APLIST_TRAVERSE(ofl->ofl_capgroups, idx1, cgp)) {
1772 Objcapset *scapset = &cgp->cg_set;
1773 Aliste idx2;
1774 Is_desc *isp;
1775
1776 cgp->cg_ndx = capndx;
1777
1778 if (scapset->oc_id.cs_str) {
1779 ofl->ofl_flags |= FLG_OF_CAPSTRS;
1780 /*
1781 * Insert the identifier string in the
1782 * appropriate string table. The capability
1783 * value can't be filled in yet, as the final
1784 * offset of the string isn't known until later.
1785 */
1786 if (st_insert(strtbl,
1787 scapset->oc_id.cs_str) == -1)
1788 return (S_ERROR);
1789 scapset->oc_id.cs_ndx = capndx;
1790 CAP_UPDATE(cap, capndx, CA_SUNW_ID, 0);
1791 }
1792
1793 if (scapset->oc_plat.cl_val) {
1794 ofl->ofl_flags |= FLG_OF_CAPSTRS;
1795
1796 /*
1797 * Insert the platform name string in the
1798 * appropriate string table. The capability
1799 * value can't be filled in yet, as the final
1800 * offset of the string isn't known until later.
1801 */
1802 for (ALIST_TRAVERSE(scapset->oc_plat.cl_val,
1803 idx2, capstr)) {
1804 if (st_insert(strtbl,
1805 capstr->cs_str) == -1)
1806 return (S_ERROR);
1807 capstr->cs_ndx = capndx;
1808 CAP_UPDATE(cap, capndx,
1809 CA_SUNW_PLAT, 0);
1810 }
1811 }
1812 if (scapset->oc_mach.cl_val) {
1813 ofl->ofl_flags |= FLG_OF_CAPSTRS;
1814
1815 /*
1816 * Insert the machine name string in the
1817 * appropriate string table. The capability
1818 * value can't be filled in yet, as the final
1819 * offset of the string isn't known until later.
1820 */
1821 for (ALIST_TRAVERSE(scapset->oc_mach.cl_val,
1822 idx2, capstr)) {
1823 if (st_insert(strtbl,
1824 capstr->cs_str) == -1)
1825 return (S_ERROR);
1826 capstr->cs_ndx = capndx;
1827 CAP_UPDATE(cap, capndx,
1828 CA_SUNW_MACH, 0);
1829 }
1830 }
1831 if (scapset->oc_hw_2.cm_val) {
1832 CAP_UPDATE(cap, capndx, CA_SUNW_HW_2,
1833 scapset->oc_hw_2.cm_val);
1834 }
1835 if (scapset->oc_hw_1.cm_val) {
1836 CAP_UPDATE(cap, capndx, CA_SUNW_HW_1,
1837 scapset->oc_hw_1.cm_val);
1838 }
1839 if (scapset->oc_sf_1.cm_val) {
1840 CAP_UPDATE(cap, capndx, CA_SUNW_SF_1,
1841 scapset->oc_sf_1.cm_val);
1842 }
1843 CAP_UPDATE(cap, capndx, CA_SUNW_NULL, 0);
1844
1845 /*
1846 * If any object capabilities are available, determine
1847 * whether these symbol capabilities are less
1848 * restrictive, and hence redundant.
1849 */
1850 if (((ofl->ofl_flags & FLG_OF_PTCAP) == 0) ||
1851 (is_cap_redundant(ocapset, scapset) == 0))
1852 continue;
1853
1854 /*
1855 * Indicate any files that provide redundant symbol
1856 * capabilities.
1857 */
1858 for (APLIST_TRAVERSE(cgp->cg_secs, idx2, isp)) {
1859 ld_eprintf(ofl, ERR_WARNING,
1860 MSG_INTL(MSG_CAP_REDUNDANT),
1861 isp->is_file->ifl_name,
1862 EC_WORD(isp->is_scnndx), isp->is_name);
1863 }
1864 }
1865 }
1866
1867 /*
1868 * If capabilities strings are required, the sh_info field of the
1869 * section header will be set to the associated string table.
1870 */
1871 if (ofl->ofl_flags & FLG_OF_CAPSTRS)
1872 shdr->sh_flags |= SHF_INFO_LINK;
1873
1874 /*
1875 * Place these capabilities in the output file.
1876 */
1877 if ((ofl->ofl_oscap = ld_place_section(ofl, isec,
1878 NULL, ident, NULL)) == (Os_desc *)S_ERROR)
1879 return (S_ERROR);
1880
1881 /*
1882 * If symbol capabilities are required, then a .SUNW_capinfo section is
1883 * also created. This table will eventually be sized to match the
1884 * associated symbol table.
1885 */
1886 if (ofl->ofl_capfamilies) {
1887 if ((ofl->ofl_oscapinfo = make_sym_sec(ofl,
1888 MSG_ORIG(MSG_SCN_SUNWCAPINFO), SHT_SUNW_capinfo,
1889 ld_targ.t_id.id_capinfo)) == (Os_desc *)S_ERROR)
1890 return (S_ERROR);
1891
1892 /*
1893 * If we're generating a dynamic object, capabilities family
1894 * members are maintained in a .SUNW_capchain section.
1895 */
1896 if (ofl->ofl_capchaincnt &&
1897 ((ofl->ofl_flags & FLG_OF_RELOBJ) == 0)) {
1898 if (new_section(ofl, SHT_SUNW_capchain,
1899 MSG_ORIG(MSG_SCN_SUNWCAPCHAIN),
1900 ofl->ofl_capchaincnt, &isec, &shdr,
1901 &data) == S_ERROR)
1902 return (S_ERROR);
1903
1904 ofl->ofl_oscapchain = ld_place_section(ofl, isec,
1905 NULL, ld_targ.t_id.id_capchain, NULL);
1906 if (ofl->ofl_oscapchain == (Os_desc *)S_ERROR)
1907 return (S_ERROR);
1908
1909 }
1910 }
1911 return (1);
1912 }
1913 #undef CAP_UPDATE
1914
1915 /*
1916 * Build the PLT section and its associated relocation entries.
1917 */
1918 static uintptr_t
1919 make_plt(Ofl_desc *ofl)
1920 {
1921 Shdr *shdr;
1922 Elf_Data *data;
1923 Is_desc *isec;
1924 size_t size = ld_targ.t_m.m_plt_reservsz +
1925 (((size_t)ofl->ofl_pltcnt + (size_t)ofl->ofl_pltpad) *
1926 ld_targ.t_m.m_plt_entsize);
1927 size_t rsize = (size_t)ofl->ofl_relocpltsz;
1928
1929 /*
1930 * On sparc, account for the NOP at the end of the plt.
1931 */
1932 if (ld_targ.t_m.m_mach == LD_TARG_BYCLASS(EM_SPARC, EM_SPARCV9))
1933 size += sizeof (Word);
1934
1935 if (new_section(ofl, SHT_PROGBITS, MSG_ORIG(MSG_SCN_PLT), 0,
1936 &isec, &shdr, &data) == S_ERROR)
1937 return (S_ERROR);
1938
1939 data->d_size = size;
1940 data->d_align = ld_targ.t_m.m_plt_align;
1941
1942 shdr->sh_flags = ld_targ.t_m.m_plt_shf_flags;
1943 shdr->sh_size = (Xword)size;
1944 shdr->sh_addralign = ld_targ.t_m.m_plt_align;
1945 shdr->sh_entsize = ld_targ.t_m.m_plt_entsize;
1946
1947 ofl->ofl_osplt = ld_place_section(ofl, isec, NULL,
1948 ld_targ.t_id.id_plt, NULL);
1949 if (ofl->ofl_osplt == (Os_desc *)S_ERROR)
1950 return (S_ERROR);
1951
1952 ofl->ofl_osplt->os_szoutrels = (Xword)rsize;
1953
1954 return (1);
1955 }
1956
1957 /*
1958 * Make the hash table. Only built for dynamic executables and shared
1959 * libraries, and provides hashed lookup into the global symbol table
1960 * (.dynsym) for the run-time linker to resolve symbol lookups.
1961 */
1962 static uintptr_t
1963 make_hash(Ofl_desc *ofl)
1964 {
1965 Shdr *shdr;
1966 Elf_Data *data;
1967 Is_desc *isec;
1968 size_t size;
1969 Word nsyms = ofl->ofl_globcnt;
1970 size_t cnt;
1971
1972 /*
1973 * Allocate section header structures. We set entcnt to 0
1974 * because it's going to change after we place this section.
1975 */
1976 if (new_section(ofl, SHT_HASH, MSG_ORIG(MSG_SCN_HASH), 0,
1977 &isec, &shdr, &data) == S_ERROR)
1978 return (S_ERROR);
1979
1980 /*
1981 * Place the section first since it will affect the local symbol
1982 * count.
1983 */
1984 ofl->ofl_oshash =
1985 ld_place_section(ofl, isec, NULL, ld_targ.t_id.id_hash, NULL);
1986 if (ofl->ofl_oshash == (Os_desc *)S_ERROR)
1987 return (S_ERROR);
1988
1989 /*
1990 * Calculate the number of output hash buckets.
1991 */
1992 ofl->ofl_hashbkts = findprime(nsyms);
1993
1994 /*
1995 * The size of the hash table is determined by
1996 *
1997 * i. the initial nbucket and nchain entries (2)
1998 * ii. the number of buckets (calculated above)
1999 * iii. the number of chains (this is based on the number of
2000 * symbols in the .dynsym array).
2001 */
2002 cnt = 2 + ofl->ofl_hashbkts + DYNSYM_ALL_CNT(ofl);
2003 size = cnt * shdr->sh_entsize;
2004
2005 /*
2006 * Finalize the section header and data buffer initialization.
2007 */
2008 if ((data->d_buf = libld_calloc(size, 1)) == NULL)
2009 return (S_ERROR);
2010 data->d_size = size;
2011 shdr->sh_size = (Xword)size;
2012
2013 return (1);
2014 }
2015
2016 /*
2017 * Generate the standard symbol table. Contains all locals and globals,
2018 * and resides in a non-allocatable section (ie. it can be stripped).
2019 */
2020 static uintptr_t
2021 make_symtab(Ofl_desc *ofl)
2022 {
2023 Shdr *shdr;
2024 Elf_Data *data;
2025 Is_desc *isec;
2026 Is_desc *xisec = 0;
2027 size_t size;
2028 Word symcnt;
2029
2030 /*
2031 * Create the section headers. Note that we supply an ent_cnt
2032 * of 0. We won't know the count until the section has been placed.
2033 */
2034 if (new_section(ofl, SHT_SYMTAB, MSG_ORIG(MSG_SCN_SYMTAB), 0,
2035 &isec, &shdr, &data) == S_ERROR)
2036 return (S_ERROR);
2037
2038 /*
2039 * Place the section first since it will affect the local symbol
2040 * count.
2041 */
2042 if ((ofl->ofl_ossymtab = ld_place_section(ofl, isec, NULL,
2043 ld_targ.t_id.id_symtab, NULL)) == (Os_desc *)S_ERROR)
2044 return (S_ERROR);
2045
2046 /*
2047 * At this point we've created all but the 'shstrtab' section.
2048 * Determine if we have to use 'Extended Sections'. If so - then
2049 * also create a SHT_SYMTAB_SHNDX section.
2050 */
2051 if ((ofl->ofl_shdrcnt + 1) >= SHN_LORESERVE) {
2052 Shdr *xshdr;
2053 Elf_Data *xdata;
2054
2055 if (new_section(ofl, SHT_SYMTAB_SHNDX,
2056 MSG_ORIG(MSG_SCN_SYMTAB_SHNDX), 0, &xisec,
2057 &xshdr, &xdata) == S_ERROR)
2058 return (S_ERROR);
2059
2060 if ((ofl->ofl_ossymshndx = ld_place_section(ofl, xisec, NULL,
2061 ld_targ.t_id.id_symtab_ndx, NULL)) == (Os_desc *)S_ERROR)
2062 return (S_ERROR);
2063 }
2064
2065 /*
2066 * Calculated number of symbols, which need to be augmented by
2067 * the (yet to be created) .shstrtab entry.
2068 */
2069 symcnt = (size_t)(1 + SYMTAB_ALL_CNT(ofl));
2070 size = symcnt * shdr->sh_entsize;
2071
2072 /*
2073 * Finalize the section header and data buffer initialization.
2074 */
2075 data->d_size = size;
2076 shdr->sh_size = (Xword)size;
2077
2078 /*
2079 * If we created a SHT_SYMTAB_SHNDX - then set it's sizes too.
2080 */
2081 if (xisec) {
2082 size_t xsize = symcnt * sizeof (Word);
2083
2084 xisec->is_indata->d_size = xsize;
2085 xisec->is_shdr->sh_size = (Xword)xsize;
2086 }
2087
2088 return (1);
2089 }
2090
2091 /*
2092 * Build a dynamic symbol table. These tables reside in the text
2093 * segment of a dynamic executable or shared library.
2094 *
2095 * .SUNW_ldynsym contains local function symbols
2096 * .dynsym contains only globals symbols
2097 *
2098 * The two tables are created adjacent to each other, with .SUNW_ldynsym
2099 * coming first.
2100 */
2101 static uintptr_t
2102 make_dynsym(Ofl_desc *ofl)
2103 {
2104 Shdr *shdr, *lshdr;
2105 Elf_Data *data, *ldata;
2106 Is_desc *isec, *lisec;
2107 size_t size;
2108 Xword cnt;
2109 int allow_ldynsym;
2110
2111 /*
2112 * Unless explicitly disabled, always produce a .SUNW_ldynsym section
2113 * when it is allowed by the file type, even if the resulting
2114 * table only ends up with a single STT_FILE in it. There are
2115 * two reasons: (1) It causes the generation of the DT_SUNW_SYMTAB
2116 * entry in the .dynamic section, which is something we would
2117 * like to encourage, and (2) Without it, we cannot generate
2118 * the associated .SUNW_dyn[sym|tls]sort sections, which are of
2119 * value to DTrace.
2120 *
2121 * In practice, it is extremely rare for an object not to have
2122 * local symbols for .SUNW_ldynsym, so 99% of the time, we'd be
2123 * doing it anyway.
2124 */
2125 allow_ldynsym = OFL_ALLOW_LDYNSYM(ofl);
2126
2127 /*
2128 * Create the section headers. Note that we supply an ent_cnt
2129 * of 0. We won't know the count until the section has been placed.
2130 */
2131 if (allow_ldynsym && new_section(ofl, SHT_SUNW_LDYNSYM,
2132 MSG_ORIG(MSG_SCN_LDYNSYM), 0, &lisec, &lshdr, &ldata) == S_ERROR)
2133 return (S_ERROR);
2134
2135 if (new_section(ofl, SHT_DYNSYM, MSG_ORIG(MSG_SCN_DYNSYM), 0,
2136 &isec, &shdr, &data) == S_ERROR)
2137 return (S_ERROR);
2138
2139 /*
2140 * Place the section(s) first since it will affect the local symbol
2141 * count.
2142 */
2143 if (allow_ldynsym &&
2144 ((ofl->ofl_osldynsym = ld_place_section(ofl, lisec, NULL,
2145 ld_targ.t_id.id_ldynsym, NULL)) == (Os_desc *)S_ERROR))
2146 return (S_ERROR);
2147 ofl->ofl_osdynsym =
2148 ld_place_section(ofl, isec, NULL, ld_targ.t_id.id_dynsym, NULL);
2149 if (ofl->ofl_osdynsym == (Os_desc *)S_ERROR)
2150 return (S_ERROR);
2151
2152 cnt = DYNSYM_ALL_CNT(ofl);
2153 size = (size_t)cnt * shdr->sh_entsize;
2154
2155 /*
2156 * Finalize the section header and data buffer initialization.
2157 */
2158 data->d_size = size;
2159 shdr->sh_size = (Xword)size;
2160
2161 /*
2162 * An ldynsym contains local function symbols. It is not
2163 * used for linking, but if present, serves to allow better
2164 * stack traces to be generated in contexts where the symtab
2165 * is not available. (dladdr(), or stripped executable/library files).
2166 */
2167 if (allow_ldynsym) {
2168 cnt = 1 + ofl->ofl_dynlocscnt + ofl->ofl_dynscopecnt;
2169 size = (size_t)cnt * shdr->sh_entsize;
2170
2171 ldata->d_size = size;
2172 lshdr->sh_size = (Xword)size;
2173 }
2174
2175 return (1);
2176 }
2177
2178 /*
2179 * Build .SUNW_dynsymsort and/or .SUNW_dyntlssort sections. These are
2180 * index sections for the .SUNW_ldynsym/.dynsym pair that present data
2181 * and function symbols sorted by address.
2182 */
2183 static uintptr_t
2184 make_dynsort(Ofl_desc *ofl)
2185 {
2186 Shdr *shdr;
2187 Elf_Data *data;
2188 Is_desc *isec;
2189
2190 /* Only do it if the .SUNW_ldynsym section is present */
2191 if (!OFL_ALLOW_LDYNSYM(ofl))
2192 return (1);
2193
2194 /* .SUNW_dynsymsort */
2195 if (ofl->ofl_dynsymsortcnt > 0) {
2196 if (new_section(ofl, SHT_SUNW_symsort,
2197 MSG_ORIG(MSG_SCN_DYNSYMSORT), ofl->ofl_dynsymsortcnt,
2198 &isec, &shdr, &data) == S_ERROR)
2199 return (S_ERROR);
2200
2201 if ((ofl->ofl_osdynsymsort = ld_place_section(ofl, isec, NULL,
2202 ld_targ.t_id.id_dynsort, NULL)) == (Os_desc *)S_ERROR)
2203 return (S_ERROR);
2204 }
2205
2206 /* .SUNW_dyntlssort */
2207 if (ofl->ofl_dyntlssortcnt > 0) {
2208 if (new_section(ofl, SHT_SUNW_tlssort,
2209 MSG_ORIG(MSG_SCN_DYNTLSSORT),
2210 ofl->ofl_dyntlssortcnt, &isec, &shdr, &data) == S_ERROR)
2211 return (S_ERROR);
2212
2213 if ((ofl->ofl_osdyntlssort = ld_place_section(ofl, isec, NULL,
2214 ld_targ.t_id.id_dynsort, NULL)) == (Os_desc *)S_ERROR)
2215 return (S_ERROR);
2216 }
2217
2218 return (1);
2219 }
2220
2221 /*
2222 * Helper routine for make_dynsym_shndx. Builds a
2223 * a SHT_SYMTAB_SHNDX for .dynsym or .SUNW_ldynsym, without knowing
2224 * which one it is.
2225 */
2226 static uintptr_t
2227 make_dyn_shndx(Ofl_desc *ofl, const char *shname, Os_desc *symtab,
2228 Os_desc **ret_os)
2229 {
2230 Is_desc *isec;
2231 Is_desc *dynsymisp;
2232 Shdr *shdr, *dynshdr;
2233 Elf_Data *data;
2234
2235 dynsymisp = ld_os_first_isdesc(symtab);
2236 dynshdr = dynsymisp->is_shdr;
2237
2238 if (new_section(ofl, SHT_SYMTAB_SHNDX, shname,
2239 (dynshdr->sh_size / dynshdr->sh_entsize),
2240 &isec, &shdr, &data) == S_ERROR)
2241 return (S_ERROR);
2242
2243 if ((*ret_os = ld_place_section(ofl, isec, NULL,
2244 ld_targ.t_id.id_dynsym_ndx, NULL)) == (Os_desc *)S_ERROR)
2245 return (S_ERROR);
2246
2247 assert(*ret_os);
2248
2249 return (1);
2250 }
2251
2252 /*
2253 * Build a SHT_SYMTAB_SHNDX for the .dynsym, and .SUNW_ldynsym
2254 */
2255 static uintptr_t
2256 make_dynsym_shndx(Ofl_desc *ofl)
2257 {
2258 /*
2259 * If there is a .SUNW_ldynsym, generate a section for its extended
2260 * index section as well.
2261 */
2262 if (OFL_ALLOW_LDYNSYM(ofl)) {
2263 if (make_dyn_shndx(ofl, MSG_ORIG(MSG_SCN_LDYNSYM_SHNDX),
2264 ofl->ofl_osldynsym, &ofl->ofl_osldynshndx) == S_ERROR)
2265 return (S_ERROR);
2266 }
2267
2268 /* The Generate a section for the dynsym */
2269 if (make_dyn_shndx(ofl, MSG_ORIG(MSG_SCN_DYNSYM_SHNDX),
2270 ofl->ofl_osdynsym, &ofl->ofl_osdynshndx) == S_ERROR)
2271 return (S_ERROR);
2272
2273 return (1);
2274 }
2275
2276
2277 /*
2278 * Build a string table for the section headers.
2279 */
2280 static uintptr_t
2281 make_shstrtab(Ofl_desc *ofl)
2282 {
2283 Shdr *shdr;
2284 Elf_Data *data;
2285 Is_desc *isec;
2286 size_t size;
2287
2288 if (new_section(ofl, SHT_STRTAB, MSG_ORIG(MSG_SCN_SHSTRTAB),
2289 0, &isec, &shdr, &data) == S_ERROR)
2290 return (S_ERROR);
2291
2292 /*
2293 * Place the section first, as it may effect the number of section
2294 * headers to account for.
2295 */
2296 ofl->ofl_osshstrtab =
2297 ld_place_section(ofl, isec, NULL, ld_targ.t_id.id_note, NULL);
2298 if (ofl->ofl_osshstrtab == (Os_desc *)S_ERROR)
2299 return (S_ERROR);
2300
2301 size = st_getstrtab_sz(ofl->ofl_shdrsttab);
2302 assert(size > 0);
2303
2304 data->d_size = size;
2305 shdr->sh_size = (Xword)size;
2306
2307 return (1);
2308 }
2309
2310 /*
2311 * Build a string section for the standard symbol table.
2312 */
2313 static uintptr_t
2314 make_strtab(Ofl_desc *ofl)
2315 {
2316 Shdr *shdr;
2317 Elf_Data *data;
2318 Is_desc *isec;
2319 size_t size;
2320
2321 /*
2322 * This string table consists of all the global and local symbols.
2323 * Account for null bytes at end of the file name and the beginning
2324 * of section.
2325 */
2326 if (st_insert(ofl->ofl_strtab, ofl->ofl_name) == -1)
2327 return (S_ERROR);
2328
2329 size = st_getstrtab_sz(ofl->ofl_strtab);
2330 assert(size > 0);
2331
2332 if (new_section(ofl, SHT_STRTAB, MSG_ORIG(MSG_SCN_STRTAB),
2333 0, &isec, &shdr, &data) == S_ERROR)
2334 return (S_ERROR);
2335
2336 /* Set the size of the data area */
2337 data->d_size = size;
2338 shdr->sh_size = (Xword)size;
2339
2340 ofl->ofl_osstrtab =
2341 ld_place_section(ofl, isec, NULL, ld_targ.t_id.id_strtab, NULL);
2342 return ((uintptr_t)ofl->ofl_osstrtab);
2343 }
2344
2345 /*
2346 * Build a string table for the dynamic symbol table.
2347 */
2348 static uintptr_t
2349 make_dynstr(Ofl_desc *ofl)
2350 {
2351 Shdr *shdr;
2352 Elf_Data *data;
2353 Is_desc *isec;
2354 size_t size;
2355
2356 /*
2357 * If producing a .SUNW_ldynsym, account for the initial STT_FILE
2358 * symbol that precedes the scope reduced global symbols.
2359 */
2360 if (OFL_ALLOW_LDYNSYM(ofl)) {
2361 if (st_insert(ofl->ofl_dynstrtab, ofl->ofl_name) == -1)
2362 return (S_ERROR);
2363 ofl->ofl_dynscopecnt++;
2364 }
2365
2366 /*
2367 * Account for any local, named register symbols. These locals are
2368 * required for reference from DT_REGISTER .dynamic entries.
2369 */
2370 if (ofl->ofl_regsyms) {
2371 int ndx;
2372
2373 for (ndx = 0; ndx < ofl->ofl_regsymsno; ndx++) {
2374 Sym_desc *sdp;
2375
2376 if ((sdp = ofl->ofl_regsyms[ndx]) == NULL)
2377 continue;
2378
2379 if (!SYM_IS_HIDDEN(sdp) &&
2380 (ELF_ST_BIND(sdp->sd_sym->st_info) != STB_LOCAL))
2381 continue;
2382
2383 if (sdp->sd_sym->st_name == NULL)
2384 continue;
2385
2386 if (st_insert(ofl->ofl_dynstrtab, sdp->sd_name) == -1)
2387 return (S_ERROR);
2388 }
2389 }
2390
2391 /*
2392 * Reserve entries for any per-symbol auxiliary/filter strings.
2393 */
2394 if (ofl->ofl_dtsfltrs != NULL) {
2395 Dfltr_desc *dftp;
2396 Aliste idx;
2397
2398 for (ALIST_TRAVERSE(ofl->ofl_dtsfltrs, idx, dftp))
2399 if (st_insert(ofl->ofl_dynstrtab, dftp->dft_str) == -1)
2400 return (S_ERROR);
2401 }
2402
2403 size = st_getstrtab_sz(ofl->ofl_dynstrtab);
2404 assert(size > 0);
2405
2406 if (new_section(ofl, SHT_STRTAB, MSG_ORIG(MSG_SCN_DYNSTR),
2407 0, &isec, &shdr, &data) == S_ERROR)
2408 return (S_ERROR);
2409
2410 /* Make it allocable if necessary */
2411 if (!(ofl->ofl_flags & FLG_OF_RELOBJ))
2412 shdr->sh_flags |= SHF_ALLOC;
2413
2414 /* Set the size of the data area */
2415 data->d_size = size + DYNSTR_EXTRA_PAD;
2416
2417 shdr->sh_size = (Xword)size;
2418
2419 ofl->ofl_osdynstr =
2420 ld_place_section(ofl, isec, NULL, ld_targ.t_id.id_dynstr, NULL);
2421 return ((uintptr_t)ofl->ofl_osdynstr);
2422 }
2423
2424 /*
2425 * Generate an output relocation section which will contain the relocation
2426 * information to be applied to the `osp' section.
2427 *
2428 * If (osp == NULL) then we are creating the coalesced relocation section
2429 * for an executable and/or a shared object.
2430 */
2431 static uintptr_t
2432 make_reloc(Ofl_desc *ofl, Os_desc *osp)
2433 {
2434 Shdr *shdr;
2435 Elf_Data *data;
2436 Is_desc *isec;
2437 size_t size;
2438 Xword sh_flags;
2439 char *sectname;
2440 Os_desc *rosp;
2441 Word relsize;
2442 const char *rel_prefix;
2443
2444 /* LINTED */
2445 if (ld_targ.t_m.m_rel_sht_type == SHT_REL) {
2446 /* REL */
2447 relsize = sizeof (Rel);
2448 rel_prefix = MSG_ORIG(MSG_SCN_REL);
2449 } else {
2450 /* RELA */
2451 relsize = sizeof (Rela);
2452 rel_prefix = MSG_ORIG(MSG_SCN_RELA);
2453 }
2454
2455 if (osp) {
2456 size = osp->os_szoutrels;
2457 sh_flags = osp->os_shdr->sh_flags;
2458 if ((sectname = libld_malloc(strlen(rel_prefix) +
2459 strlen(osp->os_name) + 1)) == 0)
2460 return (S_ERROR);
2461 (void) strcpy(sectname, rel_prefix);
2462 (void) strcat(sectname, osp->os_name);
2463 } else if (ofl->ofl_flags & FLG_OF_COMREL) {
2464 size = (ofl->ofl_reloccnt - ofl->ofl_reloccntsub) * relsize;
2465 sh_flags = SHF_ALLOC;
2466 sectname = (char *)MSG_ORIG(MSG_SCN_SUNWRELOC);
2467 } else {
2468 size = ofl->ofl_relocrelsz;
2469 sh_flags = SHF_ALLOC;
2470 sectname = (char *)rel_prefix;
2471 }
2472
2473 /*
2474 * Keep track of total size of 'output relocations' (to be stored
2475 * in .dynamic)
2476 */
2477 /* LINTED */
2478 ofl->ofl_relocsz += (Xword)size;
2479
2480 if (new_section(ofl, ld_targ.t_m.m_rel_sht_type, sectname, 0, &isec,
2481 &shdr, &data) == S_ERROR)
2482 return (S_ERROR);
2483
2484 data->d_size = size;
2485
2486 shdr->sh_size = (Xword)size;
2487 if (OFL_ALLOW_DYNSYM(ofl) && (sh_flags & SHF_ALLOC))
2488 shdr->sh_flags = SHF_ALLOC;
2489
2490 if (osp) {
2491 /*
2492 * The sh_info field of the SHT_REL* sections points to the
2493 * section the relocations are to be applied to.
2494 */
2495 shdr->sh_flags |= SHF_INFO_LINK;
2496 }
2497
2498 rosp = ld_place_section(ofl, isec, NULL, ld_targ.t_id.id_rel, NULL);
2499 if (rosp == (Os_desc *)S_ERROR)
2500 return (S_ERROR);
2501
2502 /*
2503 * Associate this relocation section to the section its going to
2504 * relocate.
2505 */
2506 if (osp) {
2507 Aliste idx;
2508 Is_desc *risp;
2509
2510 /*
2511 * This is used primarily so that we can update
2512 * SHT_GROUP[sect_no] entries to point to the
2513 * created output relocation sections.
2514 */
2515 for (APLIST_TRAVERSE(osp->os_relisdescs, idx, risp)) {
2516 risp->is_osdesc = rosp;
2517
2518 /*
2519 * If the input relocation section had the SHF_GROUP
2520 * flag set - propagate it to the output relocation
2521 * section.
2522 */
2523 if (risp->is_shdr->sh_flags & SHF_GROUP) {
2524 rosp->os_shdr->sh_flags |= SHF_GROUP;
2525 break;
2526 }
2527 }
2528 osp->os_relosdesc = rosp;
2529 } else
2530 ofl->ofl_osrel = rosp;
2531
2532 /*
2533 * If this is the first relocation section we've encountered save it
2534 * so that the .dynamic entry can be initialized accordingly.
2535 */
2536 if (ofl->ofl_osrelhead == (Os_desc *)0)
2537 ofl->ofl_osrelhead = rosp;
2538
2539 return (1);
2540 }
2541
2542 /*
2543 * Generate version needed section.
2544 */
2545 static uintptr_t
2546 make_verneed(Ofl_desc *ofl)
2547 {
2548 Shdr *shdr;
2549 Elf_Data *data;
2550 Is_desc *isec;
2551
2552 /*
2553 * verneed sections do not have a constant element size, so the
2554 * value of ent_cnt specified here (0) is meaningless.
2555 */
2556 if (new_section(ofl, SHT_SUNW_verneed, MSG_ORIG(MSG_SCN_SUNWVERSION),
2557 0, &isec, &shdr, &data) == S_ERROR)
2558 return (S_ERROR);
2559
2560 /* During version processing we calculated the total size. */
2561 data->d_size = ofl->ofl_verneedsz;
2562 shdr->sh_size = (Xword)ofl->ofl_verneedsz;
2563
2564 ofl->ofl_osverneed =
2565 ld_place_section(ofl, isec, NULL, ld_targ.t_id.id_version, NULL);
2566 return ((uintptr_t)ofl->ofl_osverneed);
2567 }
2568
2569 /*
2570 * Generate a version definition section.
2571 *
2572 * o the SHT_SUNW_verdef section defines the versions that exist within this
2573 * image.
2574 */
2575 static uintptr_t
2576 make_verdef(Ofl_desc *ofl)
2577 {
2578 Shdr *shdr;
2579 Elf_Data *data;
2580 Is_desc *isec;
2581 Ver_desc *vdp;
2582 Str_tbl *strtab;
2583
2584 /*
2585 * Reserve a string table entry for the base version dependency (other
2586 * dependencies have symbol representations, which will already be
2587 * accounted for during symbol processing).
2588 */
2589 vdp = (Ver_desc *)ofl->ofl_verdesc->apl_data[0];
2590
2591 if (OFL_IS_STATIC_OBJ(ofl))
2592 strtab = ofl->ofl_strtab;
2593 else
2594 strtab = ofl->ofl_dynstrtab;
2595
2596 if (st_insert(strtab, vdp->vd_name) == -1)
2597 return (S_ERROR);
2598
2599 /*
2600 * verdef sections do not have a constant element size, so the
2601 * value of ent_cnt specified here (0) is meaningless.
2602 */
2603 if (new_section(ofl, SHT_SUNW_verdef, MSG_ORIG(MSG_SCN_SUNWVERSION),
2604 0, &isec, &shdr, &data) == S_ERROR)
2605 return (S_ERROR);
2606
2607 /* During version processing we calculated the total size. */
2608 data->d_size = ofl->ofl_verdefsz;
2609 shdr->sh_size = (Xword)ofl->ofl_verdefsz;
2610
2611 ofl->ofl_osverdef =
2612 ld_place_section(ofl, isec, NULL, ld_targ.t_id.id_version, NULL);
2613 return ((uintptr_t)ofl->ofl_osverdef);
2614 }
2615
2616 /*
2617 * This routine is called when -z nopartial is in effect.
2618 */
2619 uintptr_t
2620 ld_make_parexpn_data(Ofl_desc *ofl, size_t size, Xword align)
2621 {
2622 Shdr *shdr;
2623 Elf_Data *data;
2624 Is_desc *isec;
2625 Os_desc *osp;
2626
2627 if (new_section(ofl, SHT_PROGBITS, MSG_ORIG(MSG_SCN_DATA), 0,
2628 &isec, &shdr, &data) == S_ERROR)
2629 return (S_ERROR);
2630
2631 shdr->sh_flags |= SHF_WRITE;
2632 data->d_size = size;
2633 shdr->sh_size = (Xword)size;
2634 if (align != 0) {
2635 data->d_align = align;
2636 shdr->sh_addralign = align;
2637 }
2638
2639 if ((data->d_buf = libld_calloc(size, 1)) == NULL)
2640 return (S_ERROR);
2641
2642 /*
2643 * Retain handle to this .data input section. Variables using move
2644 * sections (partial initialization) will be redirected here when
2645 * such global references are added and '-z nopartial' is in effect.
2646 */
2647 ofl->ofl_isparexpn = isec;
2648 osp = ld_place_section(ofl, isec, NULL, ld_targ.t_id.id_data, NULL);
2649 if (osp == (Os_desc *)S_ERROR)
2650 return (S_ERROR);
2651
2652 if (!(osp->os_flags & FLG_OS_OUTREL)) {
2653 ofl->ofl_dynshdrcnt++;
2654 osp->os_flags |= FLG_OS_OUTREL;
2655 }
2656 return (1);
2657 }
2658
2659 /*
2660 * Make .sunwmove section
2661 */
2662 uintptr_t
2663 ld_make_sunwmove(Ofl_desc *ofl, int mv_nums)
2664 {
2665 Shdr *shdr;
2666 Elf_Data *data;
2667 Is_desc *isec;
2668 Aliste idx;
2669 Sym_desc *sdp;
2670 int cnt = 1;
2671
2672
2673 if (new_section(ofl, SHT_SUNW_move, MSG_ORIG(MSG_SCN_SUNWMOVE),
2674 mv_nums, &isec, &shdr, &data) == S_ERROR)
2675 return (S_ERROR);
2676
2677 if ((data->d_buf = libld_calloc(data->d_size, 1)) == NULL)
2678 return (S_ERROR);
2679
2680 /*
2681 * Copy move entries
2682 */
2683 for (APLIST_TRAVERSE(ofl->ofl_parsyms, idx, sdp)) {
2684 Aliste idx2;
2685 Mv_desc *mdp;
2686
2687 if (sdp->sd_flags & FLG_SY_PAREXPN)
2688 continue;
2689
2690 for (ALIST_TRAVERSE(sdp->sd_move, idx2, mdp))
2691 mdp->md_oidx = cnt++;
2692 }
2693
2694 if ((ofl->ofl_osmove = ld_place_section(ofl, isec, NULL, 0, NULL)) ==
2695 (Os_desc *)S_ERROR)
2696 return (S_ERROR);
2697
2698 return (1);
2699 }
2700
2701 /*
2702 * Given a relocation descriptor that references a string table
2703 * input section, locate the string referenced and return a pointer
2704 * to it.
2705 */
2706 static const char *
2707 strmerge_get_reloc_str(Ofl_desc *ofl, Rel_desc *rsp)
2708 {
2709 Sym_desc *sdp = rsp->rel_sym;
2710 Xword str_off;
2711
2712 /*
2713 * In the case of an STT_SECTION symbol, the addend of the
2714 * relocation gives the offset into the string section. For
2715 * other symbol types, the symbol value is the offset.
2716 */
2717
2718 if (ELF_ST_TYPE(sdp->sd_sym->st_info) != STT_SECTION) {
2719 str_off = sdp->sd_sym->st_value;
2720 } else if ((rsp->rel_flags & FLG_REL_RELA) == FLG_REL_RELA) {
2721 /*
2722 * For SHT_RELA, the addend value is found in the
2723 * rel_raddend field of the relocation.
2724 */
2725 str_off = rsp->rel_raddend;
2726 } else { /* REL and STT_SECTION */
2727 /*
2728 * For SHT_REL, the "addend" is not part of the relocation
2729 * record. Instead, it is found at the relocation target
2730 * address.
2731 */
2732 uchar_t *addr = (uchar_t *)((uintptr_t)rsp->rel_roffset +
2733 (uintptr_t)rsp->rel_isdesc->is_indata->d_buf);
2734
2735 if (ld_reloc_targval_get(ofl, rsp, addr, &str_off) == 0)
2736 return (0);
2737 }
2738
2739 return (str_off + (char *)sdp->sd_isc->is_indata->d_buf);
2740 }
2741
2742 /*
2743 * First pass over the relocation records for string table merging.
2744 * Build lists of relocations and symbols that will need modification,
2745 * and insert the strings they reference into the mstrtab string table.
2746 *
2747 * entry:
2748 * ofl, osp - As passed to ld_make_strmerge().
2749 * mstrtab - String table to receive input strings. This table
2750 * must be in its first (initialization) pass and not
2751 * yet cooked (st_getstrtab_sz() not yet called).
2752 * rel_alpp - APlist to receive pointer to any relocation
2753 * descriptors with STT_SECTION symbols that reference
2754 * one of the input sections being merged.
2755 * sym_alpp - APlist to receive pointer to any symbols that reference
2756 * one of the input sections being merged.
2757 * rcp - Pointer to cache of relocation descriptors to examine.
2758 * Either &ofl->ofl_actrels (active relocations)
2759 * or &ofl->ofl_outrels (output relocations).
2760 *
2761 * exit:
2762 * On success, rel_alpp and sym_alpp are updated, and
2763 * any strings in the mergeable input sections referenced by
2764 * a relocation has been entered into mstrtab. True (1) is returned.
2765 *
2766 * On failure, False (0) is returned.
2767 */
2768 static int
2769 strmerge_pass1(Ofl_desc *ofl, Os_desc *osp, Str_tbl *mstrtab,
2770 APlist **rel_alpp, APlist **sym_alpp, Rel_cache *rcp)
2771 {
2772 Aliste idx;
2773 Rel_cachebuf *rcbp;
2774 Sym_desc *sdp;
2775 Sym_desc *last_sdp = NULL;
2776 Rel_desc *rsp;
2777 const char *name;
2778
2779 REL_CACHE_TRAVERSE(rcp, idx, rcbp, rsp) {
2780 sdp = rsp->rel_sym;
2781 if ((sdp->sd_isc == NULL) || ((sdp->sd_isc->is_flags &
2782 (FLG_IS_DISCARD | FLG_IS_INSTRMRG)) != FLG_IS_INSTRMRG) ||
2783 (sdp->sd_isc->is_osdesc != osp))
2784 continue;
2785
2786 /*
2787 * Remember symbol for use in the third pass. There is no
2788 * reason to save a given symbol more than once, so we take
2789 * advantage of the fact that relocations to a given symbol
2790 * tend to cluster in the list. If this is the same symbol
2791 * we saved last time, don't bother.
2792 */
2793 if (last_sdp != sdp) {
2794 if (aplist_append(sym_alpp, sdp, AL_CNT_STRMRGSYM) ==
2795 NULL)
2796 return (0);
2797 last_sdp = sdp;
2798 }
2799
2800 /* Enter the string into our new string table */
2801 name = strmerge_get_reloc_str(ofl, rsp);
2802 if (st_insert(mstrtab, name) == -1)
2803 return (0);
2804
2805 /*
2806 * If this is an STT_SECTION symbol, then the second pass
2807 * will need to modify this relocation, so hang on to it.
2808 */
2809 if ((ELF_ST_TYPE(sdp->sd_sym->st_info) == STT_SECTION) &&
2810 (aplist_append(rel_alpp, rsp, AL_CNT_STRMRGREL) == NULL))
2811 return (0);
2812 }
2813
2814 return (1);
2815 }
2816
2817 /*
2818 * If the output section has any SHF_MERGE|SHF_STRINGS input sections,
2819 * replace them with a single merged/compressed input section.
2820 *
2821 * entry:
2822 * ofl - Output file descriptor
2823 * osp - Output section descriptor
2824 * rel_alpp, sym_alpp, - Address of 2 APlists, to be used
2825 * for internal processing. On the initial call to
2826 * ld_make_strmerge, these list pointers must be NULL.
2827 * The caller is encouraged to pass the same lists back for
2828 * successive calls to this function without freeing
2829 * them in between calls. This causes a single pair of
2830 * memory allocations to be reused multiple times.
2831 *
2832 * exit:
2833 * If section merging is possible, it is done. If no errors are
2834 * encountered, True (1) is returned. On error, S_ERROR.
2835 *
2836 * The contents of rel_alpp and sym_alpp on exit are
2837 * undefined. The caller can free them, or pass them back to a subsequent
2838 * call to this routine, but should not examine their contents.
2839 */
2840 static uintptr_t
2841 ld_make_strmerge(Ofl_desc *ofl, Os_desc *osp, APlist **rel_alpp,
2842 APlist **sym_alpp)
2843 {
2844 Str_tbl *mstrtab; /* string table for string merge secs */
2845 Is_desc *mstrsec; /* Generated string merge section */
2846 Is_desc *isp;
2847 Shdr *mstr_shdr;
2848 Elf_Data *mstr_data;
2849 Sym_desc *sdp;
2850 Rel_desc *rsp;
2851 Aliste idx;
2852 size_t data_size;
2853 int st_setstring_status;
2854 size_t stoff;
2855
2856 /* If string table compression is disabled, there's nothing to do */
2857 if ((ofl->ofl_flags1 & FLG_OF1_NCSTTAB) != 0)
2858 return (1);
2859
2860 /*
2861 * Pass over the mergeable input sections, and if they haven't
2862 * all been discarded, create a string table.
2863 */
2864 mstrtab = NULL;
2865 for (APLIST_TRAVERSE(osp->os_mstrisdescs, idx, isp)) {
2866 if (isdesc_discarded(isp))
2867 continue;
2868
2869 /*
2870 * Input sections of 0 size are dubiously valid since they do
2871 * not even contain the NUL string. Ignore them.
2872 */
2873 if (isp->is_shdr->sh_size == 0)
2874 continue;
2875
2876 /*
2877 * We have at least one non-discarded section.
2878 * Create a string table descriptor.
2879 */
2880 if ((mstrtab = st_new(FLG_STNEW_COMPRESS)) == NULL)
2881 return (S_ERROR);
2882 break;
2883 }
2884
2885 /* If no string table was created, we have no mergeable sections */
2886 if (mstrtab == NULL)
2887 return (1);
2888
2889 /*
2890 * This routine has to make 3 passes:
2891 *
2892 * 1) Examine all relocations, insert strings from relocations
2893 * to the mergeable input sections into the string table.
2894 * 2) Modify the relocation values to be correct for the
2895 * new merged section.
2896 * 3) Modify the symbols used by the relocations to reference
2897 * the new section.
2898 *
2899 * These passes cannot be combined:
2900 * - The string table code works in two passes, and all
2901 * strings have to be loaded in pass one before the
2902 * offset of any strings can be determined.
2903 * - Multiple relocations reference a single symbol, so the
2904 * symbol cannot be modified until all relocations are
2905 * fixed.
2906 *
2907 * The number of relocations related to section merging is usually
2908 * a mere fraction of the overall active and output relocation lists,
2909 * and the number of symbols is usually a fraction of the number
2910 * of related relocations. We therefore build APlists for the
2911 * relocations and symbols in the first pass, and then use those
2912 * lists to accelerate the operation of pass 2 and 3.
2913 *
2914 * Reinitialize the lists to a completely empty state.
2915 */
2916 aplist_reset(*rel_alpp);
2917 aplist_reset(*sym_alpp);
2918
2919 /*
2920 * Pass 1:
2921 *
2922 * Every relocation related to this output section (and the input
2923 * sections that make it up) is found in either the active, or the
2924 * output relocation list, depending on whether the relocation is to
2925 * be processed by this invocation of the linker, or inserted into the
2926 * output object.
2927 *
2928 * Build lists of relocations and symbols that will need modification,
2929 * and insert the strings they reference into the mstrtab string table.
2930 */
2931 if (strmerge_pass1(ofl, osp, mstrtab, rel_alpp, sym_alpp,
2932 &ofl->ofl_actrels) == 0)
2933 goto return_s_error;
2934 if (strmerge_pass1(ofl, osp, mstrtab, rel_alpp, sym_alpp,
2935 &ofl->ofl_outrels) == 0)
2936 goto return_s_error;
2937
2938 /*
2939 * Get the size of the new input section. Requesting the
2940 * string table size "cooks" the table, and finalizes its contents.
2941 */
2942 data_size = st_getstrtab_sz(mstrtab);
2943
2944 /* Create a new input section to hold the merged strings */
2945 if (new_section_from_template(ofl, isp, data_size,
2946 &mstrsec, &mstr_shdr, &mstr_data) == S_ERROR)
2947 goto return_s_error;
2948 mstrsec->is_flags |= FLG_IS_GNSTRMRG;
2949
2950 /*
2951 * Allocate a data buffer for the new input section.
2952 * Then, associate the buffer with the string table descriptor.
2953 */
2954 if ((mstr_data->d_buf = libld_malloc(data_size)) == NULL)
2955 goto return_s_error;
2956 if (st_setstrbuf(mstrtab, mstr_data->d_buf, data_size) == -1)
2957 goto return_s_error;
2958
2959 /* Add the new section to the output image */
2960 if (ld_place_section(ofl, mstrsec, NULL, osp->os_identndx, NULL) ==
2961 (Os_desc *)S_ERROR)
2962 goto return_s_error;
2963
2964 /*
2965 * Pass 2:
2966 *
2967 * Revisit the relocation descriptors with STT_SECTION symbols
2968 * that were saved by the first pass. Update each relocation
2969 * record so that the offset it contains is for the new section
2970 * instead of the original.
2971 */
2972 for (APLIST_TRAVERSE(*rel_alpp, idx, rsp)) {
2973 const char *name;
2974
2975 /* Put the string into the merged string table */
2976 name = strmerge_get_reloc_str(ofl, rsp);
2977 st_setstring_status = st_setstring(mstrtab, name, &stoff);
2978 if (st_setstring_status == -1) {
2979 /*
2980 * A failure to insert at this point means that
2981 * something is corrupt. This isn't a resource issue.
2982 */
2983 assert(st_setstring_status != -1);
2984 goto return_s_error;
2985 }
2986
2987 /*
2988 * Alter the relocation to access the string at the
2989 * new offset in our new string table.
2990 *
2991 * For SHT_RELA platforms, it suffices to simply
2992 * update the rel_raddend field of the relocation.
2993 *
2994 * For SHT_REL platforms, the new "addend" value
2995 * needs to be written at the address being relocated.
2996 * However, we can't alter the input sections which
2997 * are mapped readonly, and the output image has not
2998 * been created yet. So, we defer this operation,
2999 * using the rel_raddend field of the relocation
3000 * which is normally 0 on a REL platform, to pass the
3001 * new "addend" value to ld_perform_outreloc() or
3002 * ld_do_activerelocs(). The FLG_REL_NADDEND flag
3003 * tells them that this is the case.
3004 */
3005 if ((rsp->rel_flags & FLG_REL_RELA) == 0) /* REL */
3006 rsp->rel_flags |= FLG_REL_NADDEND;
3007 rsp->rel_raddend = (Sxword)stoff;
3008
3009 /*
3010 * Generate a symbol name string for STT_SECTION symbols
3011 * that might reference our merged section. This shows up
3012 * in debug output and helps show how the relocation has
3013 * changed from its original input section to our merged one.
3014 */
3015 if (ld_stt_section_sym_name(mstrsec) == NULL)
3016 goto return_s_error;
3017 }
3018
3019 /*
3020 * Pass 3:
3021 *
3022 * Modify the symbols referenced by the relocation descriptors
3023 * so that they reference the new input section containing the
3024 * merged strings instead of the original input sections.
3025 */
3026 for (APLIST_TRAVERSE(*sym_alpp, idx, sdp)) {
3027 /*
3028 * If we've already processed this symbol, don't do it
3029 * twice. strmerge_pass1() uses a heuristic (relocations to
3030 * the same symbol clump together) to avoid inserting a
3031 * given symbol more than once, but repeat symbols in
3032 * the list can occur.
3033 */
3034 if ((sdp->sd_isc->is_flags & FLG_IS_INSTRMRG) == 0)
3035 continue;
3036
3037 if (ELF_ST_TYPE(sdp->sd_sym->st_info) != STT_SECTION) {
3038 /*
3039 * This is not an STT_SECTION symbol, so its
3040 * value is the offset of the string within the
3041 * input section. Update the address to reflect
3042 * the address in our new merged section.
3043 */
3044 const char *name = sdp->sd_sym->st_value +
3045 (char *)sdp->sd_isc->is_indata->d_buf;
3046
3047 st_setstring_status =
3048 st_setstring(mstrtab, name, &stoff);
3049 if (st_setstring_status == -1) {
3050 /*
3051 * A failure to insert at this point means
3052 * something is corrupt. This isn't a
3053 * resource issue.
3054 */
3055 assert(st_setstring_status != -1);
3056 goto return_s_error;
3057 }
3058
3059 if (ld_sym_copy(sdp) == S_ERROR)
3060 goto return_s_error;
3061 sdp->sd_sym->st_value = (Word)stoff;
3062 }
3063
3064 /* Redirect the symbol to our new merged section */
3065 sdp->sd_isc = mstrsec;
3066 }
3067
3068 /*
3069 * There are no references left to the original input string sections.
3070 * Mark them as discarded so they don't go into the output image.
3071 * At the same time, add up the sizes of the replaced sections.
3072 */
3073 data_size = 0;
3074 for (APLIST_TRAVERSE(osp->os_mstrisdescs, idx, isp)) {
3075 if (isp->is_flags & (FLG_IS_DISCARD | FLG_IS_GNSTRMRG))
3076 continue;
3077
3078 data_size += isp->is_indata->d_size;
3079
3080 isp->is_flags |= FLG_IS_DISCARD;
3081 DBG_CALL(Dbg_sec_discarded(ofl->ofl_lml, isp, mstrsec));
3082 }
3083
3084 /* Report how much space we saved in the output section */
3085 DBG_CALL(Dbg_sec_genstr_compress(ofl->ofl_lml, osp->os_name, data_size,
3086 mstr_data->d_size));
3087
3088 st_destroy(mstrtab);
3089 return (1);
3090
3091 return_s_error:
3092 st_destroy(mstrtab);
3093 return (S_ERROR);
3094 }
3095
3096 /*
3097 * Update a data buffers size. A number of sections have to be created, and
3098 * the sections header contributes to the size of the eventual section. Thus,
3099 * a section may be created, and once all associated sections have been created,
3100 * we return to establish the required section size.
3101 */
3102 inline static void
3103 update_data_size(Os_desc *osp, ulong_t cnt)
3104 {
3105 Is_desc *isec = ld_os_first_isdesc(osp);
3106 Elf_Data *data = isec->is_indata;
3107 Shdr *shdr = osp->os_shdr;
3108 size_t size = cnt * shdr->sh_entsize;
3109
3110 shdr->sh_size = (Xword)size;
3111 data->d_size = size;
3112 }
3113
3114 /*
3115 * The following sections are built after all input file processing and symbol
3116 * validation has been carried out. The order is important (because the
3117 * addition of a section adds a new symbol there is a chicken and egg problem
3118 * of maintaining the appropriate counts). By maintaining a known order the
3119 * individual routines can compensate for later, known, additions.
3120 */
3121 uintptr_t
3122 ld_make_sections(Ofl_desc *ofl)
3123 {
3124 ofl_flag_t flags = ofl->ofl_flags;
3125 Sg_desc *sgp;
3126
3127 /*
3128 * Generate any special sections.
3129 */
3130 if (flags & FLG_OF_ADDVERS)
3131 if (make_comment(ofl) == S_ERROR)
3132 return (S_ERROR);
3133
3134 if (make_interp(ofl) == S_ERROR)
3135 return (S_ERROR);
3136
3137 /*
3138 * Create a capabilities section if required.
3139 */
3140 if (make_cap(ofl, SHT_SUNW_cap, MSG_ORIG(MSG_SCN_SUNWCAP),
3141 ld_targ.t_id.id_cap) == S_ERROR)
3142 return (S_ERROR);
3143
3144 /*
3145 * Create any init/fini array sections.
3146 */
3147 if (make_array(ofl, SHT_INIT_ARRAY, MSG_ORIG(MSG_SCN_INITARRAY),
3148 ofl->ofl_initarray) == S_ERROR)
3149 return (S_ERROR);
3150
3151 if (make_array(ofl, SHT_FINI_ARRAY, MSG_ORIG(MSG_SCN_FINIARRAY),
3152 ofl->ofl_finiarray) == S_ERROR)
3153 return (S_ERROR);
3154
3155 if (make_array(ofl, SHT_PREINIT_ARRAY, MSG_ORIG(MSG_SCN_PREINITARRAY),
3156 ofl->ofl_preiarray) == S_ERROR)
3157 return (S_ERROR);
3158
3159 /*
3160 * Make the .plt section. This occurs after any other relocation
3161 * sections are generated (see reloc_init()) to ensure that the
3162 * associated relocation section is after all the other relocation
3163 * sections.
3164 */
3165 if ((ofl->ofl_pltcnt) || (ofl->ofl_pltpad))
3166 if (make_plt(ofl) == S_ERROR)
3167 return (S_ERROR);
3168
3169 /*
3170 * Determine whether any sections or files are not referenced. Under
3171 * -Dunused a diagnostic for any unused components is generated, under
3172 * -zignore the component is removed from the final output.
3173 */
3174 if (DBG_ENABLED || (ofl->ofl_flags1 & FLG_OF1_IGNPRC)) {
3175 if (ignore_section_processing(ofl) == S_ERROR)
3176 return (S_ERROR);
3177 }
3178
3179 /*
3180 * If we have detected a situation in which previously placed
3181 * output sections may have been discarded, perform the necessary
3182 * readjustment.
3183 */
3184 if (ofl->ofl_flags & FLG_OF_ADJOSCNT)
3185 adjust_os_count(ofl);
3186
3187 /*
3188 * Do any of the output sections contain input sections that
3189 * are candidates for string table merging? For each such case,
3190 * we create a replacement section, insert it, and discard the
3191 * originals.
3192 *
3193 * rel_alpp and sym_alpp are used by ld_make_strmerge()
3194 * for its internal processing. We are responsible for the
3195 * initialization and cleanup, and ld_make_strmerge() handles the rest.
3196 * This allows us to reuse a single pair of memory buffers, allocated
3197 * for this processing, for all the output sections.
3198 */
3199 if ((ofl->ofl_flags1 & FLG_OF1_NCSTTAB) == 0) {
3200 int error_seen = 0;
3201 APlist *rel_alpp = NULL;
3202 APlist *sym_alpp = NULL;
3203 Aliste idx1;
3204
3205 for (APLIST_TRAVERSE(ofl->ofl_segs, idx1, sgp)) {
3206 Os_desc *osp;
3207 Aliste idx2;
3208
3209 for (APLIST_TRAVERSE(sgp->sg_osdescs, idx2, osp))
3210 if ((osp->os_mstrisdescs != NULL) &&
3211 (ld_make_strmerge(ofl, osp,
3212 &rel_alpp, &sym_alpp) ==
3213 S_ERROR)) {
3214 error_seen = 1;
3215 break;
3216 }
3217 }
3218 if (rel_alpp != NULL)
3219 libld_free(rel_alpp);
3220 if (sym_alpp != NULL)
3221 libld_free(sym_alpp);
3222 if (error_seen != 0)
3223 return (S_ERROR);
3224 }
3225
3226 /*
3227 * Add any necessary versioning information.
3228 */
3229 if (!(flags & FLG_OF_NOVERSEC)) {
3230 if ((flags & FLG_OF_VERNEED) &&
3231 (make_verneed(ofl) == S_ERROR))
3232 return (S_ERROR);
3233 if ((flags & FLG_OF_VERDEF) &&
3234 (make_verdef(ofl) == S_ERROR))
3235 return (S_ERROR);
3236 if ((flags & (FLG_OF_VERNEED | FLG_OF_VERDEF)) &&
3237 ((ofl->ofl_osversym = make_sym_sec(ofl,
3238 MSG_ORIG(MSG_SCN_SUNWVERSYM), SHT_SUNW_versym,
3239 ld_targ.t_id.id_version)) == (Os_desc*)S_ERROR))
3240 return (S_ERROR);
3241 }
3242
3243 /*
3244 * Create a syminfo section if necessary.
3245 */
3246 if (flags & FLG_OF_SYMINFO) {
3247 if ((ofl->ofl_ossyminfo = make_sym_sec(ofl,
3248 MSG_ORIG(MSG_SCN_SUNWSYMINFO), SHT_SUNW_syminfo,
3249 ld_targ.t_id.id_syminfo)) == (Os_desc *)S_ERROR)
3250 return (S_ERROR);
3251 }
3252
3253 if (flags & FLG_OF_COMREL) {
3254 /*
3255 * If -zcombreloc is enabled then all relocations (except for
3256 * the PLT's) are coalesced into a single relocation section.
3257 */
3258 if (ofl->ofl_reloccnt) {
3259 if (make_reloc(ofl, NULL) == S_ERROR)
3260 return (S_ERROR);
3261 }
3262 } else {
3263 Aliste idx1;
3264
3265 /*
3266 * Create the required output relocation sections. Note, new
3267 * sections may be added to the section list that is being
3268 * traversed. These insertions can move the elements of the
3269 * Alist such that a section descriptor is re-read. Recursion
3270 * is prevented by maintaining a previous section pointer and
3271 * insuring that this pointer isn't re-examined.
3272 */
3273 for (APLIST_TRAVERSE(ofl->ofl_segs, idx1, sgp)) {
3274 Os_desc *osp, *posp = 0;
3275 Aliste idx2;
3276
3277 for (APLIST_TRAVERSE(sgp->sg_osdescs, idx2, osp)) {
3278 if ((osp != posp) && osp->os_szoutrels &&
3279 (osp != ofl->ofl_osplt)) {
3280 if (make_reloc(ofl, osp) == S_ERROR)
3281 return (S_ERROR);
3282 }
3283 posp = osp;
3284 }
3285 }
3286
3287 /*
3288 * If we're not building a combined relocation section, then
3289 * build a .rel[a] section as required.
3290 */
3291 if (ofl->ofl_relocrelsz) {
3292 if (make_reloc(ofl, NULL) == S_ERROR)
3293 return (S_ERROR);
3294 }
3295 }
3296
3297 /*
3298 * The PLT relocations are always in their own section, and we try to
3299 * keep them at the end of the PLT table. We do this to keep the hot
3300 * "data" PLT's at the head of the table nearer the .dynsym & .hash.
3301 */
3302 if (ofl->ofl_osplt && ofl->ofl_relocpltsz) {
3303 if (make_reloc(ofl, ofl->ofl_osplt) == S_ERROR)
3304 return (S_ERROR);
3305 }
3306
3307 /*
3308 * Finally build the symbol and section header sections.
3309 */
3310 if (flags & FLG_OF_DYNAMIC) {
3311 if (make_dynamic(ofl) == S_ERROR)
3312 return (S_ERROR);
3313
3314 /*
3315 * A number of sections aren't necessary within a relocatable
3316 * object, even if -dy has been used.
3317 */
3318 if (!(flags & FLG_OF_RELOBJ)) {
3319 if (make_hash(ofl) == S_ERROR)
3320 return (S_ERROR);
3321 if (make_dynstr(ofl) == S_ERROR)
3322 return (S_ERROR);
3323 if (make_dynsym(ofl) == S_ERROR)
3324 return (S_ERROR);
3325 if (ld_unwind_make_hdr(ofl) == S_ERROR)
3326 return (S_ERROR);
3327 if (make_dynsort(ofl) == S_ERROR)
3328 return (S_ERROR);
3329 }
3330 }
3331
3332 if (!(flags & FLG_OF_STRIP) || (flags & FLG_OF_RELOBJ) ||
3333 ((flags & FLG_OF_STATIC) && ofl->ofl_osversym)) {
3334 /*
3335 * Do we need to make a SHT_SYMTAB_SHNDX section
3336 * for the dynsym. If so - do it now.
3337 */
3338 if (ofl->ofl_osdynsym &&
3339 ((ofl->ofl_shdrcnt + 3) >= SHN_LORESERVE)) {
3340 if (make_dynsym_shndx(ofl) == S_ERROR)
3341 return (S_ERROR);
3342 }
3343
3344 if (make_strtab(ofl) == S_ERROR)
3345 return (S_ERROR);
3346 if (make_symtab(ofl) == S_ERROR)
3347 return (S_ERROR);
3348 } else {
3349 /*
3350 * Do we need to make a SHT_SYMTAB_SHNDX section
3351 * for the dynsym. If so - do it now.
3352 */
3353 if (ofl->ofl_osdynsym &&
3354 ((ofl->ofl_shdrcnt + 1) >= SHN_LORESERVE)) {
3355 if (make_dynsym_shndx(ofl) == S_ERROR)
3356 return (S_ERROR);
3357 }
3358 }
3359
3360 if (make_shstrtab(ofl) == S_ERROR)
3361 return (S_ERROR);
3362
3363 /*
3364 * Now that we've created all output sections, adjust the size of the
3365 * SHT_SUNW_versym and SHT_SUNW_syminfo section, which are dependent on
3366 * the associated symbol table sizes.
3367 */
3368 if (ofl->ofl_osversym || ofl->ofl_ossyminfo) {
3369 ulong_t cnt;
3370 Is_desc *isp;
3371 Os_desc *osp;
3372
3373 if (OFL_IS_STATIC_OBJ(ofl))
3374 osp = ofl->ofl_ossymtab;
3375 else
3376 osp = ofl->ofl_osdynsym;
3377
3378 isp = ld_os_first_isdesc(osp);
3379 cnt = (isp->is_shdr->sh_size / isp->is_shdr->sh_entsize);
3380
3381 if (ofl->ofl_osversym)
3382 update_data_size(ofl->ofl_osversym, cnt);
3383
3384 if (ofl->ofl_ossyminfo)
3385 update_data_size(ofl->ofl_ossyminfo, cnt);
3386 }
3387
3388 /*
3389 * Now that we've created all output sections, adjust the size of the
3390 * SHT_SUNW_capinfo, which is dependent on the associated symbol table
3391 * size.
3392 */
3393 if (ofl->ofl_oscapinfo) {
3394 ulong_t cnt;
3395
3396 /*
3397 * Symbol capabilities symbols are placed directly after the
3398 * STT_FILE symbol, section symbols, and any register symbols.
3399 * Effectively these are the first of any series of demoted
3400 * (scoped) symbols.
3401 */
3402 if (OFL_IS_STATIC_OBJ(ofl))
3403 cnt = SYMTAB_ALL_CNT(ofl);
3404 else
3405 cnt = DYNSYM_ALL_CNT(ofl);
3406
3407 update_data_size(ofl->ofl_oscapinfo, cnt);
3408 }
3409 return (1);
3410 }
3411
3412 /*
3413 * Build an additional data section - used to back OBJT symbol definitions
3414 * added with a mapfile.
3415 */
3416 Is_desc *
3417 ld_make_data(Ofl_desc *ofl, size_t size)
3418 {
3419 Shdr *shdr;
3420 Elf_Data *data;
3421 Is_desc *isec;
3422
3423 if (new_section(ofl, SHT_PROGBITS, MSG_ORIG(MSG_SCN_DATA), 0,
3424 &isec, &shdr, &data) == S_ERROR)
3425 return ((Is_desc *)S_ERROR);
3426
3427 data->d_size = size;
3428 shdr->sh_size = (Xword)size;
3429 shdr->sh_flags |= SHF_WRITE;
3430
3431 if (aplist_append(&ofl->ofl_mapdata, isec, AL_CNT_OFL_MAPSECS) == NULL)
3432 return ((Is_desc *)S_ERROR);
3433
3434 return (isec);
3435 }
3436
3437 /*
3438 * Build an additional text section - used to back FUNC symbol definitions
3439 * added with a mapfile.
3440 */
3441 Is_desc *
3442 ld_make_text(Ofl_desc *ofl, size_t size)
3443 {
3444 Shdr *shdr;
3445 Elf_Data *data;
3446 Is_desc *isec;
3447
3448 /*
3449 * Insure the size is sufficient to contain the minimum return
3450 * instruction.
3451 */
3452 if (size < ld_targ.t_nf.nf_size)
3453 size = ld_targ.t_nf.nf_size;
3454
3455 if (new_section(ofl, SHT_PROGBITS, MSG_ORIG(MSG_SCN_TEXT), 0,
3456 &isec, &shdr, &data) == S_ERROR)
3457 return ((Is_desc *)S_ERROR);
3458
3459 data->d_size = size;
3460 shdr->sh_size = (Xword)size;
3461 shdr->sh_flags |= SHF_EXECINSTR;
3462
3463 /*
3464 * Fill the buffer with the appropriate return instruction.
3465 * Note that there is no need to swap bytes on a non-native,
3466 * link, as the data being copied is given in bytes.
3467 */
3468 if ((data->d_buf = libld_calloc(size, 1)) == NULL)
3469 return ((Is_desc *)S_ERROR);
3470 (void) memcpy(data->d_buf, ld_targ.t_nf.nf_template,
3471 ld_targ.t_nf.nf_size);
3472
3473 /*
3474 * If size was larger than required, and the target supplies
3475 * a fill function, use it to fill the balance. If there is no
3476 * fill function, we accept the 0-fill supplied by libld_calloc().
3477 */
3478 if ((ld_targ.t_ff.ff_execfill != NULL) && (size > ld_targ.t_nf.nf_size))
3479 ld_targ.t_ff.ff_execfill(data->d_buf, ld_targ.t_nf.nf_size,
3480 size - ld_targ.t_nf.nf_size);
3481
3482 if (aplist_append(&ofl->ofl_maptext, isec, AL_CNT_OFL_MAPSECS) == NULL)
3483 return ((Is_desc *)S_ERROR);
3484
3485 return (isec);
3486 }
3487
3488 void
3489 ld_comdat_validate(Ofl_desc *ofl, Ifl_desc *ifl)
3490 {
3491 int i;
3492
3493 for (i = 0; i < ifl->ifl_shnum; i++) {
3494 Is_desc *isp = ifl->ifl_isdesc[i];
3495 int types = 0;
3496 char buf[1024] = "";
3497 Group_desc *gr = NULL;
3498
3499 if ((isp == NULL) || (isp->is_flags & FLG_IS_COMDAT) == 0)
3500 continue;
3501
3502 if (isp->is_shdr->sh_type == SHT_SUNW_COMDAT) {
3503 types++;
3504 (void) strlcpy(buf, MSG_ORIG(MSG_STR_SUNW_COMDAT),
3505 sizeof (buf));
3506 }
3507
3508 if (strncmp(MSG_ORIG(MSG_SCN_GNU_LINKONCE), isp->is_name,
3509 MSG_SCN_GNU_LINKONCE_SIZE) == 0) {
3510 types++;
3511 if (types > 1)
3512 (void) strlcat(buf, ", ", sizeof (buf));
3513 (void) strlcat(buf, MSG_ORIG(MSG_SCN_GNU_LINKONCE),
3514 sizeof (buf));
3515 }
3516
3517 if ((isp->is_shdr->sh_flags & SHF_GROUP) &&
3518 ((gr = ld_get_group(ofl, isp)) != NULL) &&
3519 (gr->gd_data[0] & GRP_COMDAT)) {
3520 types++;
3521 if (types > 1)
3522 (void) strlcat(buf, ", ", sizeof (buf));
3523 (void) strlcat(buf, MSG_ORIG(MSG_STR_GROUP),
3524 sizeof (buf));
3525 }
3526
3527 if (types > 1)
3528 ld_eprintf(ofl, ERR_FATAL,
3529 MSG_INTL(MSG_SCN_MULTICOMDAT), ifl->ifl_name,
3530 EC_WORD(isp->is_scnndx), isp->is_name, buf);
3531 }
3532 }