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