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) 1991, 2010, Oracle and/or its affiliates. All rights reserved.
27 * Copyright (c) 2012, Joyent, Inc. All rights reserved.
28 */
29
30 /*
31 * Map file parsing and input section to output segment mapping.
32 */
33 #include <stdio.h>
34 #include <string.h>
35 #include <debug.h>
36 #include "msg.h"
37 #include "_libld.h"
38
39 /*
40 * Each time a section is placed, the function set_addralign()
41 * is called. This function performs:
42 *
43 * - if the section is from an external file, check if this is empty or not.
44 * If not, we know the segment this section will belong needs a program
45 * header. (Of course, the program is needed only if this section falls
46 * into a loadable segment.)
47 * - compute the Least Common Multiplier for setting the segment alignment.
48 */
49 static void
50 set_addralign(Ofl_desc *ofl, Os_desc *osp, Is_desc *isp)
51 {
52 Shdr *shdr = isp->is_shdr;
53
54 /* A discarded section has no influence on the output */
55 if (isp->is_flags & FLG_IS_DISCARD)
56 return;
57
58 /*
59 * If this section has data or will be assigned data
60 * later, mark this segment not-empty.
61 */
62 if ((shdr->sh_size != 0) ||
63 ((isp->is_flags & FLG_IS_EXTERNAL) == 0))
64 osp->os_sgdesc->sg_flags |= FLG_SG_PHREQ;
65
66 if ((ofl->ofl_dtflags_1 & DF_1_NOHDR) &&
67 (osp->os_sgdesc->sg_phdr).p_type != PT_LOAD)
68 return;
69
70 osp->os_sgdesc->sg_align =
71 ld_lcm(osp->os_sgdesc->sg_align, shdr->sh_addralign);
72 }
73
74 /*
75 * Return the first input descriptor for a given output descriptor,
76 * or NULL if there are none.
77 */
78
79 Is_desc *
80 ld_os_first_isdesc(Os_desc *osp)
81 {
82 int i;
83
84 for (i = 0; i < OS_ISD_NUM; i++) {
85 APlist *ap_isdesc = osp->os_isdescs[i];
86
87 if (aplist_nitems(ap_isdesc) > 0)
88 return ((Is_desc *)ap_isdesc->apl_data[0]);
89 }
90
91 return (NULL);
92 }
93
94 /*
95 * Attach an input section to an output section
96 *
97 * entry:
98 * ofl - File descriptor
99 * osp - Output section descriptor
100 * isp - Input section descriptor
101 * mapfile_sort - True (1) if segment supports mapfile specified ordering
102 * of otherwise unordered input sections, and False (0) otherwise.
103 *
104 * exit:
105 * - The input section has been attached to the output section
106 * - If the input section is a candidate for string table merging,
107 * then it is appended to the output section's list of merge
108 * candidates (os_mstridescs).
109 *
110 * On success, returns True (1). On failure, False (0).
111 */
112 static int
113 os_attach_isp(Ofl_desc *ofl, Os_desc *osp, Is_desc *isp, int mapfile_sort)
114 {
115 Aliste init_arritems;
116 int os_isdescs_idx, do_append = 1;
117
118 if ((isp->is_flags & FLG_IS_ORDERED) == 0) {
119 init_arritems = AL_CNT_OS_ISDESCS;
120 os_isdescs_idx = OS_ISD_DEFAULT;
121
122 /*
123 * If section ordering was specified for an unordered section
124 * via the mapfile, then search in the OS_ISD_DEFAULT list
125 * and insert it in the specified position. Ordered sections
126 * are placed in ascending order before unordered sections
127 * (sections with an is_ordndx value of zero).
128 *
129 * If no mapfile ordering was specified, we append it in
130 * the usual way below.
131 */
132 if (mapfile_sort && (isp->is_ordndx > 0)) {
133 APlist *ap_isdesc = osp->os_isdescs[OS_ISD_DEFAULT];
134 Aliste idx2;
135 Is_desc *isp2;
136
137 for (APLIST_TRAVERSE(ap_isdesc, idx2, isp2)) {
138 if (isp2->is_ordndx &&
139 (isp2->is_ordndx <= isp->is_ordndx))
140 continue;
141
142 if (aplist_insert(
143 &osp->os_isdescs[OS_ISD_DEFAULT],
144 isp, init_arritems, idx2) == NULL)
145 return (0);
146 do_append = 0;
147 break;
148 }
149 }
150 } else { /* Ordered section (via shdr flags) */
151 Word shndx;
152
153 /* SHF_ORDERED uses sh_info, SHF_LINK_ORDERED uses sh_link */
154 shndx = (isp->is_shdr->sh_flags & SHF_ORDERED) ?
155 isp->is_shdr->sh_info : isp->is_shdr->sh_link;
156
157 if (shndx == SHN_BEFORE) {
158 init_arritems = AL_CNT_OS_ISDESCS_BA;
159 os_isdescs_idx = OS_ISD_BEFORE;
160 } else if (shndx == SHN_AFTER) {
161 init_arritems = AL_CNT_OS_ISDESCS_BA;
162 os_isdescs_idx = OS_ISD_AFTER;
163 } else {
164 init_arritems = AL_CNT_OS_ISDESCS;
165 os_isdescs_idx = OS_ISD_ORDERED;
166 }
167 }
168
169 /*
170 * If we didn't insert a section into the default list using
171 * mapfile specified ordering above, then append the input
172 * section to the appropriate list.
173 */
174 if (do_append && aplist_append(&(osp->os_isdescs[os_isdescs_idx]),
175 isp, init_arritems) == NULL)
176 return (0);
177 isp->is_osdesc = osp;
178
179 /*
180 * A section can be merged if the following are true:
181 * - The SHF_MERGE|SHF_STRINGS flags must be set
182 * - String table compression must not be disabled (-znocompstrtab)
183 * - Mapfile ordering must not have been used.
184 * - The section must not be ordered via section header flags.
185 * - It must not be the generated section being built to
186 * replace the sections on this list.
187 */
188 if (((isp->is_shdr->sh_flags & (SHF_MERGE | SHF_STRINGS)) !=
189 (SHF_MERGE | SHF_STRINGS)) ||
190 ((ofl->ofl_flags1 & FLG_OF1_NCSTTAB) != 0) ||
191 !do_append ||
192 ((isp->is_flags & (FLG_IS_ORDERED | FLG_IS_GNSTRMRG)) != 0))
193 return (1);
194
195 /*
196 * Skip sections with (sh_entsize > 1) or (sh_addralign > 1).
197 *
198 * sh_entsize:
199 * We are currently only able to merge string tables containing
200 * strings with 1-byte (char) characters. Support for wide
201 * characters will require our string table compression code
202 * to be extended to handle larger character sizes.
203 *
204 * sh_addralign:
205 * Alignments greater than 1 would require our string table
206 * compression code to insert null bytes to move each
207 * string to the required alignment.
208 */
209 if ((isp->is_shdr->sh_entsize > 1) ||
210 (isp->is_shdr->sh_addralign > 1)) {
211 DBG_CALL(Dbg_sec_unsup_strmerge(ofl->ofl_lml, isp));
212 return (1);
213 }
214
215 if (aplist_append(&osp->os_mstrisdescs, isp,
216 AL_CNT_OS_MSTRISDESCS) == NULL)
217 return (0);
218
219 /*
220 * The SHF_MERGE|SHF_STRINGS flags tell us that the program that
221 * created the section intended it to be mergeable. The
222 * FLG_IS_INSTRMRG flag says that we have done validity testing
223 * and decided that it is safe to act on that hint.
224 */
225 isp->is_flags |= FLG_IS_INSTRMRG;
226
227 return (1);
228 }
229
230 /*
231 * Determine whether this input COMDAT section already exists for the associated
232 * output section. If so, then discard this input section. Otherwise, this
233 * must be the first COMDAT section, thus it is kept for future comparisons.
234 */
235 static uintptr_t
236 add_comdat(Ofl_desc *ofl, Os_desc *osp, Is_desc *isp)
237 {
238 Isd_node isd, *isdp;
239 avl_tree_t *avlt;
240 avl_index_t where;
241 Group_desc *gr;
242
243 /*
244 * Sections to which COMDAT groups apply are FLG_IS_COMDAT but are
245 * discarded separately by the group logic so should never be
246 * discarded here.
247 */
248 if ((isp->is_shdr->sh_flags & SHF_GROUP) &&
249 ((gr = ld_get_group(ofl, isp)) != NULL) &&
250 (gr->gd_data[0] & GRP_COMDAT))
251 return (1);
252
253 /*
254 * Create a COMDAT avl tree for this output section if required.
255 */
256 if ((avlt = osp->os_comdats) == NULL) {
257 if ((avlt = libld_calloc(sizeof (avl_tree_t), 1)) == NULL)
258 return (S_ERROR);
259 avl_create(avlt, isdavl_compare, sizeof (Isd_node),
260 SGSOFFSETOF(Isd_node, isd_avl));
261 osp->os_comdats = avlt;
262 }
263
264 /*
265 * A standard COMDAT section uses the section name as search key.
266 */
267 isd.isd_name = isp->is_name;
268 isd.isd_hash = sgs_str_hash(isd.isd_name);
269
270 if ((isdp = avl_find(avlt, &isd, &where)) != NULL) {
271 isp->is_osdesc = osp;
272
273 /*
274 * If this section hasn't already been identified as discarded,
275 * generate a suitable diagnostic.
276 */
277 if ((isp->is_flags & FLG_IS_DISCARD) == 0) {
278 isp->is_flags |= FLG_IS_DISCARD;
279 isp->is_comdatkeep = isdp->isd_isp;
280 DBG_CALL(Dbg_sec_discarded(ofl->ofl_lml, isp,
281 isdp->isd_isp));
282 }
283
284 /*
285 * A discarded section does not require assignment to an output
286 * section. However, if relaxed relocations have been enabled
287 * (either from -z relaxreloc, or asserted with .gnu.linkonce
288 * processing), then this section must still be assigned to an
289 * output section so that the sloppy relocation logic will have
290 * the information necessary to do its work.
291 */
292 return (0);
293 }
294
295 /*
296 * This is a new COMDAT section - so keep it.
297 */
298 if ((isdp = libld_calloc(sizeof (Isd_node), 1)) == NULL)
299 return (S_ERROR);
300
301 isdp->isd_name = isd.isd_name;
302 isdp->isd_hash = isd.isd_hash;
303 isdp->isd_isp = isp;
304
305 avl_insert(avlt, isdp, where);
306 return (1);
307 }
308
309 /*
310 * Determine whether a GNU group COMDAT section name follows the convention
311 *
312 * section-name.symbol-name
313 *
314 * Each section within the input file is compared to see if the full section
315 * name matches the beginning of the COMDAT section, with a following '.'.
316 * A pointer to the symbol name, starting with the '.' is returned so that the
317 * caller can strip off the required section name.
318 */
319 static char *
320 gnu_comdat_sym(Ifl_desc *ifl, Is_desc *gisp)
321 {
322 size_t ndx;
323
324 for (ndx = 1; ndx < ifl->ifl_shnum; ndx++) {
325 Is_desc *isp;
326 size_t ssize;
327
328 if (((isp = ifl->ifl_isdesc[ndx]) == NULL) ||
329 (isp == gisp) || (isp->is_name == NULL))
330 continue;
331
332 /*
333 * It's questionable whether this size should be cached in the
334 * Is_desc. However, this seems an infrequent operation and
335 * adding Is_desc members can escalate memory usage for large
336 * link-edits. For now, size the section name dynamically.
337 */
338 ssize = strlen(isp->is_name);
339 if ((strncmp(isp->is_name, gisp->is_name, ssize) == 0) &&
340 (gisp->is_name[ssize] == '.'))
341 return ((char *)&gisp->is_name[ssize]);
342 }
343 return (NULL);
344 }
345
346 /*
347 * GNU .gnu.linkonce sections follow a naming convention that indicates the
348 * required association with an output section. Determine whether this input
349 * section follows the convention, and if so return the appropriate output
350 * section name.
351 *
352 * .gnu.linkonce.b.* -> .bss
353 * .gnu.linkonce.d.* -> .data
354 * .gnu.linkonce.l.* -> .ldata
355 * .gnu.linkonce.lb.* -> .lbss
356 * .gnu.linkonce.lr.* -> .lrodata
357 * .gnu.linkonce.r.* -> .rodata
358 * .gnu.linkonce.s.* -> .sdata
359 * .gnu.linkonce.s2.* -> .sdata2
360 * .gnu.linkonce.sb.* -> .sbss
361 * .gnu.linkonce.sb2.* -> .sbss2
362 * .gnu.linkonce.t.* -> .text
363 * .gnu.linkonce.tb.* -> .tbss
364 * .gnu.linkonce.td.* -> .tdata
365 * .gnu.linkonce.wi.* -> .debug_info
366 */
367 #define NSTR_CH1(ch) (*(nstr + 1) == (ch))
368 #define NSTR_CH2(ch) (*(nstr + 2) == (ch))
369 #define NSTR_CH3(ch) (*(nstr + 3) == (ch))
370
371 static const char *
372 gnu_linkonce_sec(const char *ostr)
373 {
374 const char *nstr = &ostr[MSG_SCN_GNU_LINKONCE_SIZE];
375
376 switch (*nstr) {
377 case 'b':
378 if (NSTR_CH1('.'))
379 return (MSG_ORIG(MSG_SCN_BSS));
380 break;
381 case 'd':
382 if (NSTR_CH1('.'))
383 return (MSG_ORIG(MSG_SCN_DATA));
384 break;
385 case 'l':
386 if (NSTR_CH1('.'))
387 return (MSG_ORIG(MSG_SCN_LDATA));
388 else if (NSTR_CH1('b') && NSTR_CH2('.'))
389 return (MSG_ORIG(MSG_SCN_LBSS));
390 else if (NSTR_CH1('r') && NSTR_CH2('.'))
391 return (MSG_ORIG(MSG_SCN_LRODATA));
392 break;
393 case 'r':
394 if (NSTR_CH1('.'))
395 return (MSG_ORIG(MSG_SCN_RODATA));
396 break;
397 case 's':
398 if (NSTR_CH1('.'))
399 return (MSG_ORIG(MSG_SCN_SDATA));
400 else if (NSTR_CH1('2') && NSTR_CH2('.'))
401 return (MSG_ORIG(MSG_SCN_SDATA2));
402 else if (NSTR_CH1('b') && NSTR_CH2('.'))
403 return (MSG_ORIG(MSG_SCN_SBSS));
404 else if (NSTR_CH1('b') && NSTR_CH2('2') && NSTR_CH3('.'))
405 return (MSG_ORIG(MSG_SCN_SBSS2));
406 break;
407 case 't':
408 if (NSTR_CH1('.'))
409 return (MSG_ORIG(MSG_SCN_TEXT));
410 else if (NSTR_CH1('b') && NSTR_CH2('.'))
411 return (MSG_ORIG(MSG_SCN_TBSS));
412 else if (NSTR_CH1('d') && NSTR_CH2('.'))
413 return (MSG_ORIG(MSG_SCN_TDATA));
414 break;
415 case 'w':
416 if (NSTR_CH1('i') && NSTR_CH2('.'))
417 return (MSG_ORIG(MSG_SCN_DEBUG_INFO));
418 break;
419 default:
420 break;
421 }
422
423 /*
424 * No special name match found.
425 */
426 return (ostr);
427 }
428 #undef NSTR_CH1
429 #undef NSTR_CH2
430 #undef NSTR_CH3
431
432
433 /*
434 * Initialize a path info buffer for use with ld_place_section().
435 *
436 * entry:
437 * ofl - Output descriptor
438 * ifl - Descriptor for input file, or NULL if there is none.
439 * info - Address of buffer to be initialized.
440 *
441 * exit:
442 * If this is an input file, and if the entrance criteria list
443 * contains at least one criteria that has a non-empty file string
444 * match list (ec_files), then the block pointed at by info is
445 * initialized, and info is returned.
446 *
447 * If there is no input file, and/or no entrance criteria containing
448 * a non-empty ec_files list, then NULL is returned. This is not
449 * an error --- the NULL is simply an optimization, understood by
450 * ld_place_path(), that allows it to skip unnecessary work.
451 */
452 Place_path_info *
453 ld_place_path_info_init(Ofl_desc *ofl, Ifl_desc *ifl, Place_path_info *info)
454 {
455 /*
456 * Return NULL if there is no input file (internally generated section)
457 * or if the entrance criteria list does not contain any items that will
458 * need to be compared to the path (all the ec_files lists are empty).
459 */
460 if ((ifl == NULL) || !(ofl->ofl_flags & FLG_OF_EC_FILES))
461 return (NULL);
462
463 info->ppi_path = ifl->ifl_name;
464 info->ppi_path_len = strlen(info->ppi_path);
465 info->ppi_isar = (ifl->ifl_flags & FLG_IF_EXTRACT) != 0;
466
467 /*
468 * The basename is the final segment of the path, equivalent to
469 * the path itself if there are no '/' delimiters.
470 */
471 info->ppi_bname = strrchr(info->ppi_path, '/');
472 if (info->ppi_bname == NULL)
473 info->ppi_bname = info->ppi_path;
474 else
475 info->ppi_bname++; /* Skip leading '/' */
476 info->ppi_bname_len =
477 info->ppi_path_len - (info->ppi_bname - info->ppi_path);
478
479 /*
480 * For an archive, the object name is the member name, which is
481 * enclosed in () at the end of the name string. Otherwise, it is
482 * the same as the basename.
483 */
484 if (info->ppi_isar) {
485 info->ppi_oname = strrchr(info->ppi_bname, '(');
486 /* There must be an archive member suffix delimited by parens */
487 assert((info->ppi_bname[info->ppi_bname_len - 1] == ')') &&
488 (info->ppi_oname != NULL));
489 info->ppi_oname++; /* skip leading '(' */
490 info->ppi_oname_len = info->ppi_bname_len -
491 (info->ppi_oname - info->ppi_bname + 1);
492 } else {
493 info->ppi_oname = info->ppi_bname;
494 info->ppi_oname_len = info->ppi_bname_len;
495 }
496
497 return (info);
498 }
499
500 /*
501 * Compare an input section path to the file comparison list the given
502 * entrance criteria.
503 *
504 * entry:
505 * path_info - A non-NULL Place_path_info block for the file
506 * containing the input section, initialized by
507 * ld_place_path_info_init()
508 * enp - Entrance criteria with a non-empty ec_files list of file
509 * comparisons to be carried out.
510 *
511 * exit:
512 * Return TRUE if a match is seen, and FALSE otherwise.
513 */
514 static Boolean
515 eval_ec_files(Place_path_info *path_info, Ent_desc *enp)
516 {
517 Aliste idx;
518 Ent_desc_file *edfp;
519 size_t cmp_len;
520 const char *cmp_str;
521
522 for (ALIST_TRAVERSE(enp->ec_files, idx, edfp)) {
523 Word type = edfp->edf_flags & TYP_ECF_MASK;
524
525 /*
526 * Determine the starting character, and # of characters,
527 * from the file path to compare against this entrance criteria
528 * file string.
529 */
530 if (type == TYP_ECF_OBJNAME) {
531 cmp_str = path_info->ppi_oname;
532 cmp_len = path_info->ppi_oname_len;
533 } else {
534 int ar_stat_diff = path_info->ppi_isar !=
535 ((edfp->edf_flags & FLG_ECF_ARMEMBER) != 0);
536
537 /*
538 * If the entrance criteria specifies an archive member
539 * and the file does not, then there can be no match.
540 */
541
542 if (ar_stat_diff && !path_info->ppi_isar)
543 continue;
544
545 if (type == TYP_ECF_PATH) {
546 cmp_str = path_info->ppi_path;
547 cmp_len = path_info->ppi_path_len;
548 } else { /* TYP_ECF_BASENAME */
549 cmp_str = path_info->ppi_bname;
550 cmp_len = path_info->ppi_bname_len;
551 }
552
553 /*
554 * If the entrance criteria does not specify an archive
555 * member and the file does, then a match just requires
556 * the paths (without the archive member) to match.
557 * Reduce the length to not include the ar member or
558 * the '(' that precedes it.
559 */
560 if (ar_stat_diff && path_info->ppi_isar)
561 cmp_len = path_info->ppi_oname - cmp_str - 1;
562 }
563
564 /*
565 * Compare the resulting string to the one from the
566 * entrance criteria.
567 */
568 if ((cmp_len == edfp->edf_name_len) &&
569 (strncmp(edfp->edf_name, cmp_str, cmp_len) == 0))
570 return (TRUE);
571 }
572
573 return (FALSE);
574 }
575
576 /*
577 * Replace the section header for the given input section with a new section
578 * header of the specified type. All values in the replacement header other
579 * than the type retain their previous values.
580 *
581 * entry:
582 * isp - Input section to replace
583 * sh_type - New section type to apply
584 *
585 * exit:
586 * Returns the pointer to the new section header on success, and
587 * NULL for failure.
588 */
589 static Shdr *
590 isp_convert_type(Is_desc *isp, Word sh_type)
591 {
592 Shdr *shdr;
593
594 if ((shdr = libld_malloc(sizeof (Shdr))) == NULL)
595 return (NULL);
596 *shdr = *isp->is_shdr;
597 isp->is_shdr = shdr;
598 shdr->sh_type = sh_type;
599 return (shdr);
600 }
601
602 /*
603 * Issue a fatal warning for the given .eh_frame section, which
604 * cannot be merged with the existing .eh_frame output section.
605 */
606 static void
607 eh_frame_muldef(Ofl_desc *ofl, Is_desc *isp)
608 {
609 Sg_desc *sgp;
610 Is_desc *isp1;
611 Os_desc *osp;
612 Aliste idx1, idx2, idx3;
613
614 /*
615 * Locate the .eh_frame output section, and use the first section
616 * assigned to it in the error message. The user can then compare
617 * the two sections to determine what attribute prevented the merge.
618 */
619 for (APLIST_TRAVERSE(ofl->ofl_segs, idx1, sgp)) {
620 for (APLIST_TRAVERSE(sgp->sg_osdescs, idx2, osp)) {
621 if ((osp->os_flags & FLG_OS_EHFRAME) == 0)
622 continue;
623
624 for (idx3 = 0; idx3 < OS_ISD_NUM; idx3++) {
625 APlist *lst = osp->os_isdescs[idx3];
626
627 if (aplist_nitems(lst) == 0)
628 continue;
629
630 isp1 = lst->apl_data[0];
631 ld_eprintf(ofl, ERR_FATAL,
632 MSG_INTL(MSG_UPD_MULEHFRAME),
633 isp1->is_file->ifl_name,
634 EC_WORD(isp1->is_scnndx), isp1->is_name,
635 isp->is_file->ifl_name,
636 EC_WORD(isp->is_scnndx), isp->is_name);
637 return;
638 }
639 }
640 }
641 }
642
643 /*
644 * Place a section into the appropriate segment and output section.
645 *
646 * entry:
647 * ofl - File descriptor
648 * isp - Input section descriptor of section to be placed.
649 * path_info - NULL, or pointer to Place_path_info buffer initialized
650 * by ld_place_path_info_init() for the file associated to isp,
651 * for use in processing entrance criteria with non-empty
652 * file matching string list (ec_files)
653 * ident - Section identifier, used to order sections relative to
654 * others within the output segment.
655 * alt_os_name - If non-NULL, the name of the output section to place
656 * isp into. If NULL, input sections go to an output section
657 * with the same name as the input section.
658 */
659 Os_desc *
660 ld_place_section(Ofl_desc *ofl, Is_desc *isp, Place_path_info *path_info,
661 int ident, const char *alt_os_name)
662 {
663 Ent_desc *enp;
664 Sg_desc *sgp;
665 Os_desc *osp;
666 Aliste idx1, iidx;
667 int os_ndx;
668 Shdr *shdr = isp->is_shdr;
669 Xword shflagmask, shflags = shdr->sh_flags;
670 Ifl_desc *ifl = isp->is_file;
671 char *oname, *sname;
672 uint_t onamehash;
673 Boolean is_ehframe = (isp->is_flags & FLG_IS_EHFRAME) != 0;
674
675 /*
676 * Define any sections that must be thought of as referenced. These
677 * sections may not be referenced externally in a manner ld(1) can
678 * discover, but they must be retained (ie. not removed by -zignore).
679 */
680 static const Msg RefSecs[] = {
681 MSG_SCN_INIT, /* MSG_ORIG(MSG_SCN_INIT) */
682 MSG_SCN_FINI, /* MSG_ORIG(MSG_SCN_FINI) */
683 MSG_SCN_EX_RANGES, /* MSG_ORIG(MSG_SCN_EX_RANGES) */
684 MSG_SCN_EX_SHARED, /* MSG_ORIG(MSG_SCN_EX_SHARED) */
685 MSG_SCN_CTORS, /* MSG_ORIG(MSG_SCN_CTORS) */
686 MSG_SCN_DTORS, /* MSG_ORIG(MSG_SCN_DTORS) */
687 MSG_SCN_EHFRAME, /* MSG_ORIG(MSG_SCN_EHFRAME) */
688 MSG_SCN_EHFRAME_HDR, /* MSG_ORIG(MSG_SCN_EHFRAME_HDR) */
689 MSG_SCN_JCR, /* MSG_ORIG(MSG_SCN_JCR) */
690 0
691 };
692
693 DBG_CALL(Dbg_sec_in(ofl->ofl_lml, isp));
694
695 /*
696 * If this section identifies group members, or this section indicates
697 * that it is a member of a group, determine whether the section is
698 * still required.
699 */
700 if ((shflags & SHF_GROUP) || (shdr->sh_type == SHT_GROUP)) {
701 Group_desc *gdesc;
702
703 if ((gdesc = ld_get_group(ofl, isp)) != NULL) {
704 DBG_CALL(Dbg_sec_group(ofl->ofl_lml, isp, gdesc));
705
706 /*
707 * If this group has been replaced by another group,
708 * then this section needs to be discarded.
709 */
710 if (gdesc->gd_oisc) {
711 isp->is_flags |= FLG_IS_DISCARD;
712
713 /*
714 * Since we're discarding the section, we
715 * can skip assigning it to an output section.
716 * The exception is that if the user
717 * specifies -z relaxreloc, then
718 * we need to assign the output section so
719 * that the sloppy relocation logic will have
720 * the information necessary to do its work.
721 */
722 if (!(ofl->ofl_flags1 & FLG_OF1_RLXREL))
723 return (NULL);
724 }
725 }
726
727 /*
728 * SHT_GROUP sections can only be included into relocatable
729 * objects.
730 */
731 if (shdr->sh_type == SHT_GROUP) {
732 if ((ofl->ofl_flags & FLG_OF_RELOBJ) == 0) {
733 isp->is_flags |= FLG_IS_DISCARD;
734 return (NULL);
735 }
736 }
737 }
738
739 /*
740 * Always assign SHF_TLS sections to the DATA segment (and then the
741 * PT_TLS embedded inside of there).
742 */
743 if (shflags & SHF_TLS)
744 shflags |= SHF_WRITE;
745
746 /*
747 * Traverse the entrance criteria list searching for a segment that
748 * matches the input section we have. If an entrance criterion is set
749 * then there must be an exact match. If we complete the loop without
750 * finding a segment, then sgp will be NULL.
751 */
752 sgp = NULL;
753 for (APLIST_TRAVERSE(ofl->ofl_ents, idx1, enp)) {
754
755 /* Disabled segments are not available for assignment */
756 if (enp->ec_segment->sg_flags & FLG_SG_DISABLED)
757 continue;
758
759 /*
760 * If an entrance criteria doesn't have any of its fields
761 * set, it will match any section it is tested against.
762 * We set the FLG_EC_CATCHALL flag on these, primarily because
763 * it helps readers of our debug output to understand what
764 * the criteria means --- otherwise the user would just see
765 * that every field is 0, but might not understand the
766 * significance of that.
767 *
768 * Given that we set this flag, we can use it here as an
769 * optimization to short circuit all of the tests in this
770 * loop. Note however, that if we did not do this, the end
771 * result would be the same --- the empty criteria will sail
772 * past the following tests and reach the end of the loop.
773 */
774 if (enp->ec_flags & FLG_EC_CATCHALL) {
775 sgp = enp->ec_segment;
776 break;
777 }
778
779 if (enp->ec_type && (enp->ec_type != shdr->sh_type))
780 continue;
781 if (enp->ec_attrmask &&
782 /* LINTED */
783 (enp->ec_attrmask & enp->ec_attrbits) !=
784 (enp->ec_attrmask & shflags))
785 continue;
786 if (enp->ec_is_name &&
787 (strcmp(enp->ec_is_name, isp->is_name) != 0))
788 continue;
789
790 if ((alist_nitems(enp->ec_files) > 0) &&
791 ((path_info == NULL) || !eval_ec_files(path_info, enp)))
792 continue;
793
794 /* All entrance criteria tests passed */
795 sgp = enp->ec_segment;
796 break;
797 }
798
799 /*
800 * The final entrance criteria record is a FLG_EC_CATCHALL that points
801 * at the final predefined segment "extra", and this final segment is
802 * tagged FLG_SG_NODISABLE. Therefore, the above loop must always find
803 * a segment.
804 */
805 assert(sgp != NULL);
806
807 /*
808 * Transfer the input section sorting key from the entrance criteria
809 * to the input section. A non-zero value means that the section
810 * will be sorted on this key amoung the other sections that have a
811 * non-zero key. These sorted sections are collectively placed at the
812 * head of the output section.
813 *
814 * If the sort key is 0, the section is placed after the sorted
815 * sections in the order they are encountered.
816 */
817 isp->is_ordndx = enp->ec_ordndx;
818
819 /* Remember that this entrance criteria has placed a section */
820 enp->ec_flags |= FLG_EC_USED;
821
822 /*
823 * If our caller has supplied an alternative name for the output
824 * section, then we defer to their request. Otherwise, the default
825 * is to use the same name as that of the input section being placed.
826 *
827 * The COMDAT, SHT_GROUP and GNU name translations that follow have
828 * the potential to alter this initial name.
829 */
830 oname = (char *)((alt_os_name == NULL) ? isp->is_name : alt_os_name);
831
832 /*
833 * Solaris section names may follow the convention:
834 *
835 * section-name%symbol-name
836 *
837 * This convention has been used to order the layout of sections within
838 * segments for objects built with the compilers -xF option. However,
839 * the final object should not contain individual section headers for
840 * all such input sections, instead the symbol name is stripped from the
841 * name to establish the final output section name.
842 *
843 * This convention has also been followed for COMDAT and sections
844 * identified though SHT_GROUP data.
845 *
846 * Strip out the % from the section name for:
847 * - Non-relocatable objects
848 * - Relocatable objects if input section sorting is
849 * in force for the segment in question.
850 */
851 if (((ofl->ofl_flags & FLG_OF_RELOBJ) == 0) ||
852 (sgp->sg_flags & FLG_SG_IS_ORDER)) {
853 if ((sname = strchr(isp->is_name, '%')) != NULL) {
854 size_t size = sname - isp->is_name;
855
856 if ((oname = libld_malloc(size + 1)) == NULL)
857 return ((Os_desc *)S_ERROR);
858 (void) strncpy(oname, isp->is_name, size);
859 oname[size] = '\0';
860 DBG_CALL(Dbg_sec_redirected(ofl->ofl_lml, isp, oname));
861 }
862 }
863
864 /*
865 * When building relocatable objects, we must not redirect COMDAT
866 * section names into their outputs, such that our output object may
867 * be successfully used as an input object also requiring COMDAT
868 * processing
869 */
870
871 /*
872 * GNU section names may follow the convention:
873 *
874 * .gnu.linkonce.*
875 *
876 * The .gnu.linkonce is a section naming convention that indicates a
877 * COMDAT requirement. Determine whether this section follows the GNU
878 * pattern, and if so, determine whether this section should be
879 * discarded or retained. The comparison of is_name[1] with 'g'
880 * is an optimization to skip using strncmp() too much. This is safe,
881 * because we know the name is not NULL, and therefore must have
882 * at least one character plus a NULL termination.
883 */
884 if ((isp->is_name == oname) && (isp->is_name[1] == 'g') &&
885 (strncmp(MSG_ORIG(MSG_SCN_GNU_LINKONCE), isp->is_name,
886 MSG_SCN_GNU_LINKONCE_SIZE) == 0)) {
887 if ((ofl->ofl_flags & FLG_OF_RELOBJ) == 0) {
888 if ((oname = (char *)gnu_linkonce_sec(isp->is_name)) !=
889 isp->is_name) {
890 DBG_CALL(Dbg_sec_redirected(ofl->ofl_lml, isp,
891 oname));
892 }
893 }
894
895 /*
896 * Explicitly identify this section type as COMDAT. Also,
897 * enable relaxed relocation processing, as this is typically
898 * a requirement with .gnu.linkonce sections.
899 */
900 isp->is_flags |= FLG_IS_COMDAT;
901 if ((ofl->ofl_flags1 & FLG_OF1_NRLXREL) == 0)
902 ofl->ofl_flags1 |= FLG_OF1_RLXREL;
903 DBG_CALL(Dbg_sec_gnu_comdat(ofl->ofl_lml, isp, TRUE,
904 (ofl->ofl_flags1 & FLG_OF1_RLXREL) != 0));
905 }
906
907 /*
908 * GNU section names may also follow the convention:
909 *
910 * section-name.symbol-name
911 *
912 * This convention is used when defining SHT_GROUP sections of type
913 * COMDAT. Thus, any group processing will have discovered any group
914 * sections, and this identification can be triggered by a pattern
915 * match section names.
916 */
917 if ((isp->is_name == oname) && (isp->is_flags & FLG_IS_COMDAT) &&
918 ((sname = gnu_comdat_sym(ifl, isp)) != NULL)) {
919 size_t size = sname - isp->is_name;
920
921 if ((ofl->ofl_flags & FLG_OF_RELOBJ) == 0) {
922 if ((oname = libld_malloc(size + 1)) == NULL)
923 return ((Os_desc *)S_ERROR);
924 (void) strncpy(oname, isp->is_name, size);
925 oname[size] = '\0';
926 DBG_CALL(Dbg_sec_redirected(ofl->ofl_lml, isp, oname));
927 }
928
929 /*
930 * Enable relaxed relocation processing, as this is
931 * typically a requirement with GNU COMDAT sections.
932 */
933 if ((ofl->ofl_flags1 & FLG_OF1_NRLXREL) == 0) {
934 ofl->ofl_flags1 |= FLG_OF1_RLXREL;
935 DBG_CALL(Dbg_sec_gnu_comdat(ofl->ofl_lml, isp,
936 FALSE, TRUE));
937 }
938 }
939
940 /*
941 * Assign a hash value now that the output section name has been
942 * finalized.
943 */
944 onamehash = sgs_str_hash(oname);
945
946 /*
947 * Determine if output section ordering is turned on. If so, return
948 * the appropriate ordering index for the section. This information
949 * is derived from the Sg_desc->sg_os_order list that was built
950 * up from the Mapfile.
951 *
952 * A value of 0 for os_ndx means that the section is not sorted
953 * (i.e. is not found in the sg_os_order). The items in sg_os_order
954 * are in the desired sort order, so adding 1 to their alist index
955 * gives a suitable index for sorting.
956 */
957 os_ndx = 0;
958 if (alist_nitems(sgp->sg_os_order) > 0) {
959 Sec_order *scop;
960
961 for (ALIST_TRAVERSE(sgp->sg_os_order, idx1, scop)) {
962 if (strcmp(scop->sco_secname, oname) == 0) {
963 scop->sco_flags |= FLG_SGO_USED;
964 os_ndx = idx1 + 1;
965 break;
966 }
967 }
968 }
969
970 /*
971 * Mask of section header flags to ignore when matching sections. We
972 * are more strict with relocatable objects, ignoring only the order
973 * flags, and keeping sections apart if they differ otherwise. This
974 * follows the policy that sections in a relative object should only
975 * be merged if their flags are the same, and avoids destroying
976 * information prematurely. For final products however, we ignore all
977 * flags that do not prevent a merge.
978 */
979 shflagmask =
980 (ofl->ofl_flags & FLG_OF_RELOBJ) ? ALL_SHF_ORDER : ALL_SHF_IGNORE;
981
982 /*
983 * Traverse the input section list for the output section we have been
984 * assigned. If we find a matching section simply add this new section.
985 */
986 iidx = 0;
987 for (APLIST_TRAVERSE(sgp->sg_osdescs, idx1, osp)) {
988 Shdr *os_shdr = osp->os_shdr;
989
990 /*
991 * An input section matches an output section if:
992 * - The ident values match
993 * - The names match
994 * - Not a GROUP section
995 * - Not a DTrace dof section
996 * - Section types match
997 * - Matching section flags, after screening out the
998 * shflagmask flags.
999 *
1000 * Section types are considered to match if any one of
1001 * the following are true:
1002 * - The type codes are the same
1003 * - Both are .eh_frame sections (regardless of type code)
1004 * - The input section is COMDAT, and the output section
1005 * is SHT_PROGBITS.
1006 */
1007 if ((ident == osp->os_identndx) &&
1008 (ident != ld_targ.t_id.id_rel) &&
1009 (onamehash == osp->os_namehash) &&
1010 (shdr->sh_type != SHT_GROUP) &&
1011 (shdr->sh_type != SHT_SUNW_dof) &&
1012 ((shdr->sh_type == os_shdr->sh_type) ||
1013 (is_ehframe && (osp->os_flags & FLG_OS_EHFRAME)) ||
1014 ((shdr->sh_type == SHT_SUNW_COMDAT) &&
1015 (os_shdr->sh_type == SHT_PROGBITS))) &&
1016 ((shflags & ~shflagmask) ==
1017 (os_shdr->sh_flags & ~shflagmask)) &&
1018 (strcmp(oname, osp->os_name) == 0)) {
1019 uintptr_t err;
1020
1021 /*
1022 * Process any COMDAT section, keeping the first and
1023 * discarding all others.
1024 */
1025 if ((isp->is_flags & FLG_IS_COMDAT) &&
1026 ((err = add_comdat(ofl, osp, isp)) != 1))
1027 return ((Os_desc *)err);
1028
1029 /*
1030 * Set alignment
1031 */
1032 set_addralign(ofl, osp, isp);
1033
1034 /*
1035 * If this section is a non-empty TLS section indicate
1036 * that a PT_TLS program header is required.
1037 */
1038 if ((shflags & SHF_TLS) && shdr->sh_size &&
1039 ((ofl->ofl_flags & FLG_OF_RELOBJ) == 0))
1040 ofl->ofl_flags |= FLG_OF_TLSPHDR;
1041
1042 /*
1043 * Insert the input section descriptor on the proper
1044 * output section descriptor list.
1045 *
1046 * If this segment requires input section ordering,
1047 * honor any mapfile specified ordering for otherwise
1048 * unordered sections by setting the mapfile_sort
1049 * argument of os_attach_isp() to True.
1050 */
1051
1052 if (os_attach_isp(ofl, osp, isp,
1053 (sgp->sg_flags & FLG_SG_IS_ORDER) != 0) == 0)
1054 return ((Os_desc *)S_ERROR);
1055
1056 /*
1057 * If this input section and file is associated to an
1058 * artificially referenced output section, make sure
1059 * they are marked as referenced also. This ensures
1060 * that this input section and file isn't eliminated
1061 * when -zignore is in effect.
1062 *
1063 * See -zignore comments when creating a new output
1064 * section below.
1065 */
1066 if (((ifl &&
1067 (ifl->ifl_flags & FLG_IF_IGNORE)) || DBG_ENABLED) &&
1068 (osp->os_flags & FLG_OS_SECTREF)) {
1069 isp->is_flags |= FLG_IS_SECTREF;
1070 if (ifl)
1071 ifl->ifl_flags |= FLG_IF_FILEREF;
1072 }
1073
1074 DBG_CALL(Dbg_sec_added(ofl->ofl_lml, osp, sgp));
1075 return (osp);
1076 }
1077
1078 /*
1079 * Do we need to worry about section ordering?
1080 */
1081 if (os_ndx) {
1082 if (osp->os_ordndx) {
1083 if (os_ndx < osp->os_ordndx)
1084 /* insert section here. */
1085 break;
1086 else {
1087 iidx = idx1 + 1;
1088 continue;
1089 }
1090 } else {
1091 /* insert section here. */
1092 break;
1093 }
1094 } else if (osp->os_ordndx) {
1095 iidx = idx1 + 1;
1096 continue;
1097 }
1098
1099 /*
1100 * If the new sections identifier is less than that of the
1101 * present input section we need to insert the new section
1102 * at this point.
1103 */
1104 if (ident < osp->os_identndx)
1105 break;
1106
1107 iidx = idx1 + 1;
1108 }
1109
1110 /*
1111 * We are adding a new output section. Update the section header
1112 * count and associated string size.
1113 *
1114 * If the input section triggering this output section has been marked
1115 * for discard, and if no other non-discarded input section comes along
1116 * to join it, then we will over count. We cannot know if this will
1117 * happen or not until all input is seen. Set FLG_OF_AJDOSCNT to
1118 * trigger a final count readjustment.
1119 */
1120 if (isp->is_flags & FLG_IS_DISCARD)
1121 ofl->ofl_flags |= FLG_OF_ADJOSCNT;
1122 ofl->ofl_shdrcnt++;
1123 if (st_insert(ofl->ofl_shdrsttab, oname) == -1)
1124 return ((Os_desc *)S_ERROR);
1125
1126 /*
1127 * Create a new output section descriptor.
1128 */
1129 if ((osp = libld_calloc(sizeof (Os_desc), 1)) == NULL)
1130 return ((Os_desc *)S_ERROR);
1131 if ((osp->os_shdr = libld_calloc(sizeof (Shdr), 1)) == NULL)
1132 return ((Os_desc *)S_ERROR);
1133
1134 /*
1135 * Convert COMDAT section to PROGBITS as this the first section of the
1136 * output section. Save any COMDAT section for later processing, as
1137 * additional COMDAT sections that match this section need discarding.
1138 */
1139 if ((shdr->sh_type == SHT_SUNW_COMDAT) &&
1140 ((shdr = isp_convert_type(isp, SHT_PROGBITS)) == NULL))
1141 return ((Os_desc *)S_ERROR);
1142 if ((isp->is_flags & FLG_IS_COMDAT) &&
1143 (add_comdat(ofl, osp, isp) == S_ERROR))
1144 return ((Os_desc *)S_ERROR);
1145
1146 if (is_ehframe) {
1147 /*
1148 * Executable or sharable objects can have at most a single
1149 * .eh_frame section. Detect attempts to create more than
1150 * one. This occurs if the input sections have incompatible
1151 * attributes.
1152 */
1153 if ((ofl->ofl_flags & FLG_OF_EHFRAME) &&
1154 !(ofl->ofl_flags & FLG_OF_RELOBJ)) {
1155 eh_frame_muldef(ofl, isp);
1156 return ((Os_desc *)S_ERROR);
1157 }
1158 ofl->ofl_flags |= FLG_OF_EHFRAME;
1159
1160 /*
1161 * For .eh_frame sections, we always set the type to be the
1162 * type specified by the ABI. This allows .eh_frame sections
1163 * of type SHT_PROGBITS to be correctly merged with .eh_frame
1164 * sections of the ABI-defined type (e.g. SHT_AMD64_UNWIND),
1165 * with the output being of the ABI-defined type.
1166 */
1167 osp->os_shdr->sh_type = ld_targ.t_m.m_sht_unwind;
1168 } else {
1169 osp->os_shdr->sh_type = shdr->sh_type;
1170 }
1171
1172 osp->os_shdr->sh_flags = shdr->sh_flags;
1173 osp->os_shdr->sh_entsize = shdr->sh_entsize;
1174 osp->os_name = oname;
1175 osp->os_namehash = onamehash;
1176 osp->os_ordndx = os_ndx;
1177 osp->os_sgdesc = sgp;
1178 if (is_ehframe)
1179 osp->os_flags |= FLG_OS_EHFRAME;
1180
1181 if (ifl && (shdr->sh_type == SHT_PROGBITS)) {
1182 /*
1183 * Try to preserve the intended meaning of sh_link/sh_info.
1184 * See the translate_link() in update.c.
1185 */
1186 osp->os_shdr->sh_link = shdr->sh_link;
1187 if (shdr->sh_flags & SHF_INFO_LINK)
1188 osp->os_shdr->sh_info = shdr->sh_info;
1189 }
1190
1191 /*
1192 * When -zignore is in effect, user supplied sections and files that are
1193 * not referenced from other sections, are eliminated from the object
1194 * being produced. Some sections, although unreferenced, are special,
1195 * and must not be eliminated. Determine if this new output section is
1196 * one of those special sections, and if so mark it artificially as
1197 * referenced. Any input section and file associated to this output
1198 * section is also be marked as referenced, and thus won't be eliminated
1199 * from the final output.
1200 */
1201 if (ifl && ((ofl->ofl_flags1 & FLG_OF1_IGNPRC) || DBG_ENABLED)) {
1202 const Msg *refsec;
1203
1204 for (refsec = RefSecs; *refsec; refsec++) {
1205 if (strcmp(osp->os_name, MSG_ORIG(*refsec)) == 0) {
1206 osp->os_flags |= FLG_OS_SECTREF;
1207
1208 if ((ifl->ifl_flags & FLG_IF_IGNORE) ||
1209 DBG_ENABLED) {
1210 isp->is_flags |= FLG_IS_SECTREF;
1211 ifl->ifl_flags |= FLG_IF_FILEREF;
1212 }
1213 break;
1214 }
1215 }
1216 }
1217
1218 /*
1219 * Sections of type SHT_GROUP are added to the ofl->ofl_osgroups list,
1220 * so that they can be updated as a group later.
1221 */
1222 if ((shdr->sh_type == SHT_GROUP) &&
1223 ((isp->is_flags & FLG_IS_DISCARD) == 0) &&
1224 (aplist_append(&ofl->ofl_osgroups, osp,
1225 AL_CNT_OFL_OSGROUPS) == NULL))
1226 return ((Os_desc *)S_ERROR);
1227
1228 /*
1229 * If this section is a non-empty TLS section indicate that a PT_TLS
1230 * program header is required.
1231 */
1232 if ((shflags & SHF_TLS) && shdr->sh_size &&
1233 ((ofl->ofl_flags & FLG_OF_RELOBJ) == 0))
1234 ofl->ofl_flags |= FLG_OF_TLSPHDR;
1235
1236 /*
1237 * If a non-allocatable section is going to be put into a loadable
1238 * segment then turn on the allocate bit for this section and warn the
1239 * user that we have done so. This could only happen through the use
1240 * of a mapfile.
1241 */
1242 if ((sgp->sg_phdr.p_type == PT_LOAD) &&
1243 ((osp->os_shdr->sh_flags & SHF_ALLOC) == 0)) {
1244 ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_SCN_NONALLOC),
1245 ofl->ofl_name, osp->os_name, sgp->sg_name);
1246 osp->os_shdr->sh_flags |= SHF_ALLOC;
1247 }
1248
1249 /*
1250 * Retain this sections identifier for future comparisons when placing
1251 * a section (after all sections have been processed this variable will
1252 * be used to hold the sections symbol index as we don't need to retain
1253 * the identifier any more).
1254 */
1255 osp->os_identndx = ident;
1256
1257 /*
1258 * Set alignment.
1259 */
1260 set_addralign(ofl, osp, isp);
1261
1262 if (os_attach_isp(ofl, osp, isp, 0) == 0)
1263 return ((Os_desc *)S_ERROR);
1264
1265 DBG_CALL(Dbg_sec_created(ofl->ofl_lml, osp, sgp));
1266
1267 /*
1268 * Insert the new section at the offset given by iidx. If no position
1269 * for it was identified above, this will be index 0, causing the new
1270 * section to be prepended to the beginning of the section list.
1271 * Otherwise, it is the index following the section that was identified.
1272 */
1273 if (aplist_insert(&sgp->sg_osdescs, osp, AL_CNT_SG_OSDESC,
1274 iidx) == NULL)
1275 return ((Os_desc *)S_ERROR);
1276 return (osp);
1277 }