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