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  *
  27  * Copyright (c) 1989, 2010, Oracle and/or its affiliates. All rights reserved.
  28  */
  29 
  30 /*
  31  * Symbol table management routines
  32  */
  33 
  34 #define ELF_TARGET_AMD64
  35 
  36 #include        <stdio.h>
  37 #include        <string.h>
  38 #include        <debug.h>
  39 #include        "msg.h"
  40 #include        "_libld.h"
  41 
  42 /*
  43  * AVL tree comparator function:
  44  *
  45  * The primary key is the symbol name hash with a secondary key of the symbol
  46  * name itself.
  47  */
  48 int
  49 ld_sym_avl_comp(const void *elem1, const void *elem2)
  50 {
  51         Sym_avlnode     *sav1 = (Sym_avlnode *)elem1;
  52         Sym_avlnode     *sav2 = (Sym_avlnode *)elem2;
  53         int             res;
  54 
  55         res = sav1->sav_hash - sav2->sav_hash;
  56 
  57         if (res < 0)
  58                 return (-1);
  59         if (res > 0)
  60                 return (1);
  61 
  62         /*
  63          * Hash is equal - now compare name
  64          */
  65         res = strcmp(sav1->sav_name, sav2->sav_name);
  66         if (res == 0)
  67                 return (0);
  68         if (res > 0)
  69                 return (1);
  70         return (-1);
  71 }
  72 
  73 /*
  74  * Focal point for verifying symbol names.
  75  */
  76 inline static const char *
  77 string(Ofl_desc *ofl, Ifl_desc *ifl, Sym *sym, const char *strs, size_t strsize,
  78     int symndx, Word shndx, Word symsecndx, const char *symsecname,
  79     const char *strsecname, sd_flag_t *flags)
  80 {
  81         Word    name = sym->st_name;
  82 
  83         if (name) {
  84                 if ((ifl->ifl_flags & FLG_IF_HSTRTAB) == 0) {
  85                         ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_FIL_NOSTRTABLE),
  86                             ifl->ifl_name, EC_WORD(symsecndx), symsecname,
  87                             symndx, EC_XWORD(name));
  88                         return (NULL);
  89                 }
  90                 if (name >= (Word)strsize) {
  91                         ld_eprintf(ofl, ERR_FATAL,
  92                             MSG_INTL(MSG_FIL_EXCSTRTABLE), ifl->ifl_name,
  93                             EC_WORD(symsecndx), symsecname, symndx,
  94                             EC_XWORD(name), strsecname, EC_XWORD(strsize));
  95                         return (NULL);
  96                 }
  97         }
  98 
  99         /*
 100          * Determine if we're dealing with a register and if so validate it.
 101          * If it's a scratch register, a fabricated name will be returned.
 102          */
 103         if (ld_targ.t_ms.ms_is_regsym != NULL) {
 104                 const char *regname = (*ld_targ.t_ms.ms_is_regsym)(ofl, ifl,
 105                     sym, strs, symndx, shndx, symsecname, flags);
 106 
 107                 if (regname == (const char *)S_ERROR) {
 108                         return (NULL);
 109                 }
 110                 if (regname)
 111                         return (regname);
 112         }
 113 
 114         /*
 115          * If this isn't a register, but we have a global symbol with a null
 116          * name, we're not going to be able to hash this, search for it, or
 117          * do anything interesting.  However, we've been accepting a symbol of
 118          * this kind for ages now, so give the user a warning (rather than a
 119          * fatal error), just in case this instance exists somewhere in the
 120          * world and hasn't, as yet, been a problem.
 121          */
 122         if ((name == 0) && (ELF_ST_BIND(sym->st_info) != STB_LOCAL)) {
 123                 ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_FIL_NONAMESYM),
 124                     ifl->ifl_name, EC_WORD(symsecndx), symsecname, symndx,
 125                     EC_XWORD(name));
 126         }
 127         return (strs + name);
 128 }
 129 
 130 /*
 131  * For producing symbol names strings to use in error messages.
 132  * If the symbol has a non-null name, then the string returned by
 133  * this function is the output from demangle(), surrounded by
 134  * single quotes. For null names, a descriptive string giving
 135  * the symbol section and index is generated.
 136  *
 137  * This function uses an internal static buffer to hold the resulting
 138  * string. The value returned is usable by the caller until the next
 139  * call, at which point it is overwritten.
 140  */
 141 static const char *
 142 demangle_symname(const char *name, const char *symtab_name, Word symndx)
 143 {
 144 #define INIT_BUFSIZE 256
 145 
 146         static char     *buf;
 147         static size_t   bufsize = 0;
 148         size_t          len;
 149         int             use_name;
 150 
 151         use_name = (name != NULL) && (*name != '\0');
 152 
 153         if (use_name) {
 154                 name = demangle(name);
 155                 len = strlen(name) + 2;   /* Include room for quotes */
 156         } else {
 157                 name = MSG_ORIG(MSG_STR_EMPTY);
 158                 len = strlen(symtab_name) + 2 + CONV_INV_BUFSIZE;
 159         }
 160         len++;                  /* Null termination */
 161 
 162         /* If our buffer is too small, double it until it is big enough */
 163         if (len > bufsize) {
 164                 size_t  new_bufsize = bufsize;
 165                 char    *new_buf;
 166 
 167                 if (new_bufsize == 0)
 168                         new_bufsize = INIT_BUFSIZE;
 169                 while (len > new_bufsize)
 170                         new_bufsize *= 2;
 171                 if ((new_buf = libld_malloc(new_bufsize)) == NULL)
 172                         return (name);
 173                 buf = new_buf;
 174                 bufsize = new_bufsize;
 175         }
 176 
 177         if (use_name) {
 178                 (void) snprintf(buf, bufsize, MSG_ORIG(MSG_FMT_SYMNAM), name);
 179         } else {
 180                 (void) snprintf(buf, bufsize, MSG_ORIG(MSG_FMT_NULLSYMNAM),
 181                     symtab_name, EC_WORD(symndx));
 182         }
 183 
 184         return (buf);
 185 
 186 #undef INIT_BUFSIZE
 187 }
 188 
 189 /*
 190  * Shared objects can be built that define specific symbols that can not be
 191  * directly bound to.  These objects have a syminfo section (and an associated
 192  * DF_1_NODIRECT dynamic flags entry).  Scan this table looking for symbols
 193  * that can't be bound to directly, and if this files symbol is presently
 194  * referenced, mark it so that we don't directly bind to it.
 195  */
 196 uintptr_t
 197 ld_sym_nodirect(Is_desc *isp, Ifl_desc *ifl, Ofl_desc *ofl)
 198 {
 199         Shdr            *sifshdr, *symshdr;
 200         Syminfo         *sifdata;
 201         Sym             *symdata;
 202         char            *strdata;
 203         ulong_t         cnt, _cnt;
 204 
 205         /*
 206          * Get the syminfo data, and determine the number of entries.
 207          */
 208         sifshdr = isp->is_shdr;
 209         sifdata = (Syminfo *)isp->is_indata->d_buf;
 210         cnt =  sifshdr->sh_size / sifshdr->sh_entsize;
 211 
 212         /*
 213          * Get the associated symbol table.
 214          */
 215         if ((sifshdr->sh_link == 0) || (sifshdr->sh_link >= ifl->ifl_shnum)) {
 216                 /*
 217                  * Broken input file
 218                  */
 219                 ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_FIL_INVSHINFO),
 220                     ifl->ifl_name, isp->is_name, EC_XWORD(sifshdr->sh_link));
 221                 return (0);
 222         }
 223         symshdr = ifl->ifl_isdesc[sifshdr->sh_link]->is_shdr;
 224         symdata = ifl->ifl_isdesc[sifshdr->sh_link]->is_indata->d_buf;
 225 
 226         /*
 227          * Get the string table associated with the symbol table.
 228          */
 229         strdata = ifl->ifl_isdesc[symshdr->sh_link]->is_indata->d_buf;
 230 
 231         /*
 232          * Traverse the syminfo data for symbols that can't be directly
 233          * bound to.
 234          */
 235         for (_cnt = 1, sifdata++; _cnt < cnt; _cnt++, sifdata++) {
 236                 Sym             *sym;
 237                 char            *str;
 238                 Sym_desc        *sdp;
 239 
 240                 if ((sifdata->si_flags & SYMINFO_FLG_NOEXTDIRECT) == 0)
 241                         continue;
 242 
 243                 sym = (Sym *)(symdata + _cnt);
 244                 str = (char *)(strdata + sym->st_name);
 245 
 246                 if ((sdp = ld_sym_find(str, SYM_NOHASH, NULL, ofl)) != NULL) {
 247                         if (ifl != sdp->sd_file)
 248                                 continue;
 249 
 250                         sdp->sd_flags &= ~FLG_SY_DIR;
 251                         sdp->sd_flags |= FLG_SY_NDIR;
 252                 }
 253         }
 254         return (0);
 255 }
 256 
 257 /*
 258  * If, during symbol processing, it is necessary to update a local symbols
 259  * contents before we have generated the symbol tables in the output image,
 260  * create a new symbol structure and copy the original symbol contents.  While
 261  * we are processing the input files, their local symbols are part of the
 262  * read-only mapped image.  Commonly, these symbols are copied to the new output
 263  * file image and then updated to reflect their new address and any change in
 264  * attributes.  However, sometimes during relocation counting, it is necessary
 265  * to adjust the symbols information.  This routine provides for the generation
 266  * of a new symbol image so that this update can be performed.
 267  * All global symbols are copied to an internal symbol table to improve locality
 268  * of reference and hence performance, and thus this copying is not necessary.
 269  */
 270 uintptr_t
 271 ld_sym_copy(Sym_desc *sdp)
 272 {
 273         Sym     *nsym;
 274 
 275         if (sdp->sd_flags & FLG_SY_CLEAN) {
 276                 if ((nsym = libld_malloc(sizeof (Sym))) == NULL)
 277                         return (S_ERROR);
 278                 *nsym = *(sdp->sd_sym);
 279                 sdp->sd_sym = nsym;
 280                 sdp->sd_flags &= ~FLG_SY_CLEAN;
 281         }
 282         return (1);
 283 }
 284 
 285 /*
 286  * Finds a given name in the link editors internal symbol table.  If no
 287  * hash value is specified it is calculated.  A pointer to the located
 288  * Sym_desc entry is returned, or NULL if the symbol is not found.
 289  */
 290 Sym_desc *
 291 ld_sym_find(const char *name, Word hash, avl_index_t *where, Ofl_desc *ofl)
 292 {
 293         Sym_avlnode     qsav, *sav;
 294 
 295         if (hash == SYM_NOHASH)
 296                 /* LINTED */
 297                 hash = (Word)elf_hash((const char *)name);
 298         qsav.sav_hash = hash;
 299         qsav.sav_name = name;
 300 
 301         /*
 302          * Perform search for symbol in AVL tree.  Note that the 'where' field
 303          * is passed in from the caller.  If a 'where' is present, it can be
 304          * used in subsequent 'ld_sym_enter()' calls if required.
 305          */
 306         sav = avl_find(&ofl->ofl_symavl, &qsav, where);
 307 
 308         /*
 309          * If symbol was not found in the avl tree, return null to show that.
 310          */
 311         if (sav == NULL)
 312                 return (NULL);
 313 
 314         /*
 315          * Return symbol found.
 316          */
 317         return (sav->sav_sdp);
 318 }
 319 
 320 /*
 321  * Enter a new symbol into the link editors internal symbol table.
 322  * If the symbol is from an input file, information regarding the input file
 323  * and input section is also recorded.  Otherwise (file == NULL) the symbol
 324  * has been internally generated (ie. _etext, _edata, etc.).
 325  */
 326 Sym_desc *
 327 ld_sym_enter(const char *name, Sym *osym, Word hash, Ifl_desc *ifl,
 328     Ofl_desc *ofl, Word ndx, Word shndx, sd_flag_t sdflags, avl_index_t *where)
 329 {
 330         Sym_desc        *sdp;
 331         Sym_aux         *sap;
 332         Sym_avlnode     *savl;
 333         char            *_name;
 334         Sym             *nsym;
 335         Half            etype;
 336         uchar_t         vis;
 337         avl_index_t     _where;
 338 
 339         /*
 340          * Establish the file type.
 341          */
 342         if (ifl)
 343                 etype = ifl->ifl_ehdr->e_type;
 344         else
 345                 etype = ET_NONE;
 346 
 347         ofl->ofl_entercnt++;
 348 
 349         /*
 350          * Allocate a Sym Descriptor, Auxiliary Descriptor, and a Sym AVLNode -
 351          * contiguously.
 352          */
 353         if ((savl = libld_calloc(S_DROUND(sizeof (Sym_avlnode)) +
 354             S_DROUND(sizeof (Sym_desc)) +
 355             S_DROUND(sizeof (Sym_aux)), 1)) == NULL)
 356                 return ((Sym_desc *)S_ERROR);
 357         sdp = (Sym_desc *)((uintptr_t)savl +
 358             S_DROUND(sizeof (Sym_avlnode)));
 359         sap = (Sym_aux *)((uintptr_t)sdp +
 360             S_DROUND(sizeof (Sym_desc)));
 361 
 362         savl->sav_sdp = sdp;
 363         sdp->sd_file = ifl;
 364         sdp->sd_aux = sap;
 365         savl->sav_hash = sap->sa_hash = hash;
 366 
 367         /*
 368          * Copy the symbol table entry from the input file into the internal
 369          * entry and have the symbol descriptor use it.
 370          */
 371         sdp->sd_sym = nsym = &sap->sa_sym;
 372         *nsym = *osym;
 373         sdp->sd_shndx = shndx;
 374         sdp->sd_flags |= sdflags;
 375 
 376         if ((_name = libld_malloc(strlen(name) + 1)) == NULL)
 377                 return ((Sym_desc *)S_ERROR);
 378         savl->sav_name = sdp->sd_name = (const char *)strcpy(_name, name);
 379 
 380         /*
 381          * Enter Symbol in AVL tree.
 382          */
 383         if (where == 0) {
 384                 /* LINTED */
 385                 Sym_avlnode     *_savl;
 386                 /*
 387                  * If a previous ld_sym_find() hasn't initialized 'where' do it
 388                  * now.
 389                  */
 390                 where = &_where;
 391                 _savl = avl_find(&ofl->ofl_symavl, savl, where);
 392                 assert(_savl == NULL);
 393         }
 394         avl_insert(&ofl->ofl_symavl, savl, *where);
 395 
 396         /*
 397          * Record the section index.  This is possible because the
 398          * `ifl_isdesc' table is filled before we start symbol processing.
 399          */
 400         if ((sdflags & FLG_SY_SPECSEC) || (nsym->st_shndx == SHN_UNDEF))
 401                 sdp->sd_isc = NULL;
 402         else {
 403                 sdp->sd_isc = ifl->ifl_isdesc[shndx];
 404 
 405                 /*
 406                  * If this symbol is from a relocatable object, make sure that
 407                  * it is still associated with a section.  For example, an
 408                  * unknown section type (SHT_NULL) would have been rejected on
 409                  * input with a warning.  Here, we make the use of the symbol
 410                  * fatal.  A symbol descriptor is still returned, so that the
 411                  * caller can continue processing all symbols, and hence flush
 412                  * out as many error conditions as possible.
 413                  */
 414                 if ((etype == ET_REL) && (sdp->sd_isc == NULL)) {
 415                         ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_SYM_INVSEC),
 416                             name, ifl->ifl_name, EC_XWORD(shndx));
 417                         return (sdp);
 418                 }
 419         }
 420 
 421         /*
 422          * Mark any COMMON symbols as 'tentative'.
 423          */
 424         if (sdflags & FLG_SY_SPECSEC) {
 425                 if (nsym->st_shndx == SHN_COMMON)
 426                         sdp->sd_flags |= FLG_SY_TENTSYM;
 427 #if     defined(_ELF64)
 428                 else if ((ld_targ.t_m.m_mach == EM_AMD64) &&
 429                     (nsym->st_shndx == SHN_X86_64_LCOMMON))
 430                         sdp->sd_flags |= FLG_SY_TENTSYM;
 431 #endif
 432         }
 433 
 434         /*
 435          * Establish the symbols visibility and reference.
 436          */
 437         vis = ELF_ST_VISIBILITY(nsym->st_other);
 438 
 439         if ((etype == ET_NONE) || (etype == ET_REL)) {
 440                 switch (vis) {
 441                 case STV_DEFAULT:
 442                         sdp->sd_flags |= FLG_SY_DEFAULT;
 443                         break;
 444                 case STV_INTERNAL:
 445                 case STV_HIDDEN:
 446                         sdp->sd_flags |= FLG_SY_HIDDEN;
 447                         break;
 448                 case STV_PROTECTED:
 449                         sdp->sd_flags |= FLG_SY_PROTECT;
 450                         break;
 451                 case STV_EXPORTED:
 452                         sdp->sd_flags |= FLG_SY_EXPORT;
 453                         break;
 454                 case STV_SINGLETON:
 455                         sdp->sd_flags |= (FLG_SY_SINGLE | FLG_SY_NDIR);
 456                         ofl->ofl_flags1 |= (FLG_OF1_NDIRECT | FLG_OF1_NGLBDIR);
 457                         break;
 458                 case STV_ELIMINATE:
 459                         sdp->sd_flags |= (FLG_SY_HIDDEN | FLG_SY_ELIM);
 460                         break;
 461                 default:
 462                         assert(vis <= STV_ELIMINATE);
 463                 }
 464 
 465                 sdp->sd_ref = REF_REL_NEED;
 466 
 467                 /*
 468                  * Under -Bnodirect, all exported interfaces that have not
 469                  * explicitly been defined protected or directly bound to, are
 470                  * tagged to prevent direct binding.
 471                  */
 472                 if ((ofl->ofl_flags1 & FLG_OF1_ALNODIR) &&
 473                     ((sdp->sd_flags & (FLG_SY_PROTECT | FLG_SY_DIR)) == 0) &&
 474                     (nsym->st_shndx != SHN_UNDEF)) {
 475                         sdp->sd_flags |= FLG_SY_NDIR;
 476                 }
 477         } else {
 478                 sdp->sd_ref = REF_DYN_SEEN;
 479 
 480                 /*
 481                  * If this is a protected symbol, remember this.  Note, this
 482                  * state is different from the FLG_SY_PROTECT used to establish
 483                  * a symbol definitions visibility.  This state is used to warn
 484                  * against possible copy relocations against this referenced
 485                  * symbol.
 486                  */
 487                 if (vis == STV_PROTECTED)
 488                         sdp->sd_flags |= FLG_SY_PROT;
 489 
 490                 /*
 491                  * If this is a SINGLETON definition, then indicate the symbol
 492                  * can not be directly bound to, and retain the visibility.
 493                  * This visibility will be inherited by any references made to
 494                  * this symbol.
 495                  */
 496                 if ((vis == STV_SINGLETON) && (nsym->st_shndx != SHN_UNDEF))
 497                         sdp->sd_flags |= (FLG_SY_SINGLE | FLG_SY_NDIR);
 498 
 499                 /*
 500                  * If the new symbol is from a shared library and is associated
 501                  * with a SHT_NOBITS section then this symbol originated from a
 502                  * tentative symbol.
 503                  */
 504                 if (sdp->sd_isc &&
 505                     (sdp->sd_isc->is_shdr->sh_type == SHT_NOBITS))
 506                         sdp->sd_flags |= FLG_SY_TENTSYM;
 507         }
 508 
 509         /*
 510          * Reclassify any SHN_SUNW_IGNORE symbols to SHN_UNDEF so as to
 511          * simplify future processing.
 512          */
 513         if (nsym->st_shndx == SHN_SUNW_IGNORE) {
 514                 sdp->sd_shndx = shndx = SHN_UNDEF;
 515                 sdp->sd_flags |= (FLG_SY_REDUCED |
 516                     FLG_SY_HIDDEN | FLG_SY_IGNORE | FLG_SY_ELIM);
 517         }
 518 
 519         /*
 520          * If this is an undefined, or common symbol from a relocatable object
 521          * determine whether it is a global or weak reference (see build_osym(),
 522          * where REF_DYN_NEED definitions are returned back to undefines).
 523          */
 524         if ((etype == ET_REL) &&
 525             (ELF_ST_BIND(nsym->st_info) == STB_GLOBAL) &&
 526             ((nsym->st_shndx == SHN_UNDEF) || ((sdflags & FLG_SY_SPECSEC) &&
 527 #if     defined(_ELF64)
 528             ((nsym->st_shndx == SHN_COMMON) ||
 529             ((ld_targ.t_m.m_mach == EM_AMD64) &&
 530             (nsym->st_shndx == SHN_X86_64_LCOMMON))))))
 531 #else
 532         /* BEGIN CSTYLED */
 533             (nsym->st_shndx == SHN_COMMON))))
 534         /* END CSTYLED */
 535 #endif
 536                 sdp->sd_flags |= FLG_SY_GLOBREF;
 537 
 538         /*
 539          * Record the input filename on the referenced or defined files list
 540          * for possible later diagnostics.  The `sa_rfile' pointer contains the
 541          * name of the file that first referenced this symbol and is used to
 542          * generate undefined symbol diagnostics (refer to sym_undef_entry()).
 543          * Note that this entry can be overridden if a reference from a
 544          * relocatable object is found after a reference from a shared object
 545          * (refer to sym_override()).
 546          * The `sa_dfiles' list is used to maintain the list of files that
 547          * define the same symbol.  This list can be used for two reasons:
 548          *
 549          *  -   To save the first definition of a symbol that is not available
 550          *      for this link-edit.
 551          *
 552          *  -   To save all definitions of a symbol when the -m option is in
 553          *      effect.  This is optional as it is used to list multiple
 554          *      (interposed) definitions of a symbol (refer to ldmap_out()),
 555          *      and can be quite expensive.
 556          */
 557         if (nsym->st_shndx == SHN_UNDEF) {
 558                 sap->sa_rfile = ifl->ifl_name;
 559         } else {
 560                 if (sdp->sd_ref == REF_DYN_SEEN) {
 561                         /*
 562                          * A symbol is determined to be unavailable if it
 563                          * belongs to a version of a shared object that this
 564                          * user does not wish to use, or if it belongs to an
 565                          * implicit shared object.
 566                          */
 567                         if (ifl->ifl_vercnt) {
 568                                 Ver_index       *vip;
 569                                 Half            vndx = ifl->ifl_versym[ndx];
 570 
 571                                 sap->sa_dverndx = vndx;
 572                                 vip = &ifl->ifl_verndx[vndx];
 573                                 if (!(vip->vi_flags & FLG_VER_AVAIL)) {
 574                                         sdp->sd_flags |= FLG_SY_NOTAVAIL;
 575                                         sap->sa_vfile = ifl->ifl_name;
 576                                 }
 577                         }
 578                         if (!(ifl->ifl_flags & FLG_IF_NEEDED))
 579                                 sdp->sd_flags |= FLG_SY_NOTAVAIL;
 580 
 581                 } else if (etype == ET_REL) {
 582                         /*
 583                          * If this symbol has been obtained from a versioned
 584                          * input relocatable object then the new symbol must be
 585                          * promoted to the versioning of the output file.
 586                          */
 587                         if (ifl->ifl_versym)
 588                                 ld_vers_promote(sdp, ndx, ifl, ofl);
 589                 }
 590 
 591                 if ((ofl->ofl_flags & FLG_OF_GENMAP) &&
 592                     ((sdflags & FLG_SY_SPECSEC) == 0))
 593                         if (aplist_append(&sap->sa_dfiles, ifl->ifl_name,
 594                             AL_CNT_SDP_DFILES) == NULL)
 595                                 return ((Sym_desc *)S_ERROR);
 596         }
 597 
 598         /*
 599          * Provided we're not processing a mapfile, diagnose the entered symbol.
 600          * Mapfile processing requires the symbol to be updated with additional
 601          * information, therefore the diagnosing of the symbol is deferred until
 602          * later (see Dbg_map_symbol()).
 603          */
 604         if ((ifl == NULL) || ((ifl->ifl_flags & FLG_IF_MAPFILE) == 0))
 605                 DBG_CALL(Dbg_syms_entered(ofl, nsym, sdp));
 606 
 607         return (sdp);
 608 }
 609 
 610 /*
 611  * Add a special symbol to the symbol table.  Takes special symbol name with
 612  * and without underscores.  This routine is called, after all other symbol
 613  * resolution has completed, to generate a reserved absolute symbol (the
 614  * underscore version).  Special symbols are updated with the appropriate
 615  * values in update_osym().  If the user has already defined this symbol
 616  * issue a warning and leave the symbol as is.  If the non-underscore symbol
 617  * is referenced then turn it into a weak alias of the underscored symbol.
 618  *
 619  * The bits in sdflags_u are OR'd into the flags field of the symbol for the
 620  * underscored symbol.
 621  *
 622  * If this is a global symbol, and it hasn't explicitly been defined as being
 623  * directly bound to, indicate that it can't be directly bound to.
 624  * Historically, most special symbols only have meaning to the object in which
 625  * they exist, however, they've always been global.  To ensure compatibility
 626  * with any unexpected use presently in effect, ensure these symbols don't get
 627  * directly bound to.  Note, that establishing this state here isn't sufficient
 628  * to create a syminfo table, only if a syminfo table is being created by some
 629  * other symbol directives will the nodirect binding be recorded.  This ensures
 630  * we don't create syminfo sections for all objects we create, as this might add
 631  * unnecessary bloat to users who haven't explicitly requested extra symbol
 632  * information.
 633  */
 634 static uintptr_t
 635 sym_add_spec(const char *name, const char *uname, Word sdaux_id,
 636     sd_flag_t sdflags_u, sd_flag_t sdflags, Ofl_desc *ofl)
 637 {
 638         Sym_desc        *sdp;
 639         Sym_desc        *usdp;
 640         Sym             *sym;
 641         Word            hash;
 642         avl_index_t     where;
 643 
 644         /* LINTED */
 645         hash = (Word)elf_hash(uname);
 646         if (usdp = ld_sym_find(uname, hash, &where, ofl)) {
 647                 /*
 648                  * If the underscore symbol exists and is undefined, or was
 649                  * defined in a shared library, convert it to a local symbol.
 650                  * Otherwise leave it as is and warn the user.
 651                  */
 652                 if ((usdp->sd_shndx == SHN_UNDEF) ||
 653                     (usdp->sd_ref != REF_REL_NEED)) {
 654                         usdp->sd_ref = REF_REL_NEED;
 655                         usdp->sd_shndx = usdp->sd_sym->st_shndx = SHN_ABS;
 656                         usdp->sd_flags |= FLG_SY_SPECSEC | sdflags_u;
 657                         usdp->sd_sym->st_info =
 658                             ELF_ST_INFO(STB_GLOBAL, STT_OBJECT);
 659                         usdp->sd_isc = NULL;
 660                         usdp->sd_sym->st_size = 0;
 661                         usdp->sd_sym->st_value = 0;
 662                         /* LINTED */
 663                         usdp->sd_aux->sa_symspec = (Half)sdaux_id;
 664 
 665                         /*
 666                          * If a user hasn't specifically indicated that the
 667                          * scope of this symbol be made local, then leave it
 668                          * as global (ie. prevent automatic scoping).  The GOT
 669                          * should be defined protected, whereas all other
 670                          * special symbols are tagged as no-direct.
 671                          */
 672                         if (!SYM_IS_HIDDEN(usdp) &&
 673                             (sdflags & FLG_SY_DEFAULT)) {
 674                                 usdp->sd_aux->sa_overndx = VER_NDX_GLOBAL;
 675                                 if (sdaux_id == SDAUX_ID_GOT) {
 676                                         usdp->sd_flags &= ~FLG_SY_NDIR;
 677                                         usdp->sd_flags |= FLG_SY_PROTECT;
 678                                         usdp->sd_sym->st_other = STV_PROTECTED;
 679                                 } else if (
 680                                     ((usdp->sd_flags & FLG_SY_DIR) == 0) &&
 681                                     ((ofl->ofl_flags & FLG_OF_SYMBOLIC) == 0)) {
 682                                         usdp->sd_flags |= FLG_SY_NDIR;
 683                                 }
 684                         }
 685                         usdp->sd_flags |= sdflags;
 686 
 687                         /*
 688                          * If the reference originated from a mapfile ensure
 689                          * we mark the symbol as used.
 690                          */
 691                         if (usdp->sd_flags & FLG_SY_MAPREF)
 692                                 usdp->sd_flags |= FLG_SY_MAPUSED;
 693 
 694                         DBG_CALL(Dbg_syms_updated(ofl, usdp, uname));
 695                 } else {
 696                         ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_SYM_RESERVE),
 697                             uname, usdp->sd_file->ifl_name);
 698                 }
 699         } else {
 700                 /*
 701                  * If the symbol does not exist create it.
 702                  */
 703                 if ((sym = libld_calloc(sizeof (Sym), 1)) == NULL)
 704                         return (S_ERROR);
 705                 sym->st_shndx = SHN_ABS;
 706                 sym->st_info = ELF_ST_INFO(STB_GLOBAL, STT_OBJECT);
 707                 sym->st_size = 0;
 708                 sym->st_value = 0;
 709                 DBG_CALL(Dbg_syms_created(ofl->ofl_lml, uname));
 710                 if ((usdp = ld_sym_enter(uname, sym, hash, (Ifl_desc *)NULL,
 711                     ofl, 0, SHN_ABS, (FLG_SY_SPECSEC | sdflags_u), &where)) ==
 712                     (Sym_desc *)S_ERROR)
 713                         return (S_ERROR);
 714                 usdp->sd_ref = REF_REL_NEED;
 715                 /* LINTED */
 716                 usdp->sd_aux->sa_symspec = (Half)sdaux_id;
 717 
 718                 usdp->sd_aux->sa_overndx = VER_NDX_GLOBAL;
 719 
 720                 if (sdaux_id == SDAUX_ID_GOT) {
 721                         usdp->sd_flags |= FLG_SY_PROTECT;
 722                         usdp->sd_sym->st_other = STV_PROTECTED;
 723                 } else if ((sdflags & FLG_SY_DEFAULT) &&
 724                     ((ofl->ofl_flags & FLG_OF_SYMBOLIC) == 0)) {
 725                         usdp->sd_flags |= FLG_SY_NDIR;
 726                 }
 727                 usdp->sd_flags |= sdflags;
 728         }
 729 
 730         if (name && (sdp = ld_sym_find(name, SYM_NOHASH, NULL, ofl)) &&
 731             (sdp->sd_sym->st_shndx == SHN_UNDEF)) {
 732                 uchar_t bind;
 733 
 734                 /*
 735                  * If the non-underscore symbol exists and is undefined
 736                  * convert it to be a local.  If the underscore has
 737                  * sa_symspec set (ie. it was created above) then simulate this
 738                  * as a weak alias.
 739                  */
 740                 sdp->sd_ref = REF_REL_NEED;
 741                 sdp->sd_shndx = sdp->sd_sym->st_shndx = SHN_ABS;
 742                 sdp->sd_flags |= FLG_SY_SPECSEC;
 743                 sdp->sd_isc = NULL;
 744                 sdp->sd_sym->st_size = 0;
 745                 sdp->sd_sym->st_value = 0;
 746                 /* LINTED */
 747                 sdp->sd_aux->sa_symspec = (Half)sdaux_id;
 748                 if (usdp->sd_aux->sa_symspec) {
 749                         usdp->sd_aux->sa_linkndx = 0;
 750                         sdp->sd_aux->sa_linkndx = 0;
 751                         bind = STB_WEAK;
 752                 } else
 753                         bind = STB_GLOBAL;
 754                 sdp->sd_sym->st_info = ELF_ST_INFO(bind, STT_OBJECT);
 755 
 756                 /*
 757                  * If a user hasn't specifically indicated the scope of this
 758                  * symbol be made local then leave it as global (ie. prevent
 759                  * automatic scoping).  The GOT should be defined protected,
 760                  * whereas all other special symbols are tagged as no-direct.
 761                  */
 762                 if (!SYM_IS_HIDDEN(sdp) &&
 763                     (sdflags & FLG_SY_DEFAULT)) {
 764                         sdp->sd_aux->sa_overndx = VER_NDX_GLOBAL;
 765                         if (sdaux_id == SDAUX_ID_GOT) {
 766                                 sdp->sd_flags &= ~FLG_SY_NDIR;
 767                                 sdp->sd_flags |= FLG_SY_PROTECT;
 768                                 sdp->sd_sym->st_other = STV_PROTECTED;
 769                         } else if (((sdp->sd_flags & FLG_SY_DIR) == 0) &&
 770                             ((ofl->ofl_flags & FLG_OF_SYMBOLIC) == 0)) {
 771                                 sdp->sd_flags |= FLG_SY_NDIR;
 772                         }
 773                 }
 774                 sdp->sd_flags |= sdflags;
 775 
 776                 /*
 777                  * If the reference originated from a mapfile ensure
 778                  * we mark the symbol as used.
 779                  */
 780                 if (sdp->sd_flags & FLG_SY_MAPREF)
 781                         sdp->sd_flags |= FLG_SY_MAPUSED;
 782 
 783                 DBG_CALL(Dbg_syms_updated(ofl, sdp, name));
 784         }
 785         return (1);
 786 }
 787 
 788 
 789 /*
 790  * Undefined symbols can fall into one of four types:
 791  *
 792  *  -   the symbol is really undefined (SHN_UNDEF).
 793  *
 794  *  -   versioning has been enabled, however this symbol has not been assigned
 795  *      to one of the defined versions.
 796  *
 797  *  -   the symbol has been defined by an implicitly supplied library, ie. one
 798  *      which was encounted because it was NEEDED by another library, rather
 799  *      than from a command line supplied library which would become the only
 800  *      dependency of the output file being produced.
 801  *
 802  *  -   the symbol has been defined by a version of a shared object that is
 803  *      not permitted for this link-edit.
 804  *
 805  * In all cases the file who made the first reference to this symbol will have
 806  * been recorded via the `sa_rfile' pointer.
 807  */
 808 typedef enum {
 809         UNDEF,          NOVERSION,      IMPLICIT,       NOTAVAIL,
 810         BNDLOCAL
 811 } Type;
 812 
 813 static const Msg format[] = {
 814         MSG_SYM_UND_UNDEF,              /* MSG_INTL(MSG_SYM_UND_UNDEF) */
 815         MSG_SYM_UND_NOVER,              /* MSG_INTL(MSG_SYM_UND_NOVER) */
 816         MSG_SYM_UND_IMPL,               /* MSG_INTL(MSG_SYM_UND_IMPL) */
 817         MSG_SYM_UND_NOTA,               /* MSG_INTL(MSG_SYM_UND_NOTA) */
 818         MSG_SYM_UND_BNDLOCAL            /* MSG_INTL(MSG_SYM_UND_BNDLOCAL) */
 819 };
 820 
 821 /*
 822  * Issue an undefined symbol message for the given symbol.
 823  *
 824  * entry:
 825  *      ofl - Output descriptor
 826  *      sdp - Undefined symbol to report
 827  *      type - Type of undefined symbol
 828  *      ofl_flag - One of 0, FLG_OF_FATAL, or FLG_OF_WARN.
 829  *      undef_state - Address of variable to be initialized to 0
 830  *              before the first call to sym_undef_entry, and passed
 831  *              to each subsequent call. A non-zero value for *undef_state
 832  *              indicates that this is not the first call in the series.
 833  *
 834  * exit:
 835  *      If *undef_state is 0, a title is issued.
 836  *
 837  *      A message for the undefined symbol is issued.
 838  *
 839  *      If ofl_flag is non-zero, its value is OR'd into *undef_state. Otherwise,
 840  *      all bits other than FLG_OF_FATAL and FLG_OF_WARN are set, in order to
 841  *      provide *undef_state with a non-zero value. These other bits have
 842  *      no meaning beyond that, and serve to ensure that *undef_state is
 843  *      non-zero if sym_undef_entry() has been called.
 844  */
 845 static void
 846 sym_undef_entry(Ofl_desc *ofl, Sym_desc *sdp, Type type, ofl_flag_t ofl_flag,
 847     ofl_flag_t *undef_state)
 848 {
 849         const char      *name1, *name2, *name3;
 850         Ifl_desc        *ifl = sdp->sd_file;
 851         Sym_aux         *sap = sdp->sd_aux;
 852 
 853         if (*undef_state == 0)
 854                 ld_eprintf(ofl, ERR_NONE, MSG_INTL(MSG_SYM_FMT_UNDEF),
 855                     MSG_INTL(MSG_SYM_UNDEF_ITM_11),
 856                     MSG_INTL(MSG_SYM_UNDEF_ITM_21),
 857                     MSG_INTL(MSG_SYM_UNDEF_ITM_12),
 858                     MSG_INTL(MSG_SYM_UNDEF_ITM_22));
 859 
 860         ofl->ofl_flags |= ofl_flag;
 861         *undef_state |= ofl_flag ? ofl_flag : ~(FLG_OF_FATAL | FLG_OF_WARN);
 862 
 863         switch (type) {
 864         case UNDEF:
 865         case BNDLOCAL:
 866                 name1 = sap->sa_rfile;
 867                 break;
 868         case NOVERSION:
 869                 name1 = ifl->ifl_name;
 870                 break;
 871         case IMPLICIT:
 872                 name1 = sap->sa_rfile;
 873                 name2 = ifl->ifl_name;
 874                 break;
 875         case NOTAVAIL:
 876                 name1 = sap->sa_rfile;
 877                 name2 = sap->sa_vfile;
 878                 name3 = ifl->ifl_verndx[sap->sa_dverndx].vi_name;
 879                 break;
 880         default:
 881                 return;
 882         }
 883 
 884         ld_eprintf(ofl, ERR_NONE, MSG_INTL(format[type]),
 885             demangle(sdp->sd_name), name1, name2, name3);
 886 }
 887 
 888 /*
 889  * If an undef symbol exists naming a bound for the output section,
 890  * turn it into a defined symbol with the correct value.
 891  *
 892  * We set an arbitrary 1KB limit on the resulting symbol names.
 893  */
 894 static void
 895 sym_add_bounds(Ofl_desc *ofl, Os_desc *osp, Word bound)
 896 {
 897         Sym_desc *bsdp;
 898         char symn[1024];
 899         size_t nsz;
 900 
 901         switch (bound) {
 902         case SDAUX_ID_SECBOUND_START:
 903                 nsz = snprintf(symn, sizeof (symn), "%s%s",
 904                     MSG_ORIG(MSG_SYM_SECBOUND_START), osp->os_name);
 905                 if (nsz >= sizeof (symn))
 906                         return;
 907                 break;
 908         case SDAUX_ID_SECBOUND_STOP:
 909                 nsz = snprintf(symn, sizeof (symn), "%s%s",
 910                     MSG_ORIG(MSG_SYM_SECBOUND_STOP), osp->os_name);
 911                 if (nsz >= sizeof (symn))
 912                         return;
 913                 break;
 914         default:
 915                 assert(0);
 916         }
 917 
 918         if ((bsdp = ld_sym_find(symn, SYM_NOHASH, NULL, ofl)) != NULL) {
 919                 if ((bsdp->sd_shndx != SHN_UNDEF) &&
 920                     (bsdp->sd_ref == REF_REL_NEED)) {
 921                         ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_SYM_RESERVE),
 922                             symn, bsdp->sd_file->ifl_name);
 923                         return;
 924                 }
 925 
 926                 DBG_CALL(Dbg_syms_updated(ofl, bsdp, symn));
 927 
 928                 bsdp->sd_aux->sa_symspec = bound;
 929                 bsdp->sd_aux->sa_boundsec = osp;
 930                 bsdp->sd_flags |= FLG_SY_SPECSEC;
 931                 bsdp->sd_ref = REF_REL_NEED;
 932                 bsdp->sd_sym->st_info = ELF_ST_INFO(STB_GLOBAL, STT_NOTYPE);
 933                 bsdp->sd_sym->st_other = STV_PROTECTED;
 934                 bsdp->sd_isc = NULL;
 935                 bsdp->sd_sym->st_size = 0;
 936                 bsdp->sd_sym->st_value = 0;
 937                 bsdp->sd_shndx = bsdp->sd_sym->st_shndx = SHN_ABS;
 938         }
 939 }
 940 
 941 static Boolean
 942 is_cname(const char *name)
 943 {
 944         if (strlen(name) == strspn(name,
 945             "abcdefghijklmnopqrstuvwxyz"
 946             "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 947             "0123456789"
 948             "_"))
 949                 return (TRUE);
 950         else
 951                 return (FALSE);
 952 }
 953 
 954 /*
 955  * At this point all symbol input processing has been completed, therefore
 956  * complete the symbol table entries by generating any necessary internal
 957  * symbols.
 958  */
 959 uintptr_t
 960 ld_sym_spec(Ofl_desc *ofl)
 961 {
 962         Sym_desc        *sdp;
 963         Sg_desc         *sgp;
 964 
 965         DBG_CALL(Dbg_syms_spec_title(ofl->ofl_lml));
 966 
 967         /*
 968          * For each section in the output file, look for symbols named for the
 969          * __start/__stop patterns.  If references exist, flesh the symbols to
 970          * be defined.
 971          *
 972          * The symbols are given values at the same time as the other special
 973          * symbols.
 974          */
 975         if (!(ofl->ofl_flags & FLG_OF_RELOBJ) ||
 976             (ofl->ofl_flags & FLG_OF_KMOD)) {
 977                 Aliste          idx1;
 978 
 979                 for (APLIST_TRAVERSE(ofl->ofl_segs, idx1, sgp)) {
 980                         Os_desc *osp;
 981                         Aliste idx2;
 982 
 983                         for (APLIST_TRAVERSE(sgp->sg_osdescs, idx2, osp)) {
 984                                 if (is_cname(osp->os_name)) {
 985                                         sym_add_bounds(ofl, osp,
 986                                             SDAUX_ID_SECBOUND_START);
 987                                         sym_add_bounds(ofl, osp,
 988                                             SDAUX_ID_SECBOUND_STOP);
 989                                 }
 990                         }
 991                 }
 992         }
 993 
 994         if (ofl->ofl_flags & FLG_OF_RELOBJ)
 995                 return (1);
 996 
 997         if (sym_add_spec(MSG_ORIG(MSG_SYM_ETEXT), MSG_ORIG(MSG_SYM_ETEXT_U),
 998             SDAUX_ID_ETEXT, 0, (FLG_SY_DEFAULT | FLG_SY_EXPDEF),
 999             ofl) == S_ERROR)
1000                 return (S_ERROR);
1001         if (sym_add_spec(MSG_ORIG(MSG_SYM_EDATA), MSG_ORIG(MSG_SYM_EDATA_U),
1002             SDAUX_ID_EDATA, 0, (FLG_SY_DEFAULT | FLG_SY_EXPDEF),
1003             ofl) == S_ERROR)
1004                 return (S_ERROR);
1005         if (sym_add_spec(MSG_ORIG(MSG_SYM_END), MSG_ORIG(MSG_SYM_END_U),
1006             SDAUX_ID_END, FLG_SY_DYNSORT, (FLG_SY_DEFAULT | FLG_SY_EXPDEF),
1007             ofl) == S_ERROR)
1008                 return (S_ERROR);
1009         if (sym_add_spec(MSG_ORIG(MSG_SYM_L_END), MSG_ORIG(MSG_SYM_L_END_U),
1010             SDAUX_ID_END, 0, FLG_SY_HIDDEN, ofl) == S_ERROR)
1011                 return (S_ERROR);
1012         if (sym_add_spec(MSG_ORIG(MSG_SYM_L_START), MSG_ORIG(MSG_SYM_L_START_U),
1013             SDAUX_ID_START, 0, FLG_SY_HIDDEN, ofl) == S_ERROR)
1014                 return (S_ERROR);
1015 
1016         /*
1017          * Historically we've always produced a _DYNAMIC symbol, even for
1018          * static executables (in which case its value will be 0).
1019          */
1020         if (sym_add_spec(MSG_ORIG(MSG_SYM_DYNAMIC), MSG_ORIG(MSG_SYM_DYNAMIC_U),
1021             SDAUX_ID_DYN, FLG_SY_DYNSORT, (FLG_SY_DEFAULT | FLG_SY_EXPDEF),
1022             ofl) == S_ERROR)
1023                 return (S_ERROR);
1024 
1025         if (OFL_ALLOW_DYNSYM(ofl))
1026                 if (sym_add_spec(MSG_ORIG(MSG_SYM_PLKTBL),
1027                     MSG_ORIG(MSG_SYM_PLKTBL_U), SDAUX_ID_PLT,
1028                     FLG_SY_DYNSORT, (FLG_SY_DEFAULT | FLG_SY_EXPDEF),
1029                     ofl) == S_ERROR)
1030                         return (S_ERROR);
1031 
1032         /*
1033          * A GOT reference will be accompanied by the associated GOT symbol.
1034          * Make sure it gets assigned the appropriate special attributes.
1035          */
1036         if (((sdp = ld_sym_find(MSG_ORIG(MSG_SYM_GOFTBL_U),
1037             SYM_NOHASH, NULL, ofl)) != NULL) && (sdp->sd_ref != REF_DYN_SEEN)) {
1038                 if (sym_add_spec(MSG_ORIG(MSG_SYM_GOFTBL),
1039                     MSG_ORIG(MSG_SYM_GOFTBL_U), SDAUX_ID_GOT, FLG_SY_DYNSORT,
1040                     (FLG_SY_DEFAULT | FLG_SY_EXPDEF), ofl) == S_ERROR)
1041                         return (S_ERROR);
1042         }
1043 
1044         return (1);
1045 }
1046 
1047 /*
1048  * Determine a potential capability symbol's visibility.
1049  *
1050  * The -z symbolcap option transforms an object capabilities relocatable object
1051  * into a symbol capabilities relocatable object.  Any global function symbols,
1052  * or initialized global data symbols are candidates for transforming into local
1053  * symbol capabilities definitions.  However, if a user indicates that a symbol
1054  * should be demoted to local using a mapfile, then there is no need to
1055  * transform the associated global symbol.
1056  *
1057  * Normally, a symbol's visibility is determined after the symbol resolution
1058  * process, after all symbol state has been gathered and resolved.  However,
1059  * for -z symbolcap, this determination is too late.  When a global symbol is
1060  * read from an input file we need to determine it's visibility so as to decide
1061  * whether to create a local or not.
1062  *
1063  * If a user has explicitly defined this symbol as having local scope within a
1064  * mapfile, then a symbol of the same name already exists.  However, explicit
1065  * local definitions are uncommon, as most mapfiles define the global symbol
1066  * requirements together with an auto-reduction directive '*'.  If this state
1067  * has been defined, then we must make sure that the new symbol isn't a type
1068  * that can not be demoted to local.
1069  */
1070 static int
1071 sym_cap_vis(const char *name, Word hash, Sym *sym, Ofl_desc *ofl)
1072 {
1073         Sym_desc        *sdp;
1074         uchar_t         vis;
1075         avl_index_t     where;
1076         sd_flag_t       sdflags = 0;
1077 
1078         /*
1079          * Determine the visibility of the new symbol.
1080          */
1081         vis = ELF_ST_VISIBILITY(sym->st_other);
1082         switch (vis) {
1083         case STV_EXPORTED:
1084                 sdflags |= FLG_SY_EXPORT;
1085                 break;
1086         case STV_SINGLETON:
1087                 sdflags |= FLG_SY_SINGLE;
1088                 break;
1089         }
1090 
1091         /*
1092          * Determine whether a symbol definition already exists, and if so
1093          * obtain the visibility.
1094          */
1095         if ((sdp = ld_sym_find(name, hash, &where, ofl)) != NULL)
1096                 sdflags |= sdp->sd_flags;
1097 
1098         /*
1099          * Determine whether the symbol flags indicate this symbol should be
1100          * hidden.
1101          */
1102         if ((ofl->ofl_flags & (FLG_OF_AUTOLCL | FLG_OF_AUTOELM)) &&
1103             ((sdflags & MSK_SY_NOAUTO) == 0))
1104                 sdflags |= FLG_SY_HIDDEN;
1105 
1106         return ((sdflags & FLG_SY_HIDDEN) == 0);
1107 }
1108 
1109 /*
1110  * This routine checks to see if a symbols visibility needs to be reduced to
1111  * either SYMBOLIC or LOCAL.  This routine can be called from either
1112  * reloc_init() or sym_validate().
1113  */
1114 void
1115 ld_sym_adjust_vis(Sym_desc *sdp, Ofl_desc *ofl)
1116 {
1117         ofl_flag_t      oflags = ofl->ofl_flags;
1118         Sym             *sym = sdp->sd_sym;
1119 
1120         if ((sdp->sd_ref == REF_REL_NEED) &&
1121             (sdp->sd_sym->st_shndx != SHN_UNDEF)) {
1122                 /*
1123                  * If auto-reduction/elimination is enabled, reduce any
1124                  * non-versioned, and non-local capabilities global symbols.
1125                  * A symbol is a candidate for auto-reduction/elimination if:
1126                  *
1127                  *  -   the symbol wasn't explicitly defined within a mapfile
1128                  *      (in which case all the necessary state has been applied
1129                  *      to the symbol), or
1130                  *  -   the symbol isn't one of the family of reserved
1131                  *      special symbols (ie. _end, _etext, etc.), or
1132                  *  -   the symbol isn't a SINGLETON, or
1133                  *  -   the symbol wasn't explicitly defined within a version
1134                  *      definition associated with an input relocatable object.
1135                  *
1136                  * Indicate that the symbol has been reduced as it may be
1137                  * necessary to print these symbols later.
1138                  */
1139                 if ((oflags & (FLG_OF_AUTOLCL | FLG_OF_AUTOELM)) &&
1140                     ((sdp->sd_flags & MSK_SY_NOAUTO) == 0)) {
1141                         if ((sdp->sd_flags & FLG_SY_HIDDEN) == 0) {
1142                                 sdp->sd_flags |=
1143                                     (FLG_SY_REDUCED | FLG_SY_HIDDEN);
1144                         }
1145 
1146                         if (oflags & (FLG_OF_REDLSYM | FLG_OF_AUTOELM)) {
1147                                 sdp->sd_flags |= FLG_SY_ELIM;
1148                                 sym->st_other = STV_ELIMINATE |
1149                                     (sym->st_other & ~MSK_SYM_VISIBILITY);
1150                         } else if (ELF_ST_VISIBILITY(sym->st_other) !=
1151                             STV_INTERNAL)
1152                                 sym->st_other = STV_HIDDEN |
1153                                     (sym->st_other & ~MSK_SYM_VISIBILITY);
1154                 }
1155 
1156                 /*
1157                  * If -Bsymbolic is in effect, and the symbol hasn't explicitly
1158                  * been defined nodirect (via a mapfile), then bind the global
1159                  * symbol symbolically and assign the STV_PROTECTED visibility
1160                  * attribute.
1161                  */
1162                 if ((oflags & FLG_OF_SYMBOLIC) &&
1163                     ((sdp->sd_flags & (FLG_SY_HIDDEN | FLG_SY_NDIR)) == 0)) {
1164                         sdp->sd_flags |= FLG_SY_PROTECT;
1165                         if (ELF_ST_VISIBILITY(sym->st_other) == STV_DEFAULT)
1166                                 sym->st_other = STV_PROTECTED |
1167                                     (sym->st_other & ~MSK_SYM_VISIBILITY);
1168                 }
1169         }
1170 
1171         /*
1172          * Indicate that this symbol has had it's visibility checked so that
1173          * we don't need to do this investigation again.
1174          */
1175         sdp->sd_flags |= FLG_SY_VISIBLE;
1176 }
1177 
1178 /*
1179  * Make sure a symbol definition is local to the object being built.
1180  */
1181 inline static int
1182 ensure_sym_local(Ofl_desc *ofl, Sym_desc *sdp, const char *str)
1183 {
1184         if (sdp->sd_sym->st_shndx == SHN_UNDEF) {
1185                 if (str) {
1186                         ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_SYM_UNDEF),
1187                             str, demangle((char *)sdp->sd_name));
1188                 }
1189                 return (1);
1190         }
1191         if (sdp->sd_ref != REF_REL_NEED) {
1192                 if (str) {
1193                         ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_SYM_EXTERN),
1194                             str, demangle((char *)sdp->sd_name),
1195                             sdp->sd_file->ifl_name);
1196                 }
1197                 return (1);
1198         }
1199 
1200         sdp->sd_flags |= FLG_SY_UPREQD;
1201         if (sdp->sd_isc) {
1202                 sdp->sd_isc->is_flags |= FLG_IS_SECTREF;
1203                 sdp->sd_isc->is_file->ifl_flags |= FLG_IF_FILEREF;
1204         }
1205         return (0);
1206 }
1207 
1208 /*
1209  * Make sure all the symbol definitions required for initarray, finiarray, or
1210  * preinitarray's are local to the object being built.
1211  */
1212 static int
1213 ensure_array_local(Ofl_desc *ofl, APlist *apl, const char *str)
1214 {
1215         Aliste          idx;
1216         Sym_desc        *sdp;
1217         int             ret = 0;
1218 
1219         for (APLIST_TRAVERSE(apl, idx, sdp))
1220                 ret += ensure_sym_local(ofl, sdp, str);
1221 
1222         return (ret);
1223 }
1224 
1225 /*
1226  * After all symbol table input processing has been finished, and all relocation
1227  * counting has been carried out (ie. no more symbols will be read, generated,
1228  * or modified), validate and count the relevant entries:
1229  *
1230  *  -   check and print any undefined symbols remaining.  Note that if a symbol
1231  *      has been defined by virtue of the inclusion of  an implicit shared
1232  *      library, it is still classed as undefined.
1233  *
1234  *  -   count the number of global needed symbols together with the size of
1235  *      their associated name strings (if scoping has been indicated these
1236  *      symbols may be reduced to locals).
1237  *
1238  *  -   establish the size and alignment requirements for the global .bss
1239  *      section (the alignment of this section is based on the first symbol
1240  *      that it will contain).
1241  */
1242 uintptr_t
1243 ld_sym_validate(Ofl_desc *ofl)
1244 {
1245         Sym_avlnode     *sav;
1246         Sym_desc        *sdp;
1247         Sym             *sym;
1248         ofl_flag_t      oflags = ofl->ofl_flags;
1249         ofl_flag_t      undef = 0, needed = 0, verdesc = 0;
1250         Xword           bssalign = 0, tlsalign = 0;
1251         Boolean         need_bss, need_tlsbss;
1252         Xword           bsssize = 0, tlssize = 0;
1253 #if     defined(_ELF64)
1254         Xword           lbssalign = 0, lbsssize = 0;
1255         Boolean         need_lbss;
1256 #endif
1257         int             ret, allow_ldynsym;
1258         uchar_t         type;
1259         ofl_flag_t      undef_state = 0;
1260 
1261         DBG_CALL(Dbg_basic_validate(ofl->ofl_lml));
1262 
1263         /*
1264          * The need_XXX booleans are used to determine whether we need to
1265          * create each type of bss section. We used to create these sections
1266          * if the sum of the required sizes for each type were non-zero.
1267          * However, it is possible for a compiler to generate COMMON variables
1268          * of zero-length and this tricks that logic --- even zero-length
1269          * symbols need an output section.
1270          */
1271         need_bss = need_tlsbss = FALSE;
1272 #if     defined(_ELF64)
1273         need_lbss = FALSE;
1274 #endif
1275 
1276         /*
1277          * Determine how undefined symbols are handled:
1278          *
1279          * fatal:
1280          *      If this link-edit calls for no undefined symbols to remain
1281          *      (this is the default case when generating an executable but
1282          *      can be enforced for any object using -z defs), a fatal error
1283          *      condition will be indicated.
1284          *
1285          * warning:
1286          *      If we're creating a shared object, and either the -Bsymbolic
1287          *      flag is set, or the user has turned on the -z guidance feature,
1288          *      then a non-fatal warning is issued for each symbol.
1289          *
1290          * ignore:
1291          *      In all other cases, undefined symbols are quietly allowed.
1292          */
1293         if (oflags & FLG_OF_NOUNDEF) {
1294                 undef = FLG_OF_FATAL;
1295         } else if (oflags & FLG_OF_SHAROBJ) {
1296                 if ((oflags & FLG_OF_SYMBOLIC) ||
1297                     OFL_GUIDANCE(ofl, FLG_OFG_NO_DEFS))
1298                         undef = FLG_OF_WARN;
1299         }
1300 
1301         /*
1302          * If the symbol is referenced from an implicitly included shared object
1303          * (ie. it's not on the NEEDED list) then the symbol is also classified
1304          * as undefined and a fatal error condition will be indicated.
1305          */
1306         if ((oflags & FLG_OF_NOUNDEF) || !(oflags & FLG_OF_SHAROBJ))
1307                 needed = FLG_OF_FATAL;
1308         else if ((oflags & FLG_OF_SHAROBJ) &&
1309             OFL_GUIDANCE(ofl, FLG_OFG_NO_DEFS))
1310                 needed = FLG_OF_WARN;
1311 
1312         /*
1313          * If the output image is being versioned, then all symbol definitions
1314          * must be associated with a version.  Any symbol that isn't associated
1315          * with a version is classified as undefined, and a fatal error
1316          * condition is indicated.
1317          */
1318         if ((oflags & FLG_OF_VERDEF) && (ofl->ofl_vercnt > VER_NDX_GLOBAL))
1319                 verdesc = FLG_OF_FATAL;
1320 
1321         allow_ldynsym = OFL_ALLOW_LDYNSYM(ofl);
1322 
1323         if (allow_ldynsym) {
1324                 /*
1325                  * Normally, we disallow symbols with 0 size from appearing
1326                  * in a dyn[sym|tls]sort section. However, there are some
1327                  * symbols that serve special purposes that we want to exempt
1328                  * from this rule. Look them up, and set their
1329                  * FLG_SY_DYNSORT flag.
1330                  */
1331                 static const char *special[] = {
1332                         MSG_ORIG(MSG_SYM_INIT_U),       /* _init */
1333                         MSG_ORIG(MSG_SYM_FINI_U),       /* _fini */
1334                         MSG_ORIG(MSG_SYM_START),        /* _start */
1335                         NULL
1336                 };
1337                 int i;
1338 
1339                 for (i = 0; special[i] != NULL; i++) {
1340                         if (((sdp = ld_sym_find(special[i],
1341                             SYM_NOHASH, NULL, ofl)) != NULL) &&
1342                             (sdp->sd_sym->st_size == 0)) {
1343                                 if (ld_sym_copy(sdp) == S_ERROR)
1344                                         return (S_ERROR);
1345                                 sdp->sd_flags |= FLG_SY_DYNSORT;
1346                         }
1347                 }
1348         }
1349 
1350         /*
1351          * Collect and validate the globals from the internal symbol table.
1352          */
1353         for (sav = avl_first(&ofl->ofl_symavl); sav;
1354             sav = AVL_NEXT(&ofl->ofl_symavl, sav)) {
1355                 Is_desc         *isp;
1356                 int             undeferr = 0;
1357                 uchar_t         vis;
1358 
1359                 sdp = sav->sav_sdp;
1360 
1361                 /*
1362                  * If undefined symbols are allowed, and we're not being
1363                  * asked to supply guidance, ignore any symbols that are
1364                  * not needed.
1365                  */
1366                 if (!(oflags & FLG_OF_NOUNDEF) &&
1367                     !OFL_GUIDANCE(ofl, FLG_OFG_NO_DEFS) &&
1368                     (sdp->sd_ref == REF_DYN_SEEN))
1369                         continue;
1370 
1371                 /*
1372                  * If the symbol originates from an external or parent mapfile
1373                  * reference and hasn't been matched to a reference from a
1374                  * relocatable object, ignore it.
1375                  */
1376                 if ((sdp->sd_flags & (FLG_SY_EXTERN | FLG_SY_PARENT)) &&
1377                     ((sdp->sd_flags & FLG_SY_MAPUSED) == 0)) {
1378                         sdp->sd_flags |= FLG_SY_INVALID;
1379                         continue;
1380                 }
1381 
1382                 sym = sdp->sd_sym;
1383                 type = ELF_ST_TYPE(sym->st_info);
1384 
1385                 /*
1386                  * Sanity check TLS.
1387                  */
1388                 if ((type == STT_TLS) && (sym->st_size != 0) &&
1389                     (sym->st_shndx != SHN_UNDEF) &&
1390                     (sym->st_shndx != SHN_COMMON)) {
1391                         Is_desc         *isp = sdp->sd_isc;
1392                         Ifl_desc        *ifl = sdp->sd_file;
1393 
1394                         if ((isp == NULL) || (isp->is_shdr == NULL) ||
1395                             ((isp->is_shdr->sh_flags & SHF_TLS) == 0)) {
1396                                 ld_eprintf(ofl, ERR_FATAL,
1397                                     MSG_INTL(MSG_SYM_TLS),
1398                                     demangle(sdp->sd_name), ifl->ifl_name);
1399                                 continue;
1400                         }
1401                 }
1402 
1403                 if ((sdp->sd_flags & FLG_SY_VISIBLE) == 0)
1404                         ld_sym_adjust_vis(sdp, ofl);
1405 
1406                 if ((sdp->sd_flags & FLG_SY_REDUCED) &&
1407                     (oflags & FLG_OF_PROCRED)) {
1408                         DBG_CALL(Dbg_syms_reduce(ofl, DBG_SYM_REDUCE_GLOBAL,
1409                             sdp, 0, 0));
1410                 }
1411 
1412                 /*
1413                  * Record any STV_SINGLETON existence.
1414                  */
1415                 if ((vis = ELF_ST_VISIBILITY(sym->st_other)) == STV_SINGLETON)
1416                         ofl->ofl_dtflags_1 |= DF_1_SINGLETON;
1417 
1418                 /*
1419                  * If building a shared object or executable, and this is a
1420                  * non-weak UNDEF symbol with reduced visibility (STV_*), then
1421                  * give a fatal error.
1422                  */
1423                 if (((oflags & FLG_OF_RELOBJ) == 0) &&
1424                     (sym->st_shndx == SHN_UNDEF) &&
1425                     (ELF_ST_BIND(sym->st_info) != STB_WEAK)) {
1426                         if (vis && (vis != STV_SINGLETON)) {
1427                                 sym_undef_entry(ofl, sdp, BNDLOCAL,
1428                                     FLG_OF_FATAL, &undef_state);
1429                                 continue;
1430                         }
1431                 }
1432 
1433                 /*
1434                  * If this symbol is defined in a non-allocatable section,
1435                  * reduce it to local symbol.
1436                  */
1437                 if (((isp = sdp->sd_isc) != 0) && isp->is_shdr &&
1438                     ((isp->is_shdr->sh_flags & SHF_ALLOC) == 0)) {
1439                         sdp->sd_flags |= (FLG_SY_REDUCED | FLG_SY_HIDDEN);
1440                 }
1441 
1442                 /*
1443                  * If this symbol originated as a SHN_SUNW_IGNORE, it will have
1444                  * been processed as an SHN_UNDEF.  Return the symbol to its
1445                  * original index for validation, and propagation to the output
1446                  * file.
1447                  */
1448                 if (sdp->sd_flags & FLG_SY_IGNORE)
1449                         sdp->sd_shndx = SHN_SUNW_IGNORE;
1450 
1451                 if (undef) {
1452                         /*
1453                          * If a non-weak reference remains undefined, or if a
1454                          * mapfile reference is not bound to the relocatable
1455                          * objects that make up the object being built, we have
1456                          * a fatal error.
1457                          *
1458                          * The exceptions are symbols which are defined to be
1459                          * found in the parent (FLG_SY_PARENT), which is really
1460                          * only meaningful for direct binding, or are defined
1461                          * external (FLG_SY_EXTERN) so as to suppress -zdefs
1462                          * errors.
1463                          *
1464                          * Register symbols are always allowed to be UNDEF.
1465                          *
1466                          * Note that we don't include references created via -u
1467                          * in the same shared object binding test.  This is for
1468                          * backward compatibility, in that a number of archive
1469                          * makefile rules used -u to cause archive extraction.
1470                          * These same rules have been cut and pasted to apply
1471                          * to shared objects, and thus although the -u reference
1472                          * is redundant, flagging it as fatal could cause some
1473                          * build to fail.  Also we have documented the use of
1474                          * -u as a mechanism to cause binding to weak version
1475                          * definitions, thus giving users an error condition
1476                          * would be incorrect.
1477                          */
1478                         if (!(sdp->sd_flags & FLG_SY_REGSYM) &&
1479                             ((sym->st_shndx == SHN_UNDEF) &&
1480                             ((ELF_ST_BIND(sym->st_info) != STB_WEAK) &&
1481                             ((sdp->sd_flags &
1482                             (FLG_SY_PARENT | FLG_SY_EXTERN)) == 0)) ||
1483                             ((sdp->sd_flags &
1484                             (FLG_SY_MAPREF | FLG_SY_MAPUSED | FLG_SY_HIDDEN |
1485                             FLG_SY_PROTECT)) == FLG_SY_MAPREF))) {
1486                                 sym_undef_entry(ofl, sdp, UNDEF, undef,
1487                                     &undef_state);
1488                                 undeferr = 1;
1489                         }
1490 
1491                 } else {
1492                         /*
1493                          * For building things like shared objects (or anything
1494                          * -znodefs), undefined symbols are allowed.
1495                          *
1496                          * If a mapfile reference remains undefined the user
1497                          * would probably like a warning at least (they've
1498                          * usually mis-spelt the reference).  Refer to the above
1499                          * comments for discussion on -u references, which
1500                          * are not tested for in the same manner.
1501                          */
1502                         if ((sdp->sd_flags &
1503                             (FLG_SY_MAPREF | FLG_SY_MAPUSED)) ==
1504                             FLG_SY_MAPREF) {
1505                                 sym_undef_entry(ofl, sdp, UNDEF, FLG_OF_WARN,
1506                                     &undef_state);
1507                                 undeferr = 1;
1508                         }
1509                 }
1510 
1511                 /*
1512                  * If this symbol comes from a dependency mark the dependency
1513                  * as required (-z ignore can result in unused dependencies
1514                  * being dropped).  If we need to record dependency versioning
1515                  * information indicate what version of the needed shared object
1516                  * this symbol is part of.  Flag the symbol as undefined if it
1517                  * has not been made available to us.
1518                  */
1519                 if ((sdp->sd_ref == REF_DYN_NEED) &&
1520                     (!(sdp->sd_flags & FLG_SY_REFRSD))) {
1521                         sdp->sd_file->ifl_flags |= FLG_IF_DEPREQD;
1522 
1523                         /*
1524                          * Capture that we've bound to a symbol that doesn't
1525                          * allow being directly bound to.
1526                          */
1527                         if (sdp->sd_flags & FLG_SY_NDIR)
1528                                 ofl->ofl_flags1 |= FLG_OF1_NGLBDIR;
1529 
1530                         if (sdp->sd_file->ifl_vercnt) {
1531                                 int             vndx;
1532                                 Ver_index       *vip;
1533 
1534                                 vndx = sdp->sd_aux->sa_dverndx;
1535                                 vip = &sdp->sd_file->ifl_verndx[vndx];
1536                                 if (vip->vi_flags & FLG_VER_AVAIL) {
1537                                         vip->vi_flags |= FLG_VER_REFER;
1538                                 } else {
1539                                         sym_undef_entry(ofl, sdp, NOTAVAIL,
1540                                             FLG_OF_FATAL, &undef_state);
1541                                         continue;
1542                                 }
1543                         }
1544                 }
1545 
1546                 /*
1547                  * Test that we do not bind to symbol supplied from an implicit
1548                  * shared object.  If a binding is from a weak reference it can
1549                  * be ignored.
1550                  */
1551                 if (needed && !undeferr && (sdp->sd_flags & FLG_SY_GLOBREF) &&
1552                     (sdp->sd_ref == REF_DYN_NEED) &&
1553                     (sdp->sd_flags & FLG_SY_NOTAVAIL)) {
1554                         sym_undef_entry(ofl, sdp, IMPLICIT, needed,
1555                             &undef_state);
1556                         if (needed == FLG_OF_FATAL)
1557                                 continue;
1558                 }
1559 
1560                 /*
1561                  * Test that a symbol isn't going to be reduced to local scope
1562                  * which actually wants to bind to a shared object - if so it's
1563                  * a fatal error.
1564                  */
1565                 if ((sdp->sd_ref == REF_DYN_NEED) &&
1566                     (sdp->sd_flags & (FLG_SY_HIDDEN | FLG_SY_PROTECT))) {
1567                         sym_undef_entry(ofl, sdp, BNDLOCAL, FLG_OF_FATAL,
1568                             &undef_state);
1569                         continue;
1570                 }
1571 
1572                 /*
1573                  * If the output image is to be versioned then all symbol
1574                  * definitions must be associated with a version.  Remove any
1575                  * versioning that might be left associated with an undefined
1576                  * symbol.
1577                  */
1578                 if (verdesc && (sdp->sd_ref == REF_REL_NEED)) {
1579                         if (sym->st_shndx == SHN_UNDEF) {
1580                                 if (sdp->sd_aux && sdp->sd_aux->sa_overndx)
1581                                         sdp->sd_aux->sa_overndx = 0;
1582                         } else {
1583                                 if (!SYM_IS_HIDDEN(sdp) && sdp->sd_aux &&
1584                                     (sdp->sd_aux->sa_overndx == 0)) {
1585                                         sym_undef_entry(ofl, sdp, NOVERSION,
1586                                             verdesc, &undef_state);
1587                                         continue;
1588                                 }
1589                         }
1590                 }
1591 
1592                 /*
1593                  * If we don't need the symbol there's no need to process it
1594                  * any further.
1595                  */
1596                 if (sdp->sd_ref == REF_DYN_SEEN)
1597                         continue;
1598 
1599                 /*
1600                  * Calculate the size and alignment requirements for the global
1601                  * .bss and .tls sections.  If we're building a relocatable
1602                  * object only account for scoped COMMON symbols (these will
1603                  * be converted to .bss references).
1604                  *
1605                  * When -z nopartial is in effect, partially initialized
1606                  * symbols are directed to the special .data section
1607                  * created for that purpose (ofl->ofl_isparexpn).
1608                  * Otherwise, partially initialized symbols go to .bss.
1609                  *
1610                  * Also refer to make_mvsections() in sunwmove.c
1611                  */
1612                 if ((sym->st_shndx == SHN_COMMON) &&
1613                     (((oflags & FLG_OF_RELOBJ) == 0) ||
1614                     (SYM_IS_HIDDEN(sdp) && (oflags & FLG_OF_PROCRED)))) {
1615                         if ((sdp->sd_move == NULL) ||
1616                             ((sdp->sd_flags & FLG_SY_PAREXPN) == 0)) {
1617                                 if (type != STT_TLS) {
1618                                         need_bss = TRUE;
1619                                         bsssize = (Xword)S_ROUND(bsssize,
1620                                             sym->st_value) + sym->st_size;
1621                                         if (sym->st_value > bssalign)
1622                                                 bssalign = sym->st_value;
1623                                 } else {
1624                                         need_tlsbss = TRUE;
1625                                         tlssize = (Xword)S_ROUND(tlssize,
1626                                             sym->st_value) + sym->st_size;
1627                                         if (sym->st_value > tlsalign)
1628                                                 tlsalign = sym->st_value;
1629                                 }
1630                         }
1631                 }
1632 
1633 #if     defined(_ELF64)
1634                 /*
1635                  * Calculate the size and alignment requirement for the global
1636                  * .lbss. TLS or partially initialized symbols do not need to be
1637                  * considered yet.
1638                  */
1639                 if ((ld_targ.t_m.m_mach == EM_AMD64) &&
1640                     (sym->st_shndx == SHN_X86_64_LCOMMON)) {
1641                         need_lbss = TRUE;
1642                         lbsssize = (Xword)S_ROUND(lbsssize, sym->st_value) +
1643                             sym->st_size;
1644                         if (sym->st_value > lbssalign)
1645                                 lbssalign = sym->st_value;
1646                 }
1647 #endif
1648                 /*
1649                  * If a symbol was referenced via the command line
1650                  * (ld -u <>, ...), then this counts as a reference against the
1651                  * symbol. Mark any section that symbol is defined in.
1652                  */
1653                 if (((isp = sdp->sd_isc) != 0) &&
1654                     (sdp->sd_flags & FLG_SY_CMDREF)) {
1655                         isp->is_flags |= FLG_IS_SECTREF;
1656                         isp->is_file->ifl_flags |= FLG_IF_FILEREF;
1657                 }
1658 
1659                 /*
1660                  * Update the symbol count and the associated name string size.
1661                  * Note, a capabilities symbol must remain as visible as a
1662                  * global symbol.  However, the runtime linker recognizes the
1663                  * hidden requirement and ensures the symbol isn't made globally
1664                  * available at runtime.
1665                  */
1666                 if (SYM_IS_HIDDEN(sdp) && (oflags & FLG_OF_PROCRED)) {
1667                         /*
1668                          * If any reductions are being processed, keep a count
1669                          * of eliminated symbols, and if the symbol is being
1670                          * reduced to local, count it's size for the .symtab.
1671                          */
1672                         if (sdp->sd_flags & FLG_SY_ELIM) {
1673                                 ofl->ofl_elimcnt++;
1674                         } else {
1675                                 ofl->ofl_scopecnt++;
1676                                 if ((((sdp->sd_flags & FLG_SY_REGSYM) == 0) ||
1677                                     sym->st_name) && (st_insert(ofl->ofl_strtab,
1678                                     sdp->sd_name) == -1))
1679                                         return (S_ERROR);
1680                                 if (allow_ldynsym && sym->st_name &&
1681                                     ldynsym_symtype[type]) {
1682                                         ofl->ofl_dynscopecnt++;
1683                                         if (st_insert(ofl->ofl_dynstrtab,
1684                                             sdp->sd_name) == -1)
1685                                                 return (S_ERROR);
1686                                         /* Include it in sort section? */
1687                                         DYNSORT_COUNT(sdp, sym, type, ++);
1688                                 }
1689                         }
1690                 } else {
1691                         ofl->ofl_globcnt++;
1692 
1693                         /*
1694                          * Check to see if this global variable should go into
1695                          * a sort section. Sort sections require a
1696                          * .SUNW_ldynsym section, so, don't check unless a
1697                          * .SUNW_ldynsym is allowed.
1698                          */
1699                         if (allow_ldynsym)
1700                                 DYNSORT_COUNT(sdp, sym, type, ++);
1701 
1702                         /*
1703                          * If global direct bindings are in effect, or this
1704                          * symbol has bound to a dependency which was specified
1705                          * as requiring direct bindings, and it hasn't
1706                          * explicitly been defined as a non-direct binding
1707                          * symbol, mark it.
1708                          */
1709                         if (((ofl->ofl_dtflags_1 & DF_1_DIRECT) || (isp &&
1710                             (isp->is_file->ifl_flags & FLG_IF_DIRECT))) &&
1711                             ((sdp->sd_flags & FLG_SY_NDIR) == 0))
1712                                 sdp->sd_flags |= FLG_SY_DIR;
1713 
1714                         /*
1715                          * Insert the symbol name.
1716                          */
1717                         if (((sdp->sd_flags & FLG_SY_REGSYM) == 0) ||
1718                             sym->st_name) {
1719                                 if (st_insert(ofl->ofl_strtab,
1720                                     sdp->sd_name) == -1)
1721                                         return (S_ERROR);
1722 
1723                                 if (!(ofl->ofl_flags & FLG_OF_RELOBJ) &&
1724                                     (st_insert(ofl->ofl_dynstrtab,
1725                                     sdp->sd_name) == -1))
1726                                         return (S_ERROR);
1727                         }
1728 
1729                         /*
1730                          * If this section offers a global symbol - record that
1731                          * fact.
1732                          */
1733                         if (isp) {
1734                                 isp->is_flags |= FLG_IS_SECTREF;
1735                                 isp->is_file->ifl_flags |= FLG_IF_FILEREF;
1736                         }
1737                 }
1738         }
1739 
1740         /*
1741          * Guidance: Use -z defs|nodefs when building shared objects.
1742          *
1743          * Our caller issues this, unless we mask it out here. So we mask it
1744          * out unless we've issued at least one warnings or fatal error.
1745          */
1746         if (!((oflags & FLG_OF_SHAROBJ) && OFL_GUIDANCE(ofl, FLG_OFG_NO_DEFS) &&
1747             (undef_state & (FLG_OF_FATAL | FLG_OF_WARN))))
1748                 ofl->ofl_guideflags |= FLG_OFG_NO_DEFS;
1749 
1750         /*
1751          * If we've encountered a fatal error during symbol validation then
1752          * return now.
1753          */
1754         if (ofl->ofl_flags & FLG_OF_FATAL)
1755                 return (1);
1756 
1757         /*
1758          * Now that symbol resolution is completed, scan any register symbols.
1759          * From now on, we're only interested in those that contribute to the
1760          * output file.
1761          */
1762         if (ofl->ofl_regsyms) {
1763                 int     ndx;
1764 
1765                 for (ndx = 0; ndx < ofl->ofl_regsymsno; ndx++) {
1766                         if ((sdp = ofl->ofl_regsyms[ndx]) == NULL)
1767                                 continue;
1768                         if (sdp->sd_ref != REF_REL_NEED) {
1769                                 ofl->ofl_regsyms[ndx] = NULL;
1770                                 continue;
1771                         }
1772 
1773                         ofl->ofl_regsymcnt++;
1774                         if (sdp->sd_sym->st_name == 0)
1775                                 sdp->sd_name = MSG_ORIG(MSG_STR_EMPTY);
1776 
1777                         if (SYM_IS_HIDDEN(sdp) ||
1778                             (ELF_ST_BIND(sdp->sd_sym->st_info) == STB_LOCAL))
1779                                 ofl->ofl_lregsymcnt++;
1780                 }
1781         }
1782 
1783         /*
1784          * Generate the .bss section now that we know its size and alignment.
1785          */
1786         if (need_bss) {
1787                 if (ld_make_bss(ofl, bsssize, bssalign,
1788                     ld_targ.t_id.id_bss) == S_ERROR)
1789                         return (S_ERROR);
1790         }
1791         if (need_tlsbss) {
1792                 if (ld_make_bss(ofl, tlssize, tlsalign,
1793                     ld_targ.t_id.id_tlsbss) == S_ERROR)
1794                         return (S_ERROR);
1795         }
1796 #if     defined(_ELF64)
1797         if ((ld_targ.t_m.m_mach == EM_AMD64) &&
1798             need_lbss && !(oflags & FLG_OF_RELOBJ)) {
1799                 if (ld_make_bss(ofl, lbsssize, lbssalign,
1800                     ld_targ.t_id.id_lbss) == S_ERROR)
1801                         return (S_ERROR);
1802         }
1803 #endif
1804         /*
1805          * Determine what entry point symbol we need, and if found save its
1806          * symbol descriptor so that we can update the ELF header entry with the
1807          * symbols value later (see update_oehdr).  Make sure the symbol is
1808          * tagged to ensure its update in case -s is in effect.  Use any -e
1809          * option first, or the default entry points `_start' and `main'.
1810          */
1811         ret = 0;
1812         if (ofl->ofl_entry) {
1813                 if ((sdp = ld_sym_find(ofl->ofl_entry, SYM_NOHASH,
1814                     NULL, ofl)) == NULL) {
1815                         ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_ARG_NOENTRY),
1816                             ofl->ofl_entry);
1817                         ret++;
1818                 } else if (ensure_sym_local(ofl, sdp,
1819                     MSG_INTL(MSG_SYM_ENTRY)) != 0) {
1820                         ret++;
1821                 } else {
1822                         ofl->ofl_entry = (void *)sdp;
1823                 }
1824         } else if (((sdp = ld_sym_find(MSG_ORIG(MSG_SYM_START),
1825             SYM_NOHASH, NULL, ofl)) != NULL) && (ensure_sym_local(ofl,
1826             sdp, 0) == 0)) {
1827                 ofl->ofl_entry = (void *)sdp;
1828 
1829         } else if (((sdp = ld_sym_find(MSG_ORIG(MSG_SYM_MAIN),
1830             SYM_NOHASH, NULL, ofl)) != NULL) && (ensure_sym_local(ofl,
1831             sdp, 0) == 0)) {
1832                 ofl->ofl_entry = (void *)sdp;
1833         }
1834 
1835         /*
1836          * If ld -zdtrace=<sym> was given, then validate that the symbol is
1837          * defined within the current object being built.
1838          */
1839         if ((sdp = ofl->ofl_dtracesym) != 0)
1840                 ret += ensure_sym_local(ofl, sdp, MSG_ORIG(MSG_STR_DTRACE));
1841 
1842         /*
1843          * If any initarray, finiarray or preinitarray functions have been
1844          * requested, make sure they are defined within the current object
1845          * being built.
1846          */
1847         if (ofl->ofl_initarray) {
1848                 ret += ensure_array_local(ofl, ofl->ofl_initarray,
1849                     MSG_ORIG(MSG_SYM_INITARRAY));
1850         }
1851         if (ofl->ofl_finiarray) {
1852                 ret += ensure_array_local(ofl, ofl->ofl_finiarray,
1853                     MSG_ORIG(MSG_SYM_FINIARRAY));
1854         }
1855         if (ofl->ofl_preiarray) {
1856                 ret += ensure_array_local(ofl, ofl->ofl_preiarray,
1857                     MSG_ORIG(MSG_SYM_PREINITARRAY));
1858         }
1859 
1860         if (ret)
1861                 return (S_ERROR);
1862 
1863         /*
1864          * If we're required to record any needed dependencies versioning
1865          * information calculate it now that all symbols have been validated.
1866          */
1867         if ((oflags & (FLG_OF_VERNEED | FLG_OF_NOVERSEC)) == FLG_OF_VERNEED)
1868                 return (ld_vers_check_need(ofl));
1869         else
1870                 return (1);
1871 }
1872 
1873 /*
1874  * qsort(3c) comparison function.  As an optimization for associating weak
1875  * symbols to their strong counterparts sort global symbols according to their
1876  * section index, address and binding.
1877  */
1878 static int
1879 compare(const void *sdpp1, const void *sdpp2)
1880 {
1881         Sym_desc        *sdp1 = *((Sym_desc **)sdpp1);
1882         Sym_desc        *sdp2 = *((Sym_desc **)sdpp2);
1883         Sym             *sym1, *sym2;
1884         uchar_t         bind1, bind2;
1885 
1886         /*
1887          * Symbol descriptors may be zero, move these to the front of the
1888          * sorted array.
1889          */
1890         if (sdp1 == NULL)
1891                 return (-1);
1892         if (sdp2 == NULL)
1893                 return (1);
1894 
1895         sym1 = sdp1->sd_sym;
1896         sym2 = sdp2->sd_sym;
1897 
1898         /*
1899          * Compare the symbols section index.  This is important when sorting
1900          * the symbol tables of relocatable objects.  In this case, a symbols
1901          * value is the offset within the associated section, and thus many
1902          * symbols can have the same value, but are effectively different
1903          * addresses.
1904          */
1905         if (sym1->st_shndx > sym2->st_shndx)
1906                 return (1);
1907         if (sym1->st_shndx < sym2->st_shndx)
1908                 return (-1);
1909 
1910         /*
1911          * Compare the symbols value (address).
1912          */
1913         if (sym1->st_value > sym2->st_value)
1914                 return (1);
1915         if (sym1->st_value < sym2->st_value)
1916                 return (-1);
1917 
1918         bind1 = ELF_ST_BIND(sym1->st_info);
1919         bind2 = ELF_ST_BIND(sym2->st_info);
1920 
1921         /*
1922          * If two symbols have the same address place the weak symbol before
1923          * any strong counterpart.
1924          */
1925         if (bind1 > bind2)
1926                 return (-1);
1927         if (bind1 < bind2)
1928                 return (1);
1929 
1930         return (0);
1931 }
1932 
1933 /*
1934  * Issue a MSG_SYM_BADADDR error from ld_sym_process(). This error
1935  * is issued when a symbol address/size is not contained by the
1936  * target section.
1937  *
1938  * Such objects are at least partially corrupt, and the user would
1939  * be well advised to be skeptical of them, and to ask their compiler
1940  * supplier to fix the problem. However, a distinction needs to be
1941  * made between symbols that reference readonly text, and those that
1942  * access writable data. Other than throwing off profiling results,
1943  * the readonly section case is less serious. We have encountered
1944  * such objects in the field. In order to allow existing objects
1945  * to continue working, we issue a warning rather than a fatal error
1946  * if the symbol is against readonly text. Other cases are fatal.
1947  */
1948 static void
1949 issue_badaddr_msg(Ifl_desc *ifl, Ofl_desc *ofl, Sym_desc *sdp,
1950     Sym *sym, Word shndx)
1951 {
1952         Error           err;
1953         const char      *msg;
1954 
1955         if ((sdp->sd_isc->is_shdr->sh_flags & (SHF_WRITE | SHF_ALLOC)) ==
1956             SHF_ALLOC) {
1957                 msg = MSG_INTL(MSG_SYM_BADADDR_ROTXT);
1958                 err = ERR_WARNING;
1959         } else {
1960                 msg = MSG_INTL(MSG_SYM_BADADDR);
1961                 err = ERR_FATAL;
1962         }
1963 
1964         ld_eprintf(ofl, err, msg, demangle(sdp->sd_name),
1965             ifl->ifl_name, shndx, sdp->sd_isc->is_name,
1966             EC_XWORD(sdp->sd_isc->is_shdr->sh_size),
1967             EC_XWORD(sym->st_value), EC_XWORD(sym->st_size));
1968 }
1969 
1970 /*
1971  * Global symbols that are candidates for translation to local capability
1972  * symbols under -z symbolcap, are maintained on a local symbol list.  Once
1973  * all symbols of a file are processed, this list is traversed to cull any
1974  * unnecessary weak symbol aliases.
1975  */
1976 typedef struct {
1977         Sym_desc        *c_nsdp;        /* new lead symbol */
1978         Sym_desc        *c_osdp;        /* original symbol */
1979         Cap_group       *c_group;       /* symbol capability group */
1980         Word            c_ndx;          /* symbol index */
1981 } Cap_pair;
1982 
1983 /*
1984  * Process the symbol table for the specified input file.  At this point all
1985  * input sections from this input file have been assigned an input section
1986  * descriptor which is saved in the `ifl_isdesc' array.
1987  *
1988  *  -   local symbols are saved (as is) if the input file is a  relocatable
1989  *      object
1990  *
1991  *  -   global symbols are added to the linkers internal symbol table if they
1992  *      are not already present, otherwise a symbol resolution function is
1993  *      called upon to resolve the conflict.
1994  */
1995 uintptr_t
1996 ld_sym_process(Is_desc *isc, Ifl_desc *ifl, Ofl_desc *ofl)
1997 {
1998         /*
1999          * This macro tests the given symbol to see if it is out of
2000          * range relative to the section it references.
2001          *
2002          * entry:
2003          *      - ifl is a relative object (ET_REL)
2004          *      _sdp - Symbol descriptor
2005          *      _sym - Symbol
2006          *      _type - Symbol type
2007          *
2008          * The following are tested:
2009          *      - Symbol length is non-zero
2010          *      - Symbol type is a type that references code or data
2011          *      - Referenced section is not 0 (indicates an UNDEF symbol)
2012          *        and is not in the range of special values above SHN_LORESERVE
2013          *        (excluding SHN_XINDEX, which is OK).
2014          *      - We have a valid section header for the target section
2015          *
2016          * If the above are all true, and the symbol position is not
2017          * contained by the target section, this macro evaluates to
2018          * True (1). Otherwise, False(0).
2019          */
2020 #define SYM_LOC_BADADDR(_sdp, _sym, _type) \
2021         (_sym->st_size && dynsymsort_symtype[_type] && \
2022         (_sym->st_shndx != SHN_UNDEF) && \
2023         ((_sym->st_shndx < SHN_LORESERVE) || \
2024                 (_sym->st_shndx == SHN_XINDEX)) && \
2025         _sdp->sd_isc && _sdp->sd_isc->is_shdr && \
2026         ((_sym->st_value + _sym->st_size) > _sdp->sd_isc->is_shdr->sh_size))
2027 
2028         Conv_inv_buf_t  inv_buf;
2029         Sym             *sym = (Sym *)isc->is_indata->d_buf;
2030         Word            *symshndx = NULL;
2031         Shdr            *shdr = isc->is_shdr;
2032         Sym_desc        *sdp;
2033         size_t          strsize;
2034         char            *strs;
2035         uchar_t         type, bind;
2036         Word            ndx, hash, local, total;
2037         uchar_t         osabi = ifl->ifl_ehdr->e_ident[EI_OSABI];
2038         Half            mach = ifl->ifl_ehdr->e_machine;
2039         Half            etype = ifl->ifl_ehdr->e_type;
2040         int             etype_rel;
2041         const char      *symsecname, *strsecname;
2042         Word            symsecndx;
2043         avl_index_t     where;
2044         int             test_gnu_hidden_bit, weak;
2045         Cap_desc        *cdp = NULL;
2046         Alist           *cappairs = NULL;
2047 
2048         /*
2049          * Its possible that a file may contain more that one symbol table,
2050          * ie. .dynsym and .symtab in a shared library.  Only process the first
2051          * table (here, we assume .dynsym comes before .symtab).
2052          */
2053         if (ifl->ifl_symscnt)
2054                 return (1);
2055 
2056         if (isc->is_symshndx)
2057                 symshndx = isc->is_symshndx->is_indata->d_buf;
2058 
2059         DBG_CALL(Dbg_syms_process(ofl->ofl_lml, ifl));
2060 
2061         symsecndx = isc->is_scnndx;
2062         if (isc->is_name)
2063                 symsecname = isc->is_name;
2064         else
2065                 symsecname = MSG_ORIG(MSG_STR_EMPTY);
2066 
2067         /*
2068          * From the symbol tables section header information determine which
2069          * strtab table is needed to locate the actual symbol names.
2070          */
2071         if (ifl->ifl_flags & FLG_IF_HSTRTAB) {
2072                 ndx = shdr->sh_link;
2073                 if ((ndx == 0) || (ndx >= ifl->ifl_shnum)) {
2074                         ld_eprintf(ofl, ERR_FATAL,
2075                             MSG_INTL(MSG_FIL_INVSHLINK), ifl->ifl_name,
2076                             EC_WORD(symsecndx), symsecname, EC_XWORD(ndx));
2077                         return (S_ERROR);
2078                 }
2079                 strsize = ifl->ifl_isdesc[ndx]->is_shdr->sh_size;
2080                 strs = ifl->ifl_isdesc[ndx]->is_indata->d_buf;
2081                 if (ifl->ifl_isdesc[ndx]->is_name)
2082                         strsecname = ifl->ifl_isdesc[ndx]->is_name;
2083                 else
2084                         strsecname = MSG_ORIG(MSG_STR_EMPTY);
2085         } else {
2086                 /*
2087                  * There is no string table section in this input file
2088                  * although there are symbols in this symbol table section.
2089                  * This means that these symbols do not have names.
2090                  * Currently, only scratch register symbols are allowed
2091                  * not to have names.
2092                  */
2093                 strsize = 0;
2094                 strs = (char *)MSG_ORIG(MSG_STR_EMPTY);
2095                 strsecname = MSG_ORIG(MSG_STR_EMPTY);
2096         }
2097 
2098         /*
2099          * Determine the number of local symbols together with the total
2100          * number we have to process.
2101          */
2102         total = (Word)(shdr->sh_size / shdr->sh_entsize);
2103         local = shdr->sh_info;
2104 
2105         /*
2106          * Allocate a symbol table index array and a local symbol array
2107          * (global symbols are processed and added to the ofl->ofl_symbkt[]
2108          * array).  If we are dealing with a relocatable object, allocate the
2109          * local symbol descriptors.  If this isn't a relocatable object we
2110          * still have to process any shared object locals to determine if any
2111          * register symbols exist.  Although these aren't added to the output
2112          * image, they are used as part of symbol resolution.
2113          */
2114         if ((ifl->ifl_oldndx = libld_malloc((size_t)(total *
2115             sizeof (Sym_desc *)))) == NULL)
2116                 return (S_ERROR);
2117         etype_rel = (etype == ET_REL);
2118         if (etype_rel && local) {
2119                 if ((ifl->ifl_locs =
2120                     libld_calloc(sizeof (Sym_desc), local)) == NULL)
2121                         return (S_ERROR);
2122                 /* LINTED */
2123                 ifl->ifl_locscnt = (Word)local;
2124         }
2125         ifl->ifl_symscnt = total;
2126 
2127         /*
2128          * If there are local symbols to save add them to the symbol table
2129          * index array.
2130          */
2131         if (local) {
2132                 int             allow_ldynsym = OFL_ALLOW_LDYNSYM(ofl);
2133                 Sym_desc        *last_file_sdp = NULL;
2134                 int             last_file_ndx = 0;
2135 
2136                 for (sym++, ndx = 1; ndx < local; sym++, ndx++) {
2137                         sd_flag_t       sdflags = FLG_SY_CLEAN;
2138                         Word            shndx;
2139                         const char      *name;
2140                         Sym_desc        *rsdp;
2141                         int             shndx_bad = 0;
2142                         int             symtab_enter = 1;
2143 
2144                         /*
2145                          * Determine and validate the associated section index.
2146                          */
2147                         if (symshndx && (sym->st_shndx == SHN_XINDEX)) {
2148                                 shndx = symshndx[ndx];
2149                         } else if ((shndx = sym->st_shndx) >= SHN_LORESERVE) {
2150                                 sdflags |= FLG_SY_SPECSEC;
2151                         } else if (shndx > ifl->ifl_shnum) {
2152                                 /* We need the name before we can issue error */
2153                                 shndx_bad = 1;
2154                         }
2155 
2156                         /*
2157                          * Check if st_name has a valid value or not.
2158                          */
2159                         if ((name = string(ofl, ifl, sym, strs, strsize, ndx,
2160                             shndx, symsecndx, symsecname, strsecname,
2161                             &sdflags)) == NULL)
2162                                 continue;
2163 
2164                         /*
2165                          * Now that we have the name, if the section index
2166                          * was bad, report it.
2167                          */
2168                         if (shndx_bad) {
2169                                 ld_eprintf(ofl, ERR_WARNING,
2170                                     MSG_INTL(MSG_SYM_INVSHNDX),
2171                                     demangle_symname(name, symsecname, ndx),
2172                                     ifl->ifl_name,
2173                                     conv_sym_shndx(osabi, mach, sym->st_shndx,
2174                                     CONV_FMT_DECIMAL, &inv_buf));
2175                                 continue;
2176                         }
2177 
2178                         /*
2179                          * If this local symbol table originates from a shared
2180                          * object, then we're only interested in recording
2181                          * register symbols.  As local symbol descriptors aren't
2182                          * allocated for shared objects, one will be allocated
2183                          * to associated with the register symbol.  This symbol
2184                          * won't become part of the output image, but we must
2185                          * process it to test for register conflicts.
2186                          */
2187                         rsdp = sdp = NULL;
2188                         if (sdflags & FLG_SY_REGSYM) {
2189                                 /*
2190                                  * The presence of FLG_SY_REGSYM means that
2191                                  * the pointers in ld_targ.t_ms are non-NULL.
2192                                  */
2193                                 rsdp = (*ld_targ.t_ms.ms_reg_find)(sym, ofl);
2194                                 if (rsdp != 0) {
2195                                         /*
2196                                          * The fact that another register def-
2197                                          * inition has been found is fatal.
2198                                          * Call the verification routine to get
2199                                          * the error message and move on.
2200                                          */
2201                                         (void) (*ld_targ.t_ms.ms_reg_check)
2202                                             (rsdp, sym, name, ifl, ofl);
2203                                         continue;
2204                                 }
2205 
2206                                 if (etype == ET_DYN) {
2207                                         if ((sdp = libld_calloc(
2208                                             sizeof (Sym_desc), 1)) == NULL)
2209                                                 return (S_ERROR);
2210                                         sdp->sd_ref = REF_DYN_SEEN;
2211 
2212                                         /* Will not appear in output object */
2213                                         symtab_enter = 0;
2214                                 }
2215                         } else if (etype == ET_DYN)
2216                                 continue;
2217 
2218                         /*
2219                          * Fill in the remaining symbol descriptor information.
2220                          */
2221                         if (sdp == NULL) {
2222                                 sdp = &(ifl->ifl_locs[ndx]);
2223                                 sdp->sd_ref = REF_REL_NEED;
2224                                 sdp->sd_symndx = ndx;
2225                         }
2226                         if (rsdp == NULL) {
2227                                 sdp->sd_name = name;
2228                                 sdp->sd_sym = sym;
2229                                 sdp->sd_shndx = shndx;
2230                                 sdp->sd_flags = sdflags;
2231                                 sdp->sd_file = ifl;
2232                                 ifl->ifl_oldndx[ndx] = sdp;
2233                         }
2234 
2235                         DBG_CALL(Dbg_syms_entry(ofl->ofl_lml, ndx, sdp));
2236 
2237                         /*
2238                          * Reclassify any SHN_SUNW_IGNORE symbols to SHN_UNDEF
2239                          * so as to simplify future processing.
2240                          */
2241                         if (sym->st_shndx == SHN_SUNW_IGNORE) {
2242                                 sdp->sd_shndx = shndx = SHN_UNDEF;
2243                                 sdp->sd_flags |= (FLG_SY_IGNORE | FLG_SY_ELIM);
2244                         }
2245 
2246                         /*
2247                          * Process any register symbols.
2248                          */
2249                         if (sdp->sd_flags & FLG_SY_REGSYM) {
2250                                 /*
2251                                  * Add a diagnostic to indicate we've caught a
2252                                  * register symbol, as this can be useful if a
2253                                  * register conflict is later discovered.
2254                                  */
2255                                 DBG_CALL(Dbg_syms_entered(ofl, sym, sdp));
2256 
2257                                 /*
2258                                  * If this register symbol hasn't already been
2259                                  * recorded, enter it now.
2260                                  *
2261                                  * The presence of FLG_SY_REGSYM means that
2262                                  * the pointers in ld_targ.t_ms are non-NULL.
2263                                  */
2264                                 if ((rsdp == NULL) &&
2265                                     ((*ld_targ.t_ms.ms_reg_enter)(sdp, ofl) ==
2266                                     0))
2267                                         return (S_ERROR);
2268                         }
2269 
2270                         /*
2271                          * Assign an input section.
2272                          */
2273                         if ((sym->st_shndx != SHN_UNDEF) &&
2274                             ((sdp->sd_flags & FLG_SY_SPECSEC) == 0))
2275                                 sdp->sd_isc = ifl->ifl_isdesc[shndx];
2276 
2277                         /*
2278                          * If this symbol falls within the range of a section
2279                          * being discarded, then discard the symbol itself.
2280                          * There is no reason to keep this local symbol.
2281                          */
2282                         if (sdp->sd_isc &&
2283                             (sdp->sd_isc->is_flags & FLG_IS_DISCARD)) {
2284                                 sdp->sd_flags |= FLG_SY_ISDISC;
2285                                 DBG_CALL(Dbg_syms_discarded(ofl->ofl_lml, sdp));
2286                                 continue;
2287                         }
2288 
2289                         /*
2290                          * Skip any section symbols as new versions of these
2291                          * will be created.
2292                          */
2293                         if ((type = ELF_ST_TYPE(sym->st_info)) == STT_SECTION) {
2294                                 if (sym->st_shndx == SHN_UNDEF) {
2295                                         ld_eprintf(ofl, ERR_WARNING,
2296                                             MSG_INTL(MSG_SYM_INVSHNDX),
2297                                             demangle_symname(name, symsecname,
2298                                             ndx), ifl->ifl_name,
2299                                             conv_sym_shndx(osabi, mach,
2300                                             sym->st_shndx, CONV_FMT_DECIMAL,
2301                                             &inv_buf));
2302                                 }
2303                                 continue;
2304                         }
2305 
2306                         /*
2307                          * For a relocatable object, if this symbol is defined
2308                          * and has non-zero length and references an address
2309                          * within an associated section, then check its extents
2310                          * to make sure the section boundaries encompass it.
2311                          * If they don't, the ELF file is corrupt.
2312                          */
2313                         if (etype_rel) {
2314                                 if (SYM_LOC_BADADDR(sdp, sym, type)) {
2315                                         issue_badaddr_msg(ifl, ofl, sdp,
2316                                             sym, shndx);
2317                                         if (ofl->ofl_flags & FLG_OF_FATAL)
2318                                                 continue;
2319                                 }
2320 
2321                                 /*
2322                                  * We have observed relocatable objects
2323                                  * containing identical adjacent STT_FILE
2324                                  * symbols. Discard any other than the first,
2325                                  * as they are all equivalent and the extras
2326                                  * do not add information.
2327                                  *
2328                                  * For the purpose of this test, we assume
2329                                  * that only the symbol type and the string
2330                                  * table offset (st_name) matter.
2331                                  */
2332                                 if (type == STT_FILE) {
2333                                         int toss = (last_file_sdp != NULL) &&
2334                                             ((ndx - 1) == last_file_ndx) &&
2335                                             (sym->st_name ==
2336                                             last_file_sdp->sd_sym->st_name);
2337 
2338                                         last_file_sdp = sdp;
2339                                         last_file_ndx = ndx;
2340                                         if (toss) {
2341                                                 sdp->sd_flags |= FLG_SY_INVALID;
2342                                                 DBG_CALL(Dbg_syms_dup_discarded(
2343                                                     ofl->ofl_lml, ndx, sdp));
2344                                                 continue;
2345                                         }
2346                                 }
2347                         }
2348 
2349 
2350                         /*
2351                          * Sanity check for TLS
2352                          */
2353                         if ((sym->st_size != 0) && ((type == STT_TLS) &&
2354                             (sym->st_shndx != SHN_COMMON))) {
2355                                 Is_desc *isp = sdp->sd_isc;
2356 
2357                                 if ((isp == NULL) || (isp->is_shdr == NULL) ||
2358                                     ((isp->is_shdr->sh_flags & SHF_TLS) == 0)) {
2359                                         ld_eprintf(ofl, ERR_FATAL,
2360                                             MSG_INTL(MSG_SYM_TLS),
2361                                             demangle(sdp->sd_name),
2362                                             ifl->ifl_name);
2363                                         continue;
2364                                 }
2365                         }
2366 
2367                         /*
2368                          * Carry our some basic sanity checks (these are just
2369                          * some of the erroneous symbol entries we've come
2370                          * across, there's probably a lot more).  The symbol
2371                          * will not be carried forward to the output file, which
2372                          * won't be a problem unless a relocation is required
2373                          * against it.
2374                          */
2375                         if (((sdp->sd_flags & FLG_SY_SPECSEC) &&
2376                             ((sym->st_shndx == SHN_COMMON)) ||
2377                             ((type == STT_FILE) &&
2378                             (sym->st_shndx != SHN_ABS))) ||
2379                             (sdp->sd_isc && (sdp->sd_isc->is_osdesc == NULL))) {
2380                                 ld_eprintf(ofl, ERR_WARNING,
2381                                     MSG_INTL(MSG_SYM_INVSHNDX),
2382                                     demangle_symname(name, symsecname, ndx),
2383                                     ifl->ifl_name,
2384                                     conv_sym_shndx(osabi, mach, sym->st_shndx,
2385                                     CONV_FMT_DECIMAL, &inv_buf));
2386                                 sdp->sd_isc = NULL;
2387                                 sdp->sd_flags |= FLG_SY_INVALID;
2388                                 continue;
2389                         }
2390 
2391                         /*
2392                          * As these local symbols will become part of the output
2393                          * image, record their number and name string size.
2394                          * Globals are counted after all input file processing
2395                          * (and hence symbol resolution) is complete during
2396                          * sym_validate().
2397                          */
2398                         if (!(ofl->ofl_flags & FLG_OF_REDLSYM) &&
2399                             symtab_enter) {
2400                                 ofl->ofl_locscnt++;
2401 
2402                                 if ((((sdp->sd_flags & FLG_SY_REGSYM) == 0) ||
2403                                     sym->st_name) && (st_insert(ofl->ofl_strtab,
2404                                     sdp->sd_name) == -1))
2405                                         return (S_ERROR);
2406 
2407                                 if (allow_ldynsym && sym->st_name &&
2408                                     ldynsym_symtype[type]) {
2409                                         ofl->ofl_dynlocscnt++;
2410                                         if (st_insert(ofl->ofl_dynstrtab,
2411                                             sdp->sd_name) == -1)
2412                                                 return (S_ERROR);
2413                                         /* Include it in sort section? */
2414                                         DYNSORT_COUNT(sdp, sym, type, ++);
2415                                 }
2416                         }
2417                 }
2418         }
2419 
2420         /*
2421          * The GNU ld interprets the top bit of the 16-bit Versym value
2422          * (0x8000) as the "hidden" bit. If this bit is set, the linker
2423          * is supposed to act as if that symbol does not exist. The Solaris
2424          * linker does not support this mechanism, or the model of interface
2425          * evolution that it allows, but we honor it in GNU ld produced
2426          * objects in order to interoperate with them.
2427          *
2428          * Determine if we should honor the GNU hidden bit for this file.
2429          */
2430         test_gnu_hidden_bit = ((ifl->ifl_flags & FLG_IF_GNUVER) != 0) &&
2431             (ifl->ifl_versym != NULL);
2432 
2433         /*
2434          * Determine whether object capabilities for this file are being
2435          * converted into symbol capabilities.  If so, global function symbols,
2436          * and initialized global data symbols, need special translation and
2437          * processing.
2438          */
2439         if ((etype == ET_REL) && (ifl->ifl_flags & FLG_IF_OTOSCAP))
2440                 cdp = ifl->ifl_caps;
2441 
2442         /*
2443          * Now scan the global symbols entering them in the internal symbol
2444          * table or resolving them as necessary.
2445          */
2446         sym = (Sym *)isc->is_indata->d_buf;
2447         sym += local;
2448         weak = 0;
2449         /* LINTED */
2450         for (ndx = (int)local; ndx < total; sym++, ndx++) {
2451                 const char      *name;
2452                 sd_flag_t       sdflags = 0;
2453                 Word            shndx;
2454                 int             shndx_bad = 0;
2455                 Sym             *nsym = sym;
2456                 Cap_pair        *cpp = NULL;
2457                 uchar_t         ntype;
2458 
2459                 /*
2460                  * Determine and validate the associated section index.
2461                  */
2462                 if (symshndx && (nsym->st_shndx == SHN_XINDEX)) {
2463                         shndx = symshndx[ndx];
2464                 } else if ((shndx = nsym->st_shndx) >= SHN_LORESERVE) {
2465                         sdflags |= FLG_SY_SPECSEC;
2466                 } else if (shndx > ifl->ifl_shnum) {
2467                         /* We need the name before we can issue error */
2468                         shndx_bad = 1;
2469                 }
2470 
2471                 /*
2472                  * Check if st_name has a valid value or not.
2473                  */
2474                 if ((name = string(ofl, ifl, nsym, strs, strsize, ndx, shndx,
2475                     symsecndx, symsecname, strsecname, &sdflags)) == NULL)
2476                         continue;
2477 
2478                 /*
2479                  * Now that we have the name, report an erroneous section index.
2480                  */
2481                 if (shndx_bad) {
2482                         ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_SYM_INVSHNDX),
2483                             demangle_symname(name, symsecname, ndx),
2484                             ifl->ifl_name,
2485                             conv_sym_shndx(osabi, mach, nsym->st_shndx,
2486                             CONV_FMT_DECIMAL, &inv_buf));
2487                         continue;
2488                 }
2489 
2490                 /*
2491                  * Test for the GNU hidden bit, and ignore symbols that
2492                  * have it set.
2493                  */
2494                 if (test_gnu_hidden_bit &&
2495                     ((ifl->ifl_versym[ndx] & 0x8000) != 0))
2496                         continue;
2497 
2498                 /*
2499                  * The linker itself will generate symbols for _end, _etext,
2500                  * _edata, _DYNAMIC and _PROCEDURE_LINKAGE_TABLE_, so don't
2501                  * bother entering these symbols from shared objects.  This
2502                  * results in some wasted resolution processing, which is hard
2503                  * to feel, but if nothing else, pollutes diagnostic relocation
2504                  * output.
2505                  */
2506                 if (name[0] && (etype == ET_DYN) && (nsym->st_size == 0) &&
2507                     (ELF_ST_TYPE(nsym->st_info) == STT_OBJECT) &&
2508                     (name[0] == '_') && ((name[1] == 'e') ||
2509                     (name[1] == 'D') || (name[1] == 'P')) &&
2510                     ((strcmp(name, MSG_ORIG(MSG_SYM_ETEXT_U)) == 0) ||
2511                     (strcmp(name, MSG_ORIG(MSG_SYM_EDATA_U)) == 0) ||
2512                     (strcmp(name, MSG_ORIG(MSG_SYM_END_U)) == 0) ||
2513                     (strcmp(name, MSG_ORIG(MSG_SYM_DYNAMIC_U)) == 0) ||
2514                     (strcmp(name, MSG_ORIG(MSG_SYM_PLKTBL_U)) == 0))) {
2515                         ifl->ifl_oldndx[ndx] = 0;
2516                         continue;
2517                 }
2518 
2519                 /*
2520                  * The '-z wrap=XXX' option emulates the GNU ld --wrap=XXX
2521                  * option. When XXX is the symbol to be wrapped:
2522                  *
2523                  *  -   An undefined reference to XXX is converted to __wrap_XXX
2524                  *  -   An undefined reference to __real_XXX is converted to XXX
2525                  *
2526                  * The idea is that the user can supply a wrapper function
2527                  * __wrap_XXX that does some work, and then uses the name
2528                  * __real_XXX to pass the call on to the real function. The
2529                  * wrapper objects are linked with the original unmodified
2530                  * objects to produce a wrapped version of the output object.
2531                  */
2532                 if (ofl->ofl_wrap && name[0] && (shndx == SHN_UNDEF)) {
2533                         WrapSymNode wsn, *wsnp;
2534 
2535                         /*
2536                          * If this is the __real_XXX form, advance the
2537                          * pointer to reference the wrapped name.
2538                          */
2539                         wsn.wsn_name = name;
2540                         if ((*name == '_') &&
2541                             (strncmp(name, MSG_ORIG(MSG_STR_UU_REAL_U),
2542                             MSG_STR_UU_REAL_U_SIZE) == 0))
2543                                 wsn.wsn_name += MSG_STR_UU_REAL_U_SIZE;
2544 
2545                         /*
2546                          * Is this symbol in the wrap AVL tree? If so, map
2547                          * XXX to __wrap_XXX, and __real_XXX to XXX. Note that
2548                          * wsn.wsn_name will equal the current value of name
2549                          * if the __real_ prefix is not present.
2550                          */
2551                         if ((wsnp = avl_find(ofl->ofl_wrap, &wsn, 0)) != NULL) {
2552                                 const char *old_name = name;
2553 
2554                                 name = (wsn.wsn_name == name) ?
2555                                     wsnp->wsn_wrapname : wsn.wsn_name;
2556                                 DBG_CALL(Dbg_syms_wrap(ofl->ofl_lml, ndx,
2557                                     old_name, name));
2558                         }
2559                 }
2560 
2561                 /*
2562                  * Determine and validate the symbols binding.
2563                  */
2564                 bind = ELF_ST_BIND(nsym->st_info);
2565                 if ((bind != STB_GLOBAL) && (bind != STB_WEAK)) {
2566                         ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_SYM_NONGLOB),
2567                             demangle_symname(name, symsecname, ndx),
2568                             ifl->ifl_name,
2569                             conv_sym_info_bind(bind, 0, &inv_buf));
2570                         continue;
2571                 }
2572                 if (bind == STB_WEAK)
2573                         weak++;
2574 
2575                 /*
2576                  * If this symbol falls within the range of a section being
2577                  * discarded, then discard the symbol itself.
2578                  */
2579                 if (((sdflags & FLG_SY_SPECSEC) == 0) &&
2580                     (nsym->st_shndx != SHN_UNDEF)) {
2581                         Is_desc *isp;
2582 
2583                         if (shndx >= ifl->ifl_shnum) {
2584                                 /*
2585                                  * Carry our some basic sanity checks
2586                                  * The symbol will not be carried forward to
2587                                  * the output file, which won't be a problem
2588                                  * unless a relocation is required against it.
2589                                  */
2590                                 ld_eprintf(ofl, ERR_WARNING,
2591                                     MSG_INTL(MSG_SYM_INVSHNDX),
2592                                     demangle_symname(name, symsecname, ndx),
2593                                     ifl->ifl_name,
2594                                     conv_sym_shndx(osabi, mach, nsym->st_shndx,
2595                                     CONV_FMT_DECIMAL, &inv_buf));
2596                                 continue;
2597                         }
2598 
2599                         isp = ifl->ifl_isdesc[shndx];
2600                         if (isp && (isp->is_flags & FLG_IS_DISCARD)) {
2601                                 if ((sdp =
2602                                     libld_calloc(sizeof (Sym_desc), 1)) == NULL)
2603                                         return (S_ERROR);
2604 
2605                                 /*
2606                                  * Create a dummy symbol entry so that if we
2607                                  * find any references to this discarded symbol
2608                                  * we can compensate.
2609                                  */
2610                                 sdp->sd_name = name;
2611                                 sdp->sd_sym = nsym;
2612                                 sdp->sd_file = ifl;
2613                                 sdp->sd_isc = isp;
2614                                 sdp->sd_flags = FLG_SY_ISDISC;
2615                                 ifl->ifl_oldndx[ndx] = sdp;
2616 
2617                                 DBG_CALL(Dbg_syms_discarded(ofl->ofl_lml, sdp));
2618                                 continue;
2619                         }
2620                 }
2621 
2622                 /*
2623                  * If object capabilities for this file are being converted
2624                  * into symbol capabilities, then:
2625                  *
2626                  *  -   Any global function, or initialized global data symbol
2627                  *      definitions (ie., those that are not associated with
2628                  *      special symbol types, ie., ABS, COMMON, etc.), and which
2629                  *      have not been reduced to locals, are converted to symbol
2630                  *      references (UNDEF).  This ensures that any reference to
2631                  *      the original symbol, for example from a relocation, get
2632                  *      associated to a capabilities family lead symbol, ie., a
2633                  *      generic instance.
2634                  *
2635                  *  -   For each global function, or object symbol definition,
2636                  *      a new local symbol is created.  The function or object
2637                  *      is renamed using the capabilities CA_SUNW_ID definition
2638                  *      (which might have been fabricated for this purpose -
2639                  *      see get_cap_group()).  The new symbol name is:
2640                  *
2641                  *          <original name>%<capability group identifier>
2642                  *
2643                  *      This symbol is associated to the same location, and
2644                  *      becomes a capabilities family member.
2645                  */
2646                 /* LINTED */
2647                 hash = (Word)elf_hash(name);
2648 
2649                 ntype = ELF_ST_TYPE(nsym->st_info);
2650                 if (cdp && (nsym->st_shndx != SHN_UNDEF) &&
2651                     ((sdflags & FLG_SY_SPECSEC) == 0) &&
2652                     ((ntype == STT_FUNC) || (ntype == STT_OBJECT))) {
2653                         /*
2654                          * Determine this symbol's visibility.  If a mapfile has
2655                          * indicated this symbol should be local, then there's
2656                          * no point in transforming this global symbol to a
2657                          * capabilities symbol.  Otherwise, create a symbol
2658                          * capability pair descriptor to record this symbol as
2659                          * a candidate for translation.
2660                          */
2661                         if (sym_cap_vis(name, hash, sym, ofl) &&
2662                             ((cpp = alist_append(&cappairs, NULL,
2663                             sizeof (Cap_pair), AL_CNT_CAP_PAIRS)) == NULL))
2664                                 return (S_ERROR);
2665                 }
2666 
2667                 if (cpp) {
2668                         Sym     *rsym;
2669 
2670                         DBG_CALL(Dbg_syms_cap_convert(ofl, ndx, name, nsym));
2671 
2672                         /*
2673                          * Allocate a new symbol descriptor to represent the
2674                          * transformed global symbol.  The descriptor points
2675                          * to the original symbol information (which might
2676                          * indicate a global or weak visibility).  The symbol
2677                          * information will be transformed into a local symbol
2678                          * later, after any weak aliases are culled.
2679                          */
2680                         if ((cpp->c_osdp =
2681                             libld_malloc(sizeof (Sym_desc))) == NULL)
2682                                 return (S_ERROR);
2683 
2684                         cpp->c_osdp->sd_name = name;
2685                         cpp->c_osdp->sd_sym = nsym;
2686                         cpp->c_osdp->sd_shndx = shndx;
2687                         cpp->c_osdp->sd_file = ifl;
2688                         cpp->c_osdp->sd_isc = ifl->ifl_isdesc[shndx];
2689                         cpp->c_osdp->sd_ref = REF_REL_NEED;
2690 
2691                         /*
2692                          * Save the capabilities group this symbol belongs to,
2693                          * and the original symbol index.
2694                          */
2695                         cpp->c_group = cdp->ca_groups->apl_data[0];
2696                         cpp->c_ndx = ndx;
2697 
2698                         /*
2699                          * Replace the original symbol definition with a symbol
2700                          * reference.  Make sure this reference isn't left as a
2701                          * weak.
2702                          */
2703                         if ((rsym = libld_malloc(sizeof (Sym))) == NULL)
2704                                 return (S_ERROR);
2705 
2706                         *rsym = *nsym;
2707 
2708                         rsym->st_info = ELF_ST_INFO(STB_GLOBAL, ntype);
2709                         rsym->st_shndx = shndx = SHN_UNDEF;
2710                         rsym->st_value = 0;
2711                         rsym->st_size = 0;
2712 
2713                         sdflags |= FLG_SY_CAP;
2714 
2715                         nsym = rsym;
2716                 }
2717 
2718                 /*
2719                  * If the symbol does not already exist in the internal symbol
2720                  * table add it, otherwise resolve the conflict.  If the symbol
2721                  * from this file is kept, retain its symbol table index for
2722                  * possible use in associating a global alias.
2723                  */
2724                 if ((sdp = ld_sym_find(name, hash, &where, ofl)) == NULL) {
2725                         DBG_CALL(Dbg_syms_global(ofl->ofl_lml, ndx, name));
2726                         if ((sdp = ld_sym_enter(name, nsym, hash, ifl, ofl, ndx,
2727                             shndx, sdflags, &where)) == (Sym_desc *)S_ERROR)
2728                                 return (S_ERROR);
2729 
2730                 } else if (ld_sym_resolve(sdp, nsym, ifl, ofl, ndx, shndx,
2731                     sdflags) == S_ERROR)
2732                         return (S_ERROR);
2733 
2734                 /*
2735                  * Now that we have a symbol descriptor, retain the descriptor
2736                  * for later use by symbol capabilities processing.
2737                  */
2738                 if (cpp)
2739                         cpp->c_nsdp = sdp;
2740 
2741                 /*
2742                  * After we've compared a defined symbol in one shared
2743                  * object, flag the symbol so we don't compare it again.
2744                  */
2745                 if ((etype == ET_DYN) && (nsym->st_shndx != SHN_UNDEF) &&
2746                     ((sdp->sd_flags & FLG_SY_SOFOUND) == 0))
2747                         sdp->sd_flags |= FLG_SY_SOFOUND;
2748 
2749                 /*
2750                  * If the symbol is accepted from this file retain the symbol
2751                  * index for possible use in aliasing.
2752                  */
2753                 if (sdp->sd_file == ifl)
2754                         sdp->sd_symndx = ndx;
2755 
2756                 ifl->ifl_oldndx[ndx] = sdp;
2757 
2758                 /*
2759                  * If we've accepted a register symbol, continue to validate
2760                  * it.
2761                  */
2762                 if (sdp->sd_flags & FLG_SY_REGSYM) {
2763                         Sym_desc        *rsdp;
2764 
2765                         /*
2766                          * The presence of FLG_SY_REGSYM means that
2767                          * the pointers in ld_targ.t_ms are non-NULL.
2768                          */
2769                         rsdp = (*ld_targ.t_ms.ms_reg_find)(sdp->sd_sym, ofl);
2770                         if (rsdp == NULL) {
2771                                 if ((*ld_targ.t_ms.ms_reg_enter)(sdp, ofl) == 0)
2772                                         return (S_ERROR);
2773                         } else if (rsdp != sdp) {
2774                                 (void) (*ld_targ.t_ms.ms_reg_check)(rsdp,
2775                                     sdp->sd_sym, sdp->sd_name, ifl, ofl);
2776                         }
2777                 }
2778 
2779                 /*
2780                  * For a relocatable object, if this symbol is defined
2781                  * and has non-zero length and references an address
2782                  * within an associated section, then check its extents
2783                  * to make sure the section boundaries encompass it.
2784                  * If they don't, the ELF file is corrupt. Note that this
2785                  * global symbol may have come from another file to satisfy
2786                  * an UNDEF symbol of the same name from this one. In that
2787                  * case, we don't check it, because it was already checked
2788                  * as part of its own file.
2789                  */
2790                 if (etype_rel && (sdp->sd_file == ifl)) {
2791                         Sym *tsym = sdp->sd_sym;
2792 
2793                         if (SYM_LOC_BADADDR(sdp, tsym,
2794                             ELF_ST_TYPE(tsym->st_info))) {
2795                                 issue_badaddr_msg(ifl, ofl, sdp,
2796                                     tsym, tsym->st_shndx);
2797                                 continue;
2798                         }
2799                 }
2800         }
2801         DBG_CALL(Dbg_util_nl(ofl->ofl_lml, DBG_NL_STD));
2802 
2803         /*
2804          * Associate weak (alias) symbols to their non-weak counterparts by
2805          * scanning the global symbols one more time.
2806          *
2807          * This association is needed when processing the symbols from a shared
2808          * object dependency when a a weak definition satisfies a reference:
2809          *
2810          *  -   When building a dynamic executable, if a referenced symbol is a
2811          *      data item, the symbol data is copied to the executables address
2812          *      space.  In this copy-relocation case, we must also reassociate
2813          *      the alias symbol with its new location in the executable.
2814          *
2815          *  -   If the referenced symbol is a function then we may need to
2816          *      promote the symbols binding from undefined weak to undefined,
2817          *      otherwise the run-time linker will not generate the correct
2818          *      relocation error should the symbol not be found.
2819          *
2820          * Weak alias association is also required when a local dynsym table
2821          * is being created.  This table should only contain one instance of a
2822          * symbol that is associated to a given address.
2823          *
2824          * The true association between a weak/strong symbol pair is that both
2825          * symbol entries are identical, thus first we create a sorted symbol
2826          * list keyed off of the symbols section index and value.  If the symbol
2827          * belongs to the same section and has the same value, then the chances
2828          * are that the rest of the symbols data is the same.  This list is then
2829          * scanned for weak symbols, and if one is found then any strong
2830          * association will exist in the entries that follow.  Thus we just have
2831          * to scan one (typically a single alias) or more (in the uncommon
2832          * instance of multiple weak to strong associations) entries to
2833          * determine if a match exists.
2834          */
2835         if (weak && (OFL_ALLOW_LDYNSYM(ofl) || (etype == ET_DYN)) &&
2836             (total > local)) {
2837                 static Sym_desc **sort;
2838                 static size_t   osize = 0;
2839                 size_t          nsize = (total - local) * sizeof (Sym_desc *);
2840 
2841                 /*
2842                  * As we might be processing many input files, and many symbols,
2843                  * try and reuse a static sort buffer.  Note, presently we're
2844                  * playing the game of never freeing any buffers as there's a
2845                  * belief this wastes time.
2846                  */
2847                 if ((osize == 0) || (nsize > osize)) {
2848                         if ((sort = libld_malloc(nsize)) == NULL)
2849                                 return (S_ERROR);
2850                         osize = nsize;
2851                 }
2852                 (void) memcpy((void *)sort, &ifl->ifl_oldndx[local], nsize);
2853 
2854                 qsort(sort, (total - local), sizeof (Sym_desc *), compare);
2855 
2856                 for (ndx = 0; ndx < (total - local); ndx++) {
2857                         Sym_desc        *wsdp = sort[ndx];
2858                         Sym             *wsym;
2859                         int             sndx;
2860 
2861                         /*
2862                          * Ignore any empty symbol descriptor, or the case where
2863                          * the symbol has been resolved to a different file.
2864                          */
2865                         if ((wsdp == NULL) || (wsdp->sd_file != ifl))
2866                                 continue;
2867 
2868                         wsym = wsdp->sd_sym;
2869 
2870                         if ((wsym->st_shndx == SHN_UNDEF) ||
2871                             (wsdp->sd_flags & FLG_SY_SPECSEC) ||
2872                             (ELF_ST_BIND(wsym->st_info) != STB_WEAK))
2873                                 continue;
2874 
2875                         /*
2876                          * We have a weak symbol, if it has a strong alias it
2877                          * will have been sorted to one of the following sort
2878                          * table entries.  Note that we could have multiple weak
2879                          * symbols aliased to one strong (if this occurs then
2880                          * the strong symbol only maintains one alias back to
2881                          * the last weak).
2882                          */
2883                         for (sndx = ndx + 1; sndx < (total - local); sndx++) {
2884                                 Sym_desc        *ssdp = sort[sndx];
2885                                 Sym             *ssym;
2886                                 sd_flag_t       w_dynbits, s_dynbits;
2887 
2888                                 /*
2889                                  * Ignore any empty symbol descriptor, or the
2890                                  * case where the symbol has been resolved to a
2891                                  * different file.
2892                                  */
2893                                 if ((ssdp == NULL) || (ssdp->sd_file != ifl))
2894                                         continue;
2895 
2896                                 ssym = ssdp->sd_sym;
2897 
2898                                 if (ssym->st_shndx == SHN_UNDEF)
2899                                         continue;
2900 
2901                                 if ((ssym->st_shndx != wsym->st_shndx) ||
2902                                     (ssym->st_value != wsym->st_value))
2903                                         break;
2904 
2905                                 if ((ssym->st_size != wsym->st_size) ||
2906                                     (ssdp->sd_flags & FLG_SY_SPECSEC) ||
2907                                     (ELF_ST_BIND(ssym->st_info) == STB_WEAK))
2908                                         continue;
2909 
2910                                 /*
2911                                  * If a sharable object, set link fields so
2912                                  * that they reference each other.`
2913                                  */
2914                                 if (etype == ET_DYN) {
2915                                         ssdp->sd_aux->sa_linkndx =
2916                                             (Word)wsdp->sd_symndx;
2917                                         wsdp->sd_aux->sa_linkndx =
2918                                             (Word)ssdp->sd_symndx;
2919                                 }
2920 
2921                                 /*
2922                                  * Determine which of these two symbols go into
2923                                  * the sort section.  If a mapfile has made
2924                                  * explicit settings of the FLG_SY_*DYNSORT
2925                                  * flags for both symbols, then we do what they
2926                                  * say.  If one has the DYNSORT flags set, we
2927                                  * set the NODYNSORT bit in the other.  And if
2928                                  * neither has an explicit setting, then we
2929                                  * favor the weak symbol because they usually
2930                                  * lack the leading underscore.
2931                                  */
2932                                 w_dynbits = wsdp->sd_flags &
2933                                     (FLG_SY_DYNSORT | FLG_SY_NODYNSORT);
2934                                 s_dynbits = ssdp->sd_flags &
2935                                     (FLG_SY_DYNSORT | FLG_SY_NODYNSORT);
2936                                 if (!(w_dynbits && s_dynbits)) {
2937                                         if (s_dynbits) {
2938                                                 if (s_dynbits == FLG_SY_DYNSORT)
2939                                                         wsdp->sd_flags |=
2940                                                             FLG_SY_NODYNSORT;
2941                                         } else if (w_dynbits !=
2942                                             FLG_SY_NODYNSORT) {
2943                                                 ssdp->sd_flags |=
2944                                                     FLG_SY_NODYNSORT;
2945                                         }
2946                                 }
2947                                 break;
2948                         }
2949                 }
2950         }
2951 
2952         /*
2953          * Having processed all symbols, under -z symbolcap, reprocess any
2954          * symbols that are being translated from global to locals.  The symbol
2955          * pair that has been collected defines the original symbol (c_osdp),
2956          * which will become a local, and the new symbol (c_nsdp), which will
2957          * become a reference (UNDEF) for the original.
2958          *
2959          * Scan these symbol pairs looking for weak symbols, which have non-weak
2960          * aliases.  There is no need to translate both of these symbols to
2961          * locals, only the global is necessary.
2962          */
2963         if (cappairs) {
2964                 Aliste          idx1;
2965                 Cap_pair        *cpp1;
2966 
2967                 for (ALIST_TRAVERSE(cappairs, idx1, cpp1)) {
2968                         Sym_desc        *sdp1 = cpp1->c_osdp;
2969                         Sym             *sym1 = sdp1->sd_sym;
2970                         uchar_t         bind1 = ELF_ST_BIND(sym1->st_info);
2971                         Aliste          idx2;
2972                         Cap_pair        *cpp2;
2973 
2974                         /*
2975                          * If this symbol isn't weak, it's capability member is
2976                          * retained for the creation of a local symbol.
2977                          */
2978                         if (bind1 != STB_WEAK)
2979                                 continue;
2980 
2981                         /*
2982                          * If this is a weak symbol, traverse the capabilities
2983                          * list again to determine if a corresponding non-weak
2984                          * symbol exists.
2985                          */
2986                         for (ALIST_TRAVERSE(cappairs, idx2, cpp2)) {
2987                                 Sym_desc        *sdp2 = cpp2->c_osdp;
2988                                 Sym             *sym2 = sdp2->sd_sym;
2989                                 uchar_t         bind2 =
2990                                     ELF_ST_BIND(sym2->st_info);
2991 
2992                                 if ((cpp1 == cpp2) ||
2993                                     (cpp1->c_group != cpp2->c_group) ||
2994                                     (sym1->st_value != sym2->st_value) ||
2995                                     (bind2 == STB_WEAK))
2996                                         continue;
2997 
2998                                 /*
2999                                  * The weak symbol (sym1) has a non-weak (sym2)
3000                                  * counterpart.  There's no point in translating
3001                                  * both of these equivalent symbols to locals.
3002                                  * Add this symbol capability alias to the
3003                                  * capabilities family information, and remove
3004                                  * the weak symbol.
3005                                  */
3006                                 if (ld_cap_add_family(ofl, cpp2->c_nsdp,
3007                                     cpp1->c_nsdp, NULL, NULL) == S_ERROR)
3008                                         return (S_ERROR);
3009 
3010                                 free((void *)cpp1->c_osdp);
3011                                 (void) alist_delete(cappairs, &idx1);
3012                         }
3013                 }
3014 
3015                 DBG_CALL(Dbg_util_nl(ofl->ofl_lml, DBG_NL_STD));
3016 
3017                 /*
3018                  * The capability pairs information now represents all the
3019                  * global symbols that need transforming to locals.  These
3020                  * local symbols are renamed using their group identifiers.
3021                  */
3022                 for (ALIST_TRAVERSE(cappairs, idx1, cpp1)) {
3023                         Sym_desc        *osdp = cpp1->c_osdp;
3024                         Objcapset       *capset;
3025                         size_t          nsize, tsize;
3026                         const char      *oname;
3027                         char            *cname, *idstr;
3028                         Sym             *csym;
3029 
3030                         /*
3031                          * If the local symbol has not yet been translated
3032                          * convert it to a local symbol with a name.
3033                          */
3034                         if ((osdp->sd_flags & FLG_SY_CAP) != 0)
3035                                 continue;
3036 
3037                         /*
3038                          * As we're converting object capabilities to symbol
3039                          * capabilities, obtain the capabilities set for this
3040                          * object, so as to retrieve the CA_SUNW_ID value.
3041                          */
3042                         capset = &cpp1->c_group->cg_set;
3043 
3044                         /*
3045                          * Create a new name from the existing symbol and the
3046                          * capabilities group identifier.  Note, the delimiter
3047                          * between the symbol name and identifier name is hard-
3048                          * coded here (%), so that we establish a convention
3049                          * for transformed symbol names.
3050                          */
3051                         oname = osdp->sd_name;
3052 
3053                         idstr = capset->oc_id.cs_str;
3054                         nsize = strlen(oname);
3055                         tsize = nsize + 1 + strlen(idstr) + 1;
3056                         if ((cname = libld_malloc(tsize)) == 0)
3057                                 return (S_ERROR);
3058 
3059                         (void) strcpy(cname, oname);
3060                         cname[nsize++] = '%';
3061                         (void) strcpy(&cname[nsize], idstr);
3062 
3063                         /*
3064                          * Allocate a new symbol table entry, transform this
3065                          * symbol to a local, and assign the new name.
3066                          */
3067                         if ((csym = libld_malloc(sizeof (Sym))) == NULL)
3068                                 return (S_ERROR);
3069 
3070                         *csym = *osdp->sd_sym;
3071                         csym->st_info = ELF_ST_INFO(STB_LOCAL,
3072                             ELF_ST_TYPE(osdp->sd_sym->st_info));
3073 
3074                         osdp->sd_name = cname;
3075                         osdp->sd_sym = csym;
3076                         osdp->sd_flags = FLG_SY_CAP;
3077 
3078                         /*
3079                          * Keep track of this new local symbol.  As -z symbolcap
3080                          * can only be used to create a relocatable object, a
3081                          * dynamic symbol table can't exist.  Ensure there is
3082                          * space reserved in the string table.
3083                          */
3084                         ofl->ofl_caploclcnt++;
3085                         if (st_insert(ofl->ofl_strtab, cname) == -1)
3086                                 return (S_ERROR);
3087 
3088                         DBG_CALL(Dbg_syms_cap_local(ofl, cpp1->c_ndx,
3089                             cname, csym, osdp));
3090 
3091                         /*
3092                          * Establish this capability pair as a family.
3093                          */
3094                         if (ld_cap_add_family(ofl, cpp1->c_nsdp, osdp,
3095                             cpp1->c_group, &ifl->ifl_caps->ca_syms) == S_ERROR)
3096                                 return (S_ERROR);
3097                 }
3098         }
3099 
3100         return (1);
3101 
3102 #undef SYM_LOC_BADADDR
3103 }
3104 
3105 /*
3106  * Add an undefined symbol to the symbol table.  The reference originates from
3107  * the location identified by the message id (mid).  These references can
3108  * originate from command line options such as -e, -u, -initarray, etc.
3109  * (identified with MSG_INTL(MSG_STR_COMMAND)), or from internally generated
3110  * TLS relocation references (identified with MSG_INTL(MSG_STR_TLSREL)).
3111  */
3112 Sym_desc *
3113 ld_sym_add_u(const char *name, Ofl_desc *ofl, Msg mid)
3114 {
3115         Sym             *sym;
3116         Ifl_desc        *ifl = NULL, *_ifl;
3117         Sym_desc        *sdp;
3118         Word            hash;
3119         Aliste          idx;
3120         avl_index_t     where;
3121         const char      *reference = MSG_INTL(mid);
3122 
3123         /*
3124          * As an optimization, determine whether we've already generated this
3125          * reference.  If the symbol doesn't already exist we'll create it.
3126          * Or if the symbol does exist from a different source, we'll resolve
3127          * the conflict.
3128          */
3129         /* LINTED */
3130         hash = (Word)elf_hash(name);
3131         if ((sdp = ld_sym_find(name, hash, &where, ofl)) != NULL) {
3132                 if ((sdp->sd_sym->st_shndx == SHN_UNDEF) &&
3133                     (sdp->sd_file->ifl_name == reference))
3134                         return (sdp);
3135         }
3136 
3137         /*
3138          * Determine whether a pseudo input file descriptor exists to represent
3139          * the command line, as any global symbol needs an input file descriptor
3140          * during any symbol resolution (refer to map_ifl() which provides a
3141          * similar method for adding symbols from mapfiles).
3142          */
3143         for (APLIST_TRAVERSE(ofl->ofl_objs, idx, _ifl))
3144                 if (strcmp(_ifl->ifl_name, reference) == 0) {
3145                         ifl = _ifl;
3146                         break;
3147                 }
3148 
3149         /*
3150          * If no descriptor exists create one.
3151          */
3152         if (ifl == NULL) {
3153                 if ((ifl = libld_calloc(sizeof (Ifl_desc), 1)) == NULL)
3154                         return ((Sym_desc *)S_ERROR);
3155                 ifl->ifl_name = reference;
3156                 ifl->ifl_flags = FLG_IF_NEEDED | FLG_IF_FILEREF;
3157                 if ((ifl->ifl_ehdr = libld_calloc(sizeof (Ehdr), 1)) == NULL)
3158                         return ((Sym_desc *)S_ERROR);
3159                 ifl->ifl_ehdr->e_type = ET_REL;
3160 
3161                 if (aplist_append(&ofl->ofl_objs, ifl, AL_CNT_OFL_OBJS) == NULL)
3162                         return ((Sym_desc *)S_ERROR);
3163         }
3164 
3165         /*
3166          * Allocate a symbol structure and add it to the global symbol table.
3167          */
3168         if ((sym = libld_calloc(sizeof (Sym), 1)) == NULL)
3169                 return ((Sym_desc *)S_ERROR);
3170         sym->st_info = ELF_ST_INFO(STB_GLOBAL, STT_NOTYPE);
3171         sym->st_shndx = SHN_UNDEF;
3172 
3173         DBG_CALL(Dbg_syms_process(ofl->ofl_lml, ifl));
3174         if (sdp == NULL) {
3175                 DBG_CALL(Dbg_syms_global(ofl->ofl_lml, 0, name));
3176                 if ((sdp = ld_sym_enter(name, sym, hash, ifl, ofl, 0, SHN_UNDEF,
3177                     0, &where)) == (Sym_desc *)S_ERROR)
3178                         return ((Sym_desc *)S_ERROR);
3179         } else if (ld_sym_resolve(sdp, sym, ifl, ofl, 0,
3180             SHN_UNDEF, 0) == S_ERROR)
3181                 return ((Sym_desc *)S_ERROR);
3182 
3183         sdp->sd_flags &= ~FLG_SY_CLEAN;
3184         sdp->sd_flags |= FLG_SY_CMDREF;
3185 
3186         return (sdp);
3187 }
3188 
3189 /*
3190  * STT_SECTION symbols have their st_name field set to NULL, and consequently
3191  * have no name. Generate a name suitable for diagnostic use for such a symbol
3192  * and store it in the input section descriptor. The resulting name will be
3193  * of the form:
3194  *
3195  *      "XXX (section)"
3196  *
3197  * where XXX is the name of the section.
3198  *
3199  * entry:
3200  *      isc - Input section associated with the symbol.
3201  *      fmt - NULL, or format string to use.
3202  *
3203  * exit:
3204  *      Sets isp->is_sym_name to the allocated string. Returns the
3205  *      string pointer, or NULL on allocation failure.
3206  */
3207 const char *
3208 ld_stt_section_sym_name(Is_desc *isp)
3209 {
3210         const char      *fmt;
3211         char            *str;
3212         size_t          len;
3213 
3214         if ((isp == NULL) || (isp->is_name == NULL))
3215                 return (NULL);
3216 
3217         if (isp->is_sym_name == NULL) {
3218                 fmt = (isp->is_flags & FLG_IS_GNSTRMRG) ?
3219                     MSG_INTL(MSG_STR_SECTION_MSTR) : MSG_INTL(MSG_STR_SECTION);
3220 
3221                 len = strlen(fmt) + strlen(isp->is_name) + 1;
3222 
3223                 if ((str = libld_malloc(len)) == NULL)
3224                         return (NULL);
3225                 (void) snprintf(str, len, fmt, isp->is_name);
3226                 isp->is_sym_name = str;
3227         }
3228 
3229         return (isp->is_sym_name);
3230 }