bfd/elf-eh-frame.c

   1 /* .eh_frame section optimization.
   2    Copyright (C) 2001-2015 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, cookie);
 906               /* RSEC will be NULL if FDE was cleared out as it was belonging to
 907                  a discarded SHT_GROUP.  */
 908               if (rsec)
 909                 {
 910                   REQUIRE (rsec->owner == abfd);
 911                   this_inf->u.fde.next_for_section = elf_fde_list (rsec);
 912                   elf_fde_list (rsec) = this_inf;
 913                 }
 914             }
 915
 916           /* Skip the initial location and address range.  */
 917           start = buf;
 918           length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
 919           REQUIRE (skip_bytes (&buf, end, 2 * length));
 920
 921           SKIP_RELOCS (buf - length);
 922           if (!GET_RELOC (buf - length)
 923               && read_value (abfd, buf - length, length, FALSE) == 0)
 924             {
 925               (*info->callbacks->minfo)
 926                 (_("discarding zero address range FDE in %B(%A).\n"),
 927                  abfd, sec);
 928               this_inf->u.fde.cie_inf = NULL;
 929             }
 930
 931           /* Skip the augmentation size, if present.  */
 932           if (cie->augmentation[0] == 'z')
 933             REQUIRE (read_uleb128 (&buf, end, &length));
 934           else
 935             length = 0;
 936
 937           /* Of the supported augmentation characters above, only 'L'
 938              adds augmentation data to the FDE.  This code would need to
 939              be adjusted if any future augmentations do the same thing.  */
 940           if (cie->lsda_encoding != DW_EH_PE_omit)
 941             {
 942               SKIP_RELOCS (buf);
 943               if (cie->can_make_lsda_relative && GET_RELOC (buf))
 944                 cie->cie_inf->u.cie.make_lsda_relative = 1;
 945               this_inf->lsda_offset = buf - start;
 946               /* If there's no 'z' augmentation, we don't know where the
 947                  CFA insns begin.  Assume no padding.  */
 948               if (cie->augmentation[0] != 'z')
 949                 length = end - buf;
 950             }
 951
 952           /* Skip over the augmentation data.  */
 953           REQUIRE (skip_bytes (&buf, end, length));
 954           insns = buf;
 955
 956           buf = last_fde + 4 + hdr_length;
 957
 958           /* For NULL RSEC (cleared FDE belonging to a discarded section)
 959              the relocations are commonly cleared.  We do not sanity check if
 960              all these relocations are cleared as (1) relocations to
 961              .gcc_except_table will remain uncleared (they will get dropped
 962              with the drop of this unused FDE) and (2) BFD already safely drops
 963              relocations of any type to .eh_frame by
 964              elf_section_ignore_discarded_relocs.
 965              TODO: The .gcc_except_table entries should be also filtered as
 966              .eh_frame entries; or GCC could rather use COMDAT for them.  */
 967           SKIP_RELOCS (buf);
 968         }
 969
 970       /* Try to interpret the CFA instructions and find the first
 971          padding nop.  Shrink this_inf's size so that it doesn't
 972          include the padding.  */
 973       length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
 974       set_loc_count = 0;
 975       insns_end = skip_non_nops (insns, end, length, &set_loc_count);
 976       /* If we don't understand the CFA instructions, we can't know
 977          what needs to be adjusted there.  */
 978       if (insns_end == NULL
 979           /* For the time being we don't support DW_CFA_set_loc in
 980              CIE instructions.  */
 981           || (set_loc_count && this_inf->cie))
 982         goto free_no_table;
 983       this_inf->size -= end - insns_end;
 984       if (insns_end != end && this_inf->cie)
 985         {
 986           cie->initial_insn_length -= end - insns_end;
 987           cie->length -= end - insns_end;
 988         }
 989       if (set_loc_count
 990           && ((cie->fde_encoding & 0x70) == DW_EH_PE_pcrel
 991               || this_inf->make_relative))
 992         {
 993           unsigned int cnt;
 994           bfd_byte *p;
 995
 996           this_inf->set_loc = (unsigned int *)
 997               bfd_malloc ((set_loc_count + 1) * sizeof (unsigned int));
 998           REQUIRE (this_inf->set_loc);
 999           this_inf->set_loc[0] = set_loc_count;
1000           p = insns;
1001           cnt = 0;
1002           while (p < end)
1003             {
1004               if (*p == DW_CFA_set_loc)
1005                 this_inf->set_loc[++cnt] = p + 1 - start;
1006               REQUIRE (skip_cfa_op (&p, end, length));
1007             }
1008         }
1009
1010       this_inf->removed = 1;
1011       this_inf->fde_encoding = cie->fde_encoding;
1012       this_inf->lsda_encoding = cie->lsda_encoding;
1013       sec_info->count++;
1014     }
1015   BFD_ASSERT (sec_info->count == num_entries);
1016   BFD_ASSERT (cie_count == num_cies);
1017
1018   elf_section_data (sec)->sec_info = sec_info;
1019   sec->sec_info_type = SEC_INFO_TYPE_EH_FRAME;
1020   if (!bfd_link_relocatable (info))
1021     {
1022       /* Keep info for merging cies.  */
1023       sec_info->cies = local_cies;
1024       local_cies = NULL;
1025     }
1026   goto success;
1027
1028  free_no_table:
1029   (*info->callbacks->einfo)
1030     (_("%P: error in %B(%A); no .eh_frame_hdr table will be created.\n"),
1031      abfd, sec);
1032   hdr_info->u.dwarf.table = FALSE;
1033   if (sec_info)
1034     free (sec_info);
1035  success:
1036   if (ehbuf)
1037     free (ehbuf);
1038   if (local_cies)
1039     free (local_cies);
1040 #undef REQUIRE
1041 }
1042
1043 /* Order eh_frame_hdr entries by the VMA of their text section.  */
1044
1045 static int
1046 cmp_eh_frame_hdr (const void *a, const void *b)
1047 {
1048   bfd_vma text_a;
1049   bfd_vma text_b;
1050   asection *sec;
1051
1052   sec = *(asection *const *)a;
1053   sec = (asection *) elf_section_data (sec)->sec_info;
1054   text_a = sec->output_section->vma + sec->output_offset;
1055   sec = *(asection *const *)b;
1056   sec = (asection *) elf_section_data (sec)->sec_info;
1057   text_b = sec->output_section->vma + sec->output_offset;
1058
1059   if (text_a < text_b)
1060     return -1;
1061   return text_a > text_b;
1062
1063 }
1064
1065 /* Add space for a CANTUNWIND terminator to SEC if the text sections
1066    referenced by it and NEXT are not contiguous, or NEXT is NULL.  */
1067
1068 static void
1069 add_eh_frame_hdr_terminator (asection *sec,
1070                              asection *next)
1071 {
1072   bfd_vma end;
1073   bfd_vma next_start;
1074   asection *text_sec;
1075
1076   if (next)
1077     {
1078       /* See if there is a gap (presumably a text section without unwind info)
1079          between these two entries.  */
1080       text_sec = (asection *) elf_section_data (sec)->sec_info;
1081       end = text_sec->output_section->vma + text_sec->output_offset
1082             + text_sec->size;
1083       text_sec = (asection *) elf_section_data (next)->sec_info;
1084       next_start = text_sec->output_section->vma + text_sec->output_offset;
1085       if (end == next_start)
1086         return;
1087     }
1088
1089   /* Add space for a CANTUNWIND terminator.  */
1090   if (!sec->rawsize)
1091     sec->rawsize = sec->size;
1092
1093   bfd_set_section_size (sec->owner, sec, sec->size + 8);
1094 }
1095
1096 /* Finish a pass over all .eh_frame_entry sections.  */
1097
1098 bfd_boolean
1099 _bfd_elf_end_eh_frame_parsing (struct bfd_link_info *info)
1100 {
1101   struct eh_frame_hdr_info *hdr_info;
1102   unsigned int i;
1103
1104   hdr_info = &elf_hash_table (info)->eh_info;
1105
1106   if (info->eh_frame_hdr_type != COMPACT_EH_HDR
1107       || hdr_info->array_count == 0)
1108     return FALSE;
1109
1110   bfd_elf_discard_eh_frame_entry (hdr_info);
1111
1112   qsort (hdr_info->u.compact.entries, hdr_info->array_count,
1113          sizeof (asection *), cmp_eh_frame_hdr);
1114
1115   for (i = 0; i < hdr_info->array_count - 1; i++)
1116     {
1117       add_eh_frame_hdr_terminator (hdr_info->u.compact.entries[i],
1118                                    hdr_info->u.compact.entries[i + 1]);
1119     }
1120
1121   /* Add a CANTUNWIND terminator after the last entry.  */
1122   add_eh_frame_hdr_terminator (hdr_info->u.compact.entries[i], NULL);
1123   return TRUE;
1124 }
1125
1126 /* Mark all relocations against CIE or FDE ENT, which occurs in
1127    .eh_frame section SEC.  COOKIE describes the relocations in SEC;
1128    its "rel" field can be changed freely.  */
1129
1130 static bfd_boolean
1131 mark_entry (struct bfd_link_info *info, asection *sec,
1132             struct eh_cie_fde *ent, elf_gc_mark_hook_fn gc_mark_hook,
1133             struct elf_reloc_cookie *cookie)
1134 {
1135   /* FIXME: octets_per_byte.  */
1136   for (cookie->rel = cookie->rels + ent->reloc_index;
1137        cookie->rel < cookie->relend
1138          && cookie->rel->r_offset < ent->offset + ent->size;
1139        cookie->rel++)
1140     if (!_bfd_elf_gc_mark_reloc (info, sec, gc_mark_hook, cookie))
1141       return FALSE;
1142
1143   return TRUE;
1144 }
1145
1146 /* Mark all the relocations against FDEs that relate to code in input
1147    section SEC.  The FDEs belong to .eh_frame section EH_FRAME, whose
1148    relocations are described by COOKIE.  */
1149
1150 bfd_boolean
1151 _bfd_elf_gc_mark_fdes (struct bfd_link_info *info, asection *sec,
1152                        asection *eh_frame, elf_gc_mark_hook_fn gc_mark_hook,
1153                        struct elf_reloc_cookie *cookie)
1154 {
1155   struct eh_cie_fde *fde, *cie;
1156
1157   for (fde = elf_fde_list (sec); fde; fde = fde->u.fde.next_for_section)
1158     {
1159       if (!mark_entry (info, eh_frame, fde, gc_mark_hook, cookie))
1160         return FALSE;
1161
1162       /* At this stage, all cie_inf fields point to local CIEs, so we
1163          can use the same cookie to refer to them.  */
1164       cie = fde->u.fde.cie_inf;
1165       if (cie != NULL && !cie->u.cie.gc_mark)
1166         {
1167           cie->u.cie.gc_mark = 1;
1168           if (!mark_entry (info, eh_frame, cie, gc_mark_hook, cookie))
1169             return FALSE;
1170         }
1171     }
1172   return TRUE;
1173 }
1174
1175 /* Input section SEC of ABFD is an .eh_frame section that contains the
1176    CIE described by CIE_INF.  Return a version of CIE_INF that is going
1177    to be kept in the output, adding CIE_INF to the output if necessary.
1178
1179    HDR_INFO is the .eh_frame_hdr information and COOKIE describes the
1180    relocations in REL.  */
1181
1182 static struct eh_cie_fde *
1183 find_merged_cie (bfd *abfd, struct bfd_link_info *info, asection *sec,
1184                  struct eh_frame_hdr_info *hdr_info,
1185                  struct elf_reloc_cookie *cookie,
1186                  struct eh_cie_fde *cie_inf)
1187 {
1188   unsigned long r_symndx;
1189   struct cie *cie, *new_cie;
1190   Elf_Internal_Rela *rel;
1191   void **loc;
1192
1193   /* Use CIE_INF if we have already decided to keep it.  */
1194   if (!cie_inf->removed)
1195     return cie_inf;
1196
1197   /* If we have merged CIE_INF with another CIE, use that CIE instead.  */
1198   if (cie_inf->u.cie.merged)
1199     return cie_inf->u.cie.u.merged_with;
1200
1201   cie = cie_inf->u.cie.u.full_cie;
1202
1203   /* Assume we will need to keep CIE_INF.  */
1204   cie_inf->removed = 0;
1205   cie_inf->u.cie.u.sec = sec;
1206
1207   /* If we are not merging CIEs, use CIE_INF.  */
1208   if (cie == NULL)
1209     return cie_inf;
1210
1211   if (cie->per_encoding != DW_EH_PE_omit)
1212     {
1213       bfd_boolean per_binds_local;
1214
1215       /* Work out the address of personality routine, or at least
1216          enough info that we could calculate the address had we made a
1217          final section layout.  The symbol on the reloc is enough,
1218          either the hash for a global, or (bfd id, index) pair for a
1219          local.  The assumption here is that no one uses addends on
1220          the reloc.  */
1221       rel = cookie->rels + cie->personality.reloc_index;
1222       memset (&cie->personality, 0, sizeof (cie->personality));
1223 #ifdef BFD64
1224       if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64)
1225         r_symndx = ELF64_R_SYM (rel->r_info);
1226       else
1227 #endif
1228         r_symndx = ELF32_R_SYM (rel->r_info);
1229       if (r_symndx >= cookie->locsymcount
1230           || ELF_ST_BIND (cookie->locsyms[r_symndx].st_info) != STB_LOCAL)
1231         {
1232           struct elf_link_hash_entry *h;
1233
1234           r_symndx -= cookie->extsymoff;
1235           h = cookie->sym_hashes[r_symndx];
1236
1237           while (h->root.type == bfd_link_hash_indirect
1238                  || h->root.type == bfd_link_hash_warning)
1239             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1240
1241           cie->personality.h = h;
1242           per_binds_local = SYMBOL_REFERENCES_LOCAL (info, h);
1243         }
1244       else
1245         {
1246           Elf_Internal_Sym *sym;
1247           asection *sym_sec;
1248
1249           sym = &cookie->locsyms[r_symndx];
1250           sym_sec = bfd_section_from_elf_index (abfd, sym->st_shndx);
1251           if (sym_sec == NULL)
1252             return cie_inf;
1253
1254           if (sym_sec->kept_section != NULL)
1255             sym_sec = sym_sec->kept_section;
1256           if (sym_sec->output_section == NULL)
1257             return cie_inf;
1258
1259           cie->local_personality = 1;
1260           cie->personality.sym.bfd_id = abfd->id;
1261           cie->personality.sym.index = r_symndx;
1262           per_binds_local = TRUE;
1263         }
1264
1265       if (per_binds_local
1266           && bfd_link_pic (info)
1267           && (cie->per_encoding & 0x70) == DW_EH_PE_absptr
1268           && (get_elf_backend_data (abfd)
1269               ->elf_backend_can_make_relative_eh_frame (abfd, info, sec)))
1270         {
1271           cie_inf->u.cie.make_per_encoding_relative = 1;
1272           cie_inf->u.cie.per_encoding_relative = 1;
1273         }
1274     }
1275
1276   /* See if we can merge this CIE with an earlier one.  */
1277   cie_compute_hash (cie);
1278   if (hdr_info->u.dwarf.cies == NULL)
1279     {
1280       hdr_info->u.dwarf.cies = htab_try_create (1, cie_hash, cie_eq, free);
1281       if (hdr_info->u.dwarf.cies == NULL)
1282         return cie_inf;
1283     }
1284   loc = htab_find_slot_with_hash (hdr_info->u.dwarf.cies, cie,
1285                                   cie->hash, INSERT);
1286   if (loc == NULL)
1287     return cie_inf;
1288
1289   new_cie = (struct cie *) *loc;
1290   if (new_cie == NULL)
1291     {
1292       /* Keep CIE_INF and record it in the hash table.  */
1293       new_cie = (struct cie *) malloc (sizeof (struct cie));
1294       if (new_cie == NULL)
1295         return cie_inf;
1296
1297       memcpy (new_cie, cie, sizeof (struct cie));
1298       *loc = new_cie;
1299     }
1300   else
1301     {
1302       /* Merge CIE_INF with NEW_CIE->CIE_INF.  */
1303       cie_inf->removed = 1;
1304       cie_inf->u.cie.merged = 1;
1305       cie_inf->u.cie.u.merged_with = new_cie->cie_inf;
1306       if (cie_inf->u.cie.make_lsda_relative)
1307         new_cie->cie_inf->u.cie.make_lsda_relative = 1;
1308     }
1309   return new_cie->cie_inf;
1310 }
1311
1312 /* This function is called for each input file before the .eh_frame
1313    section is relocated.  It discards duplicate CIEs and FDEs for discarded
1314    functions.  The function returns TRUE iff any entries have been
1315    deleted.  */
1316
1317 bfd_boolean
1318 _bfd_elf_discard_section_eh_frame
1319    (bfd *abfd, struct bfd_link_info *info, asection *sec,
1320     bfd_boolean (*reloc_symbol_deleted_p) (bfd_vma, void *),
1321     struct elf_reloc_cookie *cookie)
1322 {
1323   struct eh_cie_fde *ent;
1324   struct eh_frame_sec_info *sec_info;
1325   struct eh_frame_hdr_info *hdr_info;
1326   unsigned int ptr_size, offset;
1327
1328   if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME)
1329     return FALSE;
1330
1331   sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
1332   if (sec_info == NULL)
1333     return FALSE;
1334
1335   ptr_size = (get_elf_backend_data (sec->owner)
1336               ->elf_backend_eh_frame_address_size (sec->owner, sec));
1337
1338   hdr_info = &elf_hash_table (info)->eh_info;
1339   for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1340     if (ent->size == 4)
1341       /* There should only be one zero terminator, on the last input
1342          file supplying .eh_frame (crtend.o).  Remove any others.  */
1343       ent->removed = sec->map_head.s != NULL;
1344     else if (!ent->cie && ent->u.fde.cie_inf != NULL)
1345       {
1346         bfd_boolean keep;
1347         if ((sec->flags & SEC_LINKER_CREATED) != 0 && cookie->rels == NULL)
1348           {
1349             unsigned int width
1350               = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1351             bfd_vma value
1352               = read_value (abfd, sec->contents + ent->offset + 8 + width,
1353                             width, get_DW_EH_PE_signed (ent->fde_encoding));
1354             keep = value != 0;
1355           }
1356         else
1357           {
1358             cookie->rel = cookie->rels + ent->reloc_index;
1359             /* FIXME: octets_per_byte.  */
1360             BFD_ASSERT (cookie->rel < cookie->relend
1361                         && cookie->rel->r_offset == ent->offset + 8);
1362             keep = !(*reloc_symbol_deleted_p) (ent->offset + 8, cookie);
1363           }
1364         if (keep)
1365           {
1366             if (bfd_link_pic (info)
1367                 && (((ent->fde_encoding & 0x70) == DW_EH_PE_absptr
1368                      && ent->make_relative == 0)
1369                     || (ent->fde_encoding & 0x70) == DW_EH_PE_aligned))
1370               {
1371                 /* If a shared library uses absolute pointers
1372                    which we cannot turn into PC relative,
1373                    don't create the binary search table,
1374                    since it is affected by runtime relocations.  */
1375                 hdr_info->u.dwarf.table = FALSE;
1376                 (*info->callbacks->einfo)
1377                   (_("%P: FDE encoding in %B(%A) prevents .eh_frame_hdr"
1378                      " table being created.\n"), abfd, sec);
1379               }
1380             ent->removed = 0;
1381             hdr_info->u.dwarf.fde_count++;
1382             ent->u.fde.cie_inf = find_merged_cie (abfd, info, sec, hdr_info,
1383                                                   cookie, ent->u.fde.cie_inf);
1384           }
1385       }
1386
1387   if (sec_info->cies)
1388     {
1389       free (sec_info->cies);
1390       sec_info->cies = NULL;
1391     }
1392
1393   offset = 0;
1394   for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1395     if (!ent->removed)
1396       {
1397         ent->new_offset = offset;
1398         offset += size_of_output_cie_fde (ent, ptr_size);
1399       }
1400
1401   sec->rawsize = sec->size;
1402   sec->size = offset;
1403   return offset != sec->rawsize;
1404 }
1405
1406 /* This function is called for .eh_frame_hdr section after
1407    _bfd_elf_discard_section_eh_frame has been called on all .eh_frame
1408    input sections.  It finalizes the size of .eh_frame_hdr section.  */
1409
1410 bfd_boolean
1411 _bfd_elf_discard_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
1412 {
1413   struct elf_link_hash_table *htab;
1414   struct eh_frame_hdr_info *hdr_info;
1415   asection *sec;
1416
1417   htab = elf_hash_table (info);
1418   hdr_info = &htab->eh_info;
1419
1420   if (!hdr_info->frame_hdr_is_compact && hdr_info->u.dwarf.cies != NULL)
1421     {
1422       htab_delete (hdr_info->u.dwarf.cies);
1423       hdr_info->u.dwarf.cies = NULL;
1424     }
1425
1426   sec = hdr_info->hdr_sec;
1427   if (sec == NULL)
1428     return FALSE;
1429
1430   if (info->eh_frame_hdr_type == COMPACT_EH_HDR)
1431     {
1432       /* For compact frames we only add the header.  The actual table comes
1433          from the .eh_frame_entry sections.  */
1434       sec->size = 8;
1435     }
1436   else
1437     {
1438       sec->size = EH_FRAME_HDR_SIZE;
1439       if (hdr_info->u.dwarf.table)
1440         sec->size += 4 + hdr_info->u.dwarf.fde_count * 8;
1441     }
1442
1443   elf_eh_frame_hdr (abfd) = sec;
1444   return TRUE;
1445 }
1446
1447 /* Return true if there is at least one non-empty .eh_frame section in
1448    input files.  Can only be called after ld has mapped input to
1449    output sections, and before sections are stripped.  */
1450
1451 bfd_boolean
1452 _bfd_elf_eh_frame_present (struct bfd_link_info *info)
1453 {
1454   asection *eh = bfd_get_section_by_name (info->output_bfd, ".eh_frame");
1455
1456   if (eh == NULL)
1457     return FALSE;
1458
1459   /* Count only sections which have at least a single CIE or FDE.
1460      There cannot be any CIE or FDE <= 8 bytes.  */
1461   for (eh = eh->map_head.s; eh != NULL; eh = eh->map_head.s)
1462     if (eh->size > 8)
1463       return TRUE;
1464
1465   return FALSE;
1466 }
1467
1468 /* Return true if there is at least one .eh_frame_entry section in
1469    input files.  */
1470
1471 bfd_boolean
1472 _bfd_elf_eh_frame_entry_present (struct bfd_link_info *info)
1473 {
1474   asection *o;
1475   bfd *abfd;
1476
1477   for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link.next)
1478     {
1479       for (o = abfd->sections; o; o = o->next)
1480         {
1481           const char *name = bfd_get_section_name (abfd, o);
1482
1483           if (strcmp (name, ".eh_frame_entry")
1484               && !bfd_is_abs_section (o->output_section))
1485             return TRUE;
1486         }
1487     }
1488   return FALSE;
1489 }
1490
1491 /* This function is called from size_dynamic_sections.
1492    It needs to decide whether .eh_frame_hdr should be output or not,
1493    because when the dynamic symbol table has been sized it is too late
1494    to strip sections.  */
1495
1496 bfd_boolean
1497 _bfd_elf_maybe_strip_eh_frame_hdr (struct bfd_link_info *info)
1498 {
1499   struct elf_link_hash_table *htab;
1500   struct eh_frame_hdr_info *hdr_info;
1501   struct bfd_link_hash_entry *bh = NULL;
1502   struct elf_link_hash_entry *h;
1503
1504   htab = elf_hash_table (info);
1505   hdr_info = &htab->eh_info;
1506   if (hdr_info->hdr_sec == NULL)
1507     return TRUE;
1508
1509   if (bfd_is_abs_section (hdr_info->hdr_sec->output_section)
1510       || info->eh_frame_hdr_type == 0
1511       || (info->eh_frame_hdr_type == DWARF2_EH_HDR
1512           && !_bfd_elf_eh_frame_present (info))
1513       || (info->eh_frame_hdr_type == COMPACT_EH_HDR
1514           && !_bfd_elf_eh_frame_entry_present (info)))
1515     {
1516       hdr_info->hdr_sec->flags |= SEC_EXCLUDE;
1517       hdr_info->hdr_sec = NULL;
1518       return TRUE;
1519     }
1520
1521   /* Add a hidden symbol so that systems without access to PHDRs can
1522      find the table.  */
1523   if (! (_bfd_generic_link_add_one_symbol
1524          (info, info->output_bfd, "__GNU_EH_FRAME_HDR", BSF_LOCAL,
1525           hdr_info->hdr_sec, 0, NULL, FALSE, FALSE, &bh)))
1526     return FALSE;
1527
1528   h = (struct elf_link_hash_entry *) bh;
1529   h->def_regular = 1;
1530   h->other = STV_HIDDEN;
1531   get_elf_backend_data
1532     (info->output_bfd)->elf_backend_hide_symbol (info, h, TRUE);
1533
1534   if (!hdr_info->frame_hdr_is_compact)
1535     hdr_info->u.dwarf.table = TRUE;
1536   return TRUE;
1537 }
1538
1539 /* Adjust an address in the .eh_frame section.  Given OFFSET within
1540    SEC, this returns the new offset in the adjusted .eh_frame section,
1541    or -1 if the address refers to a CIE/FDE which has been removed
1542    or to offset with dynamic relocation which is no longer needed.  */
1543
1544 bfd_vma
1545 _bfd_elf_eh_frame_section_offset (bfd *output_bfd ATTRIBUTE_UNUSED,
1546                                   struct bfd_link_info *info ATTRIBUTE_UNUSED,
1547                                   asection *sec,
1548                                   bfd_vma offset)
1549 {
1550   struct eh_frame_sec_info *sec_info;
1551   unsigned int lo, hi, mid;
1552
1553   if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME)
1554     return offset;
1555   sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
1556
1557   if (offset >= sec->rawsize)
1558     return offset - sec->rawsize + sec->size;
1559
1560   lo = 0;
1561   hi = sec_info->count;
1562   mid = 0;
1563   while (lo < hi)
1564     {
1565       mid = (lo + hi) / 2;
1566       if (offset < sec_info->entry[mid].offset)
1567         hi = mid;
1568       else if (offset
1569                >= sec_info->entry[mid].offset + sec_info->entry[mid].size)
1570         lo = mid + 1;
1571       else
1572         break;
1573     }
1574
1575   BFD_ASSERT (lo < hi);
1576
1577   /* FDE or CIE was removed.  */
1578   if (sec_info->entry[mid].removed)
1579     return (bfd_vma) -1;
1580
1581   /* If converting personality pointers to DW_EH_PE_pcrel, there will be
1582      no need for run-time relocation against the personality field.  */
1583   if (sec_info->entry[mid].cie
1584       && sec_info->entry[mid].u.cie.make_per_encoding_relative
1585       && offset == (sec_info->entry[mid].offset + 8
1586                     + sec_info->entry[mid].u.cie.personality_offset))
1587     return (bfd_vma) -2;
1588
1589   /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1590      relocation against FDE's initial_location field.  */
1591   if (!sec_info->entry[mid].cie
1592       && sec_info->entry[mid].make_relative
1593       && offset == sec_info->entry[mid].offset + 8)
1594     return (bfd_vma) -2;
1595
1596   /* If converting LSDA pointers to DW_EH_PE_pcrel, there will be no need
1597      for run-time relocation against LSDA field.  */
1598   if (!sec_info->entry[mid].cie
1599       && sec_info->entry[mid].u.fde.cie_inf->u.cie.make_lsda_relative
1600       && offset == (sec_info->entry[mid].offset + 8
1601                     + sec_info->entry[mid].lsda_offset))
1602     return (bfd_vma) -2;
1603
1604   /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1605      relocation against DW_CFA_set_loc's arguments.  */
1606   if (sec_info->entry[mid].set_loc
1607       && sec_info->entry[mid].make_relative
1608       && (offset >= sec_info->entry[mid].offset + 8
1609                     + sec_info->entry[mid].set_loc[1]))
1610     {
1611       unsigned int cnt;
1612
1613       for (cnt = 1; cnt <= sec_info->entry[mid].set_loc[0]; cnt++)
1614         if (offset == sec_info->entry[mid].offset + 8
1615                       + sec_info->entry[mid].set_loc[cnt])
1616           return (bfd_vma) -2;
1617     }
1618
1619   /* Any new augmentation bytes go before the first relocation.  */
1620   return (offset + sec_info->entry[mid].new_offset
1621           - sec_info->entry[mid].offset
1622           + extra_augmentation_string_bytes (sec_info->entry + mid)
1623           + extra_augmentation_data_bytes (sec_info->entry + mid));
1624 }
1625
1626 /* Write out .eh_frame_entry section.  Add CANTUNWIND terminator if needed.
1627    Also check that the contents look sane.  */
1628
1629 bfd_boolean
1630 _bfd_elf_write_section_eh_frame_entry (bfd *abfd, struct bfd_link_info *info,
1631                                        asection *sec, bfd_byte *contents)
1632 {
1633   const struct elf_backend_data *bed;
1634   bfd_byte cantunwind[8];
1635   bfd_vma addr;
1636   bfd_vma last_addr;
1637   bfd_vma offset;
1638   asection *text_sec = (asection *) elf_section_data (sec)->sec_info;
1639
1640   if (!sec->rawsize)
1641     sec->rawsize = sec->size;
1642
1643   BFD_ASSERT (sec->sec_info_type == SEC_INFO_TYPE_EH_FRAME_ENTRY);
1644
1645   /* Check to make sure that the text section corresponding to this eh_frame_entry
1646      section has not been excluded.  In particular, mips16 stub entries will be
1647      excluded outside of the normal process.  */
1648   if (sec->flags & SEC_EXCLUDE
1649       || text_sec->flags & SEC_EXCLUDE)
1650     return TRUE;
1651
1652   if (!bfd_set_section_contents (abfd, sec->output_section, contents,
1653                                  sec->output_offset, sec->rawsize))
1654       return FALSE;
1655
1656   last_addr = bfd_get_signed_32 (abfd, contents);
1657   /* Check that all the entries are in order.  */
1658   for (offset = 8; offset < sec->rawsize; offset += 8)
1659     {
1660       addr = bfd_get_signed_32 (abfd, contents + offset) + offset;
1661       if (addr <= last_addr)
1662         {
1663           (*_bfd_error_handler) (_("%B: %s not in order"), sec->owner, sec->name);
1664           return FALSE;
1665         }
1666
1667       last_addr = addr;
1668     }
1669
1670   addr = text_sec->output_section->vma + text_sec->output_offset
1671          + text_sec->size;
1672   addr &= ~1;
1673   addr -= (sec->output_section->vma + sec->output_offset + sec->rawsize);
1674   if (addr & 1)
1675     {
1676       (*_bfd_error_handler) (_("%B: %s invalid input section size"),
1677                              sec->owner, sec->name);
1678       bfd_set_error (bfd_error_bad_value);
1679       return FALSE;
1680     }
1681   if (last_addr >= addr + sec->rawsize)
1682     {
1683       (*_bfd_error_handler) (_("%B: %s points past end of text section"),
1684                              sec->owner, sec->name);
1685       bfd_set_error (bfd_error_bad_value);
1686       return FALSE;
1687     }
1688
1689   if (sec->size == sec->rawsize)
1690     return TRUE;
1691
1692   bed = get_elf_backend_data (abfd);
1693   BFD_ASSERT (sec->size == sec->rawsize + 8);
1694   BFD_ASSERT ((addr & 1) == 0);
1695   BFD_ASSERT (bed->cant_unwind_opcode);
1696
1697   bfd_put_32 (abfd, addr, cantunwind);
1698   bfd_put_32 (abfd, (*bed->cant_unwind_opcode) (info), cantunwind + 4);
1699   return bfd_set_section_contents (abfd, sec->output_section, cantunwind,
1700                                    sec->output_offset + sec->rawsize, 8);
1701 }
1702
1703 /* Write out .eh_frame section.  This is called with the relocated
1704    contents.  */
1705
1706 bfd_boolean
1707 _bfd_elf_write_section_eh_frame (bfd *abfd,
1708                                  struct bfd_link_info *info,
1709                                  asection *sec,
1710                                  bfd_byte *contents)
1711 {
1712   struct eh_frame_sec_info *sec_info;
1713   struct elf_link_hash_table *htab;
1714   struct eh_frame_hdr_info *hdr_info;
1715   unsigned int ptr_size;
1716   struct eh_cie_fde *ent;
1717   bfd_size_type sec_size;
1718
1719   if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME)
1720     /* FIXME: octets_per_byte.  */
1721     return bfd_set_section_contents (abfd, sec->output_section, contents,
1722                                      sec->output_offset, sec->size);
1723
1724   ptr_size = (get_elf_backend_data (abfd)
1725               ->elf_backend_eh_frame_address_size (abfd, sec));
1726   BFD_ASSERT (ptr_size != 0);
1727
1728   sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
1729   htab = elf_hash_table (info);
1730   hdr_info = &htab->eh_info;
1731
1732   if (hdr_info->u.dwarf.table && hdr_info->u.dwarf.array == NULL)
1733     {
1734       hdr_info->frame_hdr_is_compact = FALSE;
1735       hdr_info->u.dwarf.array = (struct eh_frame_array_ent *)
1736         bfd_malloc (hdr_info->u.dwarf.fde_count
1737                     * sizeof (*hdr_info->u.dwarf.array));
1738     }
1739   if (hdr_info->u.dwarf.array == NULL)
1740     hdr_info = NULL;
1741
1742   /* The new offsets can be bigger or smaller than the original offsets.
1743      We therefore need to make two passes over the section: one backward
1744      pass to move entries up and one forward pass to move entries down.
1745      The two passes won't interfere with each other because entries are
1746      not reordered  */
1747   for (ent = sec_info->entry + sec_info->count; ent-- != sec_info->entry;)
1748     if (!ent->removed && ent->new_offset > ent->offset)
1749       memmove (contents + ent->new_offset, contents + ent->offset, ent->size);
1750
1751   for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1752     if (!ent->removed && ent->new_offset < ent->offset)
1753       memmove (contents + ent->new_offset, contents + ent->offset, ent->size);
1754
1755   for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1756     {
1757       unsigned char *buf, *end;
1758       unsigned int new_size;
1759
1760       if (ent->removed)
1761         continue;
1762
1763       if (ent->size == 4)
1764         {
1765           /* Any terminating FDE must be at the end of the section.  */
1766           BFD_ASSERT (ent == sec_info->entry + sec_info->count - 1);
1767           continue;
1768         }
1769
1770       buf = contents + ent->new_offset;
1771       end = buf + ent->size;
1772       new_size = size_of_output_cie_fde (ent, ptr_size);
1773
1774       /* Update the size.  It may be shrinked.  */
1775       bfd_put_32 (abfd, new_size - 4, buf);
1776
1777       /* Filling the extra bytes with DW_CFA_nops.  */
1778       if (new_size != ent->size)
1779         memset (end, 0, new_size - ent->size);
1780
1781       if (ent->cie)
1782         {
1783           /* CIE */
1784           if (ent->make_relative
1785               || ent->u.cie.make_lsda_relative
1786               || ent->u.cie.per_encoding_relative)
1787             {
1788               char *aug;
1789               unsigned int action, extra_string, extra_data;
1790               unsigned int per_width, per_encoding;
1791
1792               /* Need to find 'R' or 'L' augmentation's argument and modify
1793                  DW_EH_PE_* value.  */
1794               action = ((ent->make_relative ? 1 : 0)
1795                         | (ent->u.cie.make_lsda_relative ? 2 : 0)
1796                         | (ent->u.cie.per_encoding_relative ? 4 : 0));
1797               extra_string = extra_augmentation_string_bytes (ent);
1798               extra_data = extra_augmentation_data_bytes (ent);
1799
1800               /* Skip length, id and version.  */
1801               buf += 9;
1802               aug = (char *) buf;
1803               buf += strlen (aug) + 1;
1804               skip_leb128 (&buf, end);
1805               skip_leb128 (&buf, end);
1806               skip_leb128 (&buf, end);
1807               if (*aug == 'z')
1808                 {
1809                   /* The uleb128 will always be a single byte for the kind
1810                      of augmentation strings that we're prepared to handle.  */
1811                   *buf++ += extra_data;
1812                   aug++;
1813                 }
1814
1815               /* Make room for the new augmentation string and data bytes.  */
1816               memmove (buf + extra_string + extra_data, buf, end - buf);
1817               memmove (aug + extra_string, aug, buf - (bfd_byte *) aug);
1818               buf += extra_string;
1819               end += extra_string + extra_data;
1820
1821               if (ent->add_augmentation_size)
1822                 {
1823                   *aug++ = 'z';
1824                   *buf++ = extra_data - 1;
1825                 }
1826               if (ent->u.cie.add_fde_encoding)
1827                 {
1828                   BFD_ASSERT (action & 1);
1829                   *aug++ = 'R';
1830                   *buf++ = make_pc_relative (DW_EH_PE_absptr, ptr_size);
1831                   action &= ~1;
1832                 }
1833
1834               while (action)
1835                 switch (*aug++)
1836                   {
1837                   case 'L':
1838                     if (action & 2)
1839                       {
1840                         BFD_ASSERT (*buf == ent->lsda_encoding);
1841                         *buf = make_pc_relative (*buf, ptr_size);
1842                         action &= ~2;
1843                       }
1844                     buf++;
1845                     break;
1846                   case 'P':
1847                     if (ent->u.cie.make_per_encoding_relative)
1848                       *buf = make_pc_relative (*buf, ptr_size);
1849                     per_encoding = *buf++;
1850                     per_width = get_DW_EH_PE_width (per_encoding, ptr_size);
1851                     BFD_ASSERT (per_width != 0);
1852                     BFD_ASSERT (((per_encoding & 0x70) == DW_EH_PE_pcrel)
1853                                 == ent->u.cie.per_encoding_relative);
1854                     if ((per_encoding & 0x70) == DW_EH_PE_aligned)
1855                       buf = (contents
1856                              + ((buf - contents + per_width - 1)
1857                                 & ~((bfd_size_type) per_width - 1)));
1858                     if (action & 4)
1859                       {
1860                         bfd_vma val;
1861
1862                         val = read_value (abfd, buf, per_width,
1863                                           get_DW_EH_PE_signed (per_encoding));
1864                         if (ent->u.cie.make_per_encoding_relative)
1865                           val -= (sec->output_section->vma
1866                                   + sec->output_offset
1867                                   + (buf - contents));
1868                         else
1869                           {
1870                             val += (bfd_vma) ent->offset - ent->new_offset;
1871                             val -= extra_string + extra_data;
1872                           }
1873                         write_value (abfd, buf, val, per_width);
1874                         action &= ~4;
1875                       }
1876                     buf += per_width;
1877                     break;
1878                   case 'R':
1879                     if (action & 1)
1880                       {
1881                         BFD_ASSERT (*buf == ent->fde_encoding);
1882                         *buf = make_pc_relative (*buf, ptr_size);
1883                         action &= ~1;
1884                       }
1885                     buf++;
1886                     break;
1887                   case 'S':
1888                     break;
1889                   default:
1890                     BFD_FAIL ();
1891                   }
1892             }
1893         }
1894       else
1895         {
1896           /* FDE */
1897           bfd_vma value, address;
1898           unsigned int width;
1899           bfd_byte *start;
1900           struct eh_cie_fde *cie;
1901
1902           /* Skip length.  */
1903           cie = ent->u.fde.cie_inf;
1904           buf += 4;
1905           value = ((ent->new_offset + sec->output_offset + 4)
1906                    - (cie->new_offset + cie->u.cie.u.sec->output_offset));
1907           bfd_put_32 (abfd, value, buf);
1908           if (bfd_link_relocatable (info))
1909             continue;
1910           buf += 4;
1911           width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1912           value = read_value (abfd, buf, width,
1913                               get_DW_EH_PE_signed (ent->fde_encoding));
1914           address = value;
1915           if (value)
1916             {
1917               switch (ent->fde_encoding & 0x70)
1918                 {
1919                 case DW_EH_PE_textrel:
1920                   BFD_ASSERT (hdr_info == NULL);
1921                   break;
1922                 case DW_EH_PE_datarel:
1923                   {
1924                     switch (abfd->arch_info->arch)
1925                       {
1926                       case bfd_arch_ia64:
1927                         BFD_ASSERT (elf_gp (abfd) != 0);
1928                         address += elf_gp (abfd);
1929                         break;
1930                       default:
1931                         (*info->callbacks->einfo)
1932                           (_("%P: DW_EH_PE_datarel unspecified"
1933                              " for this architecture.\n"));
1934                         /* Fall thru */
1935                       case bfd_arch_frv:
1936                       case bfd_arch_i386:
1937                         BFD_ASSERT (htab->hgot != NULL
1938                                     && ((htab->hgot->root.type
1939                                          == bfd_link_hash_defined)
1940                                         || (htab->hgot->root.type
1941                                             == bfd_link_hash_defweak)));
1942                         address
1943                           += (htab->hgot->root.u.def.value
1944                               + htab->hgot->root.u.def.section->output_offset
1945                               + (htab->hgot->root.u.def.section->output_section
1946                                  ->vma));
1947                         break;
1948                       }
1949                   }
1950                   break;
1951                 case DW_EH_PE_pcrel:
1952                   value += (bfd_vma) ent->offset - ent->new_offset;
1953                   address += (sec->output_section->vma
1954                               + sec->output_offset
1955                               + ent->offset + 8);
1956                   break;
1957                 }
1958               if (ent->make_relative)
1959                 value -= (sec->output_section->vma
1960                           + sec->output_offset
1961                           + ent->new_offset + 8);
1962               write_value (abfd, buf, value, width);
1963             }
1964
1965           start = buf;
1966
1967           if (hdr_info)
1968             {
1969               /* The address calculation may overflow, giving us a
1970                  value greater than 4G on a 32-bit target when
1971                  dwarf_vma is 64-bit.  */
1972               if (sizeof (address) > 4 && ptr_size == 4)
1973                 address &= 0xffffffff;
1974               hdr_info->u.dwarf.array[hdr_info->array_count].initial_loc
1975                 = address;
1976               hdr_info->u.dwarf.array[hdr_info->array_count].range
1977                 = read_value (abfd, buf + width, width, FALSE);
1978               hdr_info->u.dwarf.array[hdr_info->array_count++].fde
1979                 = (sec->output_section->vma
1980                    + sec->output_offset
1981                    + ent->new_offset);
1982             }
1983
1984           if ((ent->lsda_encoding & 0x70) == DW_EH_PE_pcrel
1985               || cie->u.cie.make_lsda_relative)
1986             {
1987               buf += ent->lsda_offset;
1988               width = get_DW_EH_PE_width (ent->lsda_encoding, ptr_size);
1989               value = read_value (abfd, buf, width,
1990                                   get_DW_EH_PE_signed (ent->lsda_encoding));
1991               if (value)
1992                 {
1993                   if ((ent->lsda_encoding & 0x70) == DW_EH_PE_pcrel)
1994                     value += (bfd_vma) ent->offset - ent->new_offset;
1995                   else if (cie->u.cie.make_lsda_relative)
1996                     value -= (sec->output_section->vma
1997                               + sec->output_offset
1998                               + ent->new_offset + 8 + ent->lsda_offset);
1999                   write_value (abfd, buf, value, width);
2000                 }
2001             }
2002           else if (ent->add_augmentation_size)
2003             {
2004               /* Skip the PC and length and insert a zero byte for the
2005                  augmentation size.  */
2006               buf += width * 2;
2007               memmove (buf + 1, buf, end - buf);
2008               *buf = 0;
2009             }
2010
2011           if (ent->set_loc)
2012             {
2013               /* Adjust DW_CFA_set_loc.  */
2014               unsigned int cnt;
2015               bfd_vma new_offset;
2016
2017               width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
2018               new_offset = ent->new_offset + 8
2019                            + extra_augmentation_string_bytes (ent)
2020                            + extra_augmentation_data_bytes (ent);
2021
2022               for (cnt = 1; cnt <= ent->set_loc[0]; cnt++)
2023                 {
2024                   buf = start + ent->set_loc[cnt];
2025
2026                   value = read_value (abfd, buf, width,
2027                                       get_DW_EH_PE_signed (ent->fde_encoding));
2028                   if (!value)
2029                     continue;
2030
2031                   if ((ent->fde_encoding & 0x70) == DW_EH_PE_pcrel)
2032                     value += (bfd_vma) ent->offset + 8 - new_offset;
2033                   if (ent->make_relative)
2034                     value -= (sec->output_section->vma
2035                               + sec->output_offset
2036                               + new_offset + ent->set_loc[cnt]);
2037                   write_value (abfd, buf, value, width);
2038                 }
2039             }
2040         }
2041     }
2042
2043   /* We don't align the section to its section alignment since the
2044      runtime library only expects all CIE/FDE records aligned at
2045      the pointer size. _bfd_elf_discard_section_eh_frame should
2046      have padded CIE/FDE records to multiple of pointer size with
2047      size_of_output_cie_fde.  */
2048   sec_size = sec->size;
2049   if (sec_info->count != 0
2050       && sec_info->entry[sec_info->count - 1].size == 4)
2051     sec_size -= 4;
2052   if ((sec_size % ptr_size) != 0)
2053     abort ();
2054
2055   /* FIXME: octets_per_byte.  */
2056   return bfd_set_section_contents (abfd, sec->output_section,
2057                                    contents, (file_ptr) sec->output_offset,
2058                                    sec->size);
2059 }
2060
2061 /* Helper function used to sort .eh_frame_hdr search table by increasing
2062    VMA of FDE initial location.  */
2063
2064 static int
2065 vma_compare (const void *a, const void *b)
2066 {
2067   const struct eh_frame_array_ent *p = (const struct eh_frame_array_ent *) a;
2068   const struct eh_frame_array_ent *q = (const struct eh_frame_array_ent *) b;
2069   if (p->initial_loc > q->initial_loc)
2070     return 1;
2071   if (p->initial_loc < q->initial_loc)
2072     return -1;
2073   if (p->range > q->range)
2074     return 1;
2075   if (p->range < q->range)
2076     return -1;
2077   return 0;
2078 }
2079
2080 /* Reorder .eh_frame_entry sections to match the associated text sections.
2081    This routine is called during the final linking step, just before writing
2082    the contents.  At this stage, sections in the eh_frame_hdr_info are already
2083    sorted in order of increasing text section address and so we simply need
2084    to make the .eh_frame_entrys follow that same order.  Note that it is
2085    invalid for a linker script to try to force a particular order of
2086    .eh_frame_entry sections.  */
2087
2088 bfd_boolean
2089 _bfd_elf_fixup_eh_frame_hdr (struct bfd_link_info *info)
2090 {
2091   asection *sec = NULL;
2092   asection *osec;
2093   struct eh_frame_hdr_info *hdr_info;
2094   unsigned int i;
2095   bfd_vma offset;
2096   struct bfd_link_order *p;
2097
2098   hdr_info = &elf_hash_table (info)->eh_info;
2099
2100   if (hdr_info->hdr_sec == NULL
2101       || info->eh_frame_hdr_type != COMPACT_EH_HDR
2102       || hdr_info->array_count == 0)
2103     return TRUE;
2104
2105   /* Change section output offsets to be in text section order.  */
2106   offset = 8;
2107   osec = hdr_info->u.compact.entries[0]->output_section;
2108   for (i = 0; i < hdr_info->array_count; i++)
2109     {
2110       sec = hdr_info->u.compact.entries[i];
2111       if (sec->output_section != osec)
2112         {
2113           (*_bfd_error_handler)
2114             (_("Invalid output section for .eh_frame_entry: %s"),
2115              sec->output_section->name);
2116           return FALSE;
2117         }
2118       sec->output_offset = offset;
2119       offset += sec->size;
2120     }
2121
2122
2123   /* Fix the link_order to match.  */
2124   for (p = sec->output_section->map_head.link_order; p != NULL; p = p->next)
2125     {
2126       if (p->type != bfd_indirect_link_order)
2127         abort();
2128
2129       p->offset = p->u.indirect.section->output_offset;
2130       if (p->next != NULL)
2131         i--;
2132     }
2133
2134   if (i != 0)
2135     {
2136       (*_bfd_error_handler)
2137         (_("Invalid contents in %s section"), osec->name);
2138       return FALSE;
2139     }
2140
2141   return TRUE;
2142 }
2143
2144 /* The .eh_frame_hdr format for Compact EH frames:
2145    ubyte version                (2)
2146    ubyte eh_ref_enc             (DW_EH_PE_* encoding of typinfo references)
2147    uint32_t count               (Number of entries in table)
2148    [array from .eh_frame_entry sections]  */
2149
2150 static bfd_boolean
2151 write_compact_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
2152 {
2153   struct elf_link_hash_table *htab;
2154   struct eh_frame_hdr_info *hdr_info;
2155   asection *sec;
2156   const struct elf_backend_data *bed;
2157   bfd_vma count;
2158   bfd_byte contents[8];
2159   unsigned int i;
2160
2161   htab = elf_hash_table (info);
2162   hdr_info = &htab->eh_info;
2163   sec = hdr_info->hdr_sec;
2164
2165   if (sec->size != 8)
2166     abort();
2167
2168   for (i = 0; i < sizeof (contents); i++)
2169     contents[i] = 0;
2170
2171   contents[0] = COMPACT_EH_HDR;
2172   bed = get_elf_backend_data (abfd);
2173
2174   BFD_ASSERT (bed->compact_eh_encoding);
2175   contents[1] = (*bed->compact_eh_encoding) (info);
2176
2177   count = (sec->output_section->size - 8) / 8;
2178   bfd_put_32 (abfd, count, contents + 4);
2179   return bfd_set_section_contents (abfd, sec->output_section, contents,
2180                                    (file_ptr) sec->output_offset, sec->size);
2181 }
2182
2183 /* The .eh_frame_hdr format for DWARF frames:
2184
2185    ubyte version                (currently 1)
2186    ubyte eh_frame_ptr_enc       (DW_EH_PE_* encoding of pointer to start of
2187                                  .eh_frame section)
2188    ubyte fde_count_enc          (DW_EH_PE_* encoding of total FDE count
2189                                  number (or DW_EH_PE_omit if there is no
2190                                  binary search table computed))
2191    ubyte table_enc              (DW_EH_PE_* encoding of binary search table,
2192                                  or DW_EH_PE_omit if not present.
2193                                  DW_EH_PE_datarel is using address of
2194                                  .eh_frame_hdr section start as base)
2195    [encoded] eh_frame_ptr       (pointer to start of .eh_frame section)
2196    optionally followed by:
2197    [encoded] fde_count          (total number of FDEs in .eh_frame section)
2198    fde_count x [encoded] initial_loc, fde
2199                                 (array of encoded pairs containing
2200                                  FDE initial_location field and FDE address,
2201                                  sorted by increasing initial_loc).  */
2202
2203 static bfd_boolean
2204 write_dwarf_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
2205 {
2206   struct elf_link_hash_table *htab;
2207   struct eh_frame_hdr_info *hdr_info;
2208   asection *sec;
2209   bfd_boolean retval = TRUE;
2210
2211   htab = elf_hash_table (info);
2212   hdr_info = &htab->eh_info;
2213   sec = hdr_info->hdr_sec;
2214   bfd_byte *contents;
2215   asection *eh_frame_sec;
2216   bfd_size_type size;
2217   bfd_vma encoded_eh_frame;
2218
2219   size = EH_FRAME_HDR_SIZE;
2220   if (hdr_info->u.dwarf.array
2221       && hdr_info->array_count == hdr_info->u.dwarf.fde_count)
2222     size += 4 + hdr_info->u.dwarf.fde_count * 8;
2223   contents = (bfd_byte *) bfd_malloc (size);
2224   if (contents == NULL)
2225     return FALSE;
2226
2227   eh_frame_sec = bfd_get_section_by_name (abfd, ".eh_frame");
2228   if (eh_frame_sec == NULL)
2229     {
2230       free (contents);
2231       return FALSE;
2232     }
2233
2234   memset (contents, 0, EH_FRAME_HDR_SIZE);
2235   /* Version.  */
2236   contents[0] = 1;
2237   /* .eh_frame offset.  */
2238   contents[1] = get_elf_backend_data (abfd)->elf_backend_encode_eh_address
2239     (abfd, info, eh_frame_sec, 0, sec, 4, &encoded_eh_frame);
2240
2241   if (hdr_info->u.dwarf.array
2242       && hdr_info->array_count == hdr_info->u.dwarf.fde_count)
2243     {
2244       /* FDE count encoding.  */
2245       contents[2] = DW_EH_PE_udata4;
2246       /* Search table encoding.  */
2247       contents[3] = DW_EH_PE_datarel | DW_EH_PE_sdata4;
2248     }
2249   else
2250     {
2251       contents[2] = DW_EH_PE_omit;
2252       contents[3] = DW_EH_PE_omit;
2253     }
2254   bfd_put_32 (abfd, encoded_eh_frame, contents + 4);
2255
2256   if (contents[2] != DW_EH_PE_omit)
2257     {
2258       unsigned int i;
2259       bfd_boolean overlap, overflow;
2260
2261       bfd_put_32 (abfd, hdr_info->u.dwarf.fde_count,
2262                   contents + EH_FRAME_HDR_SIZE);
2263       qsort (hdr_info->u.dwarf.array, hdr_info->u.dwarf.fde_count,
2264              sizeof (*hdr_info->u.dwarf.array), vma_compare);
2265       overlap = FALSE;
2266       overflow = FALSE;
2267       for (i = 0; i < hdr_info->u.dwarf.fde_count; i++)
2268         {
2269           bfd_vma val;
2270
2271           val = hdr_info->u.dwarf.array[i].initial_loc
2272             - sec->output_section->vma;
2273           val = ((val & 0xffffffff) ^ 0x80000000) - 0x80000000;
2274           if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64
2275               && (hdr_info->u.dwarf.array[i].initial_loc
2276                   != sec->output_section->vma + val))
2277             overflow = TRUE;
2278           bfd_put_32 (abfd, val, contents + EH_FRAME_HDR_SIZE + i * 8 + 4);
2279           val = hdr_info->u.dwarf.array[i].fde - sec->output_section->vma;
2280           val = ((val & 0xffffffff) ^ 0x80000000) - 0x80000000;
2281           if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64
2282               && (hdr_info->u.dwarf.array[i].fde
2283                   != sec->output_section->vma + val))
2284             overflow = TRUE;
2285           bfd_put_32 (abfd, val, contents + EH_FRAME_HDR_SIZE + i * 8 + 8);
2286           if (i != 0
2287               && (hdr_info->u.dwarf.array[i].initial_loc
2288                   < (hdr_info->u.dwarf.array[i - 1].initial_loc
2289                      + hdr_info->u.dwarf.array[i - 1].range)))
2290             overlap = TRUE;
2291         }
2292       if (overflow)
2293         (*info->callbacks->einfo) (_("%P: .eh_frame_hdr entry overflow.\n"));
2294       if (overlap)
2295         (*info->callbacks->einfo)
2296           (_("%P: .eh_frame_hdr refers to overlapping FDEs.\n"));
2297       if (overflow || overlap)
2298         {
2299           bfd_set_error (bfd_error_bad_value);
2300           retval = FALSE;
2301         }
2302     }
2303
2304   /* FIXME: octets_per_byte.  */
2305   if (!bfd_set_section_contents (abfd, sec->output_section, contents,
2306                                  (file_ptr) sec->output_offset,
2307                                  sec->size))
2308     retval = FALSE;
2309   free (contents);
2310
2311   if (hdr_info->u.dwarf.array != NULL)
2312     free (hdr_info->u.dwarf.array);
2313   return retval;
2314 }
2315
2316 /* Write out .eh_frame_hdr section.  This must be called after
2317    _bfd_elf_write_section_eh_frame has been called on all input
2318    .eh_frame sections.  */
2319
2320 bfd_boolean
2321 _bfd_elf_write_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
2322 {
2323   struct elf_link_hash_table *htab;
2324   struct eh_frame_hdr_info *hdr_info;
2325   asection *sec;
2326
2327   htab = elf_hash_table (info);
2328   hdr_info = &htab->eh_info;
2329   sec = hdr_info->hdr_sec;
2330
2331   if (info->eh_frame_hdr_type == 0 || sec == NULL)
2332     return TRUE;
2333
2334   if (info->eh_frame_hdr_type == COMPACT_EH_HDR)
2335     return write_compact_eh_frame_hdr (abfd, info);
2336   else
2337     return write_dwarf_eh_frame_hdr (abfd, info);
2338 }
2339
2340 /* Return the width of FDE addresses.  This is the default implementation.  */
2341
2342 unsigned int
2343 _bfd_elf_eh_frame_address_size (bfd *abfd, asection *sec ATTRIBUTE_UNUSED)
2344 {
2345   return elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64 ? 8 : 4;
2346 }
2347
2348 /* Decide whether we can use a PC-relative encoding within the given
2349    EH frame section.  This is the default implementation.  */
2350
2351 bfd_boolean
2352 _bfd_elf_can_make_relative (bfd *input_bfd ATTRIBUTE_UNUSED,
2353                             struct bfd_link_info *info ATTRIBUTE_UNUSED,
2354                             asection *eh_frame_section ATTRIBUTE_UNUSED)
2355 {
2356   return TRUE;
2357 }
2358
2359 /* Select an encoding for the given address.  Preference is given to
2360    PC-relative addressing modes.  */
2361
2362 bfd_byte
2363 _bfd_elf_encode_eh_address (bfd *abfd ATTRIBUTE_UNUSED,
2364                             struct bfd_link_info *info ATTRIBUTE_UNUSED,
2365                             asection *osec, bfd_vma offset,
2366                             asection *loc_sec, bfd_vma loc_offset,
2367                             bfd_vma *encoded)
2368 {
2369   *encoded = osec->vma + offset -
2370     (loc_sec->output_section->vma + loc_sec->output_offset + loc_offset);
2371   return DW_EH_PE_pcrel | DW_EH_PE_sdata4;
2372 }