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         Group_desc      *gr;
 242 
 243         /*
 244          * Sections to which COMDAT groups apply are FLG_IS_COMDAT but are
 245          * discarded separately by the group logic so should never be
 246          * discarded here.
 247          */
 248         if ((isp->is_shdr->sh_flags & SHF_GROUP) &&
 249             ((gr = ld_get_group(ofl, isp)) != NULL) &&
 250             (gr->gd_data[0] & GRP_COMDAT))
 251                 return (1);
 252 
 253         /*
 254          * Create a COMDAT avl tree for this output section if required.
 255          */
 256         if ((avlt = osp->os_comdats) == NULL) {
 257                 if ((avlt = libld_calloc(sizeof (avl_tree_t), 1)) == NULL)
 258                         return (S_ERROR);
 259                 avl_create(avlt, isdavl_compare, sizeof (Isd_node),
 260                     SGSOFFSETOF(Isd_node, isd_avl));
 261                 osp->os_comdats = avlt;
 262         }
 263 
 264         /*
 265          * A standard COMDAT section uses the section name as search key.
 266          */
 267         isd.isd_name = isp->is_name;
 268         isd.isd_hash = sgs_str_hash(isd.isd_name);
 269 
 270         if ((isdp = avl_find(avlt, &isd, &where)) != NULL) {
 271                 isp->is_osdesc = osp;
 272 
 273                 /*
 274                  * If this section hasn't already been identified as discarded,
 275                  * generate a suitable diagnostic.
 276                  */
 277                 if ((isp->is_flags & FLG_IS_DISCARD) == 0) {
 278                         isp->is_flags |= FLG_IS_DISCARD;
 279                         isp->is_comdatkeep = isdp->isd_isp;
 280                         DBG_CALL(Dbg_sec_discarded(ofl->ofl_lml, isp,
 281                             isdp->isd_isp));
 282                 }
 283 
 284                 /*
 285                  * A discarded section does not require assignment to an output
 286                  * section.  However, if relaxed relocations have been enabled
 287                  * (either from -z relaxreloc, or asserted with .gnu.linkonce
 288                  * processing), then this section must still be assigned to an
 289                  * output section so that the sloppy relocation logic will have
 290                  * the information necessary to do its work.
 291                  */
 292                 return (0);
 293         }
 294 
 295         /*
 296          * This is a new COMDAT section - so keep it.
 297          */
 298         if ((isdp = libld_calloc(sizeof (Isd_node), 1)) == NULL)
 299                 return (S_ERROR);
 300 
 301         isdp->isd_name = isd.isd_name;
 302         isdp->isd_hash = isd.isd_hash;
 303         isdp->isd_isp = isp;
 304 
 305         avl_insert(avlt, isdp, where);
 306         return (1);
 307 }
 308 
 309 /*
 310  * Determine whether a GNU group COMDAT section name follows the convention
 311  *
 312  *      section-name.symbol-name
 313  *
 314  * Each section within the input file is compared to see if the full section
 315  * name matches the beginning of the COMDAT section, with a following '.'.
 316  * A pointer to the symbol name, starting with the '.' is returned so that the
 317  * caller can strip off the required section name.
 318  */
 319 static char *
 320 gnu_comdat_sym(Ifl_desc *ifl, Is_desc *gisp)
 321 {
 322         size_t  ndx;
 323 
 324         for (ndx = 1; ndx < ifl->ifl_shnum; ndx++) {
 325                 Is_desc *isp;
 326                 size_t  ssize;
 327 
 328                 if (((isp = ifl->ifl_isdesc[ndx]) == NULL) ||
 329                     (isp == gisp) || (isp->is_name == NULL))
 330                         continue;
 331 
 332                 /*
 333                  * It's questionable whether this size should be cached in the
 334                  * Is_desc.  However, this seems an infrequent operation and
 335                  * adding Is_desc members can escalate memory usage for large
 336                  * link-edits.  For now, size the section name dynamically.
 337                  */
 338                 ssize = strlen(isp->is_name);
 339                 if ((strncmp(isp->is_name, gisp->is_name, ssize) == 0) &&
 340                     (gisp->is_name[ssize] == '.'))
 341                         return ((char *)&gisp->is_name[ssize]);
 342         }
 343         return (NULL);
 344 }
 345 
 346 /*
 347  * GNU .gnu.linkonce sections follow a naming convention that indicates the
 348  * required association with an output section.  Determine whether this input
 349  * section follows the convention, and if so return the appropriate output
 350  * section name.
 351  *
 352  *      .gnu.linkonce.b.*    ->      .bss
 353  *      .gnu.linkonce.d.*    ->      .data
 354  *      .gnu.linkonce.l.*    ->      .ldata
 355  *      .gnu.linkonce.lb.*   ->      .lbss
 356  *      .gnu.linkonce.lr.*   ->      .lrodata
 357  *      .gnu.linkonce.r.*    ->      .rodata
 358  *      .gnu.linkonce.s.*    ->      .sdata
 359  *      .gnu.linkonce.s2.*   ->      .sdata2
 360  *      .gnu.linkonce.sb.*   ->      .sbss
 361  *      .gnu.linkonce.sb2.*  ->      .sbss2
 362  *      .gnu.linkonce.t.*    ->      .text
 363  *      .gnu.linkonce.tb.*   ->      .tbss
 364  *      .gnu.linkonce.td.*   ->      .tdata
 365  *      .gnu.linkonce.wi.*   ->      .debug_info
 366  */
 367 #define NSTR_CH1(ch) (*(nstr + 1) == (ch))
 368 #define NSTR_CH2(ch) (*(nstr + 2) == (ch))
 369 #define NSTR_CH3(ch) (*(nstr + 3) == (ch))
 370 
 371 static const char *
 372 gnu_linkonce_sec(const char *ostr)
 373 {
 374         const char      *nstr = &ostr[MSG_SCN_GNU_LINKONCE_SIZE];
 375 
 376         switch (*nstr) {
 377         case 'b':
 378                 if (NSTR_CH1('.'))
 379                         return (MSG_ORIG(MSG_SCN_BSS));
 380                 break;
 381         case 'd':
 382                 if (NSTR_CH1('.'))
 383                         return (MSG_ORIG(MSG_SCN_DATA));
 384                 break;
 385         case 'l':
 386                 if (NSTR_CH1('.'))
 387                         return (MSG_ORIG(MSG_SCN_LDATA));
 388                 else if (NSTR_CH1('b') && NSTR_CH2('.'))
 389                         return (MSG_ORIG(MSG_SCN_LBSS));
 390                 else if (NSTR_CH1('r') && NSTR_CH2('.'))
 391                         return (MSG_ORIG(MSG_SCN_LRODATA));
 392                 break;
 393         case 'r':
 394                 if (NSTR_CH1('.'))
 395                         return (MSG_ORIG(MSG_SCN_RODATA));
 396                 break;
 397         case 's':
 398                 if (NSTR_CH1('.'))
 399                         return (MSG_ORIG(MSG_SCN_SDATA));
 400                 else if (NSTR_CH1('2') && NSTR_CH2('.'))
 401                         return (MSG_ORIG(MSG_SCN_SDATA2));
 402                 else if (NSTR_CH1('b') && NSTR_CH2('.'))
 403                         return (MSG_ORIG(MSG_SCN_SBSS));
 404                 else if (NSTR_CH1('b') && NSTR_CH2('2') && NSTR_CH3('.'))
 405                         return (MSG_ORIG(MSG_SCN_SBSS2));
 406                 break;
 407         case 't':
 408                 if (NSTR_CH1('.'))
 409                         return (MSG_ORIG(MSG_SCN_TEXT));
 410                 else if (NSTR_CH1('b') && NSTR_CH2('.'))
 411                         return (MSG_ORIG(MSG_SCN_TBSS));
 412                 else if (NSTR_CH1('d') && NSTR_CH2('.'))
 413                         return (MSG_ORIG(MSG_SCN_TDATA));
 414                 break;
 415         case 'w':
 416                 if (NSTR_CH1('i') && NSTR_CH2('.'))
 417                         return (MSG_ORIG(MSG_SCN_DEBUG_INFO));
 418                 break;
 419         default:
 420                 break;
 421         }
 422 
 423         /*
 424          * No special name match found.
 425          */
 426         return (ostr);
 427 }
 428 #undef  NSTR_CH1
 429 #undef  NSTR_CH2
 430 #undef  NSTR_CH3
 431 
 432 /*
 433  * The GNU link-editor maps sections generated by the GNU compiler separately
 434  * due to -ffunction-sections, -fdata-sections or for other reasons into the
 435  * "normal" section represented.
 436  *
 437  * Sections are named .<main>.<symbol> where <main> is the usual section to
 438  * which it should be mapped, and <symbol> is providing the unique name for
 439  * the original section.  Both parts of the name may contain periods, in cases
 440  * where the unique part of the name contains a '.' and/or the section it
 441  * contributes to does (such as .data.rel.ro)
 442  *
 443  * .rodata.str* and .rodata.cst* are mapped to .rodata.
 444  *
 445  * As a further complication, the GNU link-editor may or may not merge
 446  * .ctors.* and .dtors.* into init_array and fini_array, rather than ctors and
 447  * dtors.  We do not implement this at this time.
 448  *
 449  * The GNU link editor may also arrange for sections with .local in their name
 450  * to be mapped as above, but grouped together.  We do not implement this (and
 451  * do not merge them at all, to make this clear)
 452  *
 453  * This table is processed in order.  Longer mappings must come first.
 454  */
 455 static struct split_sec_mapping {
 456         char *leader;
 457         char *section;
 458         boolean_t precise;
 459 } split_sec_mapping[] = {
 460         { ".bss.",                      ".bss",                 B_FALSE },
 461         { ".ctors.",                    ".ctors",               B_FALSE },
 462         { ".data.rel.local.",           ".data.rel.local",      B_FALSE },
 463         { ".data.rel.local",            ".data.rel.local",      B_TRUE },
 464         { ".data.rel.ro.local.",        ".data.rel.ro",         B_FALSE },
 465         { ".data.rel.ro.",              ".data.rel.ro",         B_FALSE },
 466         { ".data.rel.ro",               ".data.rel.ro",         B_TRUE },
 467         { ".data.rel.",                 ".data.rel",            B_FALSE },
 468         { ".data.rel",                  ".data.rel",            B_TRUE },
 469         { ".data.",                     ".data",                B_FALSE },
 470         { ".dtors.",                    ".dtors",               B_FALSE },
 471         { ".fini_array.",               ".fini_array",          B_FALSE },
 472         { ".init_array.",               ".init_array",          B_FALSE },
 473         { ".lbss.",                     ".lbss",                B_FALSE },
 474         { ".ldata.",                    ".ldata",               B_FALSE },
 475         { ".lrodata.",                  ".lrodata",             B_FALSE },
 476         /* This intentionally applies to .rodata.cstN and .rodata.strN, too */
 477         { ".rodata.",                   ".rodata",              B_FALSE },
 478         { ".sbss2.",                    ".sbss2",               B_FALSE },
 479         { ".sbss.",                     ".sbss",                B_FALSE },
 480         { ".sdata2.",                   ".sdata2",              B_FALSE },
 481         { ".sdata.",                    ".sdata",               B_FALSE },
 482         { ".tbss.",                     ".tbss",                B_FALSE },
 483         { ".tdata.",                    ".tdata",               B_FALSE },
 484         { ".text.",                     ".text",                B_FALSE },
 485         { NULL,                         NULL,                   B_FALSE }
 486 };
 487 
 488 static const char *
 489 gnu_split_sec(const char *ostr)
 490 {
 491         struct split_sec_mapping *mp;
 492 
 493         for (mp = split_sec_mapping; mp->leader != NULL; mp++) {
 494                 if (mp->precise) {
 495                         if (strcmp(ostr, mp->leader) == 0)
 496                                 return (mp->section);
 497                 } else if (strncmp(ostr, mp->leader, strlen(mp->leader)) == 0) {
 498                         return (mp->section);
 499                 }
 500         }
 501 
 502         return (ostr);
 503 }
 504 
 505 /*
 506  * Initialize a path info buffer for use with ld_place_section().
 507  *
 508  * entry:
 509  *      ofl - Output descriptor
 510  *      ifl - Descriptor for input file, or NULL if there is none.
 511  *      info - Address of buffer to be initialized.
 512  *
 513  * exit:
 514  *      If this is an input file, and if the entrance criteria list
 515  *      contains at least one criteria that has a non-empty file string
 516  *      match list (ec_files), then the block pointed at by info is
 517  *      initialized, and info is returned.
 518  *
 519  *      If there is no input file, and/or no entrance criteria containing
 520  *      a non-empty ec_files list, then NULL is returned. This is not
 521  *      an error --- the NULL is simply an optimization, understood by
 522  *      ld_place_path(), that allows it to skip unnecessary work.
 523  */
 524 Place_path_info *
 525 ld_place_path_info_init(Ofl_desc *ofl, Ifl_desc *ifl, Place_path_info *info)
 526 {
 527         /*
 528          * Return NULL if there is no input file (internally generated section)
 529          * or if the entrance criteria list does not contain any items that will
 530          * need to be compared to the path (all the ec_files lists are empty).
 531          */
 532         if ((ifl == NULL) || !(ofl->ofl_flags & FLG_OF_EC_FILES))
 533                 return (NULL);
 534 
 535         info->ppi_path = ifl->ifl_name;
 536         info->ppi_path_len = strlen(info->ppi_path);
 537         info->ppi_isar = (ifl->ifl_flags & FLG_IF_EXTRACT) != 0;
 538 
 539         /*
 540          * The basename is the final segment of the path, equivalent to
 541          * the path itself if there are no '/' delimiters.
 542          */
 543         info->ppi_bname = strrchr(info->ppi_path, '/');
 544         if (info->ppi_bname == NULL)
 545                 info->ppi_bname = info->ppi_path;
 546         else
 547                 info->ppi_bname++;   /* Skip leading '/' */
 548         info->ppi_bname_len =
 549             info->ppi_path_len - (info->ppi_bname - info->ppi_path);
 550 
 551         /*
 552          * For an archive, the object name is the member name, which is
 553          * enclosed in () at the end of the name string. Otherwise, it is
 554          * the same as the basename.
 555          */
 556         if (info->ppi_isar) {
 557                 info->ppi_oname = strrchr(info->ppi_bname, '(');
 558                 /* There must be an archive member suffix delimited by parens */
 559                 assert((info->ppi_bname[info->ppi_bname_len - 1] == ')') &&
 560                     (info->ppi_oname != NULL));
 561                 info->ppi_oname++;   /* skip leading '(' */
 562                 info->ppi_oname_len = info->ppi_bname_len -
 563                     (info->ppi_oname - info->ppi_bname + 1);
 564         } else {
 565                 info->ppi_oname = info->ppi_bname;
 566                 info->ppi_oname_len = info->ppi_bname_len;
 567         }
 568 
 569         return (info);
 570 }
 571 
 572 /*
 573  * Compare an input section path to the file comparison list the given
 574  * entrance criteria.
 575  *
 576  * entry:
 577  *      path_info - A non-NULL Place_path_info block for the file
 578  *              containing the input section, initialized by
 579  *              ld_place_path_info_init()
 580  *      enp - Entrance criteria with a non-empty ec_files list of file
 581  *              comparisons to be carried out.
 582  *
 583  * exit:
 584  *      Return TRUE if a match is seen, and FALSE otherwise.
 585  */
 586 static Boolean
 587 eval_ec_files(Place_path_info *path_info, Ent_desc *enp)
 588 {
 589         Aliste          idx;
 590         Ent_desc_file   *edfp;
 591         size_t          cmp_len;
 592         const char      *cmp_str;
 593 
 594         for (ALIST_TRAVERSE(enp->ec_files, idx, edfp)) {
 595                 Word    type = edfp->edf_flags & TYP_ECF_MASK;
 596 
 597                 /*
 598                  * Determine the starting character, and # of characters,
 599                  * from the file path to compare against this entrance criteria
 600                  * file string.
 601                  */
 602                 if (type == TYP_ECF_OBJNAME) {
 603                         cmp_str = path_info->ppi_oname;
 604                         cmp_len = path_info->ppi_oname_len;
 605                 } else {
 606                         int ar_stat_diff = path_info->ppi_isar !=
 607                             ((edfp->edf_flags & FLG_ECF_ARMEMBER) != 0);
 608 
 609                         /*
 610                          * If the entrance criteria specifies an archive member
 611                          * and the file does not, then there can be no match.
 612                          */
 613 
 614                         if (ar_stat_diff && !path_info->ppi_isar)
 615                                 continue;
 616 
 617                         if (type == TYP_ECF_PATH) {
 618                                 cmp_str = path_info->ppi_path;
 619                                 cmp_len = path_info->ppi_path_len;
 620                         } else {        /* TYP_ECF_BASENAME */
 621                                 cmp_str = path_info->ppi_bname;
 622                                 cmp_len = path_info->ppi_bname_len;
 623                         }
 624 
 625                         /*
 626                          * If the entrance criteria does not specify an archive
 627                          * member and the file does, then a match just requires
 628                          * the paths (without the archive member) to match.
 629                          * Reduce the length to not include the ar member or
 630                          * the '(' that precedes it.
 631                          */
 632                         if (ar_stat_diff && path_info->ppi_isar)
 633                                 cmp_len = path_info->ppi_oname - cmp_str - 1;
 634                 }
 635 
 636                 /*
 637                  * Compare the resulting string to the one from the
 638                  * entrance criteria.
 639                  */
 640                 if ((cmp_len == edfp->edf_name_len) &&
 641                     (strncmp(edfp->edf_name, cmp_str, cmp_len) == 0))
 642                         return (TRUE);
 643         }
 644 
 645         return (FALSE);
 646 }
 647 
 648 /*
 649  * Replace the section header for the given input section with a new section
 650  * header of the specified type. All values in the replacement header other
 651  * than the type retain their previous values.
 652  *
 653  * entry:
 654  *      isp - Input section to replace
 655  *      sh_type - New section type to apply
 656  *
 657  * exit:
 658  *      Returns the pointer to the new section header on success, and
 659  *      NULL for failure.
 660  */
 661 static Shdr *
 662 isp_convert_type(Is_desc *isp, Word sh_type)
 663 {
 664         Shdr    *shdr;
 665 
 666         if ((shdr = libld_malloc(sizeof (Shdr))) == NULL)
 667                 return (NULL);
 668         *shdr = *isp->is_shdr;
 669         isp->is_shdr = shdr;
 670         shdr->sh_type = sh_type;
 671         return (shdr);
 672 }
 673 
 674 /*
 675  * Issue a fatal warning for the given .eh_frame section, which
 676  * cannot be merged with the existing .eh_frame output section.
 677  */
 678 static void
 679 eh_frame_muldef(Ofl_desc *ofl, Is_desc *isp)
 680 {
 681         Sg_desc *sgp;
 682         Is_desc *isp1;
 683         Os_desc *osp;
 684         Aliste  idx1, idx2, idx3;
 685 
 686         /*
 687          * Locate the .eh_frame output section, and use the first section
 688          * assigned to it in the error message. The user can then compare
 689          * the two sections to determine what attribute prevented the merge.
 690          */
 691         for (APLIST_TRAVERSE(ofl->ofl_segs, idx1, sgp)) {
 692                 for (APLIST_TRAVERSE(sgp->sg_osdescs, idx2, osp)) {
 693                         if ((osp->os_flags & FLG_OS_EHFRAME) == 0)
 694                                 continue;
 695 
 696                         for (idx3 = 0; idx3 < OS_ISD_NUM; idx3++) {
 697                                 APlist *lst = osp->os_isdescs[idx3];
 698 
 699                                 if (aplist_nitems(lst) == 0)
 700                                         continue;
 701 
 702                                 isp1 = lst->apl_data[0];
 703                                 ld_eprintf(ofl, ERR_FATAL,
 704                                     MSG_INTL(MSG_UPD_MULEHFRAME),
 705                                     isp1->is_file->ifl_name,
 706                                     EC_WORD(isp1->is_scnndx), isp1->is_name,
 707                                     isp->is_file->ifl_name,
 708                                     EC_WORD(isp->is_scnndx), isp->is_name);
 709                                 return;
 710                         }
 711                 }
 712         }
 713 }
 714 
 715 /*
 716  * Place a section into the appropriate segment and output section.
 717  *
 718  * entry:
 719  *      ofl - File descriptor
 720  *      isp - Input section descriptor of section to be placed.
 721  *      path_info - NULL, or pointer to Place_path_info buffer initialized
 722  *              by ld_place_path_info_init() for the file associated to isp,
 723  *              for use in processing entrance criteria with non-empty
 724  *              file matching string list (ec_files)
 725  *      ident - Section identifier, used to order sections relative to
 726  *              others within the output segment.
 727  *      alt_os_name - If non-NULL, the name of the output section to place
 728  *              isp into. If NULL, input sections go to an output section
 729  *              with the same name as the input section.
 730  */
 731 Os_desc *
 732 ld_place_section(Ofl_desc *ofl, Is_desc *isp, Place_path_info *path_info,
 733     int ident, const char *alt_os_name)
 734 {
 735         Ent_desc        *enp;
 736         Sg_desc         *sgp;
 737         Os_desc         *osp;
 738         Aliste          idx1, iidx;
 739         int             os_ndx;
 740         Shdr            *shdr = isp->is_shdr;
 741         Xword           shflagmask, shflags = shdr->sh_flags;
 742         Ifl_desc        *ifl = isp->is_file;
 743         char            *oname, *sname;
 744         uint_t          onamehash;
 745         Boolean         is_ehframe = (isp->is_flags & FLG_IS_EHFRAME) != 0;
 746 
 747         /*
 748          * Define any sections that must be thought of as referenced.  These
 749          * sections may not be referenced externally in a manner ld(1) can
 750          * discover, but they must be retained (ie. not removed by -zignore).
 751          */
 752         static const Msg RefSecs[] = {
 753                 MSG_SCN_INIT,           /* MSG_ORIG(MSG_SCN_INIT) */
 754                 MSG_SCN_FINI,           /* MSG_ORIG(MSG_SCN_FINI) */
 755                 MSG_SCN_EX_RANGES,      /* MSG_ORIG(MSG_SCN_EX_RANGES) */
 756                 MSG_SCN_EX_SHARED,      /* MSG_ORIG(MSG_SCN_EX_SHARED) */
 757                 MSG_SCN_CTORS,          /* MSG_ORIG(MSG_SCN_CTORS) */
 758                 MSG_SCN_DTORS,          /* MSG_ORIG(MSG_SCN_DTORS) */
 759                 MSG_SCN_EHFRAME,        /* MSG_ORIG(MSG_SCN_EHFRAME) */
 760                 MSG_SCN_EHFRAME_HDR,    /* MSG_ORIG(MSG_SCN_EHFRAME_HDR) */
 761                 MSG_SCN_JCR,            /* MSG_ORIG(MSG_SCN_JCR) */
 762                 MSG_SCN_INITARRAY,      /* MSG_ORIG(MSG_SCN_INITARRAY) */
 763                 MSG_SCN_FINIARRAY,      /* MSG_ORIG(MSG_SCN_FINIARRAY) */
 764                 MSG_SCN_PREINITARRAY,   /* MSG_ORIG(MSG_SCN_PREINITARRAY) */
 765                 0
 766         };
 767 
 768         DBG_CALL(Dbg_sec_in(ofl->ofl_lml, isp));
 769 
 770         /*
 771          * If this section identifies group members, or this section indicates
 772          * that it is a member of a group, determine whether the section is
 773          * still required.
 774          */
 775         if ((shflags & SHF_GROUP) || (shdr->sh_type == SHT_GROUP)) {
 776                 Group_desc      *gdesc;
 777 
 778                 if ((gdesc = ld_get_group(ofl, isp)) != NULL) {
 779                         DBG_CALL(Dbg_sec_group(ofl->ofl_lml, isp, gdesc));
 780 
 781                         /*
 782                          * If this group has been replaced by another group,
 783                          * then this section needs to be discarded.
 784                          */
 785                         if (gdesc->gd_oisc) {
 786                                 isp->is_flags |= FLG_IS_DISCARD;
 787 
 788                                 /*
 789                                  * Since we're discarding the section, we
 790                                  * can skip assigning it to an output section.
 791                                  * The exception is that if the user
 792                                  * specifies -z relaxreloc, then
 793                                  * we need to assign the output section so
 794                                  * that the sloppy relocation logic will have
 795                                  * the information necessary to do its work.
 796                                  */
 797                                 if (!(ofl->ofl_flags1 & FLG_OF1_RLXREL))
 798                                         return (NULL);
 799                         }
 800                 }
 801 
 802                 /*
 803                  * SHT_GROUP sections can only be included into relocatable
 804                  * objects.
 805                  */
 806                 if (shdr->sh_type == SHT_GROUP) {
 807                         if ((ofl->ofl_flags & FLG_OF_RELOBJ) == 0) {
 808                                 isp->is_flags |= FLG_IS_DISCARD;
 809                                 return (NULL);
 810                         }
 811                 }
 812         }
 813 
 814         /*
 815          * Always assign SHF_TLS sections to the DATA segment (and then the
 816          * PT_TLS embedded inside of there).
 817          */
 818         if (shflags & SHF_TLS)
 819                 shflags |= SHF_WRITE;
 820 
 821         /*
 822          * Traverse the entrance criteria list searching for a segment that
 823          * matches the input section we have.  If an entrance criterion is set
 824          * then there must be an exact match.  If we complete the loop without
 825          * finding a segment, then sgp will be NULL.
 826          */
 827         sgp = NULL;
 828         for (APLIST_TRAVERSE(ofl->ofl_ents, idx1, enp)) {
 829 
 830                 /* Disabled segments are not available for assignment */
 831                 if (enp->ec_segment->sg_flags & FLG_SG_DISABLED)
 832                         continue;
 833 
 834                 /*
 835                  * If an entrance criteria doesn't have any of its fields
 836                  * set, it will match any section it is tested against.
 837                  * We set the FLG_EC_CATCHALL flag on these, primarily because
 838                  * it helps readers of our debug output to understand what
 839                  * the criteria means --- otherwise the user would just see
 840                  * that every field is 0, but might not understand the
 841                  * significance of that.
 842                  *
 843                  * Given that we set this flag, we can use it here as an
 844                  * optimization to short circuit all of the tests in this
 845                  * loop. Note however, that if we did not do this, the end
 846                  * result would be the same --- the empty criteria will sail
 847                  * past the following tests and reach the end of the loop.
 848                  */
 849                 if (enp->ec_flags & FLG_EC_CATCHALL) {
 850                         sgp = enp->ec_segment;
 851                         break;
 852                 }
 853 
 854                 if (enp->ec_type && (enp->ec_type != shdr->sh_type))
 855                         continue;
 856                 if (enp->ec_attrmask &&
 857                     /* LINTED */
 858                     (enp->ec_attrmask & enp->ec_attrbits) !=
 859                     (enp->ec_attrmask & shflags))
 860                         continue;
 861                 if (enp->ec_is_name &&
 862                     (strcmp(enp->ec_is_name, isp->is_name) != 0))
 863                         continue;
 864 
 865                 if ((alist_nitems(enp->ec_files) > 0) &&
 866                     ((path_info == NULL) || !eval_ec_files(path_info, enp)))
 867                         continue;
 868 
 869                 /* All entrance criteria tests passed */
 870                 sgp = enp->ec_segment;
 871                 break;
 872         }
 873 
 874         /*
 875          * The final entrance criteria record is a FLG_EC_CATCHALL that points
 876          * at the final predefined segment "extra", and this final segment is
 877          * tagged FLG_SG_NODISABLE. Therefore, the above loop must always find
 878          * a segment.
 879          */
 880         assert(sgp != NULL);
 881 
 882         /*
 883          * Transfer the input section sorting key from the entrance criteria
 884          * to the input section. A non-zero value means that the section
 885          * will be sorted on this key amoung the other sections that have a
 886          * non-zero key. These sorted sections are collectively placed at the
 887          * head of the output section.
 888          *
 889          * If the sort key is 0, the section is placed after the sorted
 890          * sections in the order they are encountered.
 891          */
 892         isp->is_ordndx = enp->ec_ordndx;
 893 
 894         /* Remember that this entrance criteria has placed a section */
 895         enp->ec_flags |= FLG_EC_USED;
 896 
 897         /*
 898          * If our caller has supplied an alternative name for the output
 899          * section, then we defer to their request. Otherwise, the default
 900          * is to use the same name as that of the input section being placed.
 901          *
 902          * The COMDAT, SHT_GROUP and GNU name translations that follow have
 903          * the potential to alter this initial name.
 904          */
 905         oname = (char *)((alt_os_name == NULL) ? isp->is_name : alt_os_name);
 906 
 907         /*
 908          * Solaris section names may follow the convention:
 909          *
 910          *      section-name%symbol-name
 911          *
 912          * This convention has been used to order the layout of sections within
 913          * segments for objects built with the compilers -xF option.  However,
 914          * the final object should not contain individual section headers for
 915          * all such input sections, instead the symbol name is stripped from the
 916          * name to establish the final output section name.
 917          *
 918          * This convention has also been followed for COMDAT and sections
 919          * identified though SHT_GROUP data.
 920          *
 921          * Strip out the % from the section name for:
 922          *      - Non-relocatable objects
 923          *      - Relocatable objects if input section sorting is
 924          *        in force for the segment in question.
 925          */
 926         if (((ofl->ofl_flags & FLG_OF_RELOBJ) == 0) ||
 927             (sgp->sg_flags & FLG_SG_IS_ORDER)) {
 928                 if ((sname = strchr(isp->is_name, '%')) != NULL) {
 929                         size_t  size = sname - isp->is_name;
 930 
 931                         if ((oname = libld_malloc(size + 1)) == NULL)
 932                                 return ((Os_desc *)S_ERROR);
 933                         (void) strncpy(oname, isp->is_name, size);
 934                         oname[size] = '\0';
 935                         DBG_CALL(Dbg_sec_redirected(ofl->ofl_lml, isp, oname));
 936                 }
 937         }
 938 
 939         /*
 940          * When building relocatable objects, we must not redirect COMDAT
 941          * section names into their outputs, such that our output object may
 942          * be successfully used as an input object also requiring COMDAT
 943          * processing
 944          */
 945 
 946         /*
 947          * GNU section names may follow the convention:
 948          *
 949          *      .gnu.linkonce.*
 950          *
 951          * The .gnu.linkonce is a section naming convention that indicates a
 952          * COMDAT requirement.  Determine whether this section follows the GNU
 953          * pattern, and if so, determine whether this section should be
 954          * discarded or retained.  The comparison of is_name[1] with 'g'
 955          * is an optimization to skip using strncmp() too much. This is safe,
 956          * because we know the name is not NULL, and therefore must have
 957          * at least one character plus a NULL termination.
 958          */
 959         if ((isp->is_name == oname) && (isp->is_name[1] == 'g') &&
 960             (strncmp(MSG_ORIG(MSG_SCN_GNU_LINKONCE), isp->is_name,
 961             MSG_SCN_GNU_LINKONCE_SIZE) == 0)) {
 962                 if ((ofl->ofl_flags & FLG_OF_RELOBJ) == 0) {
 963                         if ((oname = (char *)gnu_linkonce_sec(isp->is_name)) !=
 964                             isp->is_name) {
 965                                 DBG_CALL(Dbg_sec_redirected(ofl->ofl_lml, isp,
 966                                     oname));
 967                         }
 968                 }
 969 
 970                 /*
 971                  * Explicitly identify this section type as COMDAT.  Also,
 972                  * enable relaxed relocation processing, as this is typically
 973                  * a requirement with .gnu.linkonce sections.
 974                  */
 975                 isp->is_flags |= FLG_IS_COMDAT;
 976                 if ((ofl->ofl_flags1 & FLG_OF1_NRLXREL) == 0)
 977                         ofl->ofl_flags1 |= FLG_OF1_RLXREL;
 978                 DBG_CALL(Dbg_sec_gnu_comdat(ofl->ofl_lml, isp, TRUE,
 979                     (ofl->ofl_flags1 & FLG_OF1_RLXREL) != 0));
 980         }
 981 
 982         /*
 983          * GNU section names may also follow the convention:
 984          *
 985          *      section-name.symbol-name
 986          *
 987          * This convention is used when defining SHT_GROUP sections of type
 988          * COMDAT.  Thus, any group processing will have discovered any group
 989          * sections, and this identification can be triggered by a pattern
 990          * match section names.
 991          */
 992         if ((isp->is_name == oname) && (isp->is_flags & FLG_IS_COMDAT) &&
 993             ((sname = gnu_comdat_sym(ifl, isp)) != NULL)) {
 994                 size_t  size = sname - isp->is_name;
 995 
 996                 if ((ofl->ofl_flags & FLG_OF_RELOBJ) == 0) {
 997                         if ((oname = libld_malloc(size + 1)) == NULL)
 998                                 return ((Os_desc *)S_ERROR);
 999                         (void) strncpy(oname, isp->is_name, size);
1000                         oname[size] = '\0';
1001                         DBG_CALL(Dbg_sec_redirected(ofl->ofl_lml, isp, oname));
1002                 }
1003 
1004                 /*
1005                  * Enable relaxed relocation processing, as this is
1006                  * typically a requirement with GNU COMDAT sections.
1007                  */
1008                 if ((ofl->ofl_flags1 & FLG_OF1_NRLXREL) == 0) {
1009                         ofl->ofl_flags1 |= FLG_OF1_RLXREL;
1010                         DBG_CALL(Dbg_sec_gnu_comdat(ofl->ofl_lml, isp,
1011                             FALSE, TRUE));
1012                 }
1013         }
1014 
1015         /*
1016          * GNU section names named section-name.symbol-name which are not
1017          * members of COMDAT groups are merged according to the behaviour of
1018          * the GNU link-editor.
1019          *
1020          * See the description of gnu_split_sec().
1021          */
1022         if (((ofl->ofl_flags & FLG_OF_RELOBJ) == 0) &&
1023             (isp->is_name == oname) &&
1024             ((oname = (char *)gnu_split_sec(oname)) != isp->is_name)) {
1025                 DBG_CALL(Dbg_sec_redirected(ofl->ofl_lml, isp, oname));
1026         }
1027 
1028         /*
1029          * Assign a hash value now that the output section name has been
1030          * finalized.
1031          */
1032         onamehash = sgs_str_hash(oname);
1033 
1034         /*
1035          * Determine if output section ordering is turned on. If so, return
1036          * the appropriate ordering index for the section. This information
1037          * is derived from the Sg_desc->sg_os_order list that was built
1038          * up from the Mapfile.
1039          *
1040          * A value of 0 for os_ndx means that the section is not sorted
1041          * (i.e. is not found in the sg_os_order). The items in sg_os_order
1042          * are in the desired sort order, so adding 1 to their alist index
1043          * gives a suitable index for sorting.
1044          */
1045         os_ndx = 0;
1046         if (alist_nitems(sgp->sg_os_order) > 0) {
1047                 Sec_order       *scop;
1048 
1049                 for (ALIST_TRAVERSE(sgp->sg_os_order, idx1, scop)) {
1050                         if (strcmp(scop->sco_secname, oname) == 0) {
1051                                 scop->sco_flags |= FLG_SGO_USED;
1052                                 os_ndx = idx1 + 1;
1053                                 break;
1054                         }
1055                 }
1056         }
1057 
1058         /*
1059          * Mask of section header flags to ignore when matching sections. We
1060          * are more strict with relocatable objects, ignoring only the order
1061          * flags, and keeping sections apart if they differ otherwise. This
1062          * follows the policy that sections in a relative object should only
1063          * be merged if their flags are the same, and avoids destroying
1064          * information prematurely. For final products however, we ignore all
1065          * flags that do not prevent a merge.
1066          */
1067         shflagmask =
1068             (ofl->ofl_flags & FLG_OF_RELOBJ) ? ALL_SHF_ORDER : ALL_SHF_IGNORE;
1069 
1070         /*
1071          * Traverse the input section list for the output section we have been
1072          * assigned. If we find a matching section simply add this new section.
1073          */
1074         iidx = 0;
1075         for (APLIST_TRAVERSE(sgp->sg_osdescs, idx1, osp)) {
1076                 Shdr    *os_shdr = osp->os_shdr;
1077 
1078                 /*
1079                  * An input section matches an output section if:
1080                  * -    The ident values match
1081                  * -    The names match
1082                  * -    Not a GROUP section
1083                  * -    Not a DTrace dof section
1084                  * -    Section types match
1085                  * -    Matching section flags, after screening out the
1086                  *      shflagmask flags.
1087                  *
1088                  * Section types are considered to match if any one of
1089                  * the following are true:
1090                  * -    The type codes are the same
1091                  * -    Both are .eh_frame sections (regardless of type code)
1092                  * -    The input section is COMDAT, and the output section
1093                  *      is SHT_PROGBITS.
1094                  */
1095                 if ((ident == osp->os_identndx) &&
1096                     (ident != ld_targ.t_id.id_rel) &&
1097                     (onamehash == osp->os_namehash) &&
1098                     (shdr->sh_type != SHT_GROUP) &&
1099                     (shdr->sh_type != SHT_SUNW_dof) &&
1100                     ((shdr->sh_type == os_shdr->sh_type) ||
1101                     (is_ehframe && (osp->os_flags & FLG_OS_EHFRAME)) ||
1102                     ((shdr->sh_type == SHT_SUNW_COMDAT) &&
1103                     (os_shdr->sh_type == SHT_PROGBITS))) &&
1104                     ((shflags & ~shflagmask) ==
1105                     (os_shdr->sh_flags & ~shflagmask)) &&
1106                     (strcmp(oname, osp->os_name) == 0)) {
1107                         uintptr_t       err;
1108 
1109                         /*
1110                          * Process any COMDAT section, keeping the first and
1111                          * discarding all others.
1112                          */
1113                         if ((isp->is_flags & FLG_IS_COMDAT) &&
1114                             ((err = add_comdat(ofl, osp, isp)) != 1))
1115                                 return ((Os_desc *)err);
1116 
1117                         /*
1118                          * Set alignment
1119                          */
1120                         set_addralign(ofl, osp, isp);
1121 
1122                         /*
1123                          * If this section is a non-empty TLS section indicate
1124                          * that a PT_TLS program header is required.
1125                          */
1126                         if ((shflags & SHF_TLS) && shdr->sh_size &&
1127                             ((ofl->ofl_flags & FLG_OF_RELOBJ) == 0))
1128                                 ofl->ofl_flags |= FLG_OF_TLSPHDR;
1129 
1130                         /*
1131                          * Insert the input section descriptor on the proper
1132                          * output section descriptor list.
1133                          *
1134                          * If this segment requires input section ordering,
1135                          * honor any mapfile specified ordering for otherwise
1136                          * unordered sections by setting the mapfile_sort
1137                          * argument of os_attach_isp() to True.
1138                          */
1139 
1140                         if (os_attach_isp(ofl, osp, isp,
1141                             (sgp->sg_flags & FLG_SG_IS_ORDER) != 0) == 0)
1142                                 return ((Os_desc *)S_ERROR);
1143 
1144                         /*
1145                          * If this input section and file is associated to an
1146                          * artificially referenced output section, make sure
1147                          * they are marked as referenced also. This ensures
1148                          * that this input section and file isn't eliminated
1149                          * when -zignore is in effect.
1150                          *
1151                          * See -zignore comments when creating a new output
1152                          * section below.
1153                          */
1154                         if (((ifl &&
1155                             (ifl->ifl_flags & FLG_IF_IGNORE)) || DBG_ENABLED) &&
1156                             (osp->os_flags & FLG_OS_SECTREF)) {
1157                                 isp->is_flags |= FLG_IS_SECTREF;
1158                                 if (ifl)
1159                                         ifl->ifl_flags |= FLG_IF_FILEREF;
1160                         }
1161 
1162                         DBG_CALL(Dbg_sec_added(ofl->ofl_lml, osp, sgp));
1163                         return (osp);
1164                 }
1165 
1166                 /*
1167                  * Do we need to worry about section ordering?
1168                  */
1169                 if (os_ndx) {
1170                         if (osp->os_ordndx) {
1171                                 if (os_ndx < osp->os_ordndx)
1172                                         /* insert section here. */
1173                                         break;
1174                                 else {
1175                                         iidx = idx1 + 1;
1176                                         continue;
1177                                 }
1178                         } else {
1179                                 /* insert section here. */
1180                                 break;
1181                         }
1182                 } else if (osp->os_ordndx) {
1183                         iidx = idx1 + 1;
1184                         continue;
1185                 }
1186 
1187                 /*
1188                  * If the new sections identifier is less than that of the
1189                  * present input section we need to insert the new section
1190                  * at this point.
1191                  */
1192                 if (ident < osp->os_identndx)
1193                         break;
1194 
1195                 iidx = idx1 + 1;
1196         }
1197 
1198         /*
1199          * We are adding a new output section.  Update the section header
1200          * count and associated string size.
1201          *
1202          * If the input section triggering this output section has been marked
1203          * for discard, and if no other non-discarded input section comes along
1204          * to join it, then we will over count. We cannot know if this will
1205          * happen or not until all input is seen. Set FLG_OF_AJDOSCNT to
1206          * trigger a final count readjustment.
1207          */
1208         if (isp->is_flags & FLG_IS_DISCARD)
1209                 ofl->ofl_flags |= FLG_OF_ADJOSCNT;
1210         ofl->ofl_shdrcnt++;
1211         if (st_insert(ofl->ofl_shdrsttab, oname) == -1)
1212                 return ((Os_desc *)S_ERROR);
1213 
1214         /*
1215          * Create a new output section descriptor.
1216          */
1217         if ((osp = libld_calloc(sizeof (Os_desc), 1)) == NULL)
1218                 return ((Os_desc *)S_ERROR);
1219         if ((osp->os_shdr = libld_calloc(sizeof (Shdr), 1)) == NULL)
1220                 return ((Os_desc *)S_ERROR);
1221 
1222         /*
1223          * Convert COMDAT section to PROGBITS as this the first section of the
1224          * output section.  Save any COMDAT section for later processing, as
1225          * additional COMDAT sections that match this section need discarding.
1226          */
1227         if ((shdr->sh_type == SHT_SUNW_COMDAT) &&
1228             ((shdr = isp_convert_type(isp, SHT_PROGBITS)) == NULL))
1229                 return ((Os_desc *)S_ERROR);
1230         if ((isp->is_flags & FLG_IS_COMDAT) &&
1231             (add_comdat(ofl, osp, isp) == S_ERROR))
1232                 return ((Os_desc *)S_ERROR);
1233 
1234         if (is_ehframe) {
1235                 /*
1236                  * Executable or sharable objects can have at most a single
1237                  * .eh_frame section. Detect attempts to create more than
1238                  * one. This occurs if the input sections have incompatible
1239                  * attributes.
1240                  */
1241                 if ((ofl->ofl_flags & FLG_OF_EHFRAME) &&
1242                     !(ofl->ofl_flags & FLG_OF_RELOBJ)) {
1243                         eh_frame_muldef(ofl, isp);
1244                         return ((Os_desc *)S_ERROR);
1245                 }
1246                 ofl->ofl_flags |= FLG_OF_EHFRAME;
1247 
1248                 /*
1249                  * For .eh_frame sections, we always set the type to be the
1250                  * type specified by the ABI.  This allows .eh_frame sections
1251                  * of type SHT_PROGBITS to be correctly merged with .eh_frame
1252                  * sections of the ABI-defined type (e.g. SHT_AMD64_UNWIND),
1253                  * with the output being of the ABI-defined type.
1254                  */
1255                 osp->os_shdr->sh_type = ld_targ.t_m.m_sht_unwind;
1256         } else {
1257                 osp->os_shdr->sh_type = shdr->sh_type;
1258         }
1259 
1260         osp->os_shdr->sh_flags = shdr->sh_flags;
1261         osp->os_shdr->sh_entsize = shdr->sh_entsize;
1262         osp->os_name = oname;
1263         osp->os_namehash = onamehash;
1264         osp->os_ordndx = os_ndx;
1265         osp->os_sgdesc = sgp;
1266         if (is_ehframe)
1267                 osp->os_flags |= FLG_OS_EHFRAME;
1268 
1269         if (ifl && (shdr->sh_type == SHT_PROGBITS)) {
1270                 /*
1271                  * Try to preserve the intended meaning of sh_link/sh_info.
1272                  * See the translate_link() in update.c.
1273                  */
1274                 osp->os_shdr->sh_link = shdr->sh_link;
1275                 if (shdr->sh_flags & SHF_INFO_LINK)
1276                         osp->os_shdr->sh_info = shdr->sh_info;
1277         }
1278 
1279         /*
1280          * When -zignore is in effect, user supplied sections and files that are
1281          * not referenced from other sections, are eliminated from the object
1282          * being produced.  Some sections, although unreferenced, are special,
1283          * and must not be eliminated.  Determine if this new output section is
1284          * one of those special sections, and if so mark it artificially as
1285          * referenced.  Any input section and file associated to this output
1286          * section is also be marked as referenced, and thus won't be eliminated
1287          * from the final output.
1288          */
1289         if (ifl && ((ofl->ofl_flags1 & FLG_OF1_IGNPRC) || DBG_ENABLED)) {
1290                 const Msg       *refsec;
1291 
1292                 for (refsec = RefSecs; *refsec; refsec++) {
1293                         if (strcmp(osp->os_name, MSG_ORIG(*refsec)) == 0) {
1294                                 osp->os_flags |= FLG_OS_SECTREF;
1295 
1296                                 if ((ifl->ifl_flags & FLG_IF_IGNORE) ||
1297                                     DBG_ENABLED) {
1298                                         isp->is_flags |= FLG_IS_SECTREF;
1299                                         ifl->ifl_flags |= FLG_IF_FILEREF;
1300                                 }
1301                                 break;
1302                         }
1303                 }
1304         }
1305 
1306         /*
1307          * Sections of type SHT_GROUP are added to the ofl->ofl_osgroups list,
1308          * so that they can be updated as a group later.
1309          */
1310         if ((shdr->sh_type == SHT_GROUP) &&
1311             ((isp->is_flags & FLG_IS_DISCARD) == 0) &&
1312             (aplist_append(&ofl->ofl_osgroups, osp,
1313             AL_CNT_OFL_OSGROUPS) == NULL))
1314                 return ((Os_desc *)S_ERROR);
1315 
1316         /*
1317          * If this section is a non-empty TLS section indicate that a PT_TLS
1318          * program header is required.
1319          */
1320         if ((shflags & SHF_TLS) && shdr->sh_size &&
1321             ((ofl->ofl_flags & FLG_OF_RELOBJ) == 0))
1322                 ofl->ofl_flags |= FLG_OF_TLSPHDR;
1323 
1324         /*
1325          * If a non-allocatable section is going to be put into a loadable
1326          * segment then turn on the allocate bit for this section and warn the
1327          * user that we have done so.  This could only happen through the use
1328          * of a mapfile.
1329          */
1330         if ((sgp->sg_phdr.p_type == PT_LOAD) &&
1331             ((osp->os_shdr->sh_flags & SHF_ALLOC) == 0)) {
1332                 ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_SCN_NONALLOC),
1333                     ofl->ofl_name, osp->os_name, sgp->sg_name);
1334                 osp->os_shdr->sh_flags |= SHF_ALLOC;
1335         }
1336 
1337         /*
1338          * Retain this sections identifier for future comparisons when placing
1339          * a section (after all sections have been processed this variable will
1340          * be used to hold the sections symbol index as we don't need to retain
1341          * the identifier any more).
1342          */
1343         osp->os_identndx = ident;
1344 
1345         /*
1346          * Set alignment.
1347          */
1348         set_addralign(ofl, osp, isp);
1349 
1350         if (os_attach_isp(ofl, osp, isp, 0) == 0)
1351                 return ((Os_desc *)S_ERROR);
1352 
1353         DBG_CALL(Dbg_sec_created(ofl->ofl_lml, osp, sgp));
1354 
1355         /*
1356          * Insert the new section at the offset given by iidx.  If no position
1357          * for it was identified above, this will be index 0, causing the new
1358          * section to be prepended to the beginning of the section list.
1359          * Otherwise, it is the index following the section that was identified.
1360          */
1361         if (aplist_insert(&sgp->sg_osdescs, osp, AL_CNT_SG_OSDESC,
1362             iidx) == NULL)
1363                 return ((Os_desc *)S_ERROR);
1364         return (osp);
1365 }