/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright (c) 1996, 2010, Oracle and/or its affiliates. All rights reserved. */ /* * Processing of SHF_ORDERED sections. */ #include <stdio.h> #include <fcntl.h> #include <link.h> #include <debug.h> #include "msg.h" #include "_libld.h" /* * Section Ordering History/Background: * * There are two forms of section ordering, SHF_ORDERED, and SHF_LINK_ORDER. * * SHF_ORDERED was invented at Sun in order to support the PowerPC port * of Solaris 2.6, which used it for sorting tag words which describe * the state of callee saves registers for given PC ranges. It was defined * in the OS specific ELF section flag range. Some other values were defined * at the same time: * SHF_EXCLUDE - Section is to be excluded from executables or shared * objects, and only kept in relocatable object output. * SHN_BEFORE/SHN_AFTER - Sections are placed before/after all other * sections, in the order they are encountered by the linker. * Although initially conceived to support the PowerPC, the functionality * was implemented for all platforms, and was later used to manage C++ * exceptions and stack unwinding. The PowerPC port was discontinued after * one release, but SHF_ORDERED lives on. * * SHF_LINK_ORDER was invented later by the wider ELF community, and is * therefore assigned a value in the generic ELF section flag range. It is * essentially a simpler version of SHF_ORDERED, dispensing with some * unnecessary features. The Solaris implementation of SHF_LINK_ORDER uses * SHF_EXCLUDE, and SHF_BEFORE/SHN_AFTER as well, but it appears that these * are still Solaris-only extensions not used by other implementations. * SHF_LINK_ORDER has superseded SHF_ORDERED. The older mechanism is * supported for the benefit of old pre-existing objects. * * ----- * * SHF_ORDERED offers two distinct and separate abilities: * * (1) To specify the output section * (2) To optionally be sorted relative to other sorted sections, * using a non-sorted section as a sort key. * * To do this, it uses both the sh_link, and sh_info fields: * * sh_link * Specifies the output section to receive this input section. * The sh_link field of an SHF_ORDERED section forms a linked list of * sections, all of which must have identical section header flags * (including SHF_ORDERED). The list is terminated by a final section * with a sh_link that points at itself. All input sections in this list * are assigned to the output section of the final section in the list. * Hence, if a section points at itself, the effect is that it gets * assigned to an output section in the usual default manner (i.e. an * output section with the same name as the input). However, it can * point at any arbitrary other section. This is a way to put a section * with one name into an output section with a different name. It should * be noted that this is of little value overall, because the link-editor * already supports a more general feature for directing input sections * to output sections: An input section named .text%foo will be sent to * an output section named ".text", and this works for all sections, * not just ordered ones. * * sh_info * If sh_info is in the range (1 <= value < shnum), then this input section * is added to the group of sorted sections. The section referenced by * sh_info must be unsorted, and is used as the sort key. * * If sh_info is SHN_BEFORE or SHN_AFTER, it is put in the pre/post group, * in the order it arrives (the before/after classes are not sorted). * * If sh_info is "invalid" (typically 0), then this section is added to * the group of non-sorted sections, and goes into the output file in the * order it arrives. This is not a valuable feature, as the same effect * can be achieved more simply by not setting SHF_ORDERED at all. * * SHF_LINK_ORDER is a simplification of SHF_ORDERED. It uses sh_link to specify * the section to use as a sort key and sh_info is set to 0. The standard * ".text%foo" mechanism is used to direct input sections to output sections, * and unordered sections indicate that by not setting SHF_LINK_ORDER. */ /* * A "keyshndx" is the section index for the unordered section that should * be used as a sort key for a ordered section. Verify that the given * keyshndx is valid. * * exit: * Returns 0 if the keyshndx is valid. A non-zero DBG_ORDER_ code is * returned if the keyshndx is not valid to describe the problem. */ inline static Word is_keyshndx_ok(Ifl_desc *ifl, Word keyshndx) { if ((keyshndx == SHN_BEFORE) || (keyshndx == SHN_AFTER)) return (0); /* * Validate the key range. */ if ((keyshndx == 0) || (keyshndx >= ifl->ifl_shnum)) return (DBG_ORDER_LINK_OUTRANGE); /* * The section pointed to by keyshndx should not be an ordered section. * Strictly speaking, we could test for SHF_ORDERED here instead of * ALL_SHF_ORDER as the two ordering flags are not supposed to be * mixed. Using ALL_SHF_ORDER costs the same and ensures that such * mixing doesn't go undetected. */ if (ifl->ifl_isdesc[keyshndx]->is_shdr->sh_flags & ALL_SHF_ORDER) return (DBG_ORDER_INFO_ORDER); return (0); } /* * The sh_link field of an SHF_ORDERED section forms a linked list of * sections. The list is terminated by a final section with a sh_link * that points at itself. Given the index of an SHF_ORDERED section, find * the index of the final section in the list. * * entry: * ofl - Output file descriptor * ifl - Input file descriptor * ndx - Section index of SHF_ORDERED section * alt_os_name - Address of pointer to string. If the final section * name is different than the section given by ndx, *alt_os_name * will be updated with the name of the final section. The caller * should initialize *alt_os_name to NULL before calling * this routine. * * exit: * On success: If the final section is different than the section * given by ndx, then *alt_os_name is set to its name. TRUE is returned. * * On failure, FALSE is returned. */ static Boolean validate_shf_ordered_dest(Ofl_desc *ofl, Ifl_desc *ifl, Word ndx, const char **alt_os_name) { Word shnum = ifl->ifl_shnum; Word isp1_ndx, isp2_ndx; Is_desc *isp1, *isp2; int error = 0; size_t iter = 0; /* * Traverse the list until we find the termination, or encounter * an invalid condition in the object that prevents ordering. */ isp1_ndx = ndx; isp1 = ifl->ifl_isdesc[ndx]; do { /* * Obtain index of next section in list. Ensure it is in range. */ isp2_ndx = isp1->is_shdr->sh_link; if ((isp2_ndx == 0) || (isp2_ndx >= shnum)) { error = DBG_ORDER_LINK_OUTRANGE; break; } isp2 = ifl->ifl_isdesc[isp2_ndx]; /* The section flags must match exactly */ if (isp1->is_shdr->sh_flags != isp2->is_shdr->sh_flags) { /* * The case where the next section in the list does * not have the same ordered flag set as the original * ordered section gets a unique error code. This * provides more accurate/useful debugging diagnostics. */ error = ((isp2->is_flags & FLG_IS_ORDERED) == 0) ? DBG_ORDER_LINK_ERROR : DBG_ORDER_FLAGS; break; } /* * The sh_info field specifies the section index of an * unorderd section which will be used as a sort key. * Ensure it is in range. If not, we terminate the list * at the current node instead of continuing on. */ if ((error = is_keyshndx_ok(ifl, isp2->is_shdr->sh_info)) != 0) break; /* If the section points at itself, it terminates the list */ if (isp1_ndx == isp2_ndx) break; /* * Advance to next section in list */ isp1_ndx = isp2_ndx; isp1 = isp2; /* * If we loop more times than the input file has sections, * we have encountered a malformed object in which the list * of SHF_ORDERED sections has a cycle. This can only happen * if the compiler generating the object has a bad bug. */ if (++iter >= shnum) { error = DBG_ORDER_CYCLIC; break; } /* CONSTANTCONDITION */ } while (1); /* * If we have found a problem, issue a debug diagnostic and map * the output section to 0. This indicates that the section should * remove the ordering flag and treat it as a standard section. */ if (error != 0) { isp2_ndx = 0; DBG_CALL(Dbg_sec_order_error(ofl->ofl_lml, ifl, ndx, error)); } /* Report success */ if (isp2_ndx != 0) { /* * If the destination section is different than the input * section, then set *alt_os_name to the destination name. */ if (isp2_ndx != ndx) *alt_os_name = ifl->ifl_isdesc[isp2_ndx]->is_name; return (TRUE); } /* If we get here, there is no valid destination */ return (FALSE); } /* * Called when an ordered section has a problem that prevents ordering. * The order flag is removed, and then the section is placed as an * unsorted section. */ static uintptr_t place_unordered(Ofl_desc *ofl, Is_desc *isp, Place_path_info *path_info) { isp->is_flags &= ~FLG_IS_ORDERED; if (isp->is_osdesc == NULL) return ((uintptr_t)ld_place_section(ofl, isp, path_info, isp->is_keyident, NULL)); return ((uintptr_t)isp->is_osdesc); } /* * Process ordered input section. Called from process_elf() after * all the non-ordered sections have been placed. * * entry: * ofl - Output file descriptor * ifl - Input file descriptor * ndx - Section index of SHF_ORDERED section * * exit: */ uintptr_t ld_process_ordered(Ofl_desc *ofl, Ifl_desc *ifl, Place_path_info *path_info, Word ndx) { Is_desc *isp2, *isp = ifl->ifl_isdesc[ndx]; Xword shflags = isp->is_shdr->sh_flags; const char *alt_os_name = NULL; Word keyshndx; Os_desc *osp; int error = 0; /* * Obtain the sort key section index for this ordered section. * SHF_ORDERED uses sh_info, while SHF_LINK_ORDER uses sh_link. * In order for this function to be called, one of SHF_ORDERED * or SHF_LINK_ORDER must be set. Testing for one implies the * state of the other. */ keyshndx = (shflags & SHF_ORDERED) ? isp->is_shdr->sh_info : isp->is_shdr->sh_link; /* * Validate the sort key section index. If something is wrong, * fall back to treating it as a non-ordered section. */ if ((error = is_keyshndx_ok(ifl, keyshndx)) != 0) { DBG_CALL(Dbg_sec_order_error(ofl->ofl_lml, ifl, ndx, error)); return (place_unordered(ofl, isp, path_info)); } /* * If SHF_ORDERED is in effect, validate the destination section * name given by sh_link, and set alt_os_name to the name of the * destination if it differs from the section being processed. */ if ((shflags & SHF_ORDERED) && (validate_shf_ordered_dest(ofl, ifl, ndx, &alt_os_name) == FALSE)) return (place_unordered(ofl, isp, path_info)); /* * Place the section into its output section. It's possible that this * section is discarded (possibly because it's defined COMDAT), in * which case we're done. */ if ((osp = isp->is_osdesc) == NULL) { osp = ld_place_section(ofl, isp, path_info, isp->is_keyident, alt_os_name); if ((osp == (Os_desc *)S_ERROR) || (osp == NULL)) return ((uintptr_t)osp); } /* * If the output section is not yet on the ordered list, place it on * the list. */ if (aplist_test(&ofl->ofl_ordered, osp, AL_CNT_OFL_ORDERED) == ALE_ALLOCFAIL) return ((uintptr_t)S_ERROR); /* * Output section has been found - set up its sorting information. */ if ((keyshndx != SHN_BEFORE) && (keyshndx != SHN_AFTER)) { Os_desc *osp2; isp2 = ifl->ifl_isdesc[keyshndx]; if (isp2->is_flags & FLG_IS_DISCARD) { ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_FIL_BADORDREF), ifl->ifl_name, EC_WORD(isp->is_scnndx), isp->is_name, EC_WORD(isp2->is_scnndx), isp2->is_name); return (S_ERROR); } /* * Indicate that this ordered input section will require a * sort key. Propagate the key requirement through to the * associated output section, segment and file, to trigger * the sort key creation. See ld_sec_validate(); */ isp2->is_flags |= FLG_IS_KEY; osp2 = isp2->is_osdesc; osp2->os_flags |= FLG_OS_KEY; osp2->os_sgdesc->sg_flags |= FLG_SG_KEY; ofl->ofl_flags |= FLG_OF_KEY; } return ((uintptr_t)osp); } /* * Traverse all segments looking for section ordering information that hasn't * been used. If found give a warning message to the user. Also, check if * there are any ordered key sections, and if so set up sort key values. */ void ld_sec_validate(Ofl_desc *ofl) { Aliste idx1; Sg_desc *sgp; Word key = 1; for (APLIST_TRAVERSE(ofl->ofl_segs, idx1, sgp)) { Sec_order *scop; Os_desc *osp; Aliste idx2; for (ALIST_TRAVERSE(sgp->sg_os_order, idx2, scop)) { if ((scop->sco_flags & FLG_SGO_USED) == 0) { ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_MAP_SECORDER), sgp->sg_name, scop->sco_secname); } } if ((sgp->sg_flags & FLG_SG_KEY) == 0) continue; for (APLIST_TRAVERSE(sgp->sg_osdescs, idx2, osp)) { Aliste idx3; Is_desc *isp; if ((osp->os_flags & FLG_OS_KEY) == 0) continue; /* * The input sections used as sort keys are required * to be unordered, so we only have to look at the * DEFAULT list of input sections. */ for (APLIST_TRAVERSE(osp->os_isdescs[OS_ISD_DEFAULT], idx3, isp)) { if (isp->is_flags & FLG_IS_KEY) isp->is_keyident = key++; } } } } static int comp(const void *ss1, const void *ss2) { Is_desc *s1 = *((Is_desc **)ss1); Is_desc *s2 = *((Is_desc **)ss2); Is_desc *i1, *i2; Word ndx1, ndx2; if (s1->is_shdr->sh_flags & SHF_ORDERED) ndx1 = s1->is_shdr->sh_info; else ndx1 = s1->is_shdr->sh_link; if (s2->is_shdr->sh_flags & SHF_ORDERED) ndx2 = s2->is_shdr->sh_info; else ndx2 = s2->is_shdr->sh_link; i1 = s1->is_file->ifl_isdesc[ndx1]; i2 = s2->is_file->ifl_isdesc[ndx2]; if (i1->is_keyident > i2->is_keyident) return (1); if (i1->is_keyident < i2->is_keyident) return (-1); return (0); } /* * Sort ordered input sections */ uintptr_t ld_sort_ordered(Ofl_desc *ofl) { Aliste idx1; Os_desc *osp; DBG_CALL(Dbg_sec_order_list(ofl, 0)); for (APLIST_TRAVERSE(ofl->ofl_ordered, idx1, osp)) { APlist *ap_list = osp->os_isdescs[OS_ISD_ORDERED]; Aliste apl_nitems = aplist_nitems(ap_list); /* * If this output section has a non-empty list of ordered * input sections, sort their APlist in place into their * final order. */ if (apl_nitems != 0) qsort((char *)ap_list->apl_data, apl_nitems, sizeof (Is_desc *), comp); } DBG_CALL(Dbg_sec_order_list(ofl, 1)); return (0); }
