contrib/binutils-2.25/bfd/elf-eh-frame.c

   1 /* .eh_frame section optimization.
   2    Copyright (C) 2001-2014 Free Software Foundation, Inc.
   3    Written by Jakub Jelinek <jakub@redhat.com>.
   4
   5    This file is part of BFD, the Binary File Descriptor library.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  20    MA 02110-1301, USA.  */
  21
  22 #include "sysdep.h"
  23 #include "bfd.h"
  24 #include "libbfd.h"
  25 #include "elf-bfd.h"
  26 #include "dwarf2.h"
  27
  28 #define EH_FRAME_HDR_SIZE 8
  29
  30 struct cie
  31 {
  32   unsigned int length;
  33   unsigned int hash;
  34   unsigned char version;
  35   unsigned char local_personality;
  36   char augmentation[20];
  37   bfd_vma code_align;
  38   bfd_signed_vma data_align;
  39   bfd_vma ra_column;
  40   bfd_vma augmentation_size;
  41   union {
  42     struct elf_link_hash_entry *h;
  43     struct {
  44       unsigned int bfd_id;
  45       unsigned int index;
  46     } sym;
  47     unsigned int reloc_index;
  48   } personality;
  49   struct eh_cie_fde *cie_inf;
  50   unsigned char per_encoding;
  51   unsigned char lsda_encoding;
  52   unsigned char fde_encoding;
  53   unsigned char initial_insn_length;
  54   unsigned char can_make_lsda_relative;
  55   unsigned char initial_instructions[50];
  56 };
  57
  58
  59
  60 /* If *ITER hasn't reached END yet, read the next byte into *RESULT and
  61    move onto the next byte.  Return true on success.  */
  62
  63 static inline bfd_boolean
  64 read_byte (bfd_byte **iter, bfd_byte *end, unsigned char *result)
  65 {
  66   if (*iter >= end)
  67     return FALSE;
  68   *result = *((*iter)++);
  69   return TRUE;
  70 }
  71
  72 /* Move *ITER over LENGTH bytes, or up to END, whichever is closer.
  73    Return true it was possible to move LENGTH bytes.  */
  74
  75 static inline bfd_boolean
  76 skip_bytes (bfd_byte **iter, bfd_byte *end, bfd_size_type length)
  77 {
  78   if ((bfd_size_type) (end - *iter) < length)
  79     {
  80       *iter = end;
  81       return FALSE;
  82     }
  83   *iter += length;
  84   return TRUE;
  85 }
  86
  87 /* Move *ITER over an leb128, stopping at END.  Return true if the end
  88    of the leb128 was found.  */
  89
  90 static bfd_boolean
  91 skip_leb128 (bfd_byte **iter, bfd_byte *end)
  92 {
  93   unsigned char byte;
  94   do
  95     if (!read_byte (iter, end, &byte))
  96       return FALSE;
  97   while (byte & 0x80);
  98   return TRUE;
  99 }
 100
 101 /* Like skip_leb128, but treat the leb128 as an unsigned value and
 102    store it in *VALUE.  */
 103
 104 static bfd_boolean
 105 read_uleb128 (bfd_byte **iter, bfd_byte *end, bfd_vma *value)
 106 {
 107   bfd_byte *start, *p;
 108
 109   start = *iter;
 110   if (!skip_leb128 (iter, end))
 111     return FALSE;
 112
 113   p = *iter;
 114   *value = *--p;
 115   while (p > start)
 116     *value = (*value << 7) | (*--p & 0x7f);
 117
 118   return TRUE;
 119 }
 120
 121 /* Like read_uleb128, but for signed values.  */
 122
 123 static bfd_boolean
 124 read_sleb128 (bfd_byte **iter, bfd_byte *end, bfd_signed_vma *value)
 125 {
 126   bfd_byte *start, *p;
 127
 128   start = *iter;
 129   if (!skip_leb128 (iter, end))
 130     return FALSE;
 131
 132   p = *iter;
 133   *value = ((*--p & 0x7f) ^ 0x40) - 0x40;
 134   while (p > start)
 135     *value = (*value << 7) | (*--p & 0x7f);
 136
 137   return TRUE;
 138 }
 139
 140 /* Return 0 if either encoding is variable width, or not yet known to bfd.  */
 141
 142 static
 143 int get_DW_EH_PE_width (int encoding, int ptr_size)
 144 {
 145   /* DW_EH_PE_ values of 0x60 and 0x70 weren't defined at the time .eh_frame
 146      was added to bfd.  */
 147   if ((encoding & 0x60) == 0x60)
 148     return 0;
 149
 150   switch (encoding & 7)
 151     {
 152     case DW_EH_PE_udata2: return 2;
 153     case DW_EH_PE_udata4: return 4;
 154     case DW_EH_PE_udata8: return 8;
 155     case DW_EH_PE_absptr: return ptr_size;
 156     default:
 157       break;
 158     }
 159
 160   return 0;
 161 }
 162
 163 #define get_DW_EH_PE_signed(encoding) (((encoding) & DW_EH_PE_signed) != 0)
 164
 165 /* Read a width sized value from memory.  */
 166
 167 static bfd_vma
 168 read_value (bfd *abfd, bfd_byte *buf, int width, int is_signed)
 169 {
 170   bfd_vma value;
 171
 172   switch (width)
 173     {
 174     case 2:
 175       if (is_signed)
 176         value = bfd_get_signed_16 (abfd, buf);
 177       else
 178         value = bfd_get_16 (abfd, buf);
 179       break;
 180     case 4:
 181       if (is_signed)
 182         value = bfd_get_signed_32 (abfd, buf);
 183       else
 184         value = bfd_get_32 (abfd, buf);
 185       break;
 186     case 8:
 187       if (is_signed)
 188         value = bfd_get_signed_64 (abfd, buf);
 189       else
 190         value = bfd_get_64 (abfd, buf);
 191       break;
 192     default:
 193       BFD_FAIL ();
 194       return 0;
 195     }
 196
 197   return value;
 198 }
 199
 200 /* Store a width sized value to memory.  */
 201
 202 static void
 203 write_value (bfd *abfd, bfd_byte *buf, bfd_vma value, int width)
 204 {
 205   switch (width)
 206     {
 207     case 2: bfd_put_16 (abfd, value, buf); break;
 208     case 4: bfd_put_32 (abfd, value, buf); break;
 209     case 8: bfd_put_64 (abfd, value, buf); break;
 210     default: BFD_FAIL ();
 211     }
 212 }
 213
 214 /* Return one if C1 and C2 CIEs can be merged.  */
 215
 216 static int
 217 cie_eq (const void *e1, const void *e2)
 218 {
 219   const struct cie *c1 = (const struct cie *) e1;
 220   const struct cie *c2 = (const struct cie *) e2;
 221
 222   if (c1->hash == c2->hash
 223       && c1->length == c2->length
 224       && c1->version == c2->version
 225       && c1->local_personality == c2->local_personality
 226       && strcmp (c1->augmentation, c2->augmentation) == 0
 227       && strcmp (c1->augmentation, "eh") != 0
 228       && c1->code_align == c2->code_align
 229       && c1->data_align == c2->data_align
 230       && c1->ra_column == c2->ra_column
 231       && c1->augmentation_size == c2->augmentation_size
 232       && memcmp (&c1->personality, &c2->personality,
 233                  sizeof (c1->personality)) == 0
 234       && (c1->cie_inf->u.cie.u.sec->output_section
 235           == c2->cie_inf->u.cie.u.sec->output_section)
 236       && c1->per_encoding == c2->per_encoding
 237       && c1->lsda_encoding == c2->lsda_encoding
 238       && c1->fde_encoding == c2->fde_encoding
 239       && c1->initial_insn_length == c2->initial_insn_length
 240       && c1->initial_insn_length <= sizeof (c1->initial_instructions)
 241       && memcmp (c1->initial_instructions,
 242                  c2->initial_instructions,
 243                  c1->initial_insn_length) == 0)
 244     return 1;
 245
 246   return 0;
 247 }
 248
 249 static hashval_t
 250 cie_hash (const void *e)
 251 {
 252   const struct cie *c = (const struct cie *) e;
 253   return c->hash;
 254 }
 255
 256 static hashval_t
 257 cie_compute_hash (struct cie *c)
 258 {
 259   hashval_t h = 0;
 260   size_t len;
 261   h = iterative_hash_object (c->length, h);
 262   h = iterative_hash_object (c->version, h);
 263   h = iterative_hash (c->augmentation, strlen (c->augmentation) + 1, h);
 264   h = iterative_hash_object (c->code_align, h);
 265   h = iterative_hash_object (c->data_align, h);
 266   h = iterative_hash_object (c->ra_column, h);
 267   h = iterative_hash_object (c->augmentation_size, h);
 268   h = iterative_hash_object (c->personality, h);
 269   h = iterative_hash_object (c->cie_inf->u.cie.u.sec->output_section, h);
 270   h = iterative_hash_object (c->per_encoding, h);
 271   h = iterative_hash_object (c->lsda_encoding, h);
 272   h = iterative_hash_object (c->fde_encoding, h);
 273   h = iterative_hash_object (c->initial_insn_length, h);
 274   len = c->initial_insn_length;
 275   if (len > sizeof (c->initial_instructions))
 276     len = sizeof (c->initial_instructions);
 277   h = iterative_hash (c->initial_instructions, len, h);
 278   c->hash = h;
 279   return h;
 280 }
 281
 282 /* Return the number of extra bytes that we'll be inserting into
 283    ENTRY's augmentation string.  */
 284
 285 static INLINE unsigned int
 286 extra_augmentation_string_bytes (struct eh_cie_fde *entry)
 287 {
 288   unsigned int size = 0;
 289   if (entry->cie)
 290     {
 291       if (entry->add_augmentation_size)
 292         size++;
 293       if (entry->u.cie.add_fde_encoding)
 294         size++;
 295     }
 296   return size;
 297 }
 298
 299 /* Likewise ENTRY's augmentation data.  */
 300
 301 static INLINE unsigned int
 302 extra_augmentation_data_bytes (struct eh_cie_fde *entry)
 303 {
 304   unsigned int size = 0;
 305   if (entry->add_augmentation_size)
 306     size++;
 307   if (entry->cie && entry->u.cie.add_fde_encoding)
 308     size++;
 309   return size;
 310 }
 311
 312 /* Return the size that ENTRY will have in the output.  ALIGNMENT is the
 313    required alignment of ENTRY in bytes.  */
 314
 315 static unsigned int
 316 size_of_output_cie_fde (struct eh_cie_fde *entry, unsigned int alignment)
 317 {
 318   if (entry->removed)
 319     return 0;
 320   if (entry->size == 4)
 321     return 4;
 322   return (entry->size
 323           + extra_augmentation_string_bytes (entry)
 324           + extra_augmentation_data_bytes (entry)
 325           + alignment - 1) & -alignment;
 326 }
 327
 328 /* Assume that the bytes between *ITER and END are CFA instructions.
 329    Try to move *ITER past the first instruction and return true on
 330    success.  ENCODED_PTR_WIDTH gives the width of pointer entries.  */
 331
 332 static bfd_boolean
 333 skip_cfa_op (bfd_byte **iter, bfd_byte *end, unsigned int encoded_ptr_width)
 334 {
 335   bfd_byte op;
 336   bfd_vma length;
 337
 338   if (!read_byte (iter, end, &op))
 339     return FALSE;
 340
 341   switch (op & 0xc0 ? op & 0xc0 : op)
 342     {
 343     case DW_CFA_nop:
 344     case DW_CFA_advance_loc:
 345     case DW_CFA_restore:
 346     case DW_CFA_remember_state:
 347     case DW_CFA_restore_state:
 348     case DW_CFA_GNU_window_save:
 349       /* No arguments.  */
 350       return TRUE;
 351
 352     case DW_CFA_offset:
 353     case DW_CFA_restore_extended:
 354     case DW_CFA_undefined:
 355     case DW_CFA_same_value:
 356     case DW_CFA_def_cfa_register:
 357     case DW_CFA_def_cfa_offset:
 358     case DW_CFA_def_cfa_offset_sf:
 359     case DW_CFA_GNU_args_size:
 360       /* One leb128 argument.  */
 361       return skip_leb128 (iter, end);
 362
 363     case DW_CFA_val_offset:
 364     case DW_CFA_val_offset_sf:
 365     case DW_CFA_offset_extended:
 366     case DW_CFA_register:
 367     case DW_CFA_def_cfa:
 368     case DW_CFA_offset_extended_sf:
 369     case DW_CFA_GNU_negative_offset_extended:
 370     case DW_CFA_def_cfa_sf:
 371       /* Two leb128 arguments.  */
 372       return (skip_leb128 (iter, end)
 373               && skip_leb128 (iter, end));
 374
 375     case DW_CFA_def_cfa_expression:
 376       /* A variable-length argument.  */
 377       return (read_uleb128 (iter, end, &length)
 378               && skip_bytes (iter, end, length));
 379
 380     case DW_CFA_expression:
 381     case DW_CFA_val_expression:
 382       /* A leb128 followed by a variable-length argument.  */
 383       return (skip_leb128 (iter, end)
 384               && read_uleb128 (iter, end, &length)
 385               && skip_bytes (iter, end, length));
 386
 387     case DW_CFA_set_loc:
 388       return skip_bytes (iter, end, encoded_ptr_width);
 389
 390     case DW_CFA_advance_loc1:
 391       return skip_bytes (iter, end, 1);
 392
 393     case DW_CFA_advance_loc2:
 394       return skip_bytes (iter, end, 2);
 395
 396     case DW_CFA_advance_loc4:
 397       return skip_bytes (iter, end, 4);
 398
 399     case DW_CFA_MIPS_advance_loc8:
 400       return skip_bytes (iter, end, 8);
 401
 402     default:
 403       return FALSE;
 404     }
 405 }
 406
 407 /* Try to interpret the bytes between BUF and END as CFA instructions.
 408    If every byte makes sense, return a pointer to the first DW_CFA_nop
 409    padding byte, or END if there is no padding.  Return null otherwise.
 410    ENCODED_PTR_WIDTH is as for skip_cfa_op.  */
 411
 412 static bfd_byte *
 413 skip_non_nops (bfd_byte *buf, bfd_byte *end, unsigned int encoded_ptr_width,
 414                unsigned int *set_loc_count)
 415 {
 416   bfd_byte *last;
 417
 418   last = buf;
 419   while (buf < end)
 420     if (*buf == DW_CFA_nop)
 421       buf++;
 422     else
 423       {
 424         if (*buf == DW_CFA_set_loc)
 425           ++*set_loc_count;
 426         if (!skip_cfa_op (&buf, end, encoded_ptr_width))
 427           return 0;
 428         last = buf;
 429       }
 430   return last;
 431 }
 432
 433 /* Convert absolute encoding ENCODING into PC-relative form.
 434    SIZE is the size of a pointer.  */
 435
 436 static unsigned char
 437 make_pc_relative (unsigned char encoding, unsigned int ptr_size)
 438 {
 439   if ((encoding & 0x7f) == DW_EH_PE_absptr)
 440     switch (ptr_size)
 441       {
 442       case 2:
 443         encoding |= DW_EH_PE_sdata2;
 444         break;
 445       case 4:
 446         encoding |= DW_EH_PE_sdata4;
 447         break;
 448       case 8:
 449         encoding |= DW_EH_PE_sdata8;
 450         break;
 451       }
 452   return encoding | DW_EH_PE_pcrel;
 453 }
 454
 455 /* Try to parse .eh_frame section SEC, which belongs to ABFD.  Store the
 456    information in the section's sec_info field on success.  COOKIE
 457    describes the relocations in SEC.  */
 458
 459 void
 460 _bfd_elf_parse_eh_frame (bfd *abfd, struct bfd_link_info *info,
 461                          asection *sec, struct elf_reloc_cookie *cookie)
 462 {
 463 #define REQUIRE(COND)                                   \
 464   do                                                    \
 465     if (!(COND))                                        \
 466       goto free_no_table;                               \
 467   while (0)
 468
 469   bfd_byte *ehbuf = NULL, *buf, *end;
 470   bfd_byte *last_fde;
 471   struct eh_cie_fde *this_inf;
 472   unsigned int hdr_length, hdr_id;
 473   unsigned int cie_count;
 474   struct cie *cie, *local_cies = NULL;
 475   struct elf_link_hash_table *htab;
 476   struct eh_frame_hdr_info *hdr_info;
 477   struct eh_frame_sec_info *sec_info = NULL;
 478   unsigned int ptr_size;
 479   unsigned int num_cies;
 480   unsigned int num_entries;
 481   elf_gc_mark_hook_fn gc_mark_hook;
 482
 483   htab = elf_hash_table (info);
 484   hdr_info = &htab->eh_info;
 485
 486   if (sec->size == 0
 487       || sec->sec_info_type != SEC_INFO_TYPE_NONE)
 488     {
 489       /* This file does not contain .eh_frame information.  */
 490       return;
 491     }
 492
 493   if (bfd_is_abs_section (sec->output_section))
 494     {
 495       /* At least one of the sections is being discarded from the
 496          link, so we should just ignore them.  */
 497       return;
 498     }
 499
 500   /* Read the frame unwind information from abfd.  */
 501
 502   REQUIRE (bfd_malloc_and_get_section (abfd, sec, &ehbuf));
 503
 504   if (sec->size >= 4
 505       && bfd_get_32 (abfd, ehbuf) == 0
 506       && cookie->rel == cookie->relend)
 507     {
 508       /* Empty .eh_frame section.  */
 509       free (ehbuf);
 510       return;
 511     }
 512
 513   /* If .eh_frame section size doesn't fit into int, we cannot handle
 514      it (it would need to use 64-bit .eh_frame format anyway).  */
 515   REQUIRE (sec->size == (unsigned int) sec->size);
 516
 517   ptr_size = (get_elf_backend_data (abfd)
 518               ->elf_backend_eh_frame_address_size (abfd, sec));
 519   REQUIRE (ptr_size != 0);
 520
 521   /* Go through the section contents and work out how many FDEs and
 522      CIEs there are.  */
 523   buf = ehbuf;
 524   end = ehbuf + sec->size;
 525   num_cies = 0;
 526   num_entries = 0;
 527   while (buf != end)
 528     {
 529       num_entries++;
 530
 531       /* Read the length of the entry.  */
 532       REQUIRE (skip_bytes (&buf, end, 4));
 533       hdr_length = bfd_get_32 (abfd, buf - 4);
 534
 535       /* 64-bit .eh_frame is not supported.  */
 536       REQUIRE (hdr_length != 0xffffffff);
 537       if (hdr_length == 0)
 538         break;
 539
 540       REQUIRE (skip_bytes (&buf, end, 4));
 541       hdr_id = bfd_get_32 (abfd, buf - 4);
 542       if (hdr_id == 0)
 543         num_cies++;
 544
 545       REQUIRE (skip_bytes (&buf, end, hdr_length - 4));
 546     }
 547
 548   sec_info = (struct eh_frame_sec_info *)
 549       bfd_zmalloc (sizeof (struct eh_frame_sec_info)
 550                    + (num_entries - 1) * sizeof (struct eh_cie_fde));
 551   REQUIRE (sec_info);
 552
 553   /* We need to have a "struct cie" for each CIE in this section.  */
 554   local_cies = (struct cie *) bfd_zmalloc (num_cies * sizeof (*local_cies));
 555   REQUIRE (local_cies);
 556
 557   /* FIXME: octets_per_byte.  */
 558 #define ENSURE_NO_RELOCS(buf)                           \
 559   while (cookie->rel < cookie->relend                   \
 560          && (cookie->rel->r_offset                      \
 561              < (bfd_size_type) ((buf) - ehbuf)))        \
 562     {                                                   \
 563       REQUIRE (cookie->rel->r_info == 0);               \
 564       cookie->rel++;                                    \
 565     }
 566
 567   /* FIXME: octets_per_byte.  */
 568 #define SKIP_RELOCS(buf)                                \
 569   while (cookie->rel < cookie->relend                   \
 570          && (cookie->rel->r_offset                      \
 571              < (bfd_size_type) ((buf) - ehbuf)))        \
 572     cookie->rel++
 573
 574   /* FIXME: octets_per_byte.  */
 575 #define GET_RELOC(buf)                                  \
 576   ((cookie->rel < cookie->relend                        \
 577     && (cookie->rel->r_offset                           \
 578         == (bfd_size_type) ((buf) - ehbuf)))            \
 579    ? cookie->rel : NULL)
 580
 581   buf = ehbuf;
 582   cie_count = 0;
 583   gc_mark_hook = get_elf_backend_data (abfd)->gc_mark_hook;
 584   while ((bfd_size_type) (buf - ehbuf) != sec->size)
 585     {
 586       char *aug;
 587       bfd_byte *start, *insns, *insns_end;
 588       bfd_size_type length;
 589       unsigned int set_loc_count;
 590
 591       this_inf = sec_info->entry + sec_info->count;
 592       last_fde = buf;
 593
 594       /* Read the length of the entry.  */
 595       REQUIRE (skip_bytes (&buf, ehbuf + sec->size, 4));
 596       hdr_length = bfd_get_32 (abfd, buf - 4);
 597
 598       /* The CIE/FDE must be fully contained in this input section.  */
 599       REQUIRE ((bfd_size_type) (buf - ehbuf) + hdr_length <= sec->size);
 600       end = buf + hdr_length;
 601
 602       this_inf->offset = last_fde - ehbuf;
 603       this_inf->size = 4 + hdr_length;
 604       this_inf->reloc_index = cookie->rel - cookie->rels;
 605
 606       if (hdr_length == 0)
 607         {
 608           /* A zero-length CIE should only be found at the end of
 609              the section.  */
 610           REQUIRE ((bfd_size_type) (buf - ehbuf) == sec->size);
 611           ENSURE_NO_RELOCS (buf);
 612           sec_info->count++;
 613           break;
 614         }
 615
 616       REQUIRE (skip_bytes (&buf, end, 4));
 617       hdr_id = bfd_get_32 (abfd, buf - 4);
 618
 619       if (hdr_id == 0)
 620         {
 621           unsigned int initial_insn_length;
 622
 623           /* CIE  */
 624           this_inf->cie = 1;
 625
 626           /* Point CIE to one of the section-local cie structures.  */
 627           cie = local_cies + cie_count++;
 628
 629           cie->cie_inf = this_inf;
 630           cie->length = hdr_length;
 631           start = buf;
 632           REQUIRE (read_byte (&buf, end, &cie->version));
 633
 634           /* Cannot handle unknown versions.  */
 635           REQUIRE (cie->version == 1
 636                    || cie->version == 3
 637                    || cie->version == 4);
 638           REQUIRE (strlen ((char *) buf) < sizeof (cie->augmentation));
 639
 640           strcpy (cie->augmentation, (char *) buf);
 641           buf = (bfd_byte *) strchr ((char *) buf, '\0') + 1;
 642           ENSURE_NO_RELOCS (buf);
 643           if (buf[0] == 'e' && buf[1] == 'h')
 644             {
 645               /* GCC < 3.0 .eh_frame CIE */
 646               /* We cannot merge "eh" CIEs because __EXCEPTION_TABLE__
 647                  is private to each CIE, so we don't need it for anything.
 648                  Just skip it.  */
 649               REQUIRE (skip_bytes (&buf, end, ptr_size));
 650               SKIP_RELOCS (buf);
 651             }
 652           if (cie->version >= 4)
 653             {
 654               REQUIRE (buf + 1 < end);
 655               REQUIRE (buf[0] == ptr_size);
 656               REQUIRE (buf[1] == 0);
 657               buf += 2;
 658             }
 659           REQUIRE (read_uleb128 (&buf, end, &cie->code_align));
 660           REQUIRE (read_sleb128 (&buf, end, &cie->data_align));
 661           if (cie->version == 1)
 662             {
 663               REQUIRE (buf < end);
 664               cie->ra_column = *buf++;
 665             }
 666           else
 667             REQUIRE (read_uleb128 (&buf, end, &cie->ra_column));
 668           ENSURE_NO_RELOCS (buf);
 669           cie->lsda_encoding = DW_EH_PE_omit;
 670           cie->fde_encoding = DW_EH_PE_omit;
 671           cie->per_encoding = DW_EH_PE_omit;
 672           aug = cie->augmentation;
 673           if (aug[0] != 'e' || aug[1] != 'h')
 674             {
 675               if (*aug == 'z')
 676                 {
 677                   aug++;
 678                   REQUIRE (read_uleb128 (&buf, end, &cie->augmentation_size));
 679                   ENSURE_NO_RELOCS (buf);
 680                 }
 681
 682               while (*aug != '\0')
 683                 switch (*aug++)
 684                   {
 685                   case 'L':
 686                     REQUIRE (read_byte (&buf, end, &cie->lsda_encoding));
 687                     ENSURE_NO_RELOCS (buf);
 688                     REQUIRE (get_DW_EH_PE_width (cie->lsda_encoding, ptr_size));
 689                     break;
 690                   case 'R':
 691                     REQUIRE (read_byte (&buf, end, &cie->fde_encoding));
 692                     ENSURE_NO_RELOCS (buf);
 693                     REQUIRE (get_DW_EH_PE_width (cie->fde_encoding, ptr_size));
 694                     break;
 695                   case 'S':
 696                     break;
 697                   case 'P':
 698                     {
 699                       int per_width;
 700
 701                       REQUIRE (read_byte (&buf, end, &cie->per_encoding));
 702                       per_width = get_DW_EH_PE_width (cie->per_encoding,
 703                                                       ptr_size);
 704                       REQUIRE (per_width);
 705                       if ((cie->per_encoding & 0x70) == DW_EH_PE_aligned)
 706                         {
 707                           length = -(buf - ehbuf) & (per_width - 1);
 708                           REQUIRE (skip_bytes (&buf, end, length));
 709                         }
 710                       this_inf->u.cie.personality_offset = buf - start;
 711                       ENSURE_NO_RELOCS (buf);
 712                       /* Ensure we have a reloc here.  */
 713                       REQUIRE (GET_RELOC (buf));
 714                       cie->personality.reloc_index
 715                         = cookie->rel - cookie->rels;
 716                       /* Cope with MIPS-style composite relocations.  */
 717                       do
 718                         cookie->rel++;
 719                       while (GET_RELOC (buf) != NULL);
 720                       REQUIRE (skip_bytes (&buf, end, per_width));
 721                     }
 722                     break;
 723                   default:
 724                     /* Unrecognized augmentation. Better bail out.  */
 725                     goto free_no_table;
 726                   }
 727             }
 728
 729           /* For shared libraries, try to get rid of as many RELATIVE relocs
 730              as possible.  */
 731           if (info->shared
 732               && !info->relocatable
 733               && (get_elf_backend_data (abfd)
 734                   ->elf_backend_can_make_relative_eh_frame
 735                   (abfd, info, sec)))
 736             {
 737               if ((cie->fde_encoding & 0x70) == DW_EH_PE_absptr)
 738                 this_inf->make_relative = 1;
 739               /* If the CIE doesn't already have an 'R' entry, it's fairly
 740                  easy to add one, provided that there's no aligned data
 741                  after the augmentation string.  */
 742               else if (cie->fde_encoding == DW_EH_PE_omit
 743                        && (cie->per_encoding & 0x70) != DW_EH_PE_aligned)
 744                 {
 745                   if (*cie->augmentation == 0)
 746                     this_inf->add_augmentation_size = 1;
 747                   this_inf->u.cie.add_fde_encoding = 1;
 748                   this_inf->make_relative = 1;
 749                 }
 750
 751               if ((cie->lsda_encoding & 0x70) == DW_EH_PE_absptr)
 752                 cie->can_make_lsda_relative = 1;
 753             }
 754
 755           /* If FDE encoding was not specified, it defaults to
 756              DW_EH_absptr.  */
 757           if (cie->fde_encoding == DW_EH_PE_omit)
 758             cie->fde_encoding = DW_EH_PE_absptr;
 759
 760           initial_insn_length = end - buf;
 761           cie->initial_insn_length = initial_insn_length;
 762           memcpy (cie->initial_instructions, buf,
 763                   initial_insn_length <= sizeof (cie->initial_instructions)
 764                   ? initial_insn_length : sizeof (cie->initial_instructions));
 765           insns = buf;
 766           buf += initial_insn_length;
 767           ENSURE_NO_RELOCS (buf);
 768
 769           if (!info->relocatable)
 770             {
 771               /* Keep info for merging cies.  */
 772               this_inf->u.cie.u.full_cie = cie;
 773               this_inf->u.cie.per_encoding_relative
 774                 = (cie->per_encoding & 0x70) == DW_EH_PE_pcrel;
 775             }
 776         }
 777       else
 778         {
 779           /* Find the corresponding CIE.  */
 780           unsigned int cie_offset = this_inf->offset + 4 - hdr_id;
 781           for (cie = local_cies; cie < local_cies + cie_count; cie++)
 782             if (cie_offset == cie->cie_inf->offset)
 783               break;
 784
 785           /* Ensure this FDE references one of the CIEs in this input
 786              section.  */
 787           REQUIRE (cie != local_cies + cie_count);
 788           this_inf->u.fde.cie_inf = cie->cie_inf;
 789           this_inf->make_relative = cie->cie_inf->make_relative;
 790           this_inf->add_augmentation_size
 791             = cie->cie_inf->add_augmentation_size;
 792
 793           ENSURE_NO_RELOCS (buf);
 794           if ((sec->flags & SEC_LINKER_CREATED) == 0 || cookie->rels != NULL)
 795             {
 796               asection *rsec;
 797
 798               REQUIRE (GET_RELOC (buf));
 799
 800               /* Chain together the FDEs for each section.  */
 801               rsec = _bfd_elf_gc_mark_rsec (info, sec, gc_mark_hook, cookie);
 802               /* RSEC will be NULL if FDE was cleared out as it was belonging to
 803                  a discarded SHT_GROUP.  */
 804               if (rsec)
 805                 {
 806                   REQUIRE (rsec->owner == abfd);
 807                   this_inf->u.fde.next_for_section = elf_fde_list (rsec);
 808                   elf_fde_list (rsec) = this_inf;
 809                 }
 810             }
 811
 812           /* Skip the initial location and address range.  */
 813           start = buf;
 814           length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
 815           REQUIRE (skip_bytes (&buf, end, 2 * length));
 816
 817           SKIP_RELOCS (buf - length);
 818           if (!GET_RELOC (buf - length)
 819               && read_value (abfd, buf - length, length, FALSE) == 0)
 820             {
 821               (*info->callbacks->minfo)
 822                 (_("discarding zero address range FDE in %B(%A).\n"),
 823                  abfd, sec);
 824               this_inf->u.fde.cie_inf = NULL;
 825             }
 826
 827           /* Skip the augmentation size, if present.  */
 828           if (cie->augmentation[0] == 'z')
 829             REQUIRE (read_uleb128 (&buf, end, &length));
 830           else
 831             length = 0;
 832
 833           /* Of the supported augmentation characters above, only 'L'
 834              adds augmentation data to the FDE.  This code would need to
 835              be adjusted if any future augmentations do the same thing.  */
 836           if (cie->lsda_encoding != DW_EH_PE_omit)
 837             {
 838               SKIP_RELOCS (buf);
 839               if (cie->can_make_lsda_relative && GET_RELOC (buf))
 840                 cie->cie_inf->u.cie.make_lsda_relative = 1;
 841               this_inf->lsda_offset = buf - start;
 842               /* If there's no 'z' augmentation, we don't know where the
 843                  CFA insns begin.  Assume no padding.  */
 844               if (cie->augmentation[0] != 'z')
 845                 length = end - buf;
 846             }
 847
 848           /* Skip over the augmentation data.  */
 849           REQUIRE (skip_bytes (&buf, end, length));
 850           insns = buf;
 851
 852           buf = last_fde + 4 + hdr_length;
 853
 854           /* For NULL RSEC (cleared FDE belonging to a discarded section)
 855              the relocations are commonly cleared.  We do not sanity check if
 856              all these relocations are cleared as (1) relocations to
 857              .gcc_except_table will remain uncleared (they will get dropped
 858              with the drop of this unused FDE) and (2) BFD already safely drops
 859              relocations of any type to .eh_frame by
 860              elf_section_ignore_discarded_relocs.
 861              TODO: The .gcc_except_table entries should be also filtered as
 862              .eh_frame entries; or GCC could rather use COMDAT for them.  */
 863           SKIP_RELOCS (buf);
 864         }
 865
 866       /* Try to interpret the CFA instructions and find the first
 867          padding nop.  Shrink this_inf's size so that it doesn't
 868          include the padding.  */
 869       length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
 870       set_loc_count = 0;
 871       insns_end = skip_non_nops (insns, end, length, &set_loc_count);
 872       /* If we don't understand the CFA instructions, we can't know
 873          what needs to be adjusted there.  */
 874       if (insns_end == NULL
 875           /* For the time being we don't support DW_CFA_set_loc in
 876              CIE instructions.  */
 877           || (set_loc_count && this_inf->cie))
 878         goto free_no_table;
 879       this_inf->size -= end - insns_end;
 880       if (insns_end != end && this_inf->cie)
 881         {
 882           cie->initial_insn_length -= end - insns_end;
 883           cie->length -= end - insns_end;
 884         }
 885       if (set_loc_count
 886           && ((cie->fde_encoding & 0x70) == DW_EH_PE_pcrel
 887               || this_inf->make_relative))
 888         {
 889           unsigned int cnt;
 890           bfd_byte *p;
 891
 892           this_inf->set_loc = (unsigned int *)
 893               bfd_malloc ((set_loc_count + 1) * sizeof (unsigned int));
 894           REQUIRE (this_inf->set_loc);
 895           this_inf->set_loc[0] = set_loc_count;
 896           p = insns;
 897           cnt = 0;
 898           while (p < end)
 899             {
 900               if (*p == DW_CFA_set_loc)
 901                 this_inf->set_loc[++cnt] = p + 1 - start;
 902               REQUIRE (skip_cfa_op (&p, end, length));
 903             }
 904         }
 905
 906       this_inf->removed = 1;
 907       this_inf->fde_encoding = cie->fde_encoding;
 908       this_inf->lsda_encoding = cie->lsda_encoding;
 909       sec_info->count++;
 910     }
 911   BFD_ASSERT (sec_info->count == num_entries);
 912   BFD_ASSERT (cie_count == num_cies);
 913
 914   elf_section_data (sec)->sec_info = sec_info;
 915   sec->sec_info_type = SEC_INFO_TYPE_EH_FRAME;
 916   if (!info->relocatable)
 917     {
 918       /* Keep info for merging cies.  */
 919       sec_info->cies = local_cies;
 920       local_cies = NULL;
 921     }
 922   goto success;
 923
 924  free_no_table:
 925   (*info->callbacks->einfo)
 926     (_("%P: error in %B(%A); no .eh_frame_hdr table will be created.\n"),
 927      abfd, sec);
 928   hdr_info->table = FALSE;
 929   if (sec_info)
 930     free (sec_info);
 931  success:
 932   if (ehbuf)
 933     free (ehbuf);
 934   if (local_cies)
 935     free (local_cies);
 936 #undef REQUIRE
 937 }
 938
 939 /* Mark all relocations against CIE or FDE ENT, which occurs in
 940    .eh_frame section SEC.  COOKIE describes the relocations in SEC;
 941    its "rel" field can be changed freely.  */
 942
 943 static bfd_boolean
 944 mark_entry (struct bfd_link_info *info, asection *sec,
 945             struct eh_cie_fde *ent, elf_gc_mark_hook_fn gc_mark_hook,
 946             struct elf_reloc_cookie *cookie)
 947 {
 948   /* FIXME: octets_per_byte.  */
 949   for (cookie->rel = cookie->rels + ent->reloc_index;
 950        cookie->rel < cookie->relend
 951          && cookie->rel->r_offset < ent->offset + ent->size;
 952        cookie->rel++)
 953     if (!_bfd_elf_gc_mark_reloc (info, sec, gc_mark_hook, cookie))
 954       return FALSE;
 955
 956   return TRUE;
 957 }
 958
 959 /* Mark all the relocations against FDEs that relate to code in input
 960    section SEC.  The FDEs belong to .eh_frame section EH_FRAME, whose
 961    relocations are described by COOKIE.  */
 962
 963 bfd_boolean
 964 _bfd_elf_gc_mark_fdes (struct bfd_link_info *info, asection *sec,
 965                        asection *eh_frame, elf_gc_mark_hook_fn gc_mark_hook,
 966                        struct elf_reloc_cookie *cookie)
 967 {
 968   struct eh_cie_fde *fde, *cie;
 969
 970   for (fde = elf_fde_list (sec); fde; fde = fde->u.fde.next_for_section)
 971     {
 972       if (!mark_entry (info, eh_frame, fde, gc_mark_hook, cookie))
 973         return FALSE;
 974
 975       /* At this stage, all cie_inf fields point to local CIEs, so we
 976          can use the same cookie to refer to them.  */
 977       cie = fde->u.fde.cie_inf;
 978       if (cie != NULL && !cie->u.cie.gc_mark)
 979         {
 980           cie->u.cie.gc_mark = 1;
 981           if (!mark_entry (info, eh_frame, cie, gc_mark_hook, cookie))
 982             return FALSE;
 983         }
 984     }
 985   return TRUE;
 986 }
 987
 988 /* Input section SEC of ABFD is an .eh_frame section that contains the
 989    CIE described by CIE_INF.  Return a version of CIE_INF that is going
 990    to be kept in the output, adding CIE_INF to the output if necessary.
 991
 992    HDR_INFO is the .eh_frame_hdr information and COOKIE describes the
 993    relocations in REL.  */
 994
 995 static struct eh_cie_fde *
 996 find_merged_cie (bfd *abfd, struct bfd_link_info *info, asection *sec,
 997                  struct eh_frame_hdr_info *hdr_info,
 998                  struct elf_reloc_cookie *cookie,
 999                  struct eh_cie_fde *cie_inf)
