bfd/elf-eh-frame.c

   1 /* .eh_frame section optimization.
   2    Copyright 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
   3    Written by Jakub Jelinek <jakub@redhat.com>.
   4
   5    This file is part of BFD, the Binary File Descriptor library.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
  20
  21 #include "bfd.h"
  22 #include "sysdep.h"
  23 #include "libbfd.h"
  24 #include "elf-bfd.h"
  25 #include "elf/dwarf2.h"
  26
  27 #define EH_FRAME_HDR_SIZE 8
  28
  29 /* If *ITER hasn't reached END yet, read the next byte into *RESULT and
  30    move onto the next byte.  Return true on success.  */
  31
  32 static inline bfd_boolean
  33 read_byte (bfd_byte **iter, bfd_byte *end, unsigned char *result)
  34 {
  35   if (*iter >= end)
  36     return FALSE;
  37   *result = *((*iter)++);
  38   return TRUE;
  39 }
  40
  41 /* Move *ITER over LENGTH bytes, or up to END, whichever is closer.
  42    Return true it was possible to move LENGTH bytes.  */
  43
  44 static inline bfd_boolean
  45 skip_bytes (bfd_byte **iter, bfd_byte *end, bfd_size_type length)
  46 {
  47   if ((bfd_size_type) (end - *iter) < length)
  48     {
  49       *iter = end;
  50       return FALSE;
  51     }
  52   *iter += length;
  53   return TRUE;
  54 }
  55
  56 /* Move *ITER over an leb128, stopping at END.  Return true if the end
  57    of the leb128 was found.  */
  58
  59 static bfd_boolean
  60 skip_leb128 (bfd_byte **iter, bfd_byte *end)
  61 {
  62   unsigned char byte;
  63   do
  64     if (!read_byte (iter, end, &byte))
  65       return FALSE;
  66   while (byte & 0x80);
  67   return TRUE;
  68 }
  69
  70 /* Like skip_leb128, but treat the leb128 as an unsigned value and
  71    store it in *VALUE.  */
  72
  73 static bfd_boolean
  74 read_uleb128 (bfd_byte **iter, bfd_byte *end, bfd_vma *value)
  75 {
  76   bfd_byte *start, *p;
  77
  78   start = *iter;
  79   if (!skip_leb128 (iter, end))
  80     return FALSE;
  81
  82   p = *iter;
  83   *value = *--p;
  84   while (p > start)
  85     *value = (*value << 7) | (*--p & 0x7f);
  86
  87   return TRUE;
  88 }
  89
  90 /* Like read_uleb128, but for signed values.  */
  91
  92 static bfd_boolean
  93 read_sleb128 (bfd_byte **iter, bfd_byte *end, bfd_signed_vma *value)
  94 {
  95   bfd_byte *start, *p;
  96
  97   start = *iter;
  98   if (!skip_leb128 (iter, end))
  99     return FALSE;
 100
 101   p = *iter;
 102   *value = ((*--p & 0x7f) ^ 0x40) - 0x40;
 103   while (p > start)
 104     *value = (*value << 7) | (*--p & 0x7f);
 105
 106   return TRUE;
 107 }
 108
 109 /* Return 0 if either encoding is variable width, or not yet known to bfd.  */
 110
 111 static
 112 int get_DW_EH_PE_width (int encoding, int ptr_size)
 113 {
 114   /* DW_EH_PE_ values of 0x60 and 0x70 weren't defined at the time .eh_frame
 115      was added to bfd.  */
 116   if ((encoding & 0x60) == 0x60)
 117     return 0;
 118
 119   switch (encoding & 7)
 120     {
 121     case DW_EH_PE_udata2: return 2;
 122     case DW_EH_PE_udata4: return 4;
 123     case DW_EH_PE_udata8: return 8;
 124     case DW_EH_PE_absptr: return ptr_size;
 125     default:
 126       break;
 127     }
 128
 129   return 0;
 130 }
 131
 132 #define get_DW_EH_PE_signed(encoding) (((encoding) & DW_EH_PE_signed) != 0)
 133
 134 /* Read a width sized value from memory.  */
 135
 136 static bfd_vma
 137 read_value (bfd *abfd, bfd_byte *buf, int width, int is_signed)
 138 {
 139   bfd_vma value;
 140
 141   switch (width)
 142     {
 143     case 2:
 144       if (is_signed)
 145         value = bfd_get_signed_16 (abfd, buf);
 146       else
 147         value = bfd_get_16 (abfd, buf);
 148       break;
 149     case 4:
 150       if (is_signed)
 151         value = bfd_get_signed_32 (abfd, buf);
 152       else
 153         value = bfd_get_32 (abfd, buf);
 154       break;
 155     case 8:
 156       if (is_signed)
 157         value = bfd_get_signed_64 (abfd, buf);
 158       else
 159         value = bfd_get_64 (abfd, buf);
 160       break;
 161     default:
 162       BFD_FAIL ();
 163       return 0;
 164     }
 165
 166   return value;
 167 }
 168
 169 /* Store a width sized value to memory.  */
 170
 171 static void
 172 write_value (bfd *abfd, bfd_byte *buf, bfd_vma value, int width)
 173 {
 174   switch (width)
 175     {
 176     case 2: bfd_put_16 (abfd, value, buf); break;
 177     case 4: bfd_put_32 (abfd, value, buf); break;
 178     case 8: bfd_put_64 (abfd, value, buf); break;
 179     default: BFD_FAIL ();
 180     }
 181 }
 182
 183 /* Return zero if C1 and C2 CIEs can be merged.  */
 184
 185 static
 186 int cie_compare (struct cie *c1, struct cie *c2)
 187 {
 188   if (c1->hdr.length == c2->hdr.length
 189       && c1->version == c2->version
 190       && strcmp (c1->augmentation, c2->augmentation) == 0
 191       && strcmp (c1->augmentation, "eh") != 0
 192       && c1->code_align == c2->code_align
 193       && c1->data_align == c2->data_align
 194       && c1->ra_column == c2->ra_column
 195       && c1->augmentation_size == c2->augmentation_size
 196       && c1->personality == c2->personality
 197       && c1->per_encoding == c2->per_encoding
 198       && c1->lsda_encoding == c2->lsda_encoding
 199       && c1->fde_encoding == c2->fde_encoding
 200       && c1->initial_insn_length == c2->initial_insn_length
 201       && memcmp (c1->initial_instructions,
 202                  c2->initial_instructions,
 203                  c1->initial_insn_length) == 0)
 204     return 0;
 205
 206   return 1;
 207 }
 208
 209 /* Return the number of extra bytes that we'll be inserting into
 210    ENTRY's augmentation string.  */
 211
 212 static INLINE unsigned int
 213 extra_augmentation_string_bytes (struct eh_cie_fde *entry)
 214 {
 215   unsigned int size = 0;
 216   if (entry->cie)
 217     {
 218       if (entry->add_augmentation_size)
 219         size++;
 220       if (entry->add_fde_encoding)
 221         size++;
 222     }
 223   return size;
 224 }
 225
 226 /* Likewise ENTRY's augmentation data.  */
 227
 228 static INLINE unsigned int
 229 extra_augmentation_data_bytes (struct eh_cie_fde *entry)
 230 {
 231   unsigned int size = 0;
 232   if (entry->cie)
 233     {
 234       if (entry->add_augmentation_size)
 235         size++;
 236       if (entry->add_fde_encoding)
 237         size++;
 238     }
 239   else
 240     {
 241       if (entry->cie_inf->add_augmentation_size)
 242         size++;
 243     }
 244   return size;
 245 }
 246
 247 /* Return the size that ENTRY will have in the output.  ALIGNMENT is the
 248    required alignment of ENTRY in bytes.  */
 249
 250 static unsigned int
 251 size_of_output_cie_fde (struct eh_cie_fde *entry, unsigned int alignment)
 252 {
 253   if (entry->removed)
 254     return 0;
 255   if (entry->size == 4)
 256     return 4;
 257   return (entry->size
 258           + extra_augmentation_string_bytes (entry)
 259           + extra_augmentation_data_bytes (entry)
 260           + alignment - 1) & -alignment;
 261 }
 262
 263 /* Assume that the bytes between *ITER and END are CFA instructions.
 264    Try to move *ITER past the first instruction and return true on
 265    success.  ENCODED_PTR_WIDTH gives the width of pointer entries.  */
 266
 267 static bfd_boolean
 268 skip_cfa_op (bfd_byte **iter, bfd_byte *end, unsigned int encoded_ptr_width)
 269 {
 270   bfd_byte op;
 271   bfd_vma length;
 272
 273   if (!read_byte (iter, end, &op))
 274     return FALSE;
 275
 276   switch (op & 0xc0 ? op & 0xc0 : op)
 277     {
 278     case DW_CFA_nop:
 279     case DW_CFA_advance_loc:
 280     case DW_CFA_restore:
 281     case DW_CFA_remember_state:
 282     case DW_CFA_restore_state:
 283     case DW_CFA_GNU_window_save:
 284       /* No arguments.  */
 285       return TRUE;
 286
 287     case DW_CFA_offset:
 288     case DW_CFA_restore_extended:
 289     case DW_CFA_undefined:
 290     case DW_CFA_same_value:
 291     case DW_CFA_def_cfa_register:
 292     case DW_CFA_def_cfa_offset:
 293     case DW_CFA_def_cfa_offset_sf:
 294     case DW_CFA_GNU_args_size:
 295       /* One leb128 argument.  */
 296       return skip_leb128 (iter, end);
 297
 298     case DW_CFA_val_offset:
 299     case DW_CFA_val_offset_sf:
 300     case DW_CFA_offset_extended:
 301     case DW_CFA_register:
 302     case DW_CFA_def_cfa:
 303     case DW_CFA_offset_extended_sf:
 304     case DW_CFA_GNU_negative_offset_extended:
 305     case DW_CFA_def_cfa_sf:
 306       /* Two leb128 arguments.  */
 307       return (skip_leb128 (iter, end)
 308               && skip_leb128 (iter, end));
 309
 310     case DW_CFA_def_cfa_expression:
 311       /* A variable-length argument.  */
 312       return (read_uleb128 (iter, end, &length)
 313               && skip_bytes (iter, end, length));
 314
 315     case DW_CFA_expression:
 316     case DW_CFA_val_expression:
 317       /* A leb128 followed by a variable-length argument.  */
 318       return (skip_leb128 (iter, end)
 319               && read_uleb128 (iter, end, &length)
 320               && skip_bytes (iter, end, length));
 321
 322     case DW_CFA_set_loc:
 323       return skip_bytes (iter, end, encoded_ptr_width);
 324
 325     case DW_CFA_advance_loc1:
 326       return skip_bytes (iter, end, 1);
 327
 328     case DW_CFA_advance_loc2:
 329       return skip_bytes (iter, end, 2);
 330
 331     case DW_CFA_advance_loc4:
 332       return skip_bytes (iter, end, 4);
 333
 334     case DW_CFA_MIPS_advance_loc8:
 335       return skip_bytes (iter, end, 8);
 336
 337     default:
 338       return FALSE;
 339     }
 340 }
 341
 342 /* Try to interpret the bytes between BUF and END as CFA instructions.
 343    If every byte makes sense, return a pointer to the first DW_CFA_nop
 344    padding byte, or END if there is no padding.  Return null otherwise.
 345    ENCODED_PTR_WIDTH is as for skip_cfa_op.  */
 346
 347 static bfd_byte *
 348 skip_non_nops (bfd_byte *buf, bfd_byte *end, unsigned int encoded_ptr_width,
 349                unsigned int *set_loc_count)
 350 {
 351   bfd_byte *last;
 352
 353   last = buf;
 354   while (buf < end)
 355     if (*buf == DW_CFA_nop)
 356       buf++;
 357     else
 358       {
 359         if (*buf == DW_CFA_set_loc)
 360           ++*set_loc_count;
 361         if (!skip_cfa_op (&buf, end, encoded_ptr_width))
 362           return 0;
 363         last = buf;
 364       }
 365   return last;
 366 }
 367
 368 /* This function is called for each input file before the .eh_frame
 369    section is relocated.  It discards duplicate CIEs and FDEs for discarded
 370    functions.  The function returns TRUE iff any entries have been
 371    deleted.  */
 372
 373 bfd_boolean
 374 _bfd_elf_discard_section_eh_frame
 375    (bfd *abfd, struct bfd_link_info *info, asection *sec,
 376     bfd_boolean (*reloc_symbol_deleted_p) (bfd_vma, void *),
 377     struct elf_reloc_cookie *cookie)
 378 {
 379 #define REQUIRE(COND)                                   \
 380   do                                                    \
 381     if (!(COND))                                        \
 382       goto free_no_table;                               \
 383   while (0)
 384
 385   bfd_byte *ehbuf = NULL, *buf;
 386   bfd_byte *last_cie, *last_fde;
 387   struct eh_cie_fde *ent, *last_cie_inf, *this_inf;
 388   struct cie_header hdr;
 389   struct cie cie;
 390   struct elf_link_hash_table *htab;
 391   struct eh_frame_hdr_info *hdr_info;
 392   struct eh_frame_sec_info *sec_info = NULL;
 393   unsigned int cie_usage_count, offset;
 394   unsigned int ptr_size;
 395
 396   if (sec->size == 0)
 397     {
 398       /* This file does not contain .eh_frame information.  */
 399       return FALSE;
 400     }
 401
 402   if (bfd_is_abs_section (sec->output_section))
 403     {
 404       /* At least one of the sections is being discarded from the
 405          link, so we should just ignore them.  */
 406       return FALSE;
 407     }
 408
 409   htab = elf_hash_table (info);
 410   hdr_info = &htab->eh_info;
 411
 412   /* Read the frame unwind information from abfd.  */
 413
 414   REQUIRE (bfd_malloc_and_get_section (abfd, sec, &ehbuf));
 415
 416   if (sec->size >= 4
 417       && bfd_get_32 (abfd, ehbuf) == 0
 418       && cookie->rel == cookie->relend)
 419     {
 420       /* Empty .eh_frame section.  */
 421       free (ehbuf);
 422       return FALSE;
 423     }
 424
 425   /* If .eh_frame section size doesn't fit into int, we cannot handle
 426      it (it would need to use 64-bit .eh_frame format anyway).  */
 427   REQUIRE (sec->size == (unsigned int) sec->size);
 428
 429   ptr_size = (get_elf_backend_data (abfd)
 430               ->elf_backend_eh_frame_address_size (abfd, sec));
 431   REQUIRE (ptr_size != 0);
 432
 433   buf = ehbuf;
 434   last_cie = NULL;
 435   last_cie_inf = NULL;
 436   memset (&cie, 0, sizeof (cie));
 437   cie_usage_count = 0;
 438   sec_info = bfd_zmalloc (sizeof (struct eh_frame_sec_info)
 439                           + 99 * sizeof (struct eh_cie_fde));
 440   REQUIRE (sec_info);
 441
 442   sec_info->alloced = 100;
 443
 444 #define ENSURE_NO_RELOCS(buf)                           \
 445   REQUIRE (!(cookie->rel < cookie->relend               \
 446              && (cookie->rel->r_offset                  \
 447                  < (bfd_size_type) ((buf) - ehbuf))     \
 448              && cookie->rel->r_info != 0))
 449
 450 #define SKIP_RELOCS(buf)                                \
 451   while (cookie->rel < cookie->relend                   \
 452          && (cookie->rel->r_offset                      \
 453              < (bfd_size_type) ((buf) - ehbuf)))        \
 454     cookie->rel++
 455
 456 #define GET_RELOC(buf)                                  \
 457   ((cookie->rel < cookie->relend                        \
 458     && (cookie->rel->r_offset                           \
 459         == (bfd_size_type) ((buf) - ehbuf)))            \
 460    ? cookie->rel : NULL)
 461
 462   for (;;)
 463     {
 464       char *aug;
 465       bfd_byte *start, *end, *insns, *insns_end;
 466       bfd_size_type length;
 467       unsigned int set_loc_count;
 468
 469       if (sec_info->count == sec_info->alloced)
 470         {
 471           struct eh_cie_fde *old_entry = sec_info->entry;
 472           sec_info = bfd_realloc (sec_info,
 473                                   sizeof (struct eh_frame_sec_info)
 474                                   + ((sec_info->alloced + 99)
 475                                      * sizeof (struct eh_cie_fde)));
 476           REQUIRE (sec_info);
 477
 478           memset (&sec_info->entry[sec_info->alloced], 0,
 479                   100 * sizeof (struct eh_cie_fde));
 480           sec_info->alloced += 100;
 481
 482           /* Now fix any pointers into the array.  */
 483           if (last_cie_inf >= old_entry
 484               && last_cie_inf < old_entry + sec_info->count)
 485             last_cie_inf = sec_info->entry + (last_cie_inf - old_entry);
 486         }
 487
 488       this_inf = sec_info->entry + sec_info->count;
 489       last_fde = buf;
 490       /* If we are at the end of the section, we still need to decide
 491          on whether to output or discard last encountered CIE (if any).  */
 492       if ((bfd_size_type) (buf - ehbuf) == sec->size)
 493         {
 494           hdr.length = 0;
 495           hdr.id = (unsigned int) -1;
 496           end = buf;
 497         }
 498       else
 499         {
 500           /* Read the length of the entry.  */
 501           REQUIRE (skip_bytes (&buf, ehbuf + sec->size, 4));
 502           hdr.length = bfd_get_32 (abfd, buf - 4);
 503
 504           /* 64-bit .eh_frame is not supported.  */
 505           REQUIRE (hdr.length != 0xffffffff);
 506
 507           /* The CIE/FDE must be fully contained in this input section.  */
 508           REQUIRE ((bfd_size_type) (buf - ehbuf) + hdr.length <= sec->size);
 509           end = buf + hdr.length;
 510
 511           this_inf->offset = last_fde - ehbuf;
 512           this_inf->size = 4 + hdr.length;
 513
 514           if (hdr.length == 0)
 515             {
 516               /* A zero-length CIE should only be found at the end of
 517                  the section.  */
 518               REQUIRE ((bfd_size_type) (buf - ehbuf) == sec->size);
 519               ENSURE_NO_RELOCS (buf);
 520               sec_info->count++;
 521               /* Now just finish last encountered CIE processing and break
 522                  the loop.  */
 523               hdr.id = (unsigned int) -1;
 524             }
 525           else
 526             {
 527               REQUIRE (skip_bytes (&buf, end, 4));
 528               hdr.id = bfd_get_32 (abfd, buf - 4);
 529               REQUIRE (hdr.id != (unsigned int) -1);
 530             }
 531         }
 532
 533       if (hdr.id == 0 || hdr.id == (unsigned int) -1)
 534         {
 535           unsigned int initial_insn_length;
 536
 537           /* CIE  */
 538           if (last_cie != NULL)
 539             {
 540               /* Now check if this CIE is identical to the last CIE,
 541                  in which case we can remove it provided we adjust
 542                  all FDEs.  Also, it can be removed if we have removed
 543                  all FDEs using it.  */
 544               if ((!info->relocatable
 545                    && hdr_info->last_cie_sec
 546                    && (sec->output_section
 547                        == hdr_info->last_cie_sec->output_section)
 548                    && cie_compare (&cie, &hdr_info->last_cie) == 0)
 549                   || cie_usage_count == 0)
 550                 last_cie_inf->removed = 1;
 551               else
 552                 {
 553                   hdr_info->last_cie = cie;
 554                   hdr_info->last_cie_sec = sec;
 555                   last_cie_inf->make_relative = cie.make_relative;
 556                   last_cie_inf->make_lsda_relative = cie.make_lsda_relative;
 557                   last_cie_inf->per_encoding_relative
 558                     = (cie.per_encoding & 0x70) == DW_EH_PE_pcrel;
 559                 }
 560             }
 561
 562           if (hdr.id == (unsigned int) -1)
 563             break;
 564
 565           last_cie_inf = this_inf;
 566           this_inf->cie = 1;
 567
 568           cie_usage_count = 0;
 569           memset (&cie, 0, sizeof (cie));
 570           cie.hdr = hdr;
 571           start = buf;
 572           REQUIRE (read_byte (&buf, end, &cie.version));
 573
 574           /* Cannot handle unknown versions.  */
 575           REQUIRE (cie.version == 1 || cie.version == 3);
 576           REQUIRE (strlen ((char *) buf) < sizeof (cie.augmentation));
 577
 578           strcpy (cie.augmentation, (char *) buf);
 579           buf = (bfd_byte *) strchr ((char *) buf, '\0') + 1;
 580           ENSURE_NO_RELOCS (buf);
 581           if (buf[0] == 'e' && buf[1] == 'h')
 582             {
 583               /* GCC < 3.0 .eh_frame CIE */
 584               /* We cannot merge "eh" CIEs because __EXCEPTION_TABLE__
 585                  is private to each CIE, so we don't need it for anything.
 586                  Just skip it.  */
 587               REQUIRE (skip_bytes (&buf, end, ptr_size));
 588               SKIP_RELOCS (buf);
 589             }
 590           REQUIRE (read_uleb128 (&buf, end, &cie.code_align));
 591           REQUIRE (read_sleb128 (&buf, end, &cie.data_align));
 592           if (cie.version == 1)
 593             {
 594               REQUIRE (buf < end);
 595               cie.ra_column = *buf++;
 596             }
 597           else
 598             REQUIRE (read_uleb128 (&buf, end, &cie.ra_column));
 599           ENSURE_NO_RELOCS (buf);
 600           cie.lsda_encoding = DW_EH_PE_omit;
 601           cie.fde_encoding = DW_EH_PE_omit;
 602           cie.per_encoding = DW_EH_PE_omit;
 603           aug = cie.augmentation;
 604           if (aug[0] != 'e' || aug[1] != 'h')
 605             {
 606               if (*aug == 'z')
 607                 {
 608                   aug++;
 609                   REQUIRE (read_uleb128 (&buf, end, &cie.augmentation_size));
 610                   ENSURE_NO_RELOCS (buf);
 611                 }
 612
 613               while (*aug != '\0')
 614                 switch (*aug++)
 615                   {
 616                   case 'L':
 617                     REQUIRE (read_byte (&buf, end, &cie.lsda_encoding));
 618                     ENSURE_NO_RELOCS (buf);
 619                     REQUIRE (get_DW_EH_PE_width (cie.lsda_encoding, ptr_size));
 620                     break;
 621                   case 'R':
 622                     REQUIRE (read_byte (&buf, end, &cie.fde_encoding));
 623                     ENSURE_NO_RELOCS (buf);
 624                     REQUIRE (get_DW_EH_PE_width (cie.fde_encoding, ptr_size));
 625                     break;
 626                   case 'S':
 627                     break;
 628                   case 'P':
 629                     {
 630                       int per_width;
 631
 632                       REQUIRE (read_byte (&buf, end, &cie.per_encoding));
 633                       per_width = get_DW_EH_PE_width (cie.per_encoding,
 634                                                       ptr_size);
 635                       REQUIRE (per_width);
 636                       if ((cie.per_encoding & 0xf0) == DW_EH_PE_aligned)
 637                         {
 638                           length = -(buf - ehbuf) & (per_width - 1);
 639                           REQUIRE (skip_bytes (&buf, end, length));
 640                         }
 641                       ENSURE_NO_RELOCS (buf);
 642                       /* Ensure we have a reloc here, against
 643                          a global symbol.  */
 644                       if (GET_RELOC (buf) != NULL)
 645                         {
 646                           unsigned long r_symndx;
 647
 648 #ifdef BFD64
 649                           if (ptr_size == 8)
 650                             r_symndx = ELF64_R_SYM (cookie->rel->r_info);
 651                           else
 652 #endif
 653                             r_symndx = ELF32_R_SYM (cookie->rel->r_info);
 654                           if (r_symndx >= cookie->locsymcount)
 655                             {
 656                               struct elf_link_hash_entry *h;
 657
 658                               r_symndx -= cookie->extsymoff;
 659                               h = cookie->sym_hashes[r_symndx];
 660
 661                               while (h->root.type == bfd_link_hash_indirect
 662                                      || h->root.type == bfd_link_hash_warning)
 663                                 h = (struct elf_link_hash_entry *)
 664                                     h->root.u.i.link;
 665
 666                               cie.personality = h;
 667                             }
 668                           /* Cope with MIPS-style composite relocations.  */
 669                           do
 670                             cookie->rel++;
 671                           while (GET_RELOC (buf) != NULL);
 672                         }
 673                       REQUIRE (skip_bytes (&buf, end, per_width));
 674                     }
 675                     break;
 676                   default:
 677                     /* Unrecognized augmentation. Better bail out.  */
 678                     goto free_no_table;
 679                   }
 680             }
 681
 682           /* For shared libraries, try to get rid of as many RELATIVE relocs
 683              as possible.  */
 684           if (info->shared
 685               && (get_elf_backend_data (abfd)
 686                   ->elf_backend_can_make_relative_eh_frame
 687                   (abfd, info, sec)))
 688             {
 689               if ((cie.fde_encoding & 0xf0) == DW_EH_PE_absptr)
 690                 cie.make_relative = 1;
 691               /* If the CIE doesn't already have an 'R' entry, it's fairly
 692                  easy to add one, provided that there's no aligned data
 693                  after the augmentation string.  */
 694               else if (cie.fde_encoding == DW_EH_PE_omit
 695                        && (cie.per_encoding & 0xf0) != DW_EH_PE_aligned)
 696                 {
 697                   if (*cie.augmentation == 0)
 698                     this_inf->add_augmentation_size = 1;
 699                   this_inf->add_fde_encoding = 1;
 700                   cie.make_relative = 1;
 701                 }
 702             }
 703
 704           if (info->shared
 705               && (get_elf_backend_data (abfd)
 706                   ->elf_backend_can_make_lsda_relative_eh_frame
 707                   (abfd, info, sec))
 708               && (cie.lsda_encoding & 0xf0) == DW_EH_PE_absptr)
 709             cie.make_lsda_relative = 1;
 710
 711           /* If FDE encoding was not specified, it defaults to
 712              DW_EH_absptr.  */
 713           if (cie.fde_encoding == DW_EH_PE_omit)
 714             cie.fde_encoding = DW_EH_PE_absptr;
 715
 716           initial_insn_length = end - buf;
 717           if (initial_insn_length <= 50)
 718             {
 719               cie.initial_insn_length = initial_insn_length;
 720               memcpy (cie.initial_instructions, buf, initial_insn_length);
 721             }
 722           insns = buf;
 723           buf += initial_insn_length;
 724           ENSURE_NO_RELOCS (buf);
 725           last_cie = last_fde;
 726         }
 727       else
 728         {
 729           /* Ensure this FDE uses the last CIE encountered.  */
 730           REQUIRE (last_cie);
 731           REQUIRE (hdr.id == (unsigned int) (buf - 4 - last_cie));
 732
 733           ENSURE_NO_RELOCS (buf);
 734           REQUIRE (GET_RELOC (buf));
 735
 736           if ((*reloc_symbol_deleted_p) (buf - ehbuf, cookie))
 737             /* This is a FDE against a discarded section.  It should
 738                be deleted.  */
 739             this_inf->removed = 1;
 740           else
 741             {
 742               if (info->shared
 743                   && (((cie.fde_encoding & 0xf0) == DW_EH_PE_absptr
 744                        && cie.make_relative == 0)
 745                       || (cie.fde_encoding & 0xf0) == DW_EH_PE_aligned))
 746                 {
 747                   /* If a shared library uses absolute pointers
 748                      which we cannot turn into PC relative,
 749                      don't create the binary search table,
 750                      since it is affected by runtime relocations.  */
 751                   hdr_info->table = FALSE;
 752                 }
 753               cie_usage_count++;
 754               hdr_info->fde_count++;
 755             }
 756           /* Skip the initial location and address range.  */
 757           start = buf;
 758           length = get_DW_EH_PE_width (cie.fde_encoding, ptr_size);
 759           REQUIRE (skip_bytes (&buf, end, 2 * length));
 760
 761           /* Skip the augmentation size, if present.  */
 762           if (cie.augmentation[0] == 'z')
 763             REQUIRE (read_uleb128 (&buf, end, &length));
 764           else
 765             length = 0;
 766
 767           /* Of the supported augmentation characters above, only 'L'
 768              adds augmentation data to the FDE.  This code would need to
 769              be adjusted if any future augmentations do the same thing.  */
 770           if (cie.lsda_encoding != DW_EH_PE_omit)
 771             {
 772               this_inf->lsda_offset = buf - start;
 773               /* If there's no 'z' augmentation, we don't know where the
 774                  CFA insns begin.  Assume no padding.  */
 775               if (cie.augmentation[0] != 'z')
 776                 length = end - buf;
 777             }
 778
 779           /* Skip over the augmentation data.  */
 780           REQUIRE (skip_bytes (&buf, end, length));
 781           insns = buf;
 782
 783           buf = last_fde + 4 + hdr.length;
 784           SKIP_RELOCS (buf);
 785         }
 786
 787       /* Try to interpret the CFA instructions and find the first
 788          padding nop.  Shrink this_inf's size so that it doesn't
 789          include the padding.  */
 790       length = get_DW_EH_PE_width (cie.fde_encoding, ptr_size);
 791       set_loc_count = 0;
 792       insns_end = skip_non_nops (insns, end, length, &set_loc_count);
 793       /* If we don't understand the CFA instructions, we can't know
 794          what needs to be adjusted there.  */
 795       if (insns_end == NULL
 796           /* For the time being we don't support DW_CFA_set_loc in
 797              CIE instructions.  */
 798           || (set_loc_count && this_inf->cie))
 799         goto free_no_table;
 800       this_inf->size -= end - insns_end;
 801       if (set_loc_count
 802           && ((cie.fde_encoding & 0xf0) == DW_EH_PE_pcrel
 803               || cie.make_relative))
 804         {
 805           unsigned int cnt;
 806           bfd_byte *p;
 807
 808           this_inf->set_loc = bfd_malloc ((set_loc_count + 1)
 809                                           * sizeof (unsigned int));
 810           REQUIRE (this_inf->set_loc);
 811           this_inf->set_loc[0] = set_loc_count;
 812           p = insns;
 813           cnt = 0;
 814           while (p < end)
 815             {
 816               if (*p == DW_CFA_set_loc)
 817                 this_inf->set_loc[++cnt] = p + 1 - start;
 818               REQUIRE (skip_cfa_op (&p, end, length));
 819             }
 820         }
 821
 822       this_inf->fde_encoding = cie.fde_encoding;
 823       this_inf->lsda_encoding = cie.lsda_encoding;
 824       sec_info->count++;
 825     }
 826
 827   elf_section_data (sec)->sec_info = sec_info;
 828   sec->sec_info_type = ELF_INFO_TYPE_EH_FRAME;
 829
 830   /* Ok, now we can assign new offsets.  */
 831   offset = 0;
 832   last_cie_inf = hdr_info->last_cie_inf;
 833   for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
 834     if (!ent->removed)
 835       {
 836         if (ent->cie)
 837           last_cie_inf = ent;
 838         else
 839           ent->cie_inf = last_cie_inf;
 840         ent->new_offset = offset;
 841         offset += size_of_output_cie_fde (ent, ptr_size);
 842       }
 843   hdr_info->last_cie_inf = last_cie_inf;
 844
 845   /* Resize the sec as needed.  */
 846   sec->rawsize = sec->size;
 847   sec->size = offset;
 848   if (sec->size == 0)
 849     sec->flags |= SEC_EXCLUDE;
 850
 851   free (ehbuf);
 852   return offset != sec->rawsize;
 853
 854 free_no_table:
 855   if (ehbuf)
 856     free (ehbuf);
 857   if (sec_info)
 858     free (sec_info);
 859   hdr_info->table = FALSE;
 860   hdr_info->last_cie.hdr.length = 0;
 861   return FALSE;
 862
 863 #undef REQUIRE
 864 }
 865
 866 /* This function is called for .eh_frame_hdr section after
 867    _bfd_elf_discard_section_eh_frame has been called on all .eh_frame
 868    input sections.  It finalizes the size of .eh_frame_hdr section.  */
 869
 870 bfd_boolean
 871 _bfd_elf_discard_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
 872 {
 873   struct elf_link_hash_table *htab;
 874   struct eh_frame_hdr_info *hdr_info;
 875   asection *sec;
 876
 877   htab = elf_hash_table (info);
 878   hdr_info = &htab->eh_info;
 879   sec = hdr_info->hdr_sec;
 880   if (sec == NULL)
 881     return FALSE;
 882
 883   sec->size = EH_FRAME_HDR_SIZE;
 884   if (hdr_info->table)
 885     sec->size += 4 + hdr_info->fde_count * 8;
 886
 887   elf_tdata (abfd)->eh_frame_hdr = sec;
 888   return TRUE;
 889 }
 890
 891 /* This function is called from size_dynamic_sections.
 892    It needs to decide whether .eh_frame_hdr should be output or not,
 893    because when the dynamic symbol table has been sized it is too late
 894    to strip sections.  */
 895
 896 bfd_boolean
 897 _bfd_elf_maybe_strip_eh_frame_hdr (struct bfd_link_info *info)
 898 {
 899   asection *o;
 900   bfd *abfd;
 901   struct elf_link_hash_table *htab;
 902   struct eh_frame_hdr_info *hdr_info;
 903
 904   htab = elf_hash_table (info);
 905   hdr_info = &htab->eh_info;
 906   if (hdr_info->hdr_sec == NULL)
 907     return TRUE;
 908
 909   if (bfd_is_abs_section (hdr_info->hdr_sec->output_section))
 910     {
 911       hdr_info->hdr_sec = NULL;
 912       return TRUE;
 913     }
 914
 915   abfd = NULL;
 916   if (info->eh_frame_hdr)
 917     for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link_next)
 918       {
 919         /* Count only sections which have at least a single CIE or FDE.
 920            There cannot be any CIE or FDE <= 8 bytes.  */
 921         o = bfd_get_section_by_name (abfd, ".eh_frame");
 922         if (o && o->size > 8 && !bfd_is_abs_section (o->output_section))
 923           break;
 924       }
 925
 926   if (abfd == NULL)
 927     {
 928       hdr_info->hdr_sec->flags |= SEC_EXCLUDE;
 929       hdr_info->hdr_sec = NULL;
 930       return TRUE;
 931     }
 932
 933   hdr_info->table = TRUE;
 934   return TRUE;
 935 }
 936
 937 /* Adjust an address in the .eh_frame section.  Given OFFSET within
 938    SEC, this returns the new offset in the adjusted .eh_frame section,
 939    or -1 if the address refers to a CIE/FDE which has been removed
 940    or to offset with dynamic relocation which is no longer needed.  */
 941
 942 bfd_vma
 943 _bfd_elf_eh_frame_section_offset (bfd *output_bfd ATTRIBUTE_UNUSED,
 944                                   struct bfd_link_info *info,
 945                                   asection *sec,
 946                                   bfd_vma offset)
 947 {
 948   struct eh_frame_sec_info *sec_info;
 949   struct elf_link_hash_table *htab;
 950   struct eh_frame_hdr_info *hdr_info;
 951   unsigned int lo, hi, mid;
 952
 953   if (sec->sec_info_type != ELF_INFO_TYPE_EH_FRAME)
 954     return offset;
 955   sec_info = elf_section_data (sec)->sec_info;
 956
 957   if (offset >= sec->rawsize)
 958     return offset - sec->rawsize + sec->size;
 959
 960   htab = elf_hash_table (info);
 961   hdr_info = &htab->eh_info;
 962   if (hdr_info->offsets_adjusted)
 963     offset += sec->output_offset;
 964
 965   lo = 0;
 966   hi = sec_info->count;
 967   mid = 0;
 968   while (lo < hi)
 969     {
 970       mid = (lo + hi) / 2;
 971       if (offset < sec_info->entry[mid].offset)
 972         hi = mid;
 973       else if (offset
 974                >= sec_info->entry[mid].offset + sec_info->entry[mid].size)
 975         lo = mid + 1;
 976       else
 977         break;
 978     }
 979
 980   BFD_ASSERT (lo < hi);
 981
 982   /* FDE or CIE was removed.  */
 983   if (sec_info->entry[mid].removed)
 984     return (bfd_vma) -1;
 985
 986   /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
 987      relocation against FDE's initial_location field.  */
 988   if (!sec_info->entry[mid].cie
 989       && sec_info->entry[mid].cie_inf->make_relative
 990       && offset == sec_info->entry[mid].offset + 8)
 991     return (bfd_vma) -2;
 992
 993   /* If converting LSDA pointers to DW_EH_PE_pcrel, there will be no need
 994      for run-time relocation against LSDA field.  */
 995   if (!sec_info->entry[mid].cie
 996       && sec_info->entry[mid].cie_inf->make_lsda_relative
 997       && (offset == (sec_info->entry[mid].offset + 8
 998                      + sec_info->entry[mid].lsda_offset))
 999       && (sec_info->entry[mid].cie_inf->need_lsda_relative
1000           || !hdr_info->offsets_adjusted))
1001     {
1002       sec_info->entry[mid].cie_inf->need_lsda_relative = 1;
1003       return (bfd_vma) -2;
1004     }
1005
1006   /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1007      relocation against DW_CFA_set_loc's arguments.  */
1008   if (sec_info->entry[mid].set_loc
1009       && (sec_info->entry[mid].cie
1010           ? sec_info->entry[mid].make_relative
1011           : sec_info->entry[mid].cie_inf->make_relative)
1012       && (offset >= sec_info->entry[mid].offset + 8
1013                     + sec_info->entry[mid].set_loc[1]))
1014     {
1015       unsigned int cnt;
1016
1017       for (cnt = 1; cnt <= sec_info->entry[mid].set_loc[0]; cnt++)
1018         if (offset == sec_info->entry[mid].offset + 8
1019                       + sec_info->entry[mid].set_loc[cnt])
1020           return (bfd_vma) -2;
1021     }
1022
1023   if (hdr_info->offsets_adjusted)
1024     offset -= sec->output_offset;
1025   /* Any new augmentation bytes go before the first relocation.  */
1026   return (offset + sec_info->entry[mid].new_offset
1027           - sec_info->entry[mid].offset
1028           + extra_augmentation_string_bytes (sec_info->entry + mid)
1029           + extra_augmentation_data_bytes (sec_info->entry + mid));
1030 }
1031
1032 /* Write out .eh_frame section.  This is called with the relocated
1033    contents.  */
1034
1035 bfd_boolean
1036 _bfd_elf_write_section_eh_frame (bfd *abfd,
1037                                  struct bfd_link_info *info,
1038                                  asection *sec,
1039                                  bfd_byte *contents)
1040 {
1041   struct eh_frame_sec_info *sec_info;
1042   struct elf_link_hash_table *htab;
1043   struct eh_frame_hdr_info *hdr_info;
1044   unsigned int ptr_size;
1045   struct eh_cie_fde *ent;
1046
1047   if (sec->sec_info_type != ELF_INFO_TYPE_EH_FRAME)
1048     return bfd_set_section_contents (abfd, sec->output_section, contents,
1049                                      sec->output_offset, sec->size);
1050
1051   ptr_size = (get_elf_backend_data (abfd)
1052               ->elf_backend_eh_frame_address_size (abfd, sec));
1053   BFD_ASSERT (ptr_size != 0);
1054
1055   sec_info = elf_section_data (sec)->sec_info;
1056   htab = elf_hash_table (info);
1057   hdr_info = &htab->eh_info;
1058
1059   /* First convert all offsets to output section offsets, so that a
1060      CIE offset is valid if the CIE is used by a FDE from some other
1061      section.  This can happen when duplicate CIEs are deleted in
1062      _bfd_elf_discard_section_eh_frame.  We do all sections here because
1063      this function might not be called on sections in the same order as
1064      _bfd_elf_discard_section_eh_frame.  */
1065   if (!hdr_info->offsets_adjusted)
1066     {
1067       bfd *ibfd;
1068       asection *eh;
1069       struct eh_frame_sec_info *eh_inf;
1070
1071       for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
1072         {
1073           if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1074               || (ibfd->flags & DYNAMIC) != 0)
1075             continue;
1076
1077           eh = bfd_get_section_by_name (ibfd, ".eh_frame");
1078           if (eh == NULL || eh->sec_info_type != ELF_INFO_TYPE_EH_FRAME)
1079             continue;
1080
1081           eh_inf = elf_section_data (eh)->sec_info;
1082           for (ent = eh_inf->entry; ent < eh_inf->entry + eh_inf->count; ++ent)
1083             {
1084               ent->offset += eh->output_offset;
1085               ent->new_offset += eh->output_offset;
1086             }
1087         }
1088       hdr_info->offsets_adjusted = TRUE;
1089     }
1090
1091   if (hdr_info->table && hdr_info->array == NULL)
1092     hdr_info->array
1093       = bfd_malloc (hdr_info->fde_count * sizeof(*hdr_info->array));
1094   if (hdr_info->array == NULL)
1095     hdr_info = NULL;
1096
1097   /* The new offsets can be bigger or smaller than the original offsets.
1098      We therefore need to make two passes over the section: one backward
1099      pass to move entries up and one forward pass to move entries down.
1100      The two passes won't interfere with each other because entries are
1101      not reordered  */
1102   for (ent = sec_info->entry + sec_info->count; ent-- != sec_info->entry;)
1103     if (!ent->removed && ent->new_offset > ent->offset)
1104       memmove (contents + ent->new_offset - sec->output_offset,
1105                contents + ent->offset - sec->output_offset, ent->size);
1106
1107   for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1108     if (!ent->removed && ent->new_offset < ent->offset)
1109       memmove (contents + ent->new_offset - sec->output_offset,
1110                contents + ent->offset - sec->output_offset, ent->size);
1111
1112   for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1113     {
1114       unsigned char *buf, *end;
1115       unsigned int new_size;
1116
1117       if (ent->removed)
1118         continue;
1119
1120       if (ent->size == 4)
1121         {
1122           /* Any terminating FDE must be at the end of the section.  */
1123           BFD_ASSERT (ent == sec_info->entry + sec_info->count - 1);
1124           continue;
1125         }
1126
1127       buf = contents + ent->new_offset - sec->output_offset;
1128       end = buf + ent->size;
1129       new_size = size_of_output_cie_fde (ent, ptr_size);
1130
1131       /* Update the size.  It may be shrinked.  */
1132       bfd_put_32 (abfd, new_size - 4, buf);
1133
1134       /* Filling the extra bytes with DW_CFA_nops.  */
1135       if (new_size != ent->size)
1136         memset (end, 0, new_size - ent->size);
1137
1138       if (ent->cie)
1139         {
1140           /* CIE */
1141           if (ent->make_relative
1142               || ent->need_lsda_relative
1143               || ent->per_encoding_relative)
1144             {
1145               char *aug;
1146               unsigned int action, extra_string, extra_data;
1147               unsigned int per_width, per_encoding;
1148
1149               /* Need to find 'R' or 'L' augmentation's argument and modify
1150                  DW_EH_PE_* value.  */
1151               action = ((ent->make_relative ? 1 : 0)
1152                         | (ent->need_lsda_relative ? 2 : 0)
1153                         | (ent->per_encoding_relative ? 4 : 0));
1154               extra_string = extra_augmentation_string_bytes (ent);
1155               extra_data = extra_augmentation_data_bytes (ent);
1156
1157               /* Skip length, id and version.  */
1158               buf += 9;
1159               aug = (char *) buf;
1160               buf += strlen (aug) + 1;
1161               skip_leb128 (&buf, end);
1162               skip_leb128 (&buf, end);
1163               skip_leb128 (&buf, end);
1164               if (*aug == 'z')
1165                 {
1166                   /* The uleb128 will always be a single byte for the kind
1167                      of augmentation strings that we're prepared to handle.  */
1168                   *buf++ += extra_data;
1169                   aug++;
1170                 }
1171
1172               /* Make room for the new augmentation string and data bytes.  */
1173               memmove (buf + extra_string + extra_data, buf, end - buf);
1174               memmove (aug + extra_string, aug, buf - (bfd_byte *) aug);
1175               buf += extra_string;
1176               end += extra_string + extra_data;
1177
1178               if (ent->add_augmentation_size)
1179                 {
1180                   *aug++ = 'z';
1181                   *buf++ = extra_data - 1;
1182                 }
1183               if (ent->add_fde_encoding)
1184                 {
1185                   BFD_ASSERT (action & 1);
1186                   *aug++ = 'R';
1187                   *buf++ = DW_EH_PE_pcrel;
1188                   action &= ~1;
1189                 }
1190
1191               while (action)
1192                 switch (*aug++)
1193                   {
1194                   case 'L':
1195                     if (action & 2)
1196                       {
1197                         BFD_ASSERT (*buf == ent->lsda_encoding);
1198                         *buf |= DW_EH_PE_pcrel;
1199                         action &= ~2;
1200                       }
1201                     buf++;
1202                     break;
1203                   case 'P':
1204                     per_encoding = *buf++;
1205                     per_width = get_DW_EH_PE_width (per_encoding, ptr_size);
1206                     BFD_ASSERT (per_width != 0);
1207                     BFD_ASSERT (((per_encoding & 0x70) == DW_EH_PE_pcrel)
1208                                 == ent->per_encoding_relative);
1209                     if ((per_encoding & 0xf0) == DW_EH_PE_aligned)
1210                       buf = (contents
1211                              + ((buf - contents + per_width - 1)
1212                                 & ~((bfd_size_type) per_width - 1)));
1213                     if (action & 4)
1214                       {
1215                         bfd_vma val;
1216
1217                         val = read_value (abfd, buf, per_width,
1218                                           get_DW_EH_PE_signed (per_encoding));
1219                         val += ent->offset - ent->new_offset;
1220                         val -= extra_string + extra_data;
1221                         write_value (abfd, buf, val, per_width);
1222                         action &= ~4;
1223                       }
1224                     buf += per_width;
1225                     break;
1226                   case 'R':
1227                     if (action & 1)
1228                       {
1229                         BFD_ASSERT (*buf == ent->fde_encoding);
1230                         *buf |= DW_EH_PE_pcrel;
1231                         action &= ~1;
1232                       }
1233                     buf++;
1234                     break;
1235                   case 'S':
1236                     break;
1237                   default:
1238                     BFD_FAIL ();
1239                   }
1240             }
1241         }
1242       else
1243         {
1244           /* FDE */
1245           bfd_vma value, address;
1246           unsigned int width;
1247           bfd_byte *start;
1248
1249           /* Skip length.  */
1250           buf += 4;
1251           value = ent->new_offset + 4 - ent->cie_inf->new_offset;
1252           bfd_put_32 (abfd, value, buf);
1253           buf += 4;
1254           width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1255           value = read_value (abfd, buf, width,
1256                               get_DW_EH_PE_signed (ent->fde_encoding));
1257           address = value;
1258           if (value)
1259             {
1260               switch (ent->fde_encoding & 0xf0)
1261                 {
1262                 case DW_EH_PE_indirect:
1263                 case DW_EH_PE_textrel:
1264                   BFD_ASSERT (hdr_info == NULL);
1265                   break;
1266                 case DW_EH_PE_datarel:
1267                   {
1268                     asection *got = bfd_get_section_by_name (abfd, ".got");
1269
1270                     BFD_ASSERT (got != NULL);
1271                     address += got->vma;
1272                   }
1273                   break;
1274                 case DW_EH_PE_pcrel:
1275                   value += ent->offset - ent->new_offset;
1276                   address += sec->output_section->vma + ent->offset + 8;
1277                   break;
1278                 }
1279               if (ent->cie_inf->make_relative)
1280                 value -= sec->output_section->vma + ent->new_offset + 8;
1281               write_value (abfd, buf, value, width);
1282             }
1283
1284           start = buf;
1285
1286           if (hdr_info)
1287             {
1288               hdr_info->array[hdr_info->array_count].initial_loc = address;
1289               hdr_info->array[hdr_info->array_count++].fde
1290                 = sec->output_section->vma + ent->new_offset;
1291             }
1292
1293           if ((ent->lsda_encoding & 0xf0) == DW_EH_PE_pcrel
1294               || ent->cie_inf->need_lsda_relative)
1295             {
1296               buf += ent->lsda_offset;
1297               width = get_DW_EH_PE_width (ent->lsda_encoding, ptr_size);
1298               value = read_value (abfd, buf, width,
1299                                   get_DW_EH_PE_signed (ent->lsda_encoding));
1300               if (value)
1301                 {
1302                   if ((ent->lsda_encoding & 0xf0) == DW_EH_PE_pcrel)
1303                     value += ent->offset - ent->new_offset;
1304                   else if (ent->cie_inf->need_lsda_relative)
1305                     value -= (sec->output_section->vma + ent->new_offset + 8
1306                               + ent->lsda_offset);
1307                   write_value (abfd, buf, value, width);
1308                 }
1309             }
1310           else if (ent->cie_inf->add_augmentation_size)
1311             {
1312               /* Skip the PC and length and insert a zero byte for the
1313                  augmentation size.  */
1314               buf += width * 2;
1315               memmove (buf + 1, buf, end - buf);
1316               *buf = 0;
1317             }
1318
1319           if (ent->set_loc)
1320             {
1321               /* Adjust DW_CFA_set_loc.  */
1322               unsigned int cnt, width;
1323               bfd_vma new_offset;
1324
1325               width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1326               new_offset = ent->new_offset + 8
1327                            + extra_augmentation_string_bytes (ent)
1328                            + extra_augmentation_data_bytes (ent);
1329
1330               for (cnt = 1; cnt <= ent->set_loc[0]; cnt++)
1331                 {
1332                   bfd_vma value;
1333                   buf = start + ent->set_loc[cnt];
1334
1335                   value = read_value (abfd, buf, width,
1336                                       get_DW_EH_PE_signed (ent->fde_encoding));
1337                   if (!value)
1338                     continue;
1339
1340                   if ((ent->fde_encoding & 0xf0) == DW_EH_PE_pcrel)
1341                     value += ent->offset + 8 - new_offset;
1342                   if (ent->cie_inf->make_relative)
1343                     value -= sec->output_section->vma + new_offset
1344                              + ent->set_loc[cnt];
1345                   write_value (abfd, buf, value, width);
1346                 }
1347             }
1348         }
1349     }
1350
1351   /* We don't align the section to its section alignment since the
1352      runtime library only expects all CIE/FDE records aligned at
1353      the pointer size. _bfd_elf_discard_section_eh_frame should
1354      have padded CIE/FDE records to multiple of pointer size with
1355      size_of_output_cie_fde.  */
1356   if ((sec->size % ptr_size) != 0)
1357     abort ();
1358
1359   return bfd_set_section_contents (abfd, sec->output_section,
1360                                    contents, (file_ptr) sec->output_offset,
1361                                    sec->size);
1362 }
1363
1364 /* Helper function used to sort .eh_frame_hdr search table by increasing
1365    VMA of FDE initial location.  */
1366
1367 static int
1368 vma_compare (const void *a, const void *b)
1369 {
1370   const struct eh_frame_array_ent *p = a;
1371   const struct eh_frame_array_ent *q = b;
1372   if (p->initial_loc > q->initial_loc)
1373     return 1;
1374   if (p->initial_loc < q->initial_loc)
1375     return -1;
1376   return 0;
1377 }
1378
1379 /* Write out .eh_frame_hdr section.  This must be called after
1380    _bfd_elf_write_section_eh_frame has been called on all input
1381    .eh_frame sections.
1382    .eh_frame_hdr format:
1383    ubyte version                (currently 1)
1384    ubyte eh_frame_ptr_enc       (DW_EH_PE_* encoding of pointer to start of
1385                                  .eh_frame section)
1386    ubyte fde_count_enc          (DW_EH_PE_* encoding of total FDE count
1387                                  number (or DW_EH_PE_omit if there is no
1388                                  binary search table computed))
1389    ubyte table_enc              (DW_EH_PE_* encoding of binary search table,
1390                                  or DW_EH_PE_omit if not present.
1391                                  DW_EH_PE_datarel is using address of
1392                                  .eh_frame_hdr section start as base)
1393    [encoded] eh_frame_ptr       (pointer to start of .eh_frame section)
1394    optionally followed by:
1395    [encoded] fde_count          (total number of FDEs in .eh_frame section)
1396    fde_count x [encoded] initial_loc, fde
1397                                 (array of encoded pairs containing
1398                                  FDE initial_location field and FDE address,
1399                                  sorted by increasing initial_loc).  */
1400
1401 bfd_boolean
1402 _bfd_elf_write_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
1403 {
1404   struct elf_link_hash_table *htab;
1405   struct eh_frame_hdr_info *hdr_info;
1406   asection *sec;
1407   bfd_byte *contents;
1408   asection *eh_frame_sec;
1409   bfd_size_type size;
1410   bfd_boolean retval;
1411   bfd_vma encoded_eh_frame;
1412
1413   htab = elf_hash_table (info);
1414   hdr_info = &htab->eh_info;
1415   sec = hdr_info->hdr_sec;
1416   if (sec == NULL)
1417     return TRUE;
1418
1419   size = EH_FRAME_HDR_SIZE;
1420   if (hdr_info->array && hdr_info->array_count == hdr_info->fde_count)
1421     size += 4 + hdr_info->fde_count * 8;
1422   contents = bfd_malloc (size);
1423   if (contents == NULL)
1424     return FALSE;
1425
1426   eh_frame_sec = bfd_get_section_by_name (abfd, ".eh_frame");
1427   if (eh_frame_sec == NULL)
1428     {
1429       free (contents);
1430       return FALSE;
1431     }
1432
1433   memset (contents, 0, EH_FRAME_HDR_SIZE);
1434   contents[0] = 1;                              /* Version.  */
1435   contents[1] = get_elf_backend_data (abfd)->elf_backend_encode_eh_address
1436     (abfd, info, eh_frame_sec, 0, sec, 4,
1437      &encoded_eh_frame);                        /* .eh_frame offset.  */
1438
1439   if (hdr_info->array && hdr_info->array_count == hdr_info->fde_count)
1440     {
1441       contents[2] = DW_EH_PE_udata4;            /* FDE count encoding.  */
1442       contents[3] = DW_EH_PE_datarel | DW_EH_PE_sdata4; /* Search table enc.  */
1443     }
1444   else
1445     {
1446       contents[2] = DW_EH_PE_omit;
1447       contents[3] = DW_EH_PE_omit;
1448     }
1449   bfd_put_32 (abfd, encoded_eh_frame, contents + 4);
1450
1451   if (contents[2] != DW_EH_PE_omit)
1452     {
1453       unsigned int i;
1454
1455       bfd_put_32 (abfd, hdr_info->fde_count, contents + EH_FRAME_HDR_SIZE);
1456       qsort (hdr_info->array, hdr_info->fde_count, sizeof (*hdr_info->array),
1457              vma_compare);
1458       for (i = 0; i < hdr_info->fde_count; i++)
1459         {
1460           bfd_put_32 (abfd,
1461                       hdr_info->array[i].initial_loc
1462                       - sec->output_section->vma,
1463                       contents + EH_FRAME_HDR_SIZE + i * 8 + 4);
1464           bfd_put_32 (abfd,
1465                       hdr_info->array[i].fde - sec->output_section->vma,
1466                       contents + EH_FRAME_HDR_SIZE + i * 8 + 8);
1467         }
1468     }
1469
1470   retval = bfd_set_section_contents (abfd, sec->output_section,
1471                                      contents, (file_ptr) sec->output_offset,
1472                                      sec->size);
1473   free (contents);
1474   return retval;
1475 }
1476
1477 /* Return the width of FDE addresses.  This is the default implementation.  */
1478
1479 unsigned int
1480 _bfd_elf_eh_frame_address_size (bfd *abfd, asection *sec ATTRIBUTE_UNUSED)
1481 {
1482   return elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64 ? 8 : 4;
1483 }
1484
1485 /* Decide whether we can use a PC-relative encoding within the given
1486    EH frame section.  This is the default implementation.  */
1487
1488 bfd_boolean
1489 _bfd_elf_can_make_relative (bfd *input_bfd ATTRIBUTE_UNUSED,
1490                             struct bfd_link_info *info ATTRIBUTE_UNUSED,
1491                             asection *eh_frame_section ATTRIBUTE_UNUSED)
1492 {
1493   return TRUE;
1494 }
1495
1496 /* Select an encoding for the given address.  Preference is given to
1497    PC-relative addressing modes.  */
1498
1499 bfd_byte
1500 _bfd_elf_encode_eh_address (bfd *abfd ATTRIBUTE_UNUSED,
1501                             struct bfd_link_info *info ATTRIBUTE_UNUSED,
1502                             asection *osec, bfd_vma offset,
1503                             asection *loc_sec, bfd_vma loc_offset,
1504                             bfd_vma *encoded)
1505 {
1506   *encoded = osec->vma + offset -
1507     (loc_sec->output_section->vma + loc_sec->output_offset + loc_offset);
1508   return DW_EH_PE_pcrel | DW_EH_PE_sdata4;
1509 }