bfd/elf-eh-frame.c

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