1000 {
1001   unsigned long r_symndx;
1002   struct cie *cie, *new_cie;
1003   Elf_Internal_Rela *rel;
1004   void **loc;
1005
1006   /* Use CIE_INF if we have already decided to keep it.  */
1007   if (!cie_inf->removed)
1008     return cie_inf;
1009
1010   /* If we have merged CIE_INF with another CIE, use that CIE instead.  */
1011   if (cie_inf->u.cie.merged)
1012     return cie_inf->u.cie.u.merged_with;
1013
1014   cie = cie_inf->u.cie.u.full_cie;
1015
1016   /* Assume we will need to keep CIE_INF.  */
1017   cie_inf->removed = 0;
1018   cie_inf->u.cie.u.sec = sec;
1019
1020   /* If we are not merging CIEs, use CIE_INF.  */
1021   if (cie == NULL)
1022     return cie_inf;
1023
1024   if (cie->per_encoding != DW_EH_PE_omit)
1025     {
1026       bfd_boolean per_binds_local;
1027
1028       /* Work out the address of personality routine, or at least
1029          enough info that we could calculate the address had we made a
1030          final section layout.  The symbol on the reloc is enough,
1031          either the hash for a global, or (bfd id, index) pair for a
1032          local.  The assumption here is that no one uses addends on
1033          the reloc.  */
1034       rel = cookie->rels + cie->personality.reloc_index;
1035       memset (&cie->personality, 0, sizeof (cie->personality));
1036 #ifdef BFD64
1037       if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64)
1038         r_symndx = ELF64_R_SYM (rel->r_info);
1039       else
1040 #endif
1041         r_symndx = ELF32_R_SYM (rel->r_info);
1042       if (r_symndx >= cookie->locsymcount
1043           || ELF_ST_BIND (cookie->locsyms[r_symndx].st_info) != STB_LOCAL)
1044         {
1045           struct elf_link_hash_entry *h;
1046
1047           r_symndx -= cookie->extsymoff;
1048           h = cookie->sym_hashes[r_symndx];
1049
1050           while (h->root.type == bfd_link_hash_indirect
1051                  || h->root.type == bfd_link_hash_warning)
1052             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1053
1054           cie->personality.h = h;
1055           per_binds_local = SYMBOL_REFERENCES_LOCAL (info, h);
1056         }
1057       else
1058         {
1059           Elf_Internal_Sym *sym;
1060           asection *sym_sec;
1061
1062           sym = &cookie->locsyms[r_symndx];
1063           sym_sec = bfd_section_from_elf_index (abfd, sym->st_shndx);
1064           if (sym_sec == NULL)
1065             return cie_inf;
1066
1067           if (sym_sec->kept_section != NULL)
1068             sym_sec = sym_sec->kept_section;
1069           if (sym_sec->output_section == NULL)
1070             return cie_inf;
1071
1072           cie->local_personality = 1;
1073           cie->personality.sym.bfd_id = abfd->id;
1074           cie->personality.sym.index = r_symndx;
1075           per_binds_local = TRUE;
1076         }
1077
1078       if (per_binds_local
1079           && info->shared
1080           && !info->relocatable
1081           && (cie->per_encoding & 0x70) == DW_EH_PE_absptr
1082           && (get_elf_backend_data (abfd)
1083               ->elf_backend_can_make_relative_eh_frame (abfd, info, sec)))
1084         {
1085           cie_inf->u.cie.make_per_encoding_relative = 1;
1086           cie_inf->u.cie.per_encoding_relative = 1;
1087         }
1088     }
1089
1090   /* See if we can merge this CIE with an earlier one.  */
1091   cie_compute_hash (cie);
1092   if (hdr_info->cies == NULL)
1093     {
1094       hdr_info->cies = htab_try_create (1, cie_hash, cie_eq, free);
1095       if (hdr_info->cies == NULL)
1096         return cie_inf;
1097     }
1098   loc = htab_find_slot_with_hash (hdr_info->cies, cie, cie->hash, INSERT);
1099   if (loc == NULL)
1100     return cie_inf;
1101
1102   new_cie = (struct cie *) *loc;
1103   if (new_cie == NULL)
1104     {
1105       /* Keep CIE_INF and record it in the hash table.  */
1106       new_cie = (struct cie *) malloc (sizeof (struct cie));
1107       if (new_cie == NULL)
1108         return cie_inf;
1109
1110       memcpy (new_cie, cie, sizeof (struct cie));
1111       *loc = new_cie;
1112     }
1113   else
1114     {
1115       /* Merge CIE_INF with NEW_CIE->CIE_INF.  */
1116       cie_inf->removed = 1;
1117       cie_inf->u.cie.merged = 1;
1118       cie_inf->u.cie.u.merged_with = new_cie->cie_inf;
1119       if (cie_inf->u.cie.make_lsda_relative)
1120         new_cie->cie_inf->u.cie.make_lsda_relative = 1;
1121     }
1122   return new_cie->cie_inf;
1123 }
1124
1125 /* This function is called for each input file before the .eh_frame
1126    section is relocated.  It discards duplicate CIEs and FDEs for discarded
1127    functions.  The function returns TRUE iff any entries have been
1128    deleted.  */
1129
1130 bfd_boolean
1131 _bfd_elf_discard_section_eh_frame
1132    (bfd *abfd, struct bfd_link_info *info, asection *sec,
1133     bfd_boolean (*reloc_symbol_deleted_p) (bfd_vma, void *),
1134     struct elf_reloc_cookie *cookie)
1135 {
1136   struct eh_cie_fde *ent;
1137   struct eh_frame_sec_info *sec_info;
1138   struct eh_frame_hdr_info *hdr_info;
1139   unsigned int ptr_size, offset;
1140
1141   if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME)
1142     return FALSE;
1143
1144   sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
1145   if (sec_info == NULL)
1146     return FALSE;
1147
1148   ptr_size = (get_elf_backend_data (sec->owner)
1149               ->elf_backend_eh_frame_address_size (sec->owner, sec));
1150
1151   hdr_info = &elf_hash_table (info)->eh_info;
1152   for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1153     if (ent->size == 4)
1154       /* There should only be one zero terminator, on the last input
1155          file supplying .eh_frame (crtend.o).  Remove any others.  */
1156       ent->removed = sec->map_head.s != NULL;
1157     else if (!ent->cie && ent->u.fde.cie_inf != NULL)
1158       {
1159         bfd_boolean keep;
1160         if ((sec->flags & SEC_LINKER_CREATED) != 0 && cookie->rels == NULL)
1161           {
1162             unsigned int width
1163               = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1164             bfd_vma value
1165               = read_value (abfd, sec->contents + ent->offset + 8 + width,
1166                             width, get_DW_EH_PE_signed (ent->fde_encoding));
1167             keep = value != 0;
1168           }
1169         else
1170           {
1171             cookie->rel = cookie->rels + ent->reloc_index;
1172             /* FIXME: octets_per_byte.  */
1173             BFD_ASSERT (cookie->rel < cookie->relend
1174                         && cookie->rel->r_offset == ent->offset + 8);
1175             keep = !(*reloc_symbol_deleted_p) (ent->offset + 8, cookie);
1176           }
1177         if (keep)
1178           {
1179             if (info->shared
1180                 && (((ent->fde_encoding & 0x70) == DW_EH_PE_absptr
1181                      && ent->make_relative == 0)
1182                     || (ent->fde_encoding & 0x70) == DW_EH_PE_aligned))
1183               {
1184                 /* If a shared library uses absolute pointers
1185                    which we cannot turn into PC relative,
1186                    don't create the binary search table,
1187                    since it is affected by runtime relocations.  */
1188                 hdr_info->table = FALSE;
1189                 (*info->callbacks->einfo)
1190                   (_("%P: FDE encoding in %B(%A) prevents .eh_frame_hdr"
1191                      " table being created.\n"), abfd, sec);
1192               }
1193             ent->removed = 0;
1194             hdr_info->fde_count++;
1195             ent->u.fde.cie_inf = find_merged_cie (abfd, info, sec, hdr_info,
1196                                                   cookie, ent->u.fde.cie_inf);
1197           }
1198       }
1199
1200   if (sec_info->cies)
1201     {
1202       free (sec_info->cies);
1203       sec_info->cies = NULL;
1204     }
1205
1206   offset = 0;
1207   for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1208     if (!ent->removed)
1209       {
1210         ent->new_offset = offset;
1211         offset += size_of_output_cie_fde (ent, ptr_size);
1212       }
1213
1214   sec->rawsize = sec->size;
1215   sec->size = offset;
1216   return offset != sec->rawsize;
1217 }
1218
1219 /* This function is called for .eh_frame_hdr section after
1220    _bfd_elf_discard_section_eh_frame has been called on all .eh_frame
1221    input sections.  It finalizes the size of .eh_frame_hdr section.  */
1222
1223 bfd_boolean
1224 _bfd_elf_discard_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
1225 {
1226   struct elf_link_hash_table *htab;
1227   struct eh_frame_hdr_info *hdr_info;
1228   asection *sec;
1229
1230   htab = elf_hash_table (info);
1231   hdr_info = &htab->eh_info;
1232
1233   if (hdr_info->cies != NULL)
1234     {
1235       htab_delete (hdr_info->cies);
1236       hdr_info->cies = NULL;
1237     }
1238
1239   sec = hdr_info->hdr_sec;
1240   if (sec == NULL)
1241     return FALSE;
1242
1243   sec->size = EH_FRAME_HDR_SIZE;
1244   if (hdr_info->table)
1245     sec->size += 4 + hdr_info->fde_count * 8;
1246
1247   elf_eh_frame_hdr (abfd) = sec;
1248   return TRUE;
1249 }
1250
1251 /* Return true if there is at least one non-empty .eh_frame section in
1252    input files.  Can only be called after ld has mapped input to
1253    output sections, and before sections are stripped.  */
1254 bfd_boolean
1255 _bfd_elf_eh_frame_present (struct bfd_link_info *info)
1256 {
1257   asection *eh = bfd_get_section_by_name (info->output_bfd, ".eh_frame");
1258
1259   if (eh == NULL)
1260     return FALSE;
1261
1262   /* Count only sections which have at least a single CIE or FDE.
1263      There cannot be any CIE or FDE <= 8 bytes.  */
1264   for (eh = eh->map_head.s; eh != NULL; eh = eh->map_head.s)
1265     if (eh->size > 8)
1266       return TRUE;
1267
1268   return FALSE;
1269 }
1270
1271 /* This function is called from size_dynamic_sections.
1272    It needs to decide whether .eh_frame_hdr should be output or not,
1273    because when the dynamic symbol table has been sized it is too late
1274    to strip sections.  */
1275
1276 bfd_boolean
1277 _bfd_elf_maybe_strip_eh_frame_hdr (struct bfd_link_info *info)
1278 {
1279   struct elf_link_hash_table *htab;
1280   struct eh_frame_hdr_info *hdr_info;
1281
1282   htab = elf_hash_table (info);
1283   hdr_info = &htab->eh_info;
1284   if (hdr_info->hdr_sec == NULL)
1285     return TRUE;
1286
1287   if (bfd_is_abs_section (hdr_info->hdr_sec->output_section)
1288       || !info->eh_frame_hdr
1289       || !_bfd_elf_eh_frame_present (info))
1290     {
1291       hdr_info->hdr_sec->flags |= SEC_EXCLUDE;
1292       hdr_info->hdr_sec = NULL;
1293       return TRUE;
1294     }
1295
1296   hdr_info->table = TRUE;
1297   return TRUE;
1298 }
1299
1300 /* Adjust an address in the .eh_frame section.  Given OFFSET within
1301    SEC, this returns the new offset in the adjusted .eh_frame section,
1302    or -1 if the address refers to a CIE/FDE which has been removed
1303    or to offset with dynamic relocation which is no longer needed.  */
1304
1305 bfd_vma
1306 _bfd_elf_eh_frame_section_offset (bfd *output_bfd ATTRIBUTE_UNUSED,
1307                                   struct bfd_link_info *info ATTRIBUTE_UNUSED,
1308                                   asection *sec,
1309                                   bfd_vma offset)
1310 {
1311   struct eh_frame_sec_info *sec_info;
1312   unsigned int lo, hi, mid;
1313
1314   if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME)
1315     return offset;
1316   sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
1317
1318   if (offset >= sec->rawsize)
1319     return offset - sec->rawsize + sec->size;
1320
1321   lo = 0;
1322   hi = sec_info->count;
1323   mid = 0;
1324   while (lo < hi)
1325     {
1326       mid = (lo + hi) / 2;
1327       if (offset < sec_info->entry[mid].offset)
1328         hi = mid;
1329       else if (offset
1330                >= sec_info->entry[mid].offset + sec_info->entry[mid].size)
1331         lo = mid + 1;
1332       else
1333         break;
1334     }
1335
1336   BFD_ASSERT (lo < hi);
1337
1338   /* FDE or CIE was removed.  */
1339   if (sec_info->entry[mid].removed)
1340     return (bfd_vma) -1;
1341
1342   /* If converting personality pointers to DW_EH_PE_pcrel, there will be
1343      no need for run-time relocation against the personality field.  */
1344   if (sec_info->entry[mid].cie
1345       && sec_info->entry[mid].u.cie.make_per_encoding_relative
1346       && offset == (sec_info->entry[mid].offset + 8
1347                     + sec_info->entry[mid].u.cie.personality_offset))
1348     return (bfd_vma) -2;
1349
1350   /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1351      relocation against FDE's initial_location field.  */
1352   if (!sec_info->entry[mid].cie
1353       && sec_info->entry[mid].make_relative
1354       && offset == sec_info->entry[mid].offset + 8)
1355     return (bfd_vma) -2;
1356
1357   /* If converting LSDA pointers to DW_EH_PE_pcrel, there will be no need
1358      for run-time relocation against LSDA field.  */
1359   if (!sec_info->entry[mid].cie
1360       && sec_info->entry[mid].u.fde.cie_inf->u.cie.make_lsda_relative
1361       && offset == (sec_info->entry[mid].offset + 8
1362                     + sec_info->entry[mid].lsda_offset))
1363     return (bfd_vma) -2;
1364
1365   /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1366      relocation against DW_CFA_set_loc's arguments.  */
1367   if (sec_info->entry[mid].set_loc
1368       && sec_info->entry[mid].make_relative
1369       && (offset >= sec_info->entry[mid].offset + 8
1370                     + sec_info->entry[mid].set_loc[1]))
1371     {
1372       unsigned int cnt;
1373
1374       for (cnt = 1; cnt <= sec_info->entry[mid].set_loc[0]; cnt++)
1375         if (offset == sec_info->entry[mid].offset + 8
1376                       + sec_info->entry[mid].set_loc[cnt])
1377           return (bfd_vma) -2;
1378     }
1379
1380   /* Any new augmentation bytes go before the first relocation.  */
1381   return (offset + sec_info->entry[mid].new_offset
1382           - sec_info->entry[mid].offset
1383           + extra_augmentation_string_bytes (sec_info->entry + mid)
1384           + extra_augmentation_data_bytes (sec_info->entry + mid));
1385 }
1386
1387 /* Write out .eh_frame section.  This is called with the relocated
1388    contents.  */
1389
1390 bfd_boolean
1391 _bfd_elf_write_section_eh_frame (bfd *abfd,
1392                                  struct bfd_link_info *info,
1393                                  asection *sec,
1394                                  bfd_byte *contents)
1395 {
1396   struct eh_frame_sec_info *sec_info;
1397   struct elf_link_hash_table *htab;
1398   struct eh_frame_hdr_info *hdr_info;
1399   unsigned int ptr_size;
1400   struct eh_cie_fde *ent;
1401   bfd_size_type sec_size;
1402
1403   if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME)
1404     /* FIXME: octets_per_byte.  */
1405     return bfd_set_section_contents (abfd, sec->output_section, contents,
1406                                      sec->output_offset, sec->size);
1407
1408   ptr_size = (get_elf_backend_data (abfd)
1409               ->elf_backend_eh_frame_address_size (abfd, sec));
1410   BFD_ASSERT (ptr_size != 0);
1411
1412   sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
1413   htab = elf_hash_table (info);
1414   hdr_info = &htab->eh_info;
1415
1416   if (hdr_info->table && hdr_info->array == NULL)
1417     hdr_info->array = (struct eh_frame_array_ent *)
1418         bfd_malloc (hdr_info->fde_count * sizeof(*hdr_info->array));
1419   if (hdr_info->array == NULL)
1420     hdr_info = NULL;
1421
1422   /* The new offsets can be bigger or smaller than the original offsets.
1423      We therefore need to make two passes over the section: one backward
1424      pass to move entries up and one forward pass to move entries down.
1425      The two passes won't interfere with each other because entries are
1426      not reordered  */
1427   for (ent = sec_info->entry + sec_info->count; ent-- != sec_info->entry;)
1428     if (!ent->removed && ent->new_offset > ent->offset)
1429       memmove (contents + ent->new_offset, contents + ent->offset, ent->size);
1430
1431   for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1432     if (!ent->removed && ent->new_offset < ent->offset)
1433       memmove (contents + ent->new_offset, contents + ent->offset, ent->size);
1434
1435   for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1436     {
1437       unsigned char *buf, *end;
1438       unsigned int new_size;
1439
1440       if (ent->removed)
1441         continue;
1442
1443       if (ent->size == 4)
1444         {
1445           /* Any terminating FDE must be at the end of the section.  */
1446           BFD_ASSERT (ent == sec_info->entry + sec_info->count - 1);
1447           continue;
1448         }
1449
1450       buf = contents + ent->new_offset;
1451       end = buf + ent->size;
1452       new_size = size_of_output_cie_fde (ent, ptr_size);
1453
1454       /* Update the size.  It may be shrinked.  */
1455       bfd_put_32 (abfd, new_size - 4, buf);
1456
1457       /* Filling the extra bytes with DW_CFA_nops.  */
1458       if (new_size != ent->size)
1459         memset (end, 0, new_size - ent->size);
1460
1461       if (ent->cie)
1462         {
1463           /* CIE */
1464           if (ent->make_relative
1465               || ent->u.cie.make_lsda_relative
1466               || ent->u.cie.per_encoding_relative)
1467             {
1468               char *aug;
1469               unsigned int action, extra_string, extra_data;
1470               unsigned int per_width, per_encoding;
1471
1472               /* Need to find 'R' or 'L' augmentation's argument and modify
1473                  DW_EH_PE_* value.  */
1474               action = ((ent->make_relative ? 1 : 0)
1475                         | (ent->u.cie.make_lsda_relative ? 2 : 0)
1476                         | (ent->u.cie.per_encoding_relative ? 4 : 0));
1477               extra_string = extra_augmentation_string_bytes (ent);
1478               extra_data = extra_augmentation_data_bytes (ent);
1479
1480               /* Skip length, id and version.  */
1481               buf += 9;
1482               aug = (char *) buf;
1483               buf += strlen (aug) + 1;
1484               skip_leb128 (&buf, end);
1485               skip_leb128 (&buf, end);
1486               skip_leb128 (&buf, end);
1487               if (*aug == 'z')
1488                 {
1489                   /* The uleb128 will always be a single byte for the kind
1490                      of augmentation strings that we're prepared to handle.  */
1491                   *buf++ += extra_data;
1492                   aug++;
1493                 }
1494
1495               /* Make room for the new augmentation string and data bytes.  */
1496               memmove (buf + extra_string + extra_data, buf, end - buf);
1497               memmove (aug + extra_string, aug, buf - (bfd_byte *) aug);
1498               buf += extra_string;
1499               end += extra_string + extra_data;
1500
1501               if (ent->add_augmentation_size)
1502                 {
1503                   *aug++ = 'z';
1504                   *buf++ = extra_data - 1;
1505                 }
1506               if (ent->u.cie.add_fde_encoding)
1507                 {
1508                   BFD_ASSERT (action & 1);
1509                   *aug++ = 'R';
1510                   *buf++ = make_pc_relative (DW_EH_PE_absptr, ptr_size);
1511                   action &= ~1;
1512                 }
1513
1514               while (action)
1515                 switch (*aug++)
1516                   {
1517                   case 'L':
1518                     if (action & 2)
1519                       {
1520                         BFD_ASSERT (*buf == ent->lsda_encoding);
1521                         *buf = make_pc_relative (*buf, ptr_size);
1522                         action &= ~2;
1523                       }
1524                     buf++;
1525                     break;
1526                   case 'P':
1527                     if (ent->u.cie.make_per_encoding_relative)
1528                       *buf = make_pc_relative (*buf, ptr_size);
1529                     per_encoding = *buf++;
1530                     per_width = get_DW_EH_PE_width (per_encoding, ptr_size);
1531                     BFD_ASSERT (per_width != 0);
1532                     BFD_ASSERT (((per_encoding & 0x70) == DW_EH_PE_pcrel)
1533                                 == ent->u.cie.per_encoding_relative);
1534                     if ((per_encoding & 0x70) == DW_EH_PE_aligned)
1535                       buf = (contents
1536                              + ((buf - contents + per_width - 1)
1537                                 & ~((bfd_size_type) per_width - 1)));
1538                     if (action & 4)
1539                       {
1540                         bfd_vma val;
1541
1542                         val = read_value (abfd, buf, per_width,
1543                                           get_DW_EH_PE_signed (per_encoding));
1544                         if (ent->u.cie.make_per_encoding_relative)
1545                           val -= (sec->output_section->vma
1546                                   + sec->output_offset
1547                                   + (buf - contents));
1548                         else
1549                           {
1550                             val += (bfd_vma) ent->offset - ent->new_offset;
1551                             val -= extra_string + extra_data;
1552                           }
1553                         write_value (abfd, buf, val, per_width);
1554                         action &= ~4;
1555                       }
1556                     buf += per_width;
1557                     break;
1558                   case 'R':
1559                     if (action & 1)
1560                       {
1561                         BFD_ASSERT (*buf == ent->fde_encoding);
1562                         *buf = make_pc_relative (*buf, ptr_size);
1563                         action &= ~1;
1564                       }
1565                     buf++;
1566                     break;
1567                   case 'S':
1568                     break;
1569                   default:
1570                     BFD_FAIL ();
1571                   }
1572             }
1573         }
1574       else
1575         {
1576           /* FDE */
1577           bfd_vma value, address;
1578           unsigned int width;
1579           bfd_byte *start;
1580           struct eh_cie_fde *cie;
1581
1582           /* Skip length.  */
1583           cie = ent->u.fde.cie_inf;
1584           buf += 4;
1585           value = ((ent->new_offset + sec->output_offset + 4)
1586                    - (cie->new_offset + cie->u.cie.u.sec->output_offset));
1587           bfd_put_32 (abfd, value, buf);
1588           if (info->relocatable)
1589             continue;
1590           buf += 4;
1591           width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1592           value = read_value (abfd, buf, width,
1593                               get_DW_EH_PE_signed (ent->fde_encoding));
1594           address = value;
1595           if (value)
1596             {
1597               switch (ent->fde_encoding & 0x70)
1598                 {
1599                 case DW_EH_PE_textrel:
1600                   BFD_ASSERT (hdr_info == NULL);
1601                   break;
1602                 case DW_EH_PE_datarel:
1603                   {
1604                     switch (abfd->arch_info->arch)
1605                       {
1606                       case bfd_arch_ia64:
1607                         BFD_ASSERT (elf_gp (abfd) != 0);
1608                         address += elf_gp (abfd);
1609                         break;
1610                       default:
1611                         (*info->callbacks->einfo)
1612                           (_("%P: DW_EH_PE_datarel unspecified"
1613                              " for this architecture.\n"));
1614                         /* Fall thru */
1615                       case bfd_arch_frv:
1616                       case bfd_arch_i386:
1617                         BFD_ASSERT (htab->hgot != NULL
1618                                     && ((htab->hgot->root.type
1619                                          == bfd_link_hash_defined)
1620                                         || (htab->hgot->root.type
1621                                             == bfd_link_hash_defweak)));
1622                         address
1623                           += (htab->hgot->root.u.def.value
1624                               + htab->hgot->root.u.def.section->output_offset
1625                               + (htab->hgot->root.u.def.section->output_section
1626                                  ->vma));
1627                         break;
1628                       }
1629                   }
1630                   break;
1631                 case DW_EH_PE_pcrel:
1632                   value += (bfd_vma) ent->offset - ent->new_offset;
1633                   address += (sec->output_section->vma
1634                               + sec->output_offset
1635                               + ent->offset + 8);
1636                   break;
1637                 }
1638               if (ent->make_relative)
1639                 value -= (sec->output_section->vma
1640                           + sec->output_offset
1641                           + ent->new_offset + 8);
1642               write_value (abfd, buf, value, width);
1643             }
1644
1645           start = buf;
1646
1647           if (hdr_info)
1648             {
1649               /* The address calculation may overflow, giving us a
1650                  value greater than 4G on a 32-bit target when
1651                  dwarf_vma is 64-bit.  */
1652               if (sizeof (address) > 4 && ptr_size == 4)
1653                 address &= 0xffffffff;
1654               hdr_info->array[hdr_info->array_count].initial_loc = address;
1655               hdr_info->array[hdr_info->array_count].range
1656                 = read_value (abfd, buf + width, width, FALSE);
1657               hdr_info->array[hdr_info->array_count++].fde
1658                 = (sec->output_section->vma
1659                    + sec->output_offset
1660                    + ent->new_offset);
1661             }
1662
1663           if ((ent->lsda_encoding & 0x70) == DW_EH_PE_pcrel
1664               || cie->u.cie.make_lsda_relative)
1665             {
1666               buf += ent->lsda_offset;
1667               width = get_DW_EH_PE_width (ent->lsda_encoding, ptr_size);
1668               value = read_value (abfd, buf, width,
1669                                   get_DW_EH_PE_signed (ent->lsda_encoding));
1670               if (value)
1671                 {
1672                   if ((ent->lsda_encoding & 0x70) == DW_EH_PE_pcrel)
1673                     value += (bfd_vma) ent->offset - ent->new_offset;
1674                   else if (cie->u.cie.make_lsda_relative)
1675                     value -= (sec->output_section->vma
1676                               + sec->output_offset
1677                               + ent->new_offset + 8 + ent->lsda_offset);
1678                   write_value (abfd, buf, value, width);
1679                 }
1680             }
1681           else if (ent->add_augmentation_size)
1682             {
1683               /* Skip the PC and length and insert a zero byte for the
1684                  augmentation size.  */
1685               buf += width * 2;
1686               memmove (buf + 1, buf, end - buf);
1687               *buf = 0;
1688             }
1689
1690           if (ent->set_loc)
1691             {
1692               /* Adjust DW_CFA_set_loc.  */
1693               unsigned int cnt;
1694               bfd_vma new_offset;
1695
1696               width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1697               new_offset = ent->new_offset + 8
1698                            + extra_augmentation_string_bytes (ent)
1699                            + extra_augmentation_data_bytes (ent);
1700
1701               for (cnt = 1; cnt <= ent->set_loc[0]; cnt++)
1702                 {
1703                   buf = start + ent->set_loc[cnt];
1704
1705                   value = read_value (abfd, buf, width,
1706                                       get_DW_EH_PE_signed (ent->fde_encoding));
1707                   if (!value)
1708                     continue;
1709
1710                   if ((ent->fde_encoding & 0x70) == DW_EH_PE_pcrel)
1711                     value += (bfd_vma) ent->offset + 8 - new_offset;
1712                   if (ent->make_relative)
1713                     value -= (sec->output_section->vma
1714                               + sec->output_offset
1715                               + new_offset + ent->set_loc[cnt]);
1716                   write_value (abfd, buf, value, width);
1717                 }
1718             }
1719         }
1720     }
1721
1722   /* We don't align the section to its section alignment since the
1723      runtime library only expects all CIE/FDE records aligned at
1724      the pointer size. _bfd_elf_discard_section_eh_frame should
1725      have padded CIE/FDE records to multiple of pointer size with
1726      size_of_output_cie_fde.  */
1727   sec_size = sec->size;
1728   if (sec_info->count != 0
1729       && sec_info->entry[sec_info->count - 1].size == 4)
1730     sec_size -= 4;
1731   if ((sec_size % ptr_size) != 0)
1732     abort ();
1733
1734   /* FIXME: octets_per_byte.  */
1735   return bfd_set_section_contents (abfd, sec->output_section,
1736                                    contents, (file_ptr) sec->output_offset,
1737                                    sec->size);
1738 }
1739
1740 /* Helper function used to sort .eh_frame_hdr search table by increasing
1741    VMA of FDE initial location.  */
1742
1743 static int
1744 vma_compare (const void *a, const void *b)
1745 {
1746   const struct eh_frame_array_ent *p = (const struct eh_frame_array_ent *) a;
1747   const struct eh_frame_array_ent *q = (const struct eh_frame_array_ent *) b;
1748   if (p->initial_loc > q->initial_loc)
1749     return 1;
1750   if (p->initial_loc < q->initial_loc)
1751     return -1;
1752   if (p->range > q->range)
1753     return 1;
1754   if (p->range < q->range)
1755     return -1;
1756   return 0;
1757 }
1758
1759 /* Write out .eh_frame_hdr section.  This must be called after
1760    _bfd_elf_write_section_eh_frame has been called on all input
1761    .eh_frame sections.
1762    .eh_frame_hdr format:
1763    ubyte version                (currently 1)
1764    ubyte eh_frame_ptr_enc       (DW_EH_PE_* encoding of pointer to start of
1765                                  .eh_frame section)
1766    ubyte fde_count_enc          (DW_EH_PE_* encoding of total FDE count
1767                                  number (or DW_EH_PE_omit if there is no
1768                                  binary search table computed))
1769    ubyte table_enc              (DW_EH_PE_* encoding of binary search table,
1770                                  or DW_EH_PE_omit if not present.
1771                                  DW_EH_PE_datarel is using address of
1772                                  .eh_frame_hdr section start as base)
1773    [encoded] eh_frame_ptr       (pointer to start of .eh_frame section)
1774    optionally followed by:
1775    [encoded] fde_count          (total number of FDEs in .eh_frame section)
1776    fde_count x [encoded] initial_loc, fde
1777                                 (array of encoded pairs containing
1778                                  FDE initial_location field and FDE address,
1779                                  sorted by increasing initial_loc).  */
1780
1781 bfd_boolean
1782 _bfd_elf_write_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
1783 {
1784   struct elf_link_hash_table *htab;
1785   struct eh_frame_hdr_info *hdr_info;
1786   asection *sec;
1787   bfd_boolean retval = TRUE;
1788
1789   htab = elf_hash_table (info);
1790   hdr_info = &htab->eh_info;
1791   sec = hdr_info->hdr_sec;
1792
1793   if (info->eh_frame_hdr && sec != NULL)
1794     {
1795       bfd_byte *contents;
1796       asection *eh_frame_sec;
1797       bfd_size_type size;
1798       bfd_vma encoded_eh_frame;
1799
1800       size = EH_FRAME_HDR_SIZE;
1801       if (hdr_info->array && hdr_info->array_count == hdr_info->fde_count)
1802         size += 4 + hdr_info->fde_count * 8;
1803       contents = (bfd_byte *) bfd_malloc (size);
1804       if (contents == NULL)
1805         return FALSE;
1806
1807       eh_frame_sec = bfd_get_section_by_name (abfd, ".eh_frame");
1808       if (eh_frame_sec == NULL)
1809         {
1810           free (contents);
1811           return FALSE;
1812         }
1813
1814       memset (contents, 0, EH_FRAME_HDR_SIZE);
1815       /* Version.  */
1816       contents[0] = 1;
1817       /* .eh_frame offset.  */
1818       contents[1] = get_elf_backend_data (abfd)->elf_backend_encode_eh_address
1819         (abfd, info, eh_frame_sec, 0, sec, 4, &encoded_eh_frame);
1820
1821       if (hdr_info->array && hdr_info->array_count == hdr_info->fde_count)
1822         {
1823           /* FDE count encoding.  */
1824           contents[2] = DW_EH_PE_udata4;
1825           /* Search table encoding.  */
1826           contents[3] = DW_EH_PE_datarel | DW_EH_PE_sdata4;
1827         }
1828       else
1829         {
1830           contents[2] = DW_EH_PE_omit;
1831           contents[3] = DW_EH_PE_omit;
1832         }
1833       bfd_put_32 (abfd, encoded_eh_frame, contents + 4);
1834
1835       if (contents[2] != DW_EH_PE_omit)
1836         {
1837           unsigned int i;
1838
1839           bfd_put_32 (abfd, hdr_info->fde_count, contents + EH_FRAME_HDR_SIZE);
1840           qsort (hdr_info->array, hdr_info->fde_count,
1841                  sizeof (*hdr_info->array), vma_compare);
1842           for (i = 0; i < hdr_info->fde_count; i++)
1843             {
1844               bfd_vma val;
1845
1846               val = hdr_info->array[i].initial_loc - sec->output_section->vma;
1847               val = ((val & 0xffffffff) ^ 0x80000000) - 0x80000000;
1848               if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64
1849                   && (hdr_info->array[i].initial_loc
1850                       != sec->output_section->vma + val))
1851                 (*info->callbacks->einfo)
1852                   (_("%X%P: .eh_frame_hdr table[%u] PC overflow.\n"), i);
1853               bfd_put_32 (abfd, val, contents + EH_FRAME_HDR_SIZE + i * 8 + 4);
1854
1855               val = hdr_info->array[i].fde - sec->output_section->vma;
1856               val = ((val & 0xffffffff) ^ 0x80000000) - 0x80000000;
1857               if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64
1858                   && (hdr_info->array[i].fde
1859                       != sec->output_section->vma + val))
1860                 (*info->callbacks->einfo)
1861                   (_("%X%P: .eh_frame_hdr table[%u] FDE overflow.\n"), i);
1862               bfd_put_32 (abfd, val, contents + EH_FRAME_HDR_SIZE + i * 8 + 8);
1863
1864               if (i != 0
1865                   && (hdr_info->array[i].initial_loc
1866                       < (hdr_info->array[i - 1].initial_loc
1867                          + hdr_info->array[i - 1].range)))
1868                 (*info->callbacks->einfo)
1869                   (_("%X%P: .eh_frame_hdr table[%u] FDE at %V overlaps "
1870                      "table[%u] FDE at %V.\n"),
1871                    i - 1, hdr_info->array[i - 1].fde,
1872                    i, hdr_info->array[i].fde);
1873             }
1874         }
1875
1876       /* FIXME: octets_per_byte.  */
1877       if (!bfd_set_section_contents (abfd, sec->output_section, contents,
1878                                      (file_ptr) sec->output_offset,
1879                                      sec->size))
1880         retval = FALSE;
1881       free (contents);
1882     }
1883   if (hdr_info->array != NULL)
1884     free (hdr_info->array);
1885   return retval;
1886 }
1887
1888 /* Return the width of FDE addresses.  This is the default implementation.  */
1889
1890 unsigned int
1891 _bfd_elf_eh_frame_address_size (bfd *abfd, asection *sec ATTRIBUTE_UNUSED)
1892 {
1893   return elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64 ? 8 : 4;
1894 }
1895
1896 /* Decide whether we can use a PC-relative encoding within the given
1897    EH frame section.  This is the default implementation.  */
1898
1899 bfd_boolean
1900 _bfd_elf_can_make_relative (bfd *input_bfd ATTRIBUTE_UNUSED,
1901                             struct bfd_link_info *info ATTRIBUTE_UNUSED,
1902                             asection *eh_frame_section ATTRIBUTE_UNUSED)
1903 {
1904   return TRUE;
1905 }
1906
1907 /* Select an encoding for the given address.  Preference is given to
1908    PC-relative addressing modes.  */
1909
1910 bfd_byte
1911 _bfd_elf_encode_eh_address (bfd *abfd ATTRIBUTE_UNUSED,
1912                             struct bfd_link_info *info ATTRIBUTE_UNUSED,
1913                             asection *osec, bfd_vma offset,
1914                             asection *loc_sec, bfd_vma loc_offset,
1915                             bfd_vma *encoded)
1916 {
1917   *encoded = osec->vma + offset -
1918     (loc_sec->output_section->vma + loc_sec->output_offset + loc_offset);
1919   return DW_EH_PE_pcrel | DW_EH_PE_sdata4;
1920 }