bfd/elf-eh-frame.c

   1 /* .eh_frame section optimization.
   2    Copyright (C) 2001-2016 Free Software Foundation, Inc.
   3    Written by Jakub Jelinek <jakub@redhat.com>.
   4
   5    This file is part of BFD, the Binary File Descriptor library.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  20    MA 02110-1301, USA.  */
  21
  22 #include "sysdep.h"
  23 #include "bfd.h"
  24 #include "libbfd.h"
  25 #include "elf-bfd.h"
  26 #include "dwarf2.h"
  27
  28 #define EH_FRAME_HDR_SIZE 8
  29
  30 struct cie
  31 {
  32   unsigned int length;
  33   unsigned int hash;
  34   unsigned char version;
  35   unsigned char local_personality;
  36   char augmentation[20];
  37   bfd_vma code_align;
  38   bfd_signed_vma data_align;
  39   bfd_vma ra_column;
  40   bfd_vma augmentation_size;
  41   union {
  42     struct elf_link_hash_entry *h;
  43     struct {
  44       unsigned int bfd_id;
  45       unsigned int index;
  46     } sym;
  47     unsigned int reloc_index;
  48   } personality;
  49   struct eh_cie_fde *cie_inf;
  50   unsigned char per_encoding;
  51   unsigned char lsda_encoding;
  52   unsigned char fde_encoding;
  53   unsigned char initial_insn_length;
  54   unsigned char can_make_lsda_relative;
  55   unsigned char initial_instructions[50];
  56 };
  57
  58
  59
  60 /* If *ITER hasn't reached END yet, read the next byte into *RESULT and
  61    move onto the next byte.  Return true on success.  */
  62
  63 static inline bfd_boolean
  64 read_byte (bfd_byte **iter, bfd_byte *end, unsigned char *result)
  65 {
  66   if (*iter >= end)
  67     return FALSE;
  68   *result = *((*iter)++);
  69   return TRUE;
  70 }
  71
  72 /* Move *ITER over LENGTH bytes, or up to END, whichever is closer.
  73    Return true it was possible to move LENGTH bytes.  */
  74
  75 static inline bfd_boolean
  76 skip_bytes (bfd_byte **iter, bfd_byte *end, bfd_size_type length)
  77 {
  78   if ((bfd_size_type) (end - *iter) < length)
  79     {
  80       *iter = end;
  81       return FALSE;
  82     }
  83   *iter += length;
  84   return TRUE;
  85 }
  86
  87 /* Move *ITER over an leb128, stopping at END.  Return true if the end
  88    of the leb128 was found.  */
  89
  90 static bfd_boolean
  91 skip_leb128 (bfd_byte **iter, bfd_byte *end)
  92 {
  93   unsigned char byte;
  94   do
  95     if (!read_byte (iter, end, &byte))
  96       return FALSE;
  97   while (byte & 0x80);
  98   return TRUE;
  99 }
 100
 101 /* Like skip_leb128, but treat the leb128 as an unsigned value and
 102    store it in *VALUE.  */
 103
 104 static bfd_boolean
 105 read_uleb128 (bfd_byte **iter, bfd_byte *end, bfd_vma *value)
 106 {
 107   bfd_byte *start, *p;
 108
 109   start = *iter;
 110   if (!skip_leb128 (iter, end))
 111     return FALSE;
 112
 113   p = *iter;
 114   *value = *--p;
 115   while (p > start)
 116     *value = (*value << 7) | (*--p & 0x7f);
 117
 118   return TRUE;
 119 }
 120
 121 /* Like read_uleb128, but for signed values.  */
 122
 123 static bfd_boolean
 124 read_sleb128 (bfd_byte **iter, bfd_byte *end, bfd_signed_vma *value)
 125 {
 126   bfd_byte *start, *p;
 127
 128   start = *iter;
 129   if (!skip_leb128 (iter, end))
 130     return FALSE;
 131
 132   p = *iter;
 133   *value = ((*--p & 0x7f) ^ 0x40) - 0x40;
 134   while (p > start)
 135     *value = (*value << 7) | (*--p & 0x7f);
 136
 137   return TRUE;
 138 }
 139
 140 /* Return 0 if either encoding is variable width, or not yet known to bfd.  */
 141
 142 static
 143 int get_DW_EH_PE_width (int encoding, int ptr_size)
 144 {
 145   /* DW_EH_PE_ values of 0x60 and 0x70 weren't defined at the time .eh_frame
 146      was added to bfd.  */
 147   if ((encoding & 0x60) == 0x60)
 148     return 0;
 149
 150   switch (encoding & 7)
 151     {
 152     case DW_EH_PE_udata2: return 2;
 153     case DW_EH_PE_udata4: return 4;
 154     case DW_EH_PE_udata8: return 8;
 155     case DW_EH_PE_absptr: return ptr_size;
 156     default:
 157       break;
 158     }
 159
 160   return 0;
 161 }
 162
 163 #define get_DW_EH_PE_signed(encoding) (((encoding) & DW_EH_PE_signed) != 0)
 164
 165 /* Read a width sized value from memory.  */
 166
 167 static bfd_vma
 168 read_value (bfd *abfd, bfd_byte *buf, int width, int is_signed)
 169 {
 170   bfd_vma value;
 171
 172   switch (width)
 173     {
 174     case 2:
 175       if (is_signed)
 176         value = bfd_get_signed_16 (abfd, buf);
 177       else
 178         value = bfd_get_16 (abfd, buf);
 179       break;
 180     case 4:
 181       if (is_signed)
 182         value = bfd_get_signed_32 (abfd, buf);
 183       else
 184         value = bfd_get_32 (abfd, buf);
 185       break;
 186     case 8:
 187       if (is_signed)
 188         value = bfd_get_signed_64 (abfd, buf);
 189       else
 190         value = bfd_get_64 (abfd, buf);
 191       break;
 192     default:
 193       BFD_FAIL ();
 194       return 0;
 195     }
 196
 197   return value;
 198 }
 199
 200 /* Store a width sized value to memory.  */
 201
 202 static void
 203 write_value (bfd *abfd, bfd_byte *buf, bfd_vma value, int width)
 204 {
 205   switch (width)
 206     {
 207     case 2: bfd_put_16 (abfd, value, buf); break;
 208     case 4: bfd_put_32 (abfd, value, buf); break;
 209     case 8: bfd_put_64 (abfd, value, buf); break;
 210     default: BFD_FAIL ();
 211     }
 212 }
 213
 214 /* Return one if C1 and C2 CIEs can be merged.  */
 215
 216 static int
 217 cie_eq (const void *e1, const void *e2)
 218 {
 219   const struct cie *c1 = (const struct cie *) e1;
 220   const struct cie *c2 = (const struct cie *) e2;
 221
 222   if (c1->hash == c2->hash
 223       && c1->length == c2->length
 224       && c1->version == c2->version
 225       && c1->local_personality == c2->local_personality
 226       && strcmp (c1->augmentation, c2->augmentation) == 0
 227       && strcmp (c1->augmentation, "eh") != 0
 228       && c1->code_align == c2->code_align
 229       && c1->data_align == c2->data_align
 230       && c1->ra_column == c2->ra_column
 231       && c1->augmentation_size == c2->augmentation_size
 232       && memcmp (&c1->personality, &c2->personality,
 233                  sizeof (c1->personality)) == 0
 234       && (c1->cie_inf->u.cie.u.sec->output_section
 235           == c2->cie_inf->u.cie.u.sec->output_section)
 236       && c1->per_encoding == c2->per_encoding
 237       && c1->lsda_encoding == c2->lsda_encoding
 238       && c1->fde_encoding == c2->fde_encoding
 239       && c1->initial_insn_length == c2->initial_insn_length
 240       && c1->initial_insn_length <= sizeof (c1->initial_instructions)
 241       && memcmp (c1->initial_instructions,
 242                  c2->initial_instructions,
 243                  c1->initial_insn_length) == 0)
 244     return 1;
 245
 246   return 0;
 247 }
 248
 249 static hashval_t
 250 cie_hash (const void *e)
 251 {
 252   const struct cie *c = (const struct cie *) e;
 253   return c->hash;
 254 }
 255
 256 static hashval_t
 257 cie_compute_hash (struct cie *c)
 258 {
 259   hashval_t h = 0;
 260   size_t len;
 261   h = iterative_hash_object (c->length, h);
 262   h = iterative_hash_object (c->version, h);
 263   h = iterative_hash (c->augmentation, strlen (c->augmentation) + 1, h);
 264   h = iterative_hash_object (c->code_align, h);
 265   h = iterative_hash_object (c->data_align, h);
 266   h = iterative_hash_object (c->ra_column, h);
 267   h = iterative_hash_object (c->augmentation_size, h);
 268   h = iterative_hash_object (c->personality, h);
 269   h = iterative_hash_object (c->cie_inf->u.cie.u.sec->output_section, h);
 270   h = iterative_hash_object (c->per_encoding, h);
 271   h = iterative_hash_object (c->lsda_encoding, h);
 272   h = iterative_hash_object (c->fde_encoding, h);
 273   h = iterative_hash_object (c->initial_insn_length, h);
 274   len = c->initial_insn_length;
 275   if (len > sizeof (c->initial_instructions))
 276     len = sizeof (c->initial_instructions);
 277   h = iterative_hash (c->initial_instructions, len, h);
 278   c->hash = h;
 279   return h;
 280 }
 281
 282 /* Return the number of extra bytes that we'll be inserting into
 283    ENTRY's augmentation string.  */
 284
 285 static INLINE unsigned int
 286 extra_augmentation_string_bytes (struct eh_cie_fde *entry)
 287 {
 288   unsigned int size = 0;
 289   if (entry->cie)
 290     {
 291       if (entry->add_augmentation_size)
 292         size++;
 293       if (entry->u.cie.add_fde_encoding)
 294         size++;
 295     }
 296   return size;
 297 }
 298
 299 /* Likewise ENTRY's augmentation data.  */
 300
 301 static INLINE unsigned int
 302 extra_augmentation_data_bytes (struct eh_cie_fde *entry)
 303 {
 304   unsigned int size = 0;
 305   if (entry->add_augmentation_size)
 306     size++;
 307   if (entry->cie && entry->u.cie.add_fde_encoding)
 308     size++;
 309   return size;
 310 }
 311
 312 /* Return the size that ENTRY will have in the output.  ALIGNMENT is the
 313    required alignment of ENTRY in bytes.  */
 314
 315 static unsigned int
 316 size_of_output_cie_fde (struct eh_cie_fde *entry, unsigned int alignment)
 317 {
 318   if (entry->removed)
 319     return 0;
 320   if (entry->size == 4)
 321     return 4;
 322   return (entry->size
 323           + extra_augmentation_string_bytes (entry)
 324           + extra_augmentation_data_bytes (entry)
 325           + alignment - 1) & -alignment;
 326 }
 327
 328 /* Assume that the bytes between *ITER and END are CFA instructions.
 329    Try to move *ITER past the first instruction and return true on
 330    success.  ENCODED_PTR_WIDTH gives the width of pointer entries.  */
 331
 332 static bfd_boolean
 333 skip_cfa_op (bfd_byte **iter, bfd_byte *end, unsigned int encoded_ptr_width)
 334 {
 335   bfd_byte op;
 336   bfd_vma length;
 337
 338   if (!read_byte (iter, end, &op))
 339     return FALSE;
 340
 341   switch (op & 0xc0 ? op & 0xc0 : op)
 342     {
 343     case DW_CFA_nop:
 344     case DW_CFA_advance_loc:
 345     case DW_CFA_restore:
 346     case DW_CFA_remember_state:
 347     case DW_CFA_restore_state:
 348     case DW_CFA_GNU_window_save:
 349       /* No arguments.  */
 350       return TRUE;
 351
 352     case DW_CFA_offset:
 353     case DW_CFA_restore_extended:
 354     case DW_CFA_undefined:
 355     case DW_CFA_same_value:
 356     case DW_CFA_def_cfa_register:
 357     case DW_CFA_def_cfa_offset:
 358     case DW_CFA_def_cfa_offset_sf:
 359     case DW_CFA_GNU_args_size:
 360       /* One leb128 argument.  */
 361       return skip_leb128 (iter, end);
 362
 363     case DW_CFA_val_offset:
 364     case DW_CFA_val_offset_sf:
 365     case DW_CFA_offset_extended:
 366     case DW_CFA_register:
 367     case DW_CFA_def_cfa:
 368     case DW_CFA_offset_extended_sf:
 369     case DW_CFA_GNU_negative_offset_extended:
 370     case DW_CFA_def_cfa_sf:
 371       /* Two leb128 arguments.  */
 372       return (skip_leb128 (iter, end)
 373               && skip_leb128 (iter, end));
 374
 375     case DW_CFA_def_cfa_expression:
 376       /* A variable-length argument.  */
 377       return (read_uleb128 (iter, end, &length)
 378               && skip_bytes (iter, end, length));
 379
 380     case DW_CFA_expression:
 381     case DW_CFA_val_expression:
 382       /* A leb128 followed by a variable-length argument.  */
 383       return (skip_leb128 (iter, end)
 384               && read_uleb128 (iter, end, &length)
 385               && skip_bytes (iter, end, length));
 386
 387     case DW_CFA_set_loc:
 388       return skip_bytes (iter, end, encoded_ptr_width);
 389
 390     case DW_CFA_advance_loc1:
 391       return skip_bytes (iter, end, 1);
 392
 393     case DW_CFA_advance_loc2:
 394       return skip_bytes (iter, end, 2);
 395
 396     case DW_CFA_advance_loc4:
 397       return skip_bytes (iter, end, 4);
 398
 399     case DW_CFA_MIPS_advance_loc8:
 400       return skip_bytes (iter, end, 8);
 401
 402     default:
 403       return FALSE;
 404     }
 405 }
 406
 407 /* Try to interpret the bytes between BUF and END as CFA instructions.
 408    If every byte makes sense, return a pointer to the first DW_CFA_nop
 409    padding byte, or END if there is no padding.  Return null otherwise.
 410    ENCODED_PTR_WIDTH is as for skip_cfa_op.  */
 411
 412 static bfd_byte *
 413 skip_non_nops (bfd_byte *buf, bfd_byte *end, unsigned int encoded_ptr_width,
 414                unsigned int *set_loc_count)
 415 {
 416   bfd_byte *last;
 417
 418   last = buf;
 419   while (buf < end)
 420     if (*buf == DW_CFA_nop)
 421       buf++;
 422     else
 423       {
 424         if (*buf == DW_CFA_set_loc)
 425           ++*set_loc_count;
 426         if (!skip_cfa_op (&buf, end, encoded_ptr_width))
 427           return 0;
 428         last = buf;
 429       }
 430   return last;
 431 }
 432
 433 /* Convert absolute encoding ENCODING into PC-relative form.
 434    SIZE is the size of a pointer.  */
 435
 436 static unsigned char
 437 make_pc_relative (unsigned char encoding, unsigned int ptr_size)
 438 {
 439   if ((encoding & 0x7f) == DW_EH_PE_absptr)
 440     switch (ptr_size)
 441       {
 442       case 2:
 443         encoding |= DW_EH_PE_sdata2;
 444         break;
 445       case 4:
 446         encoding |= DW_EH_PE_sdata4;
 447         break;
 448       case 8:
 449         encoding |= DW_EH_PE_sdata8;
 450         break;
 451       }
 452   return encoding | DW_EH_PE_pcrel;
 453 }
 454
 455 /*  Examine each .eh_frame_entry section and discard those
 456     those that are marked SEC_EXCLUDE.  */
 457
 458 static void
 459 bfd_elf_discard_eh_frame_entry (struct eh_frame_hdr_info *hdr_info)
 460 {
 461   unsigned int i;
 462   for (i = 0; i < hdr_info->array_count; i++)
 463     {
 464       if (hdr_info->u.compact.entries[i]->flags & SEC_EXCLUDE)
 465         {
 466           unsigned int j;
 467           for (j = i + 1; j < hdr_info->array_count; j++)
 468             hdr_info->u.compact.entries[j-1] = hdr_info->u.compact.entries[j];
 469
 470           hdr_info->array_count--;
 471           hdr_info->u.compact.entries[hdr_info->array_count] = NULL;
 472           i--;
 473         }
 474     }
 475 }
 476
 477 /* Add a .eh_frame_entry section.  */
 478
 479 static void
 480 bfd_elf_record_eh_frame_entry (struct eh_frame_hdr_info *hdr_info,
 481                                  asection *sec)
 482 {
 483   if (hdr_info->array_count == hdr_info->u.compact.allocated_entries)
 484     {
 485       if (hdr_info->u.compact.allocated_entries == 0)
 486         {
 487           hdr_info->frame_hdr_is_compact = TRUE;
 488           hdr_info->u.compact.allocated_entries = 2;
 489           hdr_info->u.compact.entries =
 490             bfd_malloc (hdr_info->u.compact.allocated_entries
 491                         * sizeof (hdr_info->u.compact.entries[0]));
 492         }
 493       else
 494         {
 495           hdr_info->u.compact.allocated_entries *= 2;
 496           hdr_info->u.compact.entries =
 497             bfd_realloc (hdr_info->u.compact.entries,
 498                          hdr_info->u.compact.allocated_entries
 499                            * sizeof (hdr_info->u.compact.entries[0]));
 500         }
 501
 502       BFD_ASSERT (hdr_info->u.compact.entries);
 503     }
 504
 505   hdr_info->u.compact.entries[hdr_info->array_count++] = sec;
 506 }
 507
 508 /* Parse a .eh_frame_entry section.  Figure out which text section it
 509    references.  */
 510
 511 bfd_boolean
 512 _bfd_elf_parse_eh_frame_entry (struct bfd_link_info *info,
 513                                asection *sec, struct elf_reloc_cookie *cookie)
 514 {
 515   struct elf_link_hash_table *htab;
 516   struct eh_frame_hdr_info *hdr_info;
 517   unsigned long r_symndx;
 518   asection *text_sec;
 519
 520   htab = elf_hash_table (info);
 521   hdr_info = &htab->eh_info;
 522
 523   if (sec->size == 0
 524       || sec->sec_info_type != SEC_INFO_TYPE_NONE)
 525     {
 526       return TRUE;
 527     }
 528
 529   if (sec->output_section && bfd_is_abs_section (sec->output_section))
 530     {
 531       /* At least one of the sections is being discarded from the
 532          link, so we should just ignore them.  */
 533       return TRUE;
 534     }
 535
 536   if (cookie->rel == cookie->relend)
 537     return FALSE;
 538
 539   /* The first relocation is the function start.  */
 540   r_symndx = cookie->rel->r_info >> cookie->r_sym_shift;
 541   if (r_symndx == STN_UNDEF)
 542     return FALSE;
 543
 544   text_sec = _bfd_elf_section_for_symbol (cookie, r_symndx, FALSE);
 545
 546   if (text_sec == NULL)
 547     return FALSE;
 548
 549   elf_section_eh_frame_entry (text_sec) = sec;
 550   if (text_sec->output_section
 551       && bfd_is_abs_section (text_sec->output_section))
 552     sec->flags |= SEC_EXCLUDE;
 553
 554   sec->sec_info_type = SEC_INFO_TYPE_EH_FRAME_ENTRY;
 555   elf_section_data (sec)->sec_info = text_sec;
 556   bfd_elf_record_eh_frame_entry (hdr_info, sec);
 557   return TRUE;
 558 }
 559
 560 /* Try to parse .eh_frame section SEC, which belongs to ABFD.  Store the
 561    information in the section's sec_info field on success.  COOKIE
 562    describes the relocations in SEC.  */
 563
 564 void
 565 _bfd_elf_parse_eh_frame (bfd *abfd, struct bfd_link_info *info,
 566                          asection *sec, struct elf_reloc_cookie *cookie)
 567 {
 568 #define REQUIRE(COND)                                   \
 569   do                                                    \
 570     if (!(COND))                                        \
 571       goto free_no_table;                               \
 572   while (0)
 573
 574   bfd_byte *ehbuf = NULL, *buf, *end;
 575   bfd_byte *last_fde;
 576   struct eh_cie_fde *this_inf;
 577   unsigned int hdr_length, hdr_id;
 578   unsigned int cie_count;
 579   struct cie *cie, *local_cies = NULL;
 580   struct elf_link_hash_table *htab;
 581   struct eh_frame_hdr_info *hdr_info;
 582   struct eh_frame_sec_info *sec_info = NULL;
 583   unsigned int ptr_size;
 584   unsigned int num_cies;
 585   unsigned int num_entries;
 586   elf_gc_mark_hook_fn gc_mark_hook;
 587
 588   htab = elf_hash_table (info);
 589   hdr_info = &htab->eh_info;
 590
 591   if (sec->size == 0
 592       || sec->sec_info_type != SEC_INFO_TYPE_NONE)
 593     {
 594       /* This file does not contain .eh_frame information.  */
 595       return;
 596     }
 597
 598   if (bfd_is_abs_section (sec->output_section))
 599     {
 600       /* At least one of the sections is being discarded from the
 601          link, so we should just ignore them.  */
 602       return;
 603     }
 604
 605   /* Read the frame unwind information from abfd.  */
 606
 607   REQUIRE (bfd_malloc_and_get_section (abfd, sec, &ehbuf));
 608
 609   if (sec->size >= 4
 610       && bfd_get_32 (abfd, ehbuf) == 0
 611       && cookie->rel == cookie->relend)
 612     {
 613       /* Empty .eh_frame section.  */
 614       free (ehbuf);
 615       return;
 616     }
 617
 618   /* If .eh_frame section size doesn't fit into int, we cannot handle
 619      it (it would need to use 64-bit .eh_frame format anyway).  */
 620   REQUIRE (sec->size == (unsigned int) sec->size);
 621
 622   ptr_size = (get_elf_backend_data (abfd)
 623               ->elf_backend_eh_frame_address_size (abfd, sec));
 624   REQUIRE (ptr_size != 0);
 625
 626   /* Go through the section contents and work out how many FDEs and
 627      CIEs there are.  */
 628   buf = ehbuf;
 629   end = ehbuf + sec->size;
 630   num_cies = 0;
 631   num_entries = 0;
 632   while (buf != end)
 633     {
 634       num_entries++;
 635
 636       /* Read the length of the entry.  */
 637       REQUIRE (skip_bytes (&buf, end, 4));
 638       hdr_length = bfd_get_32 (abfd, buf - 4);
 639
 640       /* 64-bit .eh_frame is not supported.  */
 641       REQUIRE (hdr_length != 0xffffffff);
 642       if (hdr_length == 0)
 643         break;
 644
 645       REQUIRE (skip_bytes (&buf, end, 4));
 646       hdr_id = bfd_get_32 (abfd, buf - 4);
 647       if (hdr_id == 0)
 648         num_cies++;
 649
 650       REQUIRE (skip_bytes (&buf, end, hdr_length - 4));
 651     }
 652
 653   sec_info = (struct eh_frame_sec_info *)
 654       bfd_zmalloc (sizeof (struct eh_frame_sec_info)
 655                    + (num_entries - 1) * sizeof (struct eh_cie_fde));
 656   REQUIRE (sec_info);
 657
 658   /* We need to have a "struct cie" for each CIE in this section.  */
 659   local_cies = (struct cie *) bfd_zmalloc (num_cies * sizeof (*local_cies));
 660   REQUIRE (local_cies);
 661
 662   /* FIXME: octets_per_byte.  */
 663 #define ENSURE_NO_RELOCS(buf)                           \
 664   while (cookie->rel < cookie->relend                   \
 665          && (cookie->rel->r_offset                      \
 666              < (bfd_size_type) ((buf) - ehbuf)))        \
 667     {                                                   \
 668       REQUIRE (cookie->rel->r_info == 0);               \
 669       cookie->rel++;                                    \
 670     }
 671
 672   /* FIXME: octets_per_byte.  */
 673 #define SKIP_RELOCS(buf)                                \
 674   while (cookie->rel < cookie->relend                   \
 675          && (cookie->rel->r_offset                      \
 676              < (bfd_size_type) ((buf) - ehbuf)))        \
 677     cookie->rel++
 678
 679   /* FIXME: octets_per_byte.  */
 680 #define GET_RELOC(buf)                                  \
 681   ((cookie->rel < cookie->relend                        \
 682     && (cookie->rel->r_offset                           \
 683         == (bfd_size_type) ((buf) - ehbuf)))            \
 684    ? cookie->rel : NULL)
 685
 686   buf = ehbuf;
 687   cie_count = 0;
 688   gc_mark_hook = get_elf_backend_data (abfd)->gc_mark_hook;
 689   while ((bfd_size_type) (buf - ehbuf) != sec->size)
 690     {
 691       char *aug;
 692       bfd_byte *start, *insns, *insns_end;
 693       bfd_size_type length;
 694       unsigned int set_loc_count;
 695
 696       this_inf = sec_info->entry + sec_info->count;
 697       last_fde = buf;
 698
 699       /* Read the length of the entry.  */
 700       REQUIRE (skip_bytes (&buf, ehbuf + sec->size, 4));
 701       hdr_length = bfd_get_32 (abfd, buf - 4);
 702
 703       /* The CIE/FDE must be fully contained in this input section.  */
 704       REQUIRE ((bfd_size_type) (buf - ehbuf) + hdr_length <= sec->size);
 705       end = buf + hdr_length;
 706
 707       this_inf->offset = last_fde - ehbuf;
 708       this_inf->size = 4 + hdr_length;
 709       this_inf->reloc_index = cookie->rel - cookie->rels;
 710
 711       if (hdr_length == 0)
 712         {
 713           /* A zero-length CIE should only be found at the end of
 714              the section.  */
 715           REQUIRE ((bfd_size_type) (buf - ehbuf) == sec->size);
 716           ENSURE_NO_RELOCS (buf);
 717           sec_info->count++;
 718           break;
 719         }
 720
 721       REQUIRE (skip_bytes (&buf, end, 4));
 722       hdr_id = bfd_get_32 (abfd, buf - 4);
 723
 724       if (hdr_id == 0)
 725         {
 726           unsigned int initial_insn_length;
 727
 728           /* CIE  */
 729           this_inf->cie = 1;
 730
 731           /* Point CIE to one of the section-local cie structures.  */
 732           cie = local_cies + cie_count++;
 733
 734           cie->cie_inf = this_inf;
 735           cie->length = hdr_length;
 736           start = buf;
 737           REQUIRE (read_byte (&buf, end, &cie->version));
 738
 739           /* Cannot handle unknown versions.  */
 740           REQUIRE (cie->version == 1
 741                    || cie->version == 3
 742                    || cie->version == 4);
 743           REQUIRE (strlen ((char *) buf) < sizeof (cie->augmentation));
 744
 745           strcpy (cie->augmentation, (char *) buf);
 746           buf = (bfd_byte *) strchr ((char *) buf, '\0') + 1;
 747           ENSURE_NO_RELOCS (buf);
 748           if (buf[0] == 'e' && buf[1] == 'h')
 749             {
 750               /* GCC < 3.0 .eh_frame CIE */
 751               /* We cannot merge "eh" CIEs because __EXCEPTION_TABLE__
 752                  is private to each CIE, so we don't need it for anything.
 753                  Just skip it.  */
 754               REQUIRE (skip_bytes (&buf, end, ptr_size));
 755               SKIP_RELOCS (buf);
 756             }
 757           if (cie->version >= 4)
 758             {
 759               REQUIRE (buf + 1 < end);
 760               REQUIRE (buf[0] == ptr_size);
 761               REQUIRE (buf[1] == 0);
 762               buf += 2;
 763             }
 764           REQUIRE (read_uleb128 (&buf, end, &cie->code_align));
 765           REQUIRE (read_sleb128 (&buf, end, &cie->data_align));
 766           if (cie->version == 1)
 767             {
 768               REQUIRE (buf < end);
 769               cie->ra_column = *buf++;
 770             }
 771           else
 772             REQUIRE (read_uleb128 (&buf, end, &cie->ra_column));
 773           ENSURE_NO_RELOCS (buf);
 774           cie->lsda_encoding = DW_EH_PE_omit;
 775           cie->fde_encoding = DW_EH_PE_omit;
 776           cie->per_encoding = DW_EH_PE_omit;
 777           aug = cie->augmentation;
 778           if (aug[0] != 'e' || aug[1] != 'h')
 779             {
 780               if (*aug == 'z')
 781                 {
 782                   aug++;
 783                   REQUIRE (read_uleb128 (&buf, end, &cie->augmentation_size));
 784                   ENSURE_NO_RELOCS (buf);
 785                 }
 786
 787               while (*aug != '\0')
 788                 switch (*aug++)
 789                   {
 790                   case 'L':
 791                     REQUIRE (read_byte (&buf, end, &cie->lsda_encoding));
 792                     ENSURE_NO_RELOCS (buf);
 793                     REQUIRE (get_DW_EH_PE_width (cie->lsda_encoding, ptr_size));
 794                     break;
 795                   case 'R':
 796                     REQUIRE (read_byte (&buf, end, &cie->fde_encoding));
 797                     ENSURE_NO_RELOCS (buf);
 798                     REQUIRE (get_DW_EH_PE_width (cie->fde_encoding, ptr_size));
 799                     break;
 800                   case 'S':
 801                     break;
 802                   case 'P':
 803                     {
 804                       int per_width;
 805
 806                       REQUIRE (read_byte (&buf, end, &cie->per_encoding));
 807                       per_width = get_DW_EH_PE_width (cie->per_encoding,
 808                                                       ptr_size);
 809                       REQUIRE (per_width);
 810                       if ((cie->per_encoding & 0x70) == DW_EH_PE_aligned)
 811                         {
 812                           length = -(buf - ehbuf) & (per_width - 1);
 813                           REQUIRE (skip_bytes (&buf, end, length));
 814                         }
 815                       this_inf->u.cie.personality_offset = buf - start;
 816                       ENSURE_NO_RELOCS (buf);
 817                       /* Ensure we have a reloc here.  */
 818                       REQUIRE (GET_RELOC (buf));
 819                       cie->personality.reloc_index
 820                         = cookie->rel - cookie->rels;
 821                       /* Cope with MIPS-style composite relocations.  */
 822                       do
 823                         cookie->rel++;
 824                       while (GET_RELOC (buf) != NULL);
 825                       REQUIRE (skip_bytes (&buf, end, per_width));
 826                     }
 827                     break;
 828                   default:
 829                     /* Unrecognized augmentation. Better bail out.  */
 830                     goto free_no_table;
 831                   }
 832             }
 833
 834           /* For shared libraries, try to get rid of as many RELATIVE relocs
 835              as possible.  */
 836           if (bfd_link_pic (info)
 837               && (get_elf_backend_data (abfd)
 838                   ->elf_backend_can_make_relative_eh_frame
 839                   (abfd, info, sec)))
 840             {
 841               if ((cie->fde_encoding & 0x70) == DW_EH_PE_absptr)
 842                 this_inf->make_relative = 1;
 843               /* If the CIE doesn't already have an 'R' entry, it's fairly
 844                  easy to add one, provided that there's no aligned data
 845                  after the augmentation string.  */
 846               else if (cie->fde_encoding == DW_EH_PE_omit
 847                        && (cie->per_encoding & 0x70) != DW_EH_PE_aligned)
 848                 {
 849                   if (*cie->augmentation == 0)
 850                     this_inf->add_augmentation_size = 1;
 851                   this_inf->u.cie.add_fde_encoding = 1;
 852                   this_inf->make_relative = 1;
 853                 }
 854
 855               if ((cie->lsda_encoding & 0x70) == DW_EH_PE_absptr)
 856                 cie->can_make_lsda_relative = 1;
 857             }
 858
 859           /* If FDE encoding was not specified, it defaults to
 860              DW_EH_absptr.  */
 861           if (cie->fde_encoding == DW_EH_PE_omit)
 862             cie->fde_encoding = DW_EH_PE_absptr;
 863
 864           initial_insn_length = end - buf;
 865           cie->initial_insn_length = initial_insn_length;
 866           memcpy (cie->initial_instructions, buf,
 867                   initial_insn_length <= sizeof (cie->initial_instructions)
 868                   ? initial_insn_length : sizeof (cie->initial_instructions));
 869           insns = buf;
 870           buf += initial_insn_length;
 871           ENSURE_NO_RELOCS (buf);
 872
 873           if (!bfd_link_relocatable (info))
 874             {
 875               /* Keep info for merging cies.  */
 876               this_inf->u.cie.u.full_cie = cie;
 877               this_inf->u.cie.per_encoding_relative
 878                 = (cie->per_encoding & 0x70) == DW_EH_PE_pcrel;
 879             }
 880         }
 881       else
 882         {
 883           /* Find the corresponding CIE.  */
 884           unsigned int cie_offset = this_inf->offset + 4 - hdr_id;
 885           for (cie = local_cies; cie < local_cies + cie_count; cie++)
 886             if (cie_offset == cie->cie_inf->offset)
 887               break;
 888
 889           /* Ensure this FDE references one of the CIEs in this input
 890              section.  */
 891           REQUIRE (cie != local_cies + cie_count);
 892           this_inf->u.fde.cie_inf = cie->cie_inf;
 893           this_inf->make_relative = cie->cie_inf->make_relative;
 894           this_inf->add_augmentation_size
 895             = cie->cie_inf->add_augmentation_size;
 896
 897           ENSURE_NO_RELOCS (buf);
 898           if ((sec->flags & SEC_LINKER_CREATED) == 0 || cookie->rels != NULL)
 899             {
 900               asection *rsec;
 901
 902               REQUIRE (GET_RELOC (buf));
 903
 904               /* Chain together the FDEs for each section.  */
 905               rsec = _bfd_elf_gc_mark_rsec (info, sec, gc_mark_hook,
 906                                             cookie, NULL);
 907               /* RSEC will be NULL if FDE was cleared out as it was belonging to
 908                  a discarded SHT_GROUP.  */
 909               if (rsec)
 910                 {
 911                   REQUIRE (rsec->owner == abfd);
 912                   this_inf->u.fde.next_for_section = elf_fde_list (rsec);
 913                   elf_fde_list (rsec) = this_inf;
 914                 }
 915             }
 916
 917           /* Skip the initial location and address range.  */
 918           start = buf;
 919           length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
 920           REQUIRE (skip_bytes (&buf, end, 2 * length));
 921
 922           SKIP_RELOCS (buf - length);
 923           if (!GET_RELOC (buf - length)
 924               && read_value (abfd, buf - length, length, FALSE) == 0)
 925             {
 926               (*info->callbacks->minfo)
 927                 (_("discarding zero address range FDE in %B(%A).\n"),
 928                  abfd, sec);
 929               this_inf->u.fde.cie_inf = NULL;
 930             }
 931
 932           /* Skip the augmentation size, if present.  */
 933           if (cie->augmentation[0] == 'z')
 934             REQUIRE (read_uleb128 (&buf, end, &length));
 935           else
 936             length = 0;
 937
 938           /* Of the supported augmentation characters above, only 'L'
 939              adds augmentation data to the FDE.  This code would need to
 940              be adjusted if any future augmentations do the same thing.  */
 941           if (cie->lsda_encoding != DW_EH_PE_omit)
 942             {
 943               SKIP_RELOCS (buf);
 944               if (cie->can_make_lsda_relative && GET_RELOC (buf))
 945                 cie->cie_inf->u.cie.make_lsda_relative = 1;
 946               this_inf->lsda_offset = buf - start;
 947               /* If there's no 'z' augmentation, we don't know where the
 948                  CFA insns begin.  Assume no padding.  */
 949               if (cie->augmentation[0] != 'z')
 950                 length = end - buf;
 951             }
 952
 953           /* Skip over the augmentation data.  */
 954           REQUIRE (skip_bytes (&buf, end, length));
 955           insns = buf;
 956
 957           buf = last_fde + 4 + hdr_length;
 958
 959           /* For NULL RSEC (cleared FDE belonging to a discarded section)
 960              the relocations are commonly cleared.  We do not sanity check if
 961              all these relocations are cleared as (1) relocations to
 962              .gcc_except_table will remain uncleared (they will get dropped
 963              with the drop of this unused FDE) and (2) BFD already safely drops
 964              relocations of any type to .eh_frame by
 965              elf_section_ignore_discarded_relocs.
 966              TODO: The .gcc_except_table entries should be also filtered as
 967              .eh_frame entries; or GCC could rather use COMDAT for them.  */
 968           SKIP_RELOCS (buf);
 969         }
 970
 971       /* Try to interpret the CFA instructions and find the first
 972          padding nop.  Shrink this_inf's size so that it doesn't
 973          include the padding.  */
 974       length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
 975       set_loc_count = 0;
 976       insns_end = skip_non_nops (insns, end, length, &set_loc_count);
 977       /* If we don't understand the CFA instructions, we can't know
 978          what needs to be adjusted there.  */
 979       if (insns_end == NULL
 980           /* For the time being we don't support DW_CFA_set_loc in
 981              CIE instructions.  */
 982           || (set_loc_count && this_inf->cie))
 983         goto free_no_table;
 984       this_inf->size -= end - insns_end;
 985       if (insns_end != end && this_inf->cie)
 986         {
 987           cie->initial_insn_length -= end - insns_end;
 988           cie->length -= end - insns_end;
 989         }
 990       if (set_loc_count
 991           && ((cie->fde_encoding & 0x70) == DW_EH_PE_pcrel
 992               || this_inf->make_relative))
 993         {
 994           unsigned int cnt;
 995           bfd_byte *p;
 996
 997           this_inf->set_loc = (unsigned int *)
 998               bfd_malloc ((set_loc_count + 1) * sizeof (unsigned int));
 999           REQUIRE (this_inf->set_loc);
1000           this_inf->set_loc[0] = set_loc_count;
1001           p = insns;
1002           cnt = 0;
1003           while (p < end)
1004             {
1005               if (*p == DW_CFA_set_loc)
1006                 this_inf->set_loc[++cnt] = p + 1 - start;
1007               REQUIRE (skip_cfa_op (&p, end, length));
1008             }
1009         }
1010
1011       this_inf->removed = 1;
1012       this_inf->fde_encoding = cie->fde_encoding;
1013       this_inf->lsda_encoding = cie->lsda_encoding;
1014       sec_info->count++;
1015     }
1016   BFD_ASSERT (sec_info->count == num_entries);
1017   BFD_ASSERT (cie_count == num_cies);
1018
1019   elf_section_data (sec)->sec_info = sec_info;
1020   sec->sec_info_type = SEC_INFO_TYPE_EH_FRAME;
1021   if (!bfd_link_relocatable (info))
1022     {
1023       /* Keep info for merging cies.  */
1024       sec_info->cies = local_cies;
1025       local_cies = NULL;
1026     }
1027   goto success;
1028
1029  free_no_table:
1030   (*info->callbacks->einfo)
1031     (_("%P: error in %B(%A); no .eh_frame_hdr table will be created.\n"),
1032      abfd, sec);
1033   hdr_info->u.dwarf.table = FALSE;
1034   if (sec_info)
1035     free (sec_info);
1036  success:
1037   if (ehbuf)
1038     free (ehbuf);
1039   if (local_cies)
1040     free (local_cies);
1041 #undef REQUIRE
1042 }
1043
1044 /* Order eh_frame_hdr entries by the VMA of their text section.  */
1045
1046 static int
1047 cmp_eh_frame_hdr (const void *a, const void *b)
1048 {
1049   bfd_vma text_a;
1050   bfd_vma text_b;
1051   asection *sec;
1052
1053   sec = *(asection *const *)a;
1054   sec = (asection *) elf_section_data (sec)->sec_info;
1055   text_a = sec->output_section->vma + sec->output_offset;
1056   sec = *(asection *const *)b;
1057   sec = (asection *) elf_section_data (sec)->sec_info;
1058   text_b = sec->output_section->vma + sec->output_offset;
1059
1060   if (text_a < text_b)
1061     return -1;
1062   return text_a > text_b;
1063
1064 }
1065
1066 /* Add space for a CANTUNWIND terminator to SEC if the text sections
1067    referenced by it and NEXT are not contiguous, or NEXT is NULL.  */
1068
1069 static void
1070 add_eh_frame_hdr_terminator (asection *sec,
1071                              asection *next)
1072 {
1073   bfd_vma end;
1074   bfd_vma next_start;
1075   asection *text_sec;
1076
1077   if (next)
1078     {
1079       /* See if there is a gap (presumably a text section without unwind info)
1080          between these two entries.  */
1081       text_sec = (asection *) elf_section_data (sec)->sec_info;
1082       end = text_sec->output_section->vma + text_sec->output_offset
1083             + text_sec->size;
1084       text_sec = (asection *) elf_section_data (next)->sec_info;
1085       next_start = text_sec->output_section->vma + text_sec->output_offset;
1086       if (end == next_start)
1087         return;
1088     }
1089
1090   /* Add space for a CANTUNWIND terminator.  */
1091   if (!sec->rawsize)
1092     sec->rawsize = sec->size;
1093
1094   bfd_set_section_size (sec->owner, sec, sec->size + 8);
1095 }
1096
1097 /* Finish a pass over all .eh_frame_entry sections.  */
1098
1099 bfd_boolean
1100 _bfd_elf_end_eh_frame_parsing (struct bfd_link_info *info)
1101 {
1102   struct eh_frame_hdr_info *hdr_info;
1103   unsigned int i;
1104
1105   hdr_info = &elf_hash_table (info)->eh_info;
1106
1107   if (info->eh_frame_hdr_type != COMPACT_EH_HDR
1108       || hdr_info->array_count == 0)
1109     return FALSE;
1110
1111   bfd_elf_discard_eh_frame_entry (hdr_info);
1112
1113   qsort (hdr_info->u.compact.entries, hdr_info->array_count,
1114          sizeof (asection *), cmp_eh_frame_hdr);
1115
1116   for (i = 0; i < hdr_info->array_count - 1; i++)
1117     {
1118       add_eh_frame_hdr_terminator (hdr_info->u.compact.entries[i],
1119                                    hdr_info->u.compact.entries[i + 1]);
1120     }
1121
1122   /* Add a CANTUNWIND terminator after the last entry.  */
1123   add_eh_frame_hdr_terminator (hdr_info->u.compact.entries[i], NULL);
1124   return TRUE;
1125 }
1126
1127 /* Mark all relocations against CIE or FDE ENT, which occurs in
1128    .eh_frame section SEC.  COOKIE describes the relocations in SEC;
1129    its "rel" field can be changed freely.  */
1130
1131 static bfd_boolean
1132 mark_entry (struct bfd_link_info *info, asection *sec,
1133             struct eh_cie_fde *ent, elf_gc_mark_hook_fn gc_mark_hook,
1134             struct elf_reloc_cookie *cookie)
1135 {
1136   /* FIXME: octets_per_byte.  */
1137   for (cookie->rel = cookie->rels + ent->reloc_index;
1138        cookie->rel < cookie->relend
1139          && cookie->rel->r_offset < ent->offset + ent->size;
1140        cookie->rel++)
1141     if (!_bfd_elf_gc_mark_reloc (info, sec, gc_mark_hook, cookie))
1142       return FALSE;
1143
1144   return TRUE;
1145 }
1146
1147 /* Mark all the relocations against FDEs that relate to code in input
1148    section SEC.  The FDEs belong to .eh_frame section EH_FRAME, whose
1149    relocations are described by COOKIE.  */
1150
1151 bfd_boolean
1152 _bfd_elf_gc_mark_fdes (struct bfd_link_info *info, asection *sec,
1153                        asection *eh_frame, elf_gc_mark_hook_fn gc_mark_hook,
1154                        struct elf_reloc_cookie *cookie)
1155 {
1156   struct eh_cie_fde *fde, *cie;
1157
1158   for (fde = elf_fde_list (sec); fde; fde = fde->u.fde.next_for_section)
1159     {
1160       if (!mark_entry (info, eh_frame, fde, gc_mark_hook, cookie))
1161         return FALSE;
1162
1163       /* At this stage, all cie_inf fields point to local CIEs, so we
1164          can use the same cookie to refer to them.  */
1165       cie = fde->u.fde.cie_inf;
1166       if (cie != NULL && !cie->u.cie.gc_mark)
1167         {
1168           cie->u.cie.gc_mark = 1;
1169           if (!mark_entry (info, eh_frame, cie, gc_mark_hook, cookie))
1170             return FALSE;
1171         }
1172     }
1173   return TRUE;
1174 }
1175
1176 /* Input section SEC of ABFD is an .eh_frame section that contains the
1177    CIE described by CIE_INF.  Return a version of CIE_INF that is going
1178    to be kept in the output, adding CIE_INF to the output if necessary.
1179
1180    HDR_INFO is the .eh_frame_hdr information and COOKIE describes the
1181    relocations in REL.  */
1182
1183 static struct eh_cie_fde *
1184 find_merged_cie (bfd *abfd, struct bfd_link_info *info, asection *sec,
1185                  struct eh_frame_hdr_info *hdr_info,
1186                  struct elf_reloc_cookie *cookie,
1187                  struct eh_cie_fde *cie_inf)
1188 {
1189   unsigned long r_symndx;
1190   struct cie *cie, *new_cie;
1191   Elf_Internal_Rela *rel;
1192   void **loc;
1193
1194   /* Use CIE_INF if we have already decided to keep it.  */
1195   if (!cie_inf->removed)
1196     return cie_inf;
1197
1198   /* If we have merged CIE_INF with another CIE, use that CIE instead.  */
1199   if (cie_inf->u.cie.merged)
1200     return cie_inf->u.cie.u.merged_with;
1201
1202   cie = cie_inf->u.cie.u.full_cie;
1203
1204   /* Assume we will need to keep CIE_INF.  */
1205   cie_inf->removed = 0;
1206   cie_inf->u.cie.u.sec = sec;
1207
1208   /* If we are not merging CIEs, use CIE_INF.  */
1209   if (cie == NULL)
1210     return cie_inf;
1211
1212   if (cie->per_encoding != DW_EH_PE_omit)
1213     {
1214       bfd_boolean per_binds_local;
1215
1216       /* Work out the address of personality routine, or at least
1217          enough info that we could calculate the address had we made a
1218          final section layout.  The symbol on the reloc is enough,
1219          either the hash for a global, or (bfd id, index) pair for a
1220          local.  The assumption here is that no one uses addends on
1221          the reloc.  */
1222       rel = cookie->rels + cie->personality.reloc_index;
1223       memset (&cie->personality, 0, sizeof (cie->personality));
1224 #ifdef BFD64
1225       if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64)
1226         r_symndx = ELF64_R_SYM (rel->r_info);
1227       else
1228 #endif
1229         r_symndx = ELF32_R_SYM (rel->r_info);
1230       if (r_symndx >= cookie->locsymcount
1231           || ELF_ST_BIND (cookie->locsyms[r_symndx].st_info) != STB_LOCAL)
1232         {
1233           struct elf_link_hash_entry *h;
1234
1235           r_symndx -= cookie->extsymoff;
1236           h = cookie->sym_hashes[r_symndx];
1237
1238           while (h->root.type == bfd_link_hash_indirect
1239                  || h->root.type == bfd_link_hash_warning)
1240             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1241
1242           cie->personality.h = h;
1243           per_binds_local = SYMBOL_REFERENCES_LOCAL (info, h);
1244         }
1245       else
1246         {
1247           Elf_Internal_Sym *sym;
1248           asection *sym_sec;
1249
1250           sym = &cookie->locsyms[r_symndx];
1251           sym_sec = bfd_section_from_elf_index (abfd, sym->st_shndx);
1252           if (sym_sec == NULL)
1253             return cie_inf;
1254
1255           if (sym_sec->kept_section != NULL)
1256             sym_sec = sym_sec->kept_section;
1257           if (sym_sec->output_section == NULL)
1258             return cie_inf;
1259
1260           cie->local_personality = 1;
1261           cie->personality.sym.bfd_id = abfd->id;
1262           cie->personality.sym.index = r_symndx;
1263           per_binds_local = TRUE;
1264         }
1265
1266       if (per_binds_local
1267           && bfd_link_pic (info)
1268           && (cie->per_encoding & 0x70) == DW_EH_PE_absptr
1269           && (get_elf_backend_data (abfd)
1270               ->elf_backend_can_make_relative_eh_frame (abfd, info, sec)))
1271         {
1272           cie_inf->u.cie.make_per_encoding_relative = 1;
1273           cie_inf->u.cie.per_encoding_relative = 1;
1274         }
1275     }
1276
1277   /* See if we can merge this CIE with an earlier one.  */
1278   cie_compute_hash (cie);
1279   if (hdr_info->u.dwarf.cies == NULL)
1280     {
1281       hdr_info->u.dwarf.cies = htab_try_create (1, cie_hash, cie_eq, free);
1282       if (hdr_info->u.dwarf.cies == NULL)
1283         return cie_inf;
1284     }
1285   loc = htab_find_slot_with_hash (hdr_info->u.dwarf.cies, cie,
1286                                   cie->hash, INSERT);
1287   if (loc == NULL)
1288     return cie_inf;
1289
1290   new_cie = (struct cie *) *loc;
1291   if (new_cie == NULL)
1292     {
1293       /* Keep CIE_INF and record it in the hash table.  */
1294       new_cie = (struct cie *) malloc (sizeof (struct cie));
1295       if (new_cie == NULL)
1296         return cie_inf;
1297
1298       memcpy (new_cie, cie, sizeof (struct cie));
1299       *loc = new_cie;
1300     }
1301   else
1302     {
1303       /* Merge CIE_INF with NEW_CIE->CIE_INF.  */
1304       cie_inf->removed = 1;
1305       cie_inf->u.cie.merged = 1;
1306       cie_inf->u.cie.u.merged_with = new_cie->cie_inf;
1307       if (cie_inf->u.cie.make_lsda_relative)
1308         new_cie->cie_inf->u.cie.make_lsda_relative = 1;
1309     }
1310   return new_cie->cie_inf;
1311 }
1312
1313 /* This function is called for each input file before the .eh_frame
1314    section is relocated.  It discards duplicate CIEs and FDEs for discarded
1315    functions.  The function returns TRUE iff any entries have been
1316    deleted.  */
1317
1318 bfd_boolean
1319 _bfd_elf_discard_section_eh_frame
1320    (bfd *abfd, struct bfd_link_info *info, asection *sec,
1321     bfd_boolean (*reloc_symbol_deleted_p) (bfd_vma, void *),
1322     struct elf_reloc_cookie *cookie)
1323 {
1324   struct eh_cie_fde *ent;
1325   struct eh_frame_sec_info *sec_info;
1326   struct eh_frame_hdr_info *hdr_info;
1327   unsigned int ptr_size, offset;
1328
1329   if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME)
1330     return FALSE;
1331
1332   sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
1333   if (sec_info == NULL)
1334     return FALSE;
1335
1336   ptr_size = (get_elf_backend_data (sec->owner)
1337               ->elf_backend_eh_frame_address_size (sec->owner, sec));
1338
1339   hdr_info = &elf_hash_table (info)->eh_info;
1340   for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1341     if (ent->size == 4)
1342       /* There should only be one zero terminator, on the last input
1343          file supplying .eh_frame (crtend.o).  Remove any others.  */
1344       ent->removed = sec->map_head.s != NULL;
1345     else if (!ent->cie && ent->u.fde.cie_inf != NULL)
1346       {
1347         bfd_boolean keep;
1348         if ((sec->flags & SEC_LINKER_CREATED) != 0 && cookie->rels == NULL)
1349           {
1350             unsigned int width
1351               = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1352             bfd_vma value
1353               = read_value (abfd, sec->contents + ent->offset + 8 + width,
1354                             width, get_DW_EH_PE_signed (ent->fde_encoding));
1355             keep = value != 0;
1356           }
1357         else
1358           {
1359             cookie->rel = cookie->rels + ent->reloc_index;
1360             /* FIXME: octets_per_byte.  */
1361             BFD_ASSERT (cookie->rel < cookie->relend
1362                         && cookie->rel->r_offset == ent->offset + 8);
1363             keep = !(*reloc_symbol_deleted_p) (ent->offset + 8, cookie);
1364           }
1365         if (keep)
1366           {
1367             if (bfd_link_pic (info)
1368                 && (((ent->fde_encoding & 0x70) == DW_EH_PE_absptr
1369                      && ent->make_relative == 0)
1370                     || (ent->fde_encoding & 0x70) == DW_EH_PE_aligned))
1371               {
1372                 /* If a shared library uses absolute pointers
1373                    which we cannot turn into PC relative,
1374                    don't create the binary search table,
1375                    since it is affected by runtime relocations.  */
1376                 hdr_info->u.dwarf.table = FALSE;
1377                 (*info->callbacks->einfo)
1378                   (_("%P: FDE encoding in %B(%A) prevents .eh_frame_hdr"
1379                      " table being created.\n"), abfd, sec);
1380               }
1381             ent->removed = 0;
1382             hdr_info->u.dwarf.fde_count++;
1383             ent->u.fde.cie_inf = find_merged_cie (abfd, info, sec, hdr_info,
1384                                                   cookie, ent->u.fde.cie_inf);
1385           }
1386       }
1387
1388   if (sec_info->cies)
1389     {
1390       free (sec_info->cies);
1391       sec_info->cies = NULL;
1392     }
1393
1394   offset = 0;
1395   for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1396     if (!ent->removed)
1397       {
1398         ent->new_offset = offset;
1399         offset += size_of_output_cie_fde (ent, ptr_size);
1400       }
1401
1402   sec->rawsize = sec->size;
1403   sec->size = offset;
1404   return offset != sec->rawsize;
1405 }
1406
1407 /* This function is called for .eh_frame_hdr section after
1408    _bfd_elf_discard_section_eh_frame has been called on all .eh_frame
1409    input sections.  It finalizes the size of .eh_frame_hdr section.  */
1410
1411 bfd_boolean
1412 _bfd_elf_discard_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
1413 {
1414   struct elf_link_hash_table *htab;
1415   struct eh_frame_hdr_info *hdr_info;
1416   asection *sec;
1417
1418   htab = elf_hash_table (info);
1419   hdr_info = &htab->eh_info;
1420
1421   if (!hdr_info->frame_hdr_is_compact && hdr_info->u.dwarf.cies != NULL)
1422     {
1423       htab_delete (hdr_info->u.dwarf.cies);
1424       hdr_info->u.dwarf.cies = NULL;
1425     }
1426
1427   sec = hdr_info->hdr_sec;
1428   if (sec == NULL)
1429     return FALSE;
1430
1431   if (info->eh_frame_hdr_type == COMPACT_EH_HDR)
1432     {
1433       /* For compact frames we only add the header.  The actual table comes
1434          from the .eh_frame_entry sections.  */
1435       sec->size = 8;
1436     }
1437   else
1438     {
1439       sec->size = EH_FRAME_HDR_SIZE;
1440       if (hdr_info->u.dwarf.table)
1441         sec->size += 4 + hdr_info->u.dwarf.fde_count * 8;
1442     }
1443
1444   elf_eh_frame_hdr (abfd) = sec;
1445   return TRUE;
1446 }
1447
1448 /* Return true if there is at least one non-empty .eh_frame section in
1449    input files.  Can only be called after ld has mapped input to
1450    output sections, and before sections are stripped.  */
1451
1452 bfd_boolean
1453 _bfd_elf_eh_frame_present (struct bfd_link_info *info)
1454 {
1455   asection *eh = bfd_get_section_by_name (info->output_bfd, ".eh_frame");
1456
1457   if (eh == NULL)
1458     return FALSE;
1459
1460   /* Count only sections which have at least a single CIE or FDE.
1461      There cannot be any CIE or FDE <= 8 bytes.  */
1462   for (eh = eh->map_head.s; eh != NULL; eh = eh->map_head.s)
1463     if (eh->size > 8)
1464       return TRUE;
1465
1466   return FALSE;
1467 }
1468
1469 /* Return true if there is at least one .eh_frame_entry section in
1470    input files.  */
1471
1472 bfd_boolean
1473 _bfd_elf_eh_frame_entry_present (struct bfd_link_info *info)
1474 {
1475   asection *o;
1476   bfd *abfd;
1477
1478   for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link.next)
1479     {
1480       for (o = abfd->sections; o; o = o->next)
1481         {
1482           const char *name = bfd_get_section_name (abfd, o);
1483
1484           if (strcmp (name, ".eh_frame_entry")
1485               && !bfd_is_abs_section (o->output_section))
1486             return TRUE;
1487         }
1488     }
1489   return FALSE;
1490 }
1491
1492 /* This function is called from size_dynamic_sections.
1493    It needs to decide whether .eh_frame_hdr should be output or not,
1494    because when the dynamic symbol table has been sized it is too late
1495    to strip sections.  */
1496
1497 bfd_boolean
1498 _bfd_elf_maybe_strip_eh_frame_hdr (struct bfd_link_info *info)
1499 {
1500   struct elf_link_hash_table *htab;
1501   struct eh_frame_hdr_info *hdr_info;
1502   struct bfd_link_hash_entry *bh = NULL;
1503   struct elf_link_hash_entry *h;
1504
1505   htab = elf_hash_table (info);
1506   hdr_info = &htab->eh_info;
1507   if (hdr_info->hdr_sec == NULL)
1508     return TRUE;
1509
1510   if (bfd_is_abs_section (hdr_info->hdr_sec->output_section)
1511       || info->eh_frame_hdr_type == 0
1512       || (info->eh_frame_hdr_type == DWARF2_EH_HDR
1513           && !_bfd_elf_eh_frame_present (info))
1514       || (info->eh_frame_hdr_type == COMPACT_EH_HDR
1515           && !_bfd_elf_eh_frame_entry_present (info)))
1516     {
1517       hdr_info->hdr_sec->flags |= SEC_EXCLUDE;
1518       hdr_info->hdr_sec = NULL;
1519       return TRUE;
1520     }
1521
1522   /* Add a hidden symbol so that systems without access to PHDRs can
1523      find the table.  */
1524   if (! (_bfd_generic_link_add_one_symbol
1525          (info, info->output_bfd, "__GNU_EH_FRAME_HDR", BSF_LOCAL,
1526           hdr_info->hdr_sec, 0, NULL, FALSE, FALSE, &bh)))
1527     return FALSE;
1528
1529   h = (struct elf_link_hash_entry *) bh;
1530   h->def_regular = 1;
1531   h->other = STV_HIDDEN;
1532   get_elf_backend_data
1533     (info->output_bfd)->elf_backend_hide_symbol (info, h, TRUE);
1534
1535   if (!hdr_info->frame_hdr_is_compact)
1536     hdr_info->u.dwarf.table = TRUE;
1537   return TRUE;
1538 }
1539
1540 /* Adjust an address in the .eh_frame section.  Given OFFSET within
1541    SEC, this returns the new offset in the adjusted .eh_frame section,
1542    or -1 if the address refers to a CIE/FDE which has been removed
1543    or to offset with dynamic relocation which is no longer needed.  */
1544
1545 bfd_vma
1546 _bfd_elf_eh_frame_section_offset (bfd *output_bfd ATTRIBUTE_UNUSED,
1547                                   struct bfd_link_info *info ATTRIBUTE_UNUSED,
1548                                   asection *sec,
1549                                   bfd_vma offset)
1550 {
1551   struct eh_frame_sec_info *sec_info;
1552   unsigned int lo, hi, mid;
1553
1554   if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME)
1555     return offset;
1556   sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
1557
1558   if (offset >= sec->rawsize)
1559     return offset - sec->rawsize + sec->size;
1560
1561   lo = 0;
1562   hi = sec_info->count;
1563   mid = 0;
1564   while (lo < hi)
1565     {
1566       mid = (lo + hi) / 2;
1567       if (offset < sec_info->entry[mid].offset)
1568         hi = mid;
1569       else if (offset
1570                >= sec_info->entry[mid].offset + sec_info->entry[mid].size)
1571         lo = mid + 1;
1572       else
1573         break;
1574     }
1575
1576   BFD_ASSERT (lo < hi);
1577
1578   /* FDE or CIE was removed.  */
1579   if (sec_info->entry[mid].removed)
1580     return (bfd_vma) -1;
1581
1582   /* If converting personality pointers to DW_EH_PE_pcrel, there will be
1583      no need for run-time relocation against the personality field.  */
1584   if (sec_info->entry[mid].cie
1585       && sec_info->entry[mid].u.cie.make_per_encoding_relative
1586       && offset == (sec_info->entry[mid].offset + 8
1587                     + sec_info->entry[mid].u.cie.personality_offset))
1588     return (bfd_vma) -2;
1589
1590   /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1591      relocation against FDE's initial_location field.  */
1592   if (!sec_info->entry[mid].cie
1593       && sec_info->entry[mid].make_relative
1594       && offset == sec_info->entry[mid].offset + 8)
1595     return (bfd_vma) -2;
1596
1597   /* If converting LSDA pointers to DW_EH_PE_pcrel, there will be no need
1598      for run-time relocation against LSDA field.  */
1599   if (!sec_info->entry[mid].cie
1600       && sec_info->entry[mid].u.fde.cie_inf->u.cie.make_lsda_relative
1601       && offset == (sec_info->entry[mid].offset + 8
1602                     + sec_info->entry[mid].lsda_offset))
1603     return (bfd_vma) -2;
1604
1605   /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1606      relocation against DW_CFA_set_loc's arguments.  */
1607   if (sec_info->entry[mid].set_loc
1608       && sec_info->entry[mid].make_relative
1609       && (offset >= sec_info->entry[mid].offset + 8
1610                     + sec_info->entry[mid].set_loc[1]))
1611     {
1612       unsigned int cnt;
1613
1614       for (cnt = 1; cnt <= sec_info->entry[mid].set_loc[0]; cnt++)
1615         if (offset == sec_info->entry[mid].offset + 8
1616                       + sec_info->entry[mid].set_loc[cnt])
1617           return (bfd_vma) -2;
1618     }
1619
1620   /* Any new augmentation bytes go before the first relocation.  */
1621   return (offset + sec_info->entry[mid].new_offset
1622           - sec_info->entry[mid].offset
1623           + extra_augmentation_string_bytes (sec_info->entry + mid)
1624           + extra_augmentation_data_bytes (sec_info->entry + mid));
1625 }
1626
1627 /* Write out .eh_frame_entry section.  Add CANTUNWIND terminator if needed.
1628    Also check that the contents look sane.  */
1629
1630 bfd_boolean
1631 _bfd_elf_write_section_eh_frame_entry (bfd *abfd, struct bfd_link_info *info,
1632                                        asection *sec, bfd_byte *contents)
1633 {
1634   const struct elf_backend_data *bed;
1635   bfd_byte cantunwind[8];
1636   bfd_vma addr;
1637   bfd_vma last_addr;
1638   bfd_vma offset;
1639   asection *text_sec = (asection *) elf_section_data (sec)->sec_info;
1640
1641   if (!sec->rawsize)
1642     sec->rawsize = sec->size;
1643
1644   BFD_ASSERT (sec->sec_info_type == SEC_INFO_TYPE_EH_FRAME_ENTRY);
1645
1646   /* Check to make sure that the text section corresponding to this eh_frame_entry
1647      section has not been excluded.  In particular, mips16 stub entries will be
1648      excluded outside of the normal process.  */
1649   if (sec->flags & SEC_EXCLUDE
1650       || text_sec->flags & SEC_EXCLUDE)
1651     return TRUE;
1652
1653   if (!bfd_set_section_contents (abfd, sec->output_section, contents,
1654                                  sec->output_offset, sec->rawsize))
1655       return FALSE;
1656
1657   last_addr = bfd_get_signed_32 (abfd, contents);
1658   /* Check that all the entries are in order.  */
1659   for (offset = 8; offset < sec->rawsize; offset += 8)
1660     {
1661       addr = bfd_get_signed_32 (abfd, contents + offset) + offset;
1662       if (addr <= last_addr)
1663         {
1664           (*_bfd_error_handler) (_("%B: %s not in order"), sec->owner, sec->name);
1665           return FALSE;
1666         }
1667
1668       last_addr = addr;
1669     }
1670
1671   addr = text_sec->output_section->vma + text_sec->output_offset
1672          + text_sec->size;
1673   addr &= ~1;
1674   addr -= (sec->output_section->vma + sec->output_offset + sec->rawsize);
1675   if (addr & 1)
1676     {
1677       (*_bfd_error_handler) (_("%B: %s invalid input section size"),
1678                              sec->owner, sec->name);
1679       bfd_set_error (bfd_error_bad_value);
1680       return FALSE;
1681     }
1682   if (last_addr >= addr + sec->rawsize)
1683     {
1684       (*_bfd_error_handler) (_("%B: %s points past end of text section"),
1685                              sec->owner, sec->name);
1686       bfd_set_error (bfd_error_bad_value);
1687       return FALSE;
1688     }
1689
1690   if (sec->size == sec->rawsize)
1691     return TRUE;
1692
1693   bed = get_elf_backend_data (abfd);
1694   BFD_ASSERT (sec->size == sec->rawsize + 8);
1695   BFD_ASSERT ((addr & 1) == 0);
1696   BFD_ASSERT (bed->cant_unwind_opcode);
1697
1698   bfd_put_32 (abfd, addr, cantunwind);
1699   bfd_put_32 (abfd, (*bed->cant_unwind_opcode) (info), cantunwind + 4);
1700   return bfd_set_section_contents (abfd, sec->output_section, cantunwind,
1701                                    sec->output_offset + sec->rawsize, 8);
1702 }
1703
1704 /* Write out .eh_frame section.  This is called with the relocated
1705    contents.  */
1706
1707 bfd_boolean
1708 _bfd_elf_write_section_eh_frame (bfd *abfd,
1709                                  struct bfd_link_info *info,
1710                                  asection *sec,
1711                                  bfd_byte *contents)
1712 {
1713   struct eh_frame_sec_info *sec_info;
1714   struct elf_link_hash_table *htab;
1715   struct eh_frame_hdr_info *hdr_info;
1716   unsigned int ptr_size;
1717   struct eh_cie_fde *ent;
1718   bfd_size_type sec_size;
1719
1720   if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME)
1721     /* FIXME: octets_per_byte.  */
1722     return bfd_set_section_contents (abfd, sec->output_section, contents,
1723                                      sec->output_offset, sec->size);
1724
1725   ptr_size = (get_elf_backend_data (abfd)
1726               ->elf_backend_eh_frame_address_size (abfd, sec));
1727   BFD_ASSERT (ptr_size != 0);
1728
1729   sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
1730   htab = elf_hash_table (info);
1731   hdr_info = &htab->eh_info;
1732
1733   if (hdr_info->u.dwarf.table && hdr_info->u.dwarf.array == NULL)
1734     {
1735       hdr_info->frame_hdr_is_compact = FALSE;
1736       hdr_info->u.dwarf.array = (struct eh_frame_array_ent *)
1737         bfd_malloc (hdr_info->u.dwarf.fde_count
1738                     * sizeof (*hdr_info->u.dwarf.array));
1739     }
1740   if (hdr_info->u.dwarf.array == NULL)
1741     hdr_info = NULL;
1742
1743   /* The new offsets can be bigger or smaller than the original offsets.
1744      We therefore need to make two passes over the section: one backward
1745      pass to move entries up and one forward pass to move entries down.
1746      The two passes won't interfere with each other because entries are
1747      not reordered  */
1748   for (ent = sec_info->entry + sec_info->count; ent-- != sec_info->entry;)
1749     if (!ent->removed && ent->new_offset > ent->offset)
1750       memmove (contents + ent->new_offset, contents + ent->offset, ent->size);
1751
1752   for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1753     if (!ent->removed && ent->new_offset < ent->offset)
1754       memmove (contents + ent->new_offset, contents + ent->offset, ent->size);
1755
1756   for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1757     {
1758       unsigned char *buf, *end;
1759       unsigned int new_size;
1760
1761       if (ent->removed)
1762         continue;
1763
1764       if (ent->size == 4)
1765         {
1766           /* Any terminating FDE must be at the end of the section.  */
1767           BFD_ASSERT (ent == sec_info->entry + sec_info->count - 1);
1768           continue;
1769         }
1770
1771       buf = contents + ent->new_offset;
1772       end = buf + ent->size;
1773       new_size = size_of_output_cie_fde (ent, ptr_size);
1774
1775       /* Update the size.  It may be shrinked.  */
1776       bfd_put_32 (abfd, new_size - 4, buf);
1777
1778       /* Filling the extra bytes with DW_CFA_nops.  */
1779       if (new_size != ent->size)
1780         memset (end, 0, new_size - ent->size);
1781
1782       if (ent->cie)
1783         {
1784           /* CIE */
1785           if (ent->make_relative
1786               || ent->u.cie.make_lsda_relative
1787               || ent->u.cie.per_encoding_relative)
1788             {
1789               char *aug;
1790               unsigned int action, extra_string, extra_data;
1791               unsigned int per_width, per_encoding;
1792
1793               /* Need to find 'R' or 'L' augmentation's argument and modify
1794                  DW_EH_PE_* value.  */
1795               action = ((ent->make_relative ? 1 : 0)
1796                         | (ent->u.cie.make_lsda_relative ? 2 : 0)
1797                         | (ent->u.cie.per_encoding_relative ? 4 : 0));
1798               extra_string = extra_augmentation_string_bytes (ent);
1799               extra_data = extra_augmentation_data_bytes (ent);
1800
1801               /* Skip length, id and version.  */
1802               buf += 9;
1803               aug = (char *) buf;
1804               buf += strlen (aug) + 1;
1805               skip_leb128 (&buf, end);
1806               skip_leb128 (&buf, end);
1807               skip_leb128 (&buf, end);
1808               if (*aug == 'z')
1809                 {
1810                   /* The uleb128 will always be a single byte for the kind
1811                      of augmentation strings that we're prepared to handle.  */
1812                   *buf++ += extra_data;
1813                   aug++;
1814                 }
1815
1816               /* Make room for the new augmentation string and data bytes.  */
1817               memmove (buf + extra_string + extra_data, buf, end - buf);
1818               memmove (aug + extra_string, aug, buf - (bfd_byte *) aug);
1819               buf += extra_string;
1820               end += extra_string + extra_data;
1821
1822               if (ent->add_augmentation_size)
1823                 {
1824                   *aug++ = 'z';
1825                   *buf++ = extra_data - 1;
1826                 }
1827               if (ent->u.cie.add_fde_encoding)
1828                 {
1829                   BFD_ASSERT (action & 1);
1830                   *aug++ = 'R';
1831                   *buf++ = make_pc_relative (DW_EH_PE_absptr, ptr_size);
1832                   action &= ~1;
1833                 }
1834
1835               while (action)
1836                 switch (*aug++)
1837                   {
1838                   case 'L':
1839                     if (action & 2)
1840                       {
1841                         BFD_ASSERT (*buf == ent->lsda_encoding);
1842                         *buf = make_pc_relative (*buf, ptr_size);
1843                         action &= ~2;
1844                       }
1845                     buf++;
1846                     break;
1847                   case 'P':
1848                     if (ent->u.cie.make_per_encoding_relative)
1849                       *buf = make_pc_relative (*buf, ptr_size);
1850                     per_encoding = *buf++;
1851                     per_width = get_DW_EH_PE_width (per_encoding, ptr_size);
1852                     BFD_ASSERT (per_width != 0);
1853                     BFD_ASSERT (((per_encoding & 0x70) == DW_EH_PE_pcrel)
1854                                 == ent->u.cie.per_encoding_relative);
1855                     if ((per_encoding & 0x70) == DW_EH_PE_aligned)
1856                       buf = (contents
1857                              + ((buf - contents + per_width - 1)
1858                                 & ~((bfd_size_type) per_width - 1)));
1859                     if (action & 4)
1860                       {
1861                         bfd_vma val;
1862
1863                         val = read_value (abfd, buf, per_width,
1864                                           get_DW_EH_PE_signed (per_encoding));
1865                         if (ent->u.cie.make_per_encoding_relative)
1866                           val -= (sec->output_section->vma
1867                                   + sec->output_offset
1868                                   + (buf - contents));
1869                         else
1870                           {
1871                             val += (bfd_vma) ent->offset - ent->new_offset;
1872                             val -= extra_string + extra_data;
1873                           }
1874                         write_value (abfd, buf, val, per_width);
1875                         action &= ~4;
1876                       }
1877                     buf += per_width;
1878                     break;
1879                   case 'R':
1880                     if (action & 1)
1881                       {
1882                         BFD_ASSERT (*buf == ent->fde_encoding);
1883                         *buf = make_pc_relative (*buf, ptr_size);
1884                         action &= ~1;
1885                       }
1886                     buf++;
1887                     break;
1888                   case 'S':
1889                     break;
1890                   default:
1891                     BFD_FAIL ();
1892                   }
1893             }
1894         }
1895       else
1896         {
1897           /* FDE */
1898           bfd_vma value, address;
1899           unsigned int width;
1900           bfd_byte *start;
1901           struct eh_cie_fde *cie;
1902
1903           /* Skip length.  */
1904           cie = ent->u.fde.cie_inf;
1905           buf += 4;
1906           value = ((ent->new_offset + sec->output_offset + 4)
1907                    - (cie->new_offset + cie->u.cie.u.sec->output_offset));
1908           bfd_put_32 (abfd, value, buf);
1909           if (bfd_link_relocatable (info))
1910             continue;
1911           buf += 4;
1912           width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1913           value = read_value (abfd, buf, width,
1914                               get_DW_EH_PE_signed (ent->fde_encoding));
1915           address = value;
1916           if (value)
1917             {
1918               switch (ent->fde_encoding & 0x70)
1919                 {
1920                 case DW_EH_PE_textrel:
1921                   BFD_ASSERT (hdr_info == NULL);
1922                   break;
1923                 case DW_EH_PE_datarel:
1924                   {
1925                     switch (abfd->arch_info->arch)
1926                       {
1927                       case bfd_arch_ia64:
1928                         BFD_ASSERT (elf_gp (abfd) != 0);
1929                         address += elf_gp (abfd);
1930                         break;
1931                       default:
1932                         (*info->callbacks->einfo)
1933                           (_("%P: DW_EH_PE_datarel unspecified"
1934                              " for this architecture.\n"));
1935                         /* Fall thru */
1936                       case bfd_arch_frv:
1937                       case bfd_arch_i386:
1938                         BFD_ASSERT (htab->hgot != NULL
1939                                     && ((htab->hgot->root.type
1940                                          == bfd_link_hash_defined)
1941                                         || (htab->hgot->root.type
1942                                             == bfd_link_hash_defweak)));
1943                         address
1944                           += (htab->hgot->root.u.def.value
1945                               + htab->hgot->root.u.def.section->output_offset
1946                               + (htab->hgot->root.u.def.section->output_section
1947                                  ->vma));
1948                         break;
1949                       }
1950                   }
1951                   break;
1952                 case DW_EH_PE_pcrel:
1953                   value += (bfd_vma) ent->offset - ent->new_offset;
1954                   address += (sec->output_section->vma
1955                               + sec->output_offset
1956                               + ent->offset + 8);
1957                   break;
1958                 }
1959               if (ent->make_relative)
1960                 value -= (sec->output_section->vma
1961                           + sec->output_offset
1962                           + ent->new_offset + 8);
1963               write_value (abfd, buf, value, width);
1964             }
1965
1966           start = buf;
1967
1968           if (hdr_info)
1969             {
1970               /* The address calculation may overflow, giving us a
1971                  value greater than 4G on a 32-bit target when
1972                  dwarf_vma is 64-bit.  */
1973               if (sizeof (address) > 4 && ptr_size == 4)
1974                 address &= 0xffffffff;
1975               hdr_info->u.dwarf.array[hdr_info->array_count].initial_loc
1976                 = address;
1977               hdr_info->u.dwarf.array[hdr_info->array_count].range
1978                 = read_value (abfd, buf + width, width, FALSE);
1979               hdr_info->u.dwarf.array[hdr_info->array_count++].fde
1980                 = (sec->output_section->vma
1981                    + sec->output_offset
1982                    + ent->new_offset);
1983             }
1984
1985           if ((ent->lsda_encoding & 0x70) == DW_EH_PE_pcrel
1986               || cie->u.cie.make_lsda_relative)
1987             {
1988               buf += ent->lsda_offset;
1989               width = get_DW_EH_PE_width (ent->lsda_encoding, ptr_size);
1990               value = read_value (abfd, buf, width,
1991                                   get_DW_EH_PE_signed (ent->lsda_encoding));
1992               if (value)
1993                 {
1994                   if ((ent->lsda_encoding & 0x70) == DW_EH_PE_pcrel)
1995                     value += (bfd_vma) ent->offset - ent->new_offset;
1996                   else if (cie->u.cie.make_lsda_relative)
1997                     value -= (sec->output_section->vma
1998                               + sec->output_offset
1999                               + ent->new_offset + 8 + ent->lsda_offset);
2000                   write_value (abfd, buf, value, width);
2001                 }
2002             }
2003           else if (ent->add_augmentation_size)
2004             {
2005               /* Skip the PC and length and insert a zero byte for the
2006                  augmentation size.  */
2007               buf += width * 2;
2008               memmove (buf + 1, buf, end - buf);
2009               *buf = 0;
2010             }
2011
2012           if (ent->set_loc)
2013             {
2014               /* Adjust DW_CFA_set_loc.  */
2015               unsigned int cnt;
2016               bfd_vma new_offset;
2017
2018               width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
2019               new_offset = ent->new_offset + 8
2020                            + extra_augmentation_string_bytes (ent)
2021                            + extra_augmentation_data_bytes (ent);
2022
2023               for (cnt = 1; cnt <= ent->set_loc[0]; cnt++)
2024                 {
2025                   buf = start + ent->set_loc[cnt];
2026
2027                   value = read_value (abfd, buf, width,
2028                                       get_DW_EH_PE_signed (ent->fde_encoding));
2029                   if (!value)
2030                     continue;
2031
2032                   if ((ent->fde_encoding & 0x70) == DW_EH_PE_pcrel)
2033                     value += (bfd_vma) ent->offset + 8 - new_offset;
2034                   if (ent->make_relative)
2035                     value -= (sec->output_section->vma
2036                               + sec->output_offset
2037                               + new_offset + ent->set_loc[cnt]);
2038                   write_value (abfd, buf, value, width);
2039                 }
2040             }
2041         }
2042     }
2043
2044   /* We don't align the section to its section alignment since the
2045      runtime library only expects all CIE/FDE records aligned at
2046      the pointer size. _bfd_elf_discard_section_eh_frame should
2047      have padded CIE/FDE records to multiple of pointer size with
2048      size_of_output_cie_fde.  */
2049   sec_size = sec->size;
2050   if (sec_info->count != 0
2051       && sec_info->entry[sec_info->count - 1].size == 4)
2052     sec_size -= 4;
2053   if ((sec_size % ptr_size) != 0)
2054     abort ();
2055
2056   /* FIXME: octets_per_byte.  */
2057   return bfd_set_section_contents (abfd, sec->output_section,
2058                                    contents, (file_ptr) sec->output_offset,
2059                                    sec->size);
2060 }
2061
2062 /* Helper function used to sort .eh_frame_hdr search table by increasing
2063    VMA of FDE initial location.  */
2064
2065 static int
2066 vma_compare (const void *a, const void *b)
2067 {
2068   const struct eh_frame_array_ent *p = (const struct eh_frame_array_ent *) a;
2069   const struct eh_frame_array_ent *q = (const struct eh_frame_array_ent *) b;
2070   if (p->initial_loc > q->initial_loc)
2071     return 1;
2072   if (p->initial_loc < q->initial_loc)
2073     return -1;
2074   if (p->range > q->range)
2075     return 1;
2076   if (p->range < q->range)
2077     return -1;
2078   return 0;
2079 }
2080
2081 /* Reorder .eh_frame_entry sections to match the associated text sections.
2082    This routine is called during the final linking step, just before writing
2083    the contents.  At this stage, sections in the eh_frame_hdr_info are already
2084    sorted in order of increasing text section address and so we simply need
2085    to make the .eh_frame_entrys follow that same order.  Note that it is
2086    invalid for a linker script to try to force a particular order of
2087    .eh_frame_entry sections.  */
2088
2089 bfd_boolean
2090 _bfd_elf_fixup_eh_frame_hdr (struct bfd_link_info *info)
2091 {
2092   asection *sec = NULL;
2093   asection *osec;
2094   struct eh_frame_hdr_info *hdr_info;
2095   unsigned int i;
2096   bfd_vma offset;
2097   struct bfd_link_order *p;
2098
2099   hdr_info = &elf_hash_table (info)->eh_info;
2100
2101   if (hdr_info->hdr_sec == NULL
2102       || info->eh_frame_hdr_type != COMPACT_EH_HDR
2103       || hdr_info->array_count == 0)
2104     return TRUE;
2105
2106   /* Change section output offsets to be in text section order.  */
2107   offset = 8;
2108   osec = hdr_info->u.compact.entries[0]->output_section;
2109   for (i = 0; i < hdr_info->array_count; i++)
2110     {
2111       sec = hdr_info->u.compact.entries[i];
2112       if (sec->output_section != osec)
2113         {
2114           (*_bfd_error_handler)
2115             (_("Invalid output section for .eh_frame_entry: %s"),
2116              sec->output_section->name);
2117           return FALSE;
2118         }
2119       sec->output_offset = offset;
2120       offset += sec->size;
2121     }
2122
2123
2124   /* Fix the link_order to match.  */
2125   for (p = sec->output_section->map_head.link_order; p != NULL; p = p->next)
2126     {
2127       if (p->type != bfd_indirect_link_order)
2128         abort();
2129
2130       p->offset = p->u.indirect.section->output_offset;
2131       if (p->next != NULL)
2132         i--;
2133     }
2134
2135   if (i != 0)
2136     {
2137       (*_bfd_error_handler)
2138         (_("Invalid contents in %s section"), osec->name);
2139       return FALSE;
2140     }
2141
2142   return TRUE;
2143 }
2144
2145 /* The .eh_frame_hdr format for Compact EH frames:
2146    ubyte version                (2)
2147    ubyte eh_ref_enc             (DW_EH_PE_* encoding of typinfo references)
2148    uint32_t count               (Number of entries in table)
2149    [array from .eh_frame_entry sections]  */
2150
2151 static bfd_boolean
2152 write_compact_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
2153 {
2154   struct elf_link_hash_table *htab;
2155   struct eh_frame_hdr_info *hdr_info;
2156   asection *sec;
2157   const struct elf_backend_data *bed;
2158   bfd_vma count;
2159   bfd_byte contents[8];
2160   unsigned int i;
2161
2162   htab = elf_hash_table (info);
2163   hdr_info = &htab->eh_info;
2164   sec = hdr_info->hdr_sec;
2165
2166   if (sec->size != 8)
2167     abort();
2168
2169   for (i = 0; i < sizeof (contents); i++)
2170     contents[i] = 0;
2171
2172   contents[0] = COMPACT_EH_HDR;
2173   bed = get_elf_backend_data (abfd);
2174
2175   BFD_ASSERT (bed->compact_eh_encoding);
2176   contents[1] = (*bed->compact_eh_encoding) (info);
2177
2178   count = (sec->output_section->size - 8) / 8;
2179   bfd_put_32 (abfd, count, contents + 4);
2180   return bfd_set_section_contents (abfd, sec->output_section, contents,
2181                                    (file_ptr) sec->output_offset, sec->size);
2182 }
2183
2184 /* The .eh_frame_hdr format for DWARF frames:
2185
2186    ubyte version                (currently 1)
2187    ubyte eh_frame_ptr_enc       (DW_EH_PE_* encoding of pointer to start of
2188                                  .eh_frame section)
2189    ubyte fde_count_enc          (DW_EH_PE_* encoding of total FDE count
2190                                  number (or DW_EH_PE_omit if there is no
2191                                  binary search table computed))
2192    ubyte table_enc              (DW_EH_PE_* encoding of binary search table,
2193                                  or DW_EH_PE_omit if not present.
2194                                  DW_EH_PE_datarel is using address of
2195                                  .eh_frame_hdr section start as base)
2196    [encoded] eh_frame_ptr       (pointer to start of .eh_frame section)
2197    optionally followed by:
2198    [encoded] fde_count          (total number of FDEs in .eh_frame section)
2199    fde_count x [encoded] initial_loc, fde
2200                                 (array of encoded pairs containing
2201                                  FDE initial_location field and FDE address,
2202                                  sorted by increasing initial_loc).  */
2203
2204 static bfd_boolean
2205 write_dwarf_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
2206 {
2207   struct elf_link_hash_table *htab;
2208   struct eh_frame_hdr_info *hdr_info;
2209   asection *sec;
2210   bfd_boolean retval = TRUE;
2211
2212   htab = elf_hash_table (info);
2213   hdr_info = &htab->eh_info;
2214   sec = hdr_info->hdr_sec;
2215   bfd_byte *contents;
2216   asection *eh_frame_sec;
2217   bfd_size_type size;
2218   bfd_vma encoded_eh_frame;
2219
2220   size = EH_FRAME_HDR_SIZE;
2221   if (hdr_info->u.dwarf.array
2222       && hdr_info->array_count == hdr_info->u.dwarf.fde_count)
2223     size += 4 + hdr_info->u.dwarf.fde_count * 8;
2224   contents = (bfd_byte *) bfd_malloc (size);
2225   if (contents == NULL)
2226     return FALSE;
2227
2228   eh_frame_sec = bfd_get_section_by_name (abfd, ".eh_frame");
2229   if (eh_frame_sec == NULL)
2230     {
2231       free (contents);
2232       return FALSE;
2233     }
2234
2235   memset (contents, 0, EH_FRAME_HDR_SIZE);
2236   /* Version.  */
2237   contents[0] = 1;
2238   /* .eh_frame offset.  */
2239   contents[1] = get_elf_backend_data (abfd)->elf_backend_encode_eh_address
2240     (abfd, info, eh_frame_sec, 0, sec, 4, &encoded_eh_frame);
2241
2242   if (hdr_info->u.dwarf.array
2243       && hdr_info->array_count == hdr_info->u.dwarf.fde_count)
2244     {
2245       /* FDE count encoding.  */
2246       contents[2] = DW_EH_PE_udata4;
2247       /* Search table encoding.  */
2248       contents[3] = DW_EH_PE_datarel | DW_EH_PE_sdata4;
2249     }
2250   else
2251     {
2252       contents[2] = DW_EH_PE_omit;
2253       contents[3] = DW_EH_PE_omit;
2254     }
2255   bfd_put_32 (abfd, encoded_eh_frame, contents + 4);
2256
2257   if (contents[2] != DW_EH_PE_omit)
2258     {
2259       unsigned int i;
2260       bfd_boolean overlap, overflow;
2261
2262       bfd_put_32 (abfd, hdr_info->u.dwarf.fde_count,
2263                   contents + EH_FRAME_HDR_SIZE);
2264       qsort (hdr_info->u.dwarf.array, hdr_info->u.dwarf.fde_count,
2265              sizeof (*hdr_info->u.dwarf.array), vma_compare);
2266       overlap = FALSE;
2267       overflow = FALSE;
2268       for (i = 0; i < hdr_info->u.dwarf.fde_count; i++)
2269         {
2270           bfd_vma val;
2271
2272           val = hdr_info->u.dwarf.array[i].initial_loc
2273             - sec->output_section->vma;
2274           val = ((val & 0xffffffff) ^ 0x80000000) - 0x80000000;
2275           if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64
2276               && (hdr_info->u.dwarf.array[i].initial_loc
2277                   != sec->output_section->vma + val))
2278             overflow = TRUE;
2279           bfd_put_32 (abfd, val, contents + EH_FRAME_HDR_SIZE + i * 8 + 4);
2280           val = hdr_info->u.dwarf.array[i].fde - sec->output_section->vma;
2281           val = ((val & 0xffffffff) ^ 0x80000000) - 0x80000000;
2282           if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64
2283               && (hdr_info->u.dwarf.array[i].fde
2284                   != sec->output_section->vma + val))
2285             overflow = TRUE;
2286           bfd_put_32 (abfd, val, contents + EH_FRAME_HDR_SIZE + i * 8 + 8);
2287           if (i != 0
2288               && (hdr_info->u.dwarf.array[i].initial_loc
2289                   < (hdr_info->u.dwarf.array[i - 1].initial_loc
2290                      + hdr_info->u.dwarf.array[i - 1].range)))
2291             overlap = TRUE;
2292         }
2293       if (overflow)
2294         (*info->callbacks->einfo) (_("%P: .eh_frame_hdr entry overflow.\n"));
2295       if (overlap)
2296         (*info->callbacks->einfo)
2297           (_("%P: .eh_frame_hdr refers to overlapping FDEs.\n"));
2298       if (overflow || overlap)
2299         {
2300           bfd_set_error (bfd_error_bad_value);
2301           retval = FALSE;
2302         }
2303     }
2304
2305   /* FIXME: octets_per_byte.  */
2306   if (!bfd_set_section_contents (abfd, sec->output_section, contents,
2307                                  (file_ptr) sec->output_offset,
2308                                  sec->size))
2309     retval = FALSE;
2310   free (contents);
2311
2312   if (hdr_info->u.dwarf.array != NULL)
2313     free (hdr_info->u.dwarf.array);
2314   return retval;
2315 }
2316
2317 /* Write out .eh_frame_hdr section.  This must be called after
2318    _bfd_elf_write_section_eh_frame has been called on all input
2319    .eh_frame sections.  */
2320
2321 bfd_boolean
2322 _bfd_elf_write_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
2323 {
2324   struct elf_link_hash_table *htab;
2325   struct eh_frame_hdr_info *hdr_info;
2326   asection *sec;
2327
2328   htab = elf_hash_table (info);
2329   hdr_info = &htab->eh_info;
2330   sec = hdr_info->hdr_sec;
2331
2332   if (info->eh_frame_hdr_type == 0 || sec == NULL)
2333     return TRUE;
2334
2335   if (info->eh_frame_hdr_type == COMPACT_EH_HDR)
2336     return write_compact_eh_frame_hdr (abfd, info);
2337   else
2338     return write_dwarf_eh_frame_hdr (abfd, info);
2339 }
2340
2341 /* Return the width of FDE addresses.  This is the default implementation.  */
2342
2343 unsigned int
2344 _bfd_elf_eh_frame_address_size (bfd *abfd, asection *sec ATTRIBUTE_UNUSED)
2345 {
2346   return elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64 ? 8 : 4;
2347 }
2348
2349 /* Decide whether we can use a PC-relative encoding within the given
2350    EH frame section.  This is the default implementation.  */
2351
2352 bfd_boolean
2353 _bfd_elf_can_make_relative (bfd *input_bfd ATTRIBUTE_UNUSED,
2354                             struct bfd_link_info *info ATTRIBUTE_UNUSED,
2355                             asection *eh_frame_section ATTRIBUTE_UNUSED)
2356 {
2357   return TRUE;
2358 }
2359
2360 /* Select an encoding for the given address.  Preference is given to
2361    PC-relative addressing modes.  */
2362
2363 bfd_byte
2364 _bfd_elf_encode_eh_address (bfd *abfd ATTRIBUTE_UNUSED,
2365                             struct bfd_link_info *info ATTRIBUTE_UNUSED,
2366                             asection *osec, bfd_vma offset,
2367                             asection *loc_sec, bfd_vma loc_offset,
2368                             bfd_vma *encoded)
2369 {
2370   *encoded = osec->vma + offset -
2371     (loc_sec->output_section->vma + loc_sec->output_offset + loc_offset);
2372   return DW_EH_PE_pcrel | DW_EH_PE_sdata4;
2373 }