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