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) 1988 AT&T
  24  *        All Rights Reserved
  25  *
  26  * Copyright (c) 1991, 2010, Oracle and/or its affiliates. All rights reserved.
  27  * Copyright (c) 2012, Joyent, Inc. All rights reserved.
  28  */
  29 
  30 /*
  31  * Map file parsing and input section to output segment mapping.
  32  */
  33 #include        <stdio.h>
  34 #include        <string.h>
  35 #include        <debug.h>
  36 #include        "msg.h"
  37 #include        "_libld.h"
  38 
  39 /*
  40  * Each time a section is placed, the function set_addralign()
  41  * is called.  This function performs:
  42  *
  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.
  48  */
  49 static void
  50 set_addralign(Ofl_desc *ofl, Os_desc *osp, Is_desc *isp)
  51 {
  52         Shdr    *shdr = isp->is_shdr;
  53 
  54         /* A discarded section has no influence on the output */
  55         if (isp->is_flags & FLG_IS_DISCARD)
  56                 return;
  57 
  58         /*
  59          * If this section has data or will be assigned data
  60          * later, mark this segment not-empty.
  61          */
  62         if ((shdr->sh_size != 0) ||
  63             ((isp->is_flags & FLG_IS_EXTERNAL) == 0))
  64                 osp->os_sgdesc->sg_flags |= FLG_SG_PHREQ;
  65 
  66         if ((ofl->ofl_dtflags_1 & DF_1_NOHDR) &&
  67             (osp->os_sgdesc->sg_phdr).p_type != PT_LOAD)
  68                 return;
  69 
  70         osp->os_sgdesc->sg_align =
  71             ld_lcm(osp->os_sgdesc->sg_align, shdr->sh_addralign);
  72 }
  73 
  74 /*
  75  * Return the first input descriptor for a given output descriptor,
  76  * or NULL if there are none.
  77  */
  78 
  79 Is_desc *
  80 ld_os_first_isdesc(Os_desc *osp)
  81 {
  82         int i;
  83 
  84         for (i = 0; i < OS_ISD_NUM; i++) {
  85                 APlist *ap_isdesc = osp->os_isdescs[i];
  86 
  87                 if (aplist_nitems(ap_isdesc) > 0)
  88                         return ((Is_desc *)ap_isdesc->apl_data[0]);
  89         }
  90 
  91         return (NULL);
  92 }
  93 
  94 /*
  95  * Attach an input section to an output section
  96  *
  97  * entry:
  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.
 103  *
 104  * exit:
 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).
 109  *
 110  *      On success, returns True (1). On failure, False (0).
 111  */
 112 static int
 113 os_attach_isp(Ofl_desc *ofl, Os_desc *osp, Is_desc *isp, int mapfile_sort)
 114 {
 115         Aliste  init_arritems;
 116         int     os_isdescs_idx, do_append = 1;
 117 
 118         if ((isp->is_flags & FLG_IS_ORDERED) == 0) {
 119                 init_arritems = AL_CNT_OS_ISDESCS;
 120                 os_isdescs_idx = OS_ISD_DEFAULT;
 121 
 122                 /*
 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).
 128                  *
 129                  * If no mapfile ordering was specified, we append it in
 130                  * the usual way below.
 131                  */
 132                 if (mapfile_sort && (isp->is_ordndx > 0)) {
 133                         APlist *ap_isdesc = osp->os_isdescs[OS_ISD_DEFAULT];
 134                         Aliste  idx2;
 135                         Is_desc *isp2;
 136 
 137                         for (APLIST_TRAVERSE(ap_isdesc, idx2, isp2)) {
 138                                 if (isp2->is_ordndx &&
 139                                     (isp2->is_ordndx <= isp->is_ordndx))
 140                                                 continue;
 141 
 142                                 if (aplist_insert(
 143                                     &osp->os_isdescs[OS_ISD_DEFAULT],
 144                                     isp, init_arritems, idx2) == NULL)
 145                                         return (0);
 146                                 do_append = 0;
 147                                 break;
 148                         }
 149                 }
 150         } else {                /* Ordered section (via shdr flags) */
 151                 Word shndx;
 152 
 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;
 156 
 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;
 163                 } else {
 164                         init_arritems = AL_CNT_OS_ISDESCS;
 165                         os_isdescs_idx = OS_ISD_ORDERED;
 166                 }
 167         }
 168 
 169         /*
 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.
 173          */
 174         if (do_append && aplist_append(&(osp->os_isdescs[os_isdescs_idx]),
 175             isp, init_arritems) == NULL)
 176                 return (0);
 177         isp->is_osdesc = osp;
 178 
 179         /*
 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.
 187          */
 188         if (((isp->is_shdr->sh_flags & (SHF_MERGE | SHF_STRINGS)) !=
 189             (SHF_MERGE | SHF_STRINGS)) ||
 190             ((ofl->ofl_flags1 & FLG_OF1_NCSTTAB) != 0) ||
 191             !do_append ||
 192             ((isp->is_flags & (FLG_IS_ORDERED | FLG_IS_GNSTRMRG)) != 0))
 193                 return (1);
 194 
 195         /*
 196          * Skip sections with (sh_entsize > 1) or (sh_addralign > 1).
 197          *
 198          * sh_entsize:
 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.
 203          *
 204          * sh_addralign:
 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.
 208          */
 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));
 212                 return (1);
 213         }
 214 
 215         if (aplist_append(&osp->os_mstrisdescs, isp,
 216             AL_CNT_OS_MSTRISDESCS) == NULL)
 217                 return (0);
 218 
 219         /*
 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.
 224          */
 225         isp->is_flags |= FLG_IS_INSTRMRG;
 226 
 227         return (1);
 228 }
 229 
 230 /*
 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.
 234  */
 235 static uintptr_t
 236 add_comdat(Ofl_desc *ofl, Os_desc *osp, Is_desc *isp)
 237 {
 238         Isd_node        isd, *isdp;
 239         avl_tree_t      *avlt;
 240         avl_index_t     where;
 241 
 242         /*
 243          * Create a COMDAT avl tree for this output section if required.
 244          */
 245         if ((avlt = osp->os_comdats) == NULL) {
 246                 if ((avlt = libld_calloc(sizeof (avl_tree_t), 1)) == NULL)
 247                         return (S_ERROR);
 248                 avl_create(avlt, isdavl_compare, sizeof (Isd_node),
 249                     SGSOFFSETOF(Isd_node, isd_avl));
 250                 osp->os_comdats = avlt;
 251         }
 252 
 253         /*
 254          * A standard COMDAT section uses the section name as search key.
 255          */
 256         isd.isd_name = isp->is_name;
 257         isd.isd_hash = sgs_str_hash(isd.isd_name);
 258 
 259         if ((isdp = avl_find(avlt, &isd, &where)) != NULL) {
 260                 isp->is_osdesc = osp;
 261 
 262                 /*
 263                  * If this section hasn't already been identified as discarded,
 264                  * generate a suitable diagnostic.
 265                  */
 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,
 270                             isdp->isd_isp));
 271                 }
 272 
 273                 /*
 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.
 280                  */
 281                 return (0);
 282         }
 283 
 284         /*
 285          * This is a new COMDAT section - so keep it.
 286          */
 287         if ((isdp = libld_calloc(sizeof (Isd_node), 1)) == NULL)
 288                 return (S_ERROR);
 289 
 290         isdp->isd_name = isd.isd_name;
 291         isdp->isd_hash = isd.isd_hash;
 292         isdp->isd_isp = isp;
 293 
 294         avl_insert(avlt, isdp, where);
 295         return (1);
 296 }
 297 
 298 /*
 299  * Determine whether a GNU group COMDAT section name follows the convention
 300  *
 301  *      section-name.symbol-name
 302  *
 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.
 307  */
 308 static char *
 309 gnu_comdat_sym(Ifl_desc *ifl, Is_desc *gisp)
 310 {
 311         size_t  ndx;
 312 
 313         for (ndx = 1; ndx < ifl->ifl_shnum; ndx++) {
 314                 Is_desc *isp;
 315                 size_t  ssize;
 316 
 317                 if (((isp = ifl->ifl_isdesc[ndx]) == NULL) ||
 318                     (isp == gisp) || (isp->is_name == NULL))
 319                         continue;
 320 
 321                 /*
 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.
 326                  */
 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]);
 331         }
 332         return (NULL);
 333 }
 334 
 335 /*
 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
 339  * section name.
 340  *
 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
 355  */
 356 #define NSTR_CH1(ch) (*(nstr + 1) == (ch))
 357 #define NSTR_CH2(ch) (*(nstr + 2) == (ch))
 358 #define NSTR_CH3(ch) (*(nstr + 3) == (ch))
 359 
 360 static const char *
 361 gnu_linkonce_sec(const char *ostr)
 362 {
 363         const char      *nstr = &ostr[MSG_SCN_GNU_LINKONCE_SIZE];
 364 
 365         switch (*nstr) {
 366         case 'b':
 367                 if (NSTR_CH1('.'))
 368                         return (MSG_ORIG(MSG_SCN_BSS));
 369                 break;
 370         case 'd':
 371                 if (NSTR_CH1('.'))
 372                         return (MSG_ORIG(MSG_SCN_DATA));
 373                 break;
 374         case 'l':
 375                 if (NSTR_CH1('.'))
 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));
 381                 break;
 382         case 'r':
 383                 if (NSTR_CH1('.'))
 384                         return (MSG_ORIG(MSG_SCN_RODATA));
 385                 break;
 386         case 's':
 387                 if (NSTR_CH1('.'))
 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));
 395                 break;
 396         case 't':
 397                 if (NSTR_CH1('.'))
 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));
 403                 break;
 404         case 'w':
 405                 if (NSTR_CH1('i') && NSTR_CH2('.'))
 406                         return (MSG_ORIG(MSG_SCN_DEBUG_INFO));
 407                 break;
 408         default:
 409                 break;
 410         }
 411 
 412         /*
 413          * No special name match found.
 414          */
 415         return (ostr);
 416 }
 417 #undef  NSTR_CH1
 418 #undef  NSTR_CH2
 419 #undef  NSTR_CH3
 420 
 421 
 422 /*
 423  * Initialize a path info buffer for use with ld_place_section().
 424  *
 425  * entry:
 426  *      ofl - Output descriptor
 427  *      ifl - Descriptor for input file, or NULL if there is none.
 428  *      info - Address of buffer to be initialized.
 429  *
 430  * exit:
 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.
 435  *
 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.
 440  */
 441 Place_path_info *
 442 ld_place_path_info_init(Ofl_desc *ofl, Ifl_desc *ifl, Place_path_info *info)
 443 {
 444         /*
 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).
 448          */
 449         if ((ifl == NULL) || !(ofl->ofl_flags & FLG_OF_EC_FILES))
 450                 return (NULL);
 451 
 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;
 455 
 456         /*
 457          * The basename is the final segment of the path, equivalent to
 458          * the path itself if there are no '/' delimiters.
 459          */
 460         info->ppi_bname = strrchr(info->ppi_path, '/');
 461         if (info->ppi_bname == NULL)
 462                 info->ppi_bname = info->ppi_path;
 463         else
 464                 info->ppi_bname++;   /* Skip leading '/' */
 465         info->ppi_bname_len =
 466             info->ppi_path_len - (info->ppi_bname - info->ppi_path);
 467 
 468         /*
 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.
 472          */
 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);
 481         } else {
 482                 info->ppi_oname = info->ppi_bname;
 483                 info->ppi_oname_len = info->ppi_bname_len;
 484         }
 485 
 486         return (info);
 487 }
 488 
 489 /*
 490  * Compare an input section path to the file comparison list the given
 491  * entrance criteria.
 492  *
 493  * entry:
 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.
 499  *
 500  * exit:
 501  *      Return TRUE if a match is seen, and FALSE otherwise.
 502  */
 503 static Boolean
 504 eval_ec_files(Place_path_info *path_info, Ent_desc *enp)
 505 {
 506         Aliste          idx;
 507         Ent_desc_file   *edfp;
 508         size_t          cmp_len;
 509         const char      *cmp_str;
 510 
 511         for (ALIST_TRAVERSE(enp->ec_files, idx, edfp)) {
 512                 Word    type = edfp->edf_flags & TYP_ECF_MASK;
 513 
 514                 /*
 515                  * Determine the starting character, and # of characters,
 516                  * from the file path to compare against this entrance criteria
 517                  * file string.
 518                  */
 519                 if (type == TYP_ECF_OBJNAME) {
 520                         cmp_str = path_info->ppi_oname;
 521                         cmp_len = path_info->ppi_oname_len;
 522                 } else {
 523                         int ar_stat_diff = path_info->ppi_isar !=
 524                             ((edfp->edf_flags & FLG_ECF_ARMEMBER) != 0);
 525 
 526                         /*
 527                          * If the entrance criteria specifies an archive member
 528                          * and the file does not, then there can be no match.
 529                          */
 530 
 531                         if (ar_stat_diff && !path_info->ppi_isar)
 532                                 continue;
 533 
 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;
 540                         }
 541 
 542                         /*
 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.
 548                          */
 549                         if (ar_stat_diff && path_info->ppi_isar)
 550                                 cmp_len = path_info->ppi_oname - cmp_str - 1;
 551                 }
 552 
 553                 /*
 554                  * Compare the resulting string to the one from the
 555                  * entrance criteria.
 556                  */
 557                 if ((cmp_len == edfp->edf_name_len) &&
 558                     (strncmp(edfp->edf_name, cmp_str, cmp_len) == 0))
 559                         return (TRUE);
 560         }
 561 
 562         return (FALSE);
 563 }
 564 
 565 /*
 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.
 569  *
 570  * entry:
 571  *      isp - Input section to replace
 572  *      sh_type - New section type to apply
 573  *
 574  * exit:
 575  *      Returns the pointer to the new section header on success, and
 576  *      NULL for failure.
 577  */
 578 static Shdr *
 579 isp_convert_type(Is_desc *isp, Word sh_type)
 580 {
 581         Shdr    *shdr;
 582 
 583         if ((shdr = libld_malloc(sizeof (Shdr))) == NULL)
 584                 return (NULL);
 585         *shdr = *isp->is_shdr;
 586         isp->is_shdr = shdr;
 587         shdr->sh_type = sh_type;
 588         return (shdr);
 589 }
 590 
 591 /*
 592  * Issue a fatal warning for the given .eh_frame section, which
 593  * cannot be merged with the existing .eh_frame output section.
 594  */
 595 static void
 596 eh_frame_muldef(Ofl_desc *ofl, Is_desc *isp)
 597 {
 598         Sg_desc *sgp;
 599         Is_desc *isp1;
 600         Os_desc *osp;
 601         Aliste  idx1, idx2, idx3;
 602 
 603         /*
 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.
 607          */
 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)
 611                                 continue;
 612 
 613                         for (idx3 = 0; idx3 < OS_ISD_NUM; idx3++) {
 614                                 APlist *lst = osp->os_isdescs[idx3];
 615 
 616                                 if (aplist_nitems(lst) == 0)
 617                                         continue;
 618 
 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);
 626                                 return;
 627                         }
 628                 }
 629         }
 630 }
 631 
 632 /*
 633  * Place a section into the appropriate segment and output section.
 634  *
 635  * entry:
 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.
 647  */
 648 Os_desc *
 649 ld_place_section(Ofl_desc *ofl, Is_desc *isp, Place_path_info *path_info,
 650     int ident, const char *alt_os_name)
 651 {
 652         Ent_desc        *enp;
 653         Sg_desc         *sgp;
 654         Os_desc         *osp;
 655         Aliste          idx1, iidx;
 656         int             os_ndx;
 657         Shdr            *shdr = isp->is_shdr;
 658         Xword           shflagmask, shflags = shdr->sh_flags;
 659         Ifl_desc        *ifl = isp->is_file;
 660         char            *oname, *sname;
 661         uint_t          onamehash;
 662         Boolean         is_ehframe = (isp->is_flags & FLG_IS_EHFRAME) != 0;
 663 
 664         /*
 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).
 668          */
 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) */
 679                 0
 680         };
 681 
 682         DBG_CALL(Dbg_sec_in(ofl->ofl_lml, isp));
 683 
 684         /*
 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
 687          * still required.
 688          */
 689         if ((shflags & SHF_GROUP) || (shdr->sh_type == SHT_GROUP)) {
 690                 Group_desc      *gdesc;
 691 
 692                 if ((gdesc = ld_get_group(ofl, isp)) != NULL) {
 693                         DBG_CALL(Dbg_sec_group(ofl->ofl_lml, isp, gdesc));
 694 
 695                         /*
 696                          * If this group has been replaced by another group,
 697                          * then this section needs to be discarded.
 698                          */
 699                         if (gdesc->gd_oisc) {
 700                                 isp->is_flags |= FLG_IS_DISCARD;
 701 
 702                                 /*
 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.
 710                                  */
 711                                 if (!(ofl->ofl_flags1 & FLG_OF1_RLXREL))
 712                                         return (NULL);
 713                         }
 714                 }
 715 
 716                 /*
 717                  * SHT_GROUP sections can only be included into relocatable
 718                  * objects.
 719                  */
 720                 if (shdr->sh_type == SHT_GROUP) {
 721                         if ((ofl->ofl_flags & FLG_OF_RELOBJ) == 0) {
 722                                 isp->is_flags |= FLG_IS_DISCARD;
 723                                 return (NULL);
 724                         }
 725                 }
 726         }
 727 
 728         /*
 729          * Always assign SHF_TLS sections to the DATA segment (and then the
 730          * PT_TLS embedded inside of there).
 731          */
 732         if (shflags & SHF_TLS)
 733                 shflags |= SHF_WRITE;
 734 
 735         /*
 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.
 740          */
 741         sgp = NULL;
 742         for (APLIST_TRAVERSE(ofl->ofl_ents, idx1, enp)) {
 743 
 744                 /* Disabled segments are not available for assignment */
 745                 if (enp->ec_segment->sg_flags & FLG_SG_DISABLED)
 746                         continue;
 747 
 748                 /*
 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.
 756                  *
 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.
 762                  */
 763                 if (enp->ec_flags & FLG_EC_CATCHALL) {
 764                         sgp = enp->ec_segment;
 765                         break;
 766                 }
 767 
 768                 if (enp->ec_type && (enp->ec_type != shdr->sh_type))
 769                         continue;
 770                 if (enp->ec_attrmask &&
 771                     /* LINTED */
 772                     (enp->ec_attrmask & enp->ec_attrbits) !=
 773                     (enp->ec_attrmask & shflags))
 774                         continue;
 775                 if (enp->ec_is_name &&
 776                     (strcmp(enp->ec_is_name, isp->is_name) != 0))
 777                         continue;
 778 
 779                 if ((alist_nitems(enp->ec_files) > 0) &&
 780                     ((path_info == NULL) || !eval_ec_files(path_info, enp)))
 781                         continue;
 782 
 783                 /* All entrance criteria tests passed */
 784                 sgp = enp->ec_segment;
 785                 break;
 786         }
 787 
 788         /*
 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
 792          * a segment.
 793          */
 794         assert(sgp != NULL);
 795 
 796         /*
 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.
 802          *
 803          * If the sort key is 0, the section is placed after the sorted
 804          * sections in the order they are encountered.
 805          */
 806         isp->is_ordndx = enp->ec_ordndx;
 807 
 808         /* Remember that this entrance criteria has placed a section */
 809         enp->ec_flags |= FLG_EC_USED;
 810 
 811         /*
 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.
 815          *
 816          * The COMDAT, SHT_GROUP and GNU name translations that follow have
 817          * the potential to alter this initial name.
 818          */
 819         oname = (char *)((alt_os_name == NULL) ? isp->is_name : alt_os_name);
 820 
 821         /*
 822          * Solaris section names may follow the convention:
 823          *
 824          *      section-name%symbol-name
 825          *
 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.
 831          *
 832          * This convention has also been followed for COMDAT and sections
 833          * identified though SHT_GROUP data.
 834          *
 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.
 839          */
 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;
 844 
 845                         if ((oname = libld_malloc(size + 1)) == NULL)
 846                                 return ((Os_desc *)S_ERROR);
 847                         (void) strncpy(oname, isp->is_name, size);
 848                         oname[size] = '\0';
 849                         DBG_CALL(Dbg_sec_redirected(ofl->ofl_lml, isp, oname));
 850                 }
 851         }
 852 
 853         /*
 854          * GNU section names may follow the convention:
 855          *
 856          *      .gnu.linkonce.*
 857          *
 858          * The .gnu.linkonce is a section naming convention that indicates a
 859          * COMDAT requirement.  Determine whether this section follows the GNU
 860          * pattern, and if so, determine whether this section should be
 861          * discarded or retained.  The comparison of is_name[1] with 'g'
 862          * is an optimization to skip using strncmp() too much. This is safe,
 863          * because we know the name is not NULL, and therefore must have
 864          * at least one character plus a NULL termination.
 865          */
 866         if (((ofl->ofl_flags & FLG_OF_RELOBJ) == 0) &&
 867             (isp->is_name == oname) && (isp->is_name[1] == 'g') &&
 868             (strncmp(MSG_ORIG(MSG_SCN_GNU_LINKONCE), isp->is_name,
 869             MSG_SCN_GNU_LINKONCE_SIZE) == 0)) {
 870                 if ((oname =
 871                     (char *)gnu_linkonce_sec(isp->is_name)) != isp->is_name) {
 872                         DBG_CALL(Dbg_sec_redirected(ofl->ofl_lml, isp, oname));
 873                 }
 874 
 875                 /*
 876                  * Explicitly identify this section type as COMDAT.  Also,
 877                  * enable relaxed relocation processing, as this is typically
 878                  * a requirement with .gnu.linkonce sections.
 879                  */
 880                 isp->is_flags |= FLG_IS_COMDAT;
 881                 if ((ofl->ofl_flags1 & FLG_OF1_NRLXREL) == 0)
 882                         ofl->ofl_flags1 |= FLG_OF1_RLXREL;
 883                 DBG_CALL(Dbg_sec_gnu_comdat(ofl->ofl_lml, isp, TRUE,
 884                     (ofl->ofl_flags1 & FLG_OF1_RLXREL) != 0));
 885         }
 886 
 887         /*
 888          * GNU section names may also follow the convention:
 889          *
 890          *      section-name.symbol-name
 891          *
 892          * This convention is used when defining SHT_GROUP sections of type
 893          * COMDAT.  Thus, any group processing will have discovered any group
 894          * sections, and this identification can be triggered by a pattern
 895          * match section names.
 896          */
 897         if (((ofl->ofl_flags & FLG_OF_RELOBJ) == 0) &&
 898             (isp->is_name == oname) && (isp->is_flags & FLG_IS_COMDAT) &&
 899             ((sname = gnu_comdat_sym(ifl, isp)) != NULL)) {
 900                 size_t  size = sname - isp->is_name;
 901 
 902                 if ((oname = libld_malloc(size + 1)) == NULL)
 903                         return ((Os_desc *)S_ERROR);
 904                 (void) strncpy(oname, isp->is_name, size);
 905                 oname[size] = '\0';
 906                 DBG_CALL(Dbg_sec_redirected(ofl->ofl_lml, isp, oname));
 907 
 908                 /*
 909                  * Enable relaxed relocation processing, as this is
 910                  * typically a requirement with GNU COMDAT sections.
 911                  */
 912                 if ((ofl->ofl_flags1 & FLG_OF1_NRLXREL) == 0) {
 913                         ofl->ofl_flags1 |= FLG_OF1_RLXREL;
 914                         DBG_CALL(Dbg_sec_gnu_comdat(ofl->ofl_lml, isp,
 915                             FALSE, TRUE));
 916                 }
 917         }
 918 
 919         /*
 920          * Assign a hash value now that the output section name has been
 921          * finalized.
 922          */
 923         onamehash = sgs_str_hash(oname);
 924 
 925         /*
 926          * Determine if output section ordering is turned on. If so, return
 927          * the appropriate ordering index for the section. This information
 928          * is derived from the Sg_desc->sg_os_order list that was built
 929          * up from the Mapfile.
 930          *
 931          * A value of 0 for os_ndx means that the section is not sorted
 932          * (i.e. is not found in the sg_os_order). The items in sg_os_order
 933          * are in the desired sort order, so adding 1 to their alist index
 934          * gives a suitable index for sorting.
 935          */
 936         os_ndx = 0;
 937         if (alist_nitems(sgp->sg_os_order) > 0) {
 938                 Sec_order       *scop;
 939 
 940                 for (ALIST_TRAVERSE(sgp->sg_os_order, idx1, scop)) {
 941                         if (strcmp(scop->sco_secname, oname) == 0) {
 942                                 scop->sco_flags |= FLG_SGO_USED;
 943                                 os_ndx = idx1 + 1;
 944                                 break;
 945                         }
 946                 }
 947         }
 948 
 949         /*
 950          * Mask of section header flags to ignore when matching sections. We
 951          * are more strict with relocatable objects, ignoring only the order
 952          * flags, and keeping sections apart if they differ otherwise. This
 953          * follows the policy that sections in a relative object should only
 954          * be merged if their flags are the same, and avoids destroying
 955          * information prematurely. For final products however, we ignore all
 956          * flags that do not prevent a merge.
 957          */
 958         shflagmask =
 959             (ofl->ofl_flags & FLG_OF_RELOBJ) ? ALL_SHF_ORDER : ALL_SHF_IGNORE;
 960 
 961         /*
 962          * Traverse the input section list for the output section we have been
 963          * assigned. If we find a matching section simply add this new section.
 964          */
 965         iidx = 0;
 966         for (APLIST_TRAVERSE(sgp->sg_osdescs, idx1, osp)) {
 967                 Shdr    *os_shdr = osp->os_shdr;
 968 
 969                 /*
 970                  * An input section matches an output section if:
 971                  * -    The ident values match
 972                  * -    The names match
 973                  * -    Not a GROUP section
 974                  * -    Not a DTrace dof section
 975                  * -    Section types match
 976                  * -    Matching section flags, after screening out the
 977                  *      shflagmask flags.
 978                  *
 979                  * Section types are considered to match if any one of
 980                  * the following are true:
 981                  * -    The type codes are the same
 982                  * -    Both are .eh_frame sections (regardless of type code)
 983                  * -    The input section is COMDAT, and the output section
 984                  *      is SHT_PROGBITS.
 985                  */
 986                 if ((ident == osp->os_identndx) &&
 987                     (ident != ld_targ.t_id.id_rel) &&
 988                     (onamehash == osp->os_namehash) &&
 989                     (shdr->sh_type != SHT_GROUP) &&
 990                     (shdr->sh_type != SHT_SUNW_dof) &&
 991                     ((shdr->sh_type == os_shdr->sh_type) ||
 992                     (is_ehframe && (osp->os_flags & FLG_OS_EHFRAME)) ||
 993                     ((shdr->sh_type == SHT_SUNW_COMDAT) &&
 994                     (os_shdr->sh_type == SHT_PROGBITS))) &&
 995                     ((shflags & ~shflagmask) ==
 996                     (os_shdr->sh_flags & ~shflagmask)) &&
 997                     (strcmp(oname, osp->os_name) == 0)) {
 998                         uintptr_t       err;
 999 
1000                         /*
1001                          * Process any COMDAT section, keeping the first and
1002                          * discarding all others.
1003                          */
1004                         if ((isp->is_flags & FLG_IS_COMDAT) &&
1005                             ((err = add_comdat(ofl, osp, isp)) != 1))
1006                                 return ((Os_desc *)err);
1007 
1008                         /*
1009                          * Set alignment
1010                          */
1011                         set_addralign(ofl, osp, isp);
1012 
1013                         /*
1014                          * If this section is a non-empty TLS section indicate
1015                          * that a PT_TLS program header is required.
1016                          */
1017                         if ((shflags & SHF_TLS) && shdr->sh_size &&
1018                             ((ofl->ofl_flags & FLG_OF_RELOBJ) == 0))
1019                                 ofl->ofl_flags |= FLG_OF_TLSPHDR;
1020 
1021                         /*
1022                          * Insert the input section descriptor on the proper
1023                          * output section descriptor list.
1024                          *
1025                          * If this segment requires input section ordering,
1026                          * honor any mapfile specified ordering for otherwise
1027                          * unordered sections by setting the mapfile_sort
1028                          * argument of os_attach_isp() to True.
1029                          */
1030 
1031                         if (os_attach_isp(ofl, osp, isp,
1032                             (sgp->sg_flags & FLG_SG_IS_ORDER) != 0) == 0)
1033                                 return ((Os_desc *)S_ERROR);
1034 
1035                         /*
1036                          * If this input section and file is associated to an
1037                          * artificially referenced output section, make sure
1038                          * they are marked as referenced also. This ensures
1039                          * that this input section and file isn't eliminated
1040                          * when -zignore is in effect.
1041                          *
1042                          * See -zignore comments when creating a new output
1043                          * section below.
1044                          */
1045                         if (((ifl &&
1046                             (ifl->ifl_flags & FLG_IF_IGNORE)) || DBG_ENABLED) &&
1047                             (osp->os_flags & FLG_OS_SECTREF)) {
1048                                 isp->is_flags |= FLG_IS_SECTREF;
1049                                 if (ifl)
1050                                         ifl->ifl_flags |= FLG_IF_FILEREF;
1051                         }
1052 
1053                         DBG_CALL(Dbg_sec_added(ofl->ofl_lml, osp, sgp));
1054                         return (osp);
1055                 }
1056 
1057                 /*
1058                  * Do we need to worry about section ordering?
1059                  */
1060                 if (os_ndx) {
1061                         if (osp->os_ordndx) {
1062                                 if (os_ndx < osp->os_ordndx)
1063                                         /* insert section here. */
1064                                         break;
1065                                 else {
1066                                         iidx = idx1 + 1;
1067                                         continue;
1068                                 }
1069                         } else {
1070                                 /* insert section here. */
1071                                 break;
1072                         }
1073                 } else if (osp->os_ordndx) {
1074                         iidx = idx1 + 1;
1075                         continue;
1076                 }
1077 
1078                 /*
1079                  * If the new sections identifier is less than that of the
1080                  * present input section we need to insert the new section
1081                  * at this point.
1082                  */
1083                 if (ident < osp->os_identndx)
1084                         break;
1085 
1086                 iidx = idx1 + 1;
1087         }
1088 
1089         /*
1090          * We are adding a new output section.  Update the section header
1091          * count and associated string size.
1092          *
1093          * If the input section triggering this output section has been marked
1094          * for discard, and if no other non-discarded input section comes along
1095          * to join it, then we will over count. We cannot know if this will
1096          * happen or not until all input is seen. Set FLG_OF_AJDOSCNT to
1097          * trigger a final count readjustment.
1098          */
1099         if (isp->is_flags & FLG_IS_DISCARD)
1100                 ofl->ofl_flags |= FLG_OF_ADJOSCNT;
1101         ofl->ofl_shdrcnt++;
1102         if (st_insert(ofl->ofl_shdrsttab, oname) == -1)
1103                 return ((Os_desc *)S_ERROR);
1104 
1105         /*
1106          * Create a new output section descriptor.
1107          */
1108         if ((osp = libld_calloc(sizeof (Os_desc), 1)) == NULL)
1109                 return ((Os_desc *)S_ERROR);
1110         if ((osp->os_shdr = libld_calloc(sizeof (Shdr), 1)) == NULL)
1111                 return ((Os_desc *)S_ERROR);
1112 
1113         /*
1114          * Convert COMDAT section to PROGBITS as this the first section of the
1115          * output section.  Save any COMDAT section for later processing, as
1116          * additional COMDAT sections that match this section need discarding.
1117          */
1118         if ((shdr->sh_type == SHT_SUNW_COMDAT) &&
1119             ((shdr = isp_convert_type(isp, SHT_PROGBITS)) == NULL))
1120                 return ((Os_desc *)S_ERROR);
1121         if ((isp->is_flags & FLG_IS_COMDAT) &&
1122             (add_comdat(ofl, osp, isp) == S_ERROR))
1123                 return ((Os_desc *)S_ERROR);
1124 
1125         if (is_ehframe) {
1126                 /*
1127                  * Executable or sharable objects can have at most a single
1128                  * .eh_frame section. Detect attempts to create more than
1129                  * one. This occurs if the input sections have incompatible
1130                  * attributes.
1131                  */
1132                 if ((ofl->ofl_flags & FLG_OF_EHFRAME) &&
1133                     !(ofl->ofl_flags & FLG_OF_RELOBJ)) {
1134                         eh_frame_muldef(ofl, isp);
1135                         return ((Os_desc *)S_ERROR);
1136                 }
1137                 ofl->ofl_flags |= FLG_OF_EHFRAME;
1138 
1139                 /*
1140                  * For .eh_frame sections, we always set the type to be the
1141                  * type specified by the ABI.  This allows .eh_frame sections
1142                  * of type SHT_PROGBITS to be correctly merged with .eh_frame
1143                  * sections of the ABI-defined type (e.g. SHT_AMD64_UNWIND),
1144                  * with the output being of the ABI-defined type.
1145                  */
1146                 osp->os_shdr->sh_type = ld_targ.t_m.m_sht_unwind;
1147         } else {
1148                 osp->os_shdr->sh_type = shdr->sh_type;
1149         }
1150 
1151         osp->os_shdr->sh_flags = shdr->sh_flags;
1152         osp->os_shdr->sh_entsize = shdr->sh_entsize;
1153         osp->os_name = oname;
1154         osp->os_namehash = onamehash;
1155         osp->os_ordndx = os_ndx;
1156         osp->os_sgdesc = sgp;
1157         if (is_ehframe)
1158                 osp->os_flags |= FLG_OS_EHFRAME;
1159 
1160         if (ifl && (shdr->sh_type == SHT_PROGBITS)) {
1161                 /*
1162                  * Try to preserve the intended meaning of sh_link/sh_info.
1163                  * See the translate_link() in update.c.
1164                  */
1165                 osp->os_shdr->sh_link = shdr->sh_link;
1166                 if (shdr->sh_flags & SHF_INFO_LINK)
1167                         osp->os_shdr->sh_info = shdr->sh_info;
1168         }
1169 
1170         /*
1171          * When -zignore is in effect, user supplied sections and files that are
1172          * not referenced from other sections, are eliminated from the object
1173          * being produced.  Some sections, although unreferenced, are special,
1174          * and must not be eliminated.  Determine if this new output section is
1175          * one of those special sections, and if so mark it artificially as
1176          * referenced.  Any input section and file associated to this output
1177          * section is also be marked as referenced, and thus won't be eliminated
1178          * from the final output.
1179          */
1180         if (ifl && ((ofl->ofl_flags1 & FLG_OF1_IGNPRC) || DBG_ENABLED)) {
1181                 const Msg       *refsec;
1182 
1183                 for (refsec = RefSecs; *refsec; refsec++) {
1184                         if (strcmp(osp->os_name, MSG_ORIG(*refsec)) == 0) {
1185                                 osp->os_flags |= FLG_OS_SECTREF;
1186 
1187                                 if ((ifl->ifl_flags & FLG_IF_IGNORE) ||
1188                                     DBG_ENABLED) {
1189                                         isp->is_flags |= FLG_IS_SECTREF;
1190                                         ifl->ifl_flags |= FLG_IF_FILEREF;
1191                                 }
1192                                 break;
1193                         }
1194                 }
1195         }
1196 
1197         /*
1198          * Sections of type SHT_GROUP are added to the ofl->ofl_osgroups list,
1199          * so that they can be updated as a group later.
1200          */
1201         if ((shdr->sh_type == SHT_GROUP) &&
1202             (aplist_append(&ofl->ofl_osgroups, osp,
1203             AL_CNT_OFL_OSGROUPS) == NULL))
1204                 return ((Os_desc *)S_ERROR);
1205 
1206         /*
1207          * If this section is a non-empty TLS section indicate that a PT_TLS
1208          * program header is required.
1209          */
1210         if ((shflags & SHF_TLS) && shdr->sh_size &&
1211             ((ofl->ofl_flags & FLG_OF_RELOBJ) == 0))
1212                 ofl->ofl_flags |= FLG_OF_TLSPHDR;
1213 
1214         /*
1215          * If a non-allocatable section is going to be put into a loadable
1216          * segment then turn on the allocate bit for this section and warn the
1217          * user that we have done so.  This could only happen through the use
1218          * of a mapfile.
1219          */
1220         if ((sgp->sg_phdr.p_type == PT_LOAD) &&
1221             ((osp->os_shdr->sh_flags & SHF_ALLOC) == 0)) {
1222                 ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_SCN_NONALLOC),
1223                     ofl->ofl_name, osp->os_name, sgp->sg_name);
1224                 osp->os_shdr->sh_flags |= SHF_ALLOC;
1225         }
1226 
1227         /*
1228          * Retain this sections identifier for future comparisons when placing
1229          * a section (after all sections have been processed this variable will
1230          * be used to hold the sections symbol index as we don't need to retain
1231          * the identifier any more).
1232          */
1233         osp->os_identndx = ident;
1234 
1235         /*
1236          * Set alignment.
1237          */
1238         set_addralign(ofl, osp, isp);
1239 
1240         if (os_attach_isp(ofl, osp, isp, 0) == 0)
1241                 return ((Os_desc *)S_ERROR);
1242 
1243         DBG_CALL(Dbg_sec_created(ofl->ofl_lml, osp, sgp));
1244 
1245         /*
1246          * Insert the new section at the offset given by iidx.  If no position
1247          * for it was identified above, this will be index 0, causing the new
1248          * section to be prepended to the beginning of the section list.
1249          * Otherwise, it is the index following the section that was identified.
1250          */
1251         if (aplist_insert(&sgp->sg_osdescs, osp, AL_CNT_SG_OSDESC,
1252             iidx) == NULL)
1253                 return ((Os_desc *)S_ERROR);
1254         return (osp);
1255 }