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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
  24  * Copyright 2014 Nexenta Systems, Inc.
  25  */
  26 
  27 #include        <string.h>
  28 #include        <stdio.h>
  29 #include        <sys/types.h>
  30 #include        <sgs.h>
  31 #include        <debug.h>
  32 #include        <_libld.h>
  33 #include        <dwarf.h>
  34 #include        <stdlib.h>
  35 
  36 /*
  37  * A EH_FRAME_HDR consists of the following:
  38  *
  39  *      Encoding        Field
  40  *      --------------------------------
  41  *      unsigned byte   version
  42  *      unsigned byte   eh_frame_ptr_enc
  43  *      unsigned byte   fde_count_enc
  44  *      unsigned byte   table_enc
  45  *      encoded         eh_frame_ptr
  46  *      encoded         fde_count
  47  *      [ binary search table ]
  48  *
  49  * The binary search table entries each consists of:
  50  *
  51  *      encoded         initial_func_loc
  52  *      encoded         FDE_address
  53  *
  54  * The entries in the binary search table are sorted
  55  * in a increasing order by the initial location.
  56  *
  57  *
  58  * version
  59  *
  60  *   Version of the .eh_frame_hdr format. This value shall be 1.
  61  *
  62  * eh_frame_ptr_enc
  63  *
  64  *    The encoding format of the eh_frame_ptr field.  For shared
  65  *    libraries the encoding must be
  66  *    DW_EH_PE_sdata4|DW_EH_PE_pcrel or
  67  *    DW_EH_PE_sdata4|DW_EH_PE_datarel.
  68  *
  69  *
  70  * fde_count_enc
  71  *
  72  *    The encoding format of the fde_count field. A value of
  73  *    DW_EH_PE_omit indicates the binary search table is not
  74  *    present.
  75  *
  76  * table_enc
  77  *
  78  *    The encoding format of the entries in the binary search
  79  *    table. A value of DW_EH_PE_omit indicates the binary search
  80  *    table is not present. For shared libraries the encoding
  81  *    must be DW_EH_PE_sdata4|DW_EH_PE_pcrel or
  82  *    DW_EH_PE_sdata4|DW_EH_PE_datarel.
  83  *
  84  *
  85  * eh_frame_ptr
  86  *
  87  *    The encoded value of the pointer to the start of the
  88  *    .eh_frame section.
  89  *
  90  * fde_count
  91  *
  92  *    The encoded value of the count of entries in the binary
  93  *    search table.
  94  *
  95  * binary search table
  96  *
  97  *    A binary search table containing fde_count entries. Each
  98  *    entry of the table consist of two encoded values, the
  99  *    initial location of the function to which an FDE applies,
 100  *    and the address of the FDE. The entries are sorted in an
 101  *    increasing order by the initial location value.
 102  *
 103  */
 104 
 105 
 106 /*
 107  * EH_FRAME sections
 108  * =================
 109  *
 110  * The call frame information needed for unwinding the stack is output in
 111  * an ELF section(s) of type SHT_AMD64_UNWIND (amd64) or SHT_PROGBITS (other).
 112  * In the simplest case there will be one such section per object file and it
 113  * will be named ".eh_frame".  An .eh_frame section consists of one or more
 114  * subsections. Each subsection contains a CIE (Common Information Entry)
 115  * followed by varying number of FDEs (Frame Descriptor Entry). A FDE
 116  * corresponds to an explicit or compiler generated function in a
 117  * compilation unit, all FDEs can access the CIE that begins their
 118  * subsection for data.
 119  *
 120  * If an object file contains C++ template instantiations, there shall be
 121  * a separate CIE immediately preceding each FDE corresponding to an
 122  * instantiation.
 123  *
 124  * Using the preferred encoding specified below, the .eh_frame section can
 125  * be entirely resolved at link time and thus can become part of the
 126  * text segment.
 127  *
 128  * .eh_frame Section Layout
 129  * ------------------------
 130  *
 131  * EH_PE encoding below refers to the pointer encoding as specified in the
 132  * enhanced LSB Chapter 7 for Eh_Frame_Hdr.
 133  *
 134  * Common Information Entry (CIE)
 135  * ------------------------------
 136  * CIE has the following format:
 137  *
 138  *                           Length
 139  *                              in
 140  *     Field                   Byte      Description
 141  *     -----                  ------     -----------
 142  *  1. Length                   4        Length of CIE (not including
 143  *                                       this 4-byte field).
 144  *
 145  *  2. CIE id                   4        Value Zero (0) for .eh_frame
 146  *                                       (used to distinguish CIEs and
 147  *                                       FDEs when scanning the section)
 148  *
 149  *  3. Version                  1        Value One (1)
 150  *
 151  *  4. CIE Augmentation       string     Null-terminated string with legal
 152  *                                       values being "" or 'z' optionally
 153  *                                       followed by single occurrences of
 154  *                                       'P', 'L', or 'R' in any order.
 155  *     String                            The presence of character(s) in the
 156  *                                       string dictates the content of
 157  *                                       field 8, the Augmentation Section.
 158  *                                       Each character has one or two
 159  *                                       associated operands in the AS.
 160  *                                       Operand order depends on
 161  *                                       position in the string ('z' must
 162  *                                       be first).
 163  *
 164  *  5. Code Align Factor      uleb128    To be multiplied with the
 165  *                                       "Advance Location" instructions in
 166  *                                       the Call Frame Instructions
 167  *
 168  *  6. Data Align Factor      sleb128    To be multiplied with all offset
 169  *                                       in the Call Frame Instructions
 170  *
 171  *  7. Ret Address Reg          1        A "virtual" register representation
 172  *                                       of the return address. In Dwarf V2,
 173  *                                       this is a byte, otherwise it is
 174  *                                       uleb128. It is a byte in gcc 3.3.x
 175  *
 176  *  8. Optional CIE           varying    Present if Augmentation String in
 177  *     Augmentation Section              field 4 is not 0.
 178  *
 179  *     z:
 180  *      size               uleb128       Length of the remainder of the
 181  *                                       Augmentation Section
 182  *
 183  *     P:
 184  *      personality_enc    1             Encoding specifier - preferred
 185  *                                       value is a pc-relative, signed
 186  *                                       4-byte
 187  *
 188  *
 189  *        personality routine (encoded)  Encoded pointer to personality
 190  *                                       routine (actually to the PLT
 191  *                                       entry for the personality
 192  *                                       routine)
 193  *     R:
 194  *      code_enc           1          Non-default encoding for the
 195  *                                    code-pointers (FDE members
 196  *                                    "initial_location" and "address_range"
 197  *                                    and the operand for DW_CFA_set_loc)
 198  *                                    - preferred value is pc-relative,
 199  *                                    signed 4-byte.
 200  *     L:
 201  *      lsda_enc           1          FDE augmentation bodies may contain
 202  *                                    LSDA pointers. If so they are
 203  *                                    encoded as specified here -
 204  *                                    preferred value is pc-relative,
 205  *                                    signed 4-byte possibly indirect
 206  *                                    thru a GOT entry.
 207  *
 208  *
 209  *  9. Optional Call Frame varying
 210  *     Instructions
 211  *
 212  * The size of the optional call frame instruction area must be computed
 213  * based on the overall size and the offset reached while scanning the
 214  * preceding fields of the CIE.
 215  *
 216  *
 217  * Frame Descriptor Entry (FDE)
 218  * ----------------------------
 219  * FDE has the following format:
 220  *
 221  *                            Length
 222  *                              in
 223  *     Field                   Byte      Description
 224  *     -----                  ------     -----------
 225  *  1. Length                   4        Length of remainder of this FDE
 226  *
 227  *  2. CIE Pointer              4        Distance from this field to the
 228  *                                       nearest preceding CIE
 229  *                                       (uthe value is subtracted from the
 230  *                                       current address). This value
 231  *                                       can never be zero and thus can
 232  *                                       be used to distinguish CIE's and
 233  *                                       FDE's when scanning the
 234  *                                       .eh_frame section
 235  *
 236  *  3. Initial Location       varying    Reference to the function code
 237  *                                       corresponding to this FDE.
 238  *                                       If 'R' is missing from the CIE
 239  *                                       Augmentation String, the field is an
 240  *                                       8-byte absolute pointer. Otherwise,
 241  *                                       the corresponding EH_PE encoding in the
 242  *                                       CIE Augmentation Section is used to
 243  *                                       interpret the reference.
 244  *
 245  *  4. Address Range          varying    Size of the function code corresponding
 246  *                                       to this FDE.
 247  *                                       If 'R' is missing from the CIE
 248  *                                       Augmentation String, the field is an
 249  *                                       8-byte unsigned number. Otherwise,
 250  *                                       the size is determined by the
 251  *                                       corresponding EH_PE encoding in the
 252  *                                       CIE Augmentation Section (the
 253  *                                       value is always absolute).
 254  *
 255  *  5. Optional FDE           varying    present if CIE augmentation
 256  *     Augmentation Section              string is non-empty.
 257  *
 258  *
 259  *     'z':
 260  *      length             uleb128       length of the remainder of the
 261  *                                       FDE augmentation section
 262  *
 263  *
 264  *     'L' (and length > 0):
 265  *         LSDA               varying    LSDA pointer, encoded in the
 266  *                                       format specified by the
 267  *                                       corresponding operand in the CIE's
 268  *                                       augmentation body.
 269  *
 270  *  6. Optional Call          varying
 271  *     Frame Instructions
 272  *
 273  * The size of the optional call frame instruction area must be computed
 274  * based on the overall size and the offset reached while scanning the
 275  * preceding fields of the FDE.
 276  *
 277  * The overall size of a .eh_frame section is given in the ELF section
 278  * header.  The only way to determine the number of entries is to scan
 279  * the section till the end and count.
 280  *
 281  */
 282 
 283 
 284 
 285 
 286 static uint_t
 287 extract_uint(const uchar_t *data, uint64_t *ndx, int do_swap)
 288 {
 289         uint_t  r;
 290         uchar_t *p = (uchar_t *)&r;
 291 
 292         data += *ndx;
 293         if (do_swap)
 294                 UL_ASSIGN_BSWAP_WORD(p, data);
 295         else
 296                 UL_ASSIGN_WORD(p, data);
 297 
 298         (*ndx) += 4;
 299         return (r);
 300 }
 301 
 302 /*
 303  * Create an unwind header (.eh_frame_hdr) output section.
 304  * The section is created and space reserved, but the data
 305  * is not copied into place. That is done by a later call
 306  * to ld_unwind_populate(), after active relocations have been
 307  * processed.
 308  *
 309  * When GNU linkonce processing is in effect, we can end up in a situation
 310  * where the FDEs related to discarded sections remain in the eh_frame
 311  * section. Ideally, we would remove these dead entries from eh_frame.
 312  * However, that optimization has not yet been implemented. In the current
 313  * implementation, the number of dead FDEs cannot be determined until
 314  * active relocations are processed, and that processing follows the
 315  * call to this function. This means that we are unable to detect dead FDEs
 316  * here, and the section created by this routine is sized for maximum case
 317  * where all FDEs are valid.
 318  */
 319 uintptr_t
 320 ld_unwind_make_hdr(Ofl_desc *ofl)
 321 {
 322         int             bswap = (ofl->ofl_flags1 & FLG_OF1_ENCDIFF) != 0;
 323         Shdr            *shdr;
 324         Elf_Data        *elfdata;
 325         Is_desc         *isp;
 326         size_t          size;
 327         Xword           fde_cnt;
 328         Aliste          idx1;
 329         Os_desc         *osp;
 330 
 331         /*
 332          * we only build a unwind header if we have
 333          * some unwind information in the file.
 334          */
 335         if (ofl->ofl_unwind == NULL)
 336                 return (1);
 337 
 338         /*
 339          * Allocate and initialize the Elf_Data structure.
 340          */
 341         if ((elfdata = libld_calloc(sizeof (Elf_Data), 1)) == NULL)
 342                 return (S_ERROR);
 343         elfdata->d_type = ELF_T_BYTE;
 344         elfdata->d_align = ld_targ.t_m.m_word_align;
 345         elfdata->d_version = ofl->ofl_dehdr->e_version;
 346 
 347         /*
 348          * Allocate and initialize the Shdr structure.
 349          */
 350         if ((shdr = libld_calloc(sizeof (Shdr), 1)) == NULL)
 351                 return (S_ERROR);
 352         shdr->sh_type = ld_targ.t_m.m_sht_unwind;
 353         shdr->sh_flags = SHF_ALLOC;
 354         shdr->sh_addralign = ld_targ.t_m.m_word_align;
 355         shdr->sh_entsize = 0;
 356 
 357         /*
 358          * Allocate and initialize the Is_desc structure.
 359          */
 360         if ((isp = libld_calloc(1, sizeof (Is_desc))) == NULL)
 361                 return (S_ERROR);
 362         isp->is_name = MSG_ORIG(MSG_SCN_UNWINDHDR);
 363         isp->is_shdr = shdr;
 364         isp->is_indata = elfdata;
 365 
 366         if ((ofl->ofl_unwindhdr = ld_place_section(ofl, isp, NULL,
 367             ld_targ.t_id.id_unwindhdr, NULL)) == (Os_desc *)S_ERROR)
 368                 return (S_ERROR);
 369 
 370         /*
 371          * Scan through all of the input Frame information, counting each FDE
 372          * that requires an index.  Each fde_entry gets a corresponding entry
 373          * in the binary search table.
 374          */
 375         fde_cnt = 0;
 376         for (APLIST_TRAVERSE(ofl->ofl_unwind, idx1, osp)) {
 377                 Aliste  idx2;
 378                 int     os_isdescs_idx;
 379 
 380                 OS_ISDESCS_TRAVERSE(os_isdescs_idx, osp, idx2, isp) {
 381                         uchar_t         *data;
 382                         uint64_t        off = 0;
 383 
 384                         data = isp->is_indata->d_buf;
 385                         size = isp->is_indata->d_size;
 386 
 387                         while (off < size) {
 388                                 uint_t          length, id;
 389                                 uint64_t        ndx = 0;
 390 
 391                                 /*
 392                                  * Extract length in lsb format.  A zero length
 393                                  * indicates that this CIE is a terminator and
 394                                  * that processing for unwind information is
 395                                  * complete.
 396                                  */
 397                                 length = extract_uint(data + off, &ndx, bswap);
 398                                 if (length == 0)
 399                                         break;
 400 
 401                                 /*
 402                                  * Extract CIE id in lsb format.
 403                                  */
 404                                 id = extract_uint(data + off, &ndx, bswap);
 405 
 406                                 /*
 407                                  * A CIE record has a id of '0', otherwise
 408                                  * this is a FDE entry and the 'id' is the
 409                                  * CIE pointer.
 410                                  */
 411                                 if (id == 0) {
 412                                         uint_t  cieversion;
 413                                         cieversion = data[off + ndx];
 414                                         ndx += 1;
 415                                         /* BEGIN CSTYLED */
 416                                         if (cieversion != 1 && cieversion != 3) {
 417                                             ld_eprintf(ofl, ERR_FATAL,
 418                                                 MSG_INTL(MSG_UNW_BADCIEVERS),
 419                                                 isp->is_file->ifl_name,
 420                                                 isp->is_name, off);
 421                                             return (S_ERROR);
 422                                         }
 423                                         /* END CSTYLED */
 424                                 } else {
 425                                         fde_cnt++;
 426                                 }
 427                                 off += length + 4;
 428                         }
 429                 }
 430         }
 431 
 432         /*
 433          * section size:
 434          *      byte        version             +1
 435          *      byte        eh_frame_ptr_enc    +1
 436          *      byte        fde_count_enc       +1
 437          *      byte        table_enc           +1
 438          *      4 bytes     eh_frame_ptr        +4
 439          *      4 bytes     fde_count           +4
 440          *      [4 bytes] [4bytes] * fde_count  ...
 441          */
 442         size = 12 + (8 * fde_cnt);
 443 
 444         if ((elfdata->d_buf = libld_calloc(size, 1)) == NULL)
 445                 return (S_ERROR);
 446         elfdata->d_size = size;
 447         shdr->sh_size = (Xword)size;
 448 
 449         return (1);
 450 }
 451 
 452 /*
 453  * the comparator function needs to calculate
 454  * the actual 'initloc' of a bintab entry - to
 455  * do this we initialize the following global to point
 456  * to it.
 457  */
 458 static Addr framehdr_addr;
 459 
 460 static int
 461 bintabcompare(const void *p1, const void *p2)
 462 {
 463         uint_t      *bintab1, *bintab2;
 464         uint_t      ent1, ent2;
 465 
 466         bintab1 = (uint_t *)p1;
 467         bintab2 = (uint_t *)p2;
 468 
 469         assert(bintab1 != 0);
 470         assert(bintab2 != 0);
 471 
 472         ent1 = *bintab1 + framehdr_addr;
 473         ent2 = *bintab2 + framehdr_addr;
 474 
 475         if (ent1 > ent2)
 476                 return (1);
 477         if (ent1 < ent2)
 478                 return (-1);
 479         return (0);
 480 }
 481 
 482 uintptr_t
 483 ld_unwind_populate_hdr(Ofl_desc *ofl)
 484 {
 485         uchar_t         *hdrdata;
 486         uint_t          *binarytable;
 487         uint_t          hdroff;
 488         Aliste          idx;
 489         Addr            hdraddr;
 490         Os_desc         *hdrosp;
 491         Os_desc         *osp;
 492         Os_desc         *first_unwind;
 493         uint_t          fde_count;
 494         uint_t          *uint_ptr;
 495         int             bswap = (ofl->ofl_flags1 & FLG_OF1_ENCDIFF) != 0;
 496 
 497         /*
 498          * Are we building the unwind hdr?
 499          */
 500         if ((hdrosp = ofl->ofl_unwindhdr) == 0)
 501                 return (1);
 502 
 503         hdrdata = hdrosp->os_outdata->d_buf;
 504         hdraddr = hdrosp->os_shdr->sh_addr;
 505         hdroff = 0;
 506 
 507         /*
 508          * version == 1
 509          */
 510         hdrdata[hdroff++] = 1;
 511         /*
 512          * The encodings are:
 513          *
 514          *  eh_frameptr_enc     sdata4 | pcrel
 515          *  fde_count_enc       udata4
 516          *  table_enc           sdata4 | datarel
 517          */
 518         hdrdata[hdroff++] = DW_EH_PE_sdata4 | DW_EH_PE_pcrel;
 519         hdrdata[hdroff++] = DW_EH_PE_udata4;
 520         hdrdata[hdroff++] = DW_EH_PE_sdata4 | DW_EH_PE_datarel;
 521 
 522         /*
 523          *      Header Offsets
 524          *      -----------------------------------
 525          *      byte        version             +1
 526          *      byte        eh_frame_ptr_enc    +1
 527          *      byte        fde_count_enc       +1
 528          *      byte        table_enc           +1
 529          *      4 bytes     eh_frame_ptr        +4
 530          *      4 bytes     fde_count           +4
 531          */
 532         /* LINTED */
 533         binarytable =  (uint_t *)(hdrdata + 12);
 534         first_unwind = 0;
 535         fde_count = 0;
 536 
 537         for (APLIST_TRAVERSE(ofl->ofl_unwind, idx, osp)) {
 538                 uchar_t         *data;
 539                 size_t          size;
 540                 uint64_t        off = 0, ujunk;
 541                 int64_t         sjunk;
 542                 uint_t          cieRflag = 0, ciePflag = 0;
 543                 Shdr            *shdr;
 544 
 545                 /*
 546                  * remember first UNWIND section to
 547                  * point to in the frame_ptr entry.
 548                  */
 549                 if (first_unwind == 0)
 550                         first_unwind = osp;
 551 
 552                 data = osp->os_outdata->d_buf;
 553                 shdr = osp->os_shdr;
 554                 size = shdr->sh_size;
 555 
 556                 while (off < size) {
 557                         uint_t      length, id;
 558                         uint64_t    ndx = 0;
 559 
 560                         /*
 561                          * Extract length in lsb format.  A zero length
 562                          * indicates that this CIE is a terminator and that
 563                          * processing of unwind information is complete.
 564                          */
 565                         length = extract_uint(data + off, &ndx, bswap);
 566                         if (length == 0)
 567                                 goto done;
 568 
 569                         /*
 570                          * Extract CIE id in lsb format.
 571                          */
 572                         id = extract_uint(data + off, &ndx, bswap);
 573 
 574                         /*
 575                          * A CIE record has a id of '0'; otherwise
 576                          * this is a FDE entry and the 'id' is the
 577                          * CIE pointer.
 578                          */
 579                         if (id == 0) {
 580                                 char    *cieaugstr;
 581                                 uint_t  cieaugndx;
 582                                 uint_t  cieversion;
 583 
 584                                 ciePflag = 0;
 585                                 cieRflag = 0;
 586                                 /*
 587                                  * We need to drill through the CIE
 588                                  * to find the Rflag.  It's the Rflag
 589                                  * which describes how the FDE code-pointers
 590                                  * are encoded.
 591                                  */
 592 
 593                                 cieversion = data[off + ndx];
 594                                 ndx += 1;
 595 
 596                                 /*
 597                                  * augstr
 598                                  */
 599                                 cieaugstr = (char *)(&data[off + ndx]);
 600                                 ndx += strlen(cieaugstr) + 1;
 601 
 602                                 /*
 603                                  * calign & dalign
 604                                  */
 605                                 if (uleb_extract(&data[off], &ndx,
 606                                     size - off, &ujunk) == DW_OVERFLOW) {
 607                                         ld_eprintf(ofl, ERR_FATAL,
 608                                             MSG_INTL(MSG_SCN_DWFOVRFLW),
 609                                             ofl->ofl_name,
 610                                             osp->os_name);
 611                                         return (S_ERROR);
 612                                 }
 613 
 614                                 if (sleb_extract(&data[off], &ndx,
 615                                     size - off, &sjunk) == DW_OVERFLOW) {
 616                                         ld_eprintf(ofl, ERR_FATAL,
 617                                             MSG_INTL(MSG_SCN_DWFOVRFLW),
 618                                             ofl->ofl_name,
 619                                             osp->os_name);
 620                                         return (S_ERROR);
 621                                 }
 622 
 623                                 /*
 624                                  * retreg
 625                                  */
 626                                 if (cieversion == 1) {
 627                                         ndx++;
 628                                 } else {
 629                                         if (uleb_extract(&data[off], &ndx,
 630                                             size - off, &ujunk) ==
 631                                             DW_OVERFLOW) {
 632                                                 ld_eprintf(ofl, ERR_FATAL,
 633                                                     MSG_INTL(MSG_SCN_DWFOVRFLW),
 634                                                     ofl->ofl_name,
 635                                                     osp->os_name);
 636                                                 return (S_ERROR);
 637                                         }
 638                                 }
 639                                 /*
 640                                  * we walk through the augmentation
 641                                  * section now looking for the Rflag
 642                                  */
 643                                 for (cieaugndx = 0; cieaugstr[cieaugndx];
 644                                     cieaugndx++) {
 645                                         /* BEGIN CSTYLED */
 646                                         switch (cieaugstr[cieaugndx]) {
 647                                         case 'z':
 648                                             /* size */
 649                                             if (uleb_extract(&data[off],
 650                                                 &ndx, size - off, &ujunk) ==
 651                                                 DW_OVERFLOW) {
 652                                                 ld_eprintf(ofl, ERR_FATAL,
 653                                                     MSG_INTL(MSG_SCN_DWFOVRFLW),
 654                                                     ofl->ofl_name,
 655                                                     osp->os_name);
 656                                                 return (S_ERROR);
 657                                             }
 658                                             break;
 659                                         case 'P':
 660                                             /* personality */
 661                                             ciePflag = data[off + ndx];
 662                                             ndx++;
 663                                                 /*
 664                                                  * Just need to extract the
 665                                                  * value to move on to the next
 666                                                  * field.
 667                                                  */
 668                                             switch (dwarf_ehe_extract(
 669                                                 &data[off], size - off,
 670                                                 &ndx, &ujunk, ciePflag,
 671                                                 ofl->ofl_dehdr->e_ident, B_FALSE,
 672                                                 shdr->sh_addr, off + ndx, 0)) {
 673                                             case DW_OVERFLOW:
 674                                                 ld_eprintf(ofl, ERR_FATAL,
 675                                                     MSG_INTL(MSG_SCN_DWFOVRFLW),
 676                                                     ofl->ofl_name,
 677                                                     osp->os_name);
 678                                                 return (S_ERROR);
 679                                             case DW_BAD_ENCODING:
 680                                                 ld_eprintf(ofl, ERR_FATAL,
 681                                                     MSG_INTL(MSG_SCN_DWFBADENC),
 682                                                     ofl->ofl_name,
 683                                                     osp->os_name, ciePflag);
 684                                                 return (S_ERROR);
 685                                             case DW_SUCCESS:
 686                                                 break;
 687                                             }
 688                                             break;
 689                                         case 'R':
 690                                             /* code encoding */
 691                                             cieRflag = data[off + ndx];
 692                                             ndx++;
 693                                             break;
 694                                         case 'L':
 695                                             /* lsda encoding */
 696                                             ndx++;
 697                                             break;
 698                                         }
 699                                         /* END CSTYLED */
 700                                 }
 701                         } else {
 702                                 uint_t      bintabndx;
 703                                 uint64_t    initloc;
 704                                 uint64_t    fdeaddr;
 705                                 uint64_t    gotaddr = 0;
 706 
 707                                 if (ofl->ofl_osgot != NULL)
 708                                         gotaddr =
 709                                             ofl->ofl_osgot->os_shdr->sh_addr;
 710 
 711                                 switch (dwarf_ehe_extract(&data[off],
 712                                     size - off, &ndx, &initloc, cieRflag,
 713                                     ofl->ofl_dehdr->e_ident, B_FALSE,
 714                                     shdr->sh_addr, off + ndx, gotaddr)) {
 715                                 case DW_OVERFLOW:
 716                                         ld_eprintf(ofl, ERR_FATAL,
 717                                             MSG_INTL(MSG_SCN_DWFOVRFLW),
 718                                             ofl->ofl_name,
 719                                             osp->os_name);
 720                                         return (S_ERROR);
 721                                 case DW_BAD_ENCODING:
 722                                         ld_eprintf(ofl, ERR_FATAL,
 723                                             MSG_INTL(MSG_SCN_DWFBADENC),
 724                                             ofl->ofl_name,
 725                                             osp->os_name, cieRflag);
 726                                         return (S_ERROR);
 727                                 case DW_SUCCESS:
 728                                         break;
 729                                 }
 730 
 731                                 /*
 732                                  * Ignore FDEs with initloc set to 0.
 733                                  * initloc will not be 0 unless this FDE was
 734                                  * abandoned due to GNU linkonce processing.
 735                                  * The 0 value occurs because we don't resolve
 736                                  * sloppy relocations for unwind header target
 737                                  * sections.
 738                                  */
 739                                 if (initloc != 0) {
 740                                         bintabndx = fde_count * 2;
 741                                         fde_count++;
 742 
 743                                         /*
 744                                          * FDEaddr is adjusted
 745                                          * to account for the length & id which
 746                                          * have already been consumed.
 747                                          */
 748                                         fdeaddr = shdr->sh_addr + off;
 749 
 750                                         binarytable[bintabndx] =
 751                                             (uint_t)(initloc - hdraddr);
 752                                         binarytable[bintabndx + 1] =
 753                                             (uint_t)(fdeaddr - hdraddr);
 754                                 }
 755                         }
 756 
 757                         /*
 758                          * the length does not include the length
 759                          * itself - so account for that too.
 760                          */
 761                         off += length + 4;
 762                 }
 763         }
 764 
 765 done:
 766         /*
 767          * Do a quicksort on the binary table. If this is a cross
 768          * link from a system with the opposite byte order, xlate
 769          * the resulting values into LSB order.
 770          */
 771         framehdr_addr = hdraddr;
 772         qsort((void *)binarytable, (size_t)fde_count,
 773             (size_t)(sizeof (uint_t) * 2), bintabcompare);
 774         if (bswap) {
 775                 uint_t  *btable = binarytable;
 776                 uint_t  cnt;
 777 
 778                 for (cnt = fde_count * 2; cnt-- > 0; btable++)
 779                         *btable = ld_bswap_Word(*btable);
 780         }
 781 
 782         /*
 783          * Fill in:
 784          *      first_frame_ptr
 785          *      fde_count
 786          */
 787         hdroff = 4;
 788         /* LINTED */
 789         uint_ptr = (uint_t *)(&hdrdata[hdroff]);
 790         *uint_ptr = first_unwind->os_shdr->sh_addr -
 791             (hdrosp->os_shdr->sh_addr + hdroff);
 792         if (bswap)
 793                 *uint_ptr = ld_bswap_Word(*uint_ptr);
 794 
 795         hdroff += 4;
 796         /* LINTED */
 797         uint_ptr = (uint_t *)&hdrdata[hdroff];
 798         *uint_ptr = fde_count;
 799         if (bswap)
 800                 *uint_ptr = ld_bswap_Word(*uint_ptr);
 801 
 802         /*
 803          * If relaxed relocations are active, then there is a chance
 804          * that we didn't use all the space reserved for this section.
 805          * For details, see the note at head of ld_unwind_make_hdr() above.
 806          *
 807          * Find the PT_SUNW_UNWIND program header, and change the size values
 808          * to the size of the subset of the section that was actually used.
 809          */
 810         if (ofl->ofl_flags1 & FLG_OF1_RLXREL) {
 811                 Word    phnum = ofl->ofl_nehdr->e_phnum;
 812                 Phdr    *phdr = ofl->ofl_phdr;
 813 
 814                 for (; phnum-- > 0; phdr++) {
 815                         if (phdr->p_type == PT_SUNW_UNWIND) {
 816                                 phdr->p_memsz = 12 + (8 * fde_count);
 817                                 phdr->p_filesz = phdr->p_memsz;
 818                                 break;
 819                         }
 820                 }
 821         }
 822 
 823         return (1);
 824 }
 825 
 826 /*
 827  * Append an .eh_frame section to our output list if not already present.
 828  *
 829  * Usually, there is a single .eh_frame output section. However, there can
 830  * be more if there are incompatible section flags on incoming sections.
 831  * If this does happen, the frame_ptr field of the eh_frame_hdr section
 832  * will point at the base of the first output section, and the other
 833  * sections will not be accessible via frame_ptr. However, the .eh_frame_hdr
 834  * will be able to access all the data in the different .eh_frame sections,
 835  * because the entries in sorted table are all encoded as DW_EH_PE_datarel.
 836  */
 837 uintptr_t
 838 ld_unwind_register(Os_desc *osp, Ofl_desc * ofl)
 839 {
 840         Aliste  idx;
 841         Os_desc *_osp;
 842         /*
 843          * Check to see if this output section is already
 844          * on the list.
 845          */
 846         for (APLIST_TRAVERSE(ofl->ofl_unwind, idx, _osp))
 847                 if (osp == _osp)
 848                         return (1);
 849 
 850         /*
 851          * Append output section to unwind list
 852          */
 853         if (aplist_append(&ofl->ofl_unwind, osp, AL_CNT_OFL_UNWIND) == NULL)
 854                 return (S_ERROR);
 855 
 856         return (1);
 857 }