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