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