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