bfd/elf-eh-frame.c

   1 /* .eh_frame section optimization.
   2    Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
   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 "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     unsigned int reloc_index;
  46   } personality;
  47   asection *output_sec;
  48   struct eh_cie_fde *cie_inf;
  49   unsigned char per_encoding;
  50   unsigned char lsda_encoding;
  51   unsigned char fde_encoding;
  52   unsigned char initial_insn_length;
  53   unsigned char can_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 = (const struct cie *) e1;
 219   const struct cie *c2 = (const struct cie *) 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 = (const struct cie *) 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->u.cie.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->add_augmentation_size)
 299     size++;
 300   if (entry->cie && entry->u.cie.add_fde_encoding)
 301     size++;
 302   return size;
 303 }
 304
 305 /* Return the size that ENTRY will have in the output.  ALIGNMENT is the
 306    required alignment of ENTRY in bytes.  */
 307
 308 static unsigned int
 309 size_of_output_cie_fde (struct eh_cie_fde *entry, unsigned int alignment)
 310 {
 311   if (entry->removed)
 312     return 0;
 313   if (entry->size == 4)
 314     return 4;
 315   return (entry->size
 316           + extra_augmentation_string_bytes (entry)
 317           + extra_augmentation_data_bytes (entry)
 318           + alignment - 1) & -alignment;
 319 }
 320
 321 /* Assume that the bytes between *ITER and END are CFA instructions.
 322    Try to move *ITER past the first instruction and return true on
 323    success.  ENCODED_PTR_WIDTH gives the width of pointer entries.  */
 324
 325 static bfd_boolean
 326 skip_cfa_op (bfd_byte **iter, bfd_byte *end, unsigned int encoded_ptr_width)
 327 {
 328   bfd_byte op;
 329   bfd_vma length;
 330
 331   if (!read_byte (iter, end, &op))
 332     return FALSE;
 333
 334   switch (op & 0xc0 ? op & 0xc0 : op)
 335     {
 336     case DW_CFA_nop:
 337     case DW_CFA_advance_loc:
 338     case DW_CFA_restore:
 339     case DW_CFA_remember_state:
 340     case DW_CFA_restore_state:
 341     case DW_CFA_GNU_window_save:
 342       /* No arguments.  */
 343       return TRUE;
 344
 345     case DW_CFA_offset:
 346     case DW_CFA_restore_extended:
 347     case DW_CFA_undefined:
 348     case DW_CFA_same_value:
 349     case DW_CFA_def_cfa_register:
 350     case DW_CFA_def_cfa_offset:
 351     case DW_CFA_def_cfa_offset_sf:
 352     case DW_CFA_GNU_args_size:
 353       /* One leb128 argument.  */
 354       return skip_leb128 (iter, end);
 355
 356     case DW_CFA_val_offset:
 357     case DW_CFA_val_offset_sf:
 358     case DW_CFA_offset_extended:
 359     case DW_CFA_register:
 360     case DW_CFA_def_cfa:
 361     case DW_CFA_offset_extended_sf:
 362     case DW_CFA_GNU_negative_offset_extended:
 363     case DW_CFA_def_cfa_sf:
 364       /* Two leb128 arguments.  */
 365       return (skip_leb128 (iter, end)
 366               && skip_leb128 (iter, end));
 367
 368     case DW_CFA_def_cfa_expression:
 369       /* A variable-length argument.  */
 370       return (read_uleb128 (iter, end, &length)
 371               && skip_bytes (iter, end, length));
 372
 373     case DW_CFA_expression:
 374     case DW_CFA_val_expression:
 375       /* A leb128 followed by a variable-length argument.  */
 376       return (skip_leb128 (iter, end)
 377               && read_uleb128 (iter, end, &length)
 378               && skip_bytes (iter, end, length));
 379
 380     case DW_CFA_set_loc:
 381       return skip_bytes (iter, end, encoded_ptr_width);
 382
 383     case DW_CFA_advance_loc1:
 384       return skip_bytes (iter, end, 1);
 385
 386     case DW_CFA_advance_loc2:
 387       return skip_bytes (iter, end, 2);
 388
 389     case DW_CFA_advance_loc4:
 390       return skip_bytes (iter, end, 4);
 391
 392     case DW_CFA_MIPS_advance_loc8:
 393       return skip_bytes (iter, end, 8);
 394
 395     default:
 396       return FALSE;
 397     }
 398 }
 399
 400 /* Try to interpret the bytes between BUF and END as CFA instructions.
 401    If every byte makes sense, return a pointer to the first DW_CFA_nop
 402    padding byte, or END if there is no padding.  Return null otherwise.
 403    ENCODED_PTR_WIDTH is as for skip_cfa_op.  */
 404
 405 static bfd_byte *
 406 skip_non_nops (bfd_byte *buf, bfd_byte *end, unsigned int encoded_ptr_width,
 407                unsigned int *set_loc_count)
 408 {
 409   bfd_byte *last;
 410
 411   last = buf;
 412   while (buf < end)
 413     if (*buf == DW_CFA_nop)
 414       buf++;
 415     else
 416       {
 417         if (*buf == DW_CFA_set_loc)
 418           ++*set_loc_count;
 419         if (!skip_cfa_op (&buf, end, encoded_ptr_width))
 420           return 0;
 421         last = buf;
 422       }
 423   return last;
 424 }
 425
 426 /* Called before calling _bfd_elf_parse_eh_frame on every input bfd's
 427    .eh_frame section.  */
 428
 429 void
 430 _bfd_elf_begin_eh_frame_parsing (struct bfd_link_info *info)
 431 {
 432   struct eh_frame_hdr_info *hdr_info;
 433
 434   hdr_info = &elf_hash_table (info)->eh_info;
 435   hdr_info->merge_cies = !info->relocatable;
 436 }
 437
 438 /* Try to parse .eh_frame section SEC, which belongs to ABFD.  Store the
 439    information in the section's sec_info field on success.  COOKIE
 440    describes the relocations in SEC.  */
 441
 442 void
 443 _bfd_elf_parse_eh_frame (bfd *abfd, struct bfd_link_info *info,
 444                          asection *sec, struct elf_reloc_cookie *cookie)
 445 {
 446 #define REQUIRE(COND)                                   \
 447   do                                                    \
 448     if (!(COND))                                        \
 449       goto free_no_table;                               \
 450   while (0)
 451
 452   bfd_byte *ehbuf = NULL, *buf, *end;
 453   bfd_byte *last_fde;
 454   struct eh_cie_fde *this_inf;
 455   unsigned int hdr_length, hdr_id;
 456   unsigned int cie_count;
 457   struct cie *cie, *local_cies = NULL;
 458   struct elf_link_hash_table *htab;
 459   struct eh_frame_hdr_info *hdr_info;
 460   struct eh_frame_sec_info *sec_info = NULL;
 461   unsigned int ptr_size;
 462   unsigned int num_cies;
 463   unsigned int num_entries;
 464   elf_gc_mark_hook_fn gc_mark_hook;
 465
 466   htab = elf_hash_table (info);
 467   hdr_info = &htab->eh_info;
 468   if (hdr_info->parsed_eh_frames)
 469     return;
 470
 471   if (sec->size == 0)
 472     {
 473       /* This file does not contain .eh_frame information.  */
 474       return;
 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;
 482     }
 483
 484   /* Read the frame unwind information from abfd.  */
 485
 486   REQUIRE (bfd_malloc_and_get_section (abfd, sec, &ehbuf));
 487
 488   if (sec->size >= 4
 489       && bfd_get_32 (abfd, ehbuf) == 0
 490       && cookie->rel == cookie->relend)
 491     {
 492       /* Empty .eh_frame section.  */
 493       free (ehbuf);
 494       return;
 495     }
 496
 497   /* If .eh_frame section size doesn't fit into int, we cannot handle
 498      it (it would need to use 64-bit .eh_frame format anyway).  */
 499   REQUIRE (sec->size == (unsigned int) sec->size);
 500
 501   ptr_size = (get_elf_backend_data (abfd)
 502               ->elf_backend_eh_frame_address_size (abfd, sec));
 503   REQUIRE (ptr_size != 0);
 504
 505   /* Go through the section contents and work out how many FDEs and
 506      CIEs there are.  */
 507   buf = ehbuf;
 508   end = ehbuf + sec->size;
 509   num_cies = 0;
 510   num_entries = 0;
 511   while (buf != end)
 512     {
 513       num_entries++;
 514
 515       /* Read the length of the entry.  */
 516       REQUIRE (skip_bytes (&buf, end, 4));
 517       hdr_length = bfd_get_32 (abfd, buf - 4);
 518
 519       /* 64-bit .eh_frame is not supported.  */
 520       REQUIRE (hdr_length != 0xffffffff);
 521       if (hdr_length == 0)
 522         break;
 523
 524       REQUIRE (skip_bytes (&buf, end, 4));
 525       hdr_id = bfd_get_32 (abfd, buf - 4);
 526       if (hdr_id == 0)
 527         num_cies++;
 528
 529       REQUIRE (skip_bytes (&buf, end, hdr_length - 4));
 530     }
 531
 532   sec_info = (struct eh_frame_sec_info *)
 533       bfd_zmalloc (sizeof (struct eh_frame_sec_info)
 534                    + (num_entries - 1) * sizeof (struct eh_cie_fde));
 535   REQUIRE (sec_info);
 536
 537   /* We need to have a "struct cie" for each CIE in this section.  */
 538   local_cies = (struct cie *) bfd_zmalloc (num_cies * sizeof (*local_cies));
 539   REQUIRE (local_cies);
 540
 541   /* FIXME: octets_per_byte.  */
 542 #define ENSURE_NO_RELOCS(buf)                           \
 543   REQUIRE (!(cookie->rel < cookie->relend               \
 544              && (cookie->rel->r_offset                  \
 545                  < (bfd_size_type) ((buf) - ehbuf))     \
 546              && cookie->rel->r_info != 0))
 547
 548   /* FIXME: octets_per_byte.  */
 549 #define SKIP_RELOCS(buf)                                \
 550   while (cookie->rel < cookie->relend                   \
 551          && (cookie->rel->r_offset                      \
 552              < (bfd_size_type) ((buf) - ehbuf)))        \
 553     cookie->rel++
 554
 555   /* FIXME: octets_per_byte.  */
 556 #define GET_RELOC(buf)                                  \
 557   ((cookie->rel < cookie->relend                        \
 558     && (cookie->rel->r_offset                           \
 559         == (bfd_size_type) ((buf) - ehbuf)))            \
 560    ? cookie->rel : NULL)
 561
 562   buf = ehbuf;
 563   cie_count = 0;
 564   gc_mark_hook = get_elf_backend_data (abfd)->gc_mark_hook;
 565   while ((bfd_size_type) (buf - ehbuf) != sec->size)
 566     {
 567       char *aug;
 568       bfd_byte *start, *insns, *insns_end;
 569       bfd_size_type length;
 570       unsigned int set_loc_count;
 571
 572       this_inf = sec_info->entry + sec_info->count;
 573       last_fde = buf;
 574
 575       /* Read the length of the entry.  */
 576       REQUIRE (skip_bytes (&buf, ehbuf + sec->size, 4));
 577       hdr_length = bfd_get_32 (abfd, buf - 4);
 578
 579       /* The CIE/FDE must be fully contained in this input section.  */
 580       REQUIRE ((bfd_size_type) (buf - ehbuf) + hdr_length <= sec->size);
 581       end = buf + hdr_length;
 582
 583       this_inf->offset = last_fde - ehbuf;
 584       this_inf->size = 4 + hdr_length;
 585       this_inf->reloc_index = cookie->rel - cookie->rels;
 586
 587       if (hdr_length == 0)
 588         {
 589           /* A zero-length CIE should only be found at the end of
 590              the section.  */
 591           REQUIRE ((bfd_size_type) (buf - ehbuf) == sec->size);
 592           ENSURE_NO_RELOCS (buf);
 593           sec_info->count++;
 594           break;
 595         }
 596
 597       REQUIRE (skip_bytes (&buf, end, 4));
 598       hdr_id = bfd_get_32 (abfd, buf - 4);
 599
 600       if (hdr_id == 0)
 601         {
 602           unsigned int initial_insn_length;
 603
 604           /* CIE  */
 605           this_inf->cie = 1;
 606
 607           /* Point CIE to one of the section-local cie structures.  */
 608           cie = local_cies + cie_count++;
 609
 610           cie->cie_inf = this_inf;
 611           cie->length = hdr_length;
 612           cie->output_sec = sec->output_section;
 613           start = buf;
 614           REQUIRE (read_byte (&buf, end, &cie->version));
 615
 616           /* Cannot handle unknown versions.  */
 617           REQUIRE (cie->version == 1 || cie->version == 3);
 618           REQUIRE (strlen ((char *) buf) < sizeof (cie->augmentation));
 619
 620           strcpy (cie->augmentation, (char *) buf);
 621           buf = (bfd_byte *) strchr ((char *) buf, '\0') + 1;
 622           ENSURE_NO_RELOCS (buf);
 623           if (buf[0] == 'e' && buf[1] == 'h')
 624             {
 625               /* GCC < 3.0 .eh_frame CIE */
 626               /* We cannot merge "eh" CIEs because __EXCEPTION_TABLE__
 627                  is private to each CIE, so we don't need it for anything.
 628                  Just skip it.  */
 629               REQUIRE (skip_bytes (&buf, end, ptr_size));
 630               SKIP_RELOCS (buf);
 631             }
 632           REQUIRE (read_uleb128 (&buf, end, &cie->code_align));
 633           REQUIRE (read_sleb128 (&buf, end, &cie->data_align));
 634           if (cie->version == 1)
 635             {
 636               REQUIRE (buf < end);
 637               cie->ra_column = *buf++;
 638             }
 639           else
 640             REQUIRE (read_uleb128 (&buf, end, &cie->ra_column));
 641           ENSURE_NO_RELOCS (buf);
 642           cie->lsda_encoding = DW_EH_PE_omit;
 643           cie->fde_encoding = DW_EH_PE_omit;
 644           cie->per_encoding = DW_EH_PE_omit;
 645           aug = cie->augmentation;
 646           if (aug[0] != 'e' || aug[1] != 'h')
 647             {
 648               if (*aug == 'z')
 649                 {
 650                   aug++;
 651                   REQUIRE (read_uleb128 (&buf, end, &cie->augmentation_size));
 652                   ENSURE_NO_RELOCS (buf);
 653                 }
 654
 655               while (*aug != '\0')
 656                 switch (*aug++)
 657                   {
 658                   case 'L':
 659                     REQUIRE (read_byte (&buf, end, &cie->lsda_encoding));
 660                     ENSURE_NO_RELOCS (buf);
 661                     REQUIRE (get_DW_EH_PE_width (cie->lsda_encoding, ptr_size));
 662                     break;
 663                   case 'R':
 664                     REQUIRE (read_byte (&buf, end, &cie->fde_encoding));
 665                     ENSURE_NO_RELOCS (buf);
 666                     REQUIRE (get_DW_EH_PE_width (cie->fde_encoding, ptr_size));
 667                     break;
 668                   case 'S':
 669                     break;
 670                   case 'P':
 671                     {
 672                       int per_width;
 673
 674                       REQUIRE (read_byte (&buf, end, &cie->per_encoding));
 675                       per_width = get_DW_EH_PE_width (cie->per_encoding,
 676                                                       ptr_size);
 677                       REQUIRE (per_width);
 678                       if ((cie->per_encoding & 0x70) == DW_EH_PE_aligned)
 679                         {
 680                           length = -(buf - ehbuf) & (per_width - 1);
 681                           REQUIRE (skip_bytes (&buf, end, length));
 682                         }
 683                       this_inf->u.cie.personality_offset = buf - start;
 684                       ENSURE_NO_RELOCS (buf);
 685                       /* Ensure we have a reloc here.  */
 686                       REQUIRE (GET_RELOC (buf));
 687                       cie->personality.reloc_index
 688                         = cookie->rel - cookie->rels;
 689                       /* Cope with MIPS-style composite relocations.  */
 690                       do
 691                         cookie->rel++;
 692                       while (GET_RELOC (buf) != NULL);
 693                       REQUIRE (skip_bytes (&buf, end, per_width));
 694                     }
 695                     break;
 696                   default:
 697                     /* Unrecognized augmentation. Better bail out.  */
 698                     goto free_no_table;
 699                   }
 700             }
 701
 702           /* For shared libraries, try to get rid of as many RELATIVE relocs
 703              as possible.  */
 704           if (info->shared
 705               && (get_elf_backend_data (abfd)
 706                   ->elf_backend_can_make_relative_eh_frame
 707                   (abfd, info, sec)))
 708             {
 709               if ((cie->fde_encoding & 0x70) == DW_EH_PE_absptr)
 710                 this_inf->make_relative = 1;
 711               /* If the CIE doesn't already have an 'R' entry, it's fairly
 712                  easy to add one, provided that there's no aligned data
 713                  after the augmentation string.  */
 714               else if (cie->fde_encoding == DW_EH_PE_omit
 715                        && (cie->per_encoding & 0x70) != DW_EH_PE_aligned)
 716                 {
 717                   if (*cie->augmentation == 0)
 718                     this_inf->add_augmentation_size = 1;
 719                   this_inf->u.cie.add_fde_encoding = 1;
 720                   this_inf->make_relative = 1;
 721                 }
 722
 723               if ((cie->lsda_encoding & 0x70) == DW_EH_PE_absptr)
 724                 cie->can_make_lsda_relative = 1;
 725             }
 726
 727           /* If FDE encoding was not specified, it defaults to
 728              DW_EH_absptr.  */
 729           if (cie->fde_encoding == DW_EH_PE_omit)
 730             cie->fde_encoding = DW_EH_PE_absptr;
 731
 732           initial_insn_length = end - buf;
 733           if (initial_insn_length <= sizeof (cie->initial_instructions))
 734             {
 735               cie->initial_insn_length = initial_insn_length;
 736               memcpy (cie->initial_instructions, buf, initial_insn_length);
 737             }
 738           insns = buf;
 739           buf += initial_insn_length;
 740           ENSURE_NO_RELOCS (buf);
 741
 742           if (hdr_info->merge_cies)
 743             this_inf->u.cie.u.full_cie = cie;
 744           this_inf->u.cie.per_encoding_relative
 745             = (cie->per_encoding & 0x70) == DW_EH_PE_pcrel;
 746         }
 747       else
 748         {
 749           asection *rsec;
 750
 751           /* Find the corresponding CIE.  */
 752           unsigned int cie_offset = this_inf->offset + 4 - hdr_id;
 753           for (cie = local_cies; cie < local_cies + cie_count; cie++)
 754             if (cie_offset == cie->cie_inf->offset)
 755               break;
 756
 757           /* Ensure this FDE references one of the CIEs in this input
 758              section.  */
 759           REQUIRE (cie != local_cies + cie_count);
 760           this_inf->u.fde.cie_inf = cie->cie_inf;
 761           this_inf->make_relative = cie->cie_inf->make_relative;
 762           this_inf->add_augmentation_size
 763             = cie->cie_inf->add_augmentation_size;
 764
 765           ENSURE_NO_RELOCS (buf);
 766           REQUIRE (GET_RELOC (buf));
 767
 768           /* Chain together the FDEs for each section.  */
 769           rsec = _bfd_elf_gc_mark_rsec (info, sec, gc_mark_hook, cookie);
 770           /* RSEC will be NULL if FDE was cleared out as it was belonging to
 771              a discarded SHT_GROUP.  */
 772           if (rsec)
 773             {
 774               REQUIRE (rsec->owner == abfd);
 775               this_inf->u.fde.next_for_section = elf_fde_list (rsec);
 776               elf_fde_list (rsec) = this_inf;
 777             }
 778
 779           /* Skip the initial location and address range.  */
 780           start = buf;
 781           length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
 782           REQUIRE (skip_bytes (&buf, end, 2 * length));
 783
 784           /* Skip the augmentation size, if present.  */
 785           if (cie->augmentation[0] == 'z')
 786             REQUIRE (read_uleb128 (&buf, end, &length));
 787           else
 788             length = 0;
 789
 790           /* Of the supported augmentation characters above, only 'L'
 791              adds augmentation data to the FDE.  This code would need to
 792              be adjusted if any future augmentations do the same thing.  */
 793           if (cie->lsda_encoding != DW_EH_PE_omit)
 794             {
 795               SKIP_RELOCS (buf);
 796               if (cie->can_make_lsda_relative && GET_RELOC (buf))
 797                 cie->cie_inf->u.cie.make_lsda_relative = 1;
 798               this_inf->lsda_offset = buf - start;
 799               /* If there's no 'z' augmentation, we don't know where the
 800                  CFA insns begin.  Assume no padding.  */
 801               if (cie->augmentation[0] != 'z')
 802                 length = end - buf;
 803             }
 804
 805           /* Skip over the augmentation data.  */
 806           REQUIRE (skip_bytes (&buf, end, length));
 807           insns = buf;
 808
 809           buf = last_fde + 4 + hdr_length;
 810
 811           /* For NULL RSEC (cleared FDE belonging to a discarded section)
 812              the relocations are commonly cleared.  We do not sanity check if
 813              all these relocations are cleared as (1) relocations to
 814              .gcc_except_table will remain uncleared (they will get dropped
 815              with the drop of this unused FDE) and (2) BFD already safely drops
 816              relocations of any type to .eh_frame by
 817              elf_section_ignore_discarded_relocs.
 818              TODO: The .gcc_except_table entries should be also filtered as
 819              .eh_frame entries; or GCC could rather use COMDAT for them.  */
 820           SKIP_RELOCS (buf);
 821         }
 822
 823       /* Try to interpret the CFA instructions and find the first
 824          padding nop.  Shrink this_inf's size so that it doesn't
 825          include the padding.  */
 826       length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
 827       set_loc_count = 0;
 828       insns_end = skip_non_nops (insns, end, length, &set_loc_count);
 829       /* If we don't understand the CFA instructions, we can't know
 830          what needs to be adjusted there.  */
 831       if (insns_end == NULL
 832           /* For the time being we don't support DW_CFA_set_loc in
 833              CIE instructions.  */
 834           || (set_loc_count && this_inf->cie))
 835         goto free_no_table;
 836       this_inf->size -= end - insns_end;
 837       if (insns_end != end && this_inf->cie)
 838         {
 839           cie->initial_insn_length -= end - insns_end;
 840           cie->length -= end - insns_end;
 841         }
 842       if (set_loc_count
 843           && ((cie->fde_encoding & 0x70) == DW_EH_PE_pcrel
 844               || this_inf->make_relative))
 845         {
 846           unsigned int cnt;
 847           bfd_byte *p;
 848
 849           this_inf->set_loc = (unsigned int *)
 850               bfd_malloc ((set_loc_count + 1) * sizeof (unsigned int));
 851           REQUIRE (this_inf->set_loc);
 852           this_inf->set_loc[0] = set_loc_count;
 853           p = insns;
 854           cnt = 0;
 855           while (p < end)
 856             {
 857               if (*p == DW_CFA_set_loc)
 858                 this_inf->set_loc[++cnt] = p + 1 - start;
 859               REQUIRE (skip_cfa_op (&p, end, length));
 860             }
 861         }
 862
 863       this_inf->removed = 1;
 864       this_inf->fde_encoding = cie->fde_encoding;
 865       this_inf->lsda_encoding = cie->lsda_encoding;
 866       sec_info->count++;
 867     }
 868   BFD_ASSERT (sec_info->count == num_entries);
 869   BFD_ASSERT (cie_count == num_cies);
 870
 871   elf_section_data (sec)->sec_info = sec_info;
 872   sec->sec_info_type = ELF_INFO_TYPE_EH_FRAME;
 873   if (hdr_info->merge_cies)
 874     {
 875       sec_info->cies = local_cies;
 876       local_cies = NULL;
 877     }
 878   goto success;
 879
 880  free_no_table:
 881   (*info->callbacks->einfo)
 882     (_("%P: error in %B(%A); no .eh_frame_hdr table will be created.\n"),
 883      abfd, sec);
 884   hdr_info->table = FALSE;
 885   if (sec_info)
 886     free (sec_info);
 887  success:
 888   if (ehbuf)
 889     free (ehbuf);
 890   if (local_cies)
 891     free (local_cies);
 892 #undef REQUIRE
 893 }
 894
 895 /* Finish a pass over all .eh_frame sections.  */
 896
 897 void
 898 _bfd_elf_end_eh_frame_parsing (struct bfd_link_info *info)
 899 {
 900   struct eh_frame_hdr_info *hdr_info;
 901
 902   hdr_info = &elf_hash_table (info)->eh_info;
 903   hdr_info->parsed_eh_frames = TRUE;
 904 }
 905
 906 /* Mark all relocations against CIE or FDE ENT, which occurs in
 907    .eh_frame section SEC.  COOKIE describes the relocations in SEC;
 908    its "rel" field can be changed freely.  */
 909
 910 static bfd_boolean
 911 mark_entry (struct bfd_link_info *info, asection *sec,
 912             struct eh_cie_fde *ent, elf_gc_mark_hook_fn gc_mark_hook,
 913             struct elf_reloc_cookie *cookie)
 914 {
 915   /* FIXME: octets_per_byte.  */
 916   for (cookie->rel = cookie->rels + ent->reloc_index;
 917        cookie->rel < cookie->relend
 918          && cookie->rel->r_offset < ent->offset + ent->size;
 919        cookie->rel++)
 920     if (!_bfd_elf_gc_mark_reloc (info, sec, gc_mark_hook, cookie))
 921       return FALSE;
 922
 923   return TRUE;
 924 }
 925
 926 /* Mark all the relocations against FDEs that relate to code in input
 927    section SEC.  The FDEs belong to .eh_frame section EH_FRAME, whose
 928    relocations are described by COOKIE.  */
 929
 930 bfd_boolean
 931 _bfd_elf_gc_mark_fdes (struct bfd_link_info *info, asection *sec,
 932                        asection *eh_frame, elf_gc_mark_hook_fn gc_mark_hook,
 933                        struct elf_reloc_cookie *cookie)
 934 {
 935   struct eh_cie_fde *fde, *cie;
 936
 937   for (fde = elf_fde_list (sec); fde; fde = fde->u.fde.next_for_section)
 938     {
 939       if (!mark_entry (info, eh_frame, fde, gc_mark_hook, cookie))
 940         return FALSE;
 941
 942       /* At this stage, all cie_inf fields point to local CIEs, so we
 943          can use the same cookie to refer to them.  */
 944       cie = fde->u.fde.cie_inf;
 945       if (!cie->u.cie.gc_mark)
 946         {
 947           cie->u.cie.gc_mark = 1;
 948           if (!mark_entry (info, eh_frame, cie, gc_mark_hook, cookie))
 949             return FALSE;
 950         }
 951     }
 952   return TRUE;
 953 }
 954
 955 /* Input section SEC of ABFD is an .eh_frame section that contains the
 956    CIE described by CIE_INF.  Return a version of CIE_INF that is going
 957    to be kept in the output, adding CIE_INF to the output if necessary.
 958
 959    HDR_INFO is the .eh_frame_hdr information and COOKIE describes the
 960    relocations in REL.  */
 961
 962 static struct eh_cie_fde *
 963 find_merged_cie (bfd *abfd, struct bfd_link_info *info, asection *sec,
 964                  struct eh_frame_hdr_info *hdr_info,
 965                  struct elf_reloc_cookie *cookie,
 966                  struct eh_cie_fde *cie_inf)
 967 {
 968   unsigned long r_symndx;
 969   struct cie *cie, *new_cie;
 970   Elf_Internal_Rela *rel;
 971   void **loc;
 972
 973   /* Use CIE_INF if we have already decided to keep it.  */
 974   if (!cie_inf->removed)
 975     return cie_inf;
 976
 977   /* If we have merged CIE_INF with another CIE, use that CIE instead.  */
 978   if (cie_inf->u.cie.merged)
 979     return cie_inf->u.cie.u.merged_with;
 980
 981   cie = cie_inf->u.cie.u.full_cie;
 982
 983   /* Assume we will need to keep CIE_INF.  */
 984   cie_inf->removed = 0;
 985   cie_inf->u.cie.u.sec = sec;
 986
 987   /* If we are not merging CIEs, use CIE_INF.  */
 988   if (cie == NULL)
 989     return cie_inf;
 990
 991   if (cie->per_encoding != DW_EH_PE_omit)
 992     {
 993       bfd_boolean per_binds_local;
 994
 995       /* Work out the address of personality routine, either as an absolute
 996          value or as a symbol.  */
 997       rel = cookie->rels + cie->personality.reloc_index;
 998       memset (&cie->personality, 0, sizeof (cie->personality));
 999 #ifdef BFD64
1000       if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64)
1001         r_symndx = ELF64_R_SYM (rel->r_info);
1002       else
1003 #endif
1004         r_symndx = ELF32_R_SYM (rel->r_info);
1005       if (r_symndx >= cookie->locsymcount
1006           || ELF_ST_BIND (cookie->locsyms[r_symndx].st_info) != STB_LOCAL)
1007         {
1008           struct elf_link_hash_entry *h;
1009
1010           r_symndx -= cookie->extsymoff;
1011           h = cookie->sym_hashes[r_symndx];
1012
1013           while (h->root.type == bfd_link_hash_indirect
1014                  || h->root.type == bfd_link_hash_warning)
1015             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1016
1017           cie->personality.h = h;
1018           per_binds_local = SYMBOL_REFERENCES_LOCAL (info, h);
1019         }
1020       else
1021         {
1022           Elf_Internal_Sym *sym;
1023           asection *sym_sec;
1024
1025           sym = &cookie->locsyms[r_symndx];
1026           sym_sec = bfd_section_from_elf_index (abfd, sym->st_shndx);
1027           if (sym_sec == NULL)
1028             return cie_inf;
1029
1030           if (sym_sec->kept_section != NULL)
1031             sym_sec = sym_sec->kept_section;
1032           if (sym_sec->output_section == NULL)
1033             return cie_inf;
1034
1035           cie->local_personality = 1;
1036           cie->personality.val = (sym->st_value
1037                                   + sym_sec->output_offset
1038                                   + sym_sec->output_section->vma);
1039           per_binds_local = TRUE;
1040         }
1041
1042       if (per_binds_local
1043           && info->shared
1044           && (cie->per_encoding & 0x70) == DW_EH_PE_absptr
1045           && (get_elf_backend_data (abfd)
1046               ->elf_backend_can_make_relative_eh_frame (abfd, info, sec)))
1047         {
1048           cie_inf->u.cie.make_per_encoding_relative = 1;
1049           cie_inf->u.cie.per_encoding_relative = 1;
1050         }
1051     }
1052
1053   /* See if we can merge this CIE with an earlier one.  */
1054   cie->output_sec = sec->output_section;
1055   cie_compute_hash (cie);
1056   if (hdr_info->cies == NULL)
1057     {
1058       hdr_info->cies = htab_try_create (1, cie_hash, cie_eq, free);
1059       if (hdr_info->cies == NULL)
1060         return cie_inf;
1061     }
1062   loc = htab_find_slot_with_hash (hdr_info->cies, cie, cie->hash, INSERT);
1063   if (loc == NULL)
1064     return cie_inf;
1065
1066   new_cie = (struct cie *) *loc;
1067   if (new_cie == NULL)
1068     {
1069       /* Keep CIE_INF and record it in the hash table.  */
1070       new_cie = (struct cie *) malloc (sizeof (struct cie));
1071       if (new_cie == NULL)
1072         return cie_inf;
1073
1074       memcpy (new_cie, cie, sizeof (struct cie));
1075       *loc = new_cie;
1076     }
1077   else
1078     {
1079       /* Merge CIE_INF with NEW_CIE->CIE_INF.  */
1080       cie_inf->removed = 1;
1081       cie_inf->u.cie.merged = 1;
1082       cie_inf->u.cie.u.merged_with = new_cie->cie_inf;
1083       if (cie_inf->u.cie.make_lsda_relative)
1084         new_cie->cie_inf->u.cie.make_lsda_relative = 1;
1085     }
1086   return new_cie->cie_inf;
1087 }
1088
1089 /* This function is called for each input file before the .eh_frame
1090    section is relocated.  It discards duplicate CIEs and FDEs for discarded
1091    functions.  The function returns TRUE iff any entries have been
1092    deleted.  */
1093
1094 bfd_boolean
1095 _bfd_elf_discard_section_eh_frame
1096    (bfd *abfd, struct bfd_link_info *info, asection *sec,
1097     bfd_boolean (*reloc_symbol_deleted_p) (bfd_vma, void *),
1098     struct elf_reloc_cookie *cookie)
1099 {
1100   struct eh_cie_fde *ent;
1101   struct eh_frame_sec_info *sec_info;
1102   struct eh_frame_hdr_info *hdr_info;
1103   unsigned int ptr_size, offset;
1104
1105   sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
1106   if (sec_info == NULL)
1107     return FALSE;
1108
1109   hdr_info = &elf_hash_table (info)->eh_info;
1110   for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1111     if (ent->size == 4)
1112       /* There should only be one zero terminator, on the last input
1113          file supplying .eh_frame (crtend.o).  Remove any others.  */
1114       ent->removed = sec->map_head.s != NULL;
1115     else if (!ent->cie)
1116       {
1117         cookie->rel = cookie->rels + ent->reloc_index;
1118         /* FIXME: octets_per_byte.  */
1119         BFD_ASSERT (cookie->rel < cookie->relend
1120                     && cookie->rel->r_offset == ent->offset + 8);
1121         if (!(*reloc_symbol_deleted_p) (ent->offset + 8, cookie))
1122           {
1123             if (info->shared
1124                 && (((ent->fde_encoding & 0x70) == DW_EH_PE_absptr
1125                      && ent->make_relative == 0)
1126                     || (ent->fde_encoding & 0x70) == DW_EH_PE_aligned))
1127               {
1128                 /* If a shared library uses absolute pointers
1129                    which we cannot turn into PC relative,
1130                    don't create the binary search table,
1131                    since it is affected by runtime relocations.  */
1132                 hdr_info->table = FALSE;
1133                 (*info->callbacks->einfo)
1134                   (_("%P: fde encoding in %B(%A) prevents .eh_frame_hdr"
1135                      " table being created.\n"), abfd, sec);
1136               }
1137             ent->removed = 0;
1138             hdr_info->fde_count++;
1139             ent->u.fde.cie_inf = find_merged_cie (abfd, info, sec, hdr_info,
1140                                                   cookie, ent->u.fde.cie_inf);
1141           }
1142       }
1143
1144   if (sec_info->cies)
1145     {
1146       free (sec_info->cies);
1147       sec_info->cies = NULL;
1148     }
1149
1150   ptr_size = (get_elf_backend_data (sec->owner)
1151               ->elf_backend_eh_frame_address_size (sec->owner, sec));
1152   offset = 0;
1153   for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1154     if (!ent->removed)
1155       {
1156         ent->new_offset = offset;
1157         offset += size_of_output_cie_fde (ent, ptr_size);
1158       }
1159
1160   sec->rawsize = sec->size;
1161   sec->size = offset;
1162   return offset != sec->rawsize;
1163 }
1164
1165 /* This function is called for .eh_frame_hdr section after
1166    _bfd_elf_discard_section_eh_frame has been called on all .eh_frame
1167    input sections.  It finalizes the size of .eh_frame_hdr section.  */
1168
1169 bfd_boolean
1170 _bfd_elf_discard_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
1171 {
1172   struct elf_link_hash_table *htab;
1173   struct eh_frame_hdr_info *hdr_info;
1174   asection *sec;
1175
1176   htab = elf_hash_table (info);
1177   hdr_info = &htab->eh_info;
1178
1179   if (hdr_info->cies != NULL)
1180     {
1181       htab_delete (hdr_info->cies);
1182       hdr_info->cies = NULL;
1183     }
1184
1185   sec = hdr_info->hdr_sec;
1186   if (sec == NULL)
1187     return FALSE;
1188
1189   sec->size = EH_FRAME_HDR_SIZE;
1190   if (hdr_info->table)
1191     sec->size += 4 + hdr_info->fde_count * 8;
1192
1193   elf_tdata (abfd)->eh_frame_hdr = sec;
1194   return TRUE;
1195 }
1196
1197 /* This function is called from size_dynamic_sections.
1198    It needs to decide whether .eh_frame_hdr should be output or not,
1199    because when the dynamic symbol table has been sized it is too late
1200    to strip sections.  */
1201
1202 bfd_boolean
1203 _bfd_elf_maybe_strip_eh_frame_hdr (struct bfd_link_info *info)
1204 {
1205   asection *o;
1206   bfd *abfd;
1207   struct elf_link_hash_table *htab;
1208   struct eh_frame_hdr_info *hdr_info;
1209
1210   htab = elf_hash_table (info);
1211   hdr_info = &htab->eh_info;
1212   if (hdr_info->hdr_sec == NULL)
1213     return TRUE;
1214
1215   if (bfd_is_abs_section (hdr_info->hdr_sec->output_section))
1216     {
1217       hdr_info->hdr_sec = NULL;
1218       return TRUE;
1219     }
1220
1221   abfd = NULL;
1222   if (info->eh_frame_hdr)
1223     for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link_next)
1224       {
1225         /* Count only sections which have at least a single CIE or FDE.
1226            There cannot be any CIE or FDE <= 8 bytes.  */
1227         o = bfd_get_section_by_name (abfd, ".eh_frame");
1228         if (o && o->size > 8 && !bfd_is_abs_section (o->output_section))
1229           break;
1230       }
1231
1232   if (abfd == NULL)
1233     {
1234       hdr_info->hdr_sec->flags |= SEC_EXCLUDE;
1235       hdr_info->hdr_sec = NULL;
1236       return TRUE;
1237     }
1238
1239   hdr_info->table = TRUE;
1240   return TRUE;
1241 }
1242
1243 /* Adjust an address in the .eh_frame section.  Given OFFSET within
1244    SEC, this returns the new offset in the adjusted .eh_frame section,
1245    or -1 if the address refers to a CIE/FDE which has been removed
1246    or to offset with dynamic relocation which is no longer needed.  */
1247
1248 bfd_vma
1249 _bfd_elf_eh_frame_section_offset (bfd *output_bfd ATTRIBUTE_UNUSED,
1250                                   struct bfd_link_info *info,
1251                                   asection *sec,
1252                                   bfd_vma offset)
1253 {
1254   struct eh_frame_sec_info *sec_info;
1255   struct elf_link_hash_table *htab;
1256   struct eh_frame_hdr_info *hdr_info;
1257   unsigned int lo, hi, mid;
1258
1259   if (sec->sec_info_type != ELF_INFO_TYPE_EH_FRAME)
1260     return offset;
1261   sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
1262
1263   if (offset >= sec->rawsize)
1264     return offset - sec->rawsize + sec->size;
1265
1266   htab = elf_hash_table (info);
1267   hdr_info = &htab->eh_info;
1268
1269   lo = 0;
1270   hi = sec_info->count;
1271   mid = 0;
1272   while (lo < hi)
1273     {
1274       mid = (lo + hi) / 2;
1275       if (offset < sec_info->entry[mid].offset)
1276         hi = mid;
1277       else if (offset
1278                >= sec_info->entry[mid].offset + sec_info->entry[mid].size)
1279         lo = mid + 1;
1280       else
1281         break;
1282     }
1283
1284   BFD_ASSERT (lo < hi);
1285
1286   /* FDE or CIE was removed.  */
1287   if (sec_info->entry[mid].removed)
1288     return (bfd_vma) -1;
1289
1290   /* If converting personality pointers to DW_EH_PE_pcrel, there will be
1291      no need for run-time relocation against the personality field.  */
1292   if (sec_info->entry[mid].cie
1293       && sec_info->entry[mid].u.cie.make_per_encoding_relative
1294       && offset == (sec_info->entry[mid].offset + 8
1295                     + sec_info->entry[mid].u.cie.personality_offset))
1296     return (bfd_vma) -2;
1297
1298   /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1299      relocation against FDE's initial_location field.  */
1300   if (!sec_info->entry[mid].cie
1301       && sec_info->entry[mid].make_relative
1302       && offset == sec_info->entry[mid].offset + 8)
1303     return (bfd_vma) -2;
1304
1305   /* If converting LSDA pointers to DW_EH_PE_pcrel, there will be no need
1306      for run-time relocation against LSDA field.  */
1307   if (!sec_info->entry[mid].cie
1308       && sec_info->entry[mid].u.fde.cie_inf->u.cie.make_lsda_relative
1309       && offset == (sec_info->entry[mid].offset + 8
1310                     + sec_info->entry[mid].lsda_offset))
1311     return (bfd_vma) -2;
1312
1313   /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1314      relocation against DW_CFA_set_loc's arguments.  */
1315   if (sec_info->entry[mid].set_loc
1316       && sec_info->entry[mid].make_relative
1317       && (offset >= sec_info->entry[mid].offset + 8
1318                     + sec_info->entry[mid].set_loc[1]))
1319     {
1320       unsigned int cnt;
1321
1322       for (cnt = 1; cnt <= sec_info->entry[mid].set_loc[0]; cnt++)
1323         if (offset == sec_info->entry[mid].offset + 8
1324                       + sec_info->entry[mid].set_loc[cnt])
1325           return (bfd_vma) -2;
1326     }
1327
1328   /* Any new augmentation bytes go before the first relocation.  */
1329   return (offset + sec_info->entry[mid].new_offset
1330           - sec_info->entry[mid].offset
1331           + extra_augmentation_string_bytes (sec_info->entry + mid)
1332           + extra_augmentation_data_bytes (sec_info->entry + mid));
1333 }
1334
1335 /* Write out .eh_frame section.  This is called with the relocated
1336    contents.  */
1337
1338 bfd_boolean
1339 _bfd_elf_write_section_eh_frame (bfd *abfd,
1340                                  struct bfd_link_info *info,
1341                                  asection *sec,
1342                                  bfd_byte *contents)
1343 {
1344   struct eh_frame_sec_info *sec_info;
1345   struct elf_link_hash_table *htab;
1346   struct eh_frame_hdr_info *hdr_info;
1347   unsigned int ptr_size;
1348   struct eh_cie_fde *ent;
1349
1350   if (sec->sec_info_type != ELF_INFO_TYPE_EH_FRAME)
1351     /* FIXME: octets_per_byte.  */
1352     return bfd_set_section_contents (abfd, sec->output_section, contents,
1353                                      sec->output_offset, sec->size);
1354
1355   ptr_size = (get_elf_backend_data (abfd)
1356               ->elf_backend_eh_frame_address_size (abfd, sec));
1357   BFD_ASSERT (ptr_size != 0);
1358
1359   sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
1360   htab = elf_hash_table (info);
1361   hdr_info = &htab->eh_info;
1362
1363   if (hdr_info->table && hdr_info->array == NULL)
1364     hdr_info->array = (struct eh_frame_array_ent *)
1365         bfd_malloc (hdr_info->fde_count * sizeof(*hdr_info->array));
1366   if (hdr_info->array == NULL)
1367     hdr_info = NULL;
1368
1369   /* The new offsets can be bigger or smaller than the original offsets.
1370      We therefore need to make two passes over the section: one backward
1371      pass to move entries up and one forward pass to move entries down.
1372      The two passes won't interfere with each other because entries are
1373      not reordered  */
1374   for (ent = sec_info->entry + sec_info->count; ent-- != sec_info->entry;)
1375     if (!ent->removed && ent->new_offset > ent->offset)
1376       memmove (contents + ent->new_offset, contents + ent->offset, ent->size);
1377
1378   for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1379     if (!ent->removed && ent->new_offset < ent->offset)
1380       memmove (contents + ent->new_offset, contents + ent->offset, ent->size);
1381
1382   for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1383     {
1384       unsigned char *buf, *end;
1385       unsigned int new_size;
1386
1387       if (ent->removed)
1388         continue;
1389
1390       if (ent->size == 4)
1391         {
1392           /* Any terminating FDE must be at the end of the section.  */
1393           BFD_ASSERT (ent == sec_info->entry + sec_info->count - 1);
1394           continue;
1395         }
1396
1397       buf = contents + ent->new_offset;
1398       end = buf + ent->size;
1399       new_size = size_of_output_cie_fde (ent, ptr_size);
1400
1401       /* Update the size.  It may be shrinked.  */
1402       bfd_put_32 (abfd, new_size - 4, buf);
1403
1404       /* Filling the extra bytes with DW_CFA_nops.  */
1405       if (new_size != ent->size)
1406         memset (end, 0, new_size - ent->size);
1407
1408       if (ent->cie)
1409         {
1410           /* CIE */
1411           if (ent->make_relative
1412               || ent->u.cie.make_lsda_relative
1413               || ent->u.cie.per_encoding_relative)
1414             {
1415               char *aug;
1416               unsigned int action, extra_string, extra_data;
1417               unsigned int per_width, per_encoding;
1418
1419               /* Need to find 'R' or 'L' augmentation's argument and modify
1420                  DW_EH_PE_* value.  */
1421               action = ((ent->make_relative ? 1 : 0)
1422                         | (ent->u.cie.make_lsda_relative ? 2 : 0)
1423                         | (ent->u.cie.per_encoding_relative ? 4 : 0));
1424               extra_string = extra_augmentation_string_bytes (ent);
1425               extra_data = extra_augmentation_data_bytes (ent);
1426
1427               /* Skip length, id and version.  */
1428               buf += 9;
1429               aug = (char *) buf;
1430               buf += strlen (aug) + 1;
1431               skip_leb128 (&buf, end);
1432               skip_leb128 (&buf, end);
1433               skip_leb128 (&buf, end);
1434               if (*aug == 'z')
1435                 {
1436                   /* The uleb128 will always be a single byte for the kind
1437                      of augmentation strings that we're prepared to handle.  */
1438                   *buf++ += extra_data;
1439                   aug++;
1440                 }
1441
1442               /* Make room for the new augmentation string and data bytes.  */
1443               memmove (buf + extra_string + extra_data, buf, end - buf);
1444               memmove (aug + extra_string, aug, buf - (bfd_byte *) aug);
1445               buf += extra_string;
1446               end += extra_string + extra_data;
1447
1448               if (ent->add_augmentation_size)
1449                 {
1450                   *aug++ = 'z';
1451                   *buf++ = extra_data - 1;
1452                 }
1453               if (ent->u.cie.add_fde_encoding)
1454                 {
1455                   BFD_ASSERT (action & 1);
1456                   *aug++ = 'R';
1457                   *buf++ = DW_EH_PE_pcrel;
1458                   action &= ~1;
1459                 }
1460
1461               while (action)
1462                 switch (*aug++)
1463                   {
1464                   case 'L':
1465                     if (action & 2)
1466                       {
1467                         BFD_ASSERT (*buf == ent->lsda_encoding);
1468                         *buf |= DW_EH_PE_pcrel;
1469                         action &= ~2;
1470                       }
1471                     buf++;
1472                     break;
1473                   case 'P':
1474                     if (ent->u.cie.make_per_encoding_relative)
1475                       *buf |= DW_EH_PE_pcrel;
1476                     per_encoding = *buf++;
1477                     per_width = get_DW_EH_PE_width (per_encoding, ptr_size);
1478                     BFD_ASSERT (per_width != 0);
1479                     BFD_ASSERT (((per_encoding & 0x70) == DW_EH_PE_pcrel)
1480                                 == ent->u.cie.per_encoding_relative);
1481                     if ((per_encoding & 0x70) == DW_EH_PE_aligned)
1482                       buf = (contents
1483                              + ((buf - contents + per_width - 1)
1484                                 & ~((bfd_size_type) per_width - 1)));
1485                     if (action & 4)
1486                       {
1487                         bfd_vma val;
1488
1489                         val = read_value (abfd, buf, per_width,
1490                                           get_DW_EH_PE_signed (per_encoding));
1491                         if (ent->u.cie.make_per_encoding_relative)
1492                           val -= (sec->output_section->vma
1493                                   + sec->output_offset
1494                                   + (buf - contents));
1495                         else
1496                           {
1497                             val += (bfd_vma) ent->offset - ent->new_offset;
1498                             val -= extra_string + extra_data;
1499                           }
1500                         write_value (abfd, buf, val, per_width);
1501                         action &= ~4;
1502                       }
1503                     buf += per_width;
1504                     break;
1505                   case 'R':
1506                     if (action & 1)
1507                       {
1508                         BFD_ASSERT (*buf == ent->fde_encoding);
1509                         *buf |= DW_EH_PE_pcrel;
1510                         action &= ~1;
1511                       }
1512                     buf++;
1513                     break;
1514                   case 'S':
1515                     break;
1516                   default:
1517                     BFD_FAIL ();
1518                   }
1519             }
1520         }
1521       else
1522         {
1523           /* FDE */
1524           bfd_vma value, address;
1525           unsigned int width;
1526           bfd_byte *start;
1527           struct eh_cie_fde *cie;
1528
1529           /* Skip length.  */
1530           cie = ent->u.fde.cie_inf;
1531           buf += 4;
1532           value = ((ent->new_offset + sec->output_offset + 4)
1533                    - (cie->new_offset + cie->u.cie.u.sec->output_offset));
1534           bfd_put_32 (abfd, value, buf);
1535           buf += 4;
1536           width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1537           value = read_value (abfd, buf, width,
1538                               get_DW_EH_PE_signed (ent->fde_encoding));
1539           address = value;
1540           if (value)
1541             {
1542               switch (ent->fde_encoding & 0x70)
1543                 {
1544                 case DW_EH_PE_textrel:
1545                   BFD_ASSERT (hdr_info == NULL);
1546                   break;
1547                 case DW_EH_PE_datarel:
1548                   {
1549                     asection *got = bfd_get_section_by_name (abfd, ".got");
1550
1551                     BFD_ASSERT (got != NULL);
1552                     address += got->vma;
1553                   }
1554                   break;
1555                 case DW_EH_PE_pcrel:
1556                   value += (bfd_vma) ent->offset - ent->new_offset;
1557                   address += (sec->output_section->vma
1558                               + sec->output_offset
1559                               + ent->offset + 8);
1560                   break;
1561                 }
1562               if (ent->make_relative)
1563                 value -= (sec->output_section->vma
1564                           + sec->output_offset
1565                           + ent->new_offset + 8);
1566               write_value (abfd, buf, value, width);
1567             }
1568
1569           start = buf;
1570
1571           if (hdr_info)
1572             {
1573               hdr_info->array[hdr_info->array_count].initial_loc = address;
1574               hdr_info->array[hdr_info->array_count++].fde
1575                 = (sec->output_section->vma
1576                    + sec->output_offset
1577                    + ent->new_offset);
1578             }
1579
1580           if ((ent->lsda_encoding & 0x70) == DW_EH_PE_pcrel
1581               || cie->u.cie.make_lsda_relative)
1582             {
1583               buf += ent->lsda_offset;
1584               width = get_DW_EH_PE_width (ent->lsda_encoding, ptr_size);
1585               value = read_value (abfd, buf, width,
1586                                   get_DW_EH_PE_signed (ent->lsda_encoding));
1587               if (value)
1588                 {
1589                   if ((ent->lsda_encoding & 0x70) == DW_EH_PE_pcrel)
1590                     value += (bfd_vma) ent->offset - ent->new_offset;
1591                   else if (cie->u.cie.make_lsda_relative)
1592                     value -= (sec->output_section->vma
1593                               + sec->output_offset
1594                               + ent->new_offset + 8 + ent->lsda_offset);
1595                   write_value (abfd, buf, value, width);
1596                 }
1597             }
1598           else if (ent->add_augmentation_size)
1599             {
1600               /* Skip the PC and length and insert a zero byte for the
1601                  augmentation size.  */
1602               buf += width * 2;
1603               memmove (buf + 1, buf, end - buf);
1604               *buf = 0;
1605             }
1606
1607           if (ent->set_loc)
1608             {
1609               /* Adjust DW_CFA_set_loc.  */
1610               unsigned int cnt, width;
1611               bfd_vma new_offset;
1612
1613               width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1614               new_offset = ent->new_offset + 8
1615                            + extra_augmentation_string_bytes (ent)
1616                            + extra_augmentation_data_bytes (ent);
1617
1618               for (cnt = 1; cnt <= ent->set_loc[0]; cnt++)
1619                 {
1620                   bfd_vma value;
1621                   buf = start + ent->set_loc[cnt];
1622
1623                   value = read_value (abfd, buf, width,
1624                                       get_DW_EH_PE_signed (ent->fde_encoding));
1625                   if (!value)
1626                     continue;
1627
1628                   if ((ent->fde_encoding & 0x70) == DW_EH_PE_pcrel)
1629                     value += (bfd_vma) ent->offset + 8 - new_offset;
1630                   if (ent->make_relative)
1631                     value -= (sec->output_section->vma
1632                               + sec->output_offset
1633                               + new_offset + ent->set_loc[cnt]);
1634                   write_value (abfd, buf, value, width);
1635                 }
1636             }
1637         }
1638     }
1639
1640   /* We don't align the section to its section alignment since the
1641      runtime library only expects all CIE/FDE records aligned at
1642      the pointer size. _bfd_elf_discard_section_eh_frame should
1643      have padded CIE/FDE records to multiple of pointer size with
1644      size_of_output_cie_fde.  */
1645   if ((sec->size % ptr_size) != 0)
1646     abort ();
1647
1648   /* FIXME: octets_per_byte.  */
1649   return bfd_set_section_contents (abfd, sec->output_section,
1650                                    contents, (file_ptr) sec->output_offset,
1651                                    sec->size);
1652 }
1653
1654 /* Helper function used to sort .eh_frame_hdr search table by increasing
1655    VMA of FDE initial location.  */
1656
1657 static int
1658 vma_compare (const void *a, const void *b)
1659 {
1660   const struct eh_frame_array_ent *p = (const struct eh_frame_array_ent *) a;
1661   const struct eh_frame_array_ent *q = (const struct eh_frame_array_ent *) b;
1662   if (p->initial_loc > q->initial_loc)
1663     return 1;
1664   if (p->initial_loc < q->initial_loc)
1665     return -1;
1666   return 0;
1667 }
1668
1669 /* Write out .eh_frame_hdr section.  This must be called after
1670    _bfd_elf_write_section_eh_frame has been called on all input
1671    .eh_frame sections.
1672    .eh_frame_hdr format:
1673    ubyte version                (currently 1)
1674    ubyte eh_frame_ptr_enc       (DW_EH_PE_* encoding of pointer to start of
1675                                  .eh_frame section)
1676    ubyte fde_count_enc          (DW_EH_PE_* encoding of total FDE count
1677                                  number (or DW_EH_PE_omit if there is no
1678                                  binary search table computed))
1679    ubyte table_enc              (DW_EH_PE_* encoding of binary search table,
1680                                  or DW_EH_PE_omit if not present.
1681                                  DW_EH_PE_datarel is using address of
1682                                  .eh_frame_hdr section start as base)
1683    [encoded] eh_frame_ptr       (pointer to start of .eh_frame section)
1684    optionally followed by:
1685    [encoded] fde_count          (total number of FDEs in .eh_frame section)
1686    fde_count x [encoded] initial_loc, fde
1687                                 (array of encoded pairs containing
1688                                  FDE initial_location field and FDE address,
1689                                  sorted by increasing initial_loc).  */
1690
1691 bfd_boolean
1692 _bfd_elf_write_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
1693 {
1694   struct elf_link_hash_table *htab;
1695   struct eh_frame_hdr_info *hdr_info;
1696   asection *sec;
1697   bfd_byte *contents;
1698   asection *eh_frame_sec;
1699   bfd_size_type size;
1700   bfd_boolean retval;
1701   bfd_vma encoded_eh_frame;
1702
1703   htab = elf_hash_table (info);
1704   hdr_info = &htab->eh_info;
1705   sec = hdr_info->hdr_sec;
1706   if (sec == NULL)
1707     return TRUE;
1708
1709   size = EH_FRAME_HDR_SIZE;
1710   if (hdr_info->array && hdr_info->array_count == hdr_info->fde_count)
1711     size += 4 + hdr_info->fde_count * 8;
1712   contents = (bfd_byte *) bfd_malloc (size);
1713   if (contents == NULL)
1714     return FALSE;
1715
1716   eh_frame_sec = bfd_get_section_by_name (abfd, ".eh_frame");
1717   if (eh_frame_sec == NULL)
1718     {
1719       free (contents);
1720       return FALSE;
1721     }
1722
1723   memset (contents, 0, EH_FRAME_HDR_SIZE);
1724   contents[0] = 1;                              /* Version.  */
1725   contents[1] = get_elf_backend_data (abfd)->elf_backend_encode_eh_address
1726     (abfd, info, eh_frame_sec, 0, sec, 4,
1727      &encoded_eh_frame);                        /* .eh_frame offset.  */
1728
1729   if (hdr_info->array && hdr_info->array_count == hdr_info->fde_count)
1730     {
1731       contents[2] = DW_EH_PE_udata4;            /* FDE count encoding.  */
1732       contents[3] = DW_EH_PE_datarel | DW_EH_PE_sdata4; /* Search table enc.  */
1733     }
1734   else
1735     {
1736       contents[2] = DW_EH_PE_omit;
1737       contents[3] = DW_EH_PE_omit;
1738     }
1739   bfd_put_32 (abfd, encoded_eh_frame, contents + 4);
1740
1741   if (contents[2] != DW_EH_PE_omit)
1742     {
1743       unsigned int i;
1744
1745       bfd_put_32 (abfd, hdr_info->fde_count, contents + EH_FRAME_HDR_SIZE);
1746       qsort (hdr_info->array, hdr_info->fde_count, sizeof (*hdr_info->array),
1747              vma_compare);
1748       for (i = 0; i < hdr_info->fde_count; i++)
1749         {
1750           bfd_put_32 (abfd,
1751                       hdr_info->array[i].initial_loc
1752                       - sec->output_section->vma,
1753                       contents + EH_FRAME_HDR_SIZE + i * 8 + 4);
1754           bfd_put_32 (abfd,
1755                       hdr_info->array[i].fde - sec->output_section->vma,
1756                       contents + EH_FRAME_HDR_SIZE + i * 8 + 8);
1757         }
1758     }
1759
1760   /* FIXME: octets_per_byte.  */
1761   retval = bfd_set_section_contents (abfd, sec->output_section,
1762                                      contents, (file_ptr) sec->output_offset,
1763                                      sec->size);
1764   free (contents);
1765   return retval;
1766 }
1767
1768 /* Return the width of FDE addresses.  This is the default implementation.  */
1769
1770 unsigned int
1771 _bfd_elf_eh_frame_address_size (bfd *abfd, asection *sec ATTRIBUTE_UNUSED)
1772 {
1773   return elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64 ? 8 : 4;
1774 }
1775
1776 /* Decide whether we can use a PC-relative encoding within the given
1777    EH frame section.  This is the default implementation.  */
1778
1779 bfd_boolean
1780 _bfd_elf_can_make_relative (bfd *input_bfd ATTRIBUTE_UNUSED,
1781                             struct bfd_link_info *info ATTRIBUTE_UNUSED,
1782                             asection *eh_frame_section ATTRIBUTE_UNUSED)
1783 {
1784   return TRUE;
1785 }
1786
1787 /* Select an encoding for the given address.  Preference is given to
1788    PC-relative addressing modes.  */
1789
1790 bfd_byte
1791 _bfd_elf_encode_eh_address (bfd *abfd ATTRIBUTE_UNUSED,
1792                             struct bfd_link_info *info ATTRIBUTE_UNUSED,
1793                             asection *osec, bfd_vma offset,
1794                             asection *loc_sec, bfd_vma loc_offset,
1795                             bfd_vma *encoded)
1796 {
1797   *encoded = osec->vma + offset -
1798     (loc_sec->output_section->vma + loc_sec->output_offset + loc_offset);
1799   return DW_EH_PE_pcrel | DW_EH_PE_sdata4;
1800 }