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                 if (ofl->ofl_aslr != 0)              /* DT_SUNW_ASLR */
1274                         cnt++;
1275         }
1276 
1277         /*
1278          * Account for Architecture dependent .dynamic entries, and defaults.
1279          */
1280         (*ld_targ.t_mr.mr_mach_make_dynamic)(ofl, &cnt);
1281 
1282         /*
1283          * DT_FLAGS, DT_FLAGS_1, DT_SUNW_STRPAD, and DT_NULL. Also,
1284          * allow room for the unused extra DT_NULLs. These are included
1285          * to allow an ELF editor room to add items later.
1286          */
1287         cnt += 4 + DYNAMIC_EXTRA_ELTS;
1288 
1289         /*
1290          * DT_SUNW_LDMACH. Used to hold the ELF machine code of the
1291          * linker that produced the output object. This information
1292          * allows us to determine whether a given object was linked
1293          * natively, or by a linker running on a different type of
1294          * system. This information can be valuable if one suspects
1295          * that a problem might be due to alignment or byte order issues.
1296          */
1297         cnt++;
1298 
1299         /*
1300          * Determine the size of the section from the number of entries.
1301          */
1302         size = cnt * (size_t)shdr->sh_entsize;
1303 
1304         shdr->sh_size = (Xword)size;
1305         data->d_size = size;
1306 
1307         /*
1308          * There are several tags that are specific to the Solaris osabi
1309          * range which we unconditionally put into any dynamic section
1310          * we create (e.g. DT_SUNW_STRPAD or DT_SUNW_LDMACH). As such,
1311          * any Solaris object with a dynamic section should be tagged as
1312          * ELFOSABI_SOLARIS.
1313          */
1314         ofl->ofl_flags |= FLG_OF_OSABI;
1315 
1316         return ((uintptr_t)ofl->ofl_osdynamic);
1317 }
1318 
1319 /*
1320  * Build the GOT section and its associated relocation entries.
1321  */
1322 uintptr_t
1323 ld_make_got(Ofl_desc *ofl)
1324 {
1325         Elf_Data        *data;
1326         Shdr    *shdr;
1327         Is_desc *isec;
1328         size_t  size = (size_t)ofl->ofl_gotcnt * ld_targ.t_m.m_got_entsize;
1329         size_t  rsize = (size_t)ofl->ofl_relocgotsz;
1330 
1331         if (new_section(ofl, SHT_PROGBITS, MSG_ORIG(MSG_SCN_GOT), 0,
1332             &isec, &shdr, &data) == S_ERROR)
1333                 return (S_ERROR);
1334 
1335         data->d_size = size;
1336 
1337         shdr->sh_flags |= SHF_WRITE;
1338         shdr->sh_size = (Xword)size;
1339         shdr->sh_entsize = ld_targ.t_m.m_got_entsize;
1340 
1341         ofl->ofl_osgot = ld_place_section(ofl, isec, NULL,
1342             ld_targ.t_id.id_got, NULL);
1343         if (ofl->ofl_osgot == (Os_desc *)S_ERROR)
1344                 return (S_ERROR);
1345 
1346         ofl->ofl_osgot->os_szoutrels = (Xword)rsize;
1347 
1348         return (1);
1349 }
1350 
1351 /*
1352  * Build an interpreter section.
1353  */
1354 static uintptr_t
1355 make_interp(Ofl_desc *ofl)
1356 {
1357         Shdr            *shdr;
1358         Elf_Data        *data;
1359         Is_desc         *isec;
1360         const char      *iname = ofl->ofl_interp;
1361         size_t          size;
1362 
1363         /*
1364          * If -z nointerp is in effect, don't create an interpreter section.
1365          */
1366         if (ofl->ofl_flags1 & FLG_OF1_NOINTRP)
1367                 return (1);
1368 
1369         /*
1370          * An .interp section is always created for a dynamic executable.
1371          * A user can define the interpreter to use.  This definition overrides
1372          * the default that would be recorded in an executable, and triggers
1373          * the creation of an .interp section in any other object.  Presumably
1374          * the user knows what they are doing.  Refer to the generic ELF ABI
1375          * section 5-4, and the ld(1) -I option.
1376          */
1377         if (((ofl->ofl_flags & (FLG_OF_DYNAMIC | FLG_OF_EXEC |
1378             FLG_OF_RELOBJ)) != (FLG_OF_DYNAMIC | FLG_OF_EXEC)) && !iname)
1379                 return (1);
1380 
1381         /*
1382          * In the case of a dynamic executable, supply a default interpreter
1383          * if the user has not specified their own.
1384          */
1385         if (iname == NULL)
1386                 iname = ofl->ofl_interp = ld_targ.t_m.m_def_interp;
1387 
1388         size = strlen(iname) + 1;
1389 
1390         if (new_section(ofl, SHT_PROGBITS, MSG_ORIG(MSG_SCN_INTERP), 0,
1391             &isec, &shdr, &data) == S_ERROR)
1392                 return (S_ERROR);
1393 
1394         data->d_size = size;
1395         shdr->sh_size = (Xword)size;
1396         data->d_align = shdr->sh_addralign = 1;
1397 
1398         ofl->ofl_osinterp =
1399             ld_place_section(ofl, isec, NULL, ld_targ.t_id.id_interp, NULL);
1400         return ((uintptr_t)ofl->ofl_osinterp);
1401 }
1402 
1403 /*
1404  * Common function used to build the SHT_SUNW_versym section, SHT_SUNW_syminfo
1405  * section, and SHT_SUNW_capinfo section.  Each of these sections provide
1406  * additional symbol information, and their size parallels the associated
1407  * symbol table.
1408  */
1409 static Os_desc *
1410 make_sym_sec(Ofl_desc *ofl, const char *sectname, Word stype, int ident)
1411 {
1412         Shdr            *shdr;
1413         Elf_Data        *data;
1414         Is_desc         *isec;
1415 
1416         /*
1417          * We don't know the size of this section yet, so set it to 0.  The
1418          * size gets filled in after the associated symbol table is sized.
1419          */
1420         if (new_section(ofl, stype, sectname, 0, &isec, &shdr, &data) ==
1421             S_ERROR)
1422                 return ((Os_desc *)S_ERROR);
1423 
1424         return (ld_place_section(ofl, isec, NULL, ident, NULL));
1425 }
1426 
1427 /*
1428  * Determine whether a symbol capability is redundant because the object
1429  * capabilities are more restrictive.
1430  */
1431 inline static int
1432 is_cap_redundant(Objcapset *ocapset, Objcapset *scapset)
1433 {
1434         Alist           *oalp, *salp;
1435         elfcap_mask_t   omsk, smsk;
1436 
1437         /*
1438          * Inspect any platform capabilities.  If the object defines platform
1439          * capabilities, then the object will only be loaded for those
1440          * platforms.  A symbol capability set that doesn't define the same
1441          * platforms is redundant, and a symbol capability that does not provide
1442          * at least one platform name that matches a platform name in the object
1443          * capabilities will never execute (as the object wouldn't have been
1444          * loaded).
1445          */
1446         oalp = ocapset->oc_plat.cl_val;
1447         salp = scapset->oc_plat.cl_val;
1448         if (oalp && ((salp == NULL) || cap_names_match(oalp, salp)))
1449                 return (1);
1450 
1451         /*
1452          * If the symbol capability set defines platforms, and the object
1453          * doesn't, then the symbol set is more restrictive.
1454          */
1455         if (salp && (oalp == NULL))
1456                 return (0);
1457 
1458         /*
1459          * Next, inspect any machine name capabilities.  If the object defines
1460          * machine name capabilities, then the object will only be loaded for
1461          * those machines.  A symbol capability set that doesn't define the same
1462          * machine names is redundant, and a symbol capability that does not
1463          * provide at least one machine name that matches a machine name in the
1464          * object capabilities will never execute (as the object wouldn't have
1465          * been loaded).
1466          */
1467         oalp = ocapset->oc_plat.cl_val;
1468         salp = scapset->oc_plat.cl_val;
1469         if (oalp && ((salp == NULL) || cap_names_match(oalp, salp)))
1470                 return (1);
1471 
1472         /*
1473          * If the symbol capability set defines machine names, and the object
1474          * doesn't, then the symbol set is more restrictive.
1475          */
1476         if (salp && (oalp == NULL))
1477                 return (0);
1478 
1479         /*
1480          * Next, inspect any hardware capabilities.  If the objects hardware
1481          * capabilities are greater than or equal to that of the symbols
1482          * capabilities, then the symbol capability set is redundant.  If the
1483          * symbols hardware capabilities are greater that the objects, then the
1484          * symbol set is more restrictive.
1485          *
1486          * Note that this is a somewhat arbitrary definition, as each capability
1487          * bit is independent of the others, and some of the higher order bits
1488          * could be considered to be less important than lower ones.  However,
1489          * this is the only reasonable non-subjective definition.
1490          */
1491         omsk = ocapset->oc_hw_2.cm_val;
1492         smsk = scapset->oc_hw_2.cm_val;
1493         if ((omsk > smsk) || (omsk && (omsk == smsk)))
1494                 return (1);
1495         if (omsk < smsk)
1496                 return (0);
1497 
1498         /*
1499          * Finally, inspect the remaining hardware capabilities.
1500          */
1501         omsk = ocapset->oc_hw_1.cm_val;
1502         smsk = scapset->oc_hw_1.cm_val;
1503         if ((omsk > smsk) || (omsk && (omsk == smsk)))
1504                 return (1);
1505 
1506         return (0);
1507 }
1508 
1509 /*
1510  * Capabilities values might have been assigned excluded values.  These
1511  * excluded values should be removed before calculating any capabilities
1512  * sections size.
1513  */
1514 static void
1515 capmask_value(Lm_list *lml, Word type, Capmask *capmask, int *title)
1516 {
1517         /*
1518          * First determine whether any bits should be excluded.
1519          */
1520         if ((capmask->cm_val & capmask->cm_exc) == 0)
1521                 return;
1522 
1523         DBG_CALL(Dbg_cap_post_title(lml, title));
1524 
1525         DBG_CALL(Dbg_cap_val_entry(lml, DBG_STATE_CURRENT, type,
1526             capmask->cm_val, ld_targ.t_m.m_mach));
1527         DBG_CALL(Dbg_cap_val_entry(lml, DBG_STATE_EXCLUDE, type,
1528             capmask->cm_exc, ld_targ.t_m.m_mach));
1529 
1530         capmask->cm_val &= ~capmask->cm_exc;
1531 
1532         DBG_CALL(Dbg_cap_val_entry(lml, DBG_STATE_RESOLVED, type,
1533             capmask->cm_val, ld_targ.t_m.m_mach));
1534 }
1535 
1536 static void
1537 capstr_value(Lm_list *lml, Word type, Caplist *caplist, int *title)
1538 {
1539         Aliste  idx1, idx2;
1540         char    *estr;
1541         Capstr  *capstr;
1542         Boolean found = FALSE;
1543 
1544         /*
1545          * First determine whether any strings should be excluded.
1546          */
1547         for (APLIST_TRAVERSE(caplist->cl_exc, idx1, estr)) {
1548                 for (ALIST_TRAVERSE(caplist->cl_val, idx2, capstr)) {
1549                         if (strcmp(estr, capstr->cs_str) == 0) {
1550                                 found = TRUE;
1551                                 break;
1552                         }
1553                 }
1554         }
1555 
1556         if (found == FALSE)
1557                 return;
1558 
1559         /*
1560          * Traverse the current strings, then delete the excluded strings,
1561          * and finally display the resolved strings.
1562          */
1563         if (DBG_ENABLED) {
1564                 Dbg_cap_post_title(lml, title);
1565                 for (ALIST_TRAVERSE(caplist->cl_val, idx2, capstr)) {
1566                         Dbg_cap_ptr_entry(lml, DBG_STATE_CURRENT, type,
1567                             capstr->cs_str);
1568                 }
1569         }
1570         for (APLIST_TRAVERSE(caplist->cl_exc, idx1, estr)) {
1571                 for (ALIST_TRAVERSE(caplist->cl_val, idx2, capstr)) {
1572                         if (strcmp(estr, capstr->cs_str) == 0) {
1573                                 DBG_CALL(Dbg_cap_ptr_entry(lml,
1574                                     DBG_STATE_EXCLUDE, type, capstr->cs_str));
1575                                 alist_delete(caplist->cl_val, &idx2);
1576                                 break;
1577                         }
1578                 }
1579         }
1580         if (DBG_ENABLED) {
1581                 for (ALIST_TRAVERSE(caplist->cl_val, idx2, capstr)) {
1582                         Dbg_cap_ptr_entry(lml, DBG_STATE_RESOLVED, type,
1583                             capstr->cs_str);
1584                 }
1585         }
1586 }
1587 
1588 /*
1589  * Build a capabilities section.
1590  */
1591 #define CAP_UPDATE(cap, capndx, tag, val)       \
1592         cap->c_tag = tag; \
1593         cap->c_un.c_val = val; \
1594         cap++, capndx++;
1595 
1596 static uintptr_t
1597 make_cap(Ofl_desc *ofl, Word shtype, const char *shname, int ident)
1598 {
1599         Shdr            *shdr;
1600         Elf_Data        *data;
1601         Is_desc         *isec;
1602         Cap             *cap;
1603         size_t          size = 0;
1604         Word            capndx = 0;
1605         Str_tbl         *strtbl;
1606         Objcapset       *ocapset = &ofl->ofl_ocapset;
1607         Aliste          idx1;
1608         Capstr          *capstr;
1609         int             title = 0;
1610 
1611         /*
1612          * Determine which string table to use for any CA_SUNW_MACH,
1613          * CA_SUNW_PLAT, or CA_SUNW_ID strings.
1614          */
1615         if (OFL_IS_STATIC_OBJ(ofl))
1616                 strtbl = ofl->ofl_strtab;
1617         else
1618                 strtbl = ofl->ofl_dynstrtab;
1619 
1620         /*
1621          * If symbol capabilities have been requested, but none have been
1622          * created, warn the user.  This scenario can occur if none of the
1623          * input relocatable objects defined any object capabilities.
1624          */
1625         if ((ofl->ofl_flags & FLG_OF_OTOSCAP) && (ofl->ofl_capsymcnt == 0))
1626                 ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_CAP_NOSYMSFOUND));
1627 
1628         /*
1629          * If symbol capabilities have been collected, but no symbols are left
1630          * referencing these capabilities, promote the capability groups back
1631          * to an object capability definition.
1632          */
1633         if ((ofl->ofl_flags & FLG_OF_OTOSCAP) && ofl->ofl_capsymcnt &&
1634             (ofl->ofl_capfamilies == NULL)) {
1635                 ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_CAP_NOSYMSFOUND));
1636                 ld_cap_move_symtoobj(ofl);
1637                 ofl->ofl_capsymcnt = 0;
1638                 ofl->ofl_capgroups = NULL;
1639                 ofl->ofl_flags &= ~FLG_OF_OTOSCAP;
1640         }
1641 
1642         /*
1643          * Remove any excluded capabilities.
1644          */
1645         capstr_value(ofl->ofl_lml, CA_SUNW_PLAT, &ocapset->oc_plat, &title);
1646         capstr_value(ofl->ofl_lml, CA_SUNW_MACH, &ocapset->oc_mach, &title);
1647         capmask_value(ofl->ofl_lml, CA_SUNW_HW_2, &ocapset->oc_hw_2, &title);
1648         capmask_value(ofl->ofl_lml, CA_SUNW_HW_1, &ocapset->oc_hw_1, &title);
1649         capmask_value(ofl->ofl_lml, CA_SUNW_SF_1, &ocapset->oc_sf_1, &title);
1650 
1651         /*
1652          * Determine how many entries are required for any object capabilities.
1653          */
1654         size += alist_nitems(ocapset->oc_plat.cl_val);
1655         size += alist_nitems(ocapset->oc_mach.cl_val);
1656         if (ocapset->oc_hw_2.cm_val)
1657                 size++;
1658         if (ocapset->oc_hw_1.cm_val)
1659                 size++;
1660         if (ocapset->oc_sf_1.cm_val)
1661                 size++;
1662 
1663         /*
1664          * Only identify a capabilities group if the group has content.  If a
1665          * capabilities identifier exists, and no other capabilities have been
1666          * supplied, remove the identifier.  This scenario could exist if a
1667          * user mistakenly defined a lone identifier, or if an identified group
1668          * was overridden so as to clear the existing capabilities and the
1669          * identifier was not also cleared.
1670          */
1671         if (ocapset->oc_id.cs_str) {
1672                 if (size)
1673                         size++;
1674                 else
1675                         ocapset->oc_id.cs_str = NULL;
1676         }
1677         if (size)
1678                 size++;                 /* Add CA_SUNW_NULL */
1679 
1680         /*
1681          * Determine how many entries are required for any symbol capabilities.
1682          */
1683         if (ofl->ofl_capsymcnt) {
1684                 /*
1685                  * If there are no object capabilities, a CA_SUNW_NULL entry
1686                  * is required before any symbol capabilities.
1687                  */
1688                 if (size == 0)
1689                         size++;
1690                 size += ofl->ofl_capsymcnt;
1691         }
1692 
1693         if (size == 0)
1694                 return (NULL);
1695 
1696         if (new_section(ofl, shtype, shname, size, &isec,
1697             &shdr, &data) == S_ERROR)
1698                 return (S_ERROR);
1699 
1700         if ((data->d_buf = libld_malloc(shdr->sh_size)) == NULL)
1701                 return (S_ERROR);
1702 
1703         cap = (Cap *)data->d_buf;
1704 
1705         /*
1706          * Fill in any object capabilities.  If there is an identifier, then the
1707          * identifier comes first.  The remaining items follow in precedence
1708          * order, although the order isn't important for runtime verification.
1709          */
1710         if (ocapset->oc_id.cs_str) {
1711                 ofl->ofl_flags |= FLG_OF_CAPSTRS;
1712                 if (st_insert(strtbl, ocapset->oc_id.cs_str) == -1)
1713                         return (S_ERROR);
1714                 ocapset->oc_id.cs_ndx = capndx;
1715                 CAP_UPDATE(cap, capndx, CA_SUNW_ID, 0);
1716         }
1717         if (ocapset->oc_plat.cl_val) {
1718                 ofl->ofl_flags |= (FLG_OF_PTCAP | FLG_OF_CAPSTRS);
1719 
1720                 /*
1721                  * Insert any platform name strings in the appropriate string
1722                  * table.  The capability value can't be filled in yet, as the
1723                  * final offset of the strings isn't known until later.
1724                  */
1725                 for (ALIST_TRAVERSE(ocapset->oc_plat.cl_val, idx1, capstr)) {
1726                         if (st_insert(strtbl, capstr->cs_str) == -1)
1727                                 return (S_ERROR);
1728                         capstr->cs_ndx = capndx;
1729                         CAP_UPDATE(cap, capndx, CA_SUNW_PLAT, 0);
1730                 }
1731         }
1732         if (ocapset->oc_mach.cl_val) {
1733                 ofl->ofl_flags |= (FLG_OF_PTCAP | FLG_OF_CAPSTRS);
1734 
1735                 /*
1736                  * Insert the machine name strings in the appropriate string
1737                  * table.  The capability value can't be filled in yet, as the
1738                  * final offset of the strings isn't known until later.
1739                  */
1740                 for (ALIST_TRAVERSE(ocapset->oc_mach.cl_val, idx1, capstr)) {
1741                         if (st_insert(strtbl, capstr->cs_str) == -1)
1742                                 return (S_ERROR);
1743                         capstr->cs_ndx = capndx;
1744                         CAP_UPDATE(cap, capndx, CA_SUNW_MACH, 0);
1745                 }
1746         }
1747         if (ocapset->oc_hw_2.cm_val) {
1748                 ofl->ofl_flags |= FLG_OF_PTCAP;
1749                 CAP_UPDATE(cap, capndx, CA_SUNW_HW_2, ocapset->oc_hw_2.cm_val);
1750         }
1751         if (ocapset->oc_hw_1.cm_val) {
1752                 ofl->ofl_flags |= FLG_OF_PTCAP;
1753                 CAP_UPDATE(cap, capndx, CA_SUNW_HW_1, ocapset->oc_hw_1.cm_val);
1754         }
1755         if (ocapset->oc_sf_1.cm_val) {
1756                 ofl->ofl_flags |= FLG_OF_PTCAP;
1757                 CAP_UPDATE(cap, capndx, CA_SUNW_SF_1, ocapset->oc_sf_1.cm_val);
1758         }
1759         CAP_UPDATE(cap, capndx, CA_SUNW_NULL, 0);
1760 
1761         /*
1762          * Fill in any symbol capabilities.
1763          */
1764         if (ofl->ofl_capgroups) {
1765                 Cap_group       *cgp;
1766 
1767                 for (APLIST_TRAVERSE(ofl->ofl_capgroups, idx1, cgp)) {
1768                         Objcapset       *scapset = &cgp->cg_set;
1769                         Aliste          idx2;
1770                         Is_desc         *isp;
1771 
1772                         cgp->cg_ndx = capndx;
1773 
1774                         if (scapset->oc_id.cs_str) {
1775                                 ofl->ofl_flags |= FLG_OF_CAPSTRS;
1776                                 /*
1777                                  * Insert the identifier string in the
1778                                  * appropriate string table.  The capability
1779                                  * value can't be filled in yet, as the final
1780                                  * offset of the string isn't known until later.
1781                                  */
1782                                 if (st_insert(strtbl,
1783                                     scapset->oc_id.cs_str) == -1)
1784                                         return (S_ERROR);
1785                                 scapset->oc_id.cs_ndx = capndx;
1786                                 CAP_UPDATE(cap, capndx, CA_SUNW_ID, 0);
1787                         }
1788 
1789                         if (scapset->oc_plat.cl_val) {
1790                                 ofl->ofl_flags |= FLG_OF_CAPSTRS;
1791 
1792                                 /*
1793                                  * Insert the platform name string in the
1794                                  * appropriate string table.  The capability
1795                                  * value can't be filled in yet, as the final
1796                                  * offset of the string isn't known until later.
1797                                  */
1798                                 for (ALIST_TRAVERSE(scapset->oc_plat.cl_val,
1799                                     idx2, capstr)) {
1800                                         if (st_insert(strtbl,
1801                                             capstr->cs_str) == -1)
1802                                                 return (S_ERROR);
1803                                         capstr->cs_ndx = capndx;
1804                                         CAP_UPDATE(cap, capndx,
1805                                             CA_SUNW_PLAT, 0);
1806                                 }
1807                         }
1808                         if (scapset->oc_mach.cl_val) {
1809                                 ofl->ofl_flags |= FLG_OF_CAPSTRS;
1810 
1811                                 /*
1812                                  * Insert the machine name string in the
1813                                  * appropriate string table.  The capability
1814                                  * value can't be filled in yet, as the final
1815                                  * offset of the string isn't known until later.
1816                                  */
1817                                 for (ALIST_TRAVERSE(scapset->oc_mach.cl_val,
1818                                     idx2, capstr)) {
1819                                         if (st_insert(strtbl,
1820                                             capstr->cs_str) == -1)
1821                                                 return (S_ERROR);
1822                                         capstr->cs_ndx = capndx;
1823                                         CAP_UPDATE(cap, capndx,
1824                                             CA_SUNW_MACH, 0);
1825                                 }
1826                         }
1827                         if (scapset->oc_hw_2.cm_val) {
1828                                 CAP_UPDATE(cap, capndx, CA_SUNW_HW_2,
1829                                     scapset->oc_hw_2.cm_val);
1830                         }
1831                         if (scapset->oc_hw_1.cm_val) {
1832                                 CAP_UPDATE(cap, capndx, CA_SUNW_HW_1,
1833                                     scapset->oc_hw_1.cm_val);
1834                         }
1835                         if (scapset->oc_sf_1.cm_val) {
1836                                 CAP_UPDATE(cap, capndx, CA_SUNW_SF_1,
1837                                     scapset->oc_sf_1.cm_val);
1838                         }
1839                         CAP_UPDATE(cap, capndx, CA_SUNW_NULL, 0);
1840 
1841                         /*
1842                          * If any object capabilities are available, determine
1843                          * whether these symbol capabilities are less
1844                          * restrictive, and hence redundant.
1845                          */
1846                         if (((ofl->ofl_flags & FLG_OF_PTCAP) == 0) ||
1847                             (is_cap_redundant(ocapset, scapset) == 0))
1848                                 continue;
1849 
1850                         /*
1851                          * Indicate any files that provide redundant symbol
1852                          * capabilities.
1853                          */
1854                         for (APLIST_TRAVERSE(cgp->cg_secs, idx2, isp)) {
1855                                 ld_eprintf(ofl, ERR_WARNING,
1856                                     MSG_INTL(MSG_CAP_REDUNDANT),
1857                                     isp->is_file->ifl_name,
1858                                     EC_WORD(isp->is_scnndx), isp->is_name);
1859                         }
1860                 }
1861         }
1862 
1863         /*
1864          * If capabilities strings are required, the sh_info field of the
1865          * section header will be set to the associated string table.
1866          */
1867         if (ofl->ofl_flags & FLG_OF_CAPSTRS)
1868                 shdr->sh_flags |= SHF_INFO_LINK;
1869 
1870         /*
1871          * Place these capabilities in the output file.
1872          */
1873         if ((ofl->ofl_oscap = ld_place_section(ofl, isec,
1874             NULL, ident, NULL)) == (Os_desc *)S_ERROR)
1875                 return (S_ERROR);
1876 
1877         /*
1878          * If symbol capabilities are required, then a .SUNW_capinfo section is
1879          * also created.  This table will eventually be sized to match the
1880          * associated symbol table.
1881          */
1882         if (ofl->ofl_capfamilies) {
1883                 if ((ofl->ofl_oscapinfo = make_sym_sec(ofl,
1884                     MSG_ORIG(MSG_SCN_SUNWCAPINFO), SHT_SUNW_capinfo,
1885                     ld_targ.t_id.id_capinfo)) == (Os_desc *)S_ERROR)
1886                         return (S_ERROR);
1887 
1888                 /*
1889                  * If we're generating a dynamic object, capabilities family
1890                  * members are maintained in a .SUNW_capchain section.
1891                  */
1892                 if (ofl->ofl_capchaincnt &&
1893                     ((ofl->ofl_flags & FLG_OF_RELOBJ) == 0)) {
1894                         if (new_section(ofl, SHT_SUNW_capchain,
1895                             MSG_ORIG(MSG_SCN_SUNWCAPCHAIN),
1896                             ofl->ofl_capchaincnt, &isec, &shdr,
1897                             &data) == S_ERROR)
1898                                 return (S_ERROR);
1899 
1900                         ofl->ofl_oscapchain = ld_place_section(ofl, isec,
1901                             NULL, ld_targ.t_id.id_capchain, NULL);
1902                         if (ofl->ofl_oscapchain == (Os_desc *)S_ERROR)
1903                                 return (S_ERROR);
1904 
1905                 }
1906         }
1907         return (1);
1908 }
1909 #undef  CAP_UPDATE
1910 
1911 /*
1912  * Build the PLT section and its associated relocation entries.
1913  */
1914 static uintptr_t
1915 make_plt(Ofl_desc *ofl)
1916 {
1917         Shdr            *shdr;
1918         Elf_Data        *data;
1919         Is_desc         *isec;
1920         size_t          size = ld_targ.t_m.m_plt_reservsz +
1921             (((size_t)ofl->ofl_pltcnt + (size_t)ofl->ofl_pltpad) *
1922             ld_targ.t_m.m_plt_entsize);
1923         size_t          rsize = (size_t)ofl->ofl_relocpltsz;
1924 
1925         /*
1926          * On sparc, account for the NOP at the end of the plt.
1927          */
1928         if (ld_targ.t_m.m_mach == LD_TARG_BYCLASS(EM_SPARC, EM_SPARCV9))
1929                 size += sizeof (Word);
1930 
1931         if (new_section(ofl, SHT_PROGBITS, MSG_ORIG(MSG_SCN_PLT), 0,
1932             &isec, &shdr, &data) == S_ERROR)
1933                 return (S_ERROR);
1934 
1935         data->d_size = size;
1936         data->d_align = ld_targ.t_m.m_plt_align;
1937 
1938         shdr->sh_flags = ld_targ.t_m.m_plt_shf_flags;
1939         shdr->sh_size = (Xword)size;
1940         shdr->sh_addralign = ld_targ.t_m.m_plt_align;
1941         shdr->sh_entsize = ld_targ.t_m.m_plt_entsize;
1942 
1943         ofl->ofl_osplt = ld_place_section(ofl, isec, NULL,
1944             ld_targ.t_id.id_plt, NULL);
1945         if (ofl->ofl_osplt == (Os_desc *)S_ERROR)
1946                 return (S_ERROR);
1947 
1948         ofl->ofl_osplt->os_szoutrels = (Xword)rsize;
1949 
1950         return (1);
1951 }
1952 
1953 /*
1954  * Make the hash table.  Only built for dynamic executables and shared
1955  * libraries, and provides hashed lookup into the global symbol table
1956  * (.dynsym) for the run-time linker to resolve symbol lookups.
1957  */
1958 static uintptr_t
1959 make_hash(Ofl_desc *ofl)
1960 {
1961         Shdr            *shdr;
1962         Elf_Data        *data;
1963         Is_desc         *isec;
1964         size_t          size;
1965         Word            nsyms = ofl->ofl_globcnt;
1966         size_t          cnt;
1967 
1968         /*
1969          * Allocate section header structures. We set entcnt to 0
1970          * because it's going to change after we place this section.
1971          */
1972         if (new_section(ofl, SHT_HASH, MSG_ORIG(MSG_SCN_HASH), 0,
1973             &isec, &shdr, &data) == S_ERROR)
1974                 return (S_ERROR);
1975 
1976         /*
1977          * Place the section first since it will affect the local symbol
1978          * count.
1979          */
1980         ofl->ofl_oshash =
1981             ld_place_section(ofl, isec, NULL, ld_targ.t_id.id_hash, NULL);
1982         if (ofl->ofl_oshash == (Os_desc *)S_ERROR)
1983                 return (S_ERROR);
1984 
1985         /*
1986          * Calculate the number of output hash buckets.
1987          */
1988         ofl->ofl_hashbkts = findprime(nsyms);
1989 
1990         /*
1991          * The size of the hash table is determined by
1992          *
1993          *      i.      the initial nbucket and nchain entries (2)
1994          *      ii.     the number of buckets (calculated above)
1995          *      iii.    the number of chains (this is based on the number of
1996          *              symbols in the .dynsym array).
1997          */
1998         cnt = 2 + ofl->ofl_hashbkts + DYNSYM_ALL_CNT(ofl);
1999         size = cnt * shdr->sh_entsize;
2000 
2001         /*
2002          * Finalize the section header and data buffer initialization.
2003          */
2004         if ((data->d_buf = libld_calloc(size, 1)) == NULL)
2005                 return (S_ERROR);
2006         data->d_size = size;
2007         shdr->sh_size = (Xword)size;
2008 
2009         return (1);
2010 }
2011 
2012 /*
2013  * Generate the standard symbol table.  Contains all locals and globals,
2014  * and resides in a non-allocatable section (ie. it can be stripped).
2015  */
2016 static uintptr_t
2017 make_symtab(Ofl_desc *ofl)
2018 {
2019         Shdr            *shdr;
2020         Elf_Data        *data;
2021         Is_desc         *isec;
2022         Is_desc         *xisec = 0;
2023         size_t          size;
2024         Word            symcnt;
2025 
2026         /*
2027          * Create the section headers. Note that we supply an ent_cnt
2028          * of 0. We won't know the count until the section has been placed.
2029          */
2030         if (new_section(ofl, SHT_SYMTAB, MSG_ORIG(MSG_SCN_SYMTAB), 0,
2031             &isec, &shdr, &data) == S_ERROR)
2032                 return (S_ERROR);
2033 
2034         /*
2035          * Place the section first since it will affect the local symbol
2036          * count.
2037          */
2038         if ((ofl->ofl_ossymtab = ld_place_section(ofl, isec, NULL,
2039             ld_targ.t_id.id_symtab, NULL)) == (Os_desc *)S_ERROR)
2040                 return (S_ERROR);
2041 
2042         /*
2043          * At this point we've created all but the 'shstrtab' section.
2044          * Determine if we have to use 'Extended Sections'.  If so - then
2045          * also create a SHT_SYMTAB_SHNDX section.
2046          */
2047         if ((ofl->ofl_shdrcnt + 1) >= SHN_LORESERVE) {
2048                 Shdr            *xshdr;
2049                 Elf_Data        *xdata;
2050 
2051                 if (new_section(ofl, SHT_SYMTAB_SHNDX,
2052                     MSG_ORIG(MSG_SCN_SYMTAB_SHNDX), 0, &xisec,
2053                     &xshdr, &xdata) == S_ERROR)
2054                         return (S_ERROR);
2055 
2056                 if ((ofl->ofl_ossymshndx = ld_place_section(ofl, xisec, NULL,
2057                     ld_targ.t_id.id_symtab_ndx, NULL)) == (Os_desc *)S_ERROR)
2058                         return (S_ERROR);
2059         }
2060 
2061         /*
2062          * Calculated number of symbols, which need to be augmented by
2063          * the (yet to be created) .shstrtab entry.
2064          */
2065         symcnt = (size_t)(1 + SYMTAB_ALL_CNT(ofl));
2066         size = symcnt * shdr->sh_entsize;
2067 
2068         /*
2069          * Finalize the section header and data buffer initialization.
2070          */
2071         data->d_size = size;
2072         shdr->sh_size = (Xword)size;
2073 
2074         /*
2075          * If we created a SHT_SYMTAB_SHNDX - then set it's sizes too.
2076          */
2077         if (xisec) {
2078                 size_t  xsize = symcnt * sizeof (Word);
2079 
2080                 xisec->is_indata->d_size = xsize;
2081                 xisec->is_shdr->sh_size = (Xword)xsize;
2082         }
2083 
2084         return (1);
2085 }
2086 
2087 /*
2088  * Build a dynamic symbol table. These tables reside in the text
2089  * segment of a dynamic executable or shared library.
2090  *
2091  *      .SUNW_ldynsym contains local function symbols
2092  *      .dynsym contains only globals symbols
2093  *
2094  * The two tables are created adjacent to each other, with .SUNW_ldynsym
2095  * coming first.
2096  */
2097 static uintptr_t
2098 make_dynsym(Ofl_desc *ofl)
2099 {
2100         Shdr            *shdr, *lshdr;
2101         Elf_Data        *data, *ldata;
2102         Is_desc         *isec, *lisec;
2103         size_t          size;
2104         Xword           cnt;
2105         int             allow_ldynsym;
2106 
2107         /*
2108          * Unless explicitly disabled, always produce a .SUNW_ldynsym section
2109          * when it is allowed by the file type, even if the resulting
2110          * table only ends up with a single STT_FILE in it. There are
2111          * two reasons: (1) It causes the generation of the DT_SUNW_SYMTAB
2112          * entry in the .dynamic section, which is something we would
2113          * like to encourage, and (2) Without it, we cannot generate
2114          * the associated .SUNW_dyn[sym|tls]sort sections, which are of
2115          * value to DTrace.
2116          *
2117          * In practice, it is extremely rare for an object not to have
2118          * local symbols for .SUNW_ldynsym, so 99% of the time, we'd be
2119          * doing it anyway.
2120          */
2121         allow_ldynsym = OFL_ALLOW_LDYNSYM(ofl);
2122 
2123         /*
2124          * Create the section headers. Note that we supply an ent_cnt
2125          * of 0. We won't know the count until the section has been placed.
2126          */
2127         if (allow_ldynsym && new_section(ofl, SHT_SUNW_LDYNSYM,
2128             MSG_ORIG(MSG_SCN_LDYNSYM), 0, &lisec, &lshdr, &ldata) == S_ERROR)
2129                 return (S_ERROR);
2130 
2131         if (new_section(ofl, SHT_DYNSYM, MSG_ORIG(MSG_SCN_DYNSYM), 0,
2132             &isec, &shdr, &data) == S_ERROR)
2133                 return (S_ERROR);
2134 
2135         /*
2136          * Place the section(s) first since it will affect the local symbol
2137          * count.
2138          */
2139         if (allow_ldynsym &&
2140             ((ofl->ofl_osldynsym = ld_place_section(ofl, lisec, NULL,
2141             ld_targ.t_id.id_ldynsym, NULL)) == (Os_desc *)S_ERROR))
2142                 return (S_ERROR);
2143         ofl->ofl_osdynsym =
2144             ld_place_section(ofl, isec, NULL, ld_targ.t_id.id_dynsym, NULL);
2145         if (ofl->ofl_osdynsym == (Os_desc *)S_ERROR)
2146                 return (S_ERROR);
2147 
2148         cnt = DYNSYM_ALL_CNT(ofl);
2149         size = (size_t)cnt * shdr->sh_entsize;
2150 
2151         /*
2152          * Finalize the section header and data buffer initialization.
2153          */
2154         data->d_size = size;
2155         shdr->sh_size = (Xword)size;
2156 
2157         /*
2158          * An ldynsym contains local function symbols. It is not
2159          * used for linking, but if present, serves to allow better
2160          * stack traces to be generated in contexts where the symtab
2161          * is not available. (dladdr(), or stripped executable/library files).
2162          */
2163         if (allow_ldynsym) {
2164                 cnt = 1 + ofl->ofl_dynlocscnt + ofl->ofl_dynscopecnt;
2165                 size = (size_t)cnt * shdr->sh_entsize;
2166 
2167                 ldata->d_size = size;
2168                 lshdr->sh_size = (Xword)size;
2169         }
2170 
2171         return (1);
2172 }
2173 
2174 /*
2175  * Build .SUNW_dynsymsort and/or .SUNW_dyntlssort sections. These are
2176  * index sections for the .SUNW_ldynsym/.dynsym pair that present data
2177  * and function symbols sorted by address.
2178  */
2179 static uintptr_t
2180 make_dynsort(Ofl_desc *ofl)
2181 {
2182         Shdr            *shdr;
2183         Elf_Data        *data;
2184         Is_desc         *isec;
2185 
2186         /* Only do it if the .SUNW_ldynsym section is present */
2187         if (!OFL_ALLOW_LDYNSYM(ofl))
2188                 return (1);
2189 
2190         /* .SUNW_dynsymsort */
2191         if (ofl->ofl_dynsymsortcnt > 0) {
2192                 if (new_section(ofl, SHT_SUNW_symsort,
2193                     MSG_ORIG(MSG_SCN_DYNSYMSORT), ofl->ofl_dynsymsortcnt,
2194                     &isec, &shdr, &data) == S_ERROR)
2195                 return (S_ERROR);
2196 
2197                 if ((ofl->ofl_osdynsymsort = ld_place_section(ofl, isec, NULL,
2198                     ld_targ.t_id.id_dynsort, NULL)) == (Os_desc *)S_ERROR)
2199                         return (S_ERROR);
2200         }
2201 
2202         /* .SUNW_dyntlssort */
2203         if (ofl->ofl_dyntlssortcnt > 0) {
2204                 if (new_section(ofl, SHT_SUNW_tlssort,
2205                     MSG_ORIG(MSG_SCN_DYNTLSSORT),
2206                     ofl->ofl_dyntlssortcnt, &isec, &shdr, &data) == S_ERROR)
2207                 return (S_ERROR);
2208 
2209                 if ((ofl->ofl_osdyntlssort = ld_place_section(ofl, isec, NULL,
2210                     ld_targ.t_id.id_dynsort, NULL)) == (Os_desc *)S_ERROR)
2211                         return (S_ERROR);
2212         }
2213 
2214         return (1);
2215 }
2216 
2217 /*
2218  * Helper routine for make_dynsym_shndx. Builds a
2219  * a SHT_SYMTAB_SHNDX for .dynsym or .SUNW_ldynsym, without knowing
2220  * which one it is.
2221  */
2222 static uintptr_t
2223 make_dyn_shndx(Ofl_desc *ofl, const char *shname, Os_desc *symtab,
2224     Os_desc **ret_os)
2225 {
2226         Is_desc         *isec;
2227         Is_desc         *dynsymisp;
2228         Shdr            *shdr, *dynshdr;
2229         Elf_Data        *data;
2230 
2231         dynsymisp = ld_os_first_isdesc(symtab);
2232         dynshdr = dynsymisp->is_shdr;
2233 
2234         if (new_section(ofl, SHT_SYMTAB_SHNDX, shname,
2235             (dynshdr->sh_size / dynshdr->sh_entsize),
2236             &isec, &shdr, &data) == S_ERROR)
2237                 return (S_ERROR);
2238 
2239         if ((*ret_os = ld_place_section(ofl, isec, NULL,
2240             ld_targ.t_id.id_dynsym_ndx, NULL)) == (Os_desc *)S_ERROR)
2241                 return (S_ERROR);
2242 
2243         assert(*ret_os);
2244 
2245         return (1);
2246 }
2247 
2248 /*
2249  * Build a SHT_SYMTAB_SHNDX for the .dynsym, and .SUNW_ldynsym
2250  */
2251 static uintptr_t
2252 make_dynsym_shndx(Ofl_desc *ofl)
2253 {
2254         /*
2255          * If there is a .SUNW_ldynsym, generate a section for its extended
2256          * index section as well.
2257          */
2258         if (OFL_ALLOW_LDYNSYM(ofl)) {
2259                 if (make_dyn_shndx(ofl, MSG_ORIG(MSG_SCN_LDYNSYM_SHNDX),
2260                     ofl->ofl_osldynsym, &ofl->ofl_osldynshndx) == S_ERROR)
2261                         return (S_ERROR);
2262         }
2263 
2264         /* The Generate a section for the dynsym */
2265         if (make_dyn_shndx(ofl, MSG_ORIG(MSG_SCN_DYNSYM_SHNDX),
2266             ofl->ofl_osdynsym, &ofl->ofl_osdynshndx) == S_ERROR)
2267                 return (S_ERROR);
2268 
2269         return (1);
2270 }
2271 
2272 
2273 /*
2274  * Build a string table for the section headers.
2275  */
2276 static uintptr_t
2277 make_shstrtab(Ofl_desc *ofl)
2278 {
2279         Shdr            *shdr;
2280         Elf_Data        *data;
2281         Is_desc         *isec;
2282         size_t          size;
2283 
2284         if (new_section(ofl, SHT_STRTAB, MSG_ORIG(MSG_SCN_SHSTRTAB),
2285             0, &isec, &shdr, &data) == S_ERROR)
2286                 return (S_ERROR);
2287 
2288         /*
2289          * Place the section first, as it may effect the number of section
2290          * headers to account for.
2291          */
2292         ofl->ofl_osshstrtab =
2293             ld_place_section(ofl, isec, NULL, ld_targ.t_id.id_note, NULL);
2294         if (ofl->ofl_osshstrtab == (Os_desc *)S_ERROR)
2295                 return (S_ERROR);
2296 
2297         size = st_getstrtab_sz(ofl->ofl_shdrsttab);
2298         assert(size > 0);
2299 
2300         data->d_size = size;
2301         shdr->sh_size = (Xword)size;
2302 
2303         return (1);
2304 }
2305 
2306 /*
2307  * Build a string section for the standard symbol table.
2308  */
2309 static uintptr_t
2310 make_strtab(Ofl_desc *ofl)
2311 {
2312         Shdr            *shdr;
2313         Elf_Data        *data;
2314         Is_desc         *isec;
2315         size_t          size;
2316 
2317         /*
2318          * This string table consists of all the global and local symbols.
2319          * Account for null bytes at end of the file name and the beginning
2320          * of section.
2321          */
2322         if (st_insert(ofl->ofl_strtab, ofl->ofl_name) == -1)
2323                 return (S_ERROR);
2324 
2325         size = st_getstrtab_sz(ofl->ofl_strtab);
2326         assert(size > 0);
2327 
2328         if (new_section(ofl, SHT_STRTAB, MSG_ORIG(MSG_SCN_STRTAB),
2329             0, &isec, &shdr, &data) == S_ERROR)
2330                 return (S_ERROR);
2331 
2332         /* Set the size of the data area */
2333         data->d_size = size;
2334         shdr->sh_size = (Xword)size;
2335 
2336         ofl->ofl_osstrtab =
2337             ld_place_section(ofl, isec, NULL, ld_targ.t_id.id_strtab, NULL);
2338         return ((uintptr_t)ofl->ofl_osstrtab);
2339 }
2340 
2341 /*
2342  * Build a string table for the dynamic symbol table.
2343  */
2344 static uintptr_t
2345 make_dynstr(Ofl_desc *ofl)
2346 {
2347         Shdr            *shdr;
2348         Elf_Data        *data;
2349         Is_desc         *isec;
2350         size_t          size;
2351 
2352         /*
2353          * If producing a .SUNW_ldynsym, account for the initial STT_FILE
2354          * symbol that precedes the scope reduced global symbols.
2355          */
2356         if (OFL_ALLOW_LDYNSYM(ofl)) {
2357                 if (st_insert(ofl->ofl_dynstrtab, ofl->ofl_name) == -1)
2358                         return (S_ERROR);
2359                 ofl->ofl_dynscopecnt++;
2360         }
2361 
2362         /*
2363          * Account for any local, named register symbols.  These locals are
2364          * required for reference from DT_REGISTER .dynamic entries.
2365          */
2366         if (ofl->ofl_regsyms) {
2367                 int     ndx;
2368 
2369                 for (ndx = 0; ndx < ofl->ofl_regsymsno; ndx++) {
2370                         Sym_desc        *sdp;
2371 
2372                         if ((sdp = ofl->ofl_regsyms[ndx]) == NULL)
2373                                 continue;
2374 
2375                         if (!SYM_IS_HIDDEN(sdp) &&
2376                             (ELF_ST_BIND(sdp->sd_sym->st_info) != STB_LOCAL))
2377                                 continue;
2378 
2379                         if (sdp->sd_sym->st_name == NULL)
2380                                 continue;
2381 
2382                         if (st_insert(ofl->ofl_dynstrtab, sdp->sd_name) == -1)
2383                                 return (S_ERROR);
2384                 }
2385         }
2386 
2387         /*
2388          * Reserve entries for any per-symbol auxiliary/filter strings.
2389          */
2390         if (ofl->ofl_dtsfltrs != NULL) {
2391                 Dfltr_desc      *dftp;
2392                 Aliste          idx;
2393 
2394                 for (ALIST_TRAVERSE(ofl->ofl_dtsfltrs, idx, dftp))
2395                         if (st_insert(ofl->ofl_dynstrtab, dftp->dft_str) == -1)
2396                                 return (S_ERROR);
2397         }
2398 
2399         size = st_getstrtab_sz(ofl->ofl_dynstrtab);
2400         assert(size > 0);
2401 
2402         if (new_section(ofl, SHT_STRTAB, MSG_ORIG(MSG_SCN_DYNSTR),
2403             0, &isec, &shdr, &data) == S_ERROR)
2404                 return (S_ERROR);
2405 
2406         /* Make it allocable if necessary */
2407         if (!(ofl->ofl_flags & FLG_OF_RELOBJ))
2408                 shdr->sh_flags |= SHF_ALLOC;
2409 
2410         /* Set the size of the data area */
2411         data->d_size = size + DYNSTR_EXTRA_PAD;
2412 
2413         shdr->sh_size = (Xword)size;
2414 
2415         ofl->ofl_osdynstr =
2416             ld_place_section(ofl, isec, NULL, ld_targ.t_id.id_dynstr, NULL);
2417         return ((uintptr_t)ofl->ofl_osdynstr);
2418 }
2419 
2420 /*
2421  * Generate an output relocation section which will contain the relocation
2422  * information to be applied to the `osp' section.
2423  *
2424  * If (osp == NULL) then we are creating the coalesced relocation section
2425  * for an executable and/or a shared object.
2426  */
2427 static uintptr_t
2428 make_reloc(Ofl_desc *ofl, Os_desc *osp)
2429 {
2430         Shdr            *shdr;
2431         Elf_Data        *data;
2432         Is_desc         *isec;
2433         size_t          size;
2434         Xword           sh_flags;
2435         char            *sectname;
2436         Os_desc         *rosp;
2437         Word            relsize;
2438         const char      *rel_prefix;
2439 
2440         /* LINTED */
2441         if (ld_targ.t_m.m_rel_sht_type == SHT_REL) {
2442                 /* REL */
2443                 relsize = sizeof (Rel);
2444                 rel_prefix = MSG_ORIG(MSG_SCN_REL);
2445         } else {
2446                 /* RELA */
2447                 relsize = sizeof (Rela);
2448                 rel_prefix = MSG_ORIG(MSG_SCN_RELA);
2449         }
2450 
2451         if (osp) {
2452                 size = osp->os_szoutrels;
2453                 sh_flags = osp->os_shdr->sh_flags;
2454                 if ((sectname = libld_malloc(strlen(rel_prefix) +
2455                     strlen(osp->os_name) + 1)) == 0)
2456                         return (S_ERROR);
2457                 (void) strcpy(sectname, rel_prefix);
2458                 (void) strcat(sectname, osp->os_name);
2459         } else if (ofl->ofl_flags & FLG_OF_COMREL) {
2460                 size = (ofl->ofl_reloccnt - ofl->ofl_reloccntsub) * relsize;
2461                 sh_flags = SHF_ALLOC;
2462                 sectname = (char *)MSG_ORIG(MSG_SCN_SUNWRELOC);
2463         } else {
2464                 size = ofl->ofl_relocrelsz;
2465                 sh_flags = SHF_ALLOC;
2466                 sectname = (char *)rel_prefix;
2467         }
2468 
2469         /*
2470          * Keep track of total size of 'output relocations' (to be stored
2471          * in .dynamic)
2472          */
2473         /* LINTED */
2474         ofl->ofl_relocsz += (Xword)size;
2475 
2476         if (new_section(ofl, ld_targ.t_m.m_rel_sht_type, sectname, 0, &isec,
2477             &shdr, &data) == S_ERROR)
2478                 return (S_ERROR);
2479 
2480         data->d_size = size;
2481 
2482         shdr->sh_size = (Xword)size;
2483         if (OFL_ALLOW_DYNSYM(ofl) && (sh_flags & SHF_ALLOC))
2484                 shdr->sh_flags = SHF_ALLOC;
2485 
2486         if (osp) {
2487                 /*
2488                  * The sh_info field of the SHT_REL* sections points to the
2489                  * section the relocations are to be applied to.
2490                  */
2491                 shdr->sh_flags |= SHF_INFO_LINK;
2492         }
2493 
2494         rosp = ld_place_section(ofl, isec, NULL, ld_targ.t_id.id_rel, NULL);
2495         if (rosp == (Os_desc *)S_ERROR)
2496                 return (S_ERROR);
2497 
2498         /*
2499          * Associate this relocation section to the section its going to
2500          * relocate.
2501          */
2502         if (osp) {
2503                 Aliste  idx;
2504                 Is_desc *risp;
2505 
2506                 /*
2507                  * This is used primarily so that we can update
2508                  * SHT_GROUP[sect_no] entries to point to the
2509                  * created output relocation sections.
2510                  */
2511                 for (APLIST_TRAVERSE(osp->os_relisdescs, idx, risp)) {
2512                         risp->is_osdesc = rosp;
2513 
2514                         /*
2515                          * If the input relocation section had the SHF_GROUP
2516                          * flag set - propagate it to the output relocation
2517                          * section.
2518                          */
2519                         if (risp->is_shdr->sh_flags & SHF_GROUP) {
2520                                 rosp->os_shdr->sh_flags |= SHF_GROUP;
2521                                 break;
2522                         }
2523                 }
2524                 osp->os_relosdesc = rosp;
2525         } else
2526                 ofl->ofl_osrel = rosp;
2527 
2528         /*
2529          * If this is the first relocation section we've encountered save it
2530          * so that the .dynamic entry can be initialized accordingly.
2531          */
2532         if (ofl->ofl_osrelhead == (Os_desc *)0)
2533                 ofl->ofl_osrelhead = rosp;
2534 
2535         return (1);
2536 }
2537 
2538 /*
2539  * Generate version needed section.
2540  */
2541 static uintptr_t
2542 make_verneed(Ofl_desc *ofl)
2543 {
2544         Shdr            *shdr;
2545         Elf_Data        *data;
2546         Is_desc         *isec;
2547 
2548         /*
2549          * verneed sections do not have a constant element size, so the
2550          * value of ent_cnt specified here (0) is meaningless.
2551          */
2552         if (new_section(ofl, SHT_SUNW_verneed, MSG_ORIG(MSG_SCN_SUNWVERSION),
2553             0, &isec, &shdr, &data) == S_ERROR)
2554                 return (S_ERROR);
2555 
2556         /* During version processing we calculated the total size. */
2557         data->d_size = ofl->ofl_verneedsz;
2558         shdr->sh_size = (Xword)ofl->ofl_verneedsz;
2559 
2560         ofl->ofl_osverneed =
2561             ld_place_section(ofl, isec, NULL, ld_targ.t_id.id_version, NULL);
2562         return ((uintptr_t)ofl->ofl_osverneed);
2563 }
2564 
2565 /*
2566  * Generate a version definition section.
2567  *
2568  *  o   the SHT_SUNW_verdef section defines the versions that exist within this
2569  *      image.
2570  */
2571 static uintptr_t
2572 make_verdef(Ofl_desc *ofl)
2573 {
2574         Shdr            *shdr;
2575         Elf_Data        *data;
2576         Is_desc         *isec;
2577         Ver_desc        *vdp;
2578         Str_tbl         *strtab;
2579 
2580         /*
2581          * Reserve a string table entry for the base version dependency (other
2582          * dependencies have symbol representations, which will already be
2583          * accounted for during symbol processing).
2584          */
2585         vdp = (Ver_desc *)ofl->ofl_verdesc->apl_data[0];
2586 
2587         if (OFL_IS_STATIC_OBJ(ofl))
2588                 strtab = ofl->ofl_strtab;
2589         else
2590                 strtab = ofl->ofl_dynstrtab;
2591 
2592         if (st_insert(strtab, vdp->vd_name) == -1)
2593                 return (S_ERROR);
2594 
2595         /*
2596          * verdef sections do not have a constant element size, so the
2597          * value of ent_cnt specified here (0) is meaningless.
2598          */
2599         if (new_section(ofl, SHT_SUNW_verdef, MSG_ORIG(MSG_SCN_SUNWVERSION),
2600             0, &isec, &shdr, &data) == S_ERROR)
2601                 return (S_ERROR);
2602 
2603         /* During version processing we calculated the total size. */
2604         data->d_size = ofl->ofl_verdefsz;
2605         shdr->sh_size = (Xword)ofl->ofl_verdefsz;
2606 
2607         ofl->ofl_osverdef =
2608             ld_place_section(ofl, isec, NULL, ld_targ.t_id.id_version, NULL);
2609         return ((uintptr_t)ofl->ofl_osverdef);
2610 }
2611 
2612 /*
2613  * This routine is called when -z nopartial is in effect.
2614  */
2615 uintptr_t
2616 ld_make_parexpn_data(Ofl_desc *ofl, size_t size, Xword align)
2617 {
2618         Shdr            *shdr;
2619         Elf_Data        *data;
2620         Is_desc         *isec;
2621         Os_desc         *osp;
2622 
2623         if (new_section(ofl, SHT_PROGBITS, MSG_ORIG(MSG_SCN_DATA), 0,
2624             &isec, &shdr, &data) == S_ERROR)
2625                 return (S_ERROR);
2626 
2627         shdr->sh_flags |= SHF_WRITE;
2628         data->d_size = size;
2629         shdr->sh_size = (Xword)size;
2630         if (align != 0) {
2631                 data->d_align = align;
2632                 shdr->sh_addralign = align;
2633         }
2634 
2635         if ((data->d_buf = libld_calloc(size, 1)) == NULL)
2636                 return (S_ERROR);
2637 
2638         /*
2639          * Retain handle to this .data input section. Variables using move
2640          * sections (partial initialization) will be redirected here when
2641          * such global references are added and '-z nopartial' is in effect.
2642          */
2643         ofl->ofl_isparexpn = isec;
2644         osp = ld_place_section(ofl, isec, NULL, ld_targ.t_id.id_data, NULL);
2645         if (osp == (Os_desc *)S_ERROR)
2646                 return (S_ERROR);
2647 
2648         if (!(osp->os_flags & FLG_OS_OUTREL)) {
2649                 ofl->ofl_dynshdrcnt++;
2650                 osp->os_flags |= FLG_OS_OUTREL;
2651         }
2652         return (1);
2653 }
2654 
2655 /*
2656  * Make .sunwmove section
2657  */
2658 uintptr_t
2659 ld_make_sunwmove(Ofl_desc *ofl, int mv_nums)
2660 {
2661         Shdr            *shdr;
2662         Elf_Data        *data;
2663         Is_desc         *isec;
2664         Aliste          idx;
2665         Sym_desc        *sdp;
2666         int             cnt = 1;
2667 
2668 
2669         if (new_section(ofl, SHT_SUNW_move, MSG_ORIG(MSG_SCN_SUNWMOVE),
2670             mv_nums, &isec, &shdr, &data) == S_ERROR)
2671                 return (S_ERROR);
2672 
2673         if ((data->d_buf = libld_calloc(data->d_size, 1)) == NULL)
2674                 return (S_ERROR);
2675 
2676         /*
2677          * Copy move entries
2678          */
2679         for (APLIST_TRAVERSE(ofl->ofl_parsyms, idx, sdp)) {
2680                 Aliste          idx2;
2681                 Mv_desc         *mdp;
2682 
2683                 if (sdp->sd_flags & FLG_SY_PAREXPN)
2684                         continue;
2685 
2686                 for (ALIST_TRAVERSE(sdp->sd_move, idx2, mdp))
2687                         mdp->md_oidx = cnt++;
2688         }
2689 
2690         if ((ofl->ofl_osmove = ld_place_section(ofl, isec, NULL, 0, NULL)) ==
2691             (Os_desc *)S_ERROR)
2692                 return (S_ERROR);
2693 
2694         return (1);
2695 }
2696 
2697 /*
2698  * Given a relocation descriptor that references a string table
2699  * input section, locate the string referenced and return a pointer
2700  * to it.
2701  */
2702 static const char *
2703 strmerge_get_reloc_str(Ofl_desc *ofl, Rel_desc *rsp)
2704 {
2705         Sym_desc *sdp = rsp->rel_sym;
2706         Xword    str_off;
2707 
2708         /*
2709          * In the case of an STT_SECTION symbol, the addend of the
2710          * relocation gives the offset into the string section. For
2711          * other symbol types, the symbol value is the offset.
2712          */
2713 
2714         if (ELF_ST_TYPE(sdp->sd_sym->st_info) != STT_SECTION) {
2715                 str_off = sdp->sd_sym->st_value;
2716         } else if ((rsp->rel_flags & FLG_REL_RELA) == FLG_REL_RELA) {
2717                 /*
2718                  * For SHT_RELA, the addend value is found in the
2719                  * rel_raddend field of the relocation.
2720                  */
2721                 str_off = rsp->rel_raddend;
2722         } else {        /* REL and STT_SECTION */
2723                 /*
2724                  * For SHT_REL, the "addend" is not part of the relocation
2725                  * record. Instead, it is found at the relocation target
2726                  * address.
2727                  */
2728                 uchar_t *addr = (uchar_t *)((uintptr_t)rsp->rel_roffset +
2729                     (uintptr_t)rsp->rel_isdesc->is_indata->d_buf);
2730 
2731                 if (ld_reloc_targval_get(ofl, rsp, addr, &str_off) == 0)
2732                         return (0);
2733         }
2734 
2735         return (str_off + (char *)sdp->sd_isc->is_indata->d_buf);
2736 }
2737 
2738 /*
2739  * First pass over the relocation records for string table merging.
2740  * Build lists of relocations and symbols that will need modification,
2741  * and insert the strings they reference into the mstrtab string table.
2742  *
2743  * entry:
2744  *      ofl, osp - As passed to ld_make_strmerge().
2745  *      mstrtab - String table to receive input strings. This table
2746  *              must be in its first (initialization) pass and not
2747  *              yet cooked (st_getstrtab_sz() not yet called).
2748  *      rel_alpp - APlist to receive pointer to any relocation
2749  *              descriptors with STT_SECTION symbols that reference
2750  *              one of the input sections being merged.
2751  *      sym_alpp - APlist to receive pointer to any symbols that reference
2752  *              one of the input sections being merged.
2753  *      rcp - Pointer to cache of relocation descriptors to examine.
2754  *              Either &ofl->ofl_actrels (active relocations)
2755  *              or &ofl->ofl_outrels (output relocations).
2756  *
2757  * exit:
2758  *      On success, rel_alpp and sym_alpp are updated, and
2759  *      any strings in the mergeable input sections referenced by
2760  *      a relocation has been entered into mstrtab. True (1) is returned.
2761  *
2762  *      On failure, False (0) is returned.
2763  */
2764 static int
2765 strmerge_pass1(Ofl_desc *ofl, Os_desc *osp, Str_tbl *mstrtab,
2766     APlist **rel_alpp, APlist **sym_alpp, Rel_cache *rcp)
2767 {
2768         Aliste          idx;
2769         Rel_cachebuf    *rcbp;
2770         Sym_desc        *sdp;
2771         Sym_desc        *last_sdp = NULL;
2772         Rel_desc        *rsp;
2773         const char      *name;
2774 
2775         REL_CACHE_TRAVERSE(rcp, idx, rcbp, rsp) {
2776                 sdp = rsp->rel_sym;
2777                 if ((sdp->sd_isc == NULL) || ((sdp->sd_isc->is_flags &
2778                     (FLG_IS_DISCARD | FLG_IS_INSTRMRG)) != FLG_IS_INSTRMRG) ||
2779                     (sdp->sd_isc->is_osdesc != osp))
2780                         continue;
2781 
2782                 /*
2783                  * Remember symbol for use in the third pass. There is no
2784                  * reason to save a given symbol more than once, so we take
2785                  * advantage of the fact that relocations to a given symbol
2786                  * tend to cluster in the list. If this is the same symbol
2787                  * we saved last time, don't bother.
2788                  */
2789                 if (last_sdp != sdp) {
2790                         if (aplist_append(sym_alpp, sdp, AL_CNT_STRMRGSYM) ==
2791                             NULL)
2792                                 return (0);
2793                         last_sdp = sdp;
2794                 }
2795 
2796                 /* Enter the string into our new string table */
2797                 name = strmerge_get_reloc_str(ofl, rsp);
2798                 if (st_insert(mstrtab, name) == -1)
2799                         return (0);
2800 
2801                 /*
2802                  * If this is an STT_SECTION symbol, then the second pass
2803                  * will need to modify this relocation, so hang on to it.
2804                  */
2805                 if ((ELF_ST_TYPE(sdp->sd_sym->st_info) == STT_SECTION) &&
2806                     (aplist_append(rel_alpp, rsp, AL_CNT_STRMRGREL) == NULL))
2807                         return (0);
2808         }
2809 
2810         return (1);
2811 }
2812 
2813 /*
2814  * If the output section has any SHF_MERGE|SHF_STRINGS input sections,
2815  * replace them with a single merged/compressed input section.
2816  *
2817  * entry:
2818  *      ofl - Output file descriptor
2819  *      osp - Output section descriptor
2820  *      rel_alpp, sym_alpp, - Address of 2 APlists, to be used
2821  *              for internal processing. On the initial call to
2822  *              ld_make_strmerge, these list pointers must be NULL.
2823  *              The caller is encouraged to pass the same lists back for
2824  *              successive calls to this function without freeing
2825  *              them in between calls. This causes a single pair of
2826  *              memory allocations to be reused multiple times.
2827  *
2828  * exit:
2829  *      If section merging is possible, it is done. If no errors are
2830  *      encountered, True (1) is returned. On error, S_ERROR.
2831  *
2832  *      The contents of rel_alpp and sym_alpp on exit are
2833  *      undefined. The caller can free them, or pass them back to a subsequent
2834  *      call to this routine, but should not examine their contents.
2835  */
2836 static uintptr_t
2837 ld_make_strmerge(Ofl_desc *ofl, Os_desc *osp, APlist **rel_alpp,
2838     APlist **sym_alpp)
2839 {
2840         Str_tbl         *mstrtab;       /* string table for string merge secs */
2841         Is_desc         *mstrsec;       /* Generated string merge section */
2842         Is_desc         *isp;
2843         Shdr            *mstr_shdr;
2844         Elf_Data        *mstr_data;
2845         Sym_desc        *sdp;
2846         Rel_desc        *rsp;
2847         Aliste          idx;
2848         size_t          data_size;
2849         int             st_setstring_status;
2850         size_t          stoff;
2851 
2852         /* If string table compression is disabled, there's nothing to do */
2853         if ((ofl->ofl_flags1 & FLG_OF1_NCSTTAB) != 0)
2854                 return (1);
2855 
2856         /*
2857          * Pass over the mergeable input sections, and if they haven't
2858          * all been discarded, create a string table.
2859          */
2860         mstrtab = NULL;
2861         for (APLIST_TRAVERSE(osp->os_mstrisdescs, idx, isp)) {
2862                 if (isdesc_discarded(isp))
2863                         continue;
2864 
2865                 /*
2866                  * Input sections of 0 size are dubiously valid since they do
2867                  * not even contain the NUL string.  Ignore them.
2868                  */
2869                 if (isp->is_shdr->sh_size == 0)
2870                         continue;
2871 
2872                 /*
2873                  * We have at least one non-discarded section.
2874                  * Create a string table descriptor.
2875                  */
2876                 if ((mstrtab = st_new(FLG_STNEW_COMPRESS)) == NULL)
2877                         return (S_ERROR);
2878                 break;
2879         }
2880 
2881         /* If no string table was created, we have no mergeable sections */
2882         if (mstrtab == NULL)
2883                 return (1);
2884 
2885         /*
2886          * This routine has to make 3 passes:
2887          *
2888          *      1) Examine all relocations, insert strings from relocations
2889          *              to the mergeable input sections into the string table.
2890          *      2) Modify the relocation values to be correct for the
2891          *              new merged section.
2892          *      3) Modify the symbols used by the relocations to reference
2893          *              the new section.
2894          *
2895          * These passes cannot be combined:
2896          *      - The string table code works in two passes, and all
2897          *              strings have to be loaded in pass one before the
2898          *              offset of any strings can be determined.
2899          *      - Multiple relocations reference a single symbol, so the
2900          *              symbol cannot be modified until all relocations are
2901          *              fixed.
2902          *
2903          * The number of relocations related to section merging is usually
2904          * a mere fraction of the overall active and output relocation lists,
2905          * and the number of symbols is usually a fraction of the number
2906          * of related relocations. We therefore build APlists for the
2907          * relocations and symbols in the first pass, and then use those
2908          * lists to accelerate the operation of pass 2 and 3.
2909          *
2910          * Reinitialize the lists to a completely empty state.
2911          */
2912         aplist_reset(*rel_alpp);
2913         aplist_reset(*sym_alpp);
2914 
2915         /*
2916          * Pass 1:
2917          *
2918          * Every relocation related to this output section (and the input
2919          * sections that make it up) is found in either the active, or the
2920          * output relocation list, depending on whether the relocation is to
2921          * be processed by this invocation of the linker, or inserted into the
2922          * output object.
2923          *
2924          * Build lists of relocations and symbols that will need modification,
2925          * and insert the strings they reference into the mstrtab string table.
2926          */
2927         if (strmerge_pass1(ofl, osp, mstrtab, rel_alpp, sym_alpp,
2928             &ofl->ofl_actrels) == 0)
2929                 goto return_s_error;
2930         if (strmerge_pass1(ofl, osp, mstrtab, rel_alpp, sym_alpp,
2931             &ofl->ofl_outrels) == 0)
2932                 goto return_s_error;
2933 
2934         /*
2935          * Get the size of the new input section. Requesting the
2936          * string table size "cooks" the table, and finalizes its contents.
2937          */
2938         data_size = st_getstrtab_sz(mstrtab);
2939 
2940         /* Create a new input section to hold the merged strings */
2941         if (new_section_from_template(ofl, isp, data_size,
2942             &mstrsec, &mstr_shdr, &mstr_data) == S_ERROR)
2943                 goto return_s_error;
2944         mstrsec->is_flags |= FLG_IS_GNSTRMRG;
2945 
2946         /*
2947          * Allocate a data buffer for the new input section.
2948          * Then, associate the buffer with the string table descriptor.
2949          */
2950         if ((mstr_data->d_buf = libld_malloc(data_size)) == NULL)
2951                 goto return_s_error;
2952         if (st_setstrbuf(mstrtab, mstr_data->d_buf, data_size) == -1)
2953                 goto return_s_error;
2954 
2955         /* Add the new section to the output image */
2956         if (ld_place_section(ofl, mstrsec, NULL, osp->os_identndx, NULL) ==
2957             (Os_desc *)S_ERROR)
2958                 goto return_s_error;
2959 
2960         /*
2961          * Pass 2:
2962          *
2963          * Revisit the relocation descriptors with STT_SECTION symbols
2964          * that were saved by the first pass. Update each relocation
2965          * record so that the offset it contains is for the new section
2966          * instead of the original.
2967          */
2968         for (APLIST_TRAVERSE(*rel_alpp, idx, rsp)) {
2969                 const char      *name;
2970 
2971                 /* Put the string into the merged string table */
2972                 name = strmerge_get_reloc_str(ofl, rsp);
2973                 st_setstring_status = st_setstring(mstrtab, name, &stoff);
2974                 if (st_setstring_status == -1) {
2975                         /*
2976                          * A failure to insert at this point means that
2977                          * something is corrupt. This isn't a resource issue.
2978                          */
2979                         assert(st_setstring_status != -1);
2980                         goto return_s_error;
2981                 }
2982 
2983                 /*
2984                  * Alter the relocation to access the string at the
2985                  * new offset in our new string table.
2986                  *
2987                  * For SHT_RELA platforms, it suffices to simply
2988                  * update the rel_raddend field of the relocation.
2989                  *
2990                  * For SHT_REL platforms, the new "addend" value
2991                  * needs to be written at the address being relocated.
2992                  * However, we can't alter the input sections which
2993                  * are mapped readonly, and the output image has not
2994                  * been created yet. So, we defer this operation,
2995                  * using the rel_raddend field of the relocation
2996                  * which is normally 0 on a REL platform, to pass the
2997                  * new "addend" value to ld_perform_outreloc() or
2998                  * ld_do_activerelocs(). The FLG_REL_NADDEND flag
2999                  * tells them that this is the case.
3000                  */
3001                 if ((rsp->rel_flags & FLG_REL_RELA) == 0)   /* REL */
3002                         rsp->rel_flags |= FLG_REL_NADDEND;
3003                 rsp->rel_raddend = (Sxword)stoff;
3004 
3005                 /*
3006                  * Generate a symbol name string for STT_SECTION symbols
3007                  * that might reference our merged section. This shows up
3008                  * in debug output and helps show how the relocation has
3009                  * changed from its original input section to our merged one.
3010                  */
3011                 if (ld_stt_section_sym_name(mstrsec) == NULL)
3012                         goto return_s_error;
3013         }
3014 
3015         /*
3016          * Pass 3:
3017          *
3018          * Modify the symbols referenced by the relocation descriptors
3019          * so that they reference the new input section containing the
3020          * merged strings instead of the original input sections.
3021          */
3022         for (APLIST_TRAVERSE(*sym_alpp, idx, sdp)) {
3023                 /*
3024                  * If we've already processed this symbol, don't do it
3025                  * twice. strmerge_pass1() uses a heuristic (relocations to
3026                  * the same symbol clump together) to avoid inserting a
3027                  * given symbol more than once, but repeat symbols in
3028                  * the list can occur.
3029                  */
3030                 if ((sdp->sd_isc->is_flags & FLG_IS_INSTRMRG) == 0)
3031                         continue;
3032 
3033                 if (ELF_ST_TYPE(sdp->sd_sym->st_info) != STT_SECTION) {
3034                         /*
3035                          * This is not an STT_SECTION symbol, so its
3036                          * value is the offset of the string within the
3037                          * input section. Update the address to reflect
3038                          * the address in our new merged section.
3039                          */
3040                         const char *name = sdp->sd_sym->st_value +
3041                             (char *)sdp->sd_isc->is_indata->d_buf;
3042 
3043                         st_setstring_status =
3044                             st_setstring(mstrtab, name, &stoff);
3045                         if (st_setstring_status == -1) {
3046                                 /*
3047                                  * A failure to insert at this point means
3048                                  * something is corrupt. This isn't a
3049                                  * resource issue.
3050                                  */
3051                                 assert(st_setstring_status != -1);
3052                                 goto return_s_error;
3053                         }
3054 
3055                         if (ld_sym_copy(sdp) == S_ERROR)
3056                                 goto return_s_error;
3057                         sdp->sd_sym->st_value = (Word)stoff;
3058                 }
3059 
3060                 /* Redirect the symbol to our new merged section */
3061                 sdp->sd_isc = mstrsec;
3062         }
3063 
3064         /*
3065          * There are no references left to the original input string sections.
3066          * Mark them as discarded so they don't go into the output image.
3067          * At the same time, add up the sizes of the replaced sections.
3068          */
3069         data_size = 0;
3070         for (APLIST_TRAVERSE(osp->os_mstrisdescs, idx, isp)) {
3071                 if (isp->is_flags & (FLG_IS_DISCARD | FLG_IS_GNSTRMRG))
3072                         continue;
3073 
3074                 data_size += isp->is_indata->d_size;
3075 
3076                 isp->is_flags |= FLG_IS_DISCARD;
3077                 DBG_CALL(Dbg_sec_discarded(ofl->ofl_lml, isp, mstrsec));
3078         }
3079 
3080         /* Report how much space we saved in the output section */
3081         DBG_CALL(Dbg_sec_genstr_compress(ofl->ofl_lml, osp->os_name, data_size,
3082             mstr_data->d_size));
3083 
3084         st_destroy(mstrtab);
3085         return (1);
3086 
3087 return_s_error:
3088         st_destroy(mstrtab);
3089         return (S_ERROR);
3090 }
3091 
3092 /*
3093  * Update a data buffers size.  A number of sections have to be created, and
3094  * the sections header contributes to the size of the eventual section.  Thus,
3095  * a section may be created, and once all associated sections have been created,
3096  * we return to establish the required section size.
3097  */
3098 inline static void
3099 update_data_size(Os_desc *osp, ulong_t cnt)
3100 {
3101         Is_desc         *isec = ld_os_first_isdesc(osp);
3102         Elf_Data        *data = isec->is_indata;
3103         Shdr            *shdr = osp->os_shdr;
3104         size_t          size = cnt * shdr->sh_entsize;
3105 
3106         shdr->sh_size = (Xword)size;
3107         data->d_size = size;
3108 }
3109 
3110 /*
3111  * The following sections are built after all input file processing and symbol
3112  * validation has been carried out.  The order is important (because the
3113  * addition of a section adds a new symbol there is a chicken and egg problem
3114  * of maintaining the appropriate counts).  By maintaining a known order the
3115  * individual routines can compensate for later, known, additions.
3116  */
3117 uintptr_t
3118 ld_make_sections(Ofl_desc *ofl)
3119 {
3120         ofl_flag_t      flags = ofl->ofl_flags;
3121         Sg_desc         *sgp;
3122 
3123         /*
3124          * Generate any special sections.
3125          */
3126         if (flags & FLG_OF_ADDVERS)
3127                 if (make_comment(ofl) == S_ERROR)
3128                         return (S_ERROR);
3129 
3130         if (make_interp(ofl) == S_ERROR)
3131                 return (S_ERROR);
3132 
3133         /*
3134          * Create a capabilities section if required.
3135          */
3136         if (make_cap(ofl, SHT_SUNW_cap, MSG_ORIG(MSG_SCN_SUNWCAP),
3137             ld_targ.t_id.id_cap) == S_ERROR)
3138                 return (S_ERROR);
3139 
3140         /*
3141          * Create any init/fini array sections.
3142          */
3143         if (make_array(ofl, SHT_INIT_ARRAY, MSG_ORIG(MSG_SCN_INITARRAY),
3144             ofl->ofl_initarray) == S_ERROR)
3145                 return (S_ERROR);
3146 
3147         if (make_array(ofl, SHT_FINI_ARRAY, MSG_ORIG(MSG_SCN_FINIARRAY),
3148             ofl->ofl_finiarray) == S_ERROR)
3149                 return (S_ERROR);
3150 
3151         if (make_array(ofl, SHT_PREINIT_ARRAY, MSG_ORIG(MSG_SCN_PREINITARRAY),
3152             ofl->ofl_preiarray) == S_ERROR)
3153                 return (S_ERROR);
3154 
3155         /*
3156          * Make the .plt section.  This occurs after any other relocation
3157          * sections are generated (see reloc_init()) to ensure that the
3158          * associated relocation section is after all the other relocation
3159          * sections.
3160          */
3161         if ((ofl->ofl_pltcnt) || (ofl->ofl_pltpad))
3162                 if (make_plt(ofl) == S_ERROR)
3163                         return (S_ERROR);
3164 
3165         /*
3166          * Determine whether any sections or files are not referenced.  Under
3167          * -Dunused a diagnostic for any unused components is generated, under
3168          * -zignore the component is removed from the final output.
3169          */
3170         if (DBG_ENABLED || (ofl->ofl_flags1 & FLG_OF1_IGNPRC)) {
3171                 if (ignore_section_processing(ofl) == S_ERROR)
3172                         return (S_ERROR);
3173         }
3174 
3175         /*
3176          * If we have detected a situation in which previously placed
3177          * output sections may have been discarded, perform the necessary
3178          * readjustment.
3179          */
3180         if (ofl->ofl_flags & FLG_OF_ADJOSCNT)
3181                 adjust_os_count(ofl);
3182 
3183         /*
3184          * Do any of the output sections contain input sections that
3185          * are candidates for string table merging? For each such case,
3186          * we create a replacement section, insert it, and discard the
3187          * originals.
3188          *
3189          * rel_alpp and sym_alpp are used by ld_make_strmerge()
3190          * for its internal processing. We are responsible for the
3191          * initialization and cleanup, and ld_make_strmerge() handles the rest.
3192          * This allows us to reuse a single pair of memory buffers, allocated
3193          * for this processing, for all the output sections.
3194          */
3195         if ((ofl->ofl_flags1 & FLG_OF1_NCSTTAB) == 0) {
3196                 int     error_seen = 0;
3197                 APlist  *rel_alpp = NULL;
3198                 APlist  *sym_alpp = NULL;
3199                 Aliste  idx1;
3200 
3201                 for (APLIST_TRAVERSE(ofl->ofl_segs, idx1, sgp)) {
3202                         Os_desc *osp;
3203                         Aliste  idx2;
3204 
3205                         for (APLIST_TRAVERSE(sgp->sg_osdescs, idx2, osp))
3206                                 if ((osp->os_mstrisdescs != NULL) &&
3207                                     (ld_make_strmerge(ofl, osp,
3208                                     &rel_alpp, &sym_alpp) ==
3209                                     S_ERROR)) {
3210                                         error_seen = 1;
3211                                         break;
3212                                 }
3213                 }
3214                 if (rel_alpp != NULL)
3215                         libld_free(rel_alpp);
3216                 if (sym_alpp != NULL)
3217                         libld_free(sym_alpp);
3218                 if (error_seen != 0)
3219                         return (S_ERROR);
3220         }
3221 
3222         /*
3223          * Add any necessary versioning information.
3224          */
3225         if (!(flags & FLG_OF_NOVERSEC)) {
3226                 if ((flags & FLG_OF_VERNEED) &&
3227                     (make_verneed(ofl) == S_ERROR))
3228                         return (S_ERROR);
3229                 if ((flags & FLG_OF_VERDEF) &&
3230                     (make_verdef(ofl) == S_ERROR))
3231                         return (S_ERROR);
3232                 if ((flags & (FLG_OF_VERNEED | FLG_OF_VERDEF)) &&
3233                     ((ofl->ofl_osversym = make_sym_sec(ofl,
3234                     MSG_ORIG(MSG_SCN_SUNWVERSYM), SHT_SUNW_versym,
3235                     ld_targ.t_id.id_version)) == (Os_desc*)S_ERROR))
3236                         return (S_ERROR);
3237         }
3238 
3239         /*
3240          * Create a syminfo section if necessary.
3241          */
3242         if (flags & FLG_OF_SYMINFO) {
3243                 if ((ofl->ofl_ossyminfo = make_sym_sec(ofl,
3244                     MSG_ORIG(MSG_SCN_SUNWSYMINFO), SHT_SUNW_syminfo,
3245                     ld_targ.t_id.id_syminfo)) == (Os_desc *)S_ERROR)
3246                         return (S_ERROR);
3247         }
3248 
3249         if (flags & FLG_OF_COMREL) {
3250                 /*
3251                  * If -zcombreloc is enabled then all relocations (except for
3252                  * the PLT's) are coalesced into a single relocation section.
3253                  */
3254                 if (ofl->ofl_reloccnt) {
3255                         if (make_reloc(ofl, NULL) == S_ERROR)
3256                                 return (S_ERROR);
3257                 }
3258         } else {
3259                 Aliste  idx1;
3260 
3261                 /*
3262                  * Create the required output relocation sections.  Note, new
3263                  * sections may be added to the section list that is being
3264                  * traversed.  These insertions can move the elements of the
3265                  * Alist such that a section descriptor is re-read.  Recursion
3266                  * is prevented by maintaining a previous section pointer and
3267                  * insuring that this pointer isn't re-examined.
3268                  */
3269                 for (APLIST_TRAVERSE(ofl->ofl_segs, idx1, sgp)) {
3270                         Os_desc *osp, *posp = 0;
3271                         Aliste  idx2;
3272 
3273                         for (APLIST_TRAVERSE(sgp->sg_osdescs, idx2, osp)) {
3274                                 if ((osp != posp) && osp->os_szoutrels &&
3275                                     (osp != ofl->ofl_osplt)) {
3276                                         if (make_reloc(ofl, osp) == S_ERROR)
3277                                                 return (S_ERROR);
3278                                 }
3279                                 posp = osp;
3280                         }
3281                 }
3282 
3283                 /*
3284                  * If we're not building a combined relocation section, then
3285                  * build a .rel[a] section as required.
3286                  */
3287                 if (ofl->ofl_relocrelsz) {
3288                         if (make_reloc(ofl, NULL) == S_ERROR)
3289                                 return (S_ERROR);
3290                 }
3291         }
3292 
3293         /*
3294          * The PLT relocations are always in their own section, and we try to
3295          * keep them at the end of the PLT table.  We do this to keep the hot
3296          * "data" PLT's at the head of the table nearer the .dynsym & .hash.
3297          */
3298         if (ofl->ofl_osplt && ofl->ofl_relocpltsz) {
3299                 if (make_reloc(ofl, ofl->ofl_osplt) == S_ERROR)
3300                         return (S_ERROR);
3301         }
3302 
3303         /*
3304          * Finally build the symbol and section header sections.
3305          */
3306         if (flags & FLG_OF_DYNAMIC) {
3307                 if (make_dynamic(ofl) == S_ERROR)
3308                         return (S_ERROR);
3309 
3310                 /*
3311                  * A number of sections aren't necessary within a relocatable
3312                  * object, even if -dy has been used.
3313                  */
3314                 if (!(flags & FLG_OF_RELOBJ)) {
3315                         if (make_hash(ofl) == S_ERROR)
3316                                 return (S_ERROR);
3317                         if (make_dynstr(ofl) == S_ERROR)
3318                                 return (S_ERROR);
3319                         if (make_dynsym(ofl) == S_ERROR)
3320                                 return (S_ERROR);
3321                         if (ld_unwind_make_hdr(ofl) == S_ERROR)
3322                                 return (S_ERROR);
3323                         if (make_dynsort(ofl) == S_ERROR)
3324                                 return (S_ERROR);
3325                 }
3326         }
3327 
3328         if (!(flags & FLG_OF_STRIP) || (flags & FLG_OF_RELOBJ) ||
3329             ((flags & FLG_OF_STATIC) && ofl->ofl_osversym)) {
3330                 /*
3331                  * Do we need to make a SHT_SYMTAB_SHNDX section
3332                  * for the dynsym.  If so - do it now.
3333                  */
3334                 if (ofl->ofl_osdynsym &&
3335                     ((ofl->ofl_shdrcnt + 3) >= SHN_LORESERVE)) {
3336                         if (make_dynsym_shndx(ofl) == S_ERROR)
3337                                 return (S_ERROR);
3338                 }
3339 
3340                 if (make_strtab(ofl) == S_ERROR)
3341                         return (S_ERROR);
3342                 if (make_symtab(ofl) == S_ERROR)
3343                         return (S_ERROR);
3344         } else {
3345                 /*
3346                  * Do we need to make a SHT_SYMTAB_SHNDX section
3347                  * for the dynsym.  If so - do it now.
3348                  */
3349                 if (ofl->ofl_osdynsym &&
3350                     ((ofl->ofl_shdrcnt + 1) >= SHN_LORESERVE)) {
3351                         if (make_dynsym_shndx(ofl) == S_ERROR)
3352                                 return (S_ERROR);
3353                 }
3354         }
3355 
3356         if (make_shstrtab(ofl) == S_ERROR)
3357                 return (S_ERROR);
3358 
3359         /*
3360          * Now that we've created all output sections, adjust the size of the
3361          * SHT_SUNW_versym and SHT_SUNW_syminfo section, which are dependent on
3362          * the associated symbol table sizes.
3363          */
3364         if (ofl->ofl_osversym || ofl->ofl_ossyminfo) {
3365                 ulong_t         cnt;
3366                 Is_desc         *isp;
3367                 Os_desc         *osp;
3368 
3369                 if (OFL_IS_STATIC_OBJ(ofl))
3370                         osp = ofl->ofl_ossymtab;
3371                 else
3372                         osp = ofl->ofl_osdynsym;
3373 
3374                 isp = ld_os_first_isdesc(osp);
3375                 cnt = (isp->is_shdr->sh_size / isp->is_shdr->sh_entsize);
3376 
3377                 if (ofl->ofl_osversym)
3378                         update_data_size(ofl->ofl_osversym, cnt);
3379 
3380                 if (ofl->ofl_ossyminfo)
3381                         update_data_size(ofl->ofl_ossyminfo, cnt);
3382         }
3383 
3384         /*
3385          * Now that we've created all output sections, adjust the size of the
3386          * SHT_SUNW_capinfo, which is dependent on the associated symbol table
3387          * size.
3388          */
3389         if (ofl->ofl_oscapinfo) {
3390                 ulong_t cnt;
3391 
3392                 /*
3393                  * Symbol capabilities symbols are placed directly after the
3394                  * STT_FILE symbol, section symbols, and any register symbols.
3395                  * Effectively these are the first of any series of demoted
3396                  * (scoped) symbols.
3397                  */
3398                 if (OFL_IS_STATIC_OBJ(ofl))
3399                         cnt = SYMTAB_ALL_CNT(ofl);
3400                 else
3401                         cnt = DYNSYM_ALL_CNT(ofl);
3402 
3403                 update_data_size(ofl->ofl_oscapinfo, cnt);
3404         }
3405         return (1);
3406 }
3407 
3408 /*
3409  * Build an additional data section - used to back OBJT symbol definitions
3410  * added with a mapfile.
3411  */
3412 Is_desc *
3413 ld_make_data(Ofl_desc *ofl, size_t size)
3414 {
3415         Shdr            *shdr;
3416         Elf_Data        *data;
3417         Is_desc         *isec;
3418 
3419         if (new_section(ofl, SHT_PROGBITS, MSG_ORIG(MSG_SCN_DATA), 0,
3420             &isec, &shdr, &data) == S_ERROR)
3421                 return ((Is_desc *)S_ERROR);
3422 
3423         data->d_size = size;
3424         shdr->sh_size = (Xword)size;
3425         shdr->sh_flags |= SHF_WRITE;
3426 
3427         if (aplist_append(&ofl->ofl_mapdata, isec, AL_CNT_OFL_MAPSECS) == NULL)
3428                 return ((Is_desc *)S_ERROR);
3429 
3430         return (isec);
3431 }
3432 
3433 /*
3434  * Build an additional text section - used to back FUNC symbol definitions
3435  * added with a mapfile.
3436  */
3437 Is_desc *
3438 ld_make_text(Ofl_desc *ofl, size_t size)
3439 {
3440         Shdr            *shdr;
3441         Elf_Data        *data;
3442         Is_desc         *isec;
3443 
3444         /*
3445          * Insure the size is sufficient to contain the minimum return
3446          * instruction.
3447          */
3448         if (size < ld_targ.t_nf.nf_size)
3449                 size = ld_targ.t_nf.nf_size;
3450 
3451         if (new_section(ofl, SHT_PROGBITS, MSG_ORIG(MSG_SCN_TEXT), 0,
3452             &isec, &shdr, &data) == S_ERROR)
3453                 return ((Is_desc *)S_ERROR);
3454 
3455         data->d_size = size;
3456         shdr->sh_size = (Xword)size;
3457         shdr->sh_flags |= SHF_EXECINSTR;
3458 
3459         /*
3460          * Fill the buffer with the appropriate return instruction.
3461          * Note that there is no need to swap bytes on a non-native,
3462          * link, as the data being copied is given in bytes.
3463          */
3464         if ((data->d_buf = libld_calloc(size, 1)) == NULL)
3465                 return ((Is_desc *)S_ERROR);
3466         (void) memcpy(data->d_buf, ld_targ.t_nf.nf_template,
3467             ld_targ.t_nf.nf_size);
3468 
3469         /*
3470          * If size was larger than required, and the target supplies
3471          * a fill function, use it to fill the balance. If there is no
3472          * fill function, we accept the 0-fill supplied by libld_calloc().
3473          */
3474         if ((ld_targ.t_ff.ff_execfill != NULL) && (size > ld_targ.t_nf.nf_size))
3475                 ld_targ.t_ff.ff_execfill(data->d_buf, ld_targ.t_nf.nf_size,
3476                     size - ld_targ.t_nf.nf_size);
3477 
3478         if (aplist_append(&ofl->ofl_maptext, isec, AL_CNT_OFL_MAPSECS) == NULL)
3479                 return ((Is_desc *)S_ERROR);
3480 
3481         return (isec);
3482 }
3483 
3484 void
3485 ld_comdat_validate(Ofl_desc *ofl, Ifl_desc *ifl)
3486 {
3487         int i;
3488 
3489         for (i = 0; i < ifl->ifl_shnum; i++) {
3490                 Is_desc *isp = ifl->ifl_isdesc[i];
3491                 int types = 0;
3492                 char buf[1024] = "";
3493                 Group_desc *gr = NULL;
3494 
3495                 if ((isp == NULL) || (isp->is_flags & FLG_IS_COMDAT) == 0)
3496                         continue;
3497 
3498                 if (isp->is_shdr->sh_type == SHT_SUNW_COMDAT) {
3499                         types++;
3500                         (void) strlcpy(buf, MSG_ORIG(MSG_STR_SUNW_COMDAT),
3501                             sizeof (buf));
3502                 }
3503 
3504                 if (strncmp(MSG_ORIG(MSG_SCN_GNU_LINKONCE), isp->is_name,
3505                     MSG_SCN_GNU_LINKONCE_SIZE) == 0) {
3506                         types++;
3507                         if (types > 1)
3508                                 (void) strlcat(buf, ", ", sizeof (buf));
3509                         (void) strlcat(buf, MSG_ORIG(MSG_SCN_GNU_LINKONCE),
3510                             sizeof (buf));
3511                 }
3512 
3513                 if ((isp->is_shdr->sh_flags & SHF_GROUP) &&
3514                     ((gr = ld_get_group(ofl, isp)) != NULL) &&
3515                     (gr->gd_data[0] & GRP_COMDAT)) {
3516                         types++;
3517                         if (types > 1)
3518                                 (void) strlcat(buf, ", ", sizeof (buf));
3519                         (void) strlcat(buf, MSG_ORIG(MSG_STR_GROUP),
3520                             sizeof (buf));
3521                 }
3522 
3523                 if (types > 1)
3524                         ld_eprintf(ofl, ERR_FATAL,
3525                             MSG_INTL(MSG_SCN_MULTICOMDAT), ifl->ifl_name,
3526                             EC_WORD(isp->is_scnndx), isp->is_name, buf);
3527         }
3528 }