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.
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.
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]
23 * Copyright (c) 1988 AT&T
26 * Copyright (c) 1991, 2010, Oracle and/or its affiliates. All rights reserved.
27 * Copyright (c) 2012, Joyent, Inc. All rights reserved.
31 * Map file parsing and input section to output segment mapping.
40 * Each time a section is placed, the function set_addralign()
41 * is called. This function performs:
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.
50 set_addralign(Ofl_desc
*ofl
, Os_desc
*osp
, Is_desc
*isp
)
52 Shdr
*shdr
= isp
->is_shdr
;
54 /* A discarded section has no influence on the output */
55 if (isp
->is_flags
& FLG_IS_DISCARD
)
59 * If this section has data or will be assigned data
60 * later, mark this segment not-empty.
62 if ((shdr
->sh_size
!= 0) ||
63 ((isp
->is_flags
& FLG_IS_EXTERNAL
) == 0))
64 osp
->os_sgdesc
->sg_flags
|= FLG_SG_PHREQ
;
66 if ((ofl
->ofl_dtflags_1
& DF_1_NOHDR
) &&
67 (osp
->os_sgdesc
->sg_phdr
).p_type
!= PT_LOAD
)
70 osp
->os_sgdesc
->sg_align
=
71 ld_lcm(osp
->os_sgdesc
->sg_align
, shdr
->sh_addralign
);
75 * Return the first input descriptor for a given output descriptor,
76 * or NULL if there are none.
80 ld_os_first_isdesc(Os_desc
*osp
)
84 for (i
= 0; i
< OS_ISD_NUM
; i
++) {
85 APlist
*ap_isdesc
= osp
->os_isdescs
[i
];
87 if (aplist_nitems(ap_isdesc
) > 0)
88 return ((Is_desc
*)ap_isdesc
->apl_data
[0]);
95 * Attach an input section to an output section
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.
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).
110 * On success, returns True (1). On failure, False (0).
113 os_attach_isp(Ofl_desc
*ofl
, Os_desc
*osp
, Is_desc
*isp
, int mapfile_sort
)
115 Aliste init_arritems
;
116 int os_isdescs_idx
, do_append
= 1;
118 if ((isp
->is_flags
& FLG_IS_ORDERED
) == 0) {
119 init_arritems
= AL_CNT_OS_ISDESCS
;
120 os_isdescs_idx
= OS_ISD_DEFAULT
;
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).
129 * If no mapfile ordering was specified, we append it in
130 * the usual way below.
132 if (mapfile_sort
&& (isp
->is_ordndx
> 0)) {
133 APlist
*ap_isdesc
= osp
->os_isdescs
[OS_ISD_DEFAULT
];
137 for (APLIST_TRAVERSE(ap_isdesc
, idx2
, isp2
)) {
138 if (isp2
->is_ordndx
&&
139 (isp2
->is_ordndx
<= isp
->is_ordndx
))
143 &osp
->os_isdescs
[OS_ISD_DEFAULT
],
144 isp
, init_arritems
, idx2
) == NULL
)
150 } else { /* Ordered section (via shdr flags) */
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
;
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
;
164 init_arritems
= AL_CNT_OS_ISDESCS
;
165 os_isdescs_idx
= OS_ISD_ORDERED
;
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.
174 if (do_append
&& aplist_append(&(osp
->os_isdescs
[os_isdescs_idx
]),
175 isp
, init_arritems
) == NULL
)
177 isp
->is_osdesc
= osp
;
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.
188 if (((isp
->is_shdr
->sh_flags
& (SHF_MERGE
| SHF_STRINGS
)) !=
189 (SHF_MERGE
| SHF_STRINGS
)) ||
190 ((ofl
->ofl_flags1
& FLG_OF1_NCSTTAB
) != 0) ||
192 ((isp
->is_flags
& (FLG_IS_ORDERED
| FLG_IS_GNSTRMRG
)) != 0))
196 * Skip sections with (sh_entsize > 1) or (sh_addralign > 1).
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.
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.
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
));
215 if (aplist_append(&osp
->os_mstrisdescs
, isp
,
216 AL_CNT_OS_MSTRISDESCS
) == NULL
)
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.
225 isp
->is_flags
|= FLG_IS_INSTRMRG
;
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.
236 add_comdat(Ofl_desc
*ofl
, Os_desc
*osp
, Is_desc
*isp
)
243 * Create a COMDAT avl tree for this output section if required.
245 if ((avlt
= osp
->os_comdats
) == NULL
) {
246 if ((avlt
= libld_calloc(sizeof (avl_tree_t
), 1)) == NULL
)
248 avl_create(avlt
, isdavl_compare
, sizeof (Isd_node
),
249 SGSOFFSETOF(Isd_node
, isd_avl
));
250 osp
->os_comdats
= avlt
;
254 * A standard COMDAT section uses the section name as search key.
256 isd
.isd_name
= isp
->is_name
;
257 isd
.isd_hash
= sgs_str_hash(isd
.isd_name
);
259 if ((isdp
= avl_find(avlt
, &isd
, &where
)) != NULL
) {
260 isp
->is_osdesc
= osp
;
263 * If this section hasn't already been identified as discarded,
264 * generate a suitable diagnostic.
266 if ((isp
->is_flags
& FLG_IS_DISCARD
) == 0) {
267 isp
->is_flags
|= FLG_IS_DISCARD
;
268 isp
->is_comdatkeep
= isdp
->isd_isp
;
269 DBG_CALL(Dbg_sec_discarded(ofl
->ofl_lml
, isp
,
274 * A discarded section does not require assignment to an output
275 * section. However, if relaxed relocations have been enabled
276 * (either from -z relaxreloc, or asserted with .gnu.linkonce
277 * processing), then this section must still be assigned to an
278 * output section so that the sloppy relocation logic will have
279 * the information necessary to do its work.
285 * This is a new COMDAT section - so keep it.
287 if ((isdp
= libld_calloc(sizeof (Isd_node
), 1)) == NULL
)
290 isdp
->isd_name
= isd
.isd_name
;
291 isdp
->isd_hash
= isd
.isd_hash
;
294 avl_insert(avlt
, isdp
, where
);
299 * Determine whether a GNU group COMDAT section name follows the convention
301 * section-name.symbol-name
303 * Each section within the input file is compared to see if the full section
304 * name matches the beginning of the COMDAT section, with a following '.'.
305 * A pointer to the symbol name, starting with the '.' is returned so that the
306 * caller can strip off the required section name.
309 gnu_comdat_sym(Ifl_desc
*ifl
, Is_desc
*gisp
)
313 for (ndx
= 1; ndx
< ifl
->ifl_shnum
; ndx
++) {
317 if (((isp
= ifl
->ifl_isdesc
[ndx
]) == NULL
) ||
318 (isp
== gisp
) || (isp
->is_name
== NULL
))
322 * It's questionable whether this size should be cached in the
323 * Is_desc. However, this seems an infrequent operation and
324 * adding Is_desc members can escalate memory usage for large
325 * link-edits. For now, size the section name dynamically.
327 ssize
= strlen(isp
->is_name
);
328 if ((strncmp(isp
->is_name
, gisp
->is_name
, ssize
) == 0) &&
329 (gisp
->is_name
[ssize
] == '.'))
330 return ((char *)&gisp
->is_name
[ssize
]);
336 * GNU .gnu.linkonce sections follow a naming convention that indicates the
337 * required association with an output section. Determine whether this input
338 * section follows the convention, and if so return the appropriate output
341 * .gnu.linkonce.b.* -> .bss
342 * .gnu.linkonce.d.* -> .data
343 * .gnu.linkonce.l.* -> .ldata
344 * .gnu.linkonce.lb.* -> .lbss
345 * .gnu.linkonce.lr.* -> .lrodata
346 * .gnu.linkonce.r.* -> .rodata
347 * .gnu.linkonce.s.* -> .sdata
348 * .gnu.linkonce.s2.* -> .sdata2
349 * .gnu.linkonce.sb.* -> .sbss
350 * .gnu.linkonce.sb2.* -> .sbss2
351 * .gnu.linkonce.t.* -> .text
352 * .gnu.linkonce.tb.* -> .tbss
353 * .gnu.linkonce.td.* -> .tdata
354 * .gnu.linkonce.wi.* -> .debug_info
356 #define NSTR_CH1(ch) (*(nstr + 1) == (ch))
357 #define NSTR_CH2(ch) (*(nstr + 2) == (ch))
358 #define NSTR_CH3(ch) (*(nstr + 3) == (ch))
361 gnu_linkonce_sec(const char *ostr
)
363 const char *nstr
= &ostr
[MSG_SCN_GNU_LINKONCE_SIZE
];
368 return (MSG_ORIG(MSG_SCN_BSS
));
372 return (MSG_ORIG(MSG_SCN_DATA
));
376 return (MSG_ORIG(MSG_SCN_LDATA
));
377 else if (NSTR_CH1('b') && NSTR_CH2('.'))
378 return (MSG_ORIG(MSG_SCN_LBSS
));
379 else if (NSTR_CH1('r') && NSTR_CH2('.'))
380 return (MSG_ORIG(MSG_SCN_LRODATA
));
384 return (MSG_ORIG(MSG_SCN_RODATA
));
388 return (MSG_ORIG(MSG_SCN_SDATA
));
389 else if (NSTR_CH1('2') && NSTR_CH2('.'))
390 return (MSG_ORIG(MSG_SCN_SDATA2
));
391 else if (NSTR_CH1('b') && NSTR_CH2('.'))
392 return (MSG_ORIG(MSG_SCN_SBSS
));
393 else if (NSTR_CH1('b') && NSTR_CH2('2') && NSTR_CH3('.'))
394 return (MSG_ORIG(MSG_SCN_SBSS2
));
398 return (MSG_ORIG(MSG_SCN_TEXT
));
399 else if (NSTR_CH1('b') && NSTR_CH2('.'))
400 return (MSG_ORIG(MSG_SCN_TBSS
));
401 else if (NSTR_CH1('d') && NSTR_CH2('.'))
402 return (MSG_ORIG(MSG_SCN_TDATA
));
405 if (NSTR_CH1('i') && NSTR_CH2('.'))
406 return (MSG_ORIG(MSG_SCN_DEBUG_INFO
));
413 * No special name match found.
423 * Initialize a path info buffer for use with ld_place_section().
426 * ofl - Output descriptor
427 * ifl - Descriptor for input file, or NULL if there is none.
428 * info - Address of buffer to be initialized.
431 * If this is an input file, and if the entrance criteria list
432 * contains at least one criteria that has a non-empty file string
433 * match list (ec_files), then the block pointed at by info is
434 * initialized, and info is returned.
436 * If there is no input file, and/or no entrance criteria containing
437 * a non-empty ec_files list, then NULL is returned. This is not
438 * an error --- the NULL is simply an optimization, understood by
439 * ld_place_path(), that allows it to skip unnecessary work.
442 ld_place_path_info_init(Ofl_desc
*ofl
, Ifl_desc
*ifl
, Place_path_info
*info
)
445 * Return NULL if there is no input file (internally generated section)
446 * or if the entrance criteria list does not contain any items that will
447 * need to be compared to the path (all the ec_files lists are empty).
449 if ((ifl
== NULL
) || !(ofl
->ofl_flags
& FLG_OF_EC_FILES
))
452 info
->ppi_path
= ifl
->ifl_name
;
453 info
->ppi_path_len
= strlen(info
->ppi_path
);
454 info
->ppi_isar
= (ifl
->ifl_flags
& FLG_IF_EXTRACT
) != 0;
457 * The basename is the final segment of the path, equivalent to
458 * the path itself if there are no '/' delimiters.
460 info
->ppi_bname
= strrchr(info
->ppi_path
, '/');
461 if (info
->ppi_bname
== NULL
)
462 info
->ppi_bname
= info
->ppi_path
;
464 info
->ppi_bname
++; /* Skip leading '/' */
465 info
->ppi_bname_len
=
466 info
->ppi_path_len
- (info
->ppi_bname
- info
->ppi_path
);
469 * For an archive, the object name is the member name, which is
470 * enclosed in () at the end of the name string. Otherwise, it is
471 * the same as the basename.
473 if (info
->ppi_isar
) {
474 info
->ppi_oname
= strrchr(info
->ppi_bname
, '(');
475 /* There must be an archive member suffix delimited by parens */
476 assert((info
->ppi_bname
[info
->ppi_bname_len
- 1] == ')') &&
477 (info
->ppi_oname
!= NULL
));
478 info
->ppi_oname
++; /* skip leading '(' */
479 info
->ppi_oname_len
= info
->ppi_bname_len
-
480 (info
->ppi_oname
- info
->ppi_bname
+ 1);
482 info
->ppi_oname
= info
->ppi_bname
;
483 info
->ppi_oname_len
= info
->ppi_bname_len
;
490 * Compare an input section path to the file comparison list the given
494 * path_info - A non-NULL Place_path_info block for the file
495 * containing the input section, initialized by
496 * ld_place_path_info_init()
497 * enp - Entrance criteria with a non-empty ec_files list of file
498 * comparisons to be carried out.
501 * Return TRUE if a match is seen, and FALSE otherwise.
504 eval_ec_files(Place_path_info
*path_info
, Ent_desc
*enp
)
511 for (ALIST_TRAVERSE(enp
->ec_files
, idx
, edfp
)) {
512 Word type
= edfp
->edf_flags
& TYP_ECF_MASK
;
515 * Determine the starting character, and # of characters,
516 * from the file path to compare against this entrance criteria
519 if (type
== TYP_ECF_OBJNAME
) {
520 cmp_str
= path_info
->ppi_oname
;
521 cmp_len
= path_info
->ppi_oname_len
;
523 int ar_stat_diff
= path_info
->ppi_isar
!=
524 ((edfp
->edf_flags
& FLG_ECF_ARMEMBER
) != 0);
527 * If the entrance criteria specifies an archive member
528 * and the file does not, then there can be no match.
531 if (ar_stat_diff
&& !path_info
->ppi_isar
)
534 if (type
== TYP_ECF_PATH
) {
535 cmp_str
= path_info
->ppi_path
;
536 cmp_len
= path_info
->ppi_path_len
;
537 } else { /* TYP_ECF_BASENAME */
538 cmp_str
= path_info
->ppi_bname
;
539 cmp_len
= path_info
->ppi_bname_len
;
543 * If the entrance criteria does not specify an archive
544 * member and the file does, then a match just requires
545 * the paths (without the archive member) to match.
546 * Reduce the length to not include the ar member or
547 * the '(' that precedes it.
549 if (ar_stat_diff
&& path_info
->ppi_isar
)
550 cmp_len
= path_info
->ppi_oname
- cmp_str
- 1;
554 * Compare the resulting string to the one from the
557 if ((cmp_len
== edfp
->edf_name_len
) &&
558 (strncmp(edfp
->edf_name
, cmp_str
, cmp_len
) == 0))
566 * Replace the section header for the given input section with a new section
567 * header of the specified type. All values in the replacement header other
568 * than the type retain their previous values.
571 * isp - Input section to replace
572 * sh_type - New section type to apply
575 * Returns the pointer to the new section header on success, and
579 isp_convert_type(Is_desc
*isp
, Word sh_type
)
583 if ((shdr
= libld_malloc(sizeof (Shdr
))) == NULL
)
585 *shdr
= *isp
->is_shdr
;
587 shdr
->sh_type
= sh_type
;
592 * Issue a fatal warning for the given .eh_frame section, which
593 * cannot be merged with the existing .eh_frame output section.
596 eh_frame_muldef(Ofl_desc
*ofl
, Is_desc
*isp
)
601 Aliste idx1
, idx2
, idx3
;
604 * Locate the .eh_frame output section, and use the first section
605 * assigned to it in the error message. The user can then compare
606 * the two sections to determine what attribute prevented the merge.
608 for (APLIST_TRAVERSE(ofl
->ofl_segs
, idx1
, sgp
)) {
609 for (APLIST_TRAVERSE(sgp
->sg_osdescs
, idx2
, osp
)) {
610 if ((osp
->os_flags
& FLG_OS_EHFRAME
) == 0)
613 for (idx3
= 0; idx3
< OS_ISD_NUM
; idx3
++) {
614 APlist
*lst
= osp
->os_isdescs
[idx3
];
616 if (aplist_nitems(lst
) == 0)
619 isp1
= lst
->apl_data
[0];
620 ld_eprintf(ofl
, ERR_FATAL
,
621 MSG_INTL(MSG_UPD_MULEHFRAME
),
622 isp1
->is_file
->ifl_name
,
623 EC_WORD(isp1
->is_scnndx
), isp1
->is_name
,
624 isp
->is_file
->ifl_name
,
625 EC_WORD(isp
->is_scnndx
), isp
->is_name
);
633 * Place a section into the appropriate segment and output section.
636 * ofl - File descriptor
637 * isp - Input section descriptor of section to be placed.
638 * path_info - NULL, or pointer to Place_path_info buffer initialized
639 * by ld_place_path_info_init() for the file associated to isp,
640 * for use in processing entrance criteria with non-empty
641 * file matching string list (ec_files)
642 * ident - Section identifier, used to order sections relative to
643 * others within the output segment.
644 * alt_os_name - If non-NULL, the name of the output section to place
645 * isp into. If NULL, input sections go to an output section
646 * with the same name as the input section.
649 ld_place_section(Ofl_desc
*ofl
, Is_desc
*isp
, Place_path_info
*path_info
,
650 int ident
, const char *alt_os_name
)
657 Shdr
*shdr
= isp
->is_shdr
;
658 Xword shflagmask
, shflags
= shdr
->sh_flags
;
659 Ifl_desc
*ifl
= isp
->is_file
;
662 Boolean is_ehframe
= (isp
->is_flags
& FLG_IS_EHFRAME
) != 0;
665 * Define any sections that must be thought of as referenced. These
666 * sections may not be referenced externally in a manner ld(1) can
667 * discover, but they must be retained (ie. not removed by -zignore).
669 static const Msg RefSecs
[] = {
670 MSG_SCN_INIT
, /* MSG_ORIG(MSG_SCN_INIT) */
671 MSG_SCN_FINI
, /* MSG_ORIG(MSG_SCN_FINI) */
672 MSG_SCN_EX_RANGES
, /* MSG_ORIG(MSG_SCN_EX_RANGES) */
673 MSG_SCN_EX_SHARED
, /* MSG_ORIG(MSG_SCN_EX_SHARED) */
674 MSG_SCN_CTORS
, /* MSG_ORIG(MSG_SCN_CTORS) */
675 MSG_SCN_DTORS
, /* MSG_ORIG(MSG_SCN_DTORS) */
676 MSG_SCN_EHFRAME
, /* MSG_ORIG(MSG_SCN_EHFRAME) */
677 MSG_SCN_EHFRAME_HDR
, /* MSG_ORIG(MSG_SCN_EHFRAME_HDR) */
678 MSG_SCN_JCR
, /* MSG_ORIG(MSG_SCN_JCR) */
682 DBG_CALL(Dbg_sec_in(ofl
->ofl_lml
, isp
));
685 * If this section identifies group members, or this section indicates
686 * that it is a member of a group, determine whether the section is
689 if ((shflags
& SHF_GROUP
) || (shdr
->sh_type
== SHT_GROUP
)) {
692 if ((gdesc
= ld_get_group(ofl
, isp
)) != NULL
) {
693 DBG_CALL(Dbg_sec_group(ofl
->ofl_lml
, isp
, gdesc
));
696 * If this group has been replaced by another group,
697 * then this section needs to be discarded.
699 if (gdesc
->gd_oisc
) {
700 isp
->is_flags
|= FLG_IS_DISCARD
;
703 * Since we're discarding the section, we
704 * can skip assigning it to an output section.
705 * The exception is that if the user
706 * specifies -z relaxreloc, then
707 * we need to assign the output section so
708 * that the sloppy relocation logic will have
709 * the information necessary to do its work.
711 if (!(ofl
->ofl_flags1
& FLG_OF1_RLXREL
))
717 * SHT_GROUP sections can only be included into relocatable
720 if (shdr
->sh_type
== SHT_GROUP
) {
721 if ((ofl
->ofl_flags
& FLG_OF_RELOBJ
) == 0) {
722 isp
->is_flags
|= FLG_IS_DISCARD
;
729 * Always assign SHF_TLS sections to the DATA segment (and then the
730 * PT_TLS embedded inside of there).
732 if (shflags
& SHF_TLS
)
733 shflags
|= SHF_WRITE
;
736 * Traverse the entrance criteria list searching for a segment that
737 * matches the input section we have. If an entrance criterion is set
738 * then there must be an exact match. If we complete the loop without
739 * finding a segment, then sgp will be NULL.
742 for (APLIST_TRAVERSE(ofl
->ofl_ents
, idx1
, enp
)) {
744 /* Disabled segments are not available for assignment */
745 if (enp
->ec_segment
->sg_flags
& FLG_SG_DISABLED
)
749 * If an entrance criteria doesn't have any of its fields
750 * set, it will match any section it is tested against.
751 * We set the FLG_EC_CATCHALL flag on these, primarily because
752 * it helps readers of our debug output to understand what
753 * the criteria means --- otherwise the user would just see
754 * that every field is 0, but might not understand the
755 * significance of that.
757 * Given that we set this flag, we can use it here as an
758 * optimization to short circuit all of the tests in this
759 * loop. Note however, that if we did not do this, the end
760 * result would be the same --- the empty criteria will sail
761 * past the following tests and reach the end of the loop.
763 if (enp
->ec_flags
& FLG_EC_CATCHALL
) {
764 sgp
= enp
->ec_segment
;
768 if (enp
->ec_type
&& (enp
->ec_type
!= shdr
->sh_type
))
770 if (enp
->ec_attrmask
&&
772 (enp
->ec_attrmask
& enp
->ec_attrbits
) !=
773 (enp
->ec_attrmask
& shflags
))
775 if (enp
->ec_is_name
&&
776 (strcmp(enp
->ec_is_name
, isp
->is_name
) != 0))
779 if ((alist_nitems(enp
->ec_files
) > 0) &&
780 ((path_info
== NULL
) || !eval_ec_files(path_info
, enp
)))
783 /* All entrance criteria tests passed */
784 sgp
= enp
->ec_segment
;
789 * The final entrance criteria record is a FLG_EC_CATCHALL that points
790 * at the final predefined segment "extra", and this final segment is
791 * tagged FLG_SG_NODISABLE. Therefore, the above loop must always find
797 * Transfer the input section sorting key from the entrance criteria
798 * to the input section. A non-zero value means that the section
799 * will be sorted on this key amoung the other sections that have a
800 * non-zero key. These sorted sections are collectively placed at the
801 * head of the output section.
803 * If the sort key is 0, the section is placed after the sorted
804 * sections in the order they are encountered.
806 isp
->is_ordndx
= enp
->ec_ordndx
;
808 /* Remember that this entrance criteria has placed a section */
809 enp
->ec_flags
|= FLG_EC_USED
;
812 * If our caller has supplied an alternative name for the output
813 * section, then we defer to their request. Otherwise, the default
814 * is to use the same name as that of the input section being placed.
816 * The COMDAT, SHT_GROUP and GNU name translations that follow have
817 * the potential to alter this initial name.
819 oname
= (char *)((alt_os_name
== NULL
) ? isp
->is_name
: alt_os_name
);
822 * Solaris section names may follow the convention:
824 * section-name%symbol-name
826 * This convention has been used to order the layout of sections within
827 * segments for objects built with the compilers -xF option. However,
828 * the final object should not contain individual section headers for
829 * all such input sections, instead the symbol name is stripped from the
830 * name to establish the final output section name.
832 * This convention has also been followed for COMDAT and sections
833 * identified though SHT_GROUP data.
835 * Strip out the % from the section name for:
836 * - Non-relocatable objects
837 * - Relocatable objects if input section sorting is
838 * in force for the segment in question.
840 if (((ofl
->ofl_flags
& FLG_OF_RELOBJ
) == 0) ||
841 (sgp
->sg_flags
& FLG_SG_IS_ORDER
)) {
842 if ((sname
= strchr(isp
->is_name
, '%')) != NULL
) {
843 size_t size
= sname
- isp
->is_name
;
845 if ((oname
= libld_malloc(size
+ 1)) == NULL
)
846 return ((Os_desc
*)S_ERROR
);
847 (void) strncpy(oname
, isp
->is_name
, size
);
849 DBG_CALL(Dbg_sec_redirected(ofl
->ofl_lml
, isp
, oname
));
854 * When building relocatable objects, we must not redirect COMDAT
855 * section names into their outputs, such that our output object may
856 * be successfully used as an input object also requiring COMDAT
861 * GNU section names may follow the convention:
865 * The .gnu.linkonce is a section naming convention that indicates a
866 * COMDAT requirement. Determine whether this section follows the GNU
867 * pattern, and if so, determine whether this section should be
868 * discarded or retained. The comparison of is_name[1] with 'g'
869 * is an optimization to skip using strncmp() too much. This is safe,
870 * because we know the name is not NULL, and therefore must have
871 * at least one character plus a NULL termination.
873 if ((isp
->is_name
== oname
) && (isp
->is_name
[1] == 'g') &&
874 (strncmp(MSG_ORIG(MSG_SCN_GNU_LINKONCE
), isp
->is_name
,
875 MSG_SCN_GNU_LINKONCE_SIZE
) == 0)) {
876 if ((ofl
->ofl_flags
& FLG_OF_RELOBJ
) == 0) {
877 if ((oname
= (char *)gnu_linkonce_sec(isp
->is_name
)) !=
879 DBG_CALL(Dbg_sec_redirected(ofl
->ofl_lml
, isp
,
885 * Explicitly identify this section type as COMDAT. Also,
886 * enable relaxed relocation processing, as this is typically
887 * a requirement with .gnu.linkonce sections.
889 isp
->is_flags
|= FLG_IS_COMDAT
;
890 if ((ofl
->ofl_flags1
& FLG_OF1_NRLXREL
) == 0)
891 ofl
->ofl_flags1
|= FLG_OF1_RLXREL
;
892 DBG_CALL(Dbg_sec_gnu_comdat(ofl
->ofl_lml
, isp
, TRUE
,
893 (ofl
->ofl_flags1
& FLG_OF1_RLXREL
) != 0));
897 * GNU section names may also follow the convention:
899 * section-name.symbol-name
901 * This convention is used when defining SHT_GROUP sections of type
902 * COMDAT. Thus, any group processing will have discovered any group
903 * sections, and this identification can be triggered by a pattern
904 * match section names.
906 if ((isp
->is_name
== oname
) && (isp
->is_flags
& FLG_IS_COMDAT
) &&
907 ((sname
= gnu_comdat_sym(ifl
, isp
)) != NULL
)) {
908 size_t size
= sname
- isp
->is_name
;
910 if ((ofl
->ofl_flags
& FLG_OF_RELOBJ
) == 0) {
911 if ((oname
= libld_malloc(size
+ 1)) == NULL
)
912 return ((Os_desc
*)S_ERROR
);
913 (void) strncpy(oname
, isp
->is_name
, size
);
915 DBG_CALL(Dbg_sec_redirected(ofl
->ofl_lml
, isp
, oname
));
919 * Enable relaxed relocation processing, as this is
920 * typically a requirement with GNU COMDAT sections.
922 if ((ofl
->ofl_flags1
& FLG_OF1_NRLXREL
) == 0) {
923 ofl
->ofl_flags1
|= FLG_OF1_RLXREL
;
924 DBG_CALL(Dbg_sec_gnu_comdat(ofl
->ofl_lml
, isp
,
930 * Assign a hash value now that the output section name has been
933 onamehash
= sgs_str_hash(oname
);
936 * Determine if output section ordering is turned on. If so, return
937 * the appropriate ordering index for the section. This information
938 * is derived from the Sg_desc->sg_os_order list that was built
939 * up from the Mapfile.
941 * A value of 0 for os_ndx means that the section is not sorted
942 * (i.e. is not found in the sg_os_order). The items in sg_os_order
943 * are in the desired sort order, so adding 1 to their alist index
944 * gives a suitable index for sorting.
947 if (alist_nitems(sgp
->sg_os_order
) > 0) {
950 for (ALIST_TRAVERSE(sgp
->sg_os_order
, idx1
, scop
)) {
951 if (strcmp(scop
->sco_secname
, oname
) == 0) {
952 scop
->sco_flags
|= FLG_SGO_USED
;
960 * Mask of section header flags to ignore when matching sections. We
961 * are more strict with relocatable objects, ignoring only the order
962 * flags, and keeping sections apart if they differ otherwise. This
963 * follows the policy that sections in a relative object should only
964 * be merged if their flags are the same, and avoids destroying
965 * information prematurely. For final products however, we ignore all
966 * flags that do not prevent a merge.
969 (ofl
->ofl_flags
& FLG_OF_RELOBJ
) ? ALL_SHF_ORDER
: ALL_SHF_IGNORE
;
972 * Traverse the input section list for the output section we have been
973 * assigned. If we find a matching section simply add this new section.
976 for (APLIST_TRAVERSE(sgp
->sg_osdescs
, idx1
, osp
)) {
977 Shdr
*os_shdr
= osp
->os_shdr
;
980 * An input section matches an output section if:
981 * - The ident values match
983 * - Not a GROUP section
984 * - Not a DTrace dof section
985 * - Section types match
986 * - Matching section flags, after screening out the
989 * Section types are considered to match if any one of
990 * the following are true:
991 * - The type codes are the same
992 * - Both are .eh_frame sections (regardless of type code)
993 * - The input section is COMDAT, and the output section
996 if ((ident
== osp
->os_identndx
) &&
997 (ident
!= ld_targ
.t_id
.id_rel
) &&
998 (onamehash
== osp
->os_namehash
) &&
999 (shdr
->sh_type
!= SHT_GROUP
) &&
1000 (shdr
->sh_type
!= SHT_SUNW_dof
) &&
1001 ((shdr
->sh_type
== os_shdr
->sh_type
) ||
1002 (is_ehframe
&& (osp
->os_flags
& FLG_OS_EHFRAME
)) ||
1003 ((shdr
->sh_type
== SHT_SUNW_COMDAT
) &&
1004 (os_shdr
->sh_type
== SHT_PROGBITS
))) &&
1005 ((shflags
& ~shflagmask
) ==
1006 (os_shdr
->sh_flags
& ~shflagmask
)) &&
1007 (strcmp(oname
, osp
->os_name
) == 0)) {
1011 * Process any COMDAT section, keeping the first and
1012 * discarding all others.
1014 if ((isp
->is_flags
& FLG_IS_COMDAT
) &&
1015 ((err
= add_comdat(ofl
, osp
, isp
)) != 1))
1016 return ((Os_desc
*)err
);
1021 set_addralign(ofl
, osp
, isp
);
1024 * If this section is a non-empty TLS section indicate
1025 * that a PT_TLS program header is required.
1027 if ((shflags
& SHF_TLS
) && shdr
->sh_size
&&
1028 ((ofl
->ofl_flags
& FLG_OF_RELOBJ
) == 0))
1029 ofl
->ofl_flags
|= FLG_OF_TLSPHDR
;
1032 * Insert the input section descriptor on the proper
1033 * output section descriptor list.
1035 * If this segment requires input section ordering,
1036 * honor any mapfile specified ordering for otherwise
1037 * unordered sections by setting the mapfile_sort
1038 * argument of os_attach_isp() to True.
1041 if (os_attach_isp(ofl
, osp
, isp
,
1042 (sgp
->sg_flags
& FLG_SG_IS_ORDER
) != 0) == 0)
1043 return ((Os_desc
*)S_ERROR
);
1046 * If this input section and file is associated to an
1047 * artificially referenced output section, make sure
1048 * they are marked as referenced also. This ensures
1049 * that this input section and file isn't eliminated
1050 * when -zignore is in effect.
1052 * See -zignore comments when creating a new output
1056 (ifl
->ifl_flags
& FLG_IF_IGNORE
)) || DBG_ENABLED
) &&
1057 (osp
->os_flags
& FLG_OS_SECTREF
)) {
1058 isp
->is_flags
|= FLG_IS_SECTREF
;
1060 ifl
->ifl_flags
|= FLG_IF_FILEREF
;
1063 DBG_CALL(Dbg_sec_added(ofl
->ofl_lml
, osp
, sgp
));
1068 * Do we need to worry about section ordering?
1071 if (osp
->os_ordndx
) {
1072 if (os_ndx
< osp
->os_ordndx
)
1073 /* insert section here. */
1080 /* insert section here. */
1083 } else if (osp
->os_ordndx
) {
1089 * If the new sections identifier is less than that of the
1090 * present input section we need to insert the new section
1093 if (ident
< osp
->os_identndx
)
1100 * We are adding a new output section. Update the section header
1101 * count and associated string size.
1103 * If the input section triggering this output section has been marked
1104 * for discard, and if no other non-discarded input section comes along
1105 * to join it, then we will over count. We cannot know if this will
1106 * happen or not until all input is seen. Set FLG_OF_AJDOSCNT to
1107 * trigger a final count readjustment.
1109 if (isp
->is_flags
& FLG_IS_DISCARD
)
1110 ofl
->ofl_flags
|= FLG_OF_ADJOSCNT
;
1112 if (st_insert(ofl
->ofl_shdrsttab
, oname
) == -1)
1113 return ((Os_desc
*)S_ERROR
);
1116 * Create a new output section descriptor.
1118 if ((osp
= libld_calloc(sizeof (Os_desc
), 1)) == NULL
)
1119 return ((Os_desc
*)S_ERROR
);
1120 if ((osp
->os_shdr
= libld_calloc(sizeof (Shdr
), 1)) == NULL
)
1121 return ((Os_desc
*)S_ERROR
);
1124 * Convert COMDAT section to PROGBITS as this the first section of the
1125 * output section. Save any COMDAT section for later processing, as
1126 * additional COMDAT sections that match this section need discarding.
1128 if ((shdr
->sh_type
== SHT_SUNW_COMDAT
) &&
1129 ((shdr
= isp_convert_type(isp
, SHT_PROGBITS
)) == NULL
))
1130 return ((Os_desc
*)S_ERROR
);
1131 if ((isp
->is_flags
& FLG_IS_COMDAT
) &&
1132 (add_comdat(ofl
, osp
, isp
) == S_ERROR
))
1133 return ((Os_desc
*)S_ERROR
);
1137 * Executable or sharable objects can have at most a single
1138 * .eh_frame section. Detect attempts to create more than
1139 * one. This occurs if the input sections have incompatible
1142 if ((ofl
->ofl_flags
& FLG_OF_EHFRAME
) &&
1143 !(ofl
->ofl_flags
& FLG_OF_RELOBJ
)) {
1144 eh_frame_muldef(ofl
, isp
);
1145 return ((Os_desc
*)S_ERROR
);
1147 ofl
->ofl_flags
|= FLG_OF_EHFRAME
;
1150 * For .eh_frame sections, we always set the type to be the
1151 * type specified by the ABI. This allows .eh_frame sections
1152 * of type SHT_PROGBITS to be correctly merged with .eh_frame
1153 * sections of the ABI-defined type (e.g. SHT_AMD64_UNWIND),
1154 * with the output being of the ABI-defined type.
1156 osp
->os_shdr
->sh_type
= ld_targ
.t_m
.m_sht_unwind
;
1158 osp
->os_shdr
->sh_type
= shdr
->sh_type
;
1161 osp
->os_shdr
->sh_flags
= shdr
->sh_flags
;
1162 osp
->os_shdr
->sh_entsize
= shdr
->sh_entsize
;
1163 osp
->os_name
= oname
;
1164 osp
->os_namehash
= onamehash
;
1165 osp
->os_ordndx
= os_ndx
;
1166 osp
->os_sgdesc
= sgp
;
1168 osp
->os_flags
|= FLG_OS_EHFRAME
;
1170 if (ifl
&& (shdr
->sh_type
== SHT_PROGBITS
)) {
1172 * Try to preserve the intended meaning of sh_link/sh_info.
1173 * See the translate_link() in update.c.
1175 osp
->os_shdr
->sh_link
= shdr
->sh_link
;
1176 if (shdr
->sh_flags
& SHF_INFO_LINK
)
1177 osp
->os_shdr
->sh_info
= shdr
->sh_info
;
1181 * When -zignore is in effect, user supplied sections and files that are
1182 * not referenced from other sections, are eliminated from the object
1183 * being produced. Some sections, although unreferenced, are special,
1184 * and must not be eliminated. Determine if this new output section is
1185 * one of those special sections, and if so mark it artificially as
1186 * referenced. Any input section and file associated to this output
1187 * section is also be marked as referenced, and thus won't be eliminated
1188 * from the final output.
1190 if (ifl
&& ((ofl
->ofl_flags1
& FLG_OF1_IGNPRC
) || DBG_ENABLED
)) {
1193 for (refsec
= RefSecs
; *refsec
; refsec
++) {
1194 if (strcmp(osp
->os_name
, MSG_ORIG(*refsec
)) == 0) {
1195 osp
->os_flags
|= FLG_OS_SECTREF
;
1197 if ((ifl
->ifl_flags
& FLG_IF_IGNORE
) ||
1199 isp
->is_flags
|= FLG_IS_SECTREF
;
1200 ifl
->ifl_flags
|= FLG_IF_FILEREF
;
1208 * Sections of type SHT_GROUP are added to the ofl->ofl_osgroups list,
1209 * so that they can be updated as a group later.
1211 if ((shdr
->sh_type
== SHT_GROUP
) &&
1212 ((isp
->is_flags
& FLG_IS_DISCARD
) == 0) &&
1213 (aplist_append(&ofl
->ofl_osgroups
, osp
,
1214 AL_CNT_OFL_OSGROUPS
) == NULL
))
1215 return ((Os_desc
*)S_ERROR
);
1218 * If this section is a non-empty TLS section indicate that a PT_TLS
1219 * program header is required.
1221 if ((shflags
& SHF_TLS
) && shdr
->sh_size
&&
1222 ((ofl
->ofl_flags
& FLG_OF_RELOBJ
) == 0))
1223 ofl
->ofl_flags
|= FLG_OF_TLSPHDR
;
1226 * If a non-allocatable section is going to be put into a loadable
1227 * segment then turn on the allocate bit for this section and warn the
1228 * user that we have done so. This could only happen through the use
1231 if ((sgp
->sg_phdr
.p_type
== PT_LOAD
) &&
1232 ((osp
->os_shdr
->sh_flags
& SHF_ALLOC
) == 0)) {
1233 ld_eprintf(ofl
, ERR_WARNING
, MSG_INTL(MSG_SCN_NONALLOC
),
1234 ofl
->ofl_name
, osp
->os_name
, sgp
->sg_name
);
1235 osp
->os_shdr
->sh_flags
|= SHF_ALLOC
;
1239 * Retain this sections identifier for future comparisons when placing
1240 * a section (after all sections have been processed this variable will
1241 * be used to hold the sections symbol index as we don't need to retain
1242 * the identifier any more).
1244 osp
->os_identndx
= ident
;
1249 set_addralign(ofl
, osp
, isp
);
1251 if (os_attach_isp(ofl
, osp
, isp
, 0) == 0)
1252 return ((Os_desc
*)S_ERROR
);
1254 DBG_CALL(Dbg_sec_created(ofl
->ofl_lml
, osp
, sgp
));
1257 * Insert the new section at the offset given by iidx. If no position
1258 * for it was identified above, this will be index 0, causing the new
1259 * section to be prepended to the beginning of the section list.
1260 * Otherwise, it is the index following the section that was identified.
1262 if (aplist_insert(&sgp
->sg_osdescs
, osp
, AL_CNT_SG_OSDESC
,
1264 return ((Os_desc
*)S_ERROR
);