bfd/elf-eh-frame.c

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