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) 1989, 2010, Oracle and/or its affiliates. All rights reserved.
  27  */
  28 
  29 /*
  30  * Module sections. Initialize special sections
  31  */
  32 
  33 #define ELF_TARGET_AMD64
  34 
  35 #include        <string.h>
  36 #include        <strings.h>
  37 #include        <stdio.h>
  38 #include        <link.h>
  39 #include        <debug.h>
  40 #include        "msg.h"
  41 #include        "_libld.h"
  42 
  43 inline static void
  44 remove_local(Ofl_desc *ofl, Sym_desc *sdp, int allow_ldynsym)
  45 {
  46         Sym     *sym = sdp->sd_sym;
  47         uchar_t type = ELF_ST_TYPE(sym->st_info);
  48         /* LINTED - only used for assert() */
  49         int     err;
  50 
  51         if ((ofl->ofl_flags & FLG_OF_REDLSYM) == 0) {
  52                 ofl->ofl_locscnt--;
  53 
  54                 err = st_delstring(ofl->ofl_strtab, sdp->sd_name);
  55                 assert(err != -1);
  56 
  57                 if (allow_ldynsym && ldynsym_symtype[type]) {
  58                         ofl->ofl_dynlocscnt--;
  59 
  60                         err = st_delstring(ofl->ofl_dynstrtab, sdp->sd_name);
  61                         assert(err != -1);
  62                         /* Remove from sort section? */
  63                         DYNSORT_COUNT(sdp, sym, type, --);
  64                 }
  65         }
  66         sdp->sd_flags |= FLG_SY_ISDISC;
  67 }
  68 
  69 inline static void
  70 remove_scoped(Ofl_desc *ofl, Sym_desc *sdp, int allow_ldynsym)
  71 {
  72         Sym     *sym = sdp->sd_sym;
  73         uchar_t type = ELF_ST_TYPE(sym->st_info);
  74         /* LINTED - only used for assert() */
  75         int     err;
  76 
  77         ofl->ofl_scopecnt--;
  78         ofl->ofl_elimcnt++;
  79 
  80         err = st_delstring(ofl->ofl_strtab, sdp->sd_name);
  81         assert(err != -1);
  82 
  83         if (allow_ldynsym && ldynsym_symtype[type]) {
  84                 ofl->ofl_dynscopecnt--;
  85 
  86                 err = st_delstring(ofl->ofl_dynstrtab, sdp->sd_name);
  87                 assert(err != -1);
  88                 /* Remove from sort section? */
  89                 DYNSORT_COUNT(sdp, sym, type, --);
  90         }
  91         sdp->sd_flags |= FLG_SY_ELIM;
  92 }
  93 
  94 inline static void
  95 ignore_sym(Ofl_desc *ofl, Ifl_desc *ifl, Sym_desc *sdp, int allow_ldynsym)
  96 {
  97         Os_desc *osp;
  98         Is_desc *isp = sdp->sd_isc;
  99         uchar_t bind = ELF_ST_BIND(sdp->sd_sym->st_info);
 100 
 101         if (bind == STB_LOCAL) {
 102                 uchar_t type = ELF_ST_TYPE(sdp->sd_sym->st_info);
 103 
 104                 /*
 105                  * Skip section symbols, these were never collected in the
 106                  * first place.
 107                  */
 108                 if (type == STT_SECTION)
 109                         return;
 110 
 111                 /*
 112                  * Determine if the whole file is being removed.  Remove any
 113                  * file symbol, and any symbol that is not associated with a
 114                  * section, provided the symbol has not been identified as
 115                  * (update) required.
 116                  */
 117                 if (((ifl->ifl_flags & FLG_IF_FILEREF) == 0) &&
 118                     ((type == STT_FILE) || ((isp == NULL) &&
 119                     ((sdp->sd_flags & FLG_SY_UPREQD) == 0)))) {
 120                         DBG_CALL(Dbg_syms_discarded(ofl->ofl_lml, sdp));
 121                         if (ifl->ifl_flags & FLG_IF_IGNORE)
 122                                 remove_local(ofl, sdp, allow_ldynsym);
 123                         return;
 124                 }
 125 
 126         } else {
 127                 /*
 128                  * Global symbols can only be eliminated when the interfaces of
 129                  * an object have been defined via versioning/scoping.
 130                  */
 131                 if (!SYM_IS_HIDDEN(sdp))
 132                         return;
 133 
 134                 /*
 135                  * Remove any unreferenced symbols that are not associated with
 136                  * a section.
 137                  */
 138                 if ((isp == NULL) && ((sdp->sd_flags & FLG_SY_UPREQD) == 0)) {
 139                         DBG_CALL(Dbg_syms_discarded(ofl->ofl_lml, sdp));
 140                         if (ifl->ifl_flags & FLG_IF_IGNORE)
 141                                 remove_scoped(ofl, sdp, allow_ldynsym);
 142                         return;
 143                 }
 144         }
 145 
 146         /*
 147          * Do not discard any symbols that are associated with non-allocable
 148          * segments.
 149          */
 150         if (isp && ((isp->is_flags & FLG_IS_SECTREF) == 0) &&
 151             ((osp = isp->is_osdesc) != 0) &&
 152             (osp->os_sgdesc->sg_phdr.p_type == PT_LOAD)) {
 153                 DBG_CALL(Dbg_syms_discarded(ofl->ofl_lml, sdp));
 154                 if (ifl->ifl_flags & FLG_IF_IGNORE) {
 155                         if (bind == STB_LOCAL)
 156                                 remove_local(ofl, sdp, allow_ldynsym);
 157                         else
 158                                 remove_scoped(ofl, sdp, allow_ldynsym);
 159                 }
 160         }
 161 }
 162 
 163 static Boolean
 164 isdesc_discarded(Is_desc *isp)
 165 {
 166         Ifl_desc        *ifl = isp->is_file;
 167         Os_desc         *osp = isp->is_osdesc;
 168         Word            ptype = osp->os_sgdesc->sg_phdr.p_type;
 169 
 170         if (isp->is_flags & FLG_IS_DISCARD)
 171                 return TRUE;
 172 
 173         /*
 174          * If the file is discarded, it will take
 175          * the section with it.
 176          */
 177         if (ifl &&
 178             (((ifl->ifl_flags & FLG_IF_FILEREF) == 0) ||
 179             ((ptype == PT_LOAD) &&
 180             ((isp->is_flags & FLG_IS_SECTREF) == 0) &&
 181             (isp->is_shdr->sh_size > 0))) &&
 182             (ifl->ifl_flags & FLG_IF_IGNORE))
 183                 return TRUE;
 184 
 185         return FALSE;
 186 }
 187 
 188 /*
 189  * There are situations where we may count output sections (ofl_shdrcnt)
 190  * that are subsequently eliminated from the output object. Whether or
 191  * not this happens cannot be known until all input has been seen and
 192  * section elimination code has run. However, the situations where this
 193  * outcome is possible are known, and are flagged by setting FLG_OF_ADJOSCNT.
 194  *
 195  * If FLG_OF_ADJOSCNT is set, this routine makes a pass over the output
 196  * sections. If an unused output section is encountered, we decrement
 197  * ofl->ofl_shdrcnt and remove the section name from the .shstrtab string
 198  * table (ofl->ofl_shdrsttab).
 199  *
 200  * This code must be kept in sync with the similar code
 201  * found in outfile.c:ld_create_outfile().
 202  */
 203 static void
 204 adjust_os_count(Ofl_desc *ofl)
 205 {
 206         Sg_desc         *sgp;
 207         Is_desc         *isp;
 208         Os_desc         *osp;
 209         Aliste          idx1;
 210 
 211         if ((ofl->ofl_flags & FLG_OF_ADJOSCNT) == 0)
 212                 return;
 213 
 214         /*
 215          * For each output section, look at the input sections to find at least
 216          * one input section that has not been eliminated. If none are found,
 217          * the -z ignore processing above has eliminated that output section.
 218          */
 219         for (APLIST_TRAVERSE(ofl->ofl_segs, idx1, sgp)) {
 220                 Aliste  idx2;
 221 
 222                 for (APLIST_TRAVERSE(sgp->sg_osdescs, idx2, osp)) {
 223                         Aliste  idx3;
 224                         int     keep = 0, os_isdescs_idx;
 225 
 226                         OS_ISDESCS_TRAVERSE(os_isdescs_idx, osp, idx3, isp) {
 227                                 /*
 228                                  * We have found a kept input section,
 229                                  * so the output section will be created.
 230                                  */
 231                                 if (!isdesc_discarded(isp)) {
 232                                         keep = 1;
 233                                         break;
 234                                 }
 235                         }
 236                         /*
 237                          * If no section of this name was kept, decrement
 238                          * the count and remove the name from .shstrtab.
 239                          */
 240                         if (keep == 0) {
 241                                 /* LINTED - only used for assert() */
 242                                 int err;
 243 
 244                                 ofl->ofl_shdrcnt--;
 245                                 err = st_delstring(ofl->ofl_shdrsttab,
 246                                     osp->os_name);
 247                                 assert(err != -1);
 248                         }
 249                 }
 250         }
 251 }
 252 
 253 /*
 254  * If -zignore has been in effect, scan all input files to determine if the
 255  * file, or sections from the file, have been referenced.  If not, the file or
 256  * some of the files sections can be discarded. If sections are to be
 257  * discarded, rescan the output relocations and the symbol table and remove
 258  * the relocations and symbol entries that are no longer required.
 259  *
 260  * Note:  It's possible that a section which is being discarded has contributed
 261  *        to the GOT table or the PLT table.  However, we can't at this point
 262  *        eliminate the corresponding entries.  This is because there could well
 263  *        be other sections referencing those same entries, but we don't have
 264  *        the infrastructure to determine this.  So, keep the PLT and GOT
 265  *        entries in the table in case someone wants them.
 266  * Note:  The section to be affected needs to be allocatable.
 267  *        So even if -zignore is in effect, if the section is not allocatable,
 268  *        we do not eliminate it.
 269  */
 270 static uintptr_t
 271 ignore_section_processing(Ofl_desc *ofl)
 272 {
 273         Sg_desc         *sgp;
 274         Is_desc         *isp;
 275         Os_desc         *osp;
 276         Ifl_desc        *ifl;
 277         Rel_cachebuf    *rcbp;
 278         Rel_desc        *rsp;
 279         int             allow_ldynsym = OFL_ALLOW_LDYNSYM(ofl);
 280         Aliste          idx1;
 281 
 282         for (APLIST_TRAVERSE(ofl->ofl_objs, idx1, ifl)) {
 283                 uint_t  num, discard;
 284 
 285                 /*
 286                  * Diagnose (-D unused) a completely unreferenced file.
 287                  */
 288                 if ((ifl->ifl_flags & FLG_IF_FILEREF) == 0)
 289                         DBG_CALL(Dbg_unused_file(ofl->ofl_lml,
 290                             ifl->ifl_name, 0, 0));
 291                 if (((ofl->ofl_flags1 & FLG_OF1_IGNPRC) == 0) ||
 292                     ((ifl->ifl_flags & FLG_IF_IGNORE) == 0))
 293                         continue;
 294 
 295                 /*
 296                  * Before scanning the whole symbol table to determine if
 297                  * symbols should be discard - quickly (relatively) scan the
 298                  * sections to determine if any are to be discarded.
 299                  */
 300                 discard = 0;
 301                 if (ifl->ifl_flags & FLG_IF_FILEREF) {
 302                         for (num = 1; num < ifl->ifl_shnum; num++) {
 303                                 if (((isp = ifl->ifl_isdesc[num]) != NULL) &&
 304                                     ((isp->is_flags & FLG_IS_SECTREF) == 0) &&
 305                                     ((osp = isp->is_osdesc) != NULL) &&
 306                                     ((sgp = osp->os_sgdesc) != NULL) &&
 307                                     (sgp->sg_phdr.p_type == PT_LOAD)) {
 308                                         discard++;
 309                                         break;
 310                                 }
 311                         }
 312                 }
 313 
 314                 /*
 315                  * No sections are to be 'ignored'
 316                  */
 317                 if ((discard == 0) && (ifl->ifl_flags & FLG_IF_FILEREF))
 318                         continue;
 319 
 320                 /*
 321                  * We know that we have discarded sections.  Scan the symbol
 322                  * table for this file to determine if symbols need to be
 323                  * discarded that are associated with the 'ignored' sections.
 324                  */
 325                 for (num = 1; num < ifl->ifl_symscnt; num++) {
 326                         Sym_desc        *sdp;
 327 
 328                         /*
 329                          * If the symbol definition has been resolved to another
 330                          * file, or the symbol has already been discarded or
 331                          * eliminated, skip it.
 332                          */
 333                         sdp = ifl->ifl_oldndx[num];
 334                         if ((sdp->sd_file != ifl) ||
 335                             (sdp->sd_flags &
 336                             (FLG_SY_ISDISC | FLG_SY_INVALID | FLG_SY_ELIM)))
 337                                 continue;
 338 
 339                         /*
 340                          * Complete the investigation of the symbol.
 341                          */
 342                         ignore_sym(ofl, ifl, sdp, allow_ldynsym);
 343                 }
 344         }
 345 
 346         /*
 347          * If we were only here to solicit debugging diagnostics, we're done.
 348          */
 349         if ((ofl->ofl_flags1 & FLG_OF1_IGNPRC) == 0)
 350                 return (1);
 351 
 352         /*
 353          * Scan all output relocations searching for those against discarded or
 354          * ignored sections.  If one is found, decrement the total outrel count.
 355          */
 356         REL_CACHE_TRAVERSE(&ofl->ofl_outrels, idx1, rcbp, rsp) {
 357                 Is_desc         *isc = rsp->rel_isdesc;
 358                 uint_t          flags, entsize;
 359                 Shdr            *shdr;
 360 
 361                 if ((isc == NULL) || ((isc->is_flags & (FLG_IS_SECTREF))) ||
 362                     ((ifl = isc->is_file) == NULL) ||
 363                     ((ifl->ifl_flags & FLG_IF_IGNORE) == 0) ||
 364                     ((shdr = isc->is_shdr) == NULL) ||
 365                     ((shdr->sh_flags & SHF_ALLOC) == 0))
 366                         continue;
 367 
 368                 flags = rsp->rel_flags;
 369 
 370                 if (flags & (FLG_REL_GOT | FLG_REL_BSS |
 371                     FLG_REL_NOINFO | FLG_REL_PLT))
 372                         continue;
 373 
 374                 osp = RELAUX_GET_OSDESC(rsp);
 375 
 376                 if (rsp->rel_flags & FLG_REL_RELA)
 377                         entsize = sizeof (Rela);
 378                 else
 379                         entsize = sizeof (Rel);
 380 
 381                 assert(osp->os_szoutrels > 0);
 382                 osp->os_szoutrels -= entsize;
 383 
 384                 if (!(flags & FLG_REL_PLT))
 385                         ofl->ofl_reloccntsub++;
 386 
 387                 if (rsp->rel_rtype == ld_targ.t_m.m_r_relative)
 388                         ofl->ofl_relocrelcnt--;
 389         }
 390 
 391         /*
 392          * As a result of our work here, the number of output sections may
 393          * have decreased. Trigger a call to adjust_os_count().
 394          */
 395         ofl->ofl_flags |= FLG_OF_ADJOSCNT;
 396 
 397         return (1);
 398 }
 399 
 400 /*
 401  * Allocate Elf_Data, Shdr, and Is_desc structures for a new
 402  * section.
 403  *
 404  * entry:
 405  *      ofl - Output file descriptor
 406  *      shtype - SHT_ type code for section.
 407  *      shname - String giving the name for the new section.
 408  *      entcnt - # of items contained in the data part of the new section.
 409  *              This value is multiplied against the known element size
 410  *              for the section type to determine the size of the data
 411  *              area for the section. It is only meaningful in cases where
 412  *              the section type has a non-zero element size. In other cases,
 413  *              the caller must set the size fields in the *ret_data and
 414  *              *ret_shdr structs manually.
 415  *      ret_isec, ret_shdr, ret_data - Address of pointers to
 416  *              receive address of newly allocated structs.
 417  *
 418  * exit:
 419  *      On error, returns S_ERROR. On success, returns (1), and the
 420  *      ret_ pointers have been updated to point at the new structures,
 421  *      which have been filled in. To finish the task, the caller must
 422  *      update any fields within the supplied descriptors that differ
 423  *      from its needs, and then call ld_place_section().
 424  */
 425 static uintptr_t
 426 new_section(Ofl_desc *ofl, Word shtype, const char *shname, Xword entcnt,
 427         Is_desc **ret_isec, Shdr **ret_shdr, Elf_Data **ret_data)
 428 {
 429         typedef struct sec_info {
 430                 Word d_type;
 431                 Word align;     /* Used in both data and section header */
 432                 Word sh_flags;
 433                 Word sh_entsize;
 434         } SEC_INFO_T;
 435 
 436         const SEC_INFO_T        *sec_info;
 437 
 438         Shdr            *shdr;
 439         Elf_Data        *data;
 440         Is_desc         *isec;
 441         size_t          size;
 442 
 443         /*
 444          * For each type of section, we have a distinct set of
 445          * SEC_INFO_T values. This macro defines a static structure
 446          * containing those values and generates code to set the sec_info
 447          * pointer to refer to it. The pointer in sec_info remains valid
 448          * outside of the declaration scope because the info_s struct is static.
 449          *
 450          * We can't determine the value of M_WORD_ALIGN at compile time, so
 451          * a different variant is used for those cases.
 452          */
 453 #define SET_SEC_INFO(d_type, d_align, sh_flags, sh_entsize) \
 454         { \
 455                 static const SEC_INFO_T info_s = { d_type, d_align, sh_flags, \
 456                     sh_entsize}; \
 457                 sec_info = &info_s; \
 458         }
 459 #define SET_SEC_INFO_WORD_ALIGN(d_type, sh_flags, sh_entsize) \
 460         { \
 461                 static SEC_INFO_T info_s = { d_type, 0, sh_flags, \
 462                     sh_entsize}; \
 463                 info_s.align = ld_targ.t_m.m_word_align; \
 464                 sec_info = &info_s; \
 465         }
 466 
 467         switch (shtype) {
 468         case SHT_PROGBITS:
 469                 /*
 470                  * SHT_PROGBITS sections contain are used for many
 471                  * different sections. Alignments and flags differ.
 472                  * Some have a standard entsize, and others don't.
 473                  * We set some defaults here, but there is no expectation
 474                  * that they are correct or complete for any specific
 475                  * purpose. The caller must provide the correct values.
 476                  */
 477                 SET_SEC_INFO_WORD_ALIGN(ELF_T_BYTE, SHF_ALLOC, 0)
 478                 break;
 479 
 480         case SHT_SYMTAB:
 481                 SET_SEC_INFO_WORD_ALIGN(ELF_T_SYM, 0, sizeof (Sym))
 482                 break;
 483 
 484         case SHT_DYNSYM:
 485                 SET_SEC_INFO_WORD_ALIGN(ELF_T_SYM, SHF_ALLOC, sizeof (Sym))
 486                 break;
 487 
 488         case SHT_SUNW_LDYNSYM:
 489                 ofl->ofl_flags |= FLG_OF_OSABI;
 490                 SET_SEC_INFO_WORD_ALIGN(ELF_T_SYM, SHF_ALLOC, sizeof (Sym))
 491                 break;
 492 
 493         case SHT_STRTAB:
 494                 /*
 495                  * A string table may or may not be allocable, depending
 496                  * on context, so we leave that flag unset and leave it to
 497                  * the caller to add it if necessary.
 498                  *
 499                  * String tables do not have a standard entsize, so
 500                  * we set it to 0.
 501                  */
 502                 SET_SEC_INFO(ELF_T_BYTE, 1, SHF_STRINGS, 0)
 503                 break;
 504 
 505         case SHT_RELA:
 506                 /*
 507                  * Relocations with an addend (Everything except 32-bit X86).
 508                  * The caller is expected to set all section header flags.
 509                  */
 510                 SET_SEC_INFO_WORD_ALIGN(ELF_T_RELA, 0, sizeof (Rela))
 511                 break;
 512 
 513         case SHT_REL:
 514                 /*
 515                  * Relocations without an addend (32-bit X86 only).
 516                  * The caller is expected to set all section header flags.
 517                  */
 518                 SET_SEC_INFO_WORD_ALIGN(ELF_T_REL, 0, sizeof (Rel))
 519                 break;
 520 
 521         case SHT_HASH:
 522                 SET_SEC_INFO_WORD_ALIGN(ELF_T_WORD, SHF_ALLOC, sizeof (Word))
 523                 break;
 524 
 525         case SHT_SUNW_symsort:
 526         case SHT_SUNW_tlssort:
 527                 ofl->ofl_flags |= FLG_OF_OSABI;
 528                 SET_SEC_INFO_WORD_ALIGN(ELF_T_WORD, SHF_ALLOC, sizeof (Word))
 529                 break;
 530 
 531         case SHT_DYNAMIC:
 532                 /*
 533                  * A dynamic section may or may not be allocable, and may or
 534                  * may not be writable, depending on context, so we leave the
 535                  * flags unset and leave it to the caller to add them if
 536                  * necessary.
 537                  */
 538                 SET_SEC_INFO_WORD_ALIGN(ELF_T_DYN, 0, sizeof (Dyn))
 539                 break;
 540 
 541         case SHT_NOBITS:
 542                 /*
 543                  * SHT_NOBITS is used for BSS-type sections. The size and
 544                  * alignment depend on the specific use and must be adjusted
 545                  * by the caller.
 546                  */
 547                 SET_SEC_INFO(ELF_T_BYTE, 0, SHF_ALLOC | SHF_WRITE, 0)
 548                 break;
 549 
 550         case SHT_INIT_ARRAY:
 551         case SHT_FINI_ARRAY:
 552         case SHT_PREINIT_ARRAY:
 553                 SET_SEC_INFO(ELF_T_ADDR, sizeof (Addr), SHF_ALLOC | SHF_WRITE,
 554                     sizeof (Addr))
 555                 break;
 556 
 557         case SHT_SYMTAB_SHNDX:
 558                 /*
 559                  * Note that these sections are created to be associated
 560                  * with both symtab and dynsym symbol tables. However, they
 561                  * are non-allocable in all cases, because the runtime
 562                  * linker has no need for this information. It is purely
 563                  * informational, used by elfdump(1), debuggers, etc.
 564                  */
 565                 SET_SEC_INFO_WORD_ALIGN(ELF_T_WORD, 0, sizeof (Word));
 566                 break;
 567 
 568         case SHT_SUNW_cap:
 569                 ofl->ofl_flags |= FLG_OF_OSABI;
 570                 SET_SEC_INFO_WORD_ALIGN(ELF_T_CAP, SHF_ALLOC, sizeof (Cap));
 571                 break;
 572 
 573         case SHT_SUNW_capchain:
 574                 ofl->ofl_flags |= FLG_OF_OSABI;
 575                 SET_SEC_INFO_WORD_ALIGN(ELF_T_WORD, SHF_ALLOC,
 576                     sizeof (Capchain));
 577                 break;
 578 
 579         case SHT_SUNW_capinfo:
 580                 ofl->ofl_flags |= FLG_OF_OSABI;
 581 #if     _ELF64
 582                 SET_SEC_INFO(ELF_T_XWORD, sizeof (Xword), SHF_ALLOC,
 583                     sizeof (Capinfo));
 584 #else
 585                 SET_SEC_INFO(ELF_T_WORD, sizeof (Word), SHF_ALLOC,
 586                     sizeof (Capinfo));
 587 #endif
 588                 break;
 589 
 590         case SHT_SUNW_move:
 591                 ofl->ofl_flags |= FLG_OF_OSABI;
 592                 SET_SEC_INFO(ELF_T_BYTE, sizeof (Lword),
 593                     SHF_ALLOC | SHF_WRITE, sizeof (Move));
 594                 break;
 595 
 596         case SHT_SUNW_syminfo:
 597                 ofl->ofl_flags |= FLG_OF_OSABI;
 598                 /*
 599                  * The sh_info field of the SHT_*_syminfo section points
 600                  * to the header index of the associated .dynamic section,
 601                  * so we also set SHF_INFO_LINK.
 602                  */
 603                 SET_SEC_INFO_WORD_ALIGN(ELF_T_BYTE,
 604                     SHF_ALLOC | SHF_INFO_LINK, sizeof (Syminfo));
 605                 break;
 606 
 607         case SHT_SUNW_verneed:
 608         case SHT_SUNW_verdef:
 609                 ofl->ofl_flags |= FLG_OF_OSABI;
 610                 /*
 611                  * The info for verneed and versym happen to be the same.
 612                  * The entries in these sections are not of uniform size,
 613                  * so we set the entsize to 0.
 614                  */
 615                 SET_SEC_INFO_WORD_ALIGN(ELF_T_BYTE, SHF_ALLOC, 0);
 616                 break;
 617 
 618         case SHT_SUNW_versym:
 619                 ofl->ofl_flags |= FLG_OF_OSABI;
 620                 SET_SEC_INFO_WORD_ALIGN(ELF_T_BYTE, SHF_ALLOC,
 621                     sizeof (Versym));
 622                 break;
 623 
 624         default:
 625                 /* Should not happen: fcn called with unknown section type */
 626                 assert(0);
 627                 return (S_ERROR);
 628         }
 629 #undef  SET_SEC_INFO
 630 #undef  SET_SEC_INFO_WORD_ALIGN
 631 
 632         size = entcnt * sec_info->sh_entsize;
 633 
 634         /*
 635          * Allocate and initialize the Elf_Data structure.
 636          */
 637         if ((data = libld_calloc(sizeof (Elf_Data), 1)) == NULL)
 638                 return (S_ERROR);
 639         data->d_type = sec_info->d_type;
 640         data->d_size = size;
 641         data->d_align = sec_info->align;
 642         data->d_version = ofl->ofl_dehdr->e_version;
 643 
 644         /*
 645          * Allocate and initialize the Shdr structure.
 646          */
 647         if ((shdr = libld_calloc(sizeof (Shdr), 1)) == NULL)
 648                 return (S_ERROR);
 649         shdr->sh_type = shtype;
 650         shdr->sh_size = size;
 651         shdr->sh_flags = sec_info->sh_flags;
 652         shdr->sh_addralign = sec_info->align;
 653         shdr->sh_entsize = sec_info->sh_entsize;
 654 
 655         /*
 656          * Allocate and initialize the Is_desc structure.
 657          */
 658         if ((isec = libld_calloc(1, sizeof (Is_desc))) == NULL)
 659                 return (S_ERROR);
 660         isec->is_name = shname;
 661         isec->is_shdr = shdr;
 662         isec->is_indata = data;
 663 
 664 
 665         *ret_isec = isec;
 666         *ret_shdr = shdr;
 667         *ret_data = data;
 668         return (1);
 669 }
 670 
 671 /*
 672  * Use an existing input section as a template to create a new
 673  * input section with the same values as the original, other than
 674  * the size of the data area which is supplied by the caller.
 675  *
 676  * entry:
 677  *      ofl - Output file descriptor
 678  *      ifl - Input file section to use as a template
 679  *      size - Size of data area for new section
 680  *      ret_isec, ret_shdr, ret_data - Address of pointers to
 681  *              receive address of newly allocated structs.
 682  *
 683  * exit:
 684  *      On error, returns S_ERROR. On success, returns (1), and the
 685  *      ret_ pointers have been updated to point at the new structures,
 686  *      which have been filled in. To finish the task, the caller must
 687  *      update any fields within the supplied descriptors that differ
 688  *      from its needs, and then call ld_place_section().
 689  */
 690 static uintptr_t
 691 new_section_from_template(Ofl_desc *ofl, Is_desc *tmpl_isp, size_t size,
 692         Is_desc **ret_isec, Shdr **ret_shdr, Elf_Data **ret_data)
 693 {
 694         Shdr            *shdr;
 695         Elf_Data        *data;
 696         Is_desc         *isec;
 697 
 698         /*
 699          * Allocate and initialize the Elf_Data structure.
 700          */
 701         if ((data = libld_calloc(sizeof (Elf_Data), 1)) == NULL)
 702                 return (S_ERROR);
 703         data->d_type = tmpl_isp->is_indata->d_type;
 704         data->d_size = size;
 705         data->d_align = tmpl_isp->is_shdr->sh_addralign;
 706         data->d_version = ofl->ofl_dehdr->e_version;
 707 
 708         /*
 709          * Allocate and initialize the Shdr structure.
 710          */
 711         if ((shdr = libld_malloc(sizeof (Shdr))) == NULL)
 712                 return (S_ERROR);
 713         *shdr = *tmpl_isp->is_shdr;
 714         shdr->sh_addr = 0;
 715         shdr->sh_offset = 0;
 716         shdr->sh_size = size;
 717 
 718         /*
 719          * Allocate and initialize the Is_desc structure.
 720          */
 721         if ((isec = libld_calloc(1, sizeof (Is_desc))) == NULL)
 722                 return (S_ERROR);
 723         isec->is_name = tmpl_isp->is_name;
 724         isec->is_shdr = shdr;
 725         isec->is_indata = data;
 726 
 727 
 728         *ret_isec = isec;
 729         *ret_shdr = shdr;
 730         *ret_data = data;
 731         return (1);
 732 }
 733 
 734 /*
 735  * Build a .bss section for allocation of tentative definitions.  Any `static'
 736  * .bss definitions would have been associated to their own .bss sections and
 737  * thus collected from the input files.  `global' .bss definitions are tagged
 738  * as COMMON and do not cause any associated .bss section elements to be
 739  * generated.  Here we add up all these COMMON symbols and generate the .bss
 740  * section required to represent them.
 741  */
 742 uintptr_t
 743 ld_make_bss(Ofl_desc *ofl, Xword size, Xword align, uint_t ident)
 744 {
 745         Shdr            *shdr;
 746         Elf_Data        *data;
 747         Is_desc         *isec;
 748         Os_desc         *osp;
 749         Xword           rsize = (Xword)ofl->ofl_relocbsssz;
 750 
 751         /*
 752          * Allocate header structs. We will set the name ourselves below,
 753          * and there is no entcnt for a BSS. So, the shname and entcnt
 754          * arguments are 0.
 755          */
 756         if (new_section(ofl, SHT_NOBITS, NULL, 0,
 757             &isec, &shdr, &data) == S_ERROR)
 758                 return (S_ERROR);
 759 
 760         data->d_size = (size_t)size;
 761         data->d_align = (size_t)align;
 762 
 763         shdr->sh_size = size;
 764         shdr->sh_addralign = align;
 765 
 766         if (ident == ld_targ.t_id.id_tlsbss) {
 767                 isec->is_name = MSG_ORIG(MSG_SCN_TBSS);
 768                 ofl->ofl_istlsbss = isec;
 769                 shdr->sh_flags |= SHF_TLS;
 770 
 771         } else if (ident == ld_targ.t_id.id_bss) {
 772                 isec->is_name = MSG_ORIG(MSG_SCN_BSS);
 773                 ofl->ofl_isbss = isec;
 774 
 775 #if     defined(_ELF64)
 776         } else if ((ld_targ.t_m.m_mach == EM_AMD64) &&
 777             (ident == ld_targ.t_id.id_lbss)) {
 778                 isec->is_name = MSG_ORIG(MSG_SCN_LBSS);
 779                 ofl->ofl_islbss = isec;
 780                 shdr->sh_flags |= SHF_AMD64_LARGE;
 781 #endif
 782         }
 783 
 784         /*
 785          * Retain this .*bss input section as this will be where global symbol
 786          * references are added.
 787          */
 788         if ((osp = ld_place_section(ofl, isec, NULL, ident, NULL)) ==
 789             (Os_desc *)S_ERROR)
 790                 return (S_ERROR);
 791 
 792         /*
 793          * If relocations exist against a .*bss section, a section symbol must
 794          * be created for the section in the .dynsym symbol table.
 795          */
 796         if (!(osp->os_flags & FLG_OS_OUTREL)) {
 797                 ofl_flag_t      flagtotest;
 798 
 799                 if (ident == ld_targ.t_id.id_tlsbss)
 800                         flagtotest = FLG_OF1_TLSOREL;
 801                 else
 802                         flagtotest = FLG_OF1_BSSOREL;
 803 
 804                 if (ofl->ofl_flags1 & flagtotest) {
 805                         ofl->ofl_dynshdrcnt++;
 806                         osp->os_flags |= FLG_OS_OUTREL;
 807                 }
 808         }
 809 
 810         osp->os_szoutrels = rsize;
 811         return (1);
 812 }
 813 
 814 /*
 815  * Build a SHT_{INIT|FINI|PREINIT}ARRAY section (specified via
 816  * ld -z *array=name).
 817  */
 818 static uintptr_t
 819 make_array(Ofl_desc *ofl, Word shtype, const char *sectname, APlist *alp)
 820 {
 821         uint_t          entcount;
 822         Aliste          idx;
 823         Elf_Data        *data;
 824         Is_desc         *isec;
 825         Shdr            *shdr;
 826         Sym_desc        *sdp;
 827         Rel_desc        reld;
 828         Rela            reloc;
 829         Os_desc         *osp;
 830         uintptr_t       ret = 1;
 831 
 832         if (alp == NULL)
 833                 return (1);
 834 
 835         entcount = 0;
 836         for (APLIST_TRAVERSE(alp, idx, sdp))
 837                 entcount++;
 838 
 839         if (new_section(ofl, shtype, sectname, entcount, &isec, &shdr, &data) ==
 840             S_ERROR)
 841                 return (S_ERROR);
 842 
 843         if ((data->d_buf = libld_calloc(sizeof (Addr), entcount)) == NULL)
 844                 return (S_ERROR);
 845 
 846         if (ld_place_section(ofl, isec, NULL, ld_targ.t_id.id_array, NULL) ==
 847             (Os_desc *)S_ERROR)
 848                 return (S_ERROR);
 849 
 850         osp = isec->is_osdesc;
 851 
 852         if ((ofl->ofl_osinitarray == NULL) && (shtype == SHT_INIT_ARRAY))
 853                 ofl->ofl_osinitarray = osp;
 854         if ((ofl->ofl_ospreinitarray == NULL) && (shtype == SHT_PREINIT_ARRAY))
 855                 ofl->ofl_ospreinitarray = osp;
 856         else if ((ofl->ofl_osfiniarray == NULL) && (shtype == SHT_FINI_ARRAY))
 857                 ofl->ofl_osfiniarray = osp;
 858 
 859         /*
 860          * Create relocations against this section to initialize it to the
 861          * function addresses.
 862          */
 863         reld.rel_isdesc = isec;
 864         reld.rel_aux = NULL;
 865         reld.rel_flags = FLG_REL_LOAD;
 866 
 867         /*
 868          * Fabricate the relocation information (as if a relocation record had
 869          * been input - see init_rel()).
 870          */
 871         reld.rel_rtype = ld_targ.t_m.m_r_arrayaddr;
 872         reld.rel_roffset = 0;
 873         reld.rel_raddend = 0;
 874 
 875         /*
 876          * Create a minimal relocation record to satisfy process_sym_reloc()
 877          * debugging requirements.
 878          */
 879         reloc.r_offset = 0;
 880         reloc.r_info = ELF_R_INFO(0, ld_targ.t_m.m_r_arrayaddr);
 881         reloc.r_addend = 0;
 882 
 883         DBG_CALL(Dbg_reloc_generate(ofl->ofl_lml, osp,
 884             ld_targ.t_m.m_rel_sht_type));
 885         for (APLIST_TRAVERSE(alp, idx, sdp)) {
 886                 reld.rel_sym = sdp;
 887 
 888                 if (ld_process_sym_reloc(ofl, &reld, (Rel *)&reloc, isec,
 889                     MSG_INTL(MSG_STR_COMMAND), 0) == S_ERROR) {
 890                         ret = S_ERROR;
 891                         continue;
 892                 }
 893 
 894                 reld.rel_roffset += (Xword)sizeof (Addr);
 895                 reloc.r_offset = reld.rel_roffset;
 896         }
 897 
 898         return (ret);
 899 }
 900 
 901 /*
 902  * Build a comment section (-Qy option).
 903  */
 904 static uintptr_t
 905 make_comment(Ofl_desc *ofl)
 906 {
 907         Shdr            *shdr;
 908         Elf_Data        *data;
 909         Is_desc         *isec;
 910 
 911         if (new_section(ofl, SHT_PROGBITS, MSG_ORIG(MSG_SCN_COMMENT), 0,
 912             &isec, &shdr, &data) == S_ERROR)
 913                 return (S_ERROR);
 914 
 915         data->d_buf = (void *)ofl->ofl_sgsid;
 916         data->d_size = strlen(ofl->ofl_sgsid) + 1;
 917         data->d_align = 1;
 918 
 919         shdr->sh_size = (Xword)data->d_size;
 920         shdr->sh_flags = 0;
 921         shdr->sh_addralign = 1;
 922 
 923         return ((uintptr_t)ld_place_section(ofl, isec, NULL,
 924             ld_targ.t_id.id_note, NULL));
 925 }
 926 
 927 /*
 928  * Make the dynamic section.  Calculate the size of any strings referenced
 929  * within this structure, they will be added to the global string table
 930  * (.dynstr).  This routine should be called before make_dynstr().
 931  *
 932  * This routine must be maintained in parallel with update_odynamic()
 933  * in update.c
 934  */
 935 static uintptr_t
 936 make_dynamic(Ofl_desc *ofl)
 937 {
 938         Shdr            *shdr;
 939         Os_desc         *osp;
 940         Elf_Data        *data;
 941         Is_desc         *isec;
 942         size_t          cnt = 0;
 943         Aliste          idx;
 944         Ifl_desc        *ifl;
 945         Sym_desc        *sdp;
 946         size_t          size;
 947         Str_tbl         *strtbl;
 948         ofl_flag_t      flags = ofl->ofl_flags;
 949         int             not_relobj = !(flags & FLG_OF_RELOBJ);
 950         int             unused = 0;
 951 
 952         /*
 953          * Select the required string table.
 954          */
 955         if (OFL_IS_STATIC_OBJ(ofl))
 956                 strtbl = ofl->ofl_strtab;
 957         else
 958                 strtbl = ofl->ofl_dynstrtab;
 959 
 960         /*
 961          * Only a limited subset of DT_ entries apply to relocatable
 962          * objects. See the comment at the head of update_odynamic() in
 963          * update.c for details.
 964          */
 965         if (new_section(ofl, SHT_DYNAMIC, MSG_ORIG(MSG_SCN_DYNAMIC), 0,
 966             &isec, &shdr, &data) == S_ERROR)
 967                 return (S_ERROR);
 968 
 969         /*
 970          * new_section() does not set SHF_ALLOC.  If we're building anything
 971          * besides a relocatable object, then the .dynamic section should
 972          * reside in allocatable memory.
 973          */
 974         if (not_relobj)
 975                 shdr->sh_flags |= SHF_ALLOC;
 976 
 977         /*
 978          * new_section() does not set SHF_WRITE.  If we're building an object
 979          * that specifies an interpretor, then a DT_DEBUG entry is created,
 980          * which is initialized to the applications link-map list at runtime.
 981          */
 982         if (ofl->ofl_osinterp)
 983                 shdr->sh_flags |= SHF_WRITE;
 984 
 985         osp = ofl->ofl_osdynamic =
 986             ld_place_section(ofl, isec, NULL, ld_targ.t_id.id_dynamic, NULL);
 987 
 988         /*
 989          * Reserve entries for any needed dependencies.
 990          */
 991         for (APLIST_TRAVERSE(ofl->ofl_sos, idx, ifl)) {
 992                 if (!(ifl->ifl_flags & (FLG_IF_NEEDED | FLG_IF_NEEDSTR)))
 993                         continue;
 994 
 995                 /*
 996                  * If this dependency didn't satisfy any symbol references,
 997                  * generate a debugging diagnostic (ld(1) -Dunused can be used
 998                  * to display these).  If this is a standard needed dependency,
 999                  * and -z ignore is in effect, drop the dependency.  Explicitly
1000                  * defined dependencies (i.e., -N dep) don't get dropped, and
1001                  * are flagged as being required to simplify update_odynamic()
1002                  * processing.
1003                  */
1004                 if ((ifl->ifl_flags & FLG_IF_NEEDSTR) ||
1005                     ((ifl->ifl_flags & FLG_IF_DEPREQD) == 0)) {
1006                         if (unused++ == 0)
1007                                 DBG_CALL(Dbg_util_nl(ofl->ofl_lml, DBG_NL_STD));
1008                         DBG_CALL(Dbg_unused_file(ofl->ofl_lml, ifl->ifl_soname,
1009                             (ifl->ifl_flags & FLG_IF_NEEDSTR), 0));
1010 
1011                         /*
1012                          * Guidance: Remove unused dependency.
1013                          *
1014                          * If -z ignore is in effect, this warning is not
1015                          * needed because we will quietly remove the unused
1016                          * dependency.
1017                          */
1018                         if (OFL_GUIDANCE(ofl, FLG_OFG_NO_UNUSED) &&
1019                             ((ifl->ifl_flags & FLG_IF_IGNORE) == 0))
1020                                 ld_eprintf(ofl, ERR_GUIDANCE,
1021                                     MSG_INTL(MSG_GUIDE_UNUSED),
1022                                     ifl->ifl_soname);
1023 
1024                         if (ifl->ifl_flags & FLG_IF_NEEDSTR)
1025                                 ifl->ifl_flags |= FLG_IF_DEPREQD;
1026                         else if (ifl->ifl_flags & FLG_IF_IGNORE)
1027                                 continue;
1028                 }
1029 
1030                 /*
1031                  * If this object requires a DT_POSFLAG_1 entry, reserve it.
1032                  */
1033                 if ((ifl->ifl_flags & MSK_IF_POSFLAG1) && not_relobj)
1034                         cnt++;
1035 
1036                 if (st_insert(strtbl, ifl->ifl_soname) == -1)
1037                         return (S_ERROR);
1038                 cnt++;
1039 
1040                 /*
1041                  * If the needed entry contains the $ORIGIN token make sure
1042                  * the associated DT_1_FLAGS entry is created.
1043                  */
1044                 if (strstr(ifl->ifl_soname, MSG_ORIG(MSG_STR_ORIGIN))) {
1045                         ofl->ofl_dtflags_1 |= DF_1_ORIGIN;
1046                         ofl->ofl_dtflags |= DF_ORIGIN;
1047                 }
1048         }
1049 
1050         if (unused)
1051                 DBG_CALL(Dbg_util_nl(ofl->ofl_lml, DBG_NL_STD));
1052 
1053         if (not_relobj) {
1054                 /*
1055                  * Reserve entries for any per-symbol auxiliary/filter strings.
1056                  */
1057                 cnt += alist_nitems(ofl->ofl_dtsfltrs);
1058 
1059                 /*
1060                  * Reserve entries for _init() and _fini() section addresses.
1061                  */
1062                 if (((sdp = ld_sym_find(MSG_ORIG(MSG_SYM_INIT_U),
1063                     SYM_NOHASH, NULL, ofl)) != NULL) &&
1064                     (sdp->sd_ref == REF_REL_NEED) &&
1065                     (sdp->sd_sym->st_shndx != SHN_UNDEF)) {
1066                         sdp->sd_flags |= FLG_SY_UPREQD;
1067                         cnt++;
1068                 }
1069                 if (((sdp = ld_sym_find(MSG_ORIG(MSG_SYM_FINI_U),
1070                     SYM_NOHASH, NULL, ofl)) != NULL) &&
1071                     (sdp->sd_ref == REF_REL_NEED) &&
1072                     (sdp->sd_sym->st_shndx != SHN_UNDEF)) {
1073                         sdp->sd_flags |= FLG_SY_UPREQD;
1074                         cnt++;
1075                 }
1076 
1077                 /*
1078                  * Reserve entries for any soname, filter name (shared libs
1079                  * only), run-path pointers, cache names and audit requirements.
1080                  */
1081                 if (ofl->ofl_soname) {
1082                         cnt++;
1083                         if (st_insert(strtbl, ofl->ofl_soname) == -1)
1084                                 return (S_ERROR);
1085                 }
1086                 if (ofl->ofl_filtees) {
1087                         cnt++;
1088                         if (st_insert(strtbl, ofl->ofl_filtees) == -1)
1089                                 return (S_ERROR);
1090 
1091                         /*
1092                          * If the filtees entry contains the $ORIGIN token
1093                          * make sure the associated DT_1_FLAGS entry is created.
1094                          */
1095                         if (strstr(ofl->ofl_filtees,
1096                             MSG_ORIG(MSG_STR_ORIGIN))) {
1097                                 ofl->ofl_dtflags_1 |= DF_1_ORIGIN;
1098                                 ofl->ofl_dtflags |= DF_ORIGIN;
1099                         }
1100                 }
1101         }
1102 
1103         if (ofl->ofl_rpath) {
1104                 cnt += 2;       /* DT_RPATH & DT_RUNPATH */
1105                 if (st_insert(strtbl, ofl->ofl_rpath) == -1)
1106                         return (S_ERROR);
1107 
1108                 /*
1109                  * If the rpath entry contains the $ORIGIN token make sure
1110                  * the associated DT_1_FLAGS entry is created.
1111                  */
1112                 if (strstr(ofl->ofl_rpath, MSG_ORIG(MSG_STR_ORIGIN))) {
1113                         ofl->ofl_dtflags_1 |= DF_1_ORIGIN;
1114                         ofl->ofl_dtflags |= DF_ORIGIN;
1115                 }
1116         }
1117 
1118         if (not_relobj) {
1119                 Aliste  idx;
1120                 Sg_desc *sgp;
1121 
1122                 if (ofl->ofl_config) {
1123                         cnt++;
1124                         if (st_insert(strtbl, ofl->ofl_config) == -1)
1125                                 return (S_ERROR);
1126 
1127                         /*
1128                          * If the config entry contains the $ORIGIN token
1129                          * make sure the associated DT_1_FLAGS entry is created.
1130                          */
1131                         if (strstr(ofl->ofl_config, MSG_ORIG(MSG_STR_ORIGIN))) {
1132                                 ofl->ofl_dtflags_1 |= DF_1_ORIGIN;
1133                                 ofl->ofl_dtflags |= DF_ORIGIN;
1134                         }
1135                 }
1136                 if (ofl->ofl_depaudit) {
1137                         cnt++;
1138                         if (st_insert(strtbl, ofl->ofl_depaudit) == -1)
1139                                 return (S_ERROR);
1140                 }
1141                 if (ofl->ofl_audit) {
1142                         cnt++;
1143                         if (st_insert(strtbl, ofl->ofl_audit) == -1)
1144                                 return (S_ERROR);
1145                 }
1146 
1147                 /*
1148                  * Reserve entries for the DT_HASH, DT_STRTAB, DT_STRSZ,
1149                  * DT_SYMTAB, DT_SYMENT, and DT_CHECKSUM.
1150                  */
1151                 cnt += 6;
1152 
1153                 /*
1154                  * If we are including local functions at the head of
1155                  * the dynsym, then also reserve entries for DT_SUNW_SYMTAB
1156                  * and DT_SUNW_SYMSZ.
1157                  */
1158                 if (OFL_ALLOW_LDYNSYM(ofl))
1159                         cnt += 2;
1160 
1161                 if ((ofl->ofl_dynsymsortcnt > 0) ||
1162                     (ofl->ofl_dyntlssortcnt > 0))
1163                         cnt++;          /* DT_SUNW_SORTENT */
1164 
1165                 if (ofl->ofl_dynsymsortcnt > 0)
1166                         cnt += 2;       /* DT_SUNW_[SYMSORT|SYMSORTSZ] */
1167 
1168                 if (ofl->ofl_dyntlssortcnt > 0)
1169                         cnt += 2;       /* DT_SUNW_[TLSSORT|TLSSORTSZ] */
1170 
1171                 if ((flags & (FLG_OF_VERDEF | FLG_OF_NOVERSEC)) ==
1172                     FLG_OF_VERDEF)
1173                         cnt += 2;               /* DT_VERDEF & DT_VERDEFNUM */
1174 
1175                 if ((flags & (FLG_OF_VERNEED | FLG_OF_NOVERSEC)) ==
1176                     FLG_OF_VERNEED)
1177                         cnt += 2;               /* DT_VERNEED & DT_VERNEEDNUM */
1178 
1179                 if ((flags & FLG_OF_COMREL) && ofl->ofl_relocrelcnt)
1180                         cnt++;                  /* DT_RELACOUNT */
1181 
1182                 if (flags & FLG_OF_TEXTREL) /* DT_TEXTREL */
1183                         cnt++;
1184 
1185                 if (ofl->ofl_osfiniarray)    /* DT_FINI_ARRAY */
1186                         cnt += 2;               /*    DT_FINI_ARRAYSZ */
1187 
1188                 if (ofl->ofl_osinitarray)    /* DT_INIT_ARRAY */
1189                         cnt += 2;               /*    DT_INIT_ARRAYSZ */
1190 
1191                 if (ofl->ofl_ospreinitarray) /* DT_PREINIT_ARRAY & */
1192                         cnt += 2;               /*    DT_PREINIT_ARRAYSZ */
1193 
1194                 /*
1195                  * If we have plt's reserve a DT_PLTRELSZ, DT_PLTREL and
1196                  * DT_JMPREL.
1197                  */
1198                 if (ofl->ofl_pltcnt)
1199                         cnt += 3;
1200 
1201                 /*
1202                  * If plt padding is needed (Sparcv9).
1203                  */
1204                 if (ofl->ofl_pltpad)
1205                         cnt += 2;               /* DT_PLTPAD & DT_PLTPADSZ */
1206 
1207                 /*
1208                  * If we have any relocations reserve a DT_REL, DT_RELSZ and
1209                  * DT_RELENT entry.
1210                  */
1211                 if (ofl->ofl_relocsz)
1212                         cnt += 3;
1213 
1214                 /*
1215                  * If a syminfo section is required create DT_SYMINFO,
1216                  * DT_SYMINSZ, and DT_SYMINENT entries.
1217                  */
1218                 if (flags & FLG_OF_SYMINFO)
1219                         cnt += 3;
1220 
1221                 /*
1222                  * If there are any partially initialized sections allocate
1223                  * DT_MOVETAB, DT_MOVESZ and DT_MOVEENT.
1224                  */
1225                 if (ofl->ofl_osmove)
1226                         cnt += 3;
1227 
1228                 /*
1229                  * Allocate one DT_REGISTER entry for every register symbol.
1230                  */
1231                 cnt += ofl->ofl_regsymcnt;
1232 
1233                 /*
1234                  * Reserve a entry for each '-zrtldinfo=...' specified
1235                  * on the command line.
1236                  */
1237                 for (APLIST_TRAVERSE(ofl->ofl_rtldinfo, idx, sdp))
1238                         cnt++;
1239 
1240                 /*
1241                  * The following entry should only be placed in a segment that
1242                  * is writable.
1243                  */
1244                 if (((sgp = osp->os_sgdesc) != NULL) &&
1245                     (sgp->sg_phdr.p_flags & PF_W) && ofl->ofl_osinterp)
1246                         cnt++;          /* DT_DEBUG */
1247 
1248                 /*
1249                  * Capabilities require a .dynamic entry for the .SUNW_cap
1250                  * section.
1251                  */
1252                 if (ofl->ofl_oscap)
1253                         cnt++;                  /* DT_SUNW_CAP */
1254 
1255                 /*
1256                  * Symbol capabilities require a .dynamic entry for the
1257                  * .SUNW_capinfo section.
1258                  */
1259                 if (ofl->ofl_oscapinfo)
1260                         cnt++;                  /* DT_SUNW_CAPINFO */
1261 
1262                 /*
1263                  * Capabilities chain information requires a .SUNW_capchain
1264                  * entry (DT_SUNW_CAPCHAIN), entry size (DT_SUNW_CAPCHAINENT),
1265                  * and total size (DT_SUNW_CAPCHAINSZ).
1266                  */
1267                 if (ofl->ofl_oscapchain)
1268                         cnt += 3;
1269 
1270                 if (flags & FLG_OF_SYMBOLIC)
1271                         cnt++;                  /* DT_SYMBOLIC */
1272         }
1273 
1274         /*
1275          * Account for Architecture dependent .dynamic entries, and defaults.
1276          */
1277         (*ld_targ.t_mr.mr_mach_make_dynamic)(ofl, &cnt);
1278 
1279         /*
1280          * DT_FLAGS, DT_FLAGS_1, DT_SUNW_STRPAD, and DT_NULL. Also,
1281          * allow room for the unused extra DT_NULLs. These are included
1282          * to allow an ELF editor room to add items later.
1283          */
1284         cnt += 4 + DYNAMIC_EXTRA_ELTS;
1285 
1286         /*
1287          * DT_SUNW_LDMACH. Used to hold the ELF machine code of the
1288          * linker that produced the output object. This information
1289          * allows us to determine whether a given object was linked
1290          * natively, or by a linker running on a different type of
1291          * system. This information can be valuable if one suspects
1292          * that a problem might be due to alignment or byte order issues.
1293          */
1294         cnt++;
1295 
1296         /*
1297          * Determine the size of the section from the number of entries.
1298          */
1299         size = cnt * (size_t)shdr->sh_entsize;
1300 
1301         shdr->sh_size = (Xword)size;
1302         data->d_size = size;
1303 
1304         /*
1305          * There are several tags that are specific to the Solaris osabi
1306          * range which we unconditionally put into any dynamic section
1307          * we create (e.g. DT_SUNW_STRPAD or DT_SUNW_LDMACH). As such,
1308          * any Solaris object with a dynamic section should be tagged as
1309          * ELFOSABI_SOLARIS.
1310          */
1311         ofl->ofl_flags |= FLG_OF_OSABI;
1312 
1313         return ((uintptr_t)ofl->ofl_osdynamic);
1314 }
1315 
1316 /*
1317  * Build the GOT section and its associated relocation entries.
1318  */
1319 uintptr_t
1320 ld_make_got(Ofl_desc *ofl)
1321 {
1322         Elf_Data        *data;
1323         Shdr    *shdr;
1324         Is_desc *isec;
1325         size_t  size = (size_t)ofl->ofl_gotcnt * ld_targ.t_m.m_got_entsize;
1326         size_t  rsize = (size_t)ofl->ofl_relocgotsz;
1327 
1328         if (new_section(ofl, SHT_PROGBITS, MSG_ORIG(MSG_SCN_GOT), 0,
1329             &isec, &shdr, &data) == S_ERROR)
1330                 return (S_ERROR);
1331 
1332         data->d_size = size;
1333 
1334         shdr->sh_flags |= SHF_WRITE;
1335         shdr->sh_size = (Xword)size;
1336         shdr->sh_entsize = ld_targ.t_m.m_got_entsize;
1337 
1338         ofl->ofl_osgot = ld_place_section(ofl, isec, NULL,
1339             ld_targ.t_id.id_got, NULL);
1340         if (ofl->ofl_osgot == (Os_desc *)S_ERROR)
1341                 return (S_ERROR);
1342 
1343         ofl->ofl_osgot->os_szoutrels = (Xword)rsize;
1344 
1345         return (1);
1346 }
1347 
1348 /*
1349  * Build an interpreter section.
1350  */
1351 static uintptr_t
1352 make_interp(Ofl_desc *ofl)
1353 {
1354         Shdr            *shdr;
1355         Elf_Data        *data;
1356         Is_desc         *isec;
1357         const char      *iname = ofl->ofl_interp;
1358         size_t          size;
1359 
1360         /*
1361          * If -z nointerp is in effect, don't create an interpreter section.
1362          */
1363         if (ofl->ofl_flags1 & FLG_OF1_NOINTRP)
1364                 return (1);
1365 
1366         /*
1367          * An .interp section is always created for a dynamic executable.
1368          * A user can define the interpreter to use.  This definition overrides
1369          * the default that would be recorded in an executable, and triggers
1370          * the creation of an .interp section in any other object.  Presumably
1371          * the user knows what they are doing.  Refer to the generic ELF ABI
1372          * section 5-4, and the ld(1) -I option.
1373          */
1374         if (((ofl->ofl_flags & (FLG_OF_DYNAMIC | FLG_OF_EXEC |
1375             FLG_OF_RELOBJ)) != (FLG_OF_DYNAMIC | FLG_OF_EXEC)) && !iname)
1376                 return (1);
1377 
1378         /*
1379          * In the case of a dynamic executable, supply a default interpreter
1380          * if the user has not specified their own.
1381          */
1382         if (iname == NULL)
1383                 iname = ofl->ofl_interp = ld_targ.t_m.m_def_interp;
1384 
1385         size = strlen(iname) + 1;
1386 
1387         if (new_section(ofl, SHT_PROGBITS, MSG_ORIG(MSG_SCN_INTERP), 0,
1388             &isec, &shdr, &data) == S_ERROR)
1389                 return (S_ERROR);
1390 
1391         data->d_size = size;
1392         shdr->sh_size = (Xword)size;
1393         data->d_align = shdr->sh_addralign = 1;
1394 
1395         ofl->ofl_osinterp =
1396             ld_place_section(ofl, isec, NULL, ld_targ.t_id.id_interp, NULL);
1397         return ((uintptr_t)ofl->ofl_osinterp);
1398 }
1399 
1400 /*
1401  * Common function used to build the SHT_SUNW_versym section, SHT_SUNW_syminfo
1402  * section, and SHT_SUNW_capinfo section.  Each of these sections provide
1403  * additional symbol information, and their size parallels the associated
1404  * symbol table.
1405  */
1406 static Os_desc *
1407 make_sym_sec(Ofl_desc *ofl, const char *sectname, Word stype, int ident)
1408 {
1409         Shdr            *shdr;
1410         Elf_Data        *data;
1411         Is_desc         *isec;
1412 
1413         /*
1414          * We don't know the size of this section yet, so set it to 0.  The
1415          * size gets filled in after the associated symbol table is sized.
1416          */
1417         if (new_section(ofl, stype, sectname, 0, &isec, &shdr, &data) ==
1418             S_ERROR)
1419                 return ((Os_desc *)S_ERROR);
1420 
1421         return (ld_place_section(ofl, isec, NULL, ident, NULL));
1422 }
1423 
1424 /*
1425  * Determine whether a symbol capability is redundant because the object
1426  * capabilities are more restrictive.
1427  */
1428 inline static int
1429 is_cap_redundant(Objcapset *ocapset, Objcapset *scapset)
1430 {
1431         Alist           *oalp, *salp;
1432         elfcap_mask_t   omsk, smsk;
1433 
1434         /*
1435          * Inspect any platform capabilities.  If the object defines platform
1436          * capabilities, then the object will only be loaded for those
1437          * platforms.  A symbol capability set that doesn't define the same
1438          * platforms is redundant, and a symbol capability that does not provide
1439          * at least one platform name that matches a platform name in the object
1440          * capabilities will never execute (as the object wouldn't have been
1441          * loaded).
1442          */
1443         oalp = ocapset->oc_plat.cl_val;
1444         salp = scapset->oc_plat.cl_val;
1445         if (oalp && ((salp == NULL) || cap_names_match(oalp, salp)))
1446                 return (1);
1447 
1448         /*
1449          * If the symbol capability set defines platforms, and the object
1450          * doesn't, then the symbol set is more restrictive.
1451          */
1452         if (salp && (oalp == NULL))
1453                 return (0);
1454 
1455         /*
1456          * Next, inspect any machine name capabilities.  If the object defines
1457          * machine name capabilities, then the object will only be loaded for
1458          * those machines.  A symbol capability set that doesn't define the same
1459          * machine names is redundant, and a symbol capability that does not
1460          * provide at least one machine name that matches a machine name in the
1461          * object capabilities will never execute (as the object wouldn't have
1462          * been loaded).
1463          */
1464         oalp = ocapset->oc_plat.cl_val;
1465         salp = scapset->oc_plat.cl_val;
1466         if (oalp && ((salp == NULL) || cap_names_match(oalp, salp)))
1467                 return (1);
1468 
1469         /*
1470          * If the symbol capability set defines machine names, and the object
1471          * doesn't, then the symbol set is more restrictive.
1472          */
1473         if (salp && (oalp == NULL))
1474                 return (0);
1475 
1476         /*
1477          * Next, inspect any hardware capabilities.  If the objects hardware
1478          * capabilities are greater than or equal to that of the symbols
1479          * capabilities, then the symbol capability set is redundant.  If the
1480          * symbols hardware capabilities are greater that the objects, then the
1481          * symbol set is more restrictive.
1482          *
1483          * Note that this is a somewhat arbitrary definition, as each capability
1484          * bit is independent of the others, and some of the higher order bits
1485          * could be considered to be less important than lower ones.  However,
1486          * this is the only reasonable non-subjective definition.
1487          */
1488         omsk = ocapset->oc_hw_2.cm_val;
1489         smsk = scapset->oc_hw_2.cm_val;
1490         if ((omsk > smsk) || (omsk && (omsk == smsk)))
1491                 return (1);
1492         if (omsk < smsk)
1493                 return (0);
1494 
1495         /*
1496          * Finally, inspect the remaining hardware capabilities.
1497          */
1498         omsk = ocapset->oc_hw_1.cm_val;
1499         smsk = scapset->oc_hw_1.cm_val;
1500         if ((omsk > smsk) || (omsk && (omsk == smsk)))
1501                 return (1);
1502 
1503         return (0);
1504 }
1505 
1506 /*
1507  * Capabilities values might have been assigned excluded values.  These
1508  * excluded values should be removed before calculating any capabilities
1509  * sections size.
1510  */
1511 static void
1512 capmask_value(Lm_list *lml, Word type, Capmask *capmask, int *title)
1513 {
1514         /*
1515          * First determine whether any bits should be excluded.
1516          */
1517         if ((capmask->cm_val & capmask->cm_exc) == 0)
1518                 return;
1519 
1520         DBG_CALL(Dbg_cap_post_title(lml, title));
1521 
1522         DBG_CALL(Dbg_cap_val_entry(lml, DBG_STATE_CURRENT, type,
1523             capmask->cm_val, ld_targ.t_m.m_mach));
1524         DBG_CALL(Dbg_cap_val_entry(lml, DBG_STATE_EXCLUDE, type,
1525             capmask->cm_exc, ld_targ.t_m.m_mach));
1526 
1527         capmask->cm_val &= ~capmask->cm_exc;
1528 
1529         DBG_CALL(Dbg_cap_val_entry(lml, DBG_STATE_RESOLVED, type,
1530             capmask->cm_val, ld_targ.t_m.m_mach));
1531 }
1532 
1533 static void
1534 capstr_value(Lm_list *lml, Word type, Caplist *caplist, int *title)
1535 {
1536         Aliste  idx1, idx2;
1537         char    *estr;
1538         Capstr  *capstr;
1539         Boolean found = FALSE;
1540 
1541         /*
1542          * First determine whether any strings should be excluded.
1543          */
1544         for (APLIST_TRAVERSE(caplist->cl_exc, idx1, estr)) {
1545                 for (ALIST_TRAVERSE(caplist->cl_val, idx2, capstr)) {
1546                         if (strcmp(estr, capstr->cs_str) == 0) {
1547                                 found = TRUE;
1548                                 break;
1549                         }
1550                 }
1551         }
1552 
1553         if (found == FALSE)
1554                 return;
1555 
1556         /*
1557          * Traverse the current strings, then delete the excluded strings,
1558          * and finally display the resolved strings.
1559          */
1560         if (DBG_ENABLED) {
1561                 Dbg_cap_post_title(lml, title);
1562                 for (ALIST_TRAVERSE(caplist->cl_val, idx2, capstr)) {
1563                         Dbg_cap_ptr_entry(lml, DBG_STATE_CURRENT, type,
1564                             capstr->cs_str);
1565                 }
1566         }
1567         for (APLIST_TRAVERSE(caplist->cl_exc, idx1, estr)) {
1568                 for (ALIST_TRAVERSE(caplist->cl_val, idx2, capstr)) {
1569                         if (strcmp(estr, capstr->cs_str) == 0) {
1570                                 DBG_CALL(Dbg_cap_ptr_entry(lml,
1571                                     DBG_STATE_EXCLUDE, type, capstr->cs_str));
1572                                 alist_delete(caplist->cl_val, &idx2);
1573                                 break;
1574                         }
1575                 }
1576         }
1577         if (DBG_ENABLED) {
1578                 for (ALIST_TRAVERSE(caplist->cl_val, idx2, capstr)) {
1579                         Dbg_cap_ptr_entry(lml, DBG_STATE_RESOLVED, type,
1580                             capstr->cs_str);
1581                 }
1582         }
1583 }
1584 
1585 /*
1586  * Build a capabilities section.
1587  */
1588 #define CAP_UPDATE(cap, capndx, tag, val)       \
1589         cap->c_tag = tag; \
1590         cap->c_un.c_val = val; \
1591         cap++, capndx++;
1592 
1593 static uintptr_t
1594 make_cap(Ofl_desc *ofl, Word shtype, const char *shname, int ident)
1595 {
1596         Shdr            *shdr;
1597         Elf_Data        *data;
1598         Is_desc         *isec;
1599         Cap             *cap;
1600         size_t          size = 0;
1601         Word            capndx = 0;
1602         Str_tbl         *strtbl;
1603         Objcapset       *ocapset = &ofl->ofl_ocapset;
1604         Aliste          idx1;
1605         Capstr          *capstr;
1606         int             title = 0;
1607 
1608         /*
1609          * Determine which string table to use for any CA_SUNW_MACH,
1610          * CA_SUNW_PLAT, or CA_SUNW_ID strings.
1611          */
1612         if (OFL_IS_STATIC_OBJ(ofl))
1613                 strtbl = ofl->ofl_strtab;
1614         else
1615                 strtbl = ofl->ofl_dynstrtab;
1616 
1617         /*
1618          * If symbol capabilities have been requested, but none have been
1619          * created, warn the user.  This scenario can occur if none of the
1620          * input relocatable objects defined any object capabilities.
1621          */
1622         if ((ofl->ofl_flags & FLG_OF_OTOSCAP) && (ofl->ofl_capsymcnt == 0))
1623                 ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_CAP_NOSYMSFOUND));
1624 
1625         /*
1626          * If symbol capabilities have been collected, but no symbols are left
1627          * referencing these capabilities, promote the capability groups back
1628          * to an object capability definition.
1629          */
1630         if ((ofl->ofl_flags & FLG_OF_OTOSCAP) && ofl->ofl_capsymcnt &&
1631             (ofl->ofl_capfamilies == NULL)) {
1632                 ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_CAP_NOSYMSFOUND));
1633                 ld_cap_move_symtoobj(ofl);
1634                 ofl->ofl_capsymcnt = 0;
1635                 ofl->ofl_capgroups = NULL;
1636                 ofl->ofl_flags &= ~FLG_OF_OTOSCAP;
1637         }
1638 
1639         /*
1640          * Remove any excluded capabilities.
1641          */
1642         capstr_value(ofl->ofl_lml, CA_SUNW_PLAT, &ocapset->oc_plat, &title);
1643         capstr_value(ofl->ofl_lml, CA_SUNW_MACH, &ocapset->oc_mach, &title);
1644         capmask_value(ofl->ofl_lml, CA_SUNW_HW_2, &ocapset->oc_hw_2, &title);
1645         capmask_value(ofl->ofl_lml, CA_SUNW_HW_1, &ocapset->oc_hw_1, &title);
1646         capmask_value(ofl->ofl_lml, CA_SUNW_SF_1, &ocapset->oc_sf_1, &title);
1647 
1648         /*
1649          * Determine how many entries are required for any object capabilities.
1650          */
1651         size += alist_nitems(ocapset->oc_plat.cl_val);
1652         size += alist_nitems(ocapset->oc_mach.cl_val);
1653         if (ocapset->oc_hw_2.cm_val)
1654                 size++;
1655         if (ocapset->oc_hw_1.cm_val)
1656                 size++;
1657         if (ocapset->oc_sf_1.cm_val)
1658                 size++;
1659 
1660         /*
1661          * Only identify a capabilities group if the group has content.  If a
1662          * capabilities identifier exists, and no other capabilities have been
1663          * supplied, remove the identifier.  This scenario could exist if a
1664          * user mistakenly defined a lone identifier, or if an identified group
1665          * was overridden so as to clear the existing capabilities and the
1666          * identifier was not also cleared.
1667          */
1668         if (ocapset->oc_id.cs_str) {
1669                 if (size)
1670                         size++;
1671                 else
1672                         ocapset->oc_id.cs_str = NULL;
1673         }
1674         if (size)
1675                 size++;                 /* Add CA_SUNW_NULL */
1676 
1677         /*
1678          * Determine how many entries are required for any symbol capabilities.
1679          */
1680         if (ofl->ofl_capsymcnt) {
1681                 /*
1682                  * If there are no object capabilities, a CA_SUNW_NULL entry
1683                  * is required before any symbol capabilities.
1684                  */
1685                 if (size == 0)
1686                         size++;
1687                 size += ofl->ofl_capsymcnt;
1688         }
1689 
1690         if (size == 0)
1691                 return (NULL);
1692 
1693         if (new_section(ofl, shtype, shname, size, &isec,
1694             &shdr, &data) == S_ERROR)
1695                 return (S_ERROR);
1696 
1697         if ((data->d_buf = libld_malloc(shdr->sh_size)) == NULL)
1698                 return (S_ERROR);
1699 
1700         cap = (Cap *)data->d_buf;
1701 
1702         /*
1703          * Fill in any object capabilities.  If there is an identifier, then the
1704          * identifier comes first.  The remaining items follow in precedence
1705          * order, although the order isn't important for runtime verification.
1706          */
1707         if (ocapset->oc_id.cs_str) {
1708                 ofl->ofl_flags |= FLG_OF_CAPSTRS;
1709                 if (st_insert(strtbl, ocapset->oc_id.cs_str) == -1)
1710                         return (S_ERROR);
1711                 ocapset->oc_id.cs_ndx = capndx;
1712                 CAP_UPDATE(cap, capndx, CA_SUNW_ID, 0);
1713         }
1714         if (ocapset->oc_plat.cl_val) {
1715                 ofl->ofl_flags |= (FLG_OF_PTCAP | FLG_OF_CAPSTRS);
1716 
1717                 /*
1718                  * Insert any platform name strings in the appropriate string
1719                  * table.  The capability value can't be filled in yet, as the
1720                  * final offset of the strings isn't known until later.
1721                  */
1722                 for (ALIST_TRAVERSE(ocapset->oc_plat.cl_val, idx1, capstr)) {
1723                         if (st_insert(strtbl, capstr->cs_str) == -1)
1724                                 return (S_ERROR);
1725                         capstr->cs_ndx = capndx;
1726                         CAP_UPDATE(cap, capndx, CA_SUNW_PLAT, 0);
1727                 }
1728         }
1729         if (ocapset->oc_mach.cl_val) {
1730                 ofl->ofl_flags |= (FLG_OF_PTCAP | FLG_OF_CAPSTRS);
1731 
1732                 /*
1733                  * Insert the machine name strings in the appropriate string
1734                  * table.  The capability value can't be filled in yet, as the
1735                  * final offset of the strings isn't known until later.
1736                  */
1737                 for (ALIST_TRAVERSE(ocapset->oc_mach.cl_val, idx1, capstr)) {
1738                         if (st_insert(strtbl, capstr->cs_str) == -1)
1739                                 return (S_ERROR);
1740                         capstr->cs_ndx = capndx;
1741                         CAP_UPDATE(cap, capndx, CA_SUNW_MACH, 0);
1742                 }
1743         }
1744         if (ocapset->oc_hw_2.cm_val) {
1745                 ofl->ofl_flags |= FLG_OF_PTCAP;
1746                 CAP_UPDATE(cap, capndx, CA_SUNW_HW_2, ocapset->oc_hw_2.cm_val);
1747         }
1748         if (ocapset->oc_hw_1.cm_val) {
1749                 ofl->ofl_flags |= FLG_OF_PTCAP;
1750                 CAP_UPDATE(cap, capndx, CA_SUNW_HW_1, ocapset->oc_hw_1.cm_val);
1751         }
1752         if (ocapset->oc_sf_1.cm_val) {
1753                 ofl->ofl_flags |= FLG_OF_PTCAP;
1754                 CAP_UPDATE(cap, capndx, CA_SUNW_SF_1, ocapset->oc_sf_1.cm_val);
1755         }
1756         CAP_UPDATE(cap, capndx, CA_SUNW_NULL, 0);
1757 
1758         /*
1759          * Fill in any symbol capabilities.
1760          */
1761         if (ofl->ofl_capgroups) {
1762                 Cap_group       *cgp;
1763 
1764                 for (APLIST_TRAVERSE(ofl->ofl_capgroups, idx1, cgp)) {
1765                         Objcapset       *scapset = &cgp->cg_set;
1766                         Aliste          idx2;
1767                         Is_desc         *isp;
1768 
1769                         cgp->cg_ndx = capndx;
1770 
1771                         if (scapset->oc_id.cs_str) {
1772                                 ofl->ofl_flags |= FLG_OF_CAPSTRS;
1773                                 /*
1774                                  * Insert the identifier string in the
1775                                  * appropriate string table.  The capability
1776                                  * value can't be filled in yet, as the final
1777                                  * offset of the string isn't known until later.
1778                                  */
1779                                 if (st_insert(strtbl,
1780                                     scapset->oc_id.cs_str) == -1)
1781                                         return (S_ERROR);
1782                                 scapset->oc_id.cs_ndx = capndx;
1783                                 CAP_UPDATE(cap, capndx, CA_SUNW_ID, 0);
1784                         }
1785 
1786                         if (scapset->oc_plat.cl_val) {
1787                                 ofl->ofl_flags |= FLG_OF_CAPSTRS;
1788 
1789                                 /*
1790                                  * Insert the platform name string in the
1791                                  * appropriate string table.  The capability
1792                                  * value can't be filled in yet, as the final
1793                                  * offset of the string isn't known until later.
1794                                  */
1795                                 for (ALIST_TRAVERSE(scapset->oc_plat.cl_val,
1796                                     idx2, capstr)) {
1797                                         if (st_insert(strtbl,
1798                                             capstr->cs_str) == -1)
1799                                                 return (S_ERROR);
1800                                         capstr->cs_ndx = capndx;
1801                                         CAP_UPDATE(cap, capndx,
1802                                             CA_SUNW_PLAT, 0);
1803                                 }
1804                         }
1805                         if (scapset->oc_mach.cl_val) {
1806                                 ofl->ofl_flags |= FLG_OF_CAPSTRS;
1807 
1808                                 /*
1809                                  * Insert the machine name string in the
1810                                  * appropriate string table.  The capability
1811                                  * value can't be filled in yet, as the final
1812                                  * offset of the string isn't known until later.
1813                                  */
1814                                 for (ALIST_TRAVERSE(scapset->oc_mach.cl_val,
1815                                     idx2, capstr)) {
1816                                         if (st_insert(strtbl,
1817                                             capstr->cs_str) == -1)
1818                                                 return (S_ERROR);
1819                                         capstr->cs_ndx = capndx;
1820                                         CAP_UPDATE(cap, capndx,
1821                                             CA_SUNW_MACH, 0);
1822                                 }
1823                         }
1824                         if (scapset->oc_hw_2.cm_val) {
1825                                 CAP_UPDATE(cap, capndx, CA_SUNW_HW_2,
1826                                     scapset->oc_hw_2.cm_val);
1827                         }
1828                         if (scapset->oc_hw_1.cm_val) {
1829                                 CAP_UPDATE(cap, capndx, CA_SUNW_HW_1,
1830                                     scapset->oc_hw_1.cm_val);
1831                         }
1832                         if (scapset->oc_sf_1.cm_val) {
1833                                 CAP_UPDATE(cap, capndx, CA_SUNW_SF_1,
1834                                     scapset->oc_sf_1.cm_val);
1835                         }
1836                         CAP_UPDATE(cap, capndx, CA_SUNW_NULL, 0);
1837 
1838                         /*
1839                          * If any object capabilities are available, determine
1840                          * whether these symbol capabilities are less
1841                          * restrictive, and hence redundant.
1842                          */
1843                         if (((ofl->ofl_flags & FLG_OF_PTCAP) == 0) ||
1844                             (is_cap_redundant(ocapset, scapset) == 0))
1845                                 continue;
1846 
1847                         /*
1848                          * Indicate any files that provide redundant symbol
1849                          * capabilities.
1850                          */
1851                         for (APLIST_TRAVERSE(cgp->cg_secs, idx2, isp)) {
1852                                 ld_eprintf(ofl, ERR_WARNING,
1853                                     MSG_INTL(MSG_CAP_REDUNDANT),
1854                                     isp->is_file->ifl_name,
1855                                     EC_WORD(isp->is_scnndx), isp->is_name);
1856                         }
1857                 }
1858         }
1859 
1860         /*
1861          * If capabilities strings are required, the sh_info field of the
1862          * section header will be set to the associated string table.
1863          */
1864         if (ofl->ofl_flags & FLG_OF_CAPSTRS)
1865                 shdr->sh_flags |= SHF_INFO_LINK;
1866 
1867         /*
1868          * Place these capabilities in the output file.
1869          */
1870         if ((ofl->ofl_oscap = ld_place_section(ofl, isec,
1871             NULL, ident, NULL)) == (Os_desc *)S_ERROR)
1872                 return (S_ERROR);
1873 
1874         /*
1875          * If symbol capabilities are required, then a .SUNW_capinfo section is
1876          * also created.  This table will eventually be sized to match the
1877          * associated symbol table.
1878          */
1879         if (ofl->ofl_capfamilies) {
1880                 if ((ofl->ofl_oscapinfo = make_sym_sec(ofl,
1881                     MSG_ORIG(MSG_SCN_SUNWCAPINFO), SHT_SUNW_capinfo,
1882                     ld_targ.t_id.id_capinfo)) == (Os_desc *)S_ERROR)
1883                         return (S_ERROR);
1884 
1885                 /*
1886                  * If we're generating a dynamic object, capabilities family
1887                  * members are maintained in a .SUNW_capchain section.
1888                  */
1889                 if (ofl->ofl_capchaincnt &&
1890                     ((ofl->ofl_flags & FLG_OF_RELOBJ) == 0)) {
1891                         if (new_section(ofl, SHT_SUNW_capchain,
1892                             MSG_ORIG(MSG_SCN_SUNWCAPCHAIN),
1893                             ofl->ofl_capchaincnt, &isec, &shdr,
1894                             &data) == S_ERROR)
1895                                 return (S_ERROR);
1896 
1897                         ofl->ofl_oscapchain = ld_place_section(ofl, isec,
1898                             NULL, ld_targ.t_id.id_capchain, NULL);
1899                         if (ofl->ofl_oscapchain == (Os_desc *)S_ERROR)
1900                                 return (S_ERROR);
1901 
1902                 }
1903         }
1904         return (1);
1905 }
1906 #undef  CAP_UPDATE
1907 
1908 /*
1909  * Build the PLT section and its associated relocation entries.
1910  */
1911 static uintptr_t
1912 make_plt(Ofl_desc *ofl)
1913 {
1914         Shdr            *shdr;
1915         Elf_Data        *data;
1916         Is_desc         *isec;
1917         size_t          size = ld_targ.t_m.m_plt_reservsz +
1918             (((size_t)ofl->ofl_pltcnt + (size_t)ofl->ofl_pltpad) *
1919             ld_targ.t_m.m_plt_entsize);
1920         size_t          rsize = (size_t)ofl->ofl_relocpltsz;
1921 
1922         /*
1923          * On sparc, account for the NOP at the end of the plt.
1924          */
1925         if (ld_targ.t_m.m_mach == LD_TARG_BYCLASS(EM_SPARC, EM_SPARCV9))
1926                 size += sizeof (Word);
1927 
1928         if (new_section(ofl, SHT_PROGBITS, MSG_ORIG(MSG_SCN_PLT), 0,
1929             &isec, &shdr, &data) == S_ERROR)
1930                 return (S_ERROR);
1931 
1932         data->d_size = size;
1933         data->d_align = ld_targ.t_m.m_plt_align;
1934 
1935         shdr->sh_flags = ld_targ.t_m.m_plt_shf_flags;
1936         shdr->sh_size = (Xword)size;
1937         shdr->sh_addralign = ld_targ.t_m.m_plt_align;
1938         shdr->sh_entsize = ld_targ.t_m.m_plt_entsize;
1939 
1940         ofl->ofl_osplt = ld_place_section(ofl, isec, NULL,
1941             ld_targ.t_id.id_plt, NULL);
1942         if (ofl->ofl_osplt == (Os_desc *)S_ERROR)
1943                 return (S_ERROR);
1944 
1945         ofl->ofl_osplt->os_szoutrels = (Xword)rsize;
1946 
1947         return (1);
1948 }
1949 
1950 /*
1951  * Make the hash table.  Only built for dynamic executables and shared
1952  * libraries, and provides hashed lookup into the global symbol table
1953  * (.dynsym) for the run-time linker to resolve symbol lookups.
1954  */
1955 static uintptr_t
1956 make_hash(Ofl_desc *ofl)
1957 {
1958         Shdr            *shdr;
1959         Elf_Data        *data;
1960         Is_desc         *isec;
1961         size_t          size;
1962         Word            nsyms = ofl->ofl_globcnt;
1963         size_t          cnt;
1964 
1965         /*
1966          * Allocate section header structures. We set entcnt to 0
1967          * because it's going to change after we place this section.
1968          */
1969         if (new_section(ofl, SHT_HASH, MSG_ORIG(MSG_SCN_HASH), 0,
1970             &isec, &shdr, &data) == S_ERROR)
1971                 return (S_ERROR);
1972 
1973         /*
1974          * Place the section first since it will affect the local symbol
1975          * count.
1976          */
1977         ofl->ofl_oshash =
1978             ld_place_section(ofl, isec, NULL, ld_targ.t_id.id_hash, NULL);
1979         if (ofl->ofl_oshash == (Os_desc *)S_ERROR)
1980                 return (S_ERROR);
1981 
1982         /*
1983          * Calculate the number of output hash buckets.
1984          */
1985         ofl->ofl_hashbkts = findprime(nsyms);
1986 
1987         /*
1988          * The size of the hash table is determined by
1989          *
1990          *      i.      the initial nbucket and nchain entries (2)
1991          *      ii.     the number of buckets (calculated above)
1992          *      iii.    the number of chains (this is based on the number of
1993          *              symbols in the .dynsym array).
1994          */
1995         cnt = 2 + ofl->ofl_hashbkts + DYNSYM_ALL_CNT(ofl);
1996         size = cnt * shdr->sh_entsize;
1997 
1998         /*
1999          * Finalize the section header and data buffer initialization.
2000          */
2001         if ((data->d_buf = libld_calloc(size, 1)) == NULL)
2002                 return (S_ERROR);
2003         data->d_size = size;
2004         shdr->sh_size = (Xword)size;
2005 
2006         return (1);
2007 }
2008 
2009 /*
2010  * Generate the standard symbol table.  Contains all locals and globals,
2011  * and resides in a non-allocatable section (ie. it can be stripped).
2012  */
2013 static uintptr_t
2014 make_symtab(Ofl_desc *ofl)
2015 {
2016         Shdr            *shdr;
2017         Elf_Data        *data;
2018         Is_desc         *isec;
2019         Is_desc         *xisec = 0;
2020         size_t          size;
2021         Word            symcnt;
2022 
2023         /*
2024          * Create the section headers. Note that we supply an ent_cnt
2025          * of 0. We won't know the count until the section has been placed.
2026          */
2027         if (new_section(ofl, SHT_SYMTAB, MSG_ORIG(MSG_SCN_SYMTAB), 0,
2028             &isec, &shdr, &data) == S_ERROR)
2029                 return (S_ERROR);
2030 
2031         /*
2032          * Place the section first since it will affect the local symbol
2033          * count.
2034          */
2035         if ((ofl->ofl_ossymtab = ld_place_section(ofl, isec, NULL,
2036             ld_targ.t_id.id_symtab, NULL)) == (Os_desc *)S_ERROR)
2037                 return (S_ERROR);
2038 
2039         /*
2040          * At this point we've created all but the 'shstrtab' section.
2041          * Determine if we have to use 'Extended Sections'.  If so - then
2042          * also create a SHT_SYMTAB_SHNDX section.
2043          */
2044         if ((ofl->ofl_shdrcnt + 1) >= SHN_LORESERVE) {
2045                 Shdr            *xshdr;
2046                 Elf_Data        *xdata;
2047 
2048                 if (new_section(ofl, SHT_SYMTAB_SHNDX,
2049                     MSG_ORIG(MSG_SCN_SYMTAB_SHNDX), 0, &xisec,
2050                     &xshdr, &xdata) == S_ERROR)
2051                         return (S_ERROR);
2052 
2053                 if ((ofl->ofl_ossymshndx = ld_place_section(ofl, xisec, NULL,
2054                     ld_targ.t_id.id_symtab_ndx, NULL)) == (Os_desc *)S_ERROR)
2055                         return (S_ERROR);
2056         }
2057 
2058         /*
2059          * Calculated number of symbols, which need to be augmented by
2060          * the (yet to be created) .shstrtab entry.
2061          */
2062         symcnt = (size_t)(1 + SYMTAB_ALL_CNT(ofl));
2063         size = symcnt * shdr->sh_entsize;
2064 
2065         /*
2066          * Finalize the section header and data buffer initialization.
2067          */
2068         data->d_size = size;
2069         shdr->sh_size = (Xword)size;
2070 
2071         /*
2072          * If we created a SHT_SYMTAB_SHNDX - then set it's sizes too.
2073          */
2074         if (xisec) {
2075                 size_t  xsize = symcnt * sizeof (Word);
2076 
2077                 xisec->is_indata->d_size = xsize;
2078                 xisec->is_shdr->sh_size = (Xword)xsize;
2079         }
2080 
2081         return (1);
2082 }
2083 
2084 /*
2085  * Build a dynamic symbol table. These tables reside in the text
2086  * segment of a dynamic executable or shared library.
2087  *
2088  *      .SUNW_ldynsym contains local function symbols
2089  *      .dynsym contains only globals symbols
2090  *
2091  * The two tables are created adjacent to each other, with .SUNW_ldynsym
2092  * coming first.
2093  */
2094 static uintptr_t
2095 make_dynsym(Ofl_desc *ofl)
2096 {
2097         Shdr            *shdr, *lshdr;
2098         Elf_Data        *data, *ldata;
2099         Is_desc         *isec, *lisec;
2100         size_t          size;
2101         Xword           cnt;
2102         int             allow_ldynsym;
2103 
2104         /*
2105          * Unless explicitly disabled, always produce a .SUNW_ldynsym section
2106          * when it is allowed by the file type, even if the resulting
2107          * table only ends up with a single STT_FILE in it. There are
2108          * two reasons: (1) It causes the generation of the DT_SUNW_SYMTAB
2109          * entry in the .dynamic section, which is something we would
2110          * like to encourage, and (2) Without it, we cannot generate
2111          * the associated .SUNW_dyn[sym|tls]sort sections, which are of
2112          * value to DTrace.
2113          *
2114          * In practice, it is extremely rare for an object not to have
2115          * local symbols for .SUNW_ldynsym, so 99% of the time, we'd be
2116          * doing it anyway.
2117          */
2118         allow_ldynsym = OFL_ALLOW_LDYNSYM(ofl);
2119 
2120         /*
2121          * Create the section headers. Note that we supply an ent_cnt
2122          * of 0. We won't know the count until the section has been placed.
2123          */
2124         if (allow_ldynsym && new_section(ofl, SHT_SUNW_LDYNSYM,
2125             MSG_ORIG(MSG_SCN_LDYNSYM), 0, &lisec, &lshdr, &ldata) == S_ERROR)
2126                 return (S_ERROR);
2127 
2128         if (new_section(ofl, SHT_DYNSYM, MSG_ORIG(MSG_SCN_DYNSYM), 0,
2129             &isec, &shdr, &data) == S_ERROR)
2130                 return (S_ERROR);
2131 
2132         /*
2133          * Place the section(s) first since it will affect the local symbol
2134          * count.
2135          */
2136         if (allow_ldynsym &&
2137             ((ofl->ofl_osldynsym = ld_place_section(ofl, lisec, NULL,
2138             ld_targ.t_id.id_ldynsym, NULL)) == (Os_desc *)S_ERROR))
2139                 return (S_ERROR);
2140         ofl->ofl_osdynsym =
2141             ld_place_section(ofl, isec, NULL, ld_targ.t_id.id_dynsym, NULL);
2142         if (ofl->ofl_osdynsym == (Os_desc *)S_ERROR)
2143                 return (S_ERROR);
2144 
2145         cnt = DYNSYM_ALL_CNT(ofl);
2146         size = (size_t)cnt * shdr->sh_entsize;
2147 
2148         /*
2149          * Finalize the section header and data buffer initialization.
2150          */
2151         data->d_size = size;
2152         shdr->sh_size = (Xword)size;
2153 
2154         /*
2155          * An ldynsym contains local function symbols. It is not
2156          * used for linking, but if present, serves to allow better
2157          * stack traces to be generated in contexts where the symtab
2158          * is not available. (dladdr(), or stripped executable/library files).
2159          */
2160         if (allow_ldynsym) {
2161                 cnt = 1 + ofl->ofl_dynlocscnt + ofl->ofl_dynscopecnt;
2162                 size = (size_t)cnt * shdr->sh_entsize;
2163 
2164                 ldata->d_size = size;
2165                 lshdr->sh_size = (Xword)size;
2166         }
2167 
2168         return (1);
2169 }
2170 
2171 /*
2172  * Build .SUNW_dynsymsort and/or .SUNW_dyntlssort sections. These are
2173  * index sections for the .SUNW_ldynsym/.dynsym pair that present data
2174  * and function symbols sorted by address.
2175  */
2176 static uintptr_t
2177 make_dynsort(Ofl_desc *ofl)
2178 {
2179         Shdr            *shdr;
2180         Elf_Data        *data;
2181         Is_desc         *isec;
2182 
2183         /* Only do it if the .SUNW_ldynsym section is present */
2184         if (!OFL_ALLOW_LDYNSYM(ofl))
2185                 return (1);
2186 
2187         /* .SUNW_dynsymsort */
2188         if (ofl->ofl_dynsymsortcnt > 0) {
2189                 if (new_section(ofl, SHT_SUNW_symsort,
2190                     MSG_ORIG(MSG_SCN_DYNSYMSORT), ofl->ofl_dynsymsortcnt,
2191                     &isec, &shdr, &data) == S_ERROR)
2192                 return (S_ERROR);
2193 
2194                 if ((ofl->ofl_osdynsymsort = ld_place_section(ofl, isec, NULL,
2195                     ld_targ.t_id.id_dynsort, NULL)) == (Os_desc *)S_ERROR)
2196                         return (S_ERROR);
2197         }
2198 
2199         /* .SUNW_dyntlssort */
2200         if (ofl->ofl_dyntlssortcnt > 0) {
2201                 if (new_section(ofl, SHT_SUNW_tlssort,
2202                     MSG_ORIG(MSG_SCN_DYNTLSSORT),
2203                     ofl->ofl_dyntlssortcnt, &isec, &shdr, &data) == S_ERROR)
2204                 return (S_ERROR);
2205 
2206                 if ((ofl->ofl_osdyntlssort = ld_place_section(ofl, isec, NULL,
2207                     ld_targ.t_id.id_dynsort, NULL)) == (Os_desc *)S_ERROR)
2208                         return (S_ERROR);
2209         }
2210 
2211         return (1);
2212 }
2213 
2214 /*
2215  * Helper routine for make_dynsym_shndx. Builds a
2216  * a SHT_SYMTAB_SHNDX for .dynsym or .SUNW_ldynsym, without knowing
2217  * which one it is.
2218  */
2219 static uintptr_t
2220 make_dyn_shndx(Ofl_desc *ofl, const char *shname, Os_desc *symtab,
2221     Os_desc **ret_os)
2222 {
2223         Is_desc         *isec;
2224         Is_desc         *dynsymisp;
2225         Shdr            *shdr, *dynshdr;
2226         Elf_Data        *data;
2227 
2228         dynsymisp = ld_os_first_isdesc(symtab);
2229         dynshdr = dynsymisp->is_shdr;
2230 
2231         if (new_section(ofl, SHT_SYMTAB_SHNDX, shname,
2232             (dynshdr->sh_size / dynshdr->sh_entsize),
2233             &isec, &shdr, &data) == S_ERROR)
2234                 return (S_ERROR);
2235 
2236         if ((*ret_os = ld_place_section(ofl, isec, NULL,
2237             ld_targ.t_id.id_dynsym_ndx, NULL)) == (Os_desc *)S_ERROR)
2238                 return (S_ERROR);
2239 
2240         assert(*ret_os);
2241 
2242         return (1);
2243 }
2244 
2245 /*
2246  * Build a SHT_SYMTAB_SHNDX for the .dynsym, and .SUNW_ldynsym
2247  */
2248 static uintptr_t
2249 make_dynsym_shndx(Ofl_desc *ofl)
2250 {
2251         /*
2252          * If there is a .SUNW_ldynsym, generate a section for its extended
2253          * index section as well.
2254          */
2255         if (OFL_ALLOW_LDYNSYM(ofl)) {
2256                 if (make_dyn_shndx(ofl, MSG_ORIG(MSG_SCN_LDYNSYM_SHNDX),
2257                     ofl->ofl_osldynsym, &ofl->ofl_osldynshndx) == S_ERROR)
2258                         return (S_ERROR);
2259         }
2260 
2261         /* The Generate a section for the dynsym */
2262         if (make_dyn_shndx(ofl, MSG_ORIG(MSG_SCN_DYNSYM_SHNDX),
2263             ofl->ofl_osdynsym, &ofl->ofl_osdynshndx) == S_ERROR)
2264                 return (S_ERROR);
2265 
2266         return (1);
2267 }
2268 
2269 
2270 /*
2271  * Build a string table for the section headers.
2272  */
2273 static uintptr_t
2274 make_shstrtab(Ofl_desc *ofl)
2275 {
2276         Shdr            *shdr;
2277         Elf_Data        *data;
2278         Is_desc         *isec;
2279         size_t          size;
2280 
2281         if (new_section(ofl, SHT_STRTAB, MSG_ORIG(MSG_SCN_SHSTRTAB),
2282             0, &isec, &shdr, &data) == S_ERROR)
2283                 return (S_ERROR);
2284 
2285         /*
2286          * Place the section first, as it may effect the number of section
2287          * headers to account for.
2288          */
2289         ofl->ofl_osshstrtab =
2290             ld_place_section(ofl, isec, NULL, ld_targ.t_id.id_note, NULL);
2291         if (ofl->ofl_osshstrtab == (Os_desc *)S_ERROR)
2292                 return (S_ERROR);
2293 
2294         size = st_getstrtab_sz(ofl->ofl_shdrsttab);
2295         assert(size > 0);
2296 
2297         data->d_size = size;
2298         shdr->sh_size = (Xword)size;
2299 
2300         return (1);
2301 }
2302 
2303 /*
2304  * Build a string section for the standard symbol table.
2305  */
2306 static uintptr_t
2307 make_strtab(Ofl_desc *ofl)
2308 {
2309         Shdr            *shdr;
2310         Elf_Data        *data;
2311         Is_desc         *isec;
2312         size_t          size;
2313 
2314         /*
2315          * This string table consists of all the global and local symbols.
2316          * Account for null bytes at end of the file name and the beginning
2317          * of section.
2318          */
2319         if (st_insert(ofl->ofl_strtab, ofl->ofl_name) == -1)
2320                 return (S_ERROR);
2321 
2322         size = st_getstrtab_sz(ofl->ofl_strtab);
2323         assert(size > 0);
2324 
2325         if (new_section(ofl, SHT_STRTAB, MSG_ORIG(MSG_SCN_STRTAB),
2326             0, &isec, &shdr, &data) == S_ERROR)
2327                 return (S_ERROR);
2328 
2329         /* Set the size of the data area */
2330         data->d_size = size;
2331         shdr->sh_size = (Xword)size;
2332 
2333         ofl->ofl_osstrtab =
2334             ld_place_section(ofl, isec, NULL, ld_targ.t_id.id_strtab, NULL);
2335         return ((uintptr_t)ofl->ofl_osstrtab);
2336 }
2337 
2338 /*
2339  * Build a string table for the dynamic symbol table.
2340  */
2341 static uintptr_t
2342 make_dynstr(Ofl_desc *ofl)
2343 {
2344         Shdr            *shdr;
2345         Elf_Data        *data;
2346         Is_desc         *isec;
2347         size_t          size;
2348 
2349         /*
2350          * If producing a .SUNW_ldynsym, account for the initial STT_FILE
2351          * symbol that precedes the scope reduced global symbols.
2352          */
2353         if (OFL_ALLOW_LDYNSYM(ofl)) {
2354                 if (st_insert(ofl->ofl_dynstrtab, ofl->ofl_name) == -1)
2355                         return (S_ERROR);
2356                 ofl->ofl_dynscopecnt++;
2357         }
2358 
2359         /*
2360          * Account for any local, named register symbols.  These locals are
2361          * required for reference from DT_REGISTER .dynamic entries.
2362          */
2363         if (ofl->ofl_regsyms) {
2364                 int     ndx;
2365 
2366                 for (ndx = 0; ndx < ofl->ofl_regsymsno; ndx++) {
2367                         Sym_desc        *sdp;
2368 
2369                         if ((sdp = ofl->ofl_regsyms[ndx]) == NULL)
2370                                 continue;
2371 
2372                         if (!SYM_IS_HIDDEN(sdp) &&
2373                             (ELF_ST_BIND(sdp->sd_sym->st_info) != STB_LOCAL))
2374                                 continue;
2375 
2376                         if (sdp->sd_sym->st_name == NULL)
2377                                 continue;
2378 
2379                         if (st_insert(ofl->ofl_dynstrtab, sdp->sd_name) == -1)
2380                                 return (S_ERROR);
2381                 }
2382         }
2383 
2384         /*
2385          * Reserve entries for any per-symbol auxiliary/filter strings.
2386          */
2387         if (ofl->ofl_dtsfltrs != NULL) {
2388                 Dfltr_desc      *dftp;
2389                 Aliste          idx;
2390 
2391                 for (ALIST_TRAVERSE(ofl->ofl_dtsfltrs, idx, dftp))
2392                         if (st_insert(ofl->ofl_dynstrtab, dftp->dft_str) == -1)
2393                                 return (S_ERROR);
2394         }
2395 
2396         size = st_getstrtab_sz(ofl->ofl_dynstrtab);
2397         assert(size > 0);
2398 
2399         if (new_section(ofl, SHT_STRTAB, MSG_ORIG(MSG_SCN_DYNSTR),
2400             0, &isec, &shdr, &data) == S_ERROR)
2401                 return (S_ERROR);
2402 
2403         /* Make it allocable if necessary */
2404         if (!(ofl->ofl_flags & FLG_OF_RELOBJ))
2405                 shdr->sh_flags |= SHF_ALLOC;
2406 
2407         /* Set the size of the data area */
2408         data->d_size = size + DYNSTR_EXTRA_PAD;
2409 
2410         shdr->sh_size = (Xword)size;
2411 
2412         ofl->ofl_osdynstr =
2413             ld_place_section(ofl, isec, NULL, ld_targ.t_id.id_dynstr, NULL);
2414         return ((uintptr_t)ofl->ofl_osdynstr);
2415 }
2416 
2417 /*
2418  * Generate an output relocation section which will contain the relocation
2419  * information to be applied to the `osp' section.
2420  *
2421  * If (osp == NULL) then we are creating the coalesced relocation section
2422  * for an executable and/or a shared object.
2423  */
2424 static uintptr_t
2425 make_reloc(Ofl_desc *ofl, Os_desc *osp)
2426 {
2427         Shdr            *shdr;
2428         Elf_Data        *data;
2429         Is_desc         *isec;
2430         size_t          size;
2431         Xword           sh_flags;
2432         char            *sectname;
2433         Os_desc         *rosp;
2434         Word            relsize;
2435         const char      *rel_prefix;
2436 
2437         /* LINTED */
2438         if (ld_targ.t_m.m_rel_sht_type == SHT_REL) {
2439                 /* REL */
2440                 relsize = sizeof (Rel);
2441                 rel_prefix = MSG_ORIG(MSG_SCN_REL);
2442         } else {
2443                 /* RELA */
2444                 relsize = sizeof (Rela);
2445                 rel_prefix = MSG_ORIG(MSG_SCN_RELA);
2446         }
2447 
2448         if (osp) {
2449                 size = osp->os_szoutrels;
2450                 sh_flags = osp->os_shdr->sh_flags;
2451                 if ((sectname = libld_malloc(strlen(rel_prefix) +
2452                     strlen(osp->os_name) + 1)) == 0)
2453                         return (S_ERROR);
2454                 (void) strcpy(sectname, rel_prefix);
2455                 (void) strcat(sectname, osp->os_name);
2456         } else if (ofl->ofl_flags & FLG_OF_COMREL) {
2457                 size = (ofl->ofl_reloccnt - ofl->ofl_reloccntsub) * relsize;
2458                 sh_flags = SHF_ALLOC;
2459                 sectname = (char *)MSG_ORIG(MSG_SCN_SUNWRELOC);
2460         } else {
2461                 size = ofl->ofl_relocrelsz;
2462                 sh_flags = SHF_ALLOC;
2463                 sectname = (char *)rel_prefix;
2464         }
2465 
2466         /*
2467          * Keep track of total size of 'output relocations' (to be stored
2468          * in .dynamic)
2469          */
2470         /* LINTED */
2471         ofl->ofl_relocsz += (Xword)size;
2472 
2473         if (new_section(ofl, ld_targ.t_m.m_rel_sht_type, sectname, 0, &isec,
2474             &shdr, &data) == S_ERROR)
2475                 return (S_ERROR);
2476 
2477         data->d_size = size;
2478 
2479         shdr->sh_size = (Xword)size;
2480         if (OFL_ALLOW_DYNSYM(ofl) && (sh_flags & SHF_ALLOC))
2481                 shdr->sh_flags = SHF_ALLOC;
2482 
2483         if (osp) {
2484                 /*
2485                  * The sh_info field of the SHT_REL* sections points to the
2486                  * section the relocations are to be applied to.
2487                  */
2488                 shdr->sh_flags |= SHF_INFO_LINK;
2489         }
2490 
2491         rosp = ld_place_section(ofl, isec, NULL, ld_targ.t_id.id_rel, NULL);
2492         if (rosp == (Os_desc *)S_ERROR)
2493                 return (S_ERROR);
2494 
2495         /*
2496          * Associate this relocation section to the section its going to
2497          * relocate.
2498          */
2499         if (osp) {
2500                 Aliste  idx;
2501                 Is_desc *risp;
2502 
2503                 /*
2504                  * This is used primarily so that we can update
2505                  * SHT_GROUP[sect_no] entries to point to the
2506                  * created output relocation sections.
2507                  */
2508                 for (APLIST_TRAVERSE(osp->os_relisdescs, idx, risp)) {
2509                         risp->is_osdesc = rosp;
2510 
2511                         /*
2512                          * If the input relocation section had the SHF_GROUP
2513                          * flag set - propagate it to the output relocation
2514                          * section.
2515                          */
2516                         if (risp->is_shdr->sh_flags & SHF_GROUP) {
2517                                 rosp->os_shdr->sh_flags |= SHF_GROUP;
2518                                 break;
2519                         }
2520                 }
2521                 osp->os_relosdesc = rosp;
2522         } else
2523                 ofl->ofl_osrel = rosp;
2524 
2525         /*
2526          * If this is the first relocation section we've encountered save it
2527          * so that the .dynamic entry can be initialized accordingly.
2528          */
2529         if (ofl->ofl_osrelhead == (Os_desc *)0)
2530                 ofl->ofl_osrelhead = rosp;
2531 
2532         return (1);
2533 }
2534 
2535 /*
2536  * Generate version needed section.
2537  */
2538 static uintptr_t
2539 make_verneed(Ofl_desc *ofl)
2540 {
2541         Shdr            *shdr;
2542         Elf_Data        *data;
2543         Is_desc         *isec;
2544 
2545         /*
2546          * verneed sections do not have a constant element size, so the
2547          * value of ent_cnt specified here (0) is meaningless.
2548          */
2549         if (new_section(ofl, SHT_SUNW_verneed, MSG_ORIG(MSG_SCN_SUNWVERSION),
2550             0, &isec, &shdr, &data) == S_ERROR)
2551                 return (S_ERROR);
2552 
2553         /* During version processing we calculated the total size. */
2554         data->d_size = ofl->ofl_verneedsz;
2555         shdr->sh_size = (Xword)ofl->ofl_verneedsz;
2556 
2557         ofl->ofl_osverneed =
2558             ld_place_section(ofl, isec, NULL, ld_targ.t_id.id_version, NULL);
2559         return ((uintptr_t)ofl->ofl_osverneed);
2560 }
2561 
2562 /*
2563  * Generate a version definition section.
2564  *
2565  *  o   the SHT_SUNW_verdef section defines the versions that exist within this
2566  *      image.
2567  */
2568 static uintptr_t
2569 make_verdef(Ofl_desc *ofl)
2570 {
2571         Shdr            *shdr;
2572         Elf_Data        *data;
2573         Is_desc         *isec;
2574         Ver_desc        *vdp;
2575         Str_tbl         *strtab;
2576 
2577         /*
2578          * Reserve a string table entry for the base version dependency (other
2579          * dependencies have symbol representations, which will already be
2580          * accounted for during symbol processing).
2581          */
2582         vdp = (Ver_desc *)ofl->ofl_verdesc->apl_data[0];
2583 
2584         if (OFL_IS_STATIC_OBJ(ofl))
2585                 strtab = ofl->ofl_strtab;
2586         else
2587                 strtab = ofl->ofl_dynstrtab;
2588 
2589         if (st_insert(strtab, vdp->vd_name) == -1)
2590                 return (S_ERROR);
2591 
2592         /*
2593          * verdef sections do not have a constant element size, so the
2594          * value of ent_cnt specified here (0) is meaningless.
2595          */
2596         if (new_section(ofl, SHT_SUNW_verdef, MSG_ORIG(MSG_SCN_SUNWVERSION),
2597             0, &isec, &shdr, &data) == S_ERROR)
2598                 return (S_ERROR);
2599 
2600         /* During version processing we calculated the total size. */
2601         data->d_size = ofl->ofl_verdefsz;
2602         shdr->sh_size = (Xword)ofl->ofl_verdefsz;
2603 
2604         ofl->ofl_osverdef =
2605             ld_place_section(ofl, isec, NULL, ld_targ.t_id.id_version, NULL);
2606         return ((uintptr_t)ofl->ofl_osverdef);
2607 }
2608 
2609 /*
2610  * This routine is called when -z nopartial is in effect.
2611  */
2612 uintptr_t
2613 ld_make_parexpn_data(Ofl_desc *ofl, size_t size, Xword align)
2614 {
2615         Shdr            *shdr;
2616         Elf_Data        *data;
2617         Is_desc         *isec;
2618         Os_desc         *osp;
2619 
2620         if (new_section(ofl, SHT_PROGBITS, MSG_ORIG(MSG_SCN_DATA), 0,
2621             &isec, &shdr, &data) == S_ERROR)
2622                 return (S_ERROR);
2623 
2624         shdr->sh_flags |= SHF_WRITE;
2625         data->d_size = size;
2626         shdr->sh_size = (Xword)size;
2627         if (align != 0) {
2628                 data->d_align = align;
2629                 shdr->sh_addralign = align;
2630         }
2631 
2632         if ((data->d_buf = libld_calloc(size, 1)) == NULL)
2633                 return (S_ERROR);
2634 
2635         /*
2636          * Retain handle to this .data input section. Variables using move
2637          * sections (partial initialization) will be redirected here when
2638          * such global references are added and '-z nopartial' is in effect.
2639          */
2640         ofl->ofl_isparexpn = isec;
2641         osp = ld_place_section(ofl, isec, NULL, ld_targ.t_id.id_data, NULL);
2642         if (osp == (Os_desc *)S_ERROR)
2643                 return (S_ERROR);
2644 
2645         if (!(osp->os_flags & FLG_OS_OUTREL)) {
2646                 ofl->ofl_dynshdrcnt++;
2647                 osp->os_flags |= FLG_OS_OUTREL;
2648         }
2649         return (1);
2650 }
2651 
2652 /*
2653  * Make .sunwmove section
2654  */
2655 uintptr_t
2656 ld_make_sunwmove(Ofl_desc *ofl, int mv_nums)
2657 {
2658         Shdr            *shdr;
2659         Elf_Data        *data;
2660         Is_desc         *isec;
2661         Aliste          idx;
2662         Sym_desc        *sdp;
2663         int             cnt = 1;
2664 
2665 
2666         if (new_section(ofl, SHT_SUNW_move, MSG_ORIG(MSG_SCN_SUNWMOVE),
2667             mv_nums, &isec, &shdr, &data) == S_ERROR)
2668                 return (S_ERROR);
2669 
2670         if ((data->d_buf = libld_calloc(data->d_size, 1)) == NULL)
2671                 return (S_ERROR);
2672 
2673         /*
2674          * Copy move entries
2675          */
2676         for (APLIST_TRAVERSE(ofl->ofl_parsyms, idx, sdp)) {
2677                 Aliste          idx2;
2678                 Mv_desc         *mdp;
2679 
2680                 if (sdp->sd_flags & FLG_SY_PAREXPN)
2681                         continue;
2682 
2683                 for (ALIST_TRAVERSE(sdp->sd_move, idx2, mdp))
2684                         mdp->md_oidx = cnt++;
2685         }
2686 
2687         if ((ofl->ofl_osmove = ld_place_section(ofl, isec, NULL, 0, NULL)) ==
2688             (Os_desc *)S_ERROR)
2689                 return (S_ERROR);
2690 
2691         return (1);
2692 }
2693 
2694 /*
2695  * Given a relocation descriptor that references a string table
2696  * input section, locate the string referenced and return a pointer
2697  * to it.
2698  */
2699 static const char *
2700 strmerge_get_reloc_str(Ofl_desc *ofl, Rel_desc *rsp)
2701 {
2702         Sym_desc *sdp = rsp->rel_sym;
2703         Xword    str_off;
2704 
2705         /*
2706          * In the case of an STT_SECTION symbol, the addend of the
2707          * relocation gives the offset into the string section. For
2708          * other symbol types, the symbol value is the offset.
2709          */
2710 
2711         if (ELF_ST_TYPE(sdp->sd_sym->st_info) != STT_SECTION) {
2712                 str_off = sdp->sd_sym->st_value;
2713         } else if ((rsp->rel_flags & FLG_REL_RELA) == FLG_REL_RELA) {
2714                 /*
2715                  * For SHT_RELA, the addend value is found in the
2716                  * rel_raddend field of the relocation.
2717                  */
2718                 str_off = rsp->rel_raddend;
2719         } else {        /* REL and STT_SECTION */
2720                 /*
2721                  * For SHT_REL, the "addend" is not part of the relocation
2722                  * record. Instead, it is found at the relocation target
2723                  * address.
2724                  */
2725                 uchar_t *addr = (uchar_t *)((uintptr_t)rsp->rel_roffset +
2726                     (uintptr_t)rsp->rel_isdesc->is_indata->d_buf);
2727 
2728                 if (ld_reloc_targval_get(ofl, rsp, addr, &str_off) == 0)
2729                         return (0);
2730         }
2731 
2732         return (str_off + (char *)sdp->sd_isc->is_indata->d_buf);
2733 }
2734 
2735 /*
2736  * First pass over the relocation records for string table merging.
2737  * Build lists of relocations and symbols that will need modification,
2738  * and insert the strings they reference into the mstrtab string table.
2739  *
2740  * entry:
2741  *      ofl, osp - As passed to ld_make_strmerge().
2742  *      mstrtab - String table to receive input strings. This table
2743  *              must be in its first (initialization) pass and not
2744  *              yet cooked (st_getstrtab_sz() not yet called).
2745  *      rel_alpp - APlist to receive pointer to any relocation
2746  *              descriptors with STT_SECTION symbols that reference
2747  *              one of the input sections being merged.
2748  *      sym_alpp - APlist to receive pointer to any symbols that reference
2749  *              one of the input sections being merged.
2750  *      rcp - Pointer to cache of relocation descriptors to examine.
2751  *              Either &ofl->ofl_actrels (active relocations)
2752  *              or &ofl->ofl_outrels (output relocations).
2753  *
2754  * exit:
2755  *      On success, rel_alpp and sym_alpp are updated, and
2756  *      any strings in the mergeable input sections referenced by
2757  *      a relocation has been entered into mstrtab. True (1) is returned.
2758  *
2759  *      On failure, False (0) is returned.
2760  */
2761 static int
2762 strmerge_pass1(Ofl_desc *ofl, Os_desc *osp, Str_tbl *mstrtab,
2763     APlist **rel_alpp, APlist **sym_alpp, Rel_cache *rcp)
2764 {
2765         Aliste          idx;
2766         Rel_cachebuf    *rcbp;
2767         Sym_desc        *sdp;
2768         Sym_desc        *last_sdp = NULL;
2769         Rel_desc        *rsp;
2770         const char      *name;
2771 
2772         REL_CACHE_TRAVERSE(rcp, idx, rcbp, rsp) {
2773                 sdp = rsp->rel_sym;
2774                 if ((sdp->sd_isc == NULL) || ((sdp->sd_isc->is_flags &
2775                     (FLG_IS_DISCARD | FLG_IS_INSTRMRG)) != FLG_IS_INSTRMRG) ||
2776                     (sdp->sd_isc->is_osdesc != osp))
2777                         continue;
2778 
2779                 /*
2780                  * Remember symbol for use in the third pass. There is no
2781                  * reason to save a given symbol more than once, so we take
2782                  * advantage of the fact that relocations to a given symbol
2783                  * tend to cluster in the list. If this is the same symbol
2784                  * we saved last time, don't bother.
2785                  */
2786                 if (last_sdp != sdp) {
2787                         if (aplist_append(sym_alpp, sdp, AL_CNT_STRMRGSYM) ==
2788                             NULL)
2789                                 return (0);
2790                         last_sdp = sdp;
2791                 }
2792 
2793                 /* Enter the string into our new string table */
2794                 name = strmerge_get_reloc_str(ofl, rsp);
2795                 if (st_insert(mstrtab, name) == -1)
2796                         return (0);
2797 
2798                 /*
2799                  * If this is an STT_SECTION symbol, then the second pass
2800                  * will need to modify this relocation, so hang on to it.
2801                  */
2802                 if ((ELF_ST_TYPE(sdp->sd_sym->st_info) == STT_SECTION) &&
2803                     (aplist_append(rel_alpp, rsp, AL_CNT_STRMRGREL) == NULL))
2804                         return (0);
2805         }
2806 
2807         return (1);
2808 }
2809 
2810 /*
2811  * If the output section has any SHF_MERGE|SHF_STRINGS input sections,
2812  * replace them with a single merged/compressed input section.
2813  *
2814  * entry:
2815  *      ofl - Output file descriptor
2816  *      osp - Output section descriptor
2817  *      rel_alpp, sym_alpp, - Address of 2 APlists, to be used
2818  *              for internal processing. On the initial call to
2819  *              ld_make_strmerge, these list pointers must be NULL.
2820  *              The caller is encouraged to pass the same lists back for
2821  *              successive calls to this function without freeing
2822  *              them in between calls. This causes a single pair of
2823  *              memory allocations to be reused multiple times.
2824  *
2825  * exit:
2826  *      If section merging is possible, it is done. If no errors are
2827  *      encountered, True (1) is returned. On error, S_ERROR.
2828  *
2829  *      The contents of rel_alpp and sym_alpp on exit are
2830  *      undefined. The caller can free them, or pass them back to a subsequent
2831  *      call to this routine, but should not examine their contents.
2832  */
2833 static uintptr_t
2834 ld_make_strmerge(Ofl_desc *ofl, Os_desc *osp, APlist **rel_alpp,
2835     APlist **sym_alpp)
2836 {
2837         Str_tbl         *mstrtab;       /* string table for string merge secs */
2838         Is_desc         *mstrsec;       /* Generated string merge section */
2839         Is_desc         *isp;
2840         Shdr            *mstr_shdr;
2841         Elf_Data        *mstr_data;
2842         Sym_desc        *sdp;
2843         Rel_desc        *rsp;
2844         Aliste          idx;
2845         size_t          data_size;
2846         int             st_setstring_status;
2847         size_t          stoff;
2848 
2849         /* If string table compression is disabled, there's nothing to do */
2850         if ((ofl->ofl_flags1 & FLG_OF1_NCSTTAB) != 0)
2851                 return (1);
2852 
2853         /*
2854          * Pass over the mergeable input sections, and if they haven't
2855          * all been discarded, create a string table.
2856          */
2857         mstrtab = NULL;
2858         for (APLIST_TRAVERSE(osp->os_mstrisdescs, idx, isp)) {
2859                 if (isdesc_discarded(isp))
2860                         continue;
2861 
2862                 /*
2863                  * Input sections of 0 size are dubiously valid since they do
2864                  * not even contain the NUL string.  Ignore them.
2865                  */
2866                 if (isp->is_shdr->sh_size == 0)
2867                         continue;
2868 
2869                 /*
2870                  * We have at least one non-discarded section.
2871                  * Create a string table descriptor.
2872                  */
2873                 if ((mstrtab = st_new(FLG_STNEW_COMPRESS)) == NULL)
2874                         return (S_ERROR);
2875                 break;
2876         }
2877 
2878         /* If no string table was created, we have no mergeable sections */
2879         if (mstrtab == NULL)
2880                 return (1);
2881 
2882         /*
2883          * This routine has to make 3 passes:
2884          *
2885          *      1) Examine all relocations, insert strings from relocations
2886          *              to the mergeable input sections into the string table.
2887          *      2) Modify the relocation values to be correct for the
2888          *              new merged section.
2889          *      3) Modify the symbols used by the relocations to reference
2890          *              the new section.
2891          *
2892          * These passes cannot be combined:
2893          *      - The string table code works in two passes, and all
2894          *              strings have to be loaded in pass one before the
2895          *              offset of any strings can be determined.
2896          *      - Multiple relocations reference a single symbol, so the
2897          *              symbol cannot be modified until all relocations are
2898          *              fixed.
2899          *
2900          * The number of relocations related to section merging is usually
2901          * a mere fraction of the overall active and output relocation lists,
2902          * and the number of symbols is usually a fraction of the number
2903          * of related relocations. We therefore build APlists for the
2904          * relocations and symbols in the first pass, and then use those
2905          * lists to accelerate the operation of pass 2 and 3.
2906          *
2907          * Reinitialize the lists to a completely empty state.
2908          */
2909         aplist_reset(*rel_alpp);
2910         aplist_reset(*sym_alpp);
2911 
2912         /*
2913          * Pass 1:
2914          *
2915          * Every relocation related to this output section (and the input
2916          * sections that make it up) is found in either the active, or the
2917          * output relocation list, depending on whether the relocation is to
2918          * be processed by this invocation of the linker, or inserted into the
2919          * output object.
2920          *
2921          * Build lists of relocations and symbols that will need modification,
2922          * and insert the strings they reference into the mstrtab string table.
2923          */
2924         if (strmerge_pass1(ofl, osp, mstrtab, rel_alpp, sym_alpp,
2925             &ofl->ofl_actrels) == 0)
2926                 goto return_s_error;
2927         if (strmerge_pass1(ofl, osp, mstrtab, rel_alpp, sym_alpp,
2928             &ofl->ofl_outrels) == 0)
2929                 goto return_s_error;
2930 
2931         /*
2932          * Get the size of the new input section. Requesting the
2933          * string table size "cooks" the table, and finalizes its contents.
2934          */
2935         data_size = st_getstrtab_sz(mstrtab);
2936 
2937         /* Create a new input section to hold the merged strings */
2938         if (new_section_from_template(ofl, isp, data_size,
2939             &mstrsec, &mstr_shdr, &mstr_data) == S_ERROR)
2940                 goto return_s_error;
2941         mstrsec->is_flags |= FLG_IS_GNSTRMRG;
2942 
2943         /*
2944          * Allocate a data buffer for the new input section.
2945          * Then, associate the buffer with the string table descriptor.
2946          */
2947         if ((mstr_data->d_buf = libld_malloc(data_size)) == NULL)
2948                 goto return_s_error;
2949         if (st_setstrbuf(mstrtab, mstr_data->d_buf, data_size) == -1)
2950                 goto return_s_error;
2951 
2952         /* Add the new section to the output image */
2953         if (ld_place_section(ofl, mstrsec, NULL, osp->os_identndx, NULL) ==
2954             (Os_desc *)S_ERROR)
2955                 goto return_s_error;
2956 
2957         /*
2958          * Pass 2:
2959          *
2960          * Revisit the relocation descriptors with STT_SECTION symbols
2961          * that were saved by the first pass. Update each relocation
2962          * record so that the offset it contains is for the new section
2963          * instead of the original.
2964          */
2965         for (APLIST_TRAVERSE(*rel_alpp, idx, rsp)) {
2966                 const char      *name;
2967 
2968                 /* Put the string into the merged string table */
2969                 name = strmerge_get_reloc_str(ofl, rsp);
2970                 st_setstring_status = st_setstring(mstrtab, name, &stoff);
2971                 if (st_setstring_status == -1) {
2972                         /*
2973                          * A failure to insert at this point means that
2974                          * something is corrupt. This isn't a resource issue.
2975                          */
2976                         assert(st_setstring_status != -1);
2977                         goto return_s_error;
2978                 }
2979 
2980                 /*
2981                  * Alter the relocation to access the string at the
2982                  * new offset in our new string table.
2983                  *
2984                  * For SHT_RELA platforms, it suffices to simply
2985                  * update the rel_raddend field of the relocation.
2986                  *
2987                  * For SHT_REL platforms, the new "addend" value
2988                  * needs to be written at the address being relocated.
2989                  * However, we can't alter the input sections which
2990                  * are mapped readonly, and the output image has not
2991                  * been created yet. So, we defer this operation,
2992                  * using the rel_raddend field of the relocation
2993                  * which is normally 0 on a REL platform, to pass the
2994                  * new "addend" value to ld_perform_outreloc() or
2995                  * ld_do_activerelocs(). The FLG_REL_NADDEND flag
2996                  * tells them that this is the case.
2997                  */
2998                 if ((rsp->rel_flags & FLG_REL_RELA) == 0)   /* REL */
2999                         rsp->rel_flags |= FLG_REL_NADDEND;
3000                 rsp->rel_raddend = (Sxword)stoff;
3001 
3002                 /*
3003                  * Generate a symbol name string for STT_SECTION symbols
3004                  * that might reference our merged section. This shows up
3005                  * in debug output and helps show how the relocation has
3006                  * changed from its original input section to our merged one.
3007                  */
3008                 if (ld_stt_section_sym_name(mstrsec) == NULL)
3009                         goto return_s_error;
3010         }
3011 
3012         /*
3013          * Pass 3:
3014          *
3015          * Modify the symbols referenced by the relocation descriptors
3016          * so that they reference the new input section containing the
3017          * merged strings instead of the original input sections.
3018          */
3019         for (APLIST_TRAVERSE(*sym_alpp, idx, sdp)) {
3020                 /*
3021                  * If we've already processed this symbol, don't do it
3022                  * twice. strmerge_pass1() uses a heuristic (relocations to
3023                  * the same symbol clump together) to avoid inserting a
3024                  * given symbol more than once, but repeat symbols in
3025                  * the list can occur.
3026                  */
3027                 if ((sdp->sd_isc->is_flags & FLG_IS_INSTRMRG) == 0)
3028                         continue;
3029 
3030                 if (ELF_ST_TYPE(sdp->sd_sym->st_info) != STT_SECTION) {
3031                         /*
3032                          * This is not an STT_SECTION symbol, so its
3033                          * value is the offset of the string within the
3034                          * input section. Update the address to reflect
3035                          * the address in our new merged section.
3036                          */
3037                         const char *name = sdp->sd_sym->st_value +
3038                             (char *)sdp->sd_isc->is_indata->d_buf;
3039 
3040                         st_setstring_status =
3041                             st_setstring(mstrtab, name, &stoff);
3042                         if (st_setstring_status == -1) {
3043                                 /*
3044                                  * A failure to insert at this point means
3045                                  * something is corrupt. This isn't a
3046                                  * resource issue.
3047                                  */
3048                                 assert(st_setstring_status != -1);
3049                                 goto return_s_error;
3050                         }
3051 
3052                         if (ld_sym_copy(sdp) == S_ERROR)
3053                                 goto return_s_error;
3054                         sdp->sd_sym->st_value = (Word)stoff;
3055                 }
3056 
3057                 /* Redirect the symbol to our new merged section */
3058                 sdp->sd_isc = mstrsec;
3059         }
3060 
3061         /*
3062          * There are no references left to the original input string sections.
3063          * Mark them as discarded so they don't go into the output image.
3064          * At the same time, add up the sizes of the replaced sections.
3065          */
3066         data_size = 0;
3067         for (APLIST_TRAVERSE(osp->os_mstrisdescs, idx, isp)) {
3068                 if (isp->is_flags & (FLG_IS_DISCARD | FLG_IS_GNSTRMRG))
3069                         continue;
3070 
3071                 data_size += isp->is_indata->d_size;
3072 
3073                 isp->is_flags |= FLG_IS_DISCARD;
3074                 DBG_CALL(Dbg_sec_discarded(ofl->ofl_lml, isp, mstrsec));
3075         }
3076 
3077         /* Report how much space we saved in the output section */
3078         DBG_CALL(Dbg_sec_genstr_compress(ofl->ofl_lml, osp->os_name, data_size,
3079             mstr_data->d_size));
3080 
3081         st_destroy(mstrtab);
3082         return (1);
3083 
3084 return_s_error:
3085         st_destroy(mstrtab);
3086         return (S_ERROR);
3087 }
3088 
3089 /*
3090  * Update a data buffers size.  A number of sections have to be created, and
3091  * the sections header contributes to the size of the eventual section.  Thus,
3092  * a section may be created, and once all associated sections have been created,
3093  * we return to establish the required section size.
3094  */
3095 inline static void
3096 update_data_size(Os_desc *osp, ulong_t cnt)
3097 {
3098         Is_desc         *isec = ld_os_first_isdesc(osp);
3099         Elf_Data        *data = isec->is_indata;
3100         Shdr            *shdr = osp->os_shdr;
3101         size_t          size = cnt * shdr->sh_entsize;
3102 
3103         shdr->sh_size = (Xword)size;
3104         data->d_size = size;
3105 }
3106 
3107 /*
3108  * The following sections are built after all input file processing and symbol
3109  * validation has been carried out.  The order is important (because the
3110  * addition of a section adds a new symbol there is a chicken and egg problem
3111  * of maintaining the appropriate counts).  By maintaining a known order the
3112  * individual routines can compensate for later, known, additions.
3113  */
3114 uintptr_t
3115 ld_make_sections(Ofl_desc *ofl)
3116 {
3117         ofl_flag_t      flags = ofl->ofl_flags;
3118         Sg_desc         *sgp;
3119 
3120         /*
3121          * Generate any special sections.
3122          */
3123         if (flags & FLG_OF_ADDVERS)
3124                 if (make_comment(ofl) == S_ERROR)
3125                         return (S_ERROR);
3126 
3127         if (make_interp(ofl) == S_ERROR)
3128                 return (S_ERROR);
3129 
3130         /*
3131          * Create a capabilities section if required.
3132          */
3133         if (make_cap(ofl, SHT_SUNW_cap, MSG_ORIG(MSG_SCN_SUNWCAP),
3134             ld_targ.t_id.id_cap) == S_ERROR)
3135                 return (S_ERROR);
3136 
3137         /*
3138          * Create any init/fini array sections.
3139          */
3140         if (make_array(ofl, SHT_INIT_ARRAY, MSG_ORIG(MSG_SCN_INITARRAY),
3141             ofl->ofl_initarray) == S_ERROR)
3142                 return (S_ERROR);
3143 
3144         if (make_array(ofl, SHT_FINI_ARRAY, MSG_ORIG(MSG_SCN_FINIARRAY),
3145             ofl->ofl_finiarray) == S_ERROR)
3146                 return (S_ERROR);
3147 
3148         if (make_array(ofl, SHT_PREINIT_ARRAY, MSG_ORIG(MSG_SCN_PREINITARRAY),
3149             ofl->ofl_preiarray) == S_ERROR)
3150                 return (S_ERROR);
3151 
3152         /*
3153          * Make the .plt section.  This occurs after any other relocation
3154          * sections are generated (see reloc_init()) to ensure that the
3155          * associated relocation section is after all the other relocation
3156          * sections.
3157          */
3158         if ((ofl->ofl_pltcnt) || (ofl->ofl_pltpad))
3159                 if (make_plt(ofl) == S_ERROR)
3160                         return (S_ERROR);
3161 
3162         /*
3163          * Determine whether any sections or files are not referenced.  Under
3164          * -Dunused a diagnostic for any unused components is generated, under
3165          * -zignore the component is removed from the final output.
3166          */
3167         if (DBG_ENABLED || (ofl->ofl_flags1 & FLG_OF1_IGNPRC)) {
3168                 if (ignore_section_processing(ofl) == S_ERROR)
3169                         return (S_ERROR);
3170         }
3171 
3172         /*
3173          * If we have detected a situation in which previously placed
3174          * output sections may have been discarded, perform the necessary
3175          * readjustment.
3176          */
3177         if (ofl->ofl_flags & FLG_OF_ADJOSCNT)
3178                 adjust_os_count(ofl);
3179 
3180         /*
3181          * Do any of the output sections contain input sections that
3182          * are candidates for string table merging? For each such case,
3183          * we create a replacement section, insert it, and discard the
3184          * originals.
3185          *
3186          * rel_alpp and sym_alpp are used by ld_make_strmerge()
3187          * for its internal processing. We are responsible for the
3188          * initialization and cleanup, and ld_make_strmerge() handles the rest.
3189          * This allows us to reuse a single pair of memory buffers, allocated
3190          * for this processing, for all the output sections.
3191          */
3192         if ((ofl->ofl_flags1 & FLG_OF1_NCSTTAB) == 0) {
3193                 int     error_seen = 0;
3194                 APlist  *rel_alpp = NULL;
3195                 APlist  *sym_alpp = NULL;
3196                 Aliste  idx1;
3197 
3198                 for (APLIST_TRAVERSE(ofl->ofl_segs, idx1, sgp)) {
3199                         Os_desc *osp;
3200                         Aliste  idx2;
3201 
3202                         for (APLIST_TRAVERSE(sgp->sg_osdescs, idx2, osp))
3203                                 if ((osp->os_mstrisdescs != NULL) &&
3204                                     (ld_make_strmerge(ofl, osp,
3205                                     &rel_alpp, &sym_alpp) ==
3206                                     S_ERROR)) {
3207                                         error_seen = 1;
3208                                         break;
3209                                 }
3210                 }
3211                 if (rel_alpp != NULL)
3212                         libld_free(rel_alpp);
3213                 if (sym_alpp != NULL)
3214                         libld_free(sym_alpp);
3215                 if (error_seen != 0)
3216                         return (S_ERROR);
3217         }
3218 
3219         /*
3220          * Add any necessary versioning information.
3221          */
3222         if (!(flags & FLG_OF_NOVERSEC)) {
3223                 if ((flags & FLG_OF_VERNEED) &&
3224                     (make_verneed(ofl) == S_ERROR))
3225                         return (S_ERROR);
3226                 if ((flags & FLG_OF_VERDEF) &&
3227                     (make_verdef(ofl) == S_ERROR))
3228                         return (S_ERROR);
3229                 if ((flags & (FLG_OF_VERNEED | FLG_OF_VERDEF)) &&
3230                     ((ofl->ofl_osversym = make_sym_sec(ofl,
3231                     MSG_ORIG(MSG_SCN_SUNWVERSYM), SHT_SUNW_versym,
3232                     ld_targ.t_id.id_version)) == (Os_desc*)S_ERROR))
3233                         return (S_ERROR);
3234         }
3235 
3236         /*
3237          * Create a syminfo section if necessary.
3238          */
3239         if (flags & FLG_OF_SYMINFO) {
3240                 if ((ofl->ofl_ossyminfo = make_sym_sec(ofl,
3241                     MSG_ORIG(MSG_SCN_SUNWSYMINFO), SHT_SUNW_syminfo,
3242                     ld_targ.t_id.id_syminfo)) == (Os_desc *)S_ERROR)
3243                         return (S_ERROR);
3244         }
3245 
3246         if (flags & FLG_OF_COMREL) {
3247                 /*
3248                  * If -zcombreloc is enabled then all relocations (except for
3249                  * the PLT's) are coalesced into a single relocation section.
3250                  */
3251                 if (ofl->ofl_reloccnt) {
3252                         if (make_reloc(ofl, NULL) == S_ERROR)
3253                                 return (S_ERROR);
3254                 }
3255         } else {
3256                 Aliste  idx1;
3257 
3258                 /*
3259                  * Create the required output relocation sections.  Note, new
3260                  * sections may be added to the section list that is being
3261                  * traversed.  These insertions can move the elements of the
3262                  * Alist such that a section descriptor is re-read.  Recursion
3263                  * is prevented by maintaining a previous section pointer and
3264                  * insuring that this pointer isn't re-examined.
3265                  */
3266                 for (APLIST_TRAVERSE(ofl->ofl_segs, idx1, sgp)) {
3267                         Os_desc *osp, *posp = 0;
3268                         Aliste  idx2;
3269 
3270                         for (APLIST_TRAVERSE(sgp->sg_osdescs, idx2, osp)) {
3271                                 if ((osp != posp) && osp->os_szoutrels &&
3272                                     (osp != ofl->ofl_osplt)) {
3273                                         if (make_reloc(ofl, osp) == S_ERROR)
3274                                                 return (S_ERROR);
3275                                 }
3276                                 posp = osp;
3277                         }
3278                 }
3279 
3280                 /*
3281                  * If we're not building a combined relocation section, then
3282                  * build a .rel[a] section as required.
3283                  */
3284                 if (ofl->ofl_relocrelsz) {
3285                         if (make_reloc(ofl, NULL) == S_ERROR)
3286                                 return (S_ERROR);
3287                 }
3288         }
3289 
3290         /*
3291          * The PLT relocations are always in their own section, and we try to
3292          * keep them at the end of the PLT table.  We do this to keep the hot
3293          * "data" PLT's at the head of the table nearer the .dynsym & .hash.
3294          */
3295         if (ofl->ofl_osplt && ofl->ofl_relocpltsz) {
3296                 if (make_reloc(ofl, ofl->ofl_osplt) == S_ERROR)
3297                         return (S_ERROR);
3298         }
3299 
3300         /*
3301          * Finally build the symbol and section header sections.
3302          */
3303         if (flags & FLG_OF_DYNAMIC) {
3304                 if (make_dynamic(ofl) == S_ERROR)
3305                         return (S_ERROR);
3306 
3307                 /*
3308                  * A number of sections aren't necessary within a relocatable
3309                  * object, even if -dy has been used.
3310                  */
3311                 if (!(flags & FLG_OF_RELOBJ)) {
3312                         if (make_hash(ofl) == S_ERROR)
3313                                 return (S_ERROR);
3314                         if (make_dynstr(ofl) == S_ERROR)
3315                                 return (S_ERROR);
3316                         if (make_dynsym(ofl) == S_ERROR)
3317                                 return (S_ERROR);
3318                         if (ld_unwind_make_hdr(ofl) == S_ERROR)
3319                                 return (S_ERROR);
3320                         if (make_dynsort(ofl) == S_ERROR)
3321                                 return (S_ERROR);
3322                 }
3323         }
3324 
3325         if (!(flags & FLG_OF_STRIP) || (flags & FLG_OF_RELOBJ) ||
3326             ((flags & FLG_OF_STATIC) && ofl->ofl_osversym)) {
3327                 /*
3328                  * Do we need to make a SHT_SYMTAB_SHNDX section
3329                  * for the dynsym.  If so - do it now.
3330                  */
3331                 if (ofl->ofl_osdynsym &&
3332                     ((ofl->ofl_shdrcnt + 3) >= SHN_LORESERVE)) {
3333                         if (make_dynsym_shndx(ofl) == S_ERROR)
3334                                 return (S_ERROR);
3335                 }
3336 
3337                 if (make_strtab(ofl) == S_ERROR)
3338                         return (S_ERROR);
3339                 if (make_symtab(ofl) == S_ERROR)
3340                         return (S_ERROR);
3341         } else {
3342                 /*
3343                  * Do we need to make a SHT_SYMTAB_SHNDX section
3344                  * for the dynsym.  If so - do it now.
3345                  */
3346                 if (ofl->ofl_osdynsym &&
3347                     ((ofl->ofl_shdrcnt + 1) >= SHN_LORESERVE)) {
3348                         if (make_dynsym_shndx(ofl) == S_ERROR)
3349                                 return (S_ERROR);
3350                 }
3351         }
3352 
3353         if (make_shstrtab(ofl) == S_ERROR)
3354                 return (S_ERROR);
3355 
3356         /*
3357          * Now that we've created all output sections, adjust the size of the
3358          * SHT_SUNW_versym and SHT_SUNW_syminfo section, which are dependent on
3359          * the associated symbol table sizes.
3360          */
3361         if (ofl->ofl_osversym || ofl->ofl_ossyminfo) {
3362                 ulong_t         cnt;
3363                 Is_desc         *isp;
3364                 Os_desc         *osp;
3365 
3366                 if (OFL_IS_STATIC_OBJ(ofl))
3367                         osp = ofl->ofl_ossymtab;
3368                 else
3369                         osp = ofl->ofl_osdynsym;
3370 
3371                 isp = ld_os_first_isdesc(osp);
3372                 cnt = (isp->is_shdr->sh_size / isp->is_shdr->sh_entsize);
3373 
3374                 if (ofl->ofl_osversym)
3375                         update_data_size(ofl->ofl_osversym, cnt);
3376 
3377                 if (ofl->ofl_ossyminfo)
3378                         update_data_size(ofl->ofl_ossyminfo, cnt);
3379         }
3380 
3381         /*
3382          * Now that we've created all output sections, adjust the size of the
3383          * SHT_SUNW_capinfo, which is dependent on the associated symbol table
3384          * size.
3385          */
3386         if (ofl->ofl_oscapinfo) {
3387                 ulong_t cnt;
3388 
3389                 /*
3390                  * Symbol capabilities symbols are placed directly after the
3391                  * STT_FILE symbol, section symbols, and any register symbols.
3392                  * Effectively these are the first of any series of demoted
3393                  * (scoped) symbols.
3394                  */
3395                 if (OFL_IS_STATIC_OBJ(ofl))
3396                         cnt = SYMTAB_ALL_CNT(ofl);
3397                 else
3398                         cnt = DYNSYM_ALL_CNT(ofl);
3399 
3400                 update_data_size(ofl->ofl_oscapinfo, cnt);
3401         }
3402         return (1);
3403 }
3404 
3405 /*
3406  * Build an additional data section - used to back OBJT symbol definitions
3407  * added with a mapfile.
3408  */
3409 Is_desc *
3410 ld_make_data(Ofl_desc *ofl, size_t size)
3411 {
3412         Shdr            *shdr;
3413         Elf_Data        *data;
3414         Is_desc         *isec;
3415 
3416         if (new_section(ofl, SHT_PROGBITS, MSG_ORIG(MSG_SCN_DATA), 0,
3417             &isec, &shdr, &data) == S_ERROR)
3418                 return ((Is_desc *)S_ERROR);
3419 
3420         data->d_size = size;
3421         shdr->sh_size = (Xword)size;
3422         shdr->sh_flags |= SHF_WRITE;
3423 
3424         if (aplist_append(&ofl->ofl_mapdata, isec, AL_CNT_OFL_MAPSECS) == NULL)
3425                 return ((Is_desc *)S_ERROR);
3426 
3427         return (isec);
3428 }
3429 
3430 /*
3431  * Build an additional text section - used to back FUNC symbol definitions
3432  * added with a mapfile.
3433  */
3434 Is_desc *
3435 ld_make_text(Ofl_desc *ofl, size_t size)
3436 {
3437         Shdr            *shdr;
3438         Elf_Data        *data;
3439         Is_desc         *isec;
3440 
3441         /*
3442          * Insure the size is sufficient to contain the minimum return
3443          * instruction.
3444          */
3445         if (size < ld_targ.t_nf.nf_size)
3446                 size = ld_targ.t_nf.nf_size;
3447 
3448         if (new_section(ofl, SHT_PROGBITS, MSG_ORIG(MSG_SCN_TEXT), 0,
3449             &isec, &shdr, &data) == S_ERROR)
3450                 return ((Is_desc *)S_ERROR);
3451 
3452         data->d_size = size;
3453         shdr->sh_size = (Xword)size;
3454         shdr->sh_flags |= SHF_EXECINSTR;
3455 
3456         /*
3457          * Fill the buffer with the appropriate return instruction.
3458          * Note that there is no need to swap bytes on a non-native,
3459          * link, as the data being copied is given in bytes.
3460          */
3461         if ((data->d_buf = libld_calloc(size, 1)) == NULL)
3462                 return ((Is_desc *)S_ERROR);
3463         (void) memcpy(data->d_buf, ld_targ.t_nf.nf_template,
3464             ld_targ.t_nf.nf_size);
3465 
3466         /*
3467          * If size was larger than required, and the target supplies
3468          * a fill function, use it to fill the balance. If there is no
3469          * fill function, we accept the 0-fill supplied by libld_calloc().
3470          */
3471         if ((ld_targ.t_ff.ff_execfill != NULL) && (size > ld_targ.t_nf.nf_size))
3472                 ld_targ.t_ff.ff_execfill(data->d_buf, ld_targ.t_nf.nf_size,
3473                     size - ld_targ.t_nf.nf_size);
3474 
3475         if (aplist_append(&ofl->ofl_maptext, isec, AL_CNT_OFL_MAPSECS) == NULL)
3476                 return ((Is_desc *)S_ERROR);
3477 
3478         return (isec);
3479 }
3480 
3481 void
3482 ld_comdat_validate(Ofl_desc *ofl, Ifl_desc *ifl)
3483 {
3484         int i;
3485 
3486         for (i = 0; i < ifl->ifl_shnum; i++) {
3487                 Is_desc *isp = ifl->ifl_isdesc[i];
3488                 int types = 0;
3489                 char buf[1024] = "";
3490                 Group_desc *gr = NULL;
3491 
3492                 if ((isp == NULL) || (isp->is_flags & FLG_IS_COMDAT) == 0)
3493                         continue;
3494 
3495                 if (isp->is_shdr->sh_type == SHT_SUNW_COMDAT) {
3496                         types++;
3497                         (void) strlcpy(buf, MSG_ORIG(MSG_STR_SUNW_COMDAT),
3498                             sizeof (buf));
3499                 }
3500 
3501                 if (strncmp(MSG_ORIG(MSG_SCN_GNU_LINKONCE), isp->is_name,
3502                     MSG_SCN_GNU_LINKONCE_SIZE) == 0) {
3503                         types++;
3504                         if (types > 1)
3505                                 (void) strlcat(buf, ", ", sizeof (buf));
3506                         (void) strlcat(buf, MSG_ORIG(MSG_SCN_GNU_LINKONCE),
3507                             sizeof (buf));
3508                 }
3509 
3510                 if ((isp->is_shdr->sh_flags & SHF_GROUP) &&
3511                     ((gr = ld_get_group(ofl, isp)) != NULL) &&
3512                     (gr->gd_data[0] & GRP_COMDAT)) {
3513                         types++;
3514                         if (types > 1)
3515                                 (void) strlcat(buf, ", ", sizeof (buf));
3516                         (void) strlcat(buf, MSG_ORIG(MSG_STR_GROUP),
3517                             sizeof (buf));
3518                 }
3519 
3520                 if (types > 1)
3521                         ld_eprintf(ofl, ERR_FATAL,
3522                             MSG_INTL(MSG_SCN_MULTICOMDAT), ifl->ifl_name,
3523                             EC_WORD(isp->is_scnndx), isp->is_name, buf);
3524         }
3525 }