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