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