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->kept_section != NULL)
 716                                 sym_sec = sym_sec->kept_section;
 717                               if (sym_sec != NULL
 718                                   && sym_sec->output_section != NULL)
 719                                 {
 720                                   val = (sym->st_value
 721                                          + sym_sec->output_offset
 722                                          + sym_sec->output_section->vma);
 723                                   cie->personality.val = val;
 724                                   cie->local_personality = 1;
 725                                 }
 726                             }
 727
 728                           /* Cope with MIPS-style composite relocations.  */
 729                           do
 730                             cookie->rel++;
 731                           while (GET_RELOC (buf) != NULL);
 732                         }
 733                       REQUIRE (skip_bytes (&buf, end, per_width));
 734                       REQUIRE (cie->local_personality || cie->personality.h);
 735                     }
 736                     break;
 737                   default:
 738                     /* Unrecognized augmentation. Better bail out.  */
 739                     goto free_no_table;
 740                   }
 741             }
 742
 743           /* For shared libraries, try to get rid of as many RELATIVE relocs
 744              as possible.  */
 745           if (info->shared
 746               && (get_elf_backend_data (abfd)
 747                   ->elf_backend_can_make_relative_eh_frame
 748                   (abfd, info, sec)))
 749             {
 750               if ((cie->fde_encoding & 0xf0) == DW_EH_PE_absptr)
 751                 cie->make_relative = 1;
 752               /* If the CIE doesn't already have an 'R' entry, it's fairly
 753                  easy to add one, provided that there's no aligned data
 754                  after the augmentation string.  */
 755               else if (cie->fde_encoding == DW_EH_PE_omit
 756                        && (cie->per_encoding & 0xf0) != DW_EH_PE_aligned)
 757                 {
 758                   if (*cie->augmentation == 0)
 759                     this_inf->add_augmentation_size = 1;
 760                   this_inf->add_fde_encoding = 1;
 761                   cie->make_relative = 1;
 762                 }
 763             }
 764
 765           if (info->shared
 766               && (get_elf_backend_data (abfd)
 767                   ->elf_backend_can_make_lsda_relative_eh_frame
 768                   (abfd, info, sec))
 769               && (cie->lsda_encoding & 0xf0) == DW_EH_PE_absptr)
 770             cie->make_lsda_relative = 1;
 771
 772           /* If FDE encoding was not specified, it defaults to
 773              DW_EH_absptr.  */
 774           if (cie->fde_encoding == DW_EH_PE_omit)
 775             cie->fde_encoding = DW_EH_PE_absptr;
 776
 777           initial_insn_length = end - buf;
 778           if (initial_insn_length <= sizeof (cie->initial_instructions))
 779             {
 780               cie->initial_insn_length = initial_insn_length;
 781               memcpy (cie->initial_instructions, buf, initial_insn_length);
 782             }
 783           insns = buf;
 784           buf += initial_insn_length;
 785           ENSURE_NO_RELOCS (buf);
 786         }
 787       else
 788         {
 789           /* Find the corresponding CIE.  */
 790           unsigned int cie_offset = this_inf->offset + 4 - hdr_id;
 791           for (ecie = ecies; ecie < ecies + ecie_count; ++ecie)
 792             if (cie_offset == ecie->offset)
 793               break;
 794
 795           /* Ensure this FDE references one of the CIEs in this input
 796              section.  */
 797           REQUIRE (ecie != ecies + ecie_count);
 798           cie = &ecie->cie;
 799
 800           ENSURE_NO_RELOCS (buf);
 801           REQUIRE (GET_RELOC (buf));
 802
 803           if ((*reloc_symbol_deleted_p) (buf - ehbuf, cookie))
 804             /* This is a FDE against a discarded section.  It should
 805                be deleted.  */
 806             this_inf->removed = 1;
 807           else
 808             {
 809               if (info->shared
 810                   && (((cie->fde_encoding & 0xf0) == DW_EH_PE_absptr
 811                        && cie->make_relative == 0)
 812                       || (cie->fde_encoding & 0xf0) == DW_EH_PE_aligned))
 813                 {
 814                   /* If a shared library uses absolute pointers
 815                      which we cannot turn into PC relative,
 816                      don't create the binary search table,
 817                      since it is affected by runtime relocations.  */
 818                   hdr_info->table = FALSE;
 819                   (*info->callbacks->einfo)
 820                     (_("%P: fde encoding in %B(%A) prevents .eh_frame_hdr"
 821                        " table being created.\n"), abfd, sec);
 822                 }
 823               ecie->usage_count++;
 824               hdr_info->fde_count++;
 825               this_inf->cie_inf = (void *) (ecie - ecies);
 826             }
 827
 828           /* Skip the initial location and address range.  */
 829           start = buf;
 830           length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
 831           REQUIRE (skip_bytes (&buf, end, 2 * length));
 832
 833           /* Skip the augmentation size, if present.  */
 834           if (cie->augmentation[0] == 'z')
 835             REQUIRE (read_uleb128 (&buf, end, &length));
 836           else
 837             length = 0;
 838
 839           /* Of the supported augmentation characters above, only 'L'
 840              adds augmentation data to the FDE.  This code would need to
 841              be adjusted if any future augmentations do the same thing.  */
 842           if (cie->lsda_encoding != DW_EH_PE_omit)
 843             {
 844               this_inf->lsda_offset = buf - start;
 845               /* If there's no 'z' augmentation, we don't know where the
 846                  CFA insns begin.  Assume no padding.  */
 847               if (cie->augmentation[0] != 'z')
 848                 length = end - buf;
 849             }
 850
 851           /* Skip over the augmentation data.  */
 852           REQUIRE (skip_bytes (&buf, end, length));
 853           insns = buf;
 854
 855           buf = last_fde + 4 + hdr_length;
 856           SKIP_RELOCS (buf);
 857         }
 858
 859       /* Try to interpret the CFA instructions and find the first
 860          padding nop.  Shrink this_inf's size so that it doesn't
 861          include the padding.  */
 862       length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
 863       set_loc_count = 0;
 864       insns_end = skip_non_nops (insns, end, length, &set_loc_count);
 865       /* If we don't understand the CFA instructions, we can't know
 866          what needs to be adjusted there.  */
 867       if (insns_end == NULL
 868           /* For the time being we don't support DW_CFA_set_loc in
 869              CIE instructions.  */
 870           || (set_loc_count && this_inf->cie))
 871         goto free_no_table;
 872       this_inf->size -= end - insns_end;
 873       if (insns_end != end && this_inf->cie)
 874         {
 875           cie->initial_insn_length -= end - insns_end;
 876           cie->length -= end - insns_end;
 877         }
 878       if (set_loc_count
 879           && ((cie->fde_encoding & 0xf0) == DW_EH_PE_pcrel
 880               || cie->make_relative))
 881         {
 882           unsigned int cnt;
 883           bfd_byte *p;
 884
 885           this_inf->set_loc = bfd_malloc ((set_loc_count + 1)
 886                                           * sizeof (unsigned int));
 887           REQUIRE (this_inf->set_loc);
 888           this_inf->set_loc[0] = set_loc_count;
 889           p = insns;
 890           cnt = 0;
 891           while (p < end)
 892             {
 893               if (*p == DW_CFA_set_loc)
 894                 this_inf->set_loc[++cnt] = p + 1 - start;
 895               REQUIRE (skip_cfa_op (&p, end, length));
 896             }
 897         }
 898
 899       this_inf->fde_encoding = cie->fde_encoding;
 900       this_inf->lsda_encoding = cie->lsda_encoding;
 901       sec_info->count++;
 902     }
 903
 904   elf_section_data (sec)->sec_info = sec_info;
 905   sec->sec_info_type = ELF_INFO_TYPE_EH_FRAME;
 906
 907   /* Look at all CIEs in this section and determine which can be
 908      removed as unused, which can be merged with previous duplicate
 909      CIEs and which need to be kept.  */
 910   for (ecie = ecies; ecie < ecies + ecie_count; ++ecie)
 911     {
 912       if (ecie->usage_count == 0)
 913         {
 914           sec_info->entry[ecie->entry].removed = 1;
 915           continue;
 916         }
 917       ecie->cie.output_sec = sec->output_section;
 918       ecie->cie.cie_inf = sec_info->entry + ecie->entry;
 919       cie_compute_hash (&ecie->cie);
 920       if (hdr_info->cies != NULL)
 921         {
 922           void **loc = htab_find_slot_with_hash (hdr_info->cies, &ecie->cie,
 923                                                  ecie->cie.hash, INSERT);
 924           if (loc != NULL)
 925             {
 926               if (*loc != HTAB_EMPTY_ENTRY)
 927                 {
 928                   sec_info->entry[ecie->entry].removed = 1;
 929                   ecie->cie.cie_inf = ((struct cie *) *loc)->cie_inf;
 930                   continue;
 931                 }
 932
 933               *loc = malloc (sizeof (struct cie));
 934               if (*loc == NULL)
 935                 *loc = HTAB_DELETED_ENTRY;
 936               else
 937                 memcpy (*loc, &ecie->cie, sizeof (struct cie));
 938             }
 939         }
 940       ecie->cie.cie_inf->make_relative = ecie->cie.make_relative;
 941       ecie->cie.cie_inf->make_lsda_relative = ecie->cie.make_lsda_relative;
 942       ecie->cie.cie_inf->per_encoding_relative
 943         = (ecie->cie.per_encoding & 0x70) == DW_EH_PE_pcrel;
 944     }
 945
 946   /* Ok, now we can assign new offsets.  */
 947   offset = 0;
 948   for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
 949     if (!ent->removed)
 950       {
 951         if (!ent->cie)
 952           {
 953             ecie = ecies + (unsigned long) ent->cie_inf;
 954             ent->cie_inf = ecie->cie.cie_inf;
 955           }
 956         ent->new_offset = offset;
 957         offset += size_of_output_cie_fde (ent, ptr_size);
 958       }
 959
 960   /* Resize the sec as needed.  */
 961   sec->rawsize = sec->size;
 962   sec->size = offset;
 963
 964   free (ehbuf);
 965   if (ecies)
 966     free (ecies);
 967   return offset != sec->rawsize;
 968
 969 free_no_table:
 970   (*info->callbacks->einfo)
 971     (_("%P: error in %B(%A); no .eh_frame_hdr table will be created.\n"),
 972      abfd, sec);
 973   if (ehbuf)
 974     free (ehbuf);
 975   if (sec_info)
 976     free (sec_info);
 977   if (ecies)
 978     free (ecies);
 979   hdr_info->table = FALSE;
 980   return FALSE;
 981
 982 #undef REQUIRE
 983 }
 984
 985 /* This function is called for .eh_frame_hdr section after
 986    _bfd_elf_discard_section_eh_frame has been called on all .eh_frame
 987    input sections.  It finalizes the size of .eh_frame_hdr section.  */
 988
 989 bfd_boolean
 990 _bfd_elf_discard_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
 991 {
 992   struct elf_link_hash_table *htab;
 993   struct eh_frame_hdr_info *hdr_info;
 994   asection *sec;
 995
 996   htab = elf_hash_table (info);
 997   hdr_info = &htab->eh_info;
 998
 999   if (hdr_info->cies != NULL)
1000     {
1001       htab_delete (hdr_info->cies);
1002       hdr_info->cies = NULL;
1003     }
1004
1005   sec = hdr_info->hdr_sec;
1006   if (sec == NULL)
1007     return FALSE;
1008
1009   sec->size = EH_FRAME_HDR_SIZE;
1010   if (hdr_info->table)
1011     sec->size += 4 + hdr_info->fde_count * 8;
1012
1013   elf_tdata (abfd)->eh_frame_hdr = sec;
1014   return TRUE;
1015 }
1016
1017 /* This function is called from size_dynamic_sections.
1018    It needs to decide whether .eh_frame_hdr should be output or not,
1019    because when the dynamic symbol table has been sized it is too late
1020    to strip sections.  */
1021
1022 bfd_boolean
1023 _bfd_elf_maybe_strip_eh_frame_hdr (struct bfd_link_info *info)
1024 {
1025   asection *o;
1026   bfd *abfd;
1027   struct elf_link_hash_table *htab;
1028   struct eh_frame_hdr_info *hdr_info;
1029
1030   htab = elf_hash_table (info);
1031   hdr_info = &htab->eh_info;
1032   if (hdr_info->hdr_sec == NULL)
1033     return TRUE;
1034
1035   if (bfd_is_abs_section (hdr_info->hdr_sec->output_section))
1036     {
1037       hdr_info->hdr_sec = NULL;
1038       return TRUE;
1039     }
1040
1041   abfd = NULL;
1042   if (info->eh_frame_hdr)
1043     for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link_next)
1044       {
1045         /* Count only sections which have at least a single CIE or FDE.
1046            There cannot be any CIE or FDE <= 8 bytes.  */
1047         o = bfd_get_section_by_name (abfd, ".eh_frame");
1048         if (o && o->size > 8 && !bfd_is_abs_section (o->output_section))
1049           break;
1050       }
1051
1052   if (abfd == NULL)
1053     {
1054       hdr_info->hdr_sec->flags |= SEC_EXCLUDE;
1055       hdr_info->hdr_sec = NULL;
1056       return TRUE;
1057     }
1058
1059   hdr_info->table = TRUE;
1060   return TRUE;
1061 }
1062
1063 /* Adjust an address in the .eh_frame section.  Given OFFSET within
1064    SEC, this returns the new offset in the adjusted .eh_frame section,
1065    or -1 if the address refers to a CIE/FDE which has been removed
1066    or to offset with dynamic relocation which is no longer needed.  */
1067
1068 bfd_vma
1069 _bfd_elf_eh_frame_section_offset (bfd *output_bfd ATTRIBUTE_UNUSED,
1070                                   struct bfd_link_info *info,
1071                                   asection *sec,
1072                                   bfd_vma offset)
1073 {
1074   struct eh_frame_sec_info *sec_info;
1075   struct elf_link_hash_table *htab;
1076   struct eh_frame_hdr_info *hdr_info;
1077   unsigned int lo, hi, mid;
1078
1079   if (sec->sec_info_type != ELF_INFO_TYPE_EH_FRAME)
1080     return offset;
1081   sec_info = elf_section_data (sec)->sec_info;
1082
1083   if (offset >= sec->rawsize)
1084     return offset - sec->rawsize + sec->size;
1085
1086   htab = elf_hash_table (info);
1087   hdr_info = &htab->eh_info;
1088   if (hdr_info->offsets_adjusted)
1089     offset += sec->output_offset;
1090
1091   lo = 0;
1092   hi = sec_info->count;
1093   mid = 0;
1094   while (lo < hi)
1095     {
1096       mid = (lo + hi) / 2;
1097       if (offset < sec_info->entry[mid].offset)
1098         hi = mid;
1099       else if (offset
1100                >= sec_info->entry[mid].offset + sec_info->entry[mid].size)
1101         lo = mid + 1;
1102       else
1103         break;
1104     }
1105
1106   BFD_ASSERT (lo < hi);
1107
1108   /* FDE or CIE was removed.  */
1109   if (sec_info->entry[mid].removed)
1110     return (bfd_vma) -1;
1111
1112   /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1113      relocation against FDE's initial_location field.  */
1114   if (!sec_info->entry[mid].cie
1115       && sec_info->entry[mid].cie_inf->make_relative
1116       && offset == sec_info->entry[mid].offset + 8)
1117     return (bfd_vma) -2;
1118
1119   /* If converting LSDA pointers to DW_EH_PE_pcrel, there will be no need
1120      for run-time relocation against LSDA field.  */
1121   if (!sec_info->entry[mid].cie
1122       && sec_info->entry[mid].cie_inf->make_lsda_relative
1123       && (offset == (sec_info->entry[mid].offset + 8
1124                      + sec_info->entry[mid].lsda_offset))
1125       && (sec_info->entry[mid].cie_inf->need_lsda_relative
1126           || !hdr_info->offsets_adjusted))
1127     {
1128       sec_info->entry[mid].cie_inf->need_lsda_relative = 1;
1129       return (bfd_vma) -2;
1130     }
1131
1132   /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1133      relocation against DW_CFA_set_loc's arguments.  */
1134   if (sec_info->entry[mid].set_loc
1135       && (sec_info->entry[mid].cie
1136           ? sec_info->entry[mid].make_relative
1137           : sec_info->entry[mid].cie_inf->make_relative)
1138       && (offset >= sec_info->entry[mid].offset + 8
1139                     + sec_info->entry[mid].set_loc[1]))
1140     {
1141       unsigned int cnt;
1142
1143       for (cnt = 1; cnt <= sec_info->entry[mid].set_loc[0]; cnt++)
1144         if (offset == sec_info->entry[mid].offset + 8
1145                       + sec_info->entry[mid].set_loc[cnt])
1146           return (bfd_vma) -2;
1147     }
1148
1149   if (hdr_info->offsets_adjusted)
1150     offset -= sec->output_offset;
1151   /* Any new augmentation bytes go before the first relocation.  */
1152   return (offset + sec_info->entry[mid].new_offset
1153           - sec_info->entry[mid].offset
1154           + extra_augmentation_string_bytes (sec_info->entry + mid)
1155           + extra_augmentation_data_bytes (sec_info->entry + mid));
1156 }
1157
1158 /* Write out .eh_frame section.  This is called with the relocated
1159    contents.  */
1160
1161 bfd_boolean
1162 _bfd_elf_write_section_eh_frame (bfd *abfd,
1163                                  struct bfd_link_info *info,
1164                                  asection *sec,
1165                                  bfd_byte *contents)
1166 {
1167   struct eh_frame_sec_info *sec_info;
1168   struct elf_link_hash_table *htab;
1169   struct eh_frame_hdr_info *hdr_info;
1170   unsigned int ptr_size;
1171   struct eh_cie_fde *ent;
1172
1173   if (sec->sec_info_type != ELF_INFO_TYPE_EH_FRAME)
1174     return bfd_set_section_contents (abfd, sec->output_section, contents,
1175                                      sec->output_offset, sec->size);
1176
1177   ptr_size = (get_elf_backend_data (abfd)
1178               ->elf_backend_eh_frame_address_size (abfd, sec));
1179   BFD_ASSERT (ptr_size != 0);
1180
1181   sec_info = elf_section_data (sec)->sec_info;
1182   htab = elf_hash_table (info);
1183   hdr_info = &htab->eh_info;
1184
1185   /* First convert all offsets to output section offsets, so that a
1186      CIE offset is valid if the CIE is used by a FDE from some other
1187      section.  This can happen when duplicate CIEs are deleted in
1188      _bfd_elf_discard_section_eh_frame.  We do all sections here because
1189      this function might not be called on sections in the same order as
1190      _bfd_elf_discard_section_eh_frame.  */
1191   if (!hdr_info->offsets_adjusted)
1192     {
1193       bfd *ibfd;
1194       asection *eh;
1195       struct eh_frame_sec_info *eh_inf;
1196
1197       for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
1198         {
1199           if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1200               || (ibfd->flags & DYNAMIC) != 0)
1201             continue;
1202
1203           eh = bfd_get_section_by_name (ibfd, ".eh_frame");
1204           if (eh == NULL || eh->sec_info_type != ELF_INFO_TYPE_EH_FRAME)
1205             continue;
1206
1207           eh_inf = elf_section_data (eh)->sec_info;
1208           for (ent = eh_inf->entry; ent < eh_inf->entry + eh_inf->count; ++ent)
1209             {
1210               ent->offset += eh->output_offset;
1211               ent->new_offset += eh->output_offset;
1212             }
1213         }
1214       hdr_info->offsets_adjusted = TRUE;
1215     }
1216
1217   if (hdr_info->table && hdr_info->array == NULL)
1218     hdr_info->array
1219       = bfd_malloc (hdr_info->fde_count * sizeof(*hdr_info->array));
1220   if (hdr_info->array == NULL)
1221     hdr_info = NULL;
1222
1223   /* The new offsets can be bigger or smaller than the original offsets.
1224      We therefore need to make two passes over the section: one backward
1225      pass to move entries up and one forward pass to move entries down.
1226      The two passes won't interfere with each other because entries are
1227      not reordered  */
1228   for (ent = sec_info->entry + sec_info->count; ent-- != sec_info->entry;)
1229     if (!ent->removed && ent->new_offset > ent->offset)
1230       memmove (contents + ent->new_offset - sec->output_offset,
1231                contents + ent->offset - sec->output_offset, ent->size);
1232
1233   for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1234     if (!ent->removed && ent->new_offset < ent->offset)
1235       memmove (contents + ent->new_offset - sec->output_offset,
1236                contents + ent->offset - sec->output_offset, ent->size);
1237
1238   for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1239     {
1240       unsigned char *buf, *end;
1241       unsigned int new_size;
1242
1243       if (ent->removed)
1244         continue;
1245
1246       if (ent->size == 4)
1247         {
1248           /* Any terminating FDE must be at the end of the section.  */
1249           BFD_ASSERT (ent == sec_info->entry + sec_info->count - 1);
1250           continue;
1251         }
1252
1253       buf = contents + ent->new_offset - sec->output_offset;
1254       end = buf + ent->size;
1255       new_size = size_of_output_cie_fde (ent, ptr_size);
1256
1257       /* Update the size.  It may be shrinked.  */
1258       bfd_put_32 (abfd, new_size - 4, buf);
1259
1260       /* Filling the extra bytes with DW_CFA_nops.  */
1261       if (new_size != ent->size)
1262         memset (end, 0, new_size - ent->size);
1263
1264       if (ent->cie)
1265         {
1266           /* CIE */
1267           if (ent->make_relative
1268               || ent->need_lsda_relative
1269               || ent->per_encoding_relative)
1270             {
1271               char *aug;
1272               unsigned int action, extra_string, extra_data;
1273               unsigned int per_width, per_encoding;
1274
1275               /* Need to find 'R' or 'L' augmentation's argument and modify
1276                  DW_EH_PE_* value.  */
1277               action = ((ent->make_relative ? 1 : 0)
1278                         | (ent->need_lsda_relative ? 2 : 0)
1279                         | (ent->per_encoding_relative ? 4 : 0));
1280               extra_string = extra_augmentation_string_bytes (ent);
1281               extra_data = extra_augmentation_data_bytes (ent);
1282
1283               /* Skip length, id and version.  */
1284               buf += 9;
1285               aug = (char *) buf;
1286               buf += strlen (aug) + 1;
1287               skip_leb128 (&buf, end);
1288               skip_leb128 (&buf, end);
1289               skip_leb128 (&buf, end);
1290               if (*aug == 'z')
1291                 {
1292                   /* The uleb128 will always be a single byte for the kind
1293                      of augmentation strings that we're prepared to handle.  */
1294                   *buf++ += extra_data;
1295                   aug++;
1296                 }
1297
1298               /* Make room for the new augmentation string and data bytes.  */
1299               memmove (buf + extra_string + extra_data, buf, end - buf);
1300               memmove (aug + extra_string, aug, buf - (bfd_byte *) aug);
1301               buf += extra_string;
1302               end += extra_string + extra_data;
1303
1304               if (ent->add_augmentation_size)
1305                 {
1306                   *aug++ = 'z';
1307                   *buf++ = extra_data - 1;
1308                 }
1309               if (ent->add_fde_encoding)
1310                 {
1311                   BFD_ASSERT (action & 1);
1312                   *aug++ = 'R';
1313                   *buf++ = DW_EH_PE_pcrel;
1314                   action &= ~1;
1315                 }
1316
1317               while (action)
1318                 switch (*aug++)
1319                   {
1320                   case 'L':
1321                     if (action & 2)
1322                       {
1323                         BFD_ASSERT (*buf == ent->lsda_encoding);
1324                         *buf |= DW_EH_PE_pcrel;
1325                         action &= ~2;
1326                       }
1327                     buf++;
1328                     break;
1329                   case 'P':
1330                     per_encoding = *buf++;
1331                     per_width = get_DW_EH_PE_width (per_encoding, ptr_size);
1332                     BFD_ASSERT (per_width != 0);
1333                     BFD_ASSERT (((per_encoding & 0x70) == DW_EH_PE_pcrel)
1334                                 == ent->per_encoding_relative);
1335                     if ((per_encoding & 0xf0) == DW_EH_PE_aligned)
1336                       buf = (contents
1337                              + ((buf - contents + per_width - 1)
1338                                 & ~((bfd_size_type) per_width - 1)));
1339                     if (action & 4)
1340                       {
1341                         bfd_vma val;
1342
1343                         val = read_value (abfd, buf, per_width,
1344                                           get_DW_EH_PE_signed (per_encoding));
1345                         val += ent->offset - ent->new_offset;
1346                         val -= extra_string + extra_data;
1347                         write_value (abfd, buf, val, per_width);
1348                         action &= ~4;
1349                       }
1350                     buf += per_width;
1351                     break;
1352                   case 'R':
1353                     if (action & 1)
1354                       {
1355                         BFD_ASSERT (*buf == ent->fde_encoding);
1356                         *buf |= DW_EH_PE_pcrel;
1357                         action &= ~1;
1358                       }
1359                     buf++;
1360                     break;
1361                   case 'S':
1362                     break;
1363                   default:
1364                     BFD_FAIL ();
1365                   }
1366             }
1367         }
1368       else
1369         {
1370           /* FDE */
1371           bfd_vma value, address;
1372           unsigned int width;
1373           bfd_byte *start;
1374
1375           /* Skip length.  */
1376           buf += 4;
1377           value = ent->new_offset + 4 - ent->cie_inf->new_offset;
1378           bfd_put_32 (abfd, value, buf);
1379           buf += 4;
1380           width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1381           value = read_value (abfd, buf, width,
1382                               get_DW_EH_PE_signed (ent->fde_encoding));
1383           address = value;
1384           if (value)
1385             {
1386               switch (ent->fde_encoding & 0xf0)
1387                 {
1388                 case DW_EH_PE_indirect:
1389                 case DW_EH_PE_textrel:
1390                   BFD_ASSERT (hdr_info == NULL);
1391                   break;
1392                 case DW_EH_PE_datarel:
1393                   {
1394                     asection *got = bfd_get_section_by_name (abfd, ".got");
1395
1396                     BFD_ASSERT (got != NULL);
1397                     address += got->vma;
1398                   }
1399                   break;
1400                 case DW_EH_PE_pcrel:
1401                   value += ent->offset - ent->new_offset;
1402                   address += sec->output_section->vma + ent->offset + 8;
1403                   break;
1404                 }
1405               if (ent->cie_inf->make_relative)
1406                 value -= sec->output_section->vma + ent->new_offset + 8;
1407               write_value (abfd, buf, value, width);
1408             }
1409
1410           start = buf;
1411
1412           if (hdr_info)
1413             {
1414               hdr_info->array[hdr_info->array_count].initial_loc = address;
1415               hdr_info->array[hdr_info->array_count++].fde
1416                 = sec->output_section->vma + ent->new_offset;
1417             }
1418
1419           if ((ent->lsda_encoding & 0xf0) == DW_EH_PE_pcrel
1420               || ent->cie_inf->need_lsda_relative)
1421             {
1422               buf += ent->lsda_offset;
1423               width = get_DW_EH_PE_width (ent->lsda_encoding, ptr_size);
1424               value = read_value (abfd, buf, width,
1425                                   get_DW_EH_PE_signed (ent->lsda_encoding));
1426               if (value)
1427                 {
1428                   if ((ent->lsda_encoding & 0xf0) == DW_EH_PE_pcrel)
1429                     value += ent->offset - ent->new_offset;
1430                   else if (ent->cie_inf->need_lsda_relative)
1431                     value -= (sec->output_section->vma + ent->new_offset + 8
1432                               + ent->lsda_offset);
1433                   write_value (abfd, buf, value, width);
1434                 }
1435             }
1436           else if (ent->cie_inf->add_augmentation_size)
1437             {
1438               /* Skip the PC and length and insert a zero byte for the
1439                  augmentation size.  */
1440               buf += width * 2;
1441               memmove (buf + 1, buf, end - buf);
1442               *buf = 0;
1443             }
1444
1445           if (ent->set_loc)
1446             {
1447               /* Adjust DW_CFA_set_loc.  */
1448               unsigned int cnt, width;
1449               bfd_vma new_offset;
1450
1451               width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1452               new_offset = ent->new_offset + 8
1453                            + extra_augmentation_string_bytes (ent)
1454                            + extra_augmentation_data_bytes (ent);
1455
1456               for (cnt = 1; cnt <= ent->set_loc[0]; cnt++)
1457                 {
1458                   bfd_vma value;
1459                   buf = start + ent->set_loc[cnt];
1460
1461                   value = read_value (abfd, buf, width,
1462                                       get_DW_EH_PE_signed (ent->fde_encoding));
1463                   if (!value)
1464                     continue;
1465
1466                   if ((ent->fde_encoding & 0xf0) == DW_EH_PE_pcrel)
1467                     value += ent->offset + 8 - new_offset;
1468                   if (ent->cie_inf->make_relative)
1469                     value -= sec->output_section->vma + new_offset
1470                              + ent->set_loc[cnt];
1471                   write_value (abfd, buf, value, width);
1472                 }
1473             }
1474         }
1475     }
1476
1477   /* We don't align the section to its section alignment since the
1478      runtime library only expects all CIE/FDE records aligned at
1479      the pointer size. _bfd_elf_discard_section_eh_frame should
1480      have padded CIE/FDE records to multiple of pointer size with
1481      size_of_output_cie_fde.  */
1482   if ((sec->size % ptr_size) != 0)
1483     abort ();
1484
1485   return bfd_set_section_contents (abfd, sec->output_section,
1486                                    contents, (file_ptr) sec->output_offset,
1487                                    sec->size);
1488 }
1489
1490 /* Helper function used to sort .eh_frame_hdr search table by increasing
1491    VMA of FDE initial location.  */
1492
1493 static int
1494 vma_compare (const void *a, const void *b)
1495 {
1496   const struct eh_frame_array_ent *p = a;
1497   const struct eh_frame_array_ent *q = b;
1498   if (p->initial_loc > q->initial_loc)
1499     return 1;
1500   if (p->initial_loc < q->initial_loc)
1501     return -1;
1502   return 0;
1503 }
1504
1505 /* Write out .eh_frame_hdr section.  This must be called after
1506    _bfd_elf_write_section_eh_frame has been called on all input
1507    .eh_frame sections.
1508    .eh_frame_hdr format:
1509    ubyte version                (currently 1)
1510    ubyte eh_frame_ptr_enc       (DW_EH_PE_* encoding of pointer to start of
1511                                  .eh_frame section)
1512    ubyte fde_count_enc          (DW_EH_PE_* encoding of total FDE count
1513                                  number (or DW_EH_PE_omit if there is no
1514                                  binary search table computed))
1515    ubyte table_enc              (DW_EH_PE_* encoding of binary search table,
1516                                  or DW_EH_PE_omit if not present.
1517                                  DW_EH_PE_datarel is using address of
1518                                  .eh_frame_hdr section start as base)
1519    [encoded] eh_frame_ptr       (pointer to start of .eh_frame section)
1520    optionally followed by:
1521    [encoded] fde_count          (total number of FDEs in .eh_frame section)
1522    fde_count x [encoded] initial_loc, fde
1523                                 (array of encoded pairs containing
1524                                  FDE initial_location field and FDE address,
1525                                  sorted by increasing initial_loc).  */
1526
1527 bfd_boolean
1528 _bfd_elf_write_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
1529 {
1530   struct elf_link_hash_table *htab;
1531   struct eh_frame_hdr_info *hdr_info;
1532   asection *sec;
1533   bfd_byte *contents;
1534   asection *eh_frame_sec;
1535   bfd_size_type size;
1536   bfd_boolean retval;
1537   bfd_vma encoded_eh_frame;
1538
1539   htab = elf_hash_table (info);
1540   hdr_info = &htab->eh_info;
1541   sec = hdr_info->hdr_sec;
1542   if (sec == NULL)
1543     return TRUE;
1544
1545   size = EH_FRAME_HDR_SIZE;
1546   if (hdr_info->array && hdr_info->array_count == hdr_info->fde_count)
1547     size += 4 + hdr_info->fde_count * 8;
1548   contents = bfd_malloc (size);
1549   if (contents == NULL)
1550     return FALSE;
1551
1552   eh_frame_sec = bfd_get_section_by_name (abfd, ".eh_frame");
1553   if (eh_frame_sec == NULL)
1554     {
1555       free (contents);
1556       return FALSE;
1557     }
1558
1559   memset (contents, 0, EH_FRAME_HDR_SIZE);
1560   contents[0] = 1;                              /* Version.  */
1561   contents[1] = get_elf_backend_data (abfd)->elf_backend_encode_eh_address
1562     (abfd, info, eh_frame_sec, 0, sec, 4,
1563      &encoded_eh_frame);                        /* .eh_frame offset.  */
1564
1565   if (hdr_info->array && hdr_info->array_count == hdr_info->fde_count)
1566     {
1567       contents[2] = DW_EH_PE_udata4;            /* FDE count encoding.  */
1568       contents[3] = DW_EH_PE_datarel | DW_EH_PE_sdata4; /* Search table enc.  */
1569     }
1570   else
1571     {
1572       contents[2] = DW_EH_PE_omit;
1573       contents[3] = DW_EH_PE_omit;
1574     }
1575   bfd_put_32 (abfd, encoded_eh_frame, contents + 4);
1576
1577   if (contents[2] != DW_EH_PE_omit)
1578     {
1579       unsigned int i;
1580
1581       bfd_put_32 (abfd, hdr_info->fde_count, contents + EH_FRAME_HDR_SIZE);
1582       qsort (hdr_info->array, hdr_info->fde_count, sizeof (*hdr_info->array),
1583              vma_compare);
1584       for (i = 0; i < hdr_info->fde_count; i++)
1585         {
1586           bfd_put_32 (abfd,
1587                       hdr_info->array[i].initial_loc
1588                       - sec->output_section->vma,
1589                       contents + EH_FRAME_HDR_SIZE + i * 8 + 4);
1590           bfd_put_32 (abfd,
1591                       hdr_info->array[i].fde - sec->output_section->vma,
1592                       contents + EH_FRAME_HDR_SIZE + i * 8 + 8);
1593         }
1594     }
1595
1596   retval = bfd_set_section_contents (abfd, sec->output_section,
1597                                      contents, (file_ptr) sec->output_offset,
1598                                      sec->size);
1599   free (contents);
1600   return retval;
1601 }
1602
1603 /* Return the width of FDE addresses.  This is the default implementation.  */
1604
1605 unsigned int
1606 _bfd_elf_eh_frame_address_size (bfd *abfd, asection *sec ATTRIBUTE_UNUSED)
1607 {
1608   return elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64 ? 8 : 4;
1609 }
1610
1611 /* Decide whether we can use a PC-relative encoding within the given
1612    EH frame section.  This is the default implementation.  */
1613
1614 bfd_boolean
1615 _bfd_elf_can_make_relative (bfd *input_bfd ATTRIBUTE_UNUSED,
1616                             struct bfd_link_info *info ATTRIBUTE_UNUSED,
1617                             asection *eh_frame_section ATTRIBUTE_UNUSED)
1618 {
1619   return TRUE;
1620 }
1621
1622 /* Select an encoding for the given address.  Preference is given to
1623    PC-relative addressing modes.  */
1624
1625 bfd_byte
1626 _bfd_elf_encode_eh_address (bfd *abfd ATTRIBUTE_UNUSED,
1627                             struct bfd_link_info *info ATTRIBUTE_UNUSED,
1628                             asection *osec, bfd_vma offset,
1629                             asection *loc_sec, bfd_vma loc_offset,
1630                             bfd_vma *encoded)
1631 {
1632   *encoded = osec->vma + offset -
1633     (loc_sec->output_section->vma + loc_sec->output_offset + loc_offset);
1634   return DW_EH_PE_pcrel | DW_EH_PE_sdata4;
1635 }