contrib/binutils-2.21/bfd/elf-eh-frame.c

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