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