usr/src/cmd/sgs/libld/common/groups.c

   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 /*
 122  * When creating a .debug_macro section, in an attempt to make certain DWARF
 123  * macro information shareable, the GNU compiler must construct group sections
 124  * with a repeatable signature symbol while nevertheless having no actual
 125  * symbol to refer to (because it relates to macros).
 126  *
 127  * We use this as yet another way to clue ourselves in that sloppy relocation
 128  * will likely be required.
 129  *
 130  * The format of these gensym'd names is:
 131  *    wm<offset size>.<encoded path name>.<lineno>.<32byte hash>
 132  * Where the encoded file name may be absent.
 133  */
 134 static boolean_t
 135 is_header_gensym(const char *name)
 136 {
 137         const char      *c = NULL;
 138         size_t          len = strlen(name);
 139
 140         /* No room for leader, hash, and periods */
 141         if (len < 37)
 142                 return (B_FALSE);
 143
 144         if ((strncmp(name, "wm4.", 4) != 0) &&
 145             strncmp(name, "wm8.", 4) != 0)
 146                 return (B_FALSE);
 147
 148         c = &name[len - 33];
 149         if (*c++ != '.')
 150                 return (B_FALSE);
 151
 152         for (; *c != '\0'; c++) {
 153                 if (!(((*c >= 'a') && (*c <= 'f')) ||
 154                     ((*c >= '0') && (*c <= '9')))) {
 155                         return (B_FALSE);
 156                 }
 157         }
 158
 159         return (B_TRUE);
 160 }
 161
 162 uintptr_t
 163 ld_group_process(Is_desc *gisc, Ofl_desc *ofl)
 164 {
 165         Ifl_desc        *gifl = gisc->is_file;
 166         Shdr            *sshdr, *gshdr = gisc->is_shdr;
 167         Is_desc         *isc;
 168         Sym             *sym;
 169         const char      *str;
 170         Group_desc      gd;
 171         size_t          ndx;
 172         int             gnu_stt_section;
 173
 174         /*
 175          * Confirm that the sh_link points to a valid section.
 176          */
 177         if ((gshdr->sh_link == SHN_UNDEF) ||
 178             (gshdr->sh_link >= gifl->ifl_shnum) ||
 179             ((isc = gifl->ifl_isdesc[gshdr->sh_link]) == NULL)) {
 180                 ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_FIL_INVSHLINK),
 181                     gifl->ifl_name, EC_WORD(gisc->is_scnndx),
 182                     gisc->is_name, EC_XWORD(gshdr->sh_link));
 183                 return (0);
 184         }
 185         if (gshdr->sh_entsize == 0) {
 186                 ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_FIL_INVSHENTSIZE),
 187                     gifl->ifl_name, EC_WORD(gisc->is_scnndx), gisc->is_name,
 188                     EC_XWORD(gshdr->sh_entsize));
 189                 return (0);
 190         }
 191
 192         /*
 193          * Get the associated symbol table.  Sanity check the sh_info field
 194          * (which points to the signature symbol table entry) against the size
 195          * of the symbol table.
 196          */
 197         sshdr = isc->is_shdr;
 198         sym = (Sym *)isc->is_indata->d_buf;
 199
 200         if ((sshdr->sh_info == SHN_UNDEF) ||
 201             (gshdr->sh_info >= (Word)(sshdr->sh_size / sshdr->sh_entsize)) ||
 202             ((isc = gifl->ifl_isdesc[sshdr->sh_link]) == NULL)) {
 203                 ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_FIL_INVSHINFO),
 204                     gifl->ifl_name, EC_WORD(gisc->is_scnndx), gisc->is_name,
 205                     EC_XWORD(gshdr->sh_info));
 206                 return (0);
 207         }
 208
 209         sym += gshdr->sh_info;
 210
 211         /*
 212          * Get the symbol name from the associated string table.
 213          */
 214         str = (char *)isc->is_indata->d_buf;
 215         str += sym->st_name;
 216
 217         /*
 218          * The GNU assembler can use section symbols as the signature symbol
 219          * as described by this comment in the gold linker (found via google):
 220          *
 221          *      It seems that some versions of gas will create a section group
 222          *      associated with a section symbol, and then fail to give a name
 223          *      to the section symbol.  In such a case, use the name of the
 224          *      section.
 225          *
 226          * In order to support such objects, we do the same.
 227          */
 228         gnu_stt_section = ((sym->st_name == 0) || (*str == '\0')) &&
 229             (ELF_ST_TYPE(sym->st_info) == STT_SECTION);
 230         if (gnu_stt_section)
 231                 str = gisc->is_name;
 232
 233
 234         /*
 235          * Generate a group descriptor.
 236          */
 237         gd.gd_isc = gisc;
 238         gd.gd_oisc = NULL;
 239         gd.gd_name = str;
 240         gd.gd_data = gisc->is_indata->d_buf;
 241         gd.gd_cnt = gisc->is_indata->d_size / sizeof (Word);
 242
 243         /*
 244          * If the signature symbol is a name generated by the GNU compiler to
 245          * refer to a header, we need sloppy relocation.
 246          */
 247         if (is_header_gensym(str)) {
 248                 if ((ofl->ofl_flags1 & FLG_OF1_NRLXREL) == 0)
 249                         ofl->ofl_flags1 |= FLG_OF1_RLXREL;
 250                 DBG_CALL(Dbg_sec_gnu_comdat(ofl->ofl_lml, gisc, TRUE,
 251                     (ofl->ofl_flags1 & FLG_OF1_RLXREL) != 0));
 252         }
 253
 254         /*
 255          * Validate the section indices within the group.  If this is a COMDAT
 256          * group, mark each section as COMDAT.
 257          */
 258         for (ndx = 1; ndx < gd.gd_cnt; ndx++) {
 259                 Word    gndx;
 260
 261                 if ((gndx = gd.gd_data[ndx]) >= gifl->ifl_shnum) {
 262                         ld_eprintf(ofl, ERR_FATAL,
 263                             MSG_INTL(MSG_GRP_INVALNDX), gifl->ifl_name,
 264                             EC_WORD(gisc->is_scnndx), gisc->is_name, ndx, gndx);
 265                         return (0);
 266                 }
 267
 268                 if (gd.gd_data[0] & GRP_COMDAT)
 269                         gifl->ifl_isdesc[gndx]->is_flags |= FLG_IS_COMDAT;
 270         }
 271
 272         /*
 273          * If this is a COMDAT group, determine whether this group has already
 274          * been encountered, or whether this is the first instance of the group.
 275          */
 276         if ((gd.gd_data[0] & GRP_COMDAT) &&
 277             (gpavl_loaded(ofl, &gd) == S_ERROR))
 278                 return (S_ERROR);
 279
 280         /*
 281          * Associate the group descriptor with this input file.
 282          */
 283         if (alist_append(&(gifl->ifl_groups), &gd, sizeof (Group_desc),
 284             AL_CNT_IFL_GROUPS) == NULL)
 285                 return (S_ERROR);
 286
 287         return (1);
 288 }