bfd/elf-eh-frame.c

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