/* * 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) 1988 AT&T * All Rights Reserved * * Copyright (c) 1991, 2010, Oracle and/or its affiliates. All rights reserved. */ #define ELF_TARGET_AMD64 #include <stdio.h> #include <memory.h> #include <debug.h> #include "msg.h" #include "_libld.h" /* * The link-editor uses a segment descriptor list to describe the program * headers, and related output segments, it can potentially create. This * list is initially seeded using the templates contained in the sg_desc * array below. Additional segments may be added using a mapfile. * * The entries in sg_desc must be put in the order defined by the * Segment_id enum. * * The entries in sg_desc are initialized using the SG_DESC_INIT macro * for two reasons: * * 1) The first field of the Sg_desc struct is a program header * entry. ELF32_Phdr and ELF64_Phdr have the same fields, * but their order is different. Use of a macro allows us * to handle this transparently. * 2) Most of the fields in the Sg_desc entries are set to 0. * Use of a macro allows us to hide the clutter. * * If a given program header can be referenced via an entrance criteria * (i.e. can serve as a segment), then it must be given a unique sg_name. * Program headers that cannot be a segment (PHDR, INTERP, DYNAMIC, etc) * must have a NULL sg_name --- their program header type identifies them. */ #ifdef _ELF64 #define SG_DESC_INIT(id, p_type, p_flags, sg_name, sg_flags) \ { id, { p_type, p_flags, 0, 0, 0, 0, 0, 0}, \ sg_name, 0, 0, NULL, NULL, NULL, sg_flags, NULL, 0, NULL} #else #define SG_DESC_INIT(id, p_type, p_flags, sg_name, sg_flags) \ { id, { p_type, 0, 0, 0, 0, 0, p_flags, 0}, \ sg_name, 0, 0, NULL, NULL, NULL, sg_flags, NULL, 0, NULL} #endif /* * Predefined segment descriptors: * * The C language guarantees that a structure containing only fields of * identical type is indistinguishable from a simple array containing * the same number of items of the same type. They will have the same * size, alignment, and internal layout: * * - A pointer to one is equivalent to a pointer to the other, and you * can cast safely between them. * * - You can put both into a union, and access the elements within * either way (by index, or by name). * * We use this fact here to create an "array" of predefined segment * descriptors, assigning each one a mnemonic name that can be used to point * at it from a predefined entrance criteria descriptor (below). These * segments are positioned in the default order that will result in the * output object, unless a mapfile alters things. */ typedef struct { Sg_desc psg_phdr; Sg_desc psg_interp; Sg_desc psg_sunwcap; Sg_desc psg_text; Sg_desc psg_data; Sg_desc psg_bss; #if defined(_ELF64) Sg_desc psg_lrodata; /* (amd64-only) */ Sg_desc psg_ldata; /* (amd64-only) */ #endif Sg_desc psg_dynamic; Sg_desc psg_sunwdtrace; Sg_desc psg_tls; Sg_desc psg_unwind; Sg_desc psg_sunwstack; Sg_desc psg_note; Sg_desc psg_extra; } predef_seg_t; static const size_t predef_seg_nelts = (sizeof (predef_seg_t) / sizeof (Sg_desc)); static predef_seg_t sg_desc = { /* psg_phdr */ SG_DESC_INIT(SGID_PHDR, PT_PHDR, PF_R + PF_X, NULL, (FLG_SG_P_TYPE | FLG_SG_P_FLAGS)), /* psg_interp */ SG_DESC_INIT(SGID_INTERP, PT_INTERP, PF_R, NULL, (FLG_SG_P_TYPE | FLG_SG_P_FLAGS)), /* psg_sunwcap */ SG_DESC_INIT(SGID_SUNWCAP, PT_SUNWCAP, PF_R, NULL, (FLG_SG_P_TYPE | FLG_SG_P_FLAGS)), /* psg_text */ SG_DESC_INIT(SGID_TEXT, PT_LOAD, PF_R + PF_X, MSG_ORIG(MSG_ENT_TEXT), (FLG_SG_P_TYPE | FLG_SG_P_FLAGS)), /* psg_data */ SG_DESC_INIT(SGID_DATA, PT_LOAD, 0, MSG_ORIG(MSG_ENT_DATA), (FLG_SG_P_TYPE | FLG_SG_P_FLAGS)), /* psg_bss */ SG_DESC_INIT(SGID_BSS, PT_LOAD, 0, MSG_ORIG(MSG_ENT_BSS), (FLG_SG_P_TYPE | FLG_SG_P_FLAGS | FLG_SG_DISABLED)), #if defined(_ELF64) /* psg_lrodata (amd64-only ) */ SG_DESC_INIT(SGID_LRODATA, PT_LOAD, PF_R, MSG_ORIG(MSG_ENT_LRODATA), (FLG_SG_P_TYPE | FLG_SG_P_FLAGS)), /* psg_ldata (amd64-only ) */ SG_DESC_INIT(SGID_LDATA, PT_LOAD, 0, MSG_ORIG(MSG_ENT_LDATA), (FLG_SG_P_TYPE | FLG_SG_P_FLAGS)), #endif /* psg_dynamic */ SG_DESC_INIT(SGID_DYN, PT_DYNAMIC, 0, NULL, (FLG_SG_P_TYPE | FLG_SG_P_FLAGS)), /* psg_sunwdtrace */ SG_DESC_INIT(SGID_DTRACE, PT_SUNWDTRACE, 0, NULL, (FLG_SG_P_TYPE | FLG_SG_P_FLAGS)), /* psg_tls */ SG_DESC_INIT(SGID_TLS, PT_TLS, PF_R, NULL, (FLG_SG_P_TYPE | FLG_SG_P_FLAGS)), /* psg_unwind */ SG_DESC_INIT(SGID_UNWIND, PT_SUNW_UNWIND, PF_R, NULL, (FLG_SG_P_TYPE | FLG_SG_P_FLAGS)), /* psg_sunwstack */ SG_DESC_INIT(SGID_SUNWSTACK, PT_SUNWSTACK, 0, NULL, (FLG_SG_P_TYPE | FLG_SG_P_FLAGS | FLG_SG_DISABLED)), /* psg_note */ SG_DESC_INIT(SGID_NOTE, PT_NOTE, 0, MSG_ORIG(MSG_ENT_NOTE), FLG_SG_P_TYPE), /* * psg_extra * * This segment is referenced by the final entrance criteria descriptor * to catch any segment not otherwise placed. It cannot be disabled * via a mapfile. */ SG_DESC_INIT(SGID_EXTRA, PT_NULL, 0, MSG_ORIG(MSG_ENT_EXTRA), (FLG_SG_P_TYPE | FLG_SG_NODISABLE)) }; #undef SG_DESC_INIT /* * The processing of input files by the link-editor involves matching the * input file sections against an ordered list of entrance criteria * descriptors. The following template defines the built in entrance criteria * list. This list can be augmented using a mapfile. Each entrance criteria * is associated with a segment descriptor, providing the means for mapping * input sections to output segments. * * As with the segment descriptors, the EC_DESC_INIT macro is used * to reduce boilerplate clutter. */ #define EC_DESC_INIT(ec_is_name, ec_type, ec_attrmask, ec_attrbits, \ _seg_field, ec_flags) \ { NULL, NULL, ec_is_name, ec_type, ec_attrmask, ec_attrbits, \ &sg_desc.psg_ ## _seg_field, 0, FLG_EC_BUILTIN | ec_flags } static const Ent_desc ent_desc[] = { EC_DESC_INIT(NULL, SHT_NOTE, 0, 0, note, 0), #if defined(_ELF64) /* (amd64-only) */ EC_DESC_INIT(NULL, 0, SHF_ALLOC + SHF_WRITE + SHF_AMD64_LARGE, SHF_ALLOC + SHF_AMD64_LARGE, lrodata, 0), #endif EC_DESC_INIT(NULL, 0, SHF_ALLOC + SHF_WRITE, SHF_ALLOC, text, 0), /* * Explicitly assign the .tdata section to bss. The design of TLS * provides for initialized data being assigned to a .tdata section, * and uninitialized data being assigned to a .tbss section. These * sections should be laid out adjacent to each other, with little or * no gap between them. A PT_TLS program header is created that * defines the address range of the two sections. This header is * passed to libc to instantiate the appropriate thread allocation. * * By default a separate bss segment is disabled, however users can * trigger the creation of a bss segment with a mapfile. By default, * all bss sections are assigned to the data segment, and the section * identifiers of .tdata and .tbss ensure that these two sections are * adjacent to each other. * * However, if a bss segment is enabled, the adjacency of the .tdata * and .tbss sections can only be retained by having an explicit .tdata * entrance criteria. */ EC_DESC_INIT(MSG_ORIG(MSG_SCN_TDATA), 0, SHF_ALLOC + SHF_WRITE, SHF_ALLOC + SHF_WRITE, bss, 0), EC_DESC_INIT(NULL, SHT_NOBITS, SHF_ALLOC + SHF_WRITE, SHF_ALLOC + SHF_WRITE, bss, 0), #if defined(_ELF64) /* (amd64-only) */ EC_DESC_INIT(NULL, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_AMD64_LARGE, SHF_ALLOC + SHF_WRITE + SHF_AMD64_LARGE, data, 0), EC_DESC_INIT(NULL, 0, SHF_ALLOC + SHF_WRITE + SHF_AMD64_LARGE, SHF_ALLOC + SHF_WRITE + SHF_AMD64_LARGE, ldata, 0), #endif EC_DESC_INIT(NULL, 0, SHF_ALLOC + SHF_WRITE, SHF_ALLOC + SHF_WRITE, data, 0), /* * Final catchall rule sends remaining sections to "extra" * NULL segment, which has been tagged as FLG_SG_NODISABLE, * and which will therefore always accept them. */ EC_DESC_INIT(NULL, 0, 0, 0, extra, FLG_EC_CATCHALL) }; #undef EC_DESC_INIT /* * AVL comparison function for Sg_desc items in ofl_segs_avl. * * entry: * n1, n2 - pointers to nodes to be compared * * exit: * Returns -1 if (n1 < n2), 0 if they are equal, and 1 if (n1 > n2) */ static int ofl_segs_avl_cmp(const void *n1, const void *n2) { int rc; rc = strcmp(((Sg_desc *)n1)->sg_name, ((Sg_desc *)n2)->sg_name); if (rc > 0) return (1); if (rc < 0) return (-1); return (0); } /* * AVL comparison function for Ent_desc items in ofl_ents_avl. * * entry: * n1, n2 - pointers to nodes to be compared * * exit: * Returns -1 if (n1 < n2), 0 if they are equal, and 1 if (n1 > n2) */ static int ofl_ents_avl_cmp(const void *n1, const void *n2) { int rc; /* * There are entrance criteria nodes with NULL pointer names, * but they are never entered into the AVL tree. Hence, we can * assume that both nodes have names. */ rc = strcmp(((Ent_desc *)n1)->ec_name, ((Ent_desc *)n2)->ec_name); if (rc > 0) return (1); if (rc < 0) return (-1); return (0); } /* * Lookup a segment descriptor by name. * * entry: * ofl - Output descriptor * name - Name of desired segment * * exit: * On success, returns pointer to descriptor. On failure, returns NULL. */ Sg_desc * ld_seg_lookup(Ofl_desc *ofl, const char *name, avl_index_t *where) { Sg_desc sg; sg.sg_name = name; return (avl_find(&ofl->ofl_segs_avl, &sg, where)); } /* * Look up an entrance criteria record by name * * entry: * mf - Mapfile descriptor * name - Name of entrance criteria to locate * * exit: * On success, a pointer to the entrace criteria record is * returned. On failure, NULL is returned. * * note: * Entrance criteria are not required to have names. Only * named entrance criteria can be looked up via this method. */ Ent_desc * ld_ent_lookup(Ofl_desc *ofl, const char *name, avl_index_t *where) { Ent_desc en; en.ec_name = name; return (avl_find(&ofl->ofl_ents_avl, &en, where)); } /* * Initialize new entrance and segment descriptors and add them as lists to * the output file descriptor. */ uintptr_t ld_ent_setup(Ofl_desc *ofl, Xword segalign) { Ent_desc *enp; predef_seg_t *psegs; Sg_desc *sgp; size_t idx; /* * Initialize the elf library. */ if (elf_version(EV_CURRENT) == EV_NONE) { ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_ELF_LIBELF), EV_CURRENT); return (S_ERROR); } /* * Initialize internal Global Symbol Table AVL tree */ avl_create(&ofl->ofl_symavl, &ld_sym_avl_comp, sizeof (Sym_avlnode), SGSOFFSETOF(Sym_avlnode, sav_node)); /* Initialize segment AVL tree */ avl_create(&ofl->ofl_segs_avl, ofl_segs_avl_cmp, sizeof (Sg_desc), SGSOFFSETOF(Sg_desc, sg_avlnode)); /* Initialize entrance criteria AVL tree */ avl_create(&ofl->ofl_ents_avl, ofl_ents_avl_cmp, sizeof (Ent_desc), SGSOFFSETOF(Ent_desc, ec_avlnode)); /* * Allocate and initialize writable copies of both the entrance and * segment descriptors. * * Note that on non-amd64 targets, this allocates a few more * elements than are needed. For now, we are willing to overallocate * a small amount to simplify the code. */ if ((psegs = libld_malloc(sizeof (sg_desc))) == NULL) return (S_ERROR); (void) memcpy(psegs, &sg_desc, sizeof (sg_desc)); sgp = (Sg_desc *) psegs; /* * The data segment and stack permissions can differ: * * - Architectural/ABI per-platform differences * - Whether the object is built statically or dynamically * * Those segments so affected have their program header flags * set here at runtime, rather than in the sg_desc templates above. */ psegs->psg_data.sg_phdr.p_flags = ld_targ.t_m.m_dataseg_perm; psegs->psg_bss.sg_phdr.p_flags = ld_targ.t_m.m_dataseg_perm; psegs->psg_dynamic.sg_phdr.p_flags = ld_targ.t_m.m_dataseg_perm; psegs->psg_sunwdtrace.sg_phdr.p_flags = ld_targ.t_m.m_dataseg_perm; #if defined(_ELF64) psegs->psg_ldata.sg_phdr.p_flags = ld_targ.t_m.m_dataseg_perm; psegs->psg_sunwdtrace.sg_phdr.p_flags |= PF_X; #endif psegs->psg_sunwstack.sg_phdr.p_flags = ld_targ.t_m.m_stack_perm; if ((ofl->ofl_flags & FLG_OF_DYNAMIC) == 0) psegs->psg_data.sg_phdr.p_flags |= PF_X; /* * Traverse the new entrance descriptor list converting the segment * pointer entries to the absolute address within the new segment * descriptor list. Add each entrance descriptor to the output file * list. */ if ((enp = libld_malloc(sizeof (ent_desc))) == NULL) return (S_ERROR); (void) memcpy(enp, ent_desc, sizeof (ent_desc)); for (idx = 0; idx < (sizeof (ent_desc) / sizeof (ent_desc[0])); idx++, enp++) { #if defined(_ELF64) /* Don't use the amd64 entry conditions for non-amd64 targets */ if ((enp->ec_attrmask & SHF_AMD64_LARGE) && (ld_targ.t_m.m_mach != EM_AMD64)) continue; #endif if (aplist_append(&ofl->ofl_ents, enp, AL_CNT_OFL_ENTRANCE) == NULL) return (S_ERROR); /* * The segment pointer is currently pointing at a template * segment descriptor in sg_desc. Compute its array index, * and then use that index to compute the address of the * corresponding descriptor in the writable copy. */ enp->ec_segment = &sgp[(enp->ec_segment - (Sg_desc *) &sg_desc)]; } /* * Add each segment descriptor to the segment descriptor list. The * ones with non-NULL sg_name are also entered into the AVL tree. * For each loadable segment initialize a default alignment. Note * that ld(1) and ld.so.1 initialize this differently. */ for (idx = 0; idx < predef_seg_nelts; idx++, sgp++) { Phdr *phdr = &(sgp->sg_phdr); #if defined(_ELF64) /* Ignore amd64 segment templates for non-amd64 targets */ switch (sgp->sg_id) { case SGID_LRODATA: case SGID_LDATA: if ((ld_targ.t_m.m_mach != EM_AMD64)) continue; } #endif if (phdr->p_type == PT_LOAD) phdr->p_align = segalign; if ((aplist_append(&ofl->ofl_segs, sgp, AL_CNT_SEGMENTS)) == NULL) return (S_ERROR); #ifndef NDEBUG /* assert() is enabled */ /* * Enforce the segment name rule: Any segment that can * be referenced by an entrance descriptor must have * a name. Any segment that cannot, must have a NULL * name pointer. */ switch (phdr->p_type) { case PT_LOAD: case PT_NOTE: case PT_NULL: assert(sgp->sg_name != NULL); break; default: assert(sgp->sg_name == NULL); break; } #endif /* * Add named segment descriptors to the AVL tree to * provide O(logN) lookups. */ if (sgp->sg_name != NULL) avl_add(&ofl->ofl_segs_avl, sgp); } return (1); }
