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   if (sec->size == 0)
 931     sec->flags |= SEC_EXCLUDE;
 932
 933   free (ehbuf);
 934   if (ecies)
 935     free (ecies);
 936   return offset != sec->rawsize;
 937
 938 free_no_table:
 939   if (ehbuf)
 940     free (ehbuf);
 941   if (sec_info)
 942     free (sec_info);
 943   if (ecies)
 944     free (ecies);
 945   hdr_info->table = FALSE;
 946   return FALSE;
 947
 948 #undef REQUIRE
 949 }
 950
 951 /* This function is called for .eh_frame_hdr section after
 952    _bfd_elf_discard_section_eh_frame has been called on all .eh_frame
 953    input sections.  It finalizes the size of .eh_frame_hdr section.  */
 954
 955 bfd_boolean
 956 _bfd_elf_discard_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
 957 {
 958   struct elf_link_hash_table *htab;
 959   struct eh_frame_hdr_info *hdr_info;
 960   asection *sec;
 961
 962   htab = elf_hash_table (info);
 963   hdr_info = &htab->eh_info;
 964
 965   if (hdr_info->cies != NULL)
 966     {
 967       htab_delete (hdr_info->cies);
 968       hdr_info->cies = NULL;
 969     }
 970
 971   sec = hdr_info->hdr_sec;
 972   if (sec == NULL)
 973     return FALSE;
 974
 975   sec->size = EH_FRAME_HDR_SIZE;
 976   if (hdr_info->table)
 977     sec->size += 4 + hdr_info->fde_count * 8;
 978
 979   elf_tdata (abfd)->eh_frame_hdr = sec;
 980   return TRUE;
 981 }
 982
 983 /* This function is called from size_dynamic_sections.
 984    It needs to decide whether .eh_frame_hdr should be output or not,
 985    because when the dynamic symbol table has been sized it is too late
 986    to strip sections.  */
 987
 988 bfd_boolean
 989 _bfd_elf_maybe_strip_eh_frame_hdr (struct bfd_link_info *info)
 990 {
 991   asection *o;
 992   bfd *abfd;
 993   struct elf_link_hash_table *htab;
 994   struct eh_frame_hdr_info *hdr_info;
 995
 996   htab = elf_hash_table (info);
 997   hdr_info = &htab->eh_info;
 998   if (hdr_info->hdr_sec == NULL)
 999     return TRUE;
1000
1001   if (bfd_is_abs_section (hdr_info->hdr_sec->output_section))
1002     {
1003       hdr_info->hdr_sec = NULL;
1004       return TRUE;
1005     }
1006
1007   abfd = NULL;
1008   if (info->eh_frame_hdr)
1009     for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link_next)
1010       {
1011         /* Count only sections which have at least a single CIE or FDE.
1012            There cannot be any CIE or FDE <= 8 bytes.  */
1013         o = bfd_get_section_by_name (abfd, ".eh_frame");
1014         if (o && o->size > 8 && !bfd_is_abs_section (o->output_section))
1015           break;
1016       }
1017
1018   if (abfd == NULL)
1019     {
1020       hdr_info->hdr_sec->flags |= SEC_EXCLUDE;
1021       hdr_info->hdr_sec = NULL;
1022       return TRUE;
1023     }
1024
1025   hdr_info->table = TRUE;
1026   return TRUE;
1027 }
1028
1029 /* Adjust an address in the .eh_frame section.  Given OFFSET within
1030    SEC, this returns the new offset in the adjusted .eh_frame section,
1031    or -1 if the address refers to a CIE/FDE which has been removed
1032    or to offset with dynamic relocation which is no longer needed.  */
1033
1034 bfd_vma
1035 _bfd_elf_eh_frame_section_offset (bfd *output_bfd ATTRIBUTE_UNUSED,
1036                                   struct bfd_link_info *info,
1037                                   asection *sec,
1038                                   bfd_vma offset)
1039 {
1040   struct eh_frame_sec_info *sec_info;
1041   struct elf_link_hash_table *htab;
1042   struct eh_frame_hdr_info *hdr_info;
1043   unsigned int lo, hi, mid;
1044
1045   if (sec->sec_info_type != ELF_INFO_TYPE_EH_FRAME)
1046     return offset;
1047   sec_info = elf_section_data (sec)->sec_info;
1048
1049   if (offset >= sec->rawsize)
1050     return offset - sec->rawsize + sec->size;
1051
1052   htab = elf_hash_table (info);
1053   hdr_info = &htab->eh_info;
1054   if (hdr_info->offsets_adjusted)
1055     offset += sec->output_offset;
1056
1057   lo = 0;
1058   hi = sec_info->count;
1059   mid = 0;
1060   while (lo < hi)
1061     {
1062       mid = (lo + hi) / 2;
1063       if (offset < sec_info->entry[mid].offset)
1064         hi = mid;
1065       else if (offset
1066                >= sec_info->entry[mid].offset + sec_info->entry[mid].size)
1067         lo = mid + 1;
1068       else
1069         break;
1070     }
1071
1072   BFD_ASSERT (lo < hi);
1073
1074   /* FDE or CIE was removed.  */
1075   if (sec_info->entry[mid].removed)
1076     return (bfd_vma) -1;
1077
1078   /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1079      relocation against FDE's initial_location field.  */
1080   if (!sec_info->entry[mid].cie
1081       && sec_info->entry[mid].cie_inf->make_relative
1082       && offset == sec_info->entry[mid].offset + 8)
1083     return (bfd_vma) -2;
1084
1085   /* If converting LSDA pointers to DW_EH_PE_pcrel, there will be no need
1086      for run-time relocation against LSDA field.  */
1087   if (!sec_info->entry[mid].cie
1088       && sec_info->entry[mid].cie_inf->make_lsda_relative
1089       && (offset == (sec_info->entry[mid].offset + 8
1090                      + sec_info->entry[mid].lsda_offset))
1091       && (sec_info->entry[mid].cie_inf->need_lsda_relative
1092           || !hdr_info->offsets_adjusted))
1093     {
1094       sec_info->entry[mid].cie_inf->need_lsda_relative = 1;
1095       return (bfd_vma) -2;
1096     }
1097
1098   /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1099      relocation against DW_CFA_set_loc's arguments.  */
1100   if (sec_info->entry[mid].set_loc
1101       && (sec_info->entry[mid].cie
1102           ? sec_info->entry[mid].make_relative
1103           : sec_info->entry[mid].cie_inf->make_relative)
1104       && (offset >= sec_info->entry[mid].offset + 8
1105                     + sec_info->entry[mid].set_loc[1]))
1106     {
1107       unsigned int cnt;
1108
1109       for (cnt = 1; cnt <= sec_info->entry[mid].set_loc[0]; cnt++)
1110         if (offset == sec_info->entry[mid].offset + 8
1111                       + sec_info->entry[mid].set_loc[cnt])
1112           return (bfd_vma) -2;
1113     }
1114
1115   if (hdr_info->offsets_adjusted)
1116     offset -= sec->output_offset;
1117   /* Any new augmentation bytes go before the first relocation.  */
1118   return (offset + sec_info->entry[mid].new_offset
1119           - sec_info->entry[mid].offset
1120           + extra_augmentation_string_bytes (sec_info->entry + mid)
1121           + extra_augmentation_data_bytes (sec_info->entry + mid));
1122 }
1123
1124 /* Write out .eh_frame section.  This is called with the relocated
1125    contents.  */
1126
1127 bfd_boolean
1128 _bfd_elf_write_section_eh_frame (bfd *abfd,
1129                                  struct bfd_link_info *info,
1130                                  asection *sec,
1131                                  bfd_byte *contents)
1132 {
1133   struct eh_frame_sec_info *sec_info;
1134   struct elf_link_hash_table *htab;
1135   struct eh_frame_hdr_info *hdr_info;
1136   unsigned int ptr_size;
1137   struct eh_cie_fde *ent;
1138
1139   if (sec->sec_info_type != ELF_INFO_TYPE_EH_FRAME)
1140     return bfd_set_section_contents (abfd, sec->output_section, contents,
1141                                      sec->output_offset, sec->size);
1142
1143   ptr_size = (get_elf_backend_data (abfd)
1144               ->elf_backend_eh_frame_address_size (abfd, sec));
1145   BFD_ASSERT (ptr_size != 0);
1146
1147   sec_info = elf_section_data (sec)->sec_info;
1148   htab = elf_hash_table (info);
1149   hdr_info = &htab->eh_info;
1150
1151   /* First convert all offsets to output section offsets, so that a
1152      CIE offset is valid if the CIE is used by a FDE from some other
1153      section.  This can happen when duplicate CIEs are deleted in
1154      _bfd_elf_discard_section_eh_frame.  We do all sections here because
1155      this function might not be called on sections in the same order as
1156      _bfd_elf_discard_section_eh_frame.  */
1157   if (!hdr_info->offsets_adjusted)
1158     {
1159       bfd *ibfd;
1160       asection *eh;
1161       struct eh_frame_sec_info *eh_inf;
1162
1163       for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
1164         {
1165           if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1166               || (ibfd->flags & DYNAMIC) != 0)
1167             continue;
1168
1169           eh = bfd_get_section_by_name (ibfd, ".eh_frame");
1170           if (eh == NULL || eh->sec_info_type != ELF_INFO_TYPE_EH_FRAME)
1171             continue;
1172
1173           eh_inf = elf_section_data (eh)->sec_info;
1174           for (ent = eh_inf->entry; ent < eh_inf->entry + eh_inf->count; ++ent)
1175             {
1176               ent->offset += eh->output_offset;
1177               ent->new_offset += eh->output_offset;
1178             }
1179         }
1180       hdr_info->offsets_adjusted = TRUE;
1181     }
1182
1183   if (hdr_info->table && hdr_info->array == NULL)
1184     hdr_info->array
1185       = bfd_malloc (hdr_info->fde_count * sizeof(*hdr_info->array));
1186   if (hdr_info->array == NULL)
1187     hdr_info = NULL;
1188
1189   /* The new offsets can be bigger or smaller than the original offsets.
1190      We therefore need to make two passes over the section: one backward
1191      pass to move entries up and one forward pass to move entries down.
1192      The two passes won't interfere with each other because entries are
1193      not reordered  */
1194   for (ent = sec_info->entry + sec_info->count; ent-- != sec_info->entry;)
1195     if (!ent->removed && ent->new_offset > ent->offset)
1196       memmove (contents + ent->new_offset - sec->output_offset,
1197                contents + ent->offset - sec->output_offset, ent->size);
1198
1199   for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1200     if (!ent->removed && ent->new_offset < ent->offset)
1201       memmove (contents + ent->new_offset - sec->output_offset,
1202                contents + ent->offset - sec->output_offset, ent->size);
1203
1204   for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1205     {
1206       unsigned char *buf, *end;
1207       unsigned int new_size;
1208
1209       if (ent->removed)
1210         continue;
1211
1212       if (ent->size == 4)
1213         {
1214           /* Any terminating FDE must be at the end of the section.  */
1215           BFD_ASSERT (ent == sec_info->entry + sec_info->count - 1);
1216           continue;
1217         }
1218
1219       buf = contents + ent->new_offset - sec->output_offset;
1220       end = buf + ent->size;
1221       new_size = size_of_output_cie_fde (ent, ptr_size);
1222
1223       /* Update the size.  It may be shrinked.  */
1224       bfd_put_32 (abfd, new_size - 4, buf);
1225
1226       /* Filling the extra bytes with DW_CFA_nops.  */
1227       if (new_size != ent->size)
1228         memset (end, 0, new_size - ent->size);
1229
1230       if (ent->cie)
1231         {
1232           /* CIE */
1233           if (ent->make_relative
1234               || ent->need_lsda_relative
1235               || ent->per_encoding_relative)
1236             {
1237               char *aug;
1238               unsigned int action, extra_string, extra_data;
1239               unsigned int per_width, per_encoding;
1240
1241               /* Need to find 'R' or 'L' augmentation's argument and modify
1242                  DW_EH_PE_* value.  */
1243               action = ((ent->make_relative ? 1 : 0)
1244                         | (ent->need_lsda_relative ? 2 : 0)
1245                         | (ent->per_encoding_relative ? 4 : 0));
1246               extra_string = extra_augmentation_string_bytes (ent);
1247               extra_data = extra_augmentation_data_bytes (ent);
1248
1249               /* Skip length, id and version.  */
1250               buf += 9;
1251               aug = (char *) buf;
1252               buf += strlen (aug) + 1;
1253               skip_leb128 (&buf, end);
1254               skip_leb128 (&buf, end);
1255               skip_leb128 (&buf, end);
1256               if (*aug == 'z')
1257                 {
1258                   /* The uleb128 will always be a single byte for the kind
1259                      of augmentation strings that we're prepared to handle.  */
1260                   *buf++ += extra_data;
1261                   aug++;
1262                 }
1263
1264               /* Make room for the new augmentation string and data bytes.  */
1265               memmove (buf + extra_string + extra_data, buf, end - buf);
1266               memmove (aug + extra_string, aug, buf - (bfd_byte *) aug);
1267               buf += extra_string;
1268               end += extra_string + extra_data;
1269
1270               if (ent->add_augmentation_size)
1271                 {
1272                   *aug++ = 'z';
1273                   *buf++ = extra_data - 1;
1274                 }
1275               if (ent->add_fde_encoding)
1276                 {
1277                   BFD_ASSERT (action & 1);
1278                   *aug++ = 'R';
1279                   *buf++ = DW_EH_PE_pcrel;
1280                   action &= ~1;
1281                 }
1282
1283               while (action)
1284                 switch (*aug++)
1285                   {
1286                   case 'L':
1287                     if (action & 2)
1288                       {
1289                         BFD_ASSERT (*buf == ent->lsda_encoding);
1290                         *buf |= DW_EH_PE_pcrel;
1291                         action &= ~2;
1292                       }
1293                     buf++;
1294                     break;
1295                   case 'P':
1296                     per_encoding = *buf++;
1297                     per_width = get_DW_EH_PE_width (per_encoding, ptr_size);
1298                     BFD_ASSERT (per_width != 0);
1299                     BFD_ASSERT (((per_encoding & 0x70) == DW_EH_PE_pcrel)
1300                                 == ent->per_encoding_relative);
1301                     if ((per_encoding & 0xf0) == DW_EH_PE_aligned)
1302                       buf = (contents
1303                              + ((buf - contents + per_width - 1)
1304                                 & ~((bfd_size_type) per_width - 1)));
1305                     if (action & 4)
1306                       {
1307                         bfd_vma val;
1308
1309                         val = read_value (abfd, buf, per_width,
1310                                           get_DW_EH_PE_signed (per_encoding));
1311                         val += ent->offset - ent->new_offset;
1312                         val -= extra_string + extra_data;
1313                         write_value (abfd, buf, val, per_width);
1314                         action &= ~4;
1315                       }
1316                     buf += per_width;
1317                     break;
1318                   case 'R':
1319                     if (action & 1)
1320                       {
1321                         BFD_ASSERT (*buf == ent->fde_encoding);
1322                         *buf |= DW_EH_PE_pcrel;
1323                         action &= ~1;
1324                       }
1325                     buf++;
1326                     break;
1327                   case 'S':
1328                     break;
1329                   default:
1330                     BFD_FAIL ();
1331                   }
1332             }
1333         }
1334       else
1335         {
1336           /* FDE */
1337           bfd_vma value, address;
1338           unsigned int width;
1339           bfd_byte *start;
1340
1341           /* Skip length.  */
1342           buf += 4;
1343           value = ent->new_offset + 4 - ent->cie_inf->new_offset;
1344           bfd_put_32 (abfd, value, buf);
1345           buf += 4;
1346           width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1347           value = read_value (abfd, buf, width,
1348                               get_DW_EH_PE_signed (ent->fde_encoding));
1349           address = value;
1350           if (value)
1351             {
1352               switch (ent->fde_encoding & 0xf0)
1353                 {
1354                 case DW_EH_PE_indirect:
1355                 case DW_EH_PE_textrel:
1356                   BFD_ASSERT (hdr_info == NULL);
1357                   break;
1358                 case DW_EH_PE_datarel:
1359                   {
1360                     asection *got = bfd_get_section_by_name (abfd, ".got");
1361
1362                     BFD_ASSERT (got != NULL);
1363                     address += got->vma;
1364                   }
1365                   break;
1366                 case DW_EH_PE_pcrel:
1367                   value += ent->offset - ent->new_offset;
1368                   address += sec->output_section->vma + ent->offset + 8;
1369                   break;
1370                 }
1371               if (ent->cie_inf->make_relative)
1372                 value -= sec->output_section->vma + ent->new_offset + 8;
1373               write_value (abfd, buf, value, width);
1374             }
1375
1376           start = buf;
1377
1378           if (hdr_info)
1379             {
1380               hdr_info->array[hdr_info->array_count].initial_loc = address;
1381               hdr_info->array[hdr_info->array_count++].fde
1382                 = sec->output_section->vma + ent->new_offset;
1383             }
1384
1385           if ((ent->lsda_encoding & 0xf0) == DW_EH_PE_pcrel
1386               || ent->cie_inf->need_lsda_relative)
1387             {
1388               buf += ent->lsda_offset;
1389               width = get_DW_EH_PE_width (ent->lsda_encoding, ptr_size);
1390               value = read_value (abfd, buf, width,
1391                                   get_DW_EH_PE_signed (ent->lsda_encoding));
1392               if (value)
1393                 {
1394                   if ((ent->lsda_encoding & 0xf0) == DW_EH_PE_pcrel)
1395                     value += ent->offset - ent->new_offset;
1396                   else if (ent->cie_inf->need_lsda_relative)
1397                     value -= (sec->output_section->vma + ent->new_offset + 8
1398                               + ent->lsda_offset);
1399                   write_value (abfd, buf, value, width);
1400                 }
1401             }
1402           else if (ent->cie_inf->add_augmentation_size)
1403             {
1404               /* Skip the PC and length and insert a zero byte for the
1405                  augmentation size.  */
1406               buf += width * 2;
1407               memmove (buf + 1, buf, end - buf);
1408               *buf = 0;
1409             }
1410
1411           if (ent->set_loc)
1412             {
1413               /* Adjust DW_CFA_set_loc.  */
1414               unsigned int cnt, width;
1415               bfd_vma new_offset;
1416
1417               width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1418               new_offset = ent->new_offset + 8
1419                            + extra_augmentation_string_bytes (ent)
1420                            + extra_augmentation_data_bytes (ent);
1421
1422               for (cnt = 1; cnt <= ent->set_loc[0]; cnt++)
1423                 {
1424                   bfd_vma value;
1425                   buf = start + ent->set_loc[cnt];
1426
1427                   value = read_value (abfd, buf, width,
1428                                       get_DW_EH_PE_signed (ent->fde_encoding));
1429                   if (!value)
1430                     continue;
1431
1432                   if ((ent->fde_encoding & 0xf0) == DW_EH_PE_pcrel)
1433                     value += ent->offset + 8 - new_offset;
1434                   if (ent->cie_inf->make_relative)
1435                     value -= sec->output_section->vma + new_offset
1436                              + ent->set_loc[cnt];
1437                   write_value (abfd, buf, value, width);
1438                 }
1439             }
1440         }
1441     }
1442
1443   /* We don't align the section to its section alignment since the
1444      runtime library only expects all CIE/FDE records aligned at
1445      the pointer size. _bfd_elf_discard_section_eh_frame should
1446      have padded CIE/FDE records to multiple of pointer size with
1447      size_of_output_cie_fde.  */
1448   if ((sec->size % ptr_size) != 0)
1449     abort ();
1450
1451   return bfd_set_section_contents (abfd, sec->output_section,
1452                                    contents, (file_ptr) sec->output_offset,
1453                                    sec->size);
1454 }
1455
1456 /* Helper function used to sort .eh_frame_hdr search table by increasing
1457    VMA of FDE initial location.  */
1458
1459 static int
1460 vma_compare (const void *a, const void *b)
1461 {
1462   const struct eh_frame_array_ent *p = a;
1463   const struct eh_frame_array_ent *q = b;
1464   if (p->initial_loc > q->initial_loc)
1465     return 1;
1466   if (p->initial_loc < q->initial_loc)
1467     return -1;
1468   return 0;
1469 }
1470
1471 /* Write out .eh_frame_hdr section.  This must be called after
1472    _bfd_elf_write_section_eh_frame has been called on all input
1473    .eh_frame sections.
1474    .eh_frame_hdr format:
1475    ubyte version                (currently 1)
1476    ubyte eh_frame_ptr_enc       (DW_EH_PE_* encoding of pointer to start of
1477                                  .eh_frame section)
1478    ubyte fde_count_enc          (DW_EH_PE_* encoding of total FDE count
1479                                  number (or DW_EH_PE_omit if there is no
1480                                  binary search table computed))
1481    ubyte table_enc              (DW_EH_PE_* encoding of binary search table,
1482                                  or DW_EH_PE_omit if not present.
1483                                  DW_EH_PE_datarel is using address of
1484                                  .eh_frame_hdr section start as base)
1485    [encoded] eh_frame_ptr       (pointer to start of .eh_frame section)
1486    optionally followed by:
1487    [encoded] fde_count          (total number of FDEs in .eh_frame section)
1488    fde_count x [encoded] initial_loc, fde
1489                                 (array of encoded pairs containing
1490                                  FDE initial_location field and FDE address,
1491                                  sorted by increasing initial_loc).  */
1492
1493 bfd_boolean
1494 _bfd_elf_write_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
1495 {
1496   struct elf_link_hash_table *htab;
1497   struct eh_frame_hdr_info *hdr_info;
1498   asection *sec;
1499   bfd_byte *contents;
1500   asection *eh_frame_sec;
1501   bfd_size_type size;
1502   bfd_boolean retval;
1503   bfd_vma encoded_eh_frame;
1504
1505   htab = elf_hash_table (info);
1506   hdr_info = &htab->eh_info;
1507   sec = hdr_info->hdr_sec;
1508   if (sec == NULL)
1509     return TRUE;
1510
1511   size = EH_FRAME_HDR_SIZE;
1512   if (hdr_info->array && hdr_info->array_count == hdr_info->fde_count)
1513     size += 4 + hdr_info->fde_count * 8;
1514   contents = bfd_malloc (size);
1515   if (contents == NULL)
1516     return FALSE;
1517
1518   eh_frame_sec = bfd_get_section_by_name (abfd, ".eh_frame");
1519   if (eh_frame_sec == NULL)
1520     {
1521       free (contents);
1522       return FALSE;
1523     }
1524
1525   memset (contents, 0, EH_FRAME_HDR_SIZE);
1526   contents[0] = 1;                              /* Version.  */
1527   contents[1] = get_elf_backend_data (abfd)->elf_backend_encode_eh_address
1528     (abfd, info, eh_frame_sec, 0, sec, 4,
1529      &encoded_eh_frame);                        /* .eh_frame offset.  */
1530
1531   if (hdr_info->array && hdr_info->array_count == hdr_info->fde_count)
1532     {
1533       contents[2] = DW_EH_PE_udata4;            /* FDE count encoding.  */
1534       contents[3] = DW_EH_PE_datarel | DW_EH_PE_sdata4; /* Search table enc.  */
1535     }
1536   else
1537     {
1538       contents[2] = DW_EH_PE_omit;
1539       contents[3] = DW_EH_PE_omit;
1540     }
1541   bfd_put_32 (abfd, encoded_eh_frame, contents + 4);
1542
1543   if (contents[2] != DW_EH_PE_omit)
1544     {
1545       unsigned int i;
1546
1547       bfd_put_32 (abfd, hdr_info->fde_count, contents + EH_FRAME_HDR_SIZE);
1548       qsort (hdr_info->array, hdr_info->fde_count, sizeof (*hdr_info->array),
1549              vma_compare);
1550       for (i = 0; i < hdr_info->fde_count; i++)
1551         {
1552           bfd_put_32 (abfd,
1553                       hdr_info->array[i].initial_loc
1554                       - sec->output_section->vma,
1555                       contents + EH_FRAME_HDR_SIZE + i * 8 + 4);
1556           bfd_put_32 (abfd,
1557                       hdr_info->array[i].fde - sec->output_section->vma,
1558                       contents + EH_FRAME_HDR_SIZE + i * 8 + 8);
1559         }
1560     }
1561
1562   retval = bfd_set_section_contents (abfd, sec->output_section,
1563                                      contents, (file_ptr) sec->output_offset,
1564                                      sec->size);
1565   free (contents);
1566   return retval;
1567 }
1568
1569 /* Return the width of FDE addresses.  This is the default implementation.  */
1570
1571 unsigned int
1572 _bfd_elf_eh_frame_address_size (bfd *abfd, asection *sec ATTRIBUTE_UNUSED)
1573 {
1574   return elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64 ? 8 : 4;
1575 }
1576
1577 /* Decide whether we can use a PC-relative encoding within the given
1578    EH frame section.  This is the default implementation.  */
1579
1580 bfd_boolean
1581 _bfd_elf_can_make_relative (bfd *input_bfd ATTRIBUTE_UNUSED,
1582                             struct bfd_link_info *info ATTRIBUTE_UNUSED,
1583                             asection *eh_frame_section ATTRIBUTE_UNUSED)
1584 {
1585   return TRUE;
1586 }
1587
1588 /* Select an encoding for the given address.  Preference is given to
1589    PC-relative addressing modes.  */
1590
1591 bfd_byte
1592 _bfd_elf_encode_eh_address (bfd *abfd ATTRIBUTE_UNUSED,
1593                             struct bfd_link_info *info ATTRIBUTE_UNUSED,
1594                             asection *osec, bfd_vma offset,
1595                             asection *loc_sec, bfd_vma loc_offset,
1596                             bfd_vma *encoded)
1597 {
1598   *encoded = osec->vma + offset -
1599     (loc_sec->output_section->vma + loc_sec->output_offset + loc_offset);
1600   return DW_EH_PE_pcrel | DW_EH_PE_sdata4;
1601 }