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