bfd/elf-eh-frame.c

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