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) 2000, 2010, Oracle and/or its affiliates. All rights reserved.
  24  */
  25 
  26 #include        <stdio.h>
  27 #include        <string.h>
  28 #include        <link.h>
  29 #include        <debug.h>
  30 #include        "msg.h"
  31 #include        "_libld.h"
  32 
  33 /*
  34  * Determine whether a (COMDAT) group has already been encountered.  If so,
  35  * indicate that the group descriptor has an overriding group (gd_oisc).  This
  36  * indication triggers the ld_place_section() to discard this group, while the
  37  * gd_oisc information provides for complete diagnostics of the override.
  38  * Otherwise, this is the first occurrence of this group, therefore the group
  39  * descriptor is saved for future comparisons.
  40  */
  41 static uintptr_t
  42 gpavl_loaded(Ofl_desc *ofl, Group_desc *gdp)
  43 {
  44         Isd_node        isd, *isdp;
  45         avl_tree_t      *avlt;
  46         avl_index_t     where;
  47 
  48         /*
  49          * Create a groups avl tree if required.
  50          */
  51         if ((avlt = ofl->ofl_groups) == NULL) {
  52                 if ((avlt = libld_calloc(sizeof (avl_tree_t), 1)) == NULL)
  53                         return (S_ERROR);
  54                 avl_create(avlt, isdavl_compare, sizeof (Isd_node),
  55                     SGSOFFSETOF(Isd_node, isd_avl));
  56                 ofl->ofl_groups = avlt;
  57         }
  58 
  59         /*
  60          * An SHT_GROUP section is identified by the name of its signature
  61          * symbol rather than section name. Although the section names are
  62          * often unique, this is not required, and some compilers set it to
  63          * a generic name like ".group".
  64          */
  65         isd.isd_name = gdp->gd_name;
  66         isd.isd_hash = sgs_str_hash(isd.isd_name);
  67 
  68         if ((isdp = avl_find(avlt, &isd, &where)) != NULL) {
  69                 gdp->gd_oisc = isdp->isd_isp;
  70                 return (1);
  71         }
  72 
  73         /*
  74          * This is a new group - so keep it.
  75          */
  76         if ((isdp = libld_calloc(sizeof (Isd_node), 1)) == NULL)
  77                 return (S_ERROR);
  78 
  79         isdp->isd_name = isd.isd_name;
  80         isdp->isd_hash = isd.isd_hash;
  81         isdp->isd_isp = gdp->gd_isc;
  82 
  83         avl_insert(avlt, isdp, where);
  84         return (0);
  85 }
  86 
  87 Group_desc *
  88 ld_get_group(Ofl_desc *ofl, Is_desc *isp)
  89 {
  90         Ifl_desc        *ifl = isp->is_file;
  91         uint_t          scnndx = isp->is_scnndx;
  92         Group_desc      *gdp;
  93         Aliste          idx;
  94 
  95         /*
  96          * Scan the GROUP sections associated with this file to find the
  97          * matching group section.
  98          */
  99         for (ALIST_TRAVERSE(ifl->ifl_groups, idx, gdp)) {
 100                 size_t  ndx;
 101                 Word    *data;
 102 
 103                 if (isp->is_shdr->sh_type == SHT_GROUP) {
 104                         if (isp->is_scnndx == gdp->gd_isc->is_scnndx)
 105                                 return (gdp);
 106                         continue;
 107                 }
 108 
 109                 data = gdp->gd_data;
 110                 for (ndx = 1; ndx < gdp->gd_cnt; ndx++) {
 111                         if (data[ndx] == scnndx)
 112                                 return (gdp);
 113                 }
 114         }
 115 
 116         ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_ELF_NOGROUPSECT),
 117             ifl->ifl_name, EC_WORD(isp->is_scnndx), isp->is_name);
 118         return (NULL);
 119 }
 120 
 121 uintptr_t
 122 ld_group_process(Is_desc *gisc, Ofl_desc *ofl)
 123 {
 124         Ifl_desc        *gifl = gisc->is_file;
 125         Shdr            *sshdr, *gshdr = gisc->is_shdr;
 126         Is_desc         *isc;
 127         Sym             *sym;
 128         const char      *str;
 129         Group_desc      gd;
 130         size_t          ndx;
 131         int             gnu_stt_section;
 132 
 133         /*
 134          * Confirm that the sh_link points to a valid section.
 135          */
 136         if ((gshdr->sh_link == SHN_UNDEF) ||
 137             (gshdr->sh_link >= gifl->ifl_shnum) ||
 138             ((isc = gifl->ifl_isdesc[gshdr->sh_link]) == NULL)) {
 139                 ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_FIL_INVSHLINK),
 140                     gifl->ifl_name, EC_WORD(gisc->is_scnndx),
 141                     gisc->is_name, EC_XWORD(gshdr->sh_link));
 142                 return (0);
 143         }
 144         if (gshdr->sh_entsize == 0) {
 145                 ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_FIL_INVSHENTSIZE),
 146                     gifl->ifl_name, EC_WORD(gisc->is_scnndx), gisc->is_name,
 147                     EC_XWORD(gshdr->sh_entsize));
 148                 return (0);
 149         }
 150 
 151         /*
 152          * Get the associated symbol table.  Sanity check the sh_info field
 153          * (which points to the signature symbol table entry) against the size
 154          * of the symbol table.
 155          */
 156         sshdr = isc->is_shdr;
 157         sym = (Sym *)isc->is_indata->d_buf;
 158 
 159         if ((sshdr->sh_info == SHN_UNDEF) ||
 160             (gshdr->sh_info >= (Word)(sshdr->sh_size / sshdr->sh_entsize)) ||
 161             ((isc = gifl->ifl_isdesc[sshdr->sh_link]) == NULL)) {
 162                 ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_FIL_INVSHINFO),
 163                     gifl->ifl_name, EC_WORD(gisc->is_scnndx), gisc->is_name,
 164                     EC_XWORD(gshdr->sh_info));
 165                 return (0);
 166         }
 167 
 168         sym += gshdr->sh_info;
 169 
 170         /*
 171          * Get the symbol name from the associated string table.
 172          */
 173         str = (char *)isc->is_indata->d_buf;
 174         str += sym->st_name;
 175 
 176         /*
 177          * The GNU assembler can use section symbols as the signature symbol
 178          * as described by this comment in the gold linker (found via google):
 179          *
 180          *      It seems that some versions of gas will create a section group
 181          *      associated with a section symbol, and then fail to give a name
 182          *      to the section symbol.  In such a case, use the name of the
 183          *      section.
 184          *
 185          * In order to support such objects, we do the same.
 186          */
 187         gnu_stt_section = ((sym->st_name == 0) || (*str == '\0')) &&
 188             (ELF_ST_TYPE(sym->st_info) == STT_SECTION);
 189         if (gnu_stt_section)
 190                 str = gisc->is_name;
 191 
 192 
 193         /*
 194          * Generate a group descriptor.
 195          */
 196         gd.gd_isc = gisc;
 197         gd.gd_oisc = NULL;
 198         gd.gd_name = str;
 199         gd.gd_data = gisc->is_indata->d_buf;
 200         gd.gd_cnt = gisc->is_indata->d_size / sizeof (Word);
 201 
 202         /*
 203          * If this group is a COMDAT group, validate the signature symbol.
 204          */
 205         if ((gd.gd_data[0] & GRP_COMDAT) && !gnu_stt_section &&
 206             ((ELF_ST_BIND(sym->st_info) == STB_LOCAL) ||
 207             (sym->st_shndx == SHN_UNDEF))) {
 208                 /* If section symbol, construct a printable name for it */
 209                 if (ELF_ST_TYPE(sym->st_info) == STT_SECTION) {
 210                         if (gisc->is_sym_name == NULL)
 211                                 (void) ld_stt_section_sym_name(gisc);
 212 
 213                         if (gisc->is_sym_name != NULL)
 214                                 str = gisc->is_sym_name;
 215                 }
 216 
 217                 ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_GRP_INVALSYM),
 218                     gifl->ifl_name, EC_WORD(gisc->is_scnndx),
 219                     gisc->is_name, str);
 220                 return (0);
 221         }
 222 
 223         /*
 224          * Validate the section indices within the group.  If this is a COMDAT
 225          * group, mark each section as COMDAT.
 226          */
 227         for (ndx = 1; ndx < gd.gd_cnt; ndx++) {
 228                 Word    gndx;
 229 
 230                 if ((gndx = gd.gd_data[ndx]) >= gifl->ifl_shnum) {
 231                         ld_eprintf(ofl, ERR_FATAL,
 232                             MSG_INTL(MSG_GRP_INVALNDX), gifl->ifl_name,
 233                             EC_WORD(gisc->is_scnndx), gisc->is_name, ndx, gndx);
 234                         return (0);
 235                 }
 236 
 237                 if (gd.gd_data[0] & GRP_COMDAT)
 238                         gifl->ifl_isdesc[gndx]->is_flags |= FLG_IS_COMDAT;
 239         }
 240 
 241         /*
 242          * If this is a COMDAT group, determine whether this group has already
 243          * been encountered, or whether this is the first instance of the group.
 244          */
 245         if ((gd.gd_data[0] & GRP_COMDAT) &&
 246             (gpavl_loaded(ofl, &gd) == S_ERROR))
 247                 return (S_ERROR);
 248 
 249         /*
 250          * Associate the group descriptor with this input file.
 251          */
 252         if (alist_append(&(gifl->ifl_groups), &gd, sizeof (Group_desc),
 253             AL_CNT_IFL_GROUPS) == NULL)
 254                 return (S_ERROR);
 255 
 256         return (1);
 257 }