1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 
  22 /*
  23  *      Copyright (c) 1988 AT&T
  24  *        All Rights Reserved
  25  *
  26  * Copyright (c) 1989, 2010, Oracle and/or its affiliates. All rights reserved.
  27  */
  28 
  29 /*
  30  * set-up for relocations
  31  */
  32 
  33 #define ELF_TARGET_AMD64
  34 #define ELF_TARGET_SPARC
  35 
  36 #include        <string.h>
  37 #include        <stdio.h>
  38 #include        <alloca.h>
  39 #include        <debug.h>
  40 #include        "msg.h"
  41 #include        "_libld.h"
  42 
  43 /*
  44  * Set up the relocation table flag test macros so that they use the
  45  * relocation table for the current target machine.
  46  */
  47 #define IS_PLT(X)       RELTAB_IS_PLT(X, ld_targ.t_mr.mr_reloc_table)
  48 #define IS_GOT_RELATIVE(X) \
  49         RELTAB_IS_GOT_RELATIVE(X, ld_targ.t_mr.mr_reloc_table)
  50 #define IS_GOT_PC(X)    RELTAB_IS_GOT_PC(X, ld_targ.t_mr.mr_reloc_table)
  51 #define IS_GOTPCREL(X)  RELTAB_IS_GOTPCREL(X, ld_targ.t_mr.mr_reloc_table)
  52 #define IS_GOT_BASED(X) RELTAB_IS_GOT_BASED(X, ld_targ.t_mr.mr_reloc_table)
  53 #define IS_GOT_OPINS(X) RELTAB_IS_GOT_OPINS(X, ld_targ.t_mr.mr_reloc_table)
  54 #define IS_GOT_REQUIRED(X) \
  55         RELTAB_IS_GOT_REQUIRED(X, ld_targ.t_mr.mr_reloc_table)
  56 #define IS_PC_RELATIVE(X) RELTAB_IS_PC_RELATIVE(X, ld_targ.t_mr.mr_reloc_table)
  57 #define IS_ADD_RELATIVE(X) \
  58         RELTAB_IS_ADD_RELATIVE(X, ld_targ.t_mr.mr_reloc_table)
  59 #define IS_REGISTER(X)  RELTAB_IS_REGISTER(X, ld_targ.t_mr.mr_reloc_table)
  60 #define IS_NOTSUP(X)    RELTAB_IS_NOTSUP(X, ld_targ.t_mr.mr_reloc_table)
  61 #define IS_SEG_RELATIVE(X) \
  62         RELTAB_IS_SEG_RELATIVE(X, ld_targ.t_mr.mr_reloc_table)
  63 #define IS_EXTOFFSET(X) RELTAB_IS_EXTOFFSET(X, ld_targ.t_mr.mr_reloc_table)
  64 #define IS_SEC_RELATIVE(X) \
  65         RELTAB_IS_SEC_RELATIVE(X, ld_targ.t_mr.mr_reloc_table)
  66 #define IS_TLS_INS(X)   RELTAB_IS_TLS_INS(X, ld_targ.t_mr.mr_reloc_table)
  67 #define IS_TLS_GD(X)    RELTAB_IS_TLS_GD(X, ld_targ.t_mr.mr_reloc_table)
  68 #define IS_TLS_LD(X)    RELTAB_IS_TLS_LD(X, ld_targ.t_mr.mr_reloc_table)
  69 #define IS_TLS_IE(X)    RELTAB_IS_TLS_IE(X, ld_targ.t_mr.mr_reloc_table)
  70 #define IS_TLS_LE(X)    RELTAB_IS_TLS_LE(X, ld_targ.t_mr.mr_reloc_table)
  71 #define IS_LOCALBND(X)  RELTAB_IS_LOCALBND(X, ld_targ.t_mr.mr_reloc_table)
  72 #define IS_SIZE(X)      RELTAB_IS_SIZE(X, ld_targ.t_mr.mr_reloc_table)
  73 
  74 /*
  75  * Structure to hold copy relocation items.
  76  */
  77 typedef struct copy_rel {
  78         Sym_desc        *c_sdp;         /* symbol descriptor to be copied */
  79         Addr            c_val;          /* original symbol value */
  80 } Copy_rel;
  81 
  82 /*
  83  * For each copy relocation symbol, determine if the symbol is:
  84  *      1) to be *disp* relocated at runtime
  85  *      2) a reference symbol for *disp* relocation
  86  *      3) possibly *disp* relocated at ld time.
  87  *
  88  * The first and the second are serious errors.
  89  */
  90 static void
  91 is_disp_copied(Ofl_desc *ofl, Copy_rel *crp)
  92 {
  93         Ifl_desc        *ifl = crp->c_sdp->sd_file;
  94         Sym_desc        *sdp = crp->c_sdp;
  95         Addr            symaddr = crp->c_val;
  96         Is_desc         *irel;
  97         Aliste          idx;
  98         Conv_inv_buf_t  inv_buf;
  99 
 100         /*
 101          * This symbol may not be *disp* relocated at run time, but could
 102          * already have been *disp* relocated when the shared object was
 103          * created.  Warn the user.
 104          */
 105         if ((ifl->ifl_flags & FLG_IF_DISPDONE) &&
 106             (ofl->ofl_flags & FLG_OF_VERBOSE))
 107                 ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_REL_DISPREL2),
 108                     conv_reloc_type(ifl->ifl_ehdr->e_machine,
 109                     ld_targ.t_m.m_r_copy, 0, &inv_buf),
 110                     ifl->ifl_name, demangle(sdp->sd_name));
 111 
 112         if ((ifl->ifl_flags & FLG_IF_DISPPEND) == 0)
 113                 return;
 114 
 115         /*
 116          * Traverse the input relocation sections.
 117          */
 118         for (APLIST_TRAVERSE(ifl->ifl_relsect, idx, irel)) {
 119                 Sym_desc        *rsdp;
 120                 Is_desc         *trel;
 121                 Rel             *rend, *reloc;
 122                 Xword           rsize, entsize;
 123 
 124                 trel = ifl->ifl_isdesc[irel->is_shdr->sh_info];
 125                 rsize = irel->is_shdr->sh_size;
 126                 entsize = irel->is_shdr->sh_entsize;
 127                 reloc = (Rel *)irel->is_indata->d_buf;
 128 
 129                 /*
 130                  * Decide entry size
 131                  */
 132                 if ((entsize == 0) || (entsize > rsize)) {
 133                         if (irel->is_shdr->sh_type == SHT_RELA)
 134                                 entsize = sizeof (Rela);
 135                         else
 136                                 entsize = sizeof (Rel);
 137                 }
 138 
 139                 /*
 140                  * Traverse the relocation entries.
 141                  */
 142                 for (rend = (Rel *)((uintptr_t)reloc + (uintptr_t)rsize);
 143                     reloc < rend;
 144                     reloc = (Rel *)((uintptr_t)reloc + (uintptr_t)entsize)) {
 145                         const char      *str;
 146                         Word            rstndx;
 147 
 148                         if (IS_PC_RELATIVE(ELF_R_TYPE(reloc->r_info,
 149                             ld_targ.t_m.m_mach)) == 0)
 150                                 continue;
 151 
 152                         /*
 153                          * Determine if symbol is referenced from a relocation.
 154                          */
 155                         rstndx = (Word) ELF_R_SYM(reloc->r_info);
 156                         rsdp = ifl->ifl_oldndx[rstndx];
 157                         if (rsdp == sdp) {
 158                                 if ((str = demangle(rsdp->sd_name)) !=
 159                                     rsdp->sd_name) {
 160                                         char    *_str = alloca(strlen(str) + 1);
 161                                         (void) strcpy(_str, str);
 162                                         str = (const char *)_str;
 163                                 }
 164                                 ld_eprintf(ofl, ERR_WARNING,
 165                                     MSG_INTL(MSG_REL_DISPREL1),
 166                                     conv_reloc_type(ifl->ifl_ehdr->e_machine,
 167                                     (uint_t)ELF_R_TYPE(reloc->r_info,
 168                                     ld_targ.t_m.m_mach),
 169                                     0, &inv_buf), ifl->ifl_name, str,
 170                                     MSG_INTL(MSG_STR_UNKNOWN),
 171                                     EC_XWORD(reloc->r_offset),
 172                                     demangle(sdp->sd_name));
 173                         }
 174 
 175                         /*
 176                          * Determine whether the relocation entry is relocating
 177                          * this symbol.
 178                          */
 179                         if ((sdp->sd_isc != trel) ||
 180                             (reloc->r_offset < symaddr) ||
 181                             (reloc->r_offset >=
 182                             (symaddr + sdp->sd_sym->st_size)))
 183                                 continue;
 184 
 185                         /*
 186                          * This symbol is truely *disp* relocated, so should
 187                          * really be fixed by user.
 188                          */
 189                         if ((str = demangle(sdp->sd_name)) != sdp->sd_name) {
 190                                 char    *_str = alloca(strlen(str) + 1);
 191                                 (void) strcpy(_str, str);
 192                                 str = (const char *)_str;
 193                         }
 194                         ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_REL_DISPREL1),
 195                             conv_reloc_type(ifl->ifl_ehdr->e_machine,
 196                             (uint_t)ELF_R_TYPE(reloc->r_info,
 197                             ld_targ.t_m.m_mach), 0, &inv_buf),
 198                             ifl->ifl_name, demangle(rsdp->sd_name), str,
 199                             EC_XWORD(reloc->r_offset), str);
 200                 }
 201         }
 202 }
 203 
 204 /*
 205  * The number of symbols provided by some objects can be very large.  Use a
 206  * binary search to match the associated value to a symbol table entry.
 207  */
 208 static int
 209 disp_bsearch(const void *key, const void *array)
 210 {
 211         Addr            kvalue, avalue;
 212         Ssv_desc        *ssvp = (Ssv_desc *)array;
 213 
 214         kvalue = *((Addr *)key);
 215         avalue = ssvp->ssv_value;
 216 
 217         if (avalue > kvalue)
 218                 return (-1);
 219         if ((avalue < kvalue) &&
 220             ((avalue + ssvp->ssv_sdp->sd_sym->st_size) <= kvalue))
 221                 return (1);
 222         return (0);
 223 }
 224 
 225 /*
 226  * Given a sorted list of symbols, look for a symbol in which the relocation
 227  * offset falls between the [sym.st_value - sym.st_value + sym.st_size].  Since
 228  * the symbol list is maintained in sorted order,  we can bail once the
 229  * relocation offset becomes less than the symbol values.  The symbol is
 230  * returned for use in error diagnostics.
 231  */
 232 static Sym_desc *
 233 disp_scansyms(Ifl_desc * ifl, Rel_desc *rld, Boolean rlocal, int inspect,
 234     Ofl_desc *ofl)
 235 {
 236         Sym_desc        *tsdp, *rsdp;
 237         Sym             *rsym, *tsym;
 238         Ssv_desc        *ssvp;
 239         uchar_t         rtype, ttype;
 240         Addr            value;
 241 
 242         /*
 243          * Sorted symbol values have been uniquified by adding their associated
 244          * section offset.  Uniquify the relocation offset by adding its
 245          * associated section offset, and search for the symbol.
 246          */
 247         value = rld->rel_roffset;
 248         if (rld->rel_isdesc->is_shdr)
 249                 value += rld->rel_isdesc->is_shdr->sh_offset;
 250 
 251         if ((ssvp = bsearch((void *)&value, (void *)ifl->ifl_sortsyms,
 252             ifl->ifl_sortcnt, sizeof (Ssv_desc), &disp_bsearch)) != 0)
 253                 tsdp = ssvp->ssv_sdp;
 254         else
 255                 tsdp = 0;
 256 
 257         if (inspect)
 258                 return (tsdp);
 259 
 260         /*
 261          * Determine the relocation reference symbol and its type.
 262          */
 263         rsdp = rld->rel_sym;
 264         rsym = rsdp->sd_sym;
 265         rtype = ELF_ST_TYPE(rsym->st_info);
 266 
 267         /*
 268          * If there is no target symbol to match the relocation offset, then the
 269          * offset is effectively local data.  If the relocation symbol is global
 270          * data we have a potential for this displacement relocation to be
 271          * invalidated should the global symbol be copied.
 272          */
 273         if (tsdp == 0) {
 274                 if ((rlocal == TRUE) ||
 275                     ((rtype != STT_OBJECT) && (rtype != STT_SECTION)))
 276                 return (tsdp);
 277         } else {
 278                 /*
 279                  * If both symbols are local, no copy relocations can occur to
 280                  * either symbol.  Note, this test is very similar to the test
 281                  * used in ld_sym_adjust_vis().
 282                  */
 283                 if ((rlocal == TRUE) && (SYM_IS_HIDDEN(tsdp) ||
 284                     (ELF_ST_BIND(tsdp->sd_sym->st_info) != STB_GLOBAL) ||
 285                     ((ofl->ofl_flags & (FLG_OF_AUTOLCL | FLG_OF_AUTOELM)) &&
 286                     ((tsdp->sd_flags & MSK_SY_NOAUTO) == 0))))
 287                         return (tsdp);
 288 
 289                 /*
 290                  * Determine the relocation target symbols type.
 291                  */
 292                 tsym = tsdp->sd_sym;
 293                 ttype = ELF_ST_TYPE(tsym->st_info);
 294 
 295                 /*
 296                  * If the reference symbol is local, and the target isn't a
 297                  * data element, then no copy relocations can occur to either
 298                  * symbol.  Note, this catches pc-relative relocations against
 299                  * the _GLOBAL_OFFSET_TABLE_, which is effectively treated as
 300                  * a local symbol.
 301                  */
 302                 if ((rlocal == TRUE) && (ttype != STT_OBJECT) &&
 303                     (ttype != STT_SECTION))
 304                         return (tsdp);
 305 
 306                 /*
 307                  * Finally, one of the symbols must reference a data element.
 308                  */
 309                 if ((rtype != STT_OBJECT) && (rtype != STT_SECTION) &&
 310                     (ttype != STT_OBJECT) && (ttype != STT_SECTION))
 311                         return (tsdp);
 312         }
 313 
 314         /*
 315          * We have two global symbols, at least one of which is a data item.
 316          * The last case where a displacement relocation can be ignored, is
 317          * if the reference symbol is included in the target symbol.
 318          */
 319         value = rsym->st_value;
 320         if ((rld->rel_flags & FLG_REL_RELA) == FLG_REL_RELA)
 321                 value += rld->rel_raddend;
 322 
 323         if ((rld->rel_roffset >= value) &&
 324             (rld->rel_roffset < (value + rsym->st_size)))
 325                 return (tsdp);
 326 
 327         /*
 328          * We have a displacement relocation that could be compromised by a
 329          * copy relocation of one of the associated data items.
 330          */
 331         rld->rel_flags |= FLG_REL_DISP;
 332         return (tsdp);
 333 }
 334 
 335 void
 336 ld_disp_errmsg(const char *msg, Rel_desc *rsp, Ofl_desc *ofl)
 337 {
 338         Sym_desc        *sdp;
 339         const char      *str;
 340         Ifl_desc        *ifl = rsp->rel_isdesc->is_file;
 341         Conv_inv_buf_t  inv_buf;
 342 
 343         if ((sdp = disp_scansyms(ifl, rsp, 0, 1, ofl)) != 0)
 344                 str = demangle(sdp->sd_name);
 345         else
 346                 str = MSG_INTL(MSG_STR_UNKNOWN);
 347 
 348         ld_eprintf(ofl, ERR_WARNING, msg,
 349             conv_reloc_type(ifl->ifl_ehdr->e_machine, rsp->rel_rtype,
 350             0, &inv_buf), ifl->ifl_name, ld_reloc_sym_name(rsp), str,
 351             EC_OFF(rsp->rel_roffset));
 352 }
 353 
 354 /*
 355  * qsort(3C) comparison routine used for the disp_sortsyms().
 356  */
 357 static int
 358 disp_qsort(const void * s1, const void * s2)
 359 {
 360         Ssv_desc        *ssvp1 = ((Ssv_desc *)s1);
 361         Ssv_desc        *ssvp2 = ((Ssv_desc *)s2);
 362         Addr            val1 = ssvp1->ssv_value;
 363         Addr            val2 = ssvp2->ssv_value;
 364 
 365         if (val1 > val2)
 366                 return (1);
 367         if (val1 < val2)
 368                 return (-1);
 369         return (0);
 370 }
 371 
 372 /*
 373  * Determine whether a displacement relocation is between a local and global
 374  * symbol pair.  One symbol is used to perform the relocation, and the other
 375  * is the destination offset of the relocation.
 376  */
 377 static uintptr_t
 378 disp_inspect(Ofl_desc *ofl, Rel_desc *rld, Boolean rlocal)
 379 {
 380         Is_desc         *isp = rld->rel_isdesc;
 381         Ifl_desc        *ifl = rld->rel_isdesc->is_file;
 382 
 383         /*
 384          * If the input files symbols haven't been sorted yet, do so.
 385          */
 386         if (ifl->ifl_sortsyms == 0) {
 387                 Word    ondx, nndx;
 388 
 389                 if ((ifl->ifl_sortsyms = libld_malloc((ifl->ifl_symscnt + 1) *
 390                     sizeof (Ssv_desc))) == 0)
 391                         return (S_ERROR);
 392 
 393                 for (ondx = 0, nndx = 0; ondx < ifl->ifl_symscnt; ondx++) {
 394                         Sym_desc        *sdp;
 395                         Addr            value;
 396 
 397                         /*
 398                          * As symbol resolution has already occurred, various
 399                          * symbols from this object may have been satisfied
 400                          * from other objects.  Only select symbols from this
 401                          * object.  For the displacement test, we only really
 402                          * need to observe data definitions, however, later as
 403                          * part of providing warning disgnostics, relating the
 404                          * relocation offset to a symbol is desirable.  Thus,
 405                          * collect all symbols that define a memory area.
 406                          */
 407                         if (((sdp = ifl->ifl_oldndx[ondx]) == 0) ||
 408                             (sdp->sd_sym->st_shndx == SHN_UNDEF) ||
 409                             (sdp->sd_sym->st_shndx >= SHN_LORESERVE) ||
 410                             (sdp->sd_ref != REF_REL_NEED) ||
 411                             (sdp->sd_file != ifl) ||
 412                             (sdp->sd_sym->st_size == 0))
 413                                 continue;
 414 
 415                         /*
 416                          * As a further optimization for later checking, mark
 417                          * this section if this a global data definition.
 418                          */
 419                         if (sdp->sd_isc && (ondx >= ifl->ifl_locscnt))
 420                                 sdp->sd_isc->is_flags |= FLG_IS_GDATADEF;
 421 
 422                         /*
 423                          * Capture the symbol.  Within relocatable objects, a
 424                          * symbols value is its offset within its associated
 425                          * section.  Add the section offset to this value to
 426                          * uniquify the symbol.
 427                          */
 428                         value = sdp->sd_sym->st_value;
 429                         if (sdp->sd_isc && sdp->sd_isc->is_shdr)
 430                                 value += sdp->sd_isc->is_shdr->sh_offset;
 431 
 432                         ifl->ifl_sortsyms[nndx].ssv_value = value;
 433                         ifl->ifl_sortsyms[nndx].ssv_sdp = sdp;
 434                         nndx++;
 435                 }
 436 
 437                 /*
 438                  * Sort the list based on the symbols value (address).
 439                  */
 440                 if ((ifl->ifl_sortcnt = nndx) != 0)
 441                         qsort(ifl->ifl_sortsyms, nndx, sizeof (Ssv_desc),
 442                             &disp_qsort);
 443         }
 444 
 445         /*
 446          * If the reference symbol is local, and the section being relocated
 447          * contains no global definitions, neither can be the target of a copy
 448          * relocation.
 449          */
 450         if ((rlocal == FALSE) && ((isp->is_flags & FLG_IS_GDATADEF) == 0))
 451                 return (1);
 452 
 453         /*
 454          * Otherwise determine whether this relocation symbol and its offset
 455          * could be candidates for a copy relocation.
 456          */
 457         if (ifl->ifl_sortcnt)
 458                 (void) disp_scansyms(ifl, rld, rlocal, 0, ofl);
 459         return (1);
 460 }
 461 
 462 /*
 463  * Return a Rel_cachebuf with an available Rel_desc entry from the
 464  * specified cache, allocating a cache buffer if necessary.
 465  *
 466  * entry:
 467  *      ofl - Output file descriptor
 468  *      rcp - Relocation cache to allocate the descriptor from.
 469  *              One of &ofl->ofl_actrels or &ofl->ofl_outrels.
 470  *
 471  * exit:
 472  *      Returns the allocated descriptor, or NULL if the allocation fails.
 473  */
 474 static Rel_cachebuf *
 475 ld_add_rel_cache(Ofl_desc *ofl, Rel_cache *rcp)
 476 {
 477         Rel_cachebuf    *rcbp;
 478         size_t          nelts, size, alloc_cnt;
 479 
 480         /*
 481          * If there is space available in the present cache bucket, return the
 482          * next free entry.
 483          */
 484         alloc_cnt = aplist_nitems(rcp->rc_list);
 485         if (rcp->rc_list &&
 486             ((rcbp = rcp->rc_list->apl_data[alloc_cnt - 1]) != NULL) &&
 487             (rcbp->rc_free < rcbp->rc_end))
 488                 return (rcbp);
 489 
 490         /*
 491          * Allocate a new bucket. As we cannot know the number of relocations
 492          * we'll have in the active and output cache until after the link is
 493          * complete, the size of the bucket is a heuristic.
 494          *
 495          * In general, if the output object is an executable, or a sharable
 496          * object, then the size of the active relocation list will be nearly
 497          * the same as the number of input relocations, and the output
 498          * relocation list will be very short. If the output object is a
 499          * relocatable object, then the reverse is true. Therefore, the initial
 500          * allocation for the appropriate list is sized to fit all the input
 501          * allocations in a single shot.
 502          *
 503          * All other allocations are done in units of REL_CACHEBUF_ALLOC,
 504          * which is chosen to be large enough to cover most common cases,
 505          * but small enough that not using it fully is inconsequential.
 506          *
 507          * In an ideal scenario, this results in one allocation on each list.
 508          */
 509         nelts = REL_CACHEBUF_ALLOC;
 510         if ((alloc_cnt == 0) && (ofl->ofl_relocincnt > REL_CACHEBUF_ALLOC)) {
 511                 Boolean is_rel = (ofl->ofl_flags & FLG_OF_RELOBJ) != 0;
 512 
 513                 if (((rcp == &ofl->ofl_actrels) && !is_rel) ||
 514                     ((rcp == &ofl->ofl_outrels) && is_rel))
 515                         nelts = ofl->ofl_relocincnt;
 516         }
 517 
 518         /*
 519          * Compute the total number of bytes to allocate. The first element
 520          * of the array is built into the Rel_cachebuf header, so we subtract
 521          * one from nelts.
 522          */
 523         size = sizeof (Rel_cachebuf) + ((nelts - 1) * sizeof (Rel_desc));
 524 
 525         if (((rcbp = libld_malloc(size)) == NULL) ||
 526             (aplist_append(&rcp->rc_list, rcbp, AL_CNT_OFL_RELS) == NULL))
 527                 return (NULL);
 528 
 529         rcbp->rc_free = rcbp->rc_arr;
 530         rcbp->rc_end = rcbp->rc_arr + nelts;
 531 
 532         return (rcbp);
 533 }
 534 
 535 /*
 536  * Allocate a Rel_aux descriptor and attach it to the given Rel_desc,
 537  * allocating an auxiliary cache buffer if necessary.
 538  *
 539  * entry:
 540  *      ofl - Output file descriptor
 541  *      rdp - Rel_desc descriptor that requires an auxiliary block
 542  *
 543  * exit:
 544  *      Returns TRUE on success, and FALSE if the allocation fails.
 545  *      On success, the caller is responsible for initializing the
 546  *      auxiliary block properly.
 547  */
 548 static Boolean
 549 ld_add_rel_aux(Ofl_desc *ofl, Rel_desc *rdesc)
 550 {
 551         Rel_aux_cachebuf        *racp = NULL;
 552         size_t                  size;
 553 
 554         /*
 555          * If there is space available in the present cache bucket, use it.
 556          * Otherwise, allocate a new bucket.
 557          */
 558         if (ofl->ofl_relaux) {
 559                 racp = ofl->ofl_relaux->apl_data[
 560                     ofl->ofl_relaux->apl_nitems - 1];
 561 
 562                 if (racp && (racp->rac_free >= racp->rac_end))
 563                         racp = NULL;
 564         }
 565         if (racp == NULL) {
 566                 /*
 567                  * Compute the total number of bytes to allocate. The first
 568                  * element of the array is built into the Rel_aux_cachebuf
 569                  * header, so we subtract one from the number of elements.
 570                  */
 571                 size = sizeof (Rel_aux_cachebuf) +
 572                     ((RELAUX_CACHEBUF_ALLOC - 1) * sizeof (Rel_aux));
 573                 if (((racp = libld_malloc(size)) == NULL) ||
 574                     (aplist_append(&ofl->ofl_relaux, racp, AL_CNT_OFL_RELS) ==
 575                     NULL))
 576                         return (FALSE);
 577 
 578                 racp->rac_free = racp->rac_arr;
 579                 racp->rac_end = racp->rac_arr + RELAUX_CACHEBUF_ALLOC;
 580         }
 581 
 582         /* Take an auxiliary descriptor from the cache and add it to rdesc */
 583         rdesc->rel_aux = racp->rac_free++;
 584 
 585         return (TRUE);
 586 }
 587 
 588 /*
 589  * Enter a copy of the given Rel_desc relocation descriptor, and
 590  * any associated auxiliary Rel_aux it may reference, into the
 591  * specified relocation cache.
 592  *
 593  * entry:
 594  *      ofl - Output file descriptor
 595  *      rcp - Relocation descriptor cache to recieve relocation
 596  *      rdesc - Rel_desc image to be inserted
 597  *      flags - Flags to add to rdest->rel_flags in the inserted descriptor
 598  *
 599  * exit:
 600  *      Returns the pointer to the inserted descriptor on success.
 601  *      Returns NULL if an allocation error occurs.
 602  */
 603 Rel_desc *
 604 ld_reloc_enter(Ofl_desc *ofl, Rel_cache *rcp, Rel_desc *rdesc, Word flags)
 605 {
 606         Rel_desc        *arsp;
 607         Rel_aux         *auxp;
 608         Rel_cachebuf    *rcbp;
 609 
 610 
 611         /*
 612          * If no relocation cache structures are available, allocate a new
 613          * one and link it to the buffer list.
 614          */
 615         rcbp = ld_add_rel_cache(ofl, rcp);
 616         if (rcbp == NULL)
 617                 return (NULL);
 618         arsp = rcbp->rc_free;
 619 
 620         /*
 621          * If there is an auxiliary block on the original, allocate
 622          * one for the clone. Save the pointer, because the struct copy
 623          * below will crush it.
 624          */
 625         if (rdesc->rel_aux != NULL) {
 626                 if (!ld_add_rel_aux(ofl, arsp))
 627                         return (NULL);
 628                 auxp = arsp->rel_aux;
 629         }
 630 
 631         /* Copy contents of the original into the clone */
 632         *arsp = *rdesc;
 633 
 634         /*
 635          * If there is an auxiliary block, restore the clone's pointer to
 636          * it, and copy the auxiliary contents.
 637          */
 638         if (rdesc->rel_aux != NULL) {
 639                 arsp->rel_aux = auxp;
 640                 *auxp = *rdesc->rel_aux;
 641         }
 642         arsp->rel_flags |= flags;
 643 
 644         rcbp->rc_free++;
 645         rcp->rc_cnt++;
 646 
 647         return (arsp);
 648 }
 649 
 650 /*
 651  * Initialize a relocation descriptor auxiliary block to default
 652  * values.
 653  *
 654  * entry:
 655  *      rdesc - Relocation descriptor, with a non-NULL rel_aux field
 656  *              pointing at the auxiliary block to be initialized.
 657  *
 658  * exit:
 659  *      Each field in rdesc->rel_aux has been set to its default value
 660  */
 661 static void
 662 ld_init_rel_aux(Rel_desc *rdesc)
 663 {
 664         Rel_aux *rap = rdesc->rel_aux;
 665 
 666         /*
 667          * The default output section is the one the input section
 668          * is assigned to, assuming that there is an input section.
 669          * Failing that, NULL is the only possibility, and we expect
 670          * that the caller will assign an explicit value.
 671          */
 672         rap->ra_osdesc = (rdesc->rel_isdesc == NULL) ? NULL :
 673             rdesc->rel_isdesc->is_osdesc;
 674 
 675         /* The ra_usym defaults to the value in rel_sym */
 676         rap->ra_usym = rdesc->rel_sym;
 677 
 678         /* Remaining fields are zeroed */
 679         rap->ra_move = NULL;
 680         rap->ra_typedata = 0;
 681 }
 682 
 683 /*
 684  * The ld_reloc_set_aux_XXX() functions are used to set the value of an
 685  * auxiliary relocation item on a relocation descriptor that exists in
 686  * the active or output relocation cache. These descriptors are created
 687  * via a call to ld_reloc_enter().
 688  *
 689  * These functions preserve the illusion that every relocation descriptor
 690  * has a non-NULL auxiliary block into which values can be set, while
 691  * only creating an auxiliary block if one is actually necessary, preventing
 692  * the large memory allocations that would otherwise occur. They operate
 693  * as follows:
 694  *
 695  * -    If an auxiliary block already exists, set the desired value and
 696  *      and return TRUE.
 697  *
 698  * -    If no auxiliary block exists, but the desired value is the default
 699  *      value for the specified item, then no auxiliary block is needed,
 700  *      and TRUE is returned.
 701  *
 702  * -    If no auxiliary block exists, and the desired value is not the
 703  *      default for the specified item, allocate an auxiliary block for
 704  *      the descriptor, initialize its contents to default values for all
 705  *      items, set the specified value, and return TRUE.
 706  *
 707  * -    If an auxiliary block needs to be added, but the allocation fails,
 708  *      an error is issued, and FALSE is returned.
 709  *
 710  * Note that we only provide an ld_reloc_set_aux_XXX() function for those
 711  * auxiliary items that libld actually modifies in Rel_desc descriptors
 712  * in the active or output caches. If another one is needed, add it here.
 713  *
 714  * The PROCESS_NULL_REL_AUX macro is used to provide a single implementation
 715  * for the logic that determines if an auxiliary block is needed or not,
 716  * and handles the details of allocating and initializing it. It accepts
 717  * one argument, _isdefault_predicate, which should be a call to the
 718  * RELAUX_ISDEFAULT_xxx() macro appropriate for the auxiliary item
 719  */
 720 
 721 #define PROCESS_NULL_REL_AUX(_isdefault_predicate) \
 722         if (rdesc->rel_aux == NULL) { \
 723                 /* If requested value is the default, no need for aux block */ \
 724                 if (_isdefault_predicate) \
 725                         return (TRUE); \
 726                 /* Allocate and attach an auxiliary block */ \
 727                 if (!ld_add_rel_aux(ofl, rdesc)) \
 728                         return (FALSE); \
 729                 /* Initialize the auxiliary block with default values */ \
 730                 ld_init_rel_aux(rdesc); \
 731         }
 732 
 733 Boolean
 734 ld_reloc_set_aux_osdesc(Ofl_desc *ofl, Rel_desc *rdesc, Os_desc *osp)
 735 {
 736         PROCESS_NULL_REL_AUX(RELAUX_ISDEFAULT_OSDESC(rdesc, osp))
 737         rdesc->rel_aux->ra_osdesc = osp;
 738         return (TRUE);
 739 }
 740 
 741 Boolean
 742 ld_reloc_set_aux_usym(Ofl_desc *ofl, Rel_desc *rdesc, Sym_desc *sdp)
 743 {
 744         PROCESS_NULL_REL_AUX(RELAUX_ISDEFAULT_USYM(rdesc, sdp))
 745         rdesc->rel_aux->ra_usym = sdp;
 746         return (TRUE);
 747 }
 748 
 749 #undef PROCESS_NULL_REL_AUX
 750 
 751 /*
 752  * Return a descriptive name for the symbol associated with the
 753  * given relocation descriptor. This will be the actual symbol
 754  * name if one exists, or a suitable alternative otherwise.
 755  *
 756  * entry:
 757  *      rsp - Relocation descriptor
 758  */
 759 const char *
 760 ld_reloc_sym_name(Rel_desc *rsp)
 761 {
 762         Sym_desc        *sdp = rsp->rel_sym;
 763 
 764         if (sdp != NULL) {
 765                 /* If the symbol has a valid name use it */
 766                 if (sdp->sd_name && *sdp->sd_name)
 767                         return (demangle(sdp->sd_name));
 768 
 769                 /*
 770                  * If the symbol is STT_SECTION, and the corresponding
 771                  * section symbol has the specially prepared string intended
 772                  * for this use, use that string. The string is of the form
 773                  *      secname (section)
 774                  */
 775                 if ((ELF_ST_TYPE(sdp->sd_sym->st_info) == STT_SECTION) &&
 776                     (sdp->sd_isc != NULL) && (sdp->sd_isc->is_sym_name != NULL))
 777                         return (demangle(sdp->sd_isc->is_sym_name));
 778         } else {
 779                 /*
 780                  * Use an empty name for a register relocation with
 781                  * no symbol.
 782                  */
 783                 if (IS_REGISTER(rsp->rel_rtype))
 784                         return (MSG_ORIG(MSG_STR_EMPTY));
 785         }
 786 
 787         /* If all else fails, report it as <unknown> */
 788         return (MSG_INTL(MSG_STR_UNKNOWN));
 789 }
 790 
 791 /*
 792  * Add an active relocation record.
 793  */
 794 uintptr_t
 795 ld_add_actrel(Word flags, Rel_desc *rsp, Ofl_desc *ofl)
 796 {
 797         Rel_desc        *arsp;
 798 
 799         if ((arsp = ld_reloc_enter(ofl, &ofl->ofl_actrels, rsp, flags)) == NULL)
 800                 return (S_ERROR);
 801 
 802         /*
 803          * Any GOT relocation reference requires the creation of a .got table.
 804          * Most references to a .got require a .got entry,  which is accounted
 805          * for with the ofl_gotcnt counter.  However, some references are
 806          * relative to the .got table, but require no .got entry.  This test
 807          * insures a .got is created regardless of the type of reference.
 808          */
 809         if (IS_GOT_REQUIRED(arsp->rel_rtype))
 810                 ofl->ofl_flags |= FLG_OF_BLDGOT;
 811 
 812         /*
 813          * If this is a displacement relocation generate a warning.
 814          */
 815         if (arsp->rel_flags & FLG_REL_DISP) {
 816                 ofl->ofl_dtflags_1 |= DF_1_DISPRELDNE;
 817 
 818                 if (ofl->ofl_flags & FLG_OF_VERBOSE)
 819                         ld_disp_errmsg(MSG_INTL(MSG_REL_DISPREL3), arsp, ofl);
 820         }
 821 
 822         DBG_CALL(Dbg_reloc_ars_entry(ofl->ofl_lml, ELF_DBG_LD,
 823             arsp->rel_isdesc->is_shdr->sh_type, ld_targ.t_m.m_mach, arsp));
 824         return (1);
 825 }
 826 
 827 /*
 828  * In the platform specific machrel.XXX.c files, we sometimes write
 829  * a value directly into the got/plt. These function can be used when
 830  * the running linker has the opposite byte order of the object being
 831  * produced.
 832  */
 833 Word
 834 ld_bswap_Word(Word v)
 835 {
 836         return (BSWAP_WORD(v));
 837 }
 838 
 839 
 840 Xword
 841 ld_bswap_Xword(Xword v)
 842 {
 843         return (BSWAP_XWORD(v));
 844 }
 845 
 846 
 847 uintptr_t
 848 ld_reloc_GOT_relative(Boolean local, Rel_desc *rsp, Ofl_desc *ofl)
 849 {
 850         Sym_desc        *sdp = rsp->rel_sym;
 851         ofl_flag_t      flags = ofl->ofl_flags;
 852         Gotndx          *gnp;
 853 
 854         /*
 855          * If this is the first time we've seen this symbol in a GOT
 856          * relocation we need to assign it a GOT token.  Once we've got
 857          * all of the GOT's assigned we can assign the actual indexes.
 858          */
 859         if ((gnp = (*ld_targ.t_mr.mr_find_got_ndx)(sdp->sd_GOTndxs,
 860             GOT_REF_GENERIC, ofl, rsp)) == 0) {
 861                 Word    rtype = rsp->rel_rtype;
 862 
 863                 if ((*ld_targ.t_mr.mr_assign_got_ndx)(&(sdp->sd_GOTndxs), NULL,
 864                     GOT_REF_GENERIC, ofl, rsp, sdp) == S_ERROR)
 865                         return (S_ERROR);
 866 
 867                 /*
 868                  * Initialize the GOT table entry.
 869                  *
 870                  * For global symbols, we clear the GOT table entry and create
 871                  * a GLOB_DAT relocation against the symbol.
 872                  *
 873                  * For local symbols, we enter the symbol value into a GOT
 874                  * table entry and create a relative relocation if all of
 875                  * the following hold:
 876                  *
 877                  * -    Output is a shared object
 878                  * -    Symbol is not ABS
 879                  * -    Relocation is not against one of the special sections
 880                  *      (COMMON, ...)
 881                  * -    This is not one of the generated symbols we have
 882                  *      to update after the output object has been fully
 883                  *      laid out (_START_, _END_, ...)
 884                  *
 885                  * Local symbols that don't meet the above requirements
 886                  * are processed as is.
 887                  */
 888                 if (local == TRUE) {
 889                         if ((flags & FLG_OF_SHAROBJ) &&
 890                             (((sdp->sd_flags & FLG_SY_SPECSEC) == 0) ||
 891                             ((sdp->sd_sym->st_shndx != SHN_ABS)) ||
 892                             (sdp->sd_aux && sdp->sd_aux->sa_symspec))) {
 893                                 if (ld_add_actrel((FLG_REL_GOT | FLG_REL_GOTCL),
 894                                     rsp, ofl) == S_ERROR)
 895                                         return (S_ERROR);
 896 
 897                                 rsp->rel_rtype = ld_targ.t_m.m_r_relative;
 898 
 899                                 if ((*ld_targ.t_mr.mr_add_outrel)
 900                                     ((FLG_REL_GOT | FLG_REL_ADVAL),
 901                                     rsp, ofl) == S_ERROR)
 902                                         return (S_ERROR);
 903 
 904                                 rsp->rel_rtype = rtype;
 905                         } else {
 906                                 if (ld_add_actrel(FLG_REL_GOT, rsp,
 907                                     ofl) == S_ERROR)
 908                                         return (S_ERROR);
 909                         }
 910                 } else {
 911                         rsp->rel_rtype = ld_targ.t_m.m_r_glob_dat;
 912                         if ((*ld_targ.t_mr.mr_add_outrel)(FLG_REL_GOT,
 913                             rsp, ofl) == S_ERROR)
 914                                 return (S_ERROR);
 915                         rsp->rel_rtype = rtype;
 916                 }
 917         } else {
 918                 if ((*ld_targ.t_mr.mr_assign_got_ndx)(&(sdp->sd_GOTndxs), gnp,
 919                     GOT_REF_GENERIC, ofl, rsp, sdp) == S_ERROR)
 920                         return (S_ERROR);
 921         }
 922 
 923         /*
 924          * Perform relocation to GOT table entry.
 925          */
 926         return (ld_add_actrel(NULL, rsp, ofl));
 927 }
 928 
 929 /*
 930  * Perform relocations for PLT's
 931  */
 932 uintptr_t
 933 ld_reloc_plt(Rel_desc *rsp, Ofl_desc *ofl)
 934 {
 935         Sym_desc        *sdp = rsp->rel_sym;
 936 
 937         switch (ld_targ.t_m.m_mach) {
 938         case EM_AMD64:
 939                 /*
 940                  * AMD64 TLS code sequences do not use a unique TLS
 941                  * relocation to reference the __tls_get_addr() function call.
 942                  */
 943                 if ((ofl->ofl_flags & FLG_OF_EXEC) &&
 944                     (strcmp(sdp->sd_name, MSG_ORIG(MSG_SYM_TLSGETADDR_U)) ==
 945                     0))
 946                         return (ld_add_actrel(FLG_REL_TLSFIX, rsp, ofl));
 947                 break;
 948 
 949         case EM_386:
 950                 /*
 951                  * GNUC IA32 TLS code sequences do not use a unique TLS
 952                  * relocation to reference the ___tls_get_addr() function call.
 953                  */
 954                 if ((ofl->ofl_flags & FLG_OF_EXEC) &&
 955                     (strcmp(sdp->sd_name, MSG_ORIG(MSG_SYM_TLSGETADDR_UU)) ==
 956                     0))
 957                         return (ld_add_actrel(FLG_REL_TLSFIX, rsp, ofl));
 958                 break;
 959         }
 960 
 961         /*
 962          * if (not PLT yet assigned)
 963          * then
 964          *      assign PLT index to symbol
 965          *      build output JMP_SLOT relocation
 966          * fi
 967          */
 968         if (sdp->sd_aux->sa_PLTndx == 0) {
 969                 Word    ortype = rsp->rel_rtype;
 970 
 971                 (*ld_targ.t_mr.mr_assign_plt_ndx)(sdp, ofl);
 972 
 973                 /*
 974                  * If this symbol is binding to a lazy loadable, or deferred
 975                  * dependency, then identify the symbol.
 976                  */
 977                 if (sdp->sd_file) {
 978                         if (sdp->sd_file->ifl_flags & FLG_IF_LAZYLD)
 979                                 sdp->sd_flags |= FLG_SY_LAZYLD;
 980                         if (sdp->sd_file->ifl_flags & FLG_IF_DEFERRED)
 981                                 sdp->sd_flags |= FLG_SY_DEFERRED;
 982                 }
 983 
 984                 rsp->rel_rtype = ld_targ.t_m.m_r_jmp_slot;
 985                 if ((*ld_targ.t_mr.mr_add_outrel)(FLG_REL_PLT, rsp, ofl) ==
 986                     S_ERROR)
 987                         return (S_ERROR);
 988                 rsp->rel_rtype = ortype;
 989         }
 990 
 991         /*
 992          * Perform relocation to PLT table entry.
 993          */
 994         if ((ofl->ofl_flags & FLG_OF_SHAROBJ) &&
 995             IS_ADD_RELATIVE(rsp->rel_rtype)) {
 996                 Word    ortype  = rsp->rel_rtype;
 997 
 998                 rsp->rel_rtype = ld_targ.t_m.m_r_relative;
 999                 if ((*ld_targ.t_mr.mr_add_outrel)(FLG_REL_ADVAL, rsp, ofl) ==
1000                     S_ERROR)
1001                         return (S_ERROR);
1002                 rsp->rel_rtype = ortype;
1003                 return (1);
1004         } else
1005                 return (ld_add_actrel(NULL, rsp, ofl));
1006 }
1007 
1008 /*
1009  * Round up to the next power of 2.  Used to ensure section alignments that can
1010  * be used for copy relocation symbol alignments are sane values.
1011  */
1012 static Word
1013 nlpo2(Word val)
1014 {
1015         val--;
1016         val |= (val >> 1);
1017         val |= (val >> 2);
1018         val |= (val >> 4);
1019         val |= (val >> 8);
1020         val |= (val >> 16);
1021         return (++val);
1022 }
1023 
1024 /*
1025  * process GLOBAL undefined and ref_dyn_need symbols.
1026  */
1027 static uintptr_t
1028 reloc_exec(Rel_desc *rsp, Ofl_desc *ofl)
1029 {
1030         Sym_desc        *_sdp, *sdp = rsp->rel_sym;
1031         Sym_aux         *sap = sdp->sd_aux;
1032         Sym             *sym = sdp->sd_sym;
1033         Addr            stval;
1034 
1035         /*
1036          * Reference is to a function so simply create a plt entry for it.
1037          */
1038         if (ELF_ST_TYPE(sym->st_info) == STT_FUNC)
1039                 return (ld_reloc_plt(rsp, ofl));
1040 
1041         /*
1042          * Catch absolutes - these may cause a text relocation.
1043          */
1044         if ((sdp->sd_flags & FLG_SY_SPECSEC) && (sym->st_shndx == SHN_ABS)) {
1045                 if ((ofl->ofl_flags1 & FLG_OF1_ABSEXEC) == 0)
1046                         return ((*ld_targ.t_mr.mr_add_outrel)(NULL, rsp, ofl));
1047 
1048                 /*
1049                  * If -zabsexec is set then promote the ABSOLUTE symbol to
1050                  * current the current object and perform the relocation now.
1051                  */
1052                 sdp->sd_ref = REF_REL_NEED;
1053                 return (ld_add_actrel(NULL, rsp, ofl));
1054         }
1055 
1056         /*
1057          * If the relocation is against a writable section simply compute the
1058          * necessary output relocation.  As an optimization, if the symbol has
1059          * already been transformed into a copy relocation then we can perform
1060          * the relocation directly (copy relocations should only be generated
1061          * for references from the text segment and these relocations are
1062          * normally carried out before we get to the data segment relocations).
1063          */
1064         if ((ELF_ST_TYPE(sym->st_info) == STT_OBJECT) &&
1065             (RELAUX_GET_OSDESC(rsp)->os_shdr->sh_flags & SHF_WRITE)) {
1066                 if (sdp->sd_flags & FLG_SY_MVTOCOMM)
1067                         return (ld_add_actrel(NULL, rsp, ofl));
1068                 else
1069                         return ((*ld_targ.t_mr.mr_add_outrel)(NULL, rsp, ofl));
1070         }
1071 
1072         /*
1073          * If the reference isn't to an object (normally because a .type
1074          * directive wasn't defined in some assembler source), then apply
1075          * a generic relocation (this has a tendency to result in text
1076          * relocations).
1077          */
1078         if (ELF_ST_TYPE(sym->st_info) != STT_OBJECT) {
1079                 Conv_inv_buf_t inv_buf;
1080 
1081                 ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_REL_UNEXPSYM),
1082                     conv_sym_info_type(sdp->sd_file->ifl_ehdr->e_machine,
1083                     ELF_ST_TYPE(sym->st_info), 0, &inv_buf),
1084                     rsp->rel_isdesc->is_file->ifl_name,
1085                     ld_reloc_sym_name(rsp), sdp->sd_file->ifl_name);
1086                 return ((*ld_targ.t_mr.mr_add_outrel)(NULL, rsp, ofl));
1087         }
1088 
1089         /*
1090          * Prepare for generating a copy relocation.
1091          *
1092          * If this symbol is one of an alias pair, we need to ensure both
1093          * symbols become part of the output (the strong symbol will be used to
1094          * maintain the symbols state).  And, if we did raise the precedence of
1095          * a symbol we need to check and see if this is a weak symbol.  If it is
1096          * we want to use it's strong counter part.
1097          *
1098          * The results of this logic should be:
1099          *      ra_usym: assigned to strong
1100          *      rel_sym: assigned to symbol to perform
1101          *              copy_reloc against (weak or strong).
1102          */
1103         if (sap->sa_linkndx) {
1104                 _sdp = sdp->sd_file->ifl_oldndx[sap->sa_linkndx];
1105 
1106                 if (_sdp->sd_ref < sdp->sd_ref) {
1107                         _sdp->sd_ref = sdp->sd_ref;
1108                         _sdp->sd_flags |= FLG_SY_REFRSD;
1109 
1110                         /*
1111                          * As we're going to replicate a symbol from a shared
1112                          * object, retain its correct binding status.
1113                          */
1114                         if (ELF_ST_BIND(_sdp->sd_sym->st_info) == STB_GLOBAL)
1115                                 _sdp->sd_flags |= FLG_SY_GLOBREF;
1116 
1117                 } else if (_sdp->sd_ref > sdp->sd_ref) {
1118                         sdp->sd_ref = _sdp->sd_ref;
1119                         sdp->sd_flags |= FLG_SY_REFRSD;
1120 
1121                         /*
1122                          * As we're going to replicate a symbol from a shared
1123                          * object, retain its correct binding status.
1124                          */
1125                         if (ELF_ST_BIND(sym->st_info) == STB_GLOBAL)
1126                                 sdp->sd_flags |= FLG_SY_GLOBREF;
1127                 }
1128 
1129                 /*
1130                  * If this is a weak symbol then we want to move the strong
1131                  * symbol into local .bss.  If there is a copy_reloc to be
1132                  * performed, that should still occur against the WEAK symbol.
1133                  */
1134                 if (((ELF_ST_BIND(sdp->sd_sym->st_info) == STB_WEAK) ||
1135                     (sdp->sd_flags & FLG_SY_WEAKDEF)) &&
1136                     !ld_reloc_set_aux_usym(ofl, rsp, _sdp))
1137                         return (S_ERROR);
1138         } else
1139                 _sdp = 0;
1140 
1141         /*
1142          * If the reference is to an object then allocate space for the object
1143          * within the executables .bss.  Relocations will now be performed from
1144          * this new location.  If the original shared objects data is
1145          * initialized, then generate a copy relocation that will copy the data
1146          * to the executables .bss at runtime.
1147          */
1148         if (!(RELAUX_GET_USYM(rsp)->sd_flags & FLG_SY_MVTOCOMM)) {
1149                 Word            rtype = rsp->rel_rtype, w2align;
1150                 Copy_rel        cr;
1151 
1152                 /*
1153                  * Diagnose the original copy reference, as this symbol
1154                  * information will be overridden with the new destination.
1155                  */
1156                 DBG_CALL(Dbg_syms_copy_reloc(ofl, sdp, 0));
1157 
1158                 /*
1159                  * Indicate that the symbol(s) against which we're relocating
1160                  * have been moved to the executables common.  Also, insure that
1161                  * the symbol(s) remain marked as global, as the shared object
1162                  * from which they are copied must be able to relocate to the
1163                  * new common location within the executable.
1164                  *
1165                  * Note that even though a new symbol has been generated in the
1166                  * output files' .bss, the symbol must remain REF_DYN_NEED and
1167                  * not be promoted to REF_REL_NEED.  sym_validate() still needs
1168                  * to carry out a number of checks against the symbols binding
1169                  * that are triggered by the REF_DYN_NEED state.
1170                  */
1171                 sdp->sd_flags |=
1172                     (FLG_SY_MVTOCOMM | FLG_SY_DEFAULT | FLG_SY_EXPDEF);
1173                 sdp->sd_flags &= ~MSK_SY_LOCAL;
1174                 sdp->sd_sym->st_other &= ~MSK_SYM_VISIBILITY;
1175                 if (_sdp) {
1176                         _sdp->sd_flags |= (FLG_SY_MVTOCOMM |
1177                             FLG_SY_DEFAULT | FLG_SY_EXPDEF);
1178                         _sdp->sd_flags &= ~MSK_SY_LOCAL;
1179                         _sdp->sd_sym->st_other &= ~MSK_SYM_VISIBILITY;
1180 
1181                         /*
1182                          * Make sure the symbol has a reference in case of any
1183                          * error diagnostics against it (perhaps this belongs
1184                          * to a version that isn't allowable for this build).
1185                          * The resulting diagnostic (see sym_undef_entry())
1186                          * might seem a little bogus, as the symbol hasn't
1187                          * really been referenced by this file, but has been
1188                          * promoted as a consequence of its alias reference.
1189                          */
1190                         if (!(_sdp->sd_aux->sa_rfile))
1191                                 _sdp->sd_aux->sa_rfile = sdp->sd_aux->sa_rfile;
1192                 }
1193 
1194                 /*
1195                  * Assign the symbol to the bss.
1196                  */
1197                 _sdp = RELAUX_GET_USYM(rsp);
1198                 stval = _sdp->sd_sym->st_value;
1199                 if (ld_sym_copy(_sdp) == S_ERROR)
1200                         return (S_ERROR);
1201                 _sdp->sd_shndx = _sdp->sd_sym->st_shndx = SHN_COMMON;
1202                 _sdp->sd_flags |= FLG_SY_SPECSEC;
1203 
1204                 /*
1205                  * Ensure the symbol has sufficient alignment.  The symbol
1206                  * definition has no alignment information that can be used,
1207                  * hence we use a heuristic.  Historically, twice the native
1208                  * word alignment was sufficient for any data type, however,
1209                  * the developer may have requested larger alignments (pragma
1210                  * align).  The most conservative approach is to use a power
1211                  * of two alignment, determined from the alignment of the
1212                  * section containing the symbol definition.  Note that this
1213                  * can result in some bloat to the .bss as the not every item
1214                  * of copied data might need the section alignment.
1215                  *
1216                  * COMMON symbols carry their alignment requirements in the
1217                  * symbols st_value field.  This alignment is applied to the
1218                  * symbol when it is eventually transformed into .bss.
1219                  */
1220                 w2align = ld_targ.t_m.m_word_align * 2;
1221                 if (_sdp->sd_sym->st_size < w2align)
1222                         _sdp->sd_sym->st_value = ld_targ.t_m.m_word_align;
1223                 else {
1224                         Shdr    *shdr;
1225                         Word    isalign;
1226 
1227                         if (_sdp->sd_isc &&
1228                             ((shdr = _sdp->sd_isc->is_shdr) != NULL) &&
1229                             ((isalign = shdr->sh_addralign) != 0))
1230                                 _sdp->sd_sym->st_value = nlpo2(isalign);
1231                         else
1232                                 _sdp->sd_sym->st_value = w2align;
1233                 }
1234 
1235                 /*
1236                  * Whether or not the symbol references initialized data we
1237                  * generate a copy relocation - this differs from the past
1238                  * where we would not create the COPY_RELOC if we were binding
1239                  * against .bss.  This is done for *two* reasons.
1240                  *
1241                  *  -   If the symbol in the shared object changes to a
1242                  *      initialized data - we need the COPY to pick it up.
1243                  *  -   Without the COPY RELOC we can't tell that the symbol
1244                  *      from the COPY'd object has been moved and all bindings
1245                  *      to it should bind here.
1246                  *
1247                  * Keep this symbol in the copy relocation list to check the
1248                  * validity later.
1249                  */
1250                 cr.c_sdp = _sdp;
1251                 cr.c_val = stval;
1252                 if (alist_append(&ofl->ofl_copyrels, &cr, sizeof (Copy_rel),
1253                     AL_CNT_OFL_COPYRELS) == NULL)
1254                         return (S_ERROR);
1255 
1256                 rsp->rel_rtype = ld_targ.t_m.m_r_copy;
1257                 if ((*ld_targ.t_mr.mr_add_outrel)(FLG_REL_BSS, rsp, ofl) ==
1258                     S_ERROR)
1259                         return (S_ERROR);
1260                 rsp->rel_rtype = rtype;
1261 
1262                 /*
1263                  * If this symbol is a protected symbol, warn the user.  A
1264                  * potential issue exists as the copy relocated symbol within
1265                  * the executable can be visible to others, whereas the shared
1266                  * object that defined the original copy data symbol is pre-
1267                  * bound to reference it's own definition.  Any modification
1268                  * of the symbols data could lead to inconsistencies for the
1269                  * various users.
1270                  */
1271                 if (_sdp->sd_flags & FLG_SY_PROT) {
1272                         Conv_inv_buf_t inv_buf;
1273 
1274                         ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_REL_COPY),
1275                             conv_reloc_type(_sdp->sd_file->ifl_ehdr->e_machine,
1276                             ld_targ.t_m.m_r_copy, 0, &inv_buf),
1277                             _sdp->sd_file->ifl_name, _sdp->sd_name);
1278                 }
1279                 DBG_CALL(Dbg_syms_copy_reloc(ofl, _sdp,
1280                     _sdp->sd_sym->st_value));
1281         }
1282         return (ld_add_actrel(NULL, rsp, ofl));
1283 }
1284 
1285 /*
1286  * All relocations should have been handled by the other routines.  This
1287  * routine is here as a catch all, if we do enter it we've goofed - but
1288  * we'll try and do the best we can.
1289  */
1290 static uintptr_t
1291 reloc_generic(Rel_desc *rsp, Ofl_desc *ofl)
1292 {
1293         Ifl_desc        *ifl = rsp->rel_isdesc->is_file;
1294         Conv_inv_buf_t  inv_buf;
1295 
1296         ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_REL_UNEXPREL),
1297             conv_reloc_type(ifl->ifl_ehdr->e_machine, rsp->rel_rtype,
1298             0, &inv_buf), ifl->ifl_name, ld_reloc_sym_name(rsp));
1299 
1300         /*
1301          * If building a shared object then put the relocation off
1302          * until runtime.
1303          */
1304         if (ofl->ofl_flags & FLG_OF_SHAROBJ)
1305                 return ((*ld_targ.t_mr.mr_add_outrel)(NULL, rsp, ofl));
1306 
1307         /*
1308          * Otherwise process relocation now.
1309          */
1310         return (ld_add_actrel(NULL, rsp, ofl));
1311 }
1312 
1313 /*
1314  * Process relocations when building a relocatable object.  Typically, there
1315  * aren't many relocations that can be caught at this point, most are simply
1316  * passed through to the output relocatable object.
1317  */
1318 static uintptr_t
1319 reloc_relobj(Boolean local, Rel_desc *rsp, Ofl_desc *ofl)
1320 {
1321         Word            rtype = rsp->rel_rtype;
1322         Sym_desc        *sdp = rsp->rel_sym;
1323         Is_desc         *isp = rsp->rel_isdesc;
1324         Word            oflags = NULL;
1325 
1326         /*
1327          * Determine if we can do any relocations at this point.  We can if:
1328          *
1329          *      this is local_symbol and a non-GOT relocation, and
1330          *      the relocation is pc-relative, and
1331          *      the relocation is against a symbol in same section
1332          */
1333         if (local && !IS_GOT_RELATIVE(rtype) &&
1334             !IS_GOT_BASED(rtype) && !IS_GOT_PC(rtype) &&
1335             IS_PC_RELATIVE(rtype) &&
1336             ((sdp->sd_isc) && (sdp->sd_isc->is_osdesc == isp->is_osdesc)))
1337                 return (ld_add_actrel(NULL, rsp, ofl));
1338 
1339         /*
1340          * If -zredlocsym is in effect, translate all local symbol relocations
1341          * to be against section symbols, since section symbols are the only
1342          * local symbols which will be added to the .symtab.
1343          */
1344         if (local && (((ofl->ofl_flags & FLG_OF_REDLSYM) &&
1345             (ELF_ST_BIND(sdp->sd_sym->st_info) == STB_LOCAL)) ||
1346             ((sdp->sd_flags & FLG_SY_ELIM) &&
1347             (ofl->ofl_flags & FLG_OF_PROCRED)))) {
1348                 /*
1349                  * But if this is PIC code, don't allow it for now.
1350                  */
1351                 if (IS_GOT_RELATIVE(rsp->rel_rtype)) {
1352                         Ifl_desc        *ifl = rsp->rel_isdesc->is_file;
1353                         Conv_inv_buf_t inv_buf;
1354 
1355                         ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_REL_PICREDLOC),
1356                             ld_reloc_sym_name(rsp), ifl->ifl_name,
1357                             conv_reloc_type(ifl->ifl_ehdr->e_machine,
1358                             rsp->rel_rtype, 0, &inv_buf));
1359                         return (S_ERROR);
1360                 }
1361 
1362                 /*
1363                  * Indicate that this relocation should be processed the same
1364                  * as a section symbol.  For RELA, indicate that the addend
1365                  * also needs to be applied to this relocation.
1366                  */
1367                 if ((rsp->rel_flags & FLG_REL_RELA) == FLG_REL_RELA)
1368                         oflags = FLG_REL_SCNNDX | FLG_REL_ADVAL;
1369                 else
1370                         oflags = FLG_REL_SCNNDX;
1371         }
1372 
1373         if ((rsp->rel_flags & FLG_REL_RELA) == 0) {
1374                 /*
1375                  * Intel (Rel) relocations do not contain an addend.  Any
1376                  * addend is contained within the file at the location
1377                  * identified by the relocation offset.  Therefore, if we're
1378                  * processing a section symbol, or a -zredlocsym relocation
1379                  * (that basically transforms a local symbol reference into
1380                  * a section reference), perform an active relocation to
1381                  * propagate any addend.
1382                  */
1383                 if ((ELF_ST_TYPE(sdp->sd_sym->st_info) == STT_SECTION) ||
1384                     (oflags == FLG_REL_SCNNDX))
1385                         if (ld_add_actrel(NULL, rsp, ofl) == S_ERROR)
1386                                 return (S_ERROR);
1387         }
1388         return ((*ld_targ.t_mr.mr_add_outrel)(oflags, rsp, ofl));
1389 }
1390 
1391 /*
1392  * Perform any generic TLS validations before passing control to machine
1393  * specific routines.  At this point we know we are dealing with an executable
1394  * or shared object - relocatable objects have already been processed.
1395  */
1396 static uintptr_t
1397 reloc_TLS(Boolean local, Rel_desc *rsp, Ofl_desc *ofl)
1398 {
1399         Word            rtype = rsp->rel_rtype;
1400         ofl_flag_t      flags = ofl->ofl_flags;
1401         Ifl_desc        *ifl = rsp->rel_isdesc->is_file;
1402         Half            mach = ifl->ifl_ehdr->e_machine;
1403         Sym_desc        *sdp = rsp->rel_sym;
1404         unsigned char   type;
1405         Conv_inv_buf_t  inv_buf1, inv_buf2;
1406 
1407         /*
1408          * All TLS relocations are illegal in a static executable.
1409          */
1410         if (OFL_IS_STATIC_EXEC(ofl)) {
1411                 ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_REL_TLSSTAT),
1412                     conv_reloc_type(mach, rtype, 0, &inv_buf1), ifl->ifl_name,
1413                     ld_reloc_sym_name(rsp));
1414                 return (S_ERROR);
1415         }
1416 
1417         /*
1418          * Any TLS relocation must be against a STT_TLS symbol, all others
1419          * are illegal.
1420          */
1421         if ((type = ELF_ST_TYPE(sdp->sd_sym->st_info)) != STT_TLS) {
1422                 ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_REL_TLSBADSYM),
1423                     conv_reloc_type(mach, rtype, 0, &inv_buf1), ifl->ifl_name,
1424                     ld_reloc_sym_name(rsp),
1425                     conv_sym_info_type(mach, type, 0, &inv_buf2));
1426                 return (S_ERROR);
1427         }
1428 
1429         /*
1430          * A dynamic executable can not use the LD or LE reference models to
1431          * reference an external symbol.  A shared object can not use the LD
1432          * reference model to reference an external symbol.
1433          */
1434         if (!local && (IS_TLS_LD(rtype) ||
1435             ((flags & FLG_OF_EXEC) && IS_TLS_LE(rtype)))) {
1436                 ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_REL_TLSBND),
1437                     conv_reloc_type(mach, rtype, 0, &inv_buf1), ifl->ifl_name,
1438                     ld_reloc_sym_name(rsp), sdp->sd_file->ifl_name);
1439                 return (S_ERROR);
1440         }
1441 
1442         /*
1443          * The TLS LE model is only allowed for dynamic executables.  The TLS IE
1444          * model is allowed for shared objects, but this model has restrictions.
1445          * This model can only be used freely in dependencies that are loaded
1446          * immediately as part of process initialization.  However, during the
1447          * initial runtime handshake with libc that establishes the thread
1448          * pointer, a small backup TLS reservation is created.  This area can
1449          * be used by objects that are loaded after threads are initialized.
1450          * However, this area is limited in size and may have already been
1451          * used.  This area is intended for specialized applications, and does
1452          * not provide the degree of flexibility dynamic TLS can offer.  Under
1453          * -z verbose indicate this restriction to the user.
1454          */
1455         if ((flags & FLG_OF_EXEC) == 0) {
1456                 if (IS_TLS_LE(rtype)) {
1457                         ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_REL_TLSLE),
1458                             conv_reloc_type(mach, rtype, 0, &inv_buf1),
1459                             ifl->ifl_name, ld_reloc_sym_name(rsp));
1460                         return (S_ERROR);
1461 
1462                 } else if ((IS_TLS_IE(rtype)) &&
1463                     (flags & FLG_OF_VERBOSE)) {
1464                         ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_REL_TLSIE),
1465                             conv_reloc_type(mach, rtype, 0, &inv_buf1),
1466                             ifl->ifl_name, ld_reloc_sym_name(rsp));
1467                 }
1468         }
1469 
1470         return ((*ld_targ.t_mr.mr_reloc_TLS)(local, rsp, ofl));
1471 }
1472 
1473 uintptr_t
1474 ld_process_sym_reloc(Ofl_desc *ofl, Rel_desc *reld, Rel *reloc, Is_desc *isp,
1475     const char *isname, Word isscnndx)
1476 {
1477         Word            rtype = reld->rel_rtype;
1478         ofl_flag_t      flags = ofl->ofl_flags;
1479         Sym_desc        *sdp = reld->rel_sym;
1480         Sym_aux         *sap;
1481         Boolean         local;
1482         Conv_inv_buf_t  inv_buf;
1483 
1484         DBG_CALL(Dbg_reloc_in(ofl->ofl_lml, ELF_DBG_LD, ld_targ.t_m.m_mach,
1485             ld_targ.t_m.m_rel_sht_type, (void *)reloc, isname, isscnndx,
1486             ld_reloc_sym_name(reld)));
1487 
1488         /*
1489          * Indicate this symbol is being used for relocation and therefore must
1490          * have its output address updated accordingly (refer to update_osym()).
1491          */
1492         sdp->sd_flags |= FLG_SY_UPREQD;
1493 
1494         /*
1495          * Indicate the section this symbol is defined in has been referenced,
1496          * therefor it *is not* a candidate for elimination.
1497          */
1498         if (sdp->sd_isc) {
1499                 sdp->sd_isc->is_flags |= FLG_IS_SECTREF;
1500                 sdp->sd_isc->is_file->ifl_flags |= FLG_IF_FILEREF;
1501         }
1502 
1503         if (!ld_reloc_set_aux_usym(ofl, reld, sdp))
1504                 return (S_ERROR);
1505 
1506         /*
1507          * Determine if this symbol is actually an alias to another symbol.  If
1508          * so, and the alias is not REF_DYN_SEEN, set ra_usym to point to the
1509          * weak symbols strong counter-part.  The one exception is if the
1510          * FLG_SY_MVTOCOMM flag is set on the weak symbol.  If this is the case,
1511          * the strong is only here because of its promotion, and the weak symbol
1512          * should still be used for the relocation reference (see reloc_exec()).
1513          */
1514         sap = sdp->sd_aux;
1515         if (sap && sap->sa_linkndx &&
1516             ((ELF_ST_BIND(sdp->sd_sym->st_info) == STB_WEAK) ||
1517             (sdp->sd_flags & FLG_SY_WEAKDEF)) &&
1518             (!(sdp->sd_flags & FLG_SY_MVTOCOMM))) {
1519                 Sym_desc        *_sdp;
1520 
1521                 _sdp = sdp->sd_file->ifl_oldndx[sap->sa_linkndx];
1522                 if ((_sdp->sd_ref != REF_DYN_SEEN) &&
1523                     !ld_reloc_set_aux_usym(ofl, reld, _sdp))
1524                         return (S_ERROR);
1525         }
1526 
1527         /*
1528          * Determine whether this symbol should be bound locally or not.
1529          * Symbols are bound locally if one of the following is true:
1530          *
1531          *  -   the symbol is of type STB_LOCAL.
1532          *
1533          *  -   the output image is not a relocatable object and the relocation
1534          *      is relative to the .got.
1535          *
1536          *  -   the section being relocated is of type SHT_SUNW_dof.  These
1537          *      sections must be bound to the functions in the containing
1538          *      object and can not be interposed upon.
1539          *
1540          *  -   the symbol has been reduced (scoped to a local or symbolic) and
1541          *      reductions are being processed.
1542          *
1543          *  -   the -Bsymbolic flag is in use when building a shared object,
1544          *      and the symbol hasn't explicitly been defined as nodirect.
1545          *
1546          *  -   an executable (fixed address) is being created, and the symbol
1547          *      is defined in the executable.
1548          *
1549          *  -   the relocation is against a segment which will not be loaded
1550          *      into memory.  In this case, the relocation must be resolved
1551          *      now, as ld.so.1 can not process relocations against unmapped
1552          *      segments.
1553          */
1554         local = FALSE;
1555         if (ELF_ST_BIND(sdp->sd_sym->st_info) == STB_LOCAL) {
1556                 local = TRUE;
1557         } else if (!(reld->rel_flags & FLG_REL_LOAD)) {
1558                 local = TRUE;
1559         } else if (sdp->sd_sym->st_shndx != SHN_UNDEF) {
1560                 if (reld->rel_isdesc &&
1561                     reld->rel_isdesc->is_shdr->sh_type == SHT_SUNW_dof) {
1562                         local = TRUE;
1563                 } else if (!(flags & FLG_OF_RELOBJ) &&
1564                     (IS_LOCALBND(rtype) || IS_SEG_RELATIVE(rtype))) {
1565                         local = TRUE;
1566                 } else if ((sdp->sd_ref == REF_REL_NEED) &&
1567                     ((sdp->sd_flags & FLG_SY_CAP) == 0)) {
1568                         /*
1569                          * Global symbols may have been individually reduced in
1570                          * scope.  If the whole object is to be self contained,
1571                          * such as when generating an executable or a symbolic
1572                          * shared object, make sure all relocation symbol
1573                          * references (sections too) are treated locally.  Note,
1574                          * explicit no-direct symbols should not be bound to
1575                          * locally.
1576                          */
1577                         if ((sdp->sd_flags &
1578                             (FLG_SY_HIDDEN | FLG_SY_PROTECT)))
1579                                 local = TRUE;
1580                         else if ((flags & FLG_OF_EXEC) ||
1581                             ((flags & FLG_OF_SYMBOLIC) &&
1582                             ((sdp->sd_flags & FLG_SY_NDIR) == 0))) {
1583                                 local = TRUE;
1584                         }
1585                 }
1586         }
1587 
1588         /*
1589          * If this is a PC_RELATIVE relocation, the relocation could be
1590          * compromised if the relocated address is later used as a copy
1591          * relocated symbol (PSARC 1999/636, bugid 4187211).  Scan the input
1592          * files symbol table to cross reference this relocation offset.
1593          */
1594         if ((ofl->ofl_flags & FLG_OF_SHAROBJ) &&
1595             IS_PC_RELATIVE(rtype) &&
1596             (IS_GOT_PC(rtype) == 0) &&
1597             (IS_PLT(rtype) == 0)) {
1598                 if (disp_inspect(ofl, reld, local) == S_ERROR)
1599                         return (S_ERROR);
1600         }
1601 
1602         /*
1603          * GOT based relocations must bind to the object being built - since
1604          * they are relevant to the current GOT.  If not building a relocatable
1605          * object - give a appropriate error message.
1606          */
1607         if (!local && !(flags & FLG_OF_RELOBJ) &&
1608             IS_GOT_BASED(rtype)) {
1609                 Ifl_desc        *ifl = reld->rel_isdesc->is_file;
1610 
1611                 ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_REL_BADGOTBASED),
1612                     conv_reloc_type(ifl->ifl_ehdr->e_machine, rtype,
1613                     0, &inv_buf), ifl->ifl_name, demangle(sdp->sd_name));
1614                 return (S_ERROR);
1615         }
1616 
1617         /*
1618          * TLS symbols can only have TLS relocations.
1619          */
1620         if ((ELF_ST_TYPE(sdp->sd_sym->st_info) == STT_TLS) &&
1621             (IS_TLS_INS(rtype) == 0)) {
1622                 /*
1623                  * The above test is relaxed if the target section is
1624                  * non-allocable.
1625                  */
1626                 if (RELAUX_GET_OSDESC(reld)->os_shdr->sh_flags & SHF_ALLOC) {
1627                         Ifl_desc        *ifl = reld->rel_isdesc->is_file;
1628 
1629                         ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_REL_BADTLS),
1630                             conv_reloc_type(ifl->ifl_ehdr->e_machine,
1631                             rtype, 0, &inv_buf), ifl->ifl_name,
1632                             demangle(sdp->sd_name));
1633                         return (S_ERROR);
1634                 }
1635         }
1636 
1637         /*
1638          * Select the relocation to perform.
1639          */
1640         if (IS_REGISTER(rtype)) {
1641                 if (ld_targ.t_mr.mr_reloc_register == NULL) {
1642                         ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_REL_NOREG));
1643                         return (S_ERROR);
1644                 }
1645                 return ((*ld_targ.t_mr.mr_reloc_register)(reld, isp, ofl));
1646         }
1647 
1648         if (flags & FLG_OF_RELOBJ)
1649                 return (reloc_relobj(local, reld, ofl));
1650 
1651         if (IS_TLS_INS(rtype))
1652                 return (reloc_TLS(local, reld, ofl));
1653 
1654         if (IS_GOT_OPINS(rtype)) {
1655                 if (ld_targ.t_mr.mr_reloc_GOTOP == NULL) {
1656                         assert(0);
1657                         return (S_ERROR);
1658                 }
1659                 return ((*ld_targ.t_mr.mr_reloc_GOTOP)(local, reld, ofl));
1660         }
1661 
1662         if (IS_GOT_RELATIVE(rtype))
1663                 return (ld_reloc_GOT_relative(local, reld, ofl));
1664 
1665         if (local)
1666                 return ((*ld_targ.t_mr.mr_reloc_local)(reld, ofl));
1667 
1668         if ((IS_PLT(rtype) || ((sdp->sd_flags & FLG_SY_CAP) &&
1669             (ELF_ST_TYPE(sdp->sd_sym->st_info) == STT_FUNC))) &&
1670             ((flags & FLG_OF_BFLAG) == 0))
1671                 return (ld_reloc_plt(reld, ofl));
1672 
1673         if ((sdp->sd_ref == REF_REL_NEED) ||
1674             (flags & FLG_OF_BFLAG) || (flags & FLG_OF_SHAROBJ) ||
1675             (ELF_ST_TYPE(sdp->sd_sym->st_info) == STT_NOTYPE))
1676                 return ((*ld_targ.t_mr.mr_add_outrel)(NULL, reld, ofl));
1677 
1678         if (sdp->sd_ref == REF_DYN_NEED)
1679                 return (reloc_exec(reld, ofl));
1680 
1681         /*
1682          * IS_NOT_REL(rtype)
1683          */
1684         return (reloc_generic(reld, ofl));
1685 }
1686 
1687 /*
1688  * Given a relocation that references a local symbol from a discarded COMDAT
1689  * section, replace the symbol with the corresponding symbol from the section
1690  * that was kept.
1691  *
1692  * entry:
1693  *      reld - Relocation
1694  *      sdp - Symbol to be replaced. Must be a local symbol (STB_LOCAL).
1695  *      reject - Address of variable to receive rejection code
1696  *              if no replacement symbol is found.
1697  *
1698  * exit:
1699  *      Returns address of replacement symbol descriptor if one was
1700  *      found, and NULL otherwise. The result is also cached in
1701  *      ofl->ofl_sr_cache as an optimization to speed following calls
1702  *      for the same value of sdp.
1703  *
1704  *      On success (non-NULL result), *reject is set to RLXREL_REJ_NONE.
1705  *      On failure (NULL result), *reject is filled in with a code
1706  *      describing the underlying reason.
1707  *
1708  * note:
1709  *      The word "COMDAT" is used to refer to actual COMDAT sections, COMDAT
1710  *      groups tied together with an SHF_GROUP section, and .gnu.linkonce
1711  *      sections which provide a simplified COMDAT requirement.  COMDAT
1712  *      sections are identified with the FLG_IS_COMDAT section flag.
1713  *
1714  *      In principle, this sort of sloppy relocation remapping is
1715  *      a questionable practice. All self-referential sections should
1716  *      be in a common SHF_GROUP so that they are all kept or removed
1717  *      together. The problem is that there is no way to ensure that the
1718  *      two sections are similar enough that the replacement section will
1719  *      really supply the correct information. However, we see a couple of
1720  *      situations where it is useful to do this: (1) Older Sun C compilers
1721  *      generated DWARF sections that would refer to one of the COMDAT
1722  *      sections, and (2) gcc, when its GNU linkonce COMDAT feature is enabled.
1723  *      It turns out that the GNU ld does these sloppy remappings.
1724  *
1725  *      The GNU ld takes an approach that hard wires special section
1726  *      names and treats them specially. We avoid that practice and
1727  *      try to get the necessary work done relying only on the ELF
1728  *      attributes of the sections and symbols involved. This means
1729  *      that our heuristic is somewhat different than theirs, but the
1730  *      end result is close enough to solve the same problem.
1731  *
1732  *      gcc is in the process of converting to SHF_GROUP. This will
1733  *      eventually phase out the need for sloppy relocations, and
1734  *      then this logic won't be needed. In the meantime, relaxed relocation
1735  *      processing allows us to interoperate.
1736  */
1737 static Sym_desc *
1738 sloppy_comdat_reloc(Ofl_desc *ofl, Rel_desc *reld, Sym_desc *sdp,
1739     Rlxrel_rej *reject)
1740 {
1741         Is_desc         *rep_isp;
1742         Sym             *sym, *rep_sym;
1743         Is_desc         *isp;
1744         Ifl_desc        *ifl;
1745         Conv_inv_buf_t  inv_buf;
1746         Word            scnndx, symscnt;
1747         Sym_desc        **oldndx, *rep_sdp;
1748         const char      *is_name;
1749 
1750 
1751         /*
1752          * Sloppy relocations are never applied to .eh_frame or
1753          * .gcc_except_table sections. The entries in these sections
1754          * for discarded sections are better left uninitialized.
1755          *
1756          * We match these sections by name, because on most platforms they
1757          * are SHT_PROGBITS, and cannot be identified otherwise. On amd64
1758          * architectures, .eh_frame is SHT_AMD64_UNWIND, but that is ambiguous
1759          * (.eh_frame_hdr is also SHT_AMD64_UNWIND), so we still match it by
1760          * name.
1761          */
1762         is_name = reld->rel_isdesc->is_name;
1763         if (((is_name[1] == 'e') &&
1764             (strcmp(is_name, MSG_ORIG(MSG_SCN_EHFRAME)) == 0)) ||
1765             ((is_name[1] == 'g') &&
1766             (strcmp(is_name, MSG_ORIG(MSG_SCN_GCC_X_TBL)) == 0))) {
1767                 *reject = RLXREL_REJ_TARGET;
1768                 return (NULL);
1769         }
1770 
1771         /*
1772          * If we looked up the same symbol on the previous call, we can
1773          * return the cached value.
1774          */
1775         if (sdp == ofl->ofl_sr_cache.sr_osdp) {
1776                 *reject = ofl->ofl_sr_cache.sr_rej;
1777                 return (ofl->ofl_sr_cache.sr_rsdp);
1778         }
1779 
1780         ofl->ofl_sr_cache.sr_osdp = sdp;
1781         sym = sdp->sd_sym;
1782         isp = sdp->sd_isc;
1783         ifl = sdp->sd_file;
1784 
1785         /*
1786          * When a COMDAT section is discarded in favor of another COMDAT
1787          * section, the replacement is recorded in its section descriptor
1788          * (is_comdatkeep). We must validate the replacement before using
1789          * it. The replacement section must:
1790          *      - Not have been discarded
1791          *      - Have the same size (*)
1792          *      - Have the same section type
1793          *      - Have the same SHF_GROUP flag setting (either on or off)
1794          *      - Must be a COMDAT section of one form or the other.
1795          *
1796          * (*) One might imagine that the replacement section could be
1797          * larger than the original, rather than the exact size. However,
1798          * we have verified that this is the same policy used by the GNU
1799          * ld. If the sections are not the same size, the chance of them
1800          * being interchangeable drops significantly.
1801          */
1802         if (((rep_isp = isp->is_comdatkeep) == NULL) ||
1803             ((rep_isp->is_flags & FLG_IS_DISCARD) != 0) ||
1804             ((rep_isp->is_flags & FLG_IS_COMDAT) == 0) ||
1805             (isp->is_indata->d_size != rep_isp->is_indata->d_size) ||
1806             (isp->is_shdr->sh_type != rep_isp->is_shdr->sh_type) ||
1807             ((isp->is_shdr->sh_flags & SHF_GROUP) !=
1808             (rep_isp->is_shdr->sh_flags & SHF_GROUP))) {
1809                 *reject = ofl->ofl_sr_cache.sr_rej = RLXREL_REJ_SECTION;
1810                 return (ofl->ofl_sr_cache.sr_rsdp = NULL);
1811         }
1812 
1813         /*
1814          * We found the kept COMDAT section. Now, look at all of the
1815          * symbols from the input file that contains it to find the
1816          * symbol that corresponds to the one we started with:
1817          *      - Hasn't been discarded
1818          *      - Has section index of kept section
1819          *      - If one symbol has a name, the other must have
1820          *              the same name. The st_name field of a symbol
1821          *              is 0 if there is no name, and is a string
1822          *              table offset otherwise. The string table
1823          *              offsets may well not agree --- it is the
1824          *              actual string that matters.
1825          *      - Type and binding attributes match (st_info)
1826          *      - Values match (st_value)
1827          *      - Sizes match (st_size)
1828          *      - Visibility matches (st_other)
1829          */
1830         scnndx = rep_isp->is_scnndx;
1831         oldndx = rep_isp->is_file->ifl_oldndx;
1832         symscnt = rep_isp->is_file->ifl_symscnt;
1833         while (symscnt--) {
1834                 rep_sdp = *oldndx++;
1835                 if ((rep_sdp == NULL) || (rep_sdp->sd_flags & FLG_SY_ISDISC) ||
1836                     ((rep_sym = rep_sdp->sd_sym)->st_shndx != scnndx) ||
1837                     ((sym->st_name == 0) != (rep_sym->st_name == 0)) ||
1838                     ((sym->st_name != 0) &&
1839                     (strcmp(sdp->sd_name, rep_sdp->sd_name) != 0)) ||
1840                     (sym->st_info != rep_sym->st_info) ||
1841                     (sym->st_value != rep_sym->st_value) ||
1842                     (sym->st_size != rep_sym->st_size) ||
1843                     (sym->st_other != rep_sym->st_other))
1844                         continue;
1845 
1846 
1847                 if (ofl->ofl_flags & FLG_OF_VERBOSE) {
1848                         if (sym->st_name != 0) {
1849                                 ld_eprintf(ofl, ERR_WARNING,
1850                                     MSG_INTL(MSG_REL_SLOPCDATNAM),
1851                                     conv_reloc_type(ifl->ifl_ehdr->e_machine,
1852                                     reld->rel_rtype, 0, &inv_buf),
1853                                     ifl->ifl_name,
1854                                     EC_WORD(reld->rel_isdesc->is_scnndx),
1855                                     reld->rel_isdesc->is_name,
1856                                     rep_sdp->sd_name,
1857                                     EC_WORD(isp->is_scnndx), isp->is_name,
1858                                     rep_sdp->sd_file->ifl_name);
1859                         } else {
1860                                 ld_eprintf(ofl, ERR_WARNING,
1861                                     MSG_INTL(MSG_REL_SLOPCDATNONAM),
1862                                     conv_reloc_type(ifl->ifl_ehdr->e_machine,
1863                                     reld->rel_rtype, 0, &inv_buf),
1864                                     ifl->ifl_name,
1865                                     EC_WORD(reld->rel_isdesc->is_scnndx),
1866                                     reld->rel_isdesc->is_name,
1867                                     EC_WORD(isp->is_scnndx), isp->is_name,
1868                                     rep_sdp->sd_file->ifl_name);
1869                         }
1870                 }
1871                 DBG_CALL(Dbg_reloc_sloppycomdat(ofl->ofl_lml, rep_sdp));
1872                 *reject = ofl->ofl_sr_cache.sr_rej = RLXREL_REJ_NONE;
1873                 return (ofl->ofl_sr_cache.sr_rsdp = rep_sdp);
1874         }
1875 
1876         /* If didn't return above, we didn't find it */
1877         *reject = ofl->ofl_sr_cache.sr_rej = RLXREL_REJ_SYMBOL;
1878         return (ofl->ofl_sr_cache.sr_rsdp = NULL);
1879 }
1880 
1881 /*
1882  * Generate relocation descriptor and dispatch
1883  */
1884 static uintptr_t
1885 process_reld(Ofl_desc *ofl, Is_desc *isp, Rel_desc *reld, Word rsndx,
1886     Rel *reloc)
1887 {
1888         Ifl_desc        *ifl = isp->is_file;
1889         Word            rtype = reld->rel_rtype;
1890         Sym_desc        *sdp;
1891         Conv_inv_buf_t  inv_buf;
1892 
1893         /*
1894          * Make sure the relocation is in the valid range.
1895          */
1896         if (rtype >= ld_targ.t_m.m_r_num) {
1897                 ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_REL_INVALRELT),
1898                     ifl->ifl_name, EC_WORD(isp->is_scnndx), isp->is_name,
1899                     rtype);
1900                 return (S_ERROR);
1901         }
1902 
1903         ofl->ofl_entrelscnt++;
1904 
1905         /*
1906          * Special case: a register symbol associated with symbol index 0 is
1907          * initialized (i.e., relocated) to a constant from the r_addend field
1908          * rather than from a symbol value.
1909          */
1910         if (IS_REGISTER(rtype) && (rsndx == 0)) {
1911                 reld->rel_sym = NULL;
1912                 DBG_CALL(Dbg_reloc_in(ofl->ofl_lml, ELF_DBG_LD,
1913                     ld_targ.t_m.m_mach, isp->is_shdr->sh_type,
1914                     (void *)reloc, isp->is_name, isp->is_scnndx,
1915                     ld_reloc_sym_name(reld)));
1916                 if (ld_targ.t_mr.mr_reloc_register == NULL) {
1917                         ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_REL_NOREG));
1918                         return (S_ERROR);
1919                 }
1920                 return ((*ld_targ.t_mr.mr_reloc_register)(reld, isp, ofl));
1921         }
1922 
1923         /*
1924          * If this is a STT_SECTION symbol, make sure the associated
1925          * section has a descriptive non-NULL is_sym_name field that can
1926          * be accessed by ld_reloc_sym_name() to satisfy debugging output
1927          * and errors.
1928          *
1929          * In principle, we could add this string to every input section
1930          * as it is created, but we defer it until we see a relocation
1931          * symbol that might need it. Not every section will have such
1932          * a relocation, so we create fewer of them this way.
1933          */
1934         sdp = reld->rel_sym = ifl->ifl_oldndx[rsndx];
1935         if ((sdp != NULL) &&
1936             (ELF_ST_TYPE(sdp->sd_sym->st_info) == STT_SECTION) &&
1937             (sdp->sd_isc != NULL) && (sdp->sd_isc->is_name != NULL) &&
1938             (sdp->sd_isc->is_sym_name == NULL) &&
1939             (ld_stt_section_sym_name(sdp->sd_isc) == NULL))
1940                 return (S_ERROR);
1941 
1942         /*
1943          * If for some reason we have a null relocation record issue a
1944          * warning and continue (the compiler folks can get into this
1945          * state some time).  Normal users should never see this error.
1946          */
1947         if (rtype == ld_targ.t_m.m_r_none) {
1948                 DBG_CALL(Dbg_reloc_in(ofl->ofl_lml, ELF_DBG_LD,
1949                     ld_targ.t_m.m_mach, ld_targ.t_m.m_rel_sht_type,
1950                     (void *)reloc, isp->is_name, isp->is_scnndx,
1951                     ld_reloc_sym_name(reld)));
1952                 ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_REL_NULL),
1953                     ifl->ifl_name, EC_WORD(isp->is_scnndx), isp->is_name);
1954                 return (1);
1955         }
1956 
1957         if (((ofl->ofl_flags & FLG_OF_RELOBJ) == 0) &&
1958             IS_NOTSUP(rtype)) {
1959                 ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_REL_NOTSUP),
1960                     conv_reloc_type(ifl->ifl_ehdr->e_machine, rtype,
1961                     0, &inv_buf), ifl->ifl_name, EC_WORD(isp->is_scnndx),
1962                     isp->is_name);
1963                 return (S_ERROR);
1964         }
1965 
1966         /*
1967          * If we are here, we know that the relocation requires reference
1968          * symbol. If no symbol is assigned, this is a fatal error.
1969          */
1970         if (sdp == NULL) {
1971                 ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_REL_NOSYMBOL),
1972                     conv_reloc_type(ifl->ifl_ehdr->e_machine, rtype,
1973                     0, &inv_buf), ifl->ifl_name, EC_WORD(isp->is_scnndx),
1974                     isp->is_name, EC_XWORD(reloc->r_offset));
1975                 return (S_ERROR);
1976         }
1977 
1978         if (sdp->sd_flags & FLG_SY_IGNORE)
1979                 return (1);
1980 
1981         /*
1982          * If this symbol is part of a DISCARDED section attempt to find another
1983          * definition.
1984          */
1985         if (sdp->sd_flags & FLG_SY_ISDISC) {
1986                 Sym_desc        *nsdp = NULL;
1987                 Rlxrel_rej      reject;
1988 
1989                 if (ELF_ST_BIND(sdp->sd_sym->st_info) == STB_LOCAL) {
1990                         /*
1991                          * If "-z relaxreloc", and the input section is COMDAT
1992                          * that has been assigned to an output section, then
1993                          * determine if this is a reference to a discarded
1994                          * COMDAT section that can be replaced with a COMDAT
1995                          * that has been kept.
1996                          */
1997                         if ((ofl->ofl_flags1 & FLG_OF1_RLXREL) &&
1998                             sdp->sd_isc->is_osdesc &&
1999                             (sdp->sd_isc->is_flags & FLG_IS_COMDAT) &&
2000                             ((nsdp = sloppy_comdat_reloc(ofl, reld,
2001                             sdp, &reject)) == NULL)) {
2002                                 Shdr    *is_shdr = reld->rel_isdesc->is_shdr;
2003 
2004                                 /*
2005                                  * A matching symbol was not found. We will
2006                                  * ignore this relocation.  Determine whether
2007                                  * or not to issue a warning.
2008                                  * Warnings are always issued under -z verbose,
2009                                  * but otherwise, we will follow the lead of
2010                                  * the GNU ld and suppress them for certain
2011                                  * cases:
2012                                  *
2013                                  *  -   It is a non-allocable debug section.
2014                                  *      The GNU ld tests for these by name,
2015                                  *      but we are willing to extend it to
2016                                  *      any non-allocable section.
2017                                  *  -   The target section is excluded from
2018                                  *      sloppy relocations by policy.
2019                                  */
2020                                 if (((ofl->ofl_flags & FLG_OF_VERBOSE) != 0) ||
2021                                     ((is_shdr->sh_flags & SHF_ALLOC) &&
2022                                     (reject != RLXREL_REJ_TARGET)))
2023                                         ld_eprintf(ofl, ERR_WARNING,
2024                                             MSG_INTL(MSG_REL_SLOPCDATNOSYM),
2025                                             conv_reloc_type(
2026                                             ifl->ifl_ehdr->e_machine,
2027                                             reld->rel_rtype, 0, &inv_buf),
2028                                             ifl->ifl_name,
2029                                             EC_WORD(isp->is_scnndx),
2030                                             isp->is_name,
2031                                             ld_reloc_sym_name(reld),
2032                                             EC_WORD(sdp->sd_isc->is_scnndx),
2033                                             sdp->sd_isc->is_name);
2034                                 return (1);
2035                         }
2036                 } else if ((sdp != NULL) && sdp->sd_name && *sdp->sd_name)
2037                         nsdp = ld_sym_find(sdp->sd_name, SYM_NOHASH, NULL, ofl);
2038 
2039                 if (nsdp == NULL) {
2040                         ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_REL_SYMDISC),
2041                             conv_reloc_type(ifl->ifl_ehdr->e_machine,
2042                             reld->rel_rtype, 0, &inv_buf), ifl->ifl_name,
2043                             EC_WORD(isp->is_scnndx), isp->is_name,
2044                             ld_reloc_sym_name(reld),
2045                             EC_WORD(sdp->sd_isc->is_scnndx),
2046                             sdp->sd_isc->is_name);
2047                         return (S_ERROR);
2048                 }
2049                 ifl->ifl_oldndx[rsndx] = sdp = nsdp;
2050                 if ((ELF_ST_TYPE(sdp->sd_sym->st_info) == STT_SECTION) &&
2051                     (sdp->sd_isc != NULL) && (sdp->sd_isc->is_name != NULL) &&
2052                     (sdp->sd_isc->is_sym_name == NULL) &&
2053                     (ld_stt_section_sym_name(sdp->sd_isc) == NULL))
2054                         return (S_ERROR);
2055         }
2056 
2057         /*
2058          * If this is a global symbol, determine whether its visibility needs
2059          * adjusting.
2060          */
2061         if (sdp->sd_aux && ((sdp->sd_flags & FLG_SY_VISIBLE) == 0))
2062                 ld_sym_adjust_vis(sdp, ofl);
2063 
2064         /*
2065          * Ignore any relocation against a section that will not be in the
2066          * output file (has been stripped).
2067          */
2068         if ((sdp->sd_isc == 0) &&
2069             (ELF_ST_TYPE(sdp->sd_sym->st_info) == STT_SECTION))
2070                 return (1);
2071 
2072         /*
2073          * If the input section exists, but the section has not been associated
2074          * to an output section, then this is a little suspicious.
2075          */
2076         if (sdp->sd_isc && (sdp->sd_isc->is_osdesc == 0) &&
2077             (ELF_ST_TYPE(sdp->sd_sym->st_info) == STT_SECTION)) {
2078                 ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_RELINVSEC),
2079                     conv_reloc_type(ifl->ifl_ehdr->e_machine, rtype,
2080                     0, &inv_buf), ifl->ifl_name, EC_WORD(isp->is_scnndx),
2081                     isp->is_name, EC_WORD(sdp->sd_isc->is_scnndx),
2082                     sdp->sd_isc->is_name);
2083                 return (1);
2084         }
2085 
2086         /*
2087          * If the symbol for this relocation is invalid (which should have
2088          * generated a message during symbol processing), or the relocation
2089          * record's symbol reference is in any other way invalid, then it's
2090          * about time we gave up.
2091          */
2092         if ((sdp->sd_flags & FLG_SY_INVALID) || (rsndx == 0) ||
2093             (rsndx >= ifl->ifl_symscnt)) {
2094                 ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_REL_UNKNWSYM),
2095                     conv_reloc_type(ifl->ifl_ehdr->e_machine, rtype,
2096                     0, &inv_buf), ifl->ifl_name, EC_WORD(isp->is_scnndx),
2097                     isp->is_name, ld_reloc_sym_name(reld),
2098                     EC_XWORD(reloc->r_offset), EC_WORD(rsndx));
2099                 return (S_ERROR);
2100         }
2101 
2102         /*
2103          * Size relocations against section symbols are presently unsupported.
2104          * There is a question as to whether the input section size, or output
2105          * section size would be used.  Until an explicit requirement is
2106          * established for either case, we'll punt.
2107          */
2108         if (IS_SIZE(rtype) &&
2109             (ELF_ST_TYPE(sdp->sd_sym->st_info) == STT_SECTION)) {
2110                 ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_REL_UNSUPSIZE),
2111                     conv_reloc_type(ifl->ifl_ehdr->e_machine, rtype,
2112                     0, &inv_buf), ifl->ifl_name, EC_WORD(isp->is_scnndx),
2113                     isp->is_name);
2114                 return (S_ERROR);
2115         }
2116 
2117         reld->rel_sym = sdp;
2118         if (reld->rel_aux)
2119                 reld->rel_aux->ra_usym = sdp;
2120         return (ld_process_sym_reloc(ofl, reld, reloc, isp, isp->is_name,
2121             isp->is_scnndx));
2122 }
2123 
2124 static uintptr_t
2125 reloc_section(Ofl_desc *ofl, Is_desc *isect, Is_desc *rsect, Os_desc *osect)
2126 {
2127         Rel             *rend;          /* end of relocation section data */
2128         Rel             *reloc;         /* current relocation entry */
2129         Xword           rsize;          /* size of relocation section data */
2130         Xword           entsize;        /* size of relocation entry */
2131         Rel_desc        reld;           /* relocation descriptor */
2132         Rel_aux rel_aux;
2133         Shdr *          shdr;
2134         Word            flags = 0;
2135         uintptr_t       ret = 1;
2136 
2137         shdr = rsect->is_shdr;
2138         rsize = shdr->sh_size;
2139         reloc = (Rel *)rsect->is_indata->d_buf;
2140 
2141         /*
2142          * Decide entry size.
2143          */
2144         if (((entsize = shdr->sh_entsize) == 0) || (entsize > rsize)) {
2145                 if (shdr->sh_type == SHT_RELA)
2146                         entsize = sizeof (Rela);
2147                 else
2148                         entsize = sizeof (Rel);
2149         }
2150 
2151         /*
2152          * Build up the basic information in for the Rel_desc structure.
2153          */
2154         reld.rel_isdesc = isect;
2155         reld.rel_aux = &rel_aux;
2156         ld_init_rel_aux(&reld);
2157         rel_aux.ra_osdesc = osect;
2158 
2159         if ((ofl->ofl_flags & FLG_OF_RELOBJ) ||
2160             (osect && (osect->os_sgdesc->sg_phdr.p_type == PT_LOAD)))
2161                 flags |= FLG_REL_LOAD;
2162 
2163         if (shdr->sh_info == 0)
2164                 flags |= FLG_REL_NOINFO;
2165 
2166         DBG_CALL(Dbg_reloc_proc(ofl->ofl_lml, osect, isect, rsect));
2167 
2168         for (rend = (Rel *)((uintptr_t)reloc + (uintptr_t)rsize);
2169             reloc < rend;
2170             reloc = (Rel *)((uintptr_t)reloc + (uintptr_t)entsize)) {
2171                 Word    rsndx;
2172 
2173                 /*
2174                  * Initialize the relocation record information and process
2175                  * the individual relocation.  Reinitialize the flags to
2176                  * insure we don't carry any state over from the previous
2177                  * relocation records processing.
2178                  */
2179                 reld.rel_flags = flags;
2180                 rsndx = (*ld_targ.t_mr.mr_init_rel)(&reld,
2181                     &rel_aux.ra_typedata, (void *)reloc);
2182 
2183                 /*
2184                  * Determine whether or not to pass an auxiliary block
2185                  * in with this Rel_desc. It is not needed if both the
2186                  * osdesc and typedata fields have default values.
2187                  */
2188                 reld.rel_aux =
2189                     (RELAUX_ISDEFAULT_OSDESC(&reld, rel_aux.ra_osdesc) &&
2190                     RELAUX_ISDEFAULT_TYPEDATA(&reld, rel_aux.ra_typedata)) ?
2191                     NULL : &rel_aux;
2192 
2193                 if (process_reld(ofl, rsect, &reld, rsndx, reloc) == S_ERROR)
2194                         ret = S_ERROR;
2195         }
2196         return (ret);
2197 }
2198 
2199 static uintptr_t
2200 reloc_segments(int wr_flag, Ofl_desc *ofl)
2201 {
2202         Aliste          idx1;
2203         Sg_desc         *sgp;
2204         Is_desc         *isp;
2205 
2206         for (APLIST_TRAVERSE(ofl->ofl_segs, idx1, sgp)) {
2207                 Os_desc *osp;
2208                 Aliste  idx2;
2209 
2210                 if ((sgp->sg_phdr.p_flags & PF_W) != wr_flag)
2211                         continue;
2212 
2213                 for (APLIST_TRAVERSE(sgp->sg_osdescs, idx2, osp)) {
2214                         Is_desc *risp;
2215                         Aliste  idx3;
2216 
2217                         osp->os_szoutrels = 0;
2218                         for (APLIST_TRAVERSE(osp->os_relisdescs, idx3, risp)) {
2219                                 Word    indx;
2220 
2221                                 /*
2222                                  * Determine the input section that this
2223                                  * relocation information refers to.
2224                                  */
2225                                 indx = risp->is_shdr->sh_info;
2226                                 isp = risp->is_file->ifl_isdesc[indx];
2227 
2228                                 /*
2229                                  * Do not process relocations against sections
2230                                  * which are being discarded (COMDAT)
2231                                  */
2232                                 if (isp->is_flags & FLG_IS_DISCARD)
2233                                         continue;
2234 
2235                                 if (reloc_section(ofl, isp, risp, osp) ==
2236                                     S_ERROR)
2237                                         return (S_ERROR);
2238                         }
2239 
2240                         /*
2241                          * Check for relocations against non-writable
2242                          * allocatable sections.
2243                          */
2244                         if (osp->os_szoutrels &&
2245                             (sgp->sg_phdr.p_type == PT_LOAD) &&
2246                             ((sgp->sg_phdr.p_flags & PF_W) == 0)) {
2247                                 ofl->ofl_flags |= FLG_OF_TEXTREL;
2248                                 ofl->ofl_dtflags |= DF_TEXTREL;
2249                         }
2250                 }
2251         }
2252 
2253         return (1);
2254 }
2255 
2256 /*
2257  * Move Section related function
2258  * Get move entry
2259  */
2260 static Move *
2261 get_move_entry(Is_desc *rsect, Xword roffset)
2262 {
2263         Ifl_desc        *ifile = rsect->is_file;
2264         Shdr            *rshdr = rsect->is_shdr;
2265         Is_desc         *misp;
2266         Shdr            *mshdr;
2267         Xword           midx;
2268         Move            *mvp;
2269 
2270         /*
2271          * Set info for the target move section
2272          */
2273         misp = ifile->ifl_isdesc[rshdr->sh_info];
2274         mshdr = misp->is_shdr;
2275 
2276         if (mshdr->sh_entsize == 0)
2277                 return (NULL);
2278 
2279         /*
2280          * If this is an invalid entry, return NULL.
2281          */
2282         midx = roffset / mshdr->sh_entsize;
2283         if ((midx * mshdr->sh_entsize) >= mshdr->sh_size)
2284                 return (NULL);
2285 
2286         mvp = (Move *)misp->is_indata->d_buf;
2287         mvp += midx;
2288         return (mvp);
2289 }
2290 
2291 /*
2292  * Relocation against Move Table.
2293  */
2294 static uintptr_t
2295 process_movereloc(Ofl_desc *ofl, Is_desc *rsect)
2296 {
2297         Ifl_desc        *file = rsect->is_file;
2298         Rel             *rend, *reloc;
2299         Xword           rsize, entsize;
2300         Rel_desc        reld;
2301         Rel_aux rel_aux;
2302 
2303         rsize = rsect->is_shdr->sh_size;
2304         reloc = (Rel *)rsect->is_indata->d_buf;
2305 
2306         /*
2307          * Decide entry size.
2308          */
2309         entsize = rsect->is_shdr->sh_entsize;
2310         if ((entsize == 0) ||
2311             (entsize > rsect->is_shdr->sh_size)) {
2312                 if (rsect->is_shdr->sh_type == SHT_RELA)
2313                         entsize = sizeof (Rela);
2314                 else
2315                         entsize = sizeof (Rel);
2316         }
2317 
2318         /*
2319          * The requirement for move data ensures that we have to supply a
2320          * Rel_aux auxiliary block.
2321          */
2322         reld.rel_aux = &rel_aux;
2323         ld_init_rel_aux(&reld);
2324 
2325         /*
2326          * Go through the relocation entries.
2327          */
2328         for (rend = (Rel *)((uintptr_t)reloc + (uintptr_t)rsize);
2329             reloc < rend;
2330             reloc = (Rel *)((uintptr_t)reloc + (uintptr_t)entsize)) {
2331                 Sym_desc        *psdp;
2332                 Move            *mvp;
2333                 Word            rsndx;
2334 
2335                 /*
2336                  * Initialize the relocation record information.
2337                  */
2338                 reld.rel_flags = FLG_REL_LOAD;
2339                 rsndx = (*ld_targ.t_mr.mr_init_rel)(&reld,
2340                     &rel_aux.ra_typedata, (void *)reloc);
2341 
2342                 if (((mvp = get_move_entry(rsect, reloc->r_offset)) == NULL) ||
2343                     ((rel_aux.ra_move =
2344                     libld_malloc(sizeof (Mv_reloc))) == NULL))
2345                         return (S_ERROR);
2346 
2347                 psdp = file->ifl_oldndx[ELF_M_SYM(mvp->m_info)];
2348                 rel_aux.ra_move->mr_move = mvp;
2349                 rel_aux.ra_move->mr_sym = psdp;
2350 
2351                 if (psdp->sd_flags & FLG_SY_PAREXPN) {
2352                         int     _num, num = mvp->m_repeat;
2353 
2354                         rel_aux.ra_osdesc = ofl->ofl_isparexpn->is_osdesc;
2355                         reld.rel_isdesc = ofl->ofl_isparexpn;
2356                         reld.rel_roffset = mvp->m_poffset;
2357 
2358                         for (_num = 0; _num < num; _num++) {
2359                                 reld.rel_roffset +=
2360                                     /* LINTED */
2361                                     (_num * ELF_M_SIZE(mvp->m_info));
2362 
2363                                 /*
2364                                  * Generate Reld
2365                                  */
2366                                 if (process_reld(ofl,
2367                                     rsect, &reld, rsndx, reloc) == S_ERROR)
2368                                         return (S_ERROR);
2369                         }
2370                 } else {
2371                         /*
2372                          * Generate Reld
2373                          */
2374                         reld.rel_flags |= FLG_REL_MOVETAB;
2375                         rel_aux.ra_osdesc = ofl->ofl_osmove;
2376                         reld.rel_isdesc = ld_os_first_isdesc(ofl->ofl_osmove);
2377 
2378                         if (process_reld(ofl,
2379                             rsect, &reld, rsndx, reloc) == S_ERROR)
2380                                 return (S_ERROR);
2381                 }
2382         }
2383         return (1);
2384 }
2385 
2386 /*
2387  * This function is similar to reloc_init().
2388  *
2389  * This function is called when the SHT_SUNW_move table is expanded and there
2390  * are relocations against the SHT_SUNW_move section.
2391  */
2392 static uintptr_t
2393 reloc_movesections(Ofl_desc *ofl)
2394 {
2395         Aliste          idx;
2396         Is_desc         *risp;
2397         uintptr_t       ret = 1;
2398 
2399         /*
2400          * Generate/Expand relocation entries
2401          */
2402         for (APLIST_TRAVERSE(ofl->ofl_ismoverel, idx, risp)) {
2403                 if (process_movereloc(ofl, risp) == S_ERROR)
2404                         ret = S_ERROR;
2405         }
2406 
2407         return (ret);
2408 }
2409 
2410 /*
2411  * Count the number of output relocation entries, global offset table entries,
2412  * and procedure linkage table entries.  This function searches the segment and
2413  * outsect lists and passes each input reloc section to process_reloc().
2414  * It allocates space for any output relocations needed.  And builds up
2415  * the relocation structures for later processing.
2416  */
2417 uintptr_t
2418 ld_reloc_init(Ofl_desc *ofl)
2419 {
2420         Aliste          idx;
2421         Is_desc         *isp;
2422         Sym_desc        *sdp;
2423 
2424         DBG_CALL(Dbg_basic_collect(ofl->ofl_lml));
2425 
2426         /*
2427          * At this point we have finished processing all input symbols.  Make
2428          * sure we add any absolute (internal) symbols before continuing with
2429          * any relocation processing.
2430          */
2431         if (ld_sym_spec(ofl) == S_ERROR)
2432                 return (S_ERROR);
2433 
2434         ofl->ofl_gotcnt = ld_targ.t_m.m_got_xnumber;
2435 
2436         /*
2437          * Process all of the relocations against NON-writable segments
2438          * followed by relocations against the writable segments.
2439          *
2440          * This separation is so that when the writable segments are processed
2441          * we know whether or not a COPYRELOC will be produced for any symbols.
2442          * If relocations aren't processed in this order, a COPYRELOC and a
2443          * regular relocation can be produced against the same symbol.  The
2444          * regular relocation would be redundant.
2445          */
2446         if (reloc_segments(0, ofl) == S_ERROR)
2447                 return (S_ERROR);
2448 
2449         if (reloc_segments(PF_W, ofl) == S_ERROR)
2450                 return (S_ERROR);
2451 
2452         /*
2453          * Process any extra relocations.  These are relocation sections that
2454          * have a NULL sh_info.
2455          */
2456         for (APLIST_TRAVERSE(ofl->ofl_extrarels, idx, isp)) {
2457                 if (reloc_section(ofl, NULL, isp, NULL) == S_ERROR)
2458                         return (S_ERROR);
2459         }
2460 
2461         /*
2462          * If there were relocation against move table,
2463          * process the relocation sections.
2464          */
2465         if (reloc_movesections(ofl) == S_ERROR)
2466                 return (S_ERROR);
2467 
2468         /*
2469          * Now all the relocations are pre-processed,
2470          * check the validity of copy relocations.
2471          */
2472         if (ofl->ofl_copyrels) {
2473                 Copy_rel        *crp;
2474 
2475                 for (ALIST_TRAVERSE(ofl->ofl_copyrels, idx, crp)) {
2476                         /*
2477                          * If there were no displacement relocation
2478                          * in this file, don't worry about it.
2479                          */
2480                         if (crp->c_sdp->sd_file->ifl_flags &
2481                             (FLG_IF_DISPPEND | FLG_IF_DISPDONE))
2482                                 is_disp_copied(ofl, crp);
2483                 }
2484         }
2485 
2486         /*
2487          * GOT sections are created for dynamic executables and shared objects
2488          * if the FLG_OF_BLDGOT is set, or explicit reference has been made to
2489          * a GOT symbol.
2490          */
2491         if (((ofl->ofl_flags & FLG_OF_RELOBJ) == 0) &&
2492             ((ofl->ofl_flags & FLG_OF_BLDGOT) ||
2493             ((((sdp = ld_sym_find(MSG_ORIG(MSG_SYM_GOFTBL),
2494             SYM_NOHASH, NULL, ofl)) != NULL) ||
2495             ((sdp = ld_sym_find(MSG_ORIG(MSG_SYM_GOFTBL_U),
2496             SYM_NOHASH, NULL, ofl)) != NULL)) &&
2497             (sdp->sd_ref != REF_DYN_SEEN)))) {
2498                 if (ld_make_got(ofl) == S_ERROR)
2499                         return (S_ERROR);
2500 
2501                 /* Allocate the GOT if required by target */
2502                 if ((ld_targ.t_mr.mr_allocate_got != NULL) &&
2503                     ((*ld_targ.t_mr.mr_allocate_got)(ofl) == S_ERROR))
2504                         return (S_ERROR);
2505         }
2506 
2507         return (1);
2508 }
2509 
2510 /*
2511  * Simple comparison routine to be used by qsort() for
2512  * the sorting of the output relocation list.
2513  *
2514  * The reloc_compare() routine results in a relocation
2515  * table which is located on:
2516  *
2517  *      file referenced (NEEDED NDX)
2518  *      referenced symbol
2519  *      relocation offset
2520  *
2521  * This provides the most efficient traversal of the relocation
2522  * table at run-time.
2523  */
2524 static int
2525 reloc_compare(Reloc_list *i, Reloc_list *j)
2526 {
2527 
2528         /*
2529          * first - sort on neededndx
2530          */
2531         if (i->rl_key1 > j->rl_key1)
2532                 return (1);
2533         if (i->rl_key1 < j->rl_key1)
2534                 return (-1);
2535 
2536         /*
2537          * Then sort on symbol
2538          */
2539         if ((uintptr_t)i->rl_key2 > (uintptr_t)j->rl_key2)
2540                 return (1);
2541         if ((uintptr_t)i->rl_key2 < (uintptr_t)j->rl_key2)
2542                 return (-1);
2543 
2544         /*
2545          * i->key2 == j->key2
2546          *
2547          * At this point we fall back to key2 (offsets) to
2548          * sort the output relocations.  Ideally this will
2549          * make for the most efficient processing of these
2550          * relocations at run-time.
2551          */
2552         if (i->rl_key3 > j->rl_key3)
2553                 return (1);
2554         if (i->rl_key3 < j->rl_key3)
2555                 return (-1);
2556         return (0);
2557 }
2558 
2559 static uintptr_t
2560 do_sorted_outrelocs(Ofl_desc *ofl)
2561 {
2562         Rel_desc        *orsp;
2563         Rel_cachebuf    *rcbp;
2564         Aliste          idx;
2565         Reloc_list      *sorted_list;
2566         Word            index = 0;
2567         int             debug = 0;
2568         uintptr_t       error = 1;
2569         Boolean         remain_seen = FALSE;
2570 
2571         if ((sorted_list = libld_malloc((size_t)(sizeof (Reloc_list) *
2572             ofl->ofl_reloccnt))) == NULL)
2573                 return (S_ERROR);
2574 
2575         /*
2576          * All but the PLT output relocations are sorted in the output file
2577          * based upon their sym_desc.  By doing this multiple relocations
2578          * against the same symbol are grouped together, thus when the object
2579          * is later relocated by ld.so.1 it will take advantage of the symbol
2580          * cache that ld.so.1 has.  This can significantly reduce the runtime
2581          * relocation cost of a dynamic object.
2582          *
2583          * PLT relocations are not sorted because the order of the PLT
2584          * relocations is used by ld.so.1 to determine what symbol a PLT
2585          * relocation is against.
2586          */
2587         REL_CACHE_TRAVERSE(&ofl->ofl_outrels, idx, rcbp, orsp) {
2588                 if (debug == 0) {
2589                         DBG_CALL(Dbg_reloc_dooutrel(ofl->ofl_lml,
2590                             ld_targ.t_m.m_rel_sht_type));
2591                         debug = 1;
2592                 }
2593 
2594                 /*
2595                  * If it's a PLT relocation we output it now in the
2596                  * order that it was originally processed.
2597                  */
2598                 if (orsp->rel_flags & FLG_REL_PLT) {
2599                         if ((*ld_targ.t_mr.mr_perform_outreloc)
2600                             (orsp, ofl, &remain_seen) == S_ERROR)
2601                                 error = S_ERROR;
2602                         continue;
2603                 }
2604 
2605                 if ((orsp->rel_rtype == ld_targ.t_m.m_r_relative) ||
2606                     (orsp->rel_rtype == ld_targ.t_m.m_r_register)) {
2607                         sorted_list[index].rl_key1 = 0;
2608                         sorted_list[index].rl_key2 =
2609                             /* LINTED */
2610                             (Sym_desc *)(uintptr_t)orsp->rel_rtype;
2611                 } else {
2612                         sorted_list[index].rl_key1 =
2613                             orsp->rel_sym->sd_file->ifl_neededndx;
2614                         sorted_list[index].rl_key2 = orsp->rel_sym;
2615                 }
2616 
2617                 if (orsp->rel_flags & FLG_REL_GOT) {
2618                         sorted_list[index].rl_key3 =
2619                             (*ld_targ.t_mr.mr_calc_got_offset)(orsp, ofl);
2620                 } else {
2621                         if (orsp->rel_rtype == ld_targ.t_m.m_r_register) {
2622                                         sorted_list[index].rl_key3 = 0;
2623                         } else {
2624                                 sorted_list[index].rl_key3 = orsp->rel_roffset +
2625                                     (Xword)_elf_getxoff(orsp->
2626                                     rel_isdesc->is_indata) +
2627                                     orsp->rel_isdesc->is_osdesc->
2628                                     os_shdr->sh_addr;
2629                         }
2630                 }
2631 
2632                 sorted_list[index++].rl_rsp = orsp;
2633         }
2634 
2635         qsort(sorted_list, (size_t)ofl->ofl_reloccnt, sizeof (Reloc_list),
2636             (int (*)(const void *, const void *))reloc_compare);
2637 
2638         /*
2639          * All output relocations have now been sorted, go through
2640          * and process each relocation.
2641          */
2642         for (index = 0; index < ofl->ofl_reloccnt; index++) {
2643                 if ((*ld_targ.t_mr.mr_perform_outreloc)
2644                     (sorted_list[index].rl_rsp, ofl, &remain_seen) == S_ERROR)
2645                         error = S_ERROR;
2646         }
2647 
2648         /* Guidance: Use -z text when building shared objects */
2649         if (remain_seen && OFL_GUIDANCE(ofl, FLG_OFG_NO_TEXT))
2650                 ld_eprintf(ofl, ERR_GUIDANCE, MSG_INTL(MSG_GUIDE_TEXT));
2651 
2652         return (error);
2653 }
2654 
2655 /*
2656  * Process relocations.  Finds every input relocation section for each output
2657  * section and invokes reloc_section() to relocate that section.
2658  */
2659 uintptr_t
2660 ld_reloc_process(Ofl_desc *ofl)
2661 {
2662         Sg_desc         *sgp;
2663         Os_desc         *osp;
2664         Word            ndx = 0;
2665         ofl_flag_t      flags = ofl->ofl_flags;
2666         Shdr            *shdr;
2667 
2668         DBG_CALL(Dbg_basic_relocate(ofl->ofl_lml));
2669 
2670         /*
2671          * Determine the index of the symbol table that will be referenced by
2672          * the relocation entries.
2673          */
2674         if (OFL_ALLOW_DYNSYM(ofl))
2675                 /* LINTED */
2676                 ndx = (Word)elf_ndxscn(ofl->ofl_osdynsym->os_scn);
2677         else if (!(flags & FLG_OF_STRIP) || (flags & FLG_OF_RELOBJ))
2678                 /* LINTED */
2679                 ndx = (Word)elf_ndxscn(ofl->ofl_ossymtab->os_scn);
2680 
2681         /*
2682          * Re-initialize counters. These are used to provide relocation
2683          * offsets within the output buffers.
2684          */
2685         ofl->ofl_relocpltsz = 0;
2686         ofl->ofl_relocgotsz = 0;
2687         ofl->ofl_relocbsssz = 0;
2688 
2689         /*
2690          * Now that the output file is created and symbol update has occurred,
2691          * process the relocations collected in process_reloc().
2692          */
2693         if (do_sorted_outrelocs(ofl) == S_ERROR)
2694                 return (S_ERROR);
2695 
2696         if ((*ld_targ.t_mr.mr_do_activerelocs)(ofl) == S_ERROR)
2697                 return (S_ERROR);
2698 
2699         if ((flags & FLG_OF_COMREL) == 0) {
2700                 Aliste  idx1;
2701 
2702                 /*
2703                  * Process the relocation sections.  For each relocation
2704                  * section generated for the output image update its shdr
2705                  * information to reflect the symbol table it needs (sh_link)
2706                  * and the section to which the relocation must be applied
2707                  * (sh_info).
2708                  */
2709                 for (APLIST_TRAVERSE(ofl->ofl_segs, idx1, sgp)) {
2710                         Os_desc *osp;
2711                         Aliste  idx2;
2712 
2713                         for (APLIST_TRAVERSE(sgp->sg_osdescs, idx2, osp)) {
2714                                 if (osp->os_relosdesc == 0)
2715                                         continue;
2716 
2717                                 shdr = osp->os_relosdesc->os_shdr;
2718                                 shdr->sh_link = ndx;
2719                                 /* LINTED */
2720                                 shdr->sh_info = (Word)elf_ndxscn(osp->os_scn);
2721                         }
2722                 }
2723 
2724                 /*
2725                  * Since the .rel[a] section is not tied to any specific
2726                  * section, we'd not have found it above.
2727                  */
2728                 if ((osp = ofl->ofl_osrel) != NULL) {
2729                         shdr = osp->os_shdr;
2730                         shdr->sh_link = ndx;
2731                         shdr->sh_info = 0;
2732                 }
2733         } else {
2734                 /*
2735                  * We only have two relocation sections here, (PLT's,
2736                  * coalesced) so just hit them directly instead of stepping
2737                  * over the output sections.
2738                  */
2739                 if ((osp = ofl->ofl_osrelhead) != NULL) {
2740                         shdr = osp->os_shdr;
2741                         shdr->sh_link = ndx;
2742                         shdr->sh_info = 0;
2743                 }
2744                 if (((osp = ofl->ofl_osplt) != NULL) && osp->os_relosdesc) {
2745                         shdr = osp->os_relosdesc->os_shdr;
2746                         shdr->sh_link = ndx;
2747                         /* LINTED */
2748                         shdr->sh_info = (Word)elf_ndxscn(osp->os_scn);
2749                 }
2750         }
2751 
2752         /*
2753          * If the -z text option was given, and we have output relocations
2754          * against a non-writable, allocatable section, issue a diagnostic and
2755          * return (the actual entries that caused this error would have been
2756          * output during the relocating section phase).
2757          */
2758         if ((flags & (FLG_OF_PURETXT | FLG_OF_TEXTREL)) ==
2759             (FLG_OF_PURETXT | FLG_OF_TEXTREL)) {
2760                 ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_REL_REMAIN_3));
2761                 return (S_ERROR);
2762         }
2763 
2764         /*
2765          * Finally, initialize the first got entry with the address of the
2766          * .dynamic section (_DYNAMIC).
2767          */
2768         if (flags & FLG_OF_DYNAMIC) {
2769                 if ((*ld_targ.t_mr.mr_fillin_gotplt)(ofl) == S_ERROR)
2770                         return (S_ERROR);
2771         }
2772 
2773         /*
2774          * Now that any GOT information has been written, display the debugging
2775          * information if required.
2776          */
2777         if ((osp = ofl->ofl_osgot) != NULL)
2778                 DBG_CALL(Dbg_got_display(ofl, osp->os_shdr->sh_addr, 1,
2779                     ld_targ.t_m.m_got_xnumber, ld_targ.t_m.m_got_entsize));
2780 
2781         return (1);
2782 }
2783 
2784 /*
2785  * If the -z text option was given, and we have output relocations against a
2786  * non-writable, allocatable section, issue a diagnostic. Print offending
2787  * symbols in tabular form similar to the way undefined symbols are presented.
2788  * Called from reloc_count().  The actual fatal error condition is triggered on
2789  * in reloc_process() above.
2790  *
2791  * Note.  For historic reasons -ztext is not a default option (however all OS
2792  * shared object builds use this option).  It can be argued that this option
2793  * should also be default when generating an a.out (see 1163979).  However, if
2794  * an a.out contains text relocations it is either because the user is creating
2795  * something pretty weird (they've used the -b or -znodefs options), or because
2796  * the library against which they're building wasn't constructed correctly (ie.
2797  * a function has a NOTYPE type, in which case the a.out won't generate an
2798  * associated plt).  In the latter case the builder of the a.out can't do
2799  * anything to fix the error - thus we've chosen not to give the user an error,
2800  * or warning, for this case.
2801  */
2802 void
2803 ld_reloc_remain_entry(Rel_desc *orsp, Os_desc *osp, Ofl_desc *ofl,
2804     Boolean *remain_seen)
2805 {
2806 
2807         /*
2808          * -ztextoff
2809          */
2810         if (ofl->ofl_flags1 & FLG_OF1_TEXTOFF)
2811                 return;
2812 
2813         /*
2814          * Only give relocation errors against loadable read-only segments.
2815          */
2816         if ((orsp->rel_rtype == ld_targ.t_m.m_r_register) || (!osp) ||
2817             (osp->os_sgdesc->sg_phdr.p_type != PT_LOAD) ||
2818             (osp->os_sgdesc->sg_phdr.p_flags & PF_W))
2819                 return;
2820 
2821         /*
2822          * If we are in -ztextwarn mode, it's a silent error if a relocation is
2823          * due to a 'WEAK REFERENCE'.  This is because if the symbol is not
2824          * provided at run-time we will not perform a text-relocation.
2825          */
2826         if (((ofl->ofl_flags & FLG_OF_PURETXT) == 0) &&
2827             (ELF_ST_BIND(orsp->rel_sym->sd_sym->st_info) == STB_WEAK) &&
2828             (orsp->rel_sym->sd_sym->st_shndx == SHN_UNDEF))
2829                 return;
2830 
2831         if (*remain_seen == FALSE) {
2832                 /*
2833                  * If building with '-ztext' then emit a fatal error.  If
2834                  * building a executable then only emit a 'warning'.
2835                  */
2836                 const char *str1 = (ofl->ofl_flags & FLG_OF_PURETXT) ?
2837                     MSG_INTL(MSG_REL_RMN_ITM_11) : MSG_INTL(MSG_REL_RMN_ITM_13);
2838 
2839                 ld_eprintf(ofl, ERR_NONE, MSG_INTL(MSG_REL_REMAIN_FMT_1), str1,
2840                     MSG_INTL(MSG_REL_RMN_ITM_31), MSG_INTL(MSG_REL_RMN_ITM_12),
2841                     MSG_INTL(MSG_REL_RMN_ITM_2), MSG_INTL(MSG_REL_RMN_ITM_32));
2842 
2843                 *remain_seen = TRUE;
2844         }
2845 
2846         ld_eprintf(ofl, ERR_NONE, MSG_INTL(MSG_REL_REMAIN_2),
2847             ld_reloc_sym_name(orsp), EC_OFF(orsp->rel_roffset),
2848             orsp->rel_isdesc->is_file->ifl_name);
2849 }
2850 
2851 /*
2852  * Generic encapsulation for generating a TLS got index.
2853  */
2854 uintptr_t
2855 ld_assign_got_TLS(Boolean local, Rel_desc *rsp, Ofl_desc *ofl, Sym_desc *sdp,
2856     Gotndx *gnp, Gotref gref, Word rflag, Word ortype, Word rtype1, Word rtype2)
2857 {
2858         Word    rflags;
2859 
2860         if ((*ld_targ.t_mr.mr_assign_got_ndx)(&(sdp->sd_GOTndxs), gnp,
2861             gref, ofl, rsp, sdp) == S_ERROR)
2862                 return (S_ERROR);
2863 
2864         rflags = FLG_REL_GOT | rflag;
2865         if (local)
2866                 rflags |= FLG_REL_SCNNDX;
2867         rsp->rel_rtype = rtype1;
2868 
2869         if ((*ld_targ.t_mr.mr_add_outrel)(rflags, rsp, ofl) == S_ERROR)
2870                 return (S_ERROR);
2871 
2872         if (local && (gref == GOT_REF_TLSIE)) {
2873                 /*
2874                  * If this is a local LE TLS symbol, then the symbol won't be
2875                  * available at runtime.  The value of the local symbol will
2876                  * be placed in the associated got entry, and the got
2877                  * relocation is reassigned to a section symbol.
2878                  */
2879                 if (ld_add_actrel(rflags, rsp, ofl) == S_ERROR)
2880                         return (S_ERROR);
2881         }
2882 
2883         if (rtype2) {
2884                 rflags = FLG_REL_GOT | rflag;
2885                 rsp->rel_rtype = rtype2;
2886 
2887                 if (local) {
2888                         if (ld_add_actrel(rflags, rsp, ofl) == S_ERROR)
2889                                 return (S_ERROR);
2890                 } else {
2891                         if ((*ld_targ.t_mr.mr_add_outrel)(rflags, rsp, ofl) ==
2892                             S_ERROR)
2893                                 return (S_ERROR);
2894                 }
2895         }
2896 
2897         rsp->rel_rtype = ortype;
2898 
2899         return (1);
2900 }
2901 
2902 /*
2903  * Move Section related function
2904  */
2905 static void
2906 newroffset_for_move(Sym_desc *sdp, Move *mvp, Xword offset1, Xword *offset2)
2907 {
2908         Mv_desc         *mdp;
2909         Aliste          idx;
2910 
2911         /*
2912          * Search for matching move entry.
2913          */
2914         for (ALIST_TRAVERSE(sdp->sd_move, idx, mdp)) {
2915                 if (mdp->md_move == mvp) {
2916                         /*
2917                          * Update r_offset
2918                          */
2919                         *offset2 = (Xword)((mdp->md_oidx - 1) * sizeof (Move) +
2920                             offset1 % sizeof (Move));
2921                         return;
2922                 }
2923         }
2924 }
2925 
2926 void
2927 ld_adj_movereloc(Ofl_desc *ofl, Rel_desc *arsp)
2928 {
2929         Move            *move = arsp->rel_aux->ra_move->mr_move;
2930         Sym_desc        *psdp = arsp->rel_aux->ra_move->mr_sym;
2931         Xword           newoffset;
2932 
2933         if (arsp->rel_flags & FLG_REL_MOVETAB) {
2934                 /*
2935                  * We are relocating the move table itself.
2936                  */
2937                 newroffset_for_move(psdp, move, arsp->rel_roffset,
2938                     &newoffset);
2939                 DBG_CALL(Dbg_move_adjmovereloc(ofl->ofl_lml, arsp->rel_roffset,
2940                     newoffset, psdp->sd_name));
2941                 arsp->rel_roffset = newoffset;
2942         } else {
2943                 /*
2944                  * We are expanding the partial symbol.  So we are generating
2945                  * the relocation entry relocating the expanded partial symbol.
2946                  */
2947                 arsp->rel_roffset += psdp->sd_sym->st_value -
2948                     ofl->ofl_isparexpn->is_osdesc->os_shdr->sh_addr;
2949                 DBG_CALL(Dbg_move_adjexpandreloc(ofl->ofl_lml,
2950                     arsp->rel_roffset, psdp->sd_name));
2951         }
2952 }
2953 
2954 /*
2955  * Partially Initialized Symbol Handling routines
2956  * For RELA architecture, the second argument is reld->rel_raddend.  For REL
2957  * architecure, the second argument is the value stored at the relocation
2958  * target address.
2959  */
2960 Sym_desc *
2961 ld_am_I_partial(Rel_desc *reld, Xword val)
2962 {
2963         Ifl_desc        *ifile = reld->rel_sym->sd_isc->is_file;
2964         int             nlocs = ifile->ifl_locscnt, i;
2965 
2966         for (i = 1; i < nlocs; i++) {
2967                 Sym             *osym;
2968                 Sym_desc        *symd = ifile->ifl_oldndx[i];
2969 
2970                 if ((osym = symd->sd_osym) == 0)
2971                         continue;
2972                 if ((symd->sd_flags & FLG_SY_PAREXPN) == 0)
2973                         continue;
2974                 if ((osym->st_value <= val) &&
2975                     (osym->st_value + osym->st_size > val))
2976                         return (symd);
2977         }
2978         return (NULL);
2979 }
2980 
2981 /*
2982  * Return True (1) if the code processing the given relocation
2983  * needs to perform byte swapping when accessing the section data.
2984  */
2985 int
2986 ld_swap_reloc_data(Ofl_desc *ofl, Rel_desc *rsp)
2987 {
2988         /*
2989          * In a cross-link situation where the linker host and target
2990          * have opposite byte orders, it can be necessary to swap bytes
2991          * when doing relocation processing. This is indicated by the
2992          * presence of the FLG_OF1_ENCDIFF flag bit. However, swapping
2993          * is only needed for the section types that libelf doesn't
2994          * automatically xlate.
2995          */
2996         if ((ofl->ofl_flags1 & FLG_OF1_ENCDIFF) != 0) {
2997                 switch (RELAUX_GET_OSDESC(rsp)->os_shdr->sh_type) {
2998                 case SHT_PROGBITS:
2999                         return (1);
3000 
3001                 case SHT_SPARC_GOTDATA:
3002                         if (ld_targ.t_m.m_mach ==
3003                             LD_TARG_BYCLASS(EM_SPARC, EM_SPARCV9))
3004                                 return (1);
3005                         break;
3006 
3007                 case SHT_AMD64_UNWIND:
3008                         if (ld_targ.t_m.m_mach == EM_AMD64)
3009                                 return (1);
3010                         break;
3011                 }
3012         }
3013 
3014         /*
3015          * If FLG_OF1_ENCDIFF isn't set, or the section isn't
3016          * progbits (or similar), then no swapping is needed.
3017          */
3018         return (0);
3019 }
3020 
3021 
3022 
3023 /*
3024  * Obtain the current value at the given relocation target.
3025  *
3026  * entry:
3027  *      ofl - Output file descriptor
3028  *      rsp - Relocation record
3029  *      data - Pointer to relocation target
3030  *      value - Address of variable to recieve value
3031  *
3032  * exit:
3033  *      The value of the data at the relocation target has
3034  *      been stored in value.
3035  */
3036 int
3037 ld_reloc_targval_get(Ofl_desc *ofl, Rel_desc *rsp, uchar_t *data, Xword *value)
3038 {
3039         const Rel_entry *rep;
3040 
3041         rep = &ld_targ.t_mr.mr_reloc_table[rsp->rel_rtype];
3042 
3043         switch (rep->re_fsize) {
3044         case 1:
3045                 /* LINTED */
3046                 *value = (Xword) *((uchar_t *)data);
3047                 break;
3048         case 2:
3049                 {
3050                         Half    v;
3051                         uchar_t *v_bytes = (uchar_t *)&v;
3052 
3053                         if (OFL_SWAP_RELOC_DATA(ofl, rsp)) {
3054                                 UL_ASSIGN_BSWAP_HALF(v_bytes, data);
3055                         } else {
3056                                 UL_ASSIGN_HALF(v_bytes, data);
3057                         }
3058                         *value = (Xword) v;
3059                 }
3060                 break;
3061         case 4:
3062                 {
3063                         Word    v;
3064                         uchar_t *v_bytes = (uchar_t *)&v;
3065 
3066                         if (OFL_SWAP_RELOC_DATA(ofl, rsp)) {
3067                                 UL_ASSIGN_BSWAP_WORD(v_bytes, data);
3068                         } else {
3069                                 UL_ASSIGN_WORD(v_bytes, data);
3070                         }
3071                         *value = (Xword) v;
3072                 }
3073                 break;
3074         default:
3075                 {
3076                         Conv_inv_buf_t inv_buf;
3077                         ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_REL_UNSUPSZ),
3078                             conv_reloc_type(ld_targ.t_m.m_mach, rsp->rel_rtype,
3079                             0, &inv_buf), rsp->rel_isdesc->is_file->ifl_name,
3080                             ld_reloc_sym_name(rsp), (int)rep->re_fsize);
3081                 }
3082                 return (0);
3083         }
3084         return (1);
3085 }
3086 
3087 
3088 /*
3089  * Set the value at the given relocation target.
3090  *
3091  * entry:
3092  *      ofl - Output file descriptor
3093  *      rsp - Relocation record
3094  *      data - Pointer to relocation target
3095  *      value - Address of variable to recieve value
3096  *
3097  * exit:
3098  *      The value of the data at the relocation target has
3099  *      been stored in value.
3100  */
3101 int
3102 ld_reloc_targval_set(Ofl_desc *ofl, Rel_desc *rsp, uchar_t *data, Xword value)
3103 {
3104         const Rel_entry *rep;
3105 
3106         rep = &ld_targ.t_mr.mr_reloc_table[rsp->rel_rtype];
3107 
3108         switch (rep->re_fsize) {
3109         case 1:
3110                 /* LINTED */
3111                 *((uchar_t *)data) = (uchar_t)value;
3112                 break;
3113         case 2:
3114                 {
3115                         Half    v = (Half)value;
3116                         uchar_t *v_bytes = (uchar_t *)&v;
3117 
3118                         if (OFL_SWAP_RELOC_DATA(ofl, rsp)) {
3119                                 UL_ASSIGN_BSWAP_HALF(data, v_bytes);
3120                         } else {
3121                                 UL_ASSIGN_HALF(data, v_bytes);
3122                         }
3123                 }
3124                 break;
3125         case 4:
3126                 {
3127                         Word    v = (Word)value;
3128                         uchar_t *v_bytes = (uchar_t *)&v;
3129 
3130                         if (OFL_SWAP_RELOC_DATA(ofl, rsp)) {
3131                                 UL_ASSIGN_BSWAP_WORD(data, v_bytes);
3132                         } else {
3133                                 UL_ASSIGN_WORD(data, v_bytes);
3134                         }
3135                 }
3136                 break;
3137         default:
3138                 {
3139                         Conv_inv_buf_t inv_buf;
3140                         ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_REL_UNSUPSZ),
3141                             conv_reloc_type(ld_targ.t_m.m_mach, rsp->rel_rtype,
3142                             0, &inv_buf), rsp->rel_isdesc->is_file->ifl_name,
3143                             ld_reloc_sym_name(rsp), (int)rep->re_fsize);
3144                 }
3145                 return (0);
3146         }
3147         return (1);
3148 }
3149 
3150 
3151 /*
3152  * Because of the combinations of 32-bit lib providing 64-bit support, and
3153  * visa-versa, the use of krtld's dorelocs can result in differing message
3154  * requirements that make msg.c/msg.h creation and chkmsg "interesting".
3155  * Thus the actual message files contain a couple of entries to satisfy
3156  * each architectures build.  Here we add dummy calls to quieten chkmsg.
3157  *
3158  * chkmsg: MSG_INTL(MSG_REL_NOFIT)
3159  * chkmsg: MSG_INTL(MSG_REL_NONALIGN)
3160  */