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   bfd_vma 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                           asection *sym_sec = NULL;
 679
 680 #ifdef BFD64
 681                           if (ptr_size == 8)
 682                             r_symndx = ELF64_R_SYM (cookie->rel->r_info);
 683                           else
 684 #endif
 685                             r_symndx = ELF32_R_SYM (cookie->rel->r_info);
 686                           if (r_symndx >= cookie->locsymcount)
 687                             {
 688                               struct elf_link_hash_entry *h;
 689
 690                               r_symndx -= cookie->extsymoff;
 691                               h = cookie->sym_hashes[r_symndx];
 692
 693                               while (h->root.type == bfd_link_hash_indirect
 694                                      || h->root.type == bfd_link_hash_warning)
 695                                 h = (struct elf_link_hash_entry *)
 696                                     h->root.u.i.link;
 697
 698                               if (h->root.type == bfd_link_hash_defined
 699                                   || h->root.type == bfd_link_hash_defweak)
 700                                 {
 701                                   cie->personality = h->root.u.def.value;
 702                                   sym_sec = h->root.u.def.section;
 703                                 }
 704                             }
 705                           else
 706                             {
 707                               Elf_Internal_Shdr *symtab_hdr;
 708                               Elf_Internal_Sym *sym;
 709
 710                               symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 711                               sym = bfd_elf_get_elf_syms (abfd, symtab_hdr,
 712                                                           1, r_symndx,
 713                                                           NULL, NULL, NULL);
 714                               if (sym != NULL)
 715                                 {
 716                                   cie->personality = sym->st_value;
 717                                   sym_sec = (bfd_section_from_elf_index
 718                                              (abfd, sym->st_shndx));
 719                                   free (sym);
 720                                 }
 721                             }
 722                           if (sym_sec != NULL)
 723                             cie->personality += (sym_sec->output_section->vma
 724                                                  + sym_sec->output_offset);
 725
 726                           /* Cope with MIPS-style composite relocations.  */
 727                           do
 728                             cookie->rel++;
 729                           while (GET_RELOC (buf) != NULL);
 730                         }
 731                       REQUIRE (skip_bytes (&buf, end, per_width));
 732                       REQUIRE (cie->personality);
 733                     }
 734                     break;
 735                   default:
 736                     /* Unrecognized augmentation. Better bail out.  */
 737                     goto free_no_table;
 738                   }
 739             }
 740
 741           /* For shared libraries, try to get rid of as many RELATIVE relocs
 742              as possible.  */
 743           if (info->shared
 744               && (get_elf_backend_data (abfd)
 745                   ->elf_backend_can_make_relative_eh_frame
 746                   (abfd, info, sec)))
 747             {
 748               if ((cie->fde_encoding & 0xf0) == DW_EH_PE_absptr)
 749                 cie->make_relative = 1;
 750               /* If the CIE doesn't already have an 'R' entry, it's fairly
 751                  easy to add one, provided that there's no aligned data
 752                  after the augmentation string.  */
 753               else if (cie->fde_encoding == DW_EH_PE_omit
 754                        && (cie->per_encoding & 0xf0) != DW_EH_PE_aligned)
 755                 {
 756                   if (*cie->augmentation == 0)
 757                     this_inf->add_augmentation_size = 1;
 758                   this_inf->add_fde_encoding = 1;
 759                   cie->make_relative = 1;
 760                 }
 761             }
 762
 763           if (info->shared
 764               && (get_elf_backend_data (abfd)
 765                   ->elf_backend_can_make_lsda_relative_eh_frame
 766                   (abfd, info, sec))
 767               && (cie->lsda_encoding & 0xf0) == DW_EH_PE_absptr)
 768             cie->make_lsda_relative = 1;
 769
 770           /* If FDE encoding was not specified, it defaults to
 771              DW_EH_absptr.  */
 772           if (cie->fde_encoding == DW_EH_PE_omit)
 773             cie->fde_encoding = DW_EH_PE_absptr;
 774
 775           initial_insn_length = end - buf;
 776           if (initial_insn_length <= sizeof (cie->initial_instructions))
 777             {
 778               cie->initial_insn_length = initial_insn_length;
 779               memcpy (cie->initial_instructions, buf, initial_insn_length);
 780             }
 781           insns = buf;
 782           buf += initial_insn_length;
 783           ENSURE_NO_RELOCS (buf);
 784         }
 785       else
 786         {
 787           /* Find the corresponding CIE.  */
 788           unsigned int cie_offset = this_inf->offset + 4 - hdr_id;
 789           for (ecie = ecies; ecie < ecies + ecie_count; ++ecie)
 790             if (cie_offset == ecie->offset)
 791               break;
 792
 793           /* Ensure this FDE references one of the CIEs in this input
 794              section.  */
 795           REQUIRE (ecie != ecies + ecie_count);
 796           cie = &ecie->cie;
 797
 798           ENSURE_NO_RELOCS (buf);
 799           REQUIRE (GET_RELOC (buf));
 800
 801           if ((*reloc_symbol_deleted_p) (buf - ehbuf, cookie))
 802             /* This is a FDE against a discarded section.  It should
 803                be deleted.  */
 804             this_inf->removed = 1;
 805           else
 806             {
 807               if (info->shared
 808                   && (((cie->fde_encoding & 0xf0) == DW_EH_PE_absptr
 809                        && cie->make_relative == 0)
 810                       || (cie->fde_encoding & 0xf0) == DW_EH_PE_aligned))
 811                 {
 812                   /* If a shared library uses absolute pointers
 813                      which we cannot turn into PC relative,
 814                      don't create the binary search table,
 815                      since it is affected by runtime relocations.  */
 816                   hdr_info->table = FALSE;
 817                   (*info->callbacks->einfo)
 818                     (_("%P: fde encoding in %B(%A) prevents .eh_frame_hdr"
 819                        " table being created.\n"), abfd, sec);
 820                 }
 821               ecie->usage_count++;
 822               hdr_info->fde_count++;
 823               this_inf->cie_inf = (void *) (ecie - ecies);
 824             }
 825
 826           /* Skip the initial location and address range.  */
 827           start = buf;
 828           length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
 829           REQUIRE (skip_bytes (&buf, end, 2 * length));
 830
 831           /* Skip the augmentation size, if present.  */
 832           if (cie->augmentation[0] == 'z')
 833             REQUIRE (read_uleb128 (&buf, end, &length));
 834           else
 835             length = 0;
 836
 837           /* Of the supported augmentation characters above, only 'L'
 838              adds augmentation data to the FDE.  This code would need to
 839              be adjusted if any future augmentations do the same thing.  */
 840           if (cie->lsda_encoding != DW_EH_PE_omit)
 841             {
 842               this_inf->lsda_offset = buf - start;
 843               /* If there's no 'z' augmentation, we don't know where the
 844                  CFA insns begin.  Assume no padding.  */
 845               if (cie->augmentation[0] != 'z')
 846                 length = end - buf;
 847             }
 848
 849           /* Skip over the augmentation data.  */
 850           REQUIRE (skip_bytes (&buf, end, length));
 851           insns = buf;
 852
 853           buf = last_fde + 4 + hdr_length;
 854           SKIP_RELOCS (buf);
 855         }
 856
 857       /* Try to interpret the CFA instructions and find the first
 858          padding nop.  Shrink this_inf's size so that it doesn't
 859          include the padding.  */
 860       length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
 861       set_loc_count = 0;
 862       insns_end = skip_non_nops (insns, end, length, &set_loc_count);
 863       /* If we don't understand the CFA instructions, we can't know
 864          what needs to be adjusted there.  */
 865       if (insns_end == NULL
 866           /* For the time being we don't support DW_CFA_set_loc in
 867              CIE instructions.  */
 868           || (set_loc_count && this_inf->cie))
 869         goto free_no_table;
 870       this_inf->size -= end - insns_end;
 871       if (insns_end != end && this_inf->cie)
 872         {
 873           cie->initial_insn_length -= end - insns_end;
 874           cie->length -= end - insns_end;
 875         }
 876       if (set_loc_count
 877           && ((cie->fde_encoding & 0xf0) == DW_EH_PE_pcrel
 878               || cie->make_relative))
 879         {
 880           unsigned int cnt;
 881           bfd_byte *p;
 882
 883           this_inf->set_loc = bfd_malloc ((set_loc_count + 1)
 884                                           * sizeof (unsigned int));
 885           REQUIRE (this_inf->set_loc);
 886           this_inf->set_loc[0] = set_loc_count;
 887           p = insns;
 888           cnt = 0;
 889           while (p < end)
 890             {
 891               if (*p == DW_CFA_set_loc)
 892                 this_inf->set_loc[++cnt] = p + 1 - start;
 893               REQUIRE (skip_cfa_op (&p, end, length));
 894             }
 895         }
 896
 897       this_inf->fde_encoding = cie->fde_encoding;
 898       this_inf->lsda_encoding = cie->lsda_encoding;
 899       sec_info->count++;
 900     }
 901
 902   elf_section_data (sec)->sec_info = sec_info;
 903   sec->sec_info_type = ELF_INFO_TYPE_EH_FRAME;
 904
 905   /* Look at all CIEs in this section and determine which can be
 906      removed as unused, which can be merged with previous duplicate
 907      CIEs and which need to be kept.  */
 908   for (ecie = ecies; ecie < ecies + ecie_count; ++ecie)
 909     {
 910       if (ecie->usage_count == 0)
 911         {
 912           sec_info->entry[ecie->entry].removed = 1;
 913           continue;
 914         }
 915       ecie->cie.output_sec = sec->output_section;
 916       ecie->cie.cie_inf = sec_info->entry + ecie->entry;
 917       cie_compute_hash (&ecie->cie);
 918       if (hdr_info->cies != NULL)
 919         {
 920           void **loc = htab_find_slot_with_hash (hdr_info->cies, &ecie->cie,
 921                                                  ecie->cie.hash, INSERT);
 922           if (loc != NULL)
 923             {
 924               if (*loc != HTAB_EMPTY_ENTRY)
 925                 {
 926                   sec_info->entry[ecie->entry].removed = 1;
 927                   ecie->cie.cie_inf = ((struct cie *) *loc)->cie_inf;
 928                   continue;
 929                 }
 930
 931               *loc = malloc (sizeof (struct cie));
 932               if (*loc == NULL)
 933                 *loc = HTAB_DELETED_ENTRY;
 934               else
 935                 memcpy (*loc, &ecie->cie, sizeof (struct cie));
 936             }
 937         }
 938       ecie->cie.cie_inf->make_relative = ecie->cie.make_relative;
 939       ecie->cie.cie_inf->make_lsda_relative = ecie->cie.make_lsda_relative;
 940       ecie->cie.cie_inf->per_encoding_relative
 941         = (ecie->cie.per_encoding & 0x70) == DW_EH_PE_pcrel;
 942     }
 943
 944   /* Ok, now we can assign new offsets.  */
 945   offset = 0;
 946   for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
 947     if (!ent->removed)
 948       {
 949         if (!ent->cie)
 950           {
 951             ecie = ecies + (unsigned long) ent->cie_inf;
 952             ent->cie_inf = ecie->cie.cie_inf;
 953           }
 954         ent->new_offset = offset;
 955         offset += size_of_output_cie_fde (ent, ptr_size);
 956       }
 957
 958   /* Resize the sec as needed.  */
 959   sec->rawsize = sec->size;
 960   sec->size = offset;
 961
 962   free (ehbuf);
 963   if (ecies)
 964     free (ecies);
 965   return offset != sec->rawsize;
 966
 967 free_no_table:
 968   (*info->callbacks->einfo)
 969     (_("%P: error in %B(%A); no .eh_frame_hdr table will be created.\n"),
 970      abfd, sec);
 971   if (ehbuf)
 972     free (ehbuf);
 973   if (sec_info)
 974     free (sec_info);
 975   if (ecies)
 976     free (ecies);
 977   hdr_info->table = FALSE;
 978   return FALSE;
 979
 980 #undef REQUIRE
 981 }
 982
 983 /* This function is called for .eh_frame_hdr section after
 984    _bfd_elf_discard_section_eh_frame has been called on all .eh_frame
 985    input sections.  It finalizes the size of .eh_frame_hdr section.  */
 986
 987 bfd_boolean
 988 _bfd_elf_discard_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
 989 {
 990   struct elf_link_hash_table *htab;
 991   struct eh_frame_hdr_info *hdr_info;
 992   asection *sec;
 993
 994   htab = elf_hash_table (info);
 995   hdr_info = &htab->eh_info;
 996
 997   if (hdr_info->cies != NULL)
 998     {
 999       htab_delete (hdr_info->cies);
1000       hdr_info->cies = NULL;
1001     }
1002
1003   sec = hdr_info->hdr_sec;
1004   if (sec == NULL)
1005     return FALSE;
1006
1007   sec->size = EH_FRAME_HDR_SIZE;
1008   if (hdr_info->table)
1009     sec->size += 4 + hdr_info->fde_count * 8;
1010
1011   elf_tdata (abfd)->eh_frame_hdr = sec;
1012   return TRUE;
1013 }
1014
1015 /* This function is called from size_dynamic_sections.
1016    It needs to decide whether .eh_frame_hdr should be output or not,
1017    because when the dynamic symbol table has been sized it is too late
1018    to strip sections.  */
1019
1020 bfd_boolean
1021 _bfd_elf_maybe_strip_eh_frame_hdr (struct bfd_link_info *info)
1022 {
1023   asection *o;
1024   bfd *abfd;
1025   struct elf_link_hash_table *htab;
1026   struct eh_frame_hdr_info *hdr_info;
1027
1028   htab = elf_hash_table (info);
1029   hdr_info = &htab->eh_info;
1030   if (hdr_info->hdr_sec == NULL)
1031     return TRUE;
1032
1033   if (bfd_is_abs_section (hdr_info->hdr_sec->output_section))
1034     {
1035       hdr_info->hdr_sec = NULL;
1036       return TRUE;
1037     }
1038
1039   abfd = NULL;
1040   if (info->eh_frame_hdr)
1041     for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link_next)
1042       {
1043         /* Count only sections which have at least a single CIE or FDE.
1044            There cannot be any CIE or FDE <= 8 bytes.  */
1045         o = bfd_get_section_by_name (abfd, ".eh_frame");
1046         if (o && o->size > 8 && !bfd_is_abs_section (o->output_section))
1047           break;
1048       }
1049
1050   if (abfd == NULL)
1051     {
1052       hdr_info->hdr_sec->flags |= SEC_EXCLUDE;
1053       hdr_info->hdr_sec = NULL;
1054       return TRUE;
1055     }
1056
1057   hdr_info->table = TRUE;
1058   return TRUE;
1059 }
1060
1061 /* Adjust an address in the .eh_frame section.  Given OFFSET within
1062    SEC, this returns the new offset in the adjusted .eh_frame section,
1063    or -1 if the address refers to a CIE/FDE which has been removed
1064    or to offset with dynamic relocation which is no longer needed.  */
1065
1066 bfd_vma
1067 _bfd_elf_eh_frame_section_offset (bfd *output_bfd ATTRIBUTE_UNUSED,
1068                                   struct bfd_link_info *info,
1069                                   asection *sec,
1070                                   bfd_vma offset)
1071 {
1072   struct eh_frame_sec_info *sec_info;
1073   struct elf_link_hash_table *htab;
1074   struct eh_frame_hdr_info *hdr_info;
1075   unsigned int lo, hi, mid;
1076
1077   if (sec->sec_info_type != ELF_INFO_TYPE_EH_FRAME)
1078     return offset;
1079   sec_info = elf_section_data (sec)->sec_info;
1080
1081   if (offset >= sec->rawsize)
1082     return offset - sec->rawsize + sec->size;
1083
1084   htab = elf_hash_table (info);
1085   hdr_info = &htab->eh_info;
1086   if (hdr_info->offsets_adjusted)
1087     offset += sec->output_offset;
1088
1089   lo = 0;
1090   hi = sec_info->count;
1091   mid = 0;
1092   while (lo < hi)
1093     {
1094       mid = (lo + hi) / 2;
1095       if (offset < sec_info->entry[mid].offset)
1096         hi = mid;
1097       else if (offset
1098                >= sec_info->entry[mid].offset + sec_info->entry[mid].size)
1099         lo = mid + 1;
1100       else
1101         break;
1102     }
1103
1104   BFD_ASSERT (lo < hi);
1105
1106   /* FDE or CIE was removed.  */
1107   if (sec_info->entry[mid].removed)
1108     return (bfd_vma) -1;
1109
1110   /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1111      relocation against FDE's initial_location field.  */
1112   if (!sec_info->entry[mid].cie
1113       && sec_info->entry[mid].cie_inf->make_relative
1114       && offset == sec_info->entry[mid].offset + 8)
1115     return (bfd_vma) -2;
1116
1117   /* If converting LSDA pointers to DW_EH_PE_pcrel, there will be no need
1118      for run-time relocation against LSDA field.  */
1119   if (!sec_info->entry[mid].cie
1120       && sec_info->entry[mid].cie_inf->make_lsda_relative
1121       && (offset == (sec_info->entry[mid].offset + 8
1122                      + sec_info->entry[mid].lsda_offset))
1123       && (sec_info->entry[mid].cie_inf->need_lsda_relative
1124           || !hdr_info->offsets_adjusted))
1125     {
1126       sec_info->entry[mid].cie_inf->need_lsda_relative = 1;
1127       return (bfd_vma) -2;
1128     }
1129
1130   /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1131      relocation against DW_CFA_set_loc's arguments.  */
1132   if (sec_info->entry[mid].set_loc
1133       && (sec_info->entry[mid].cie
1134           ? sec_info->entry[mid].make_relative
1135           : sec_info->entry[mid].cie_inf->make_relative)
1136       && (offset >= sec_info->entry[mid].offset + 8
1137                     + sec_info->entry[mid].set_loc[1]))
1138     {
1139       unsigned int cnt;
1140
1141       for (cnt = 1; cnt <= sec_info->entry[mid].set_loc[0]; cnt++)
1142         if (offset == sec_info->entry[mid].offset + 8
1143                       + sec_info->entry[mid].set_loc[cnt])
1144           return (bfd_vma) -2;
1145     }
1146
1147   if (hdr_info->offsets_adjusted)
1148     offset -= sec->output_offset;
1149   /* Any new augmentation bytes go before the first relocation.  */
1150   return (offset + sec_info->entry[mid].new_offset
1151           - sec_info->entry[mid].offset
1152           + extra_augmentation_string_bytes (sec_info->entry + mid)
1153           + extra_augmentation_data_bytes (sec_info->entry + mid));
1154 }
1155
1156 /* Write out .eh_frame section.  This is called with the relocated
1157    contents.  */
1158
1159 bfd_boolean
1160 _bfd_elf_write_section_eh_frame (bfd *abfd,
1161                                  struct bfd_link_info *info,
1162                                  asection *sec,
1163                                  bfd_byte *contents)
1164 {
1165   struct eh_frame_sec_info *sec_info;
1166   struct elf_link_hash_table *htab;
1167   struct eh_frame_hdr_info *hdr_info;
1168   unsigned int ptr_size;
1169   struct eh_cie_fde *ent;
1170
1171   if (sec->sec_info_type != ELF_INFO_TYPE_EH_FRAME)
1172     return bfd_set_section_contents (abfd, sec->output_section, contents,
1173                                      sec->output_offset, sec->size);
1174
1175   ptr_size = (get_elf_backend_data (abfd)
1176               ->elf_backend_eh_frame_address_size (abfd, sec));
1177   BFD_ASSERT (ptr_size != 0);
1178
1179   sec_info = elf_section_data (sec)->sec_info;
1180   htab = elf_hash_table (info);
1181   hdr_info = &htab->eh_info;
1182
1183   /* First convert all offsets to output section offsets, so that a
1184      CIE offset is valid if the CIE is used by a FDE from some other
1185      section.  This can happen when duplicate CIEs are deleted in
1186      _bfd_elf_discard_section_eh_frame.  We do all sections here because
1187      this function might not be called on sections in the same order as
1188      _bfd_elf_discard_section_eh_frame.  */
1189   if (!hdr_info->offsets_adjusted)
1190     {
1191       bfd *ibfd;
1192       asection *eh;
1193       struct eh_frame_sec_info *eh_inf;
1194
1195       for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
1196         {
1197           if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1198               || (ibfd->flags & DYNAMIC) != 0)
1199             continue;
1200
1201           eh = bfd_get_section_by_name (ibfd, ".eh_frame");
1202           if (eh == NULL || eh->sec_info_type != ELF_INFO_TYPE_EH_FRAME)
1203             continue;
1204
1205           eh_inf = elf_section_data (eh)->sec_info;
1206           for (ent = eh_inf->entry; ent < eh_inf->entry + eh_inf->count; ++ent)
1207             {
1208               ent->offset += eh->output_offset;
1209               ent->new_offset += eh->output_offset;
1210             }
1211         }
1212       hdr_info->offsets_adjusted = TRUE;
1213     }
1214
1215   if (hdr_info->table && hdr_info->array == NULL)
1216     hdr_info->array
1217       = bfd_malloc (hdr_info->fde_count * sizeof(*hdr_info->array));
1218   if (hdr_info->array == NULL)
1219     hdr_info = NULL;
1220
1221   /* The new offsets can be bigger or smaller than the original offsets.
1222      We therefore need to make two passes over the section: one backward
1223      pass to move entries up and one forward pass to move entries down.
1224      The two passes won't interfere with each other because entries are
1225      not reordered  */
1226   for (ent = sec_info->entry + sec_info->count; ent-- != sec_info->entry;)
1227     if (!ent->removed && ent->new_offset > ent->offset)
1228       memmove (contents + ent->new_offset - sec->output_offset,
1229                contents + ent->offset - sec->output_offset, ent->size);
1230
1231   for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1232     if (!ent->removed && ent->new_offset < ent->offset)
1233       memmove (contents + ent->new_offset - sec->output_offset,
1234                contents + ent->offset - sec->output_offset, ent->size);
1235
1236   for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1237     {
1238       unsigned char *buf, *end;
1239       unsigned int new_size;
1240
1241       if (ent->removed)
1242         continue;
1243
1244       if (ent->size == 4)
1245         {
1246           /* Any terminating FDE must be at the end of the section.  */
1247           BFD_ASSERT (ent == sec_info->entry + sec_info->count - 1);
1248           continue;
1249         }
1250
1251       buf = contents + ent->new_offset - sec->output_offset;
1252       end = buf + ent->size;
1253       new_size = size_of_output_cie_fde (ent, ptr_size);
1254
1255       /* Update the size.  It may be shrinked.  */
1256       bfd_put_32 (abfd, new_size - 4, buf);
1257
1258       /* Filling the extra bytes with DW_CFA_nops.  */
1259       if (new_size != ent->size)
1260         memset (end, 0, new_size - ent->size);
1261
1262       if (ent->cie)
1263         {
1264           /* CIE */
1265           if (ent->make_relative
1266               || ent->need_lsda_relative
1267               || ent->per_encoding_relative)
1268             {
1269               char *aug;
1270               unsigned int action, extra_string, extra_data;
1271               unsigned int per_width, per_encoding;
1272
1273               /* Need to find 'R' or 'L' augmentation's argument and modify
1274                  DW_EH_PE_* value.  */
1275               action = ((ent->make_relative ? 1 : 0)
1276                         | (ent->need_lsda_relative ? 2 : 0)
1277                         | (ent->per_encoding_relative ? 4 : 0));
1278               extra_string = extra_augmentation_string_bytes (ent);
1279               extra_data = extra_augmentation_data_bytes (ent);
1280
1281               /* Skip length, id and version.  */
1282               buf += 9;
1283               aug = (char *) buf;
1284               buf += strlen (aug) + 1;
1285               skip_leb128 (&buf, end);
1286               skip_leb128 (&buf, end);
1287               skip_leb128 (&buf, end);
1288               if (*aug == 'z')
1289                 {
1290                   /* The uleb128 will always be a single byte for the kind
1291                      of augmentation strings that we're prepared to handle.  */
1292                   *buf++ += extra_data;
1293                   aug++;
1294                 }
1295
1296               /* Make room for the new augmentation string and data bytes.  */
1297               memmove (buf + extra_string + extra_data, buf, end - buf);
1298               memmove (aug + extra_string, aug, buf - (bfd_byte *) aug);
1299               buf += extra_string;
1300               end += extra_string + extra_data;
1301
1302               if (ent->add_augmentation_size)
1303                 {
1304                   *aug++ = 'z';
1305                   *buf++ = extra_data - 1;
1306                 }
1307               if (ent->add_fde_encoding)
1308                 {
1309                   BFD_ASSERT (action & 1);
1310                   *aug++ = 'R';
1311                   *buf++ = DW_EH_PE_pcrel;
1312                   action &= ~1;
1313                 }
1314
1315               while (action)
1316                 switch (*aug++)
1317                   {
1318                   case 'L':
1319                     if (action & 2)
1320                       {
1321                         BFD_ASSERT (*buf == ent->lsda_encoding);
1322                         *buf |= DW_EH_PE_pcrel;
1323                         action &= ~2;
1324                       }
1325                     buf++;
1326                     break;
1327                   case 'P':
1328                     per_encoding = *buf++;
1329                     per_width = get_DW_EH_PE_width (per_encoding, ptr_size);
1330                     BFD_ASSERT (per_width != 0);
1331                     BFD_ASSERT (((per_encoding & 0x70) == DW_EH_PE_pcrel)
1332                                 == ent->per_encoding_relative);
1333                     if ((per_encoding & 0xf0) == DW_EH_PE_aligned)
1334                       buf = (contents
1335                              + ((buf - contents + per_width - 1)
1336                                 & ~((bfd_size_type) per_width - 1)));
1337                     if (action & 4)
1338                       {
1339                         bfd_vma val;
1340
1341                         val = read_value (abfd, buf, per_width,
1342                                           get_DW_EH_PE_signed (per_encoding));
1343                         val += ent->offset - ent->new_offset;
1344                         val -= extra_string + extra_data;
1345                         write_value (abfd, buf, val, per_width);
1346                         action &= ~4;
1347                       }
1348                     buf += per_width;
1349                     break;
1350                   case 'R':
1351                     if (action & 1)
1352                       {
1353                         BFD_ASSERT (*buf == ent->fde_encoding);
1354                         *buf |= DW_EH_PE_pcrel;
1355                         action &= ~1;
1356                       }
1357                     buf++;
1358                     break;
1359                   case 'S':
1360                     break;
1361                   default:
1362                     BFD_FAIL ();
1363                   }
1364             }
1365         }
1366       else
1367         {
1368           /* FDE */
1369           bfd_vma value, address;
1370           unsigned int width;
1371           bfd_byte *start;
1372
1373           /* Skip length.  */
1374           buf += 4;
1375           value = ent->new_offset + 4 - ent->cie_inf->new_offset;
1376           bfd_put_32 (abfd, value, buf);
1377           buf += 4;
1378           width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1379           value = read_value (abfd, buf, width,
1380                               get_DW_EH_PE_signed (ent->fde_encoding));
1381           address = value;
1382           if (value)
1383             {
1384               switch (ent->fde_encoding & 0xf0)
1385                 {
1386                 case DW_EH_PE_indirect:
1387                 case DW_EH_PE_textrel:
1388                   BFD_ASSERT (hdr_info == NULL);
1389                   break;
1390                 case DW_EH_PE_datarel:
1391                   {
1392                     asection *got = bfd_get_section_by_name (abfd, ".got");
1393
1394                     BFD_ASSERT (got != NULL);
1395                     address += got->vma;
1396                   }
1397                   break;
1398                 case DW_EH_PE_pcrel:
1399                   value += ent->offset - ent->new_offset;
1400                   address += sec->output_section->vma + ent->offset + 8;
1401                   break;
1402                 }
1403               if (ent->cie_inf->make_relative)
1404                 value -= sec->output_section->vma + ent->new_offset + 8;
1405               write_value (abfd, buf, value, width);
1406             }
1407
1408           start = buf;
1409
1410           if (hdr_info)
1411             {
1412               hdr_info->array[hdr_info->array_count].initial_loc = address;
1413               hdr_info->array[hdr_info->array_count++].fde
1414                 = sec->output_section->vma + ent->new_offset;
1415             }
1416
1417           if ((ent->lsda_encoding & 0xf0) == DW_EH_PE_pcrel
1418               || ent->cie_inf->need_lsda_relative)
1419             {
1420               buf += ent->lsda_offset;
1421               width = get_DW_EH_PE_width (ent->lsda_encoding, ptr_size);
1422               value = read_value (abfd, buf, width,
1423                                   get_DW_EH_PE_signed (ent->lsda_encoding));
1424               if (value)
1425                 {
1426                   if ((ent->lsda_encoding & 0xf0) == DW_EH_PE_pcrel)
1427                     value += ent->offset - ent->new_offset;
1428                   else if (ent->cie_inf->need_lsda_relative)
1429                     value -= (sec->output_section->vma + ent->new_offset + 8
1430                               + ent->lsda_offset);
1431                   write_value (abfd, buf, value, width);
1432                 }
1433             }
1434           else if (ent->cie_inf->add_augmentation_size)
1435             {
1436               /* Skip the PC and length and insert a zero byte for the
1437                  augmentation size.  */
1438               buf += width * 2;
1439               memmove (buf + 1, buf, end - buf);
1440               *buf = 0;
1441             }
1442
1443           if (ent->set_loc)
1444             {
1445               /* Adjust DW_CFA_set_loc.  */
1446               unsigned int cnt, width;
1447               bfd_vma new_offset;
1448
1449               width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1450               new_offset = ent->new_offset + 8
1451                            + extra_augmentation_string_bytes (ent)
1452                            + extra_augmentation_data_bytes (ent);
1453
1454               for (cnt = 1; cnt <= ent->set_loc[0]; cnt++)
1455                 {
1456                   bfd_vma value;
1457                   buf = start + ent->set_loc[cnt];
1458
1459                   value = read_value (abfd, buf, width,
1460                                       get_DW_EH_PE_signed (ent->fde_encoding));
1461                   if (!value)
1462                     continue;
1463
1464                   if ((ent->fde_encoding & 0xf0) == DW_EH_PE_pcrel)
1465                     value += ent->offset + 8 - new_offset;
1466                   if (ent->cie_inf->make_relative)
1467                     value -= sec->output_section->vma + new_offset
1468                              + ent->set_loc[cnt];
1469                   write_value (abfd, buf, value, width);
1470                 }
1471             }
1472         }
1473     }
1474
1475   /* We don't align the section to its section alignment since the
1476      runtime library only expects all CIE/FDE records aligned at
1477      the pointer size. _bfd_elf_discard_section_eh_frame should
1478      have padded CIE/FDE records to multiple of pointer size with
1479      size_of_output_cie_fde.  */
1480   if ((sec->size % ptr_size) != 0)
1481     abort ();
1482
1483   return bfd_set_section_contents (abfd, sec->output_section,
1484                                    contents, (file_ptr) sec->output_offset,
1485                                    sec->size);
1486 }
1487
1488 /* Helper function used to sort .eh_frame_hdr search table by increasing
1489    VMA of FDE initial location.  */
1490
1491 static int
1492 vma_compare (const void *a, const void *b)
1493 {
1494   const struct eh_frame_array_ent *p = a;
1495   const struct eh_frame_array_ent *q = b;
1496   if (p->initial_loc > q->initial_loc)
1497     return 1;
1498   if (p->initial_loc < q->initial_loc)
1499     return -1;
1500   return 0;
1501 }
1502
1503 /* Write out .eh_frame_hdr section.  This must be called after
1504    _bfd_elf_write_section_eh_frame has been called on all input
1505    .eh_frame sections.
1506    .eh_frame_hdr format:
1507    ubyte version                (currently 1)
1508    ubyte eh_frame_ptr_enc       (DW_EH_PE_* encoding of pointer to start of
1509                                  .eh_frame section)
1510    ubyte fde_count_enc          (DW_EH_PE_* encoding of total FDE count
1511                                  number (or DW_EH_PE_omit if there is no
1512                                  binary search table computed))
1513    ubyte table_enc              (DW_EH_PE_* encoding of binary search table,
1514                                  or DW_EH_PE_omit if not present.
1515                                  DW_EH_PE_datarel is using address of
1516                                  .eh_frame_hdr section start as base)
1517    [encoded] eh_frame_ptr       (pointer to start of .eh_frame section)
1518    optionally followed by:
1519    [encoded] fde_count          (total number of FDEs in .eh_frame section)
1520    fde_count x [encoded] initial_loc, fde
1521                                 (array of encoded pairs containing
1522                                  FDE initial_location field and FDE address,
1523                                  sorted by increasing initial_loc).  */
1524
1525 bfd_boolean
1526 _bfd_elf_write_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
1527 {
1528   struct elf_link_hash_table *htab;
1529   struct eh_frame_hdr_info *hdr_info;
1530   asection *sec;
1531   bfd_byte *contents;
1532   asection *eh_frame_sec;
1533   bfd_size_type size;
1534   bfd_boolean retval;
1535   bfd_vma encoded_eh_frame;
1536
1537   htab = elf_hash_table (info);
1538   hdr_info = &htab->eh_info;
1539   sec = hdr_info->hdr_sec;
1540   if (sec == NULL)
1541     return TRUE;
1542
1543   size = EH_FRAME_HDR_SIZE;
1544   if (hdr_info->array && hdr_info->array_count == hdr_info->fde_count)
1545     size += 4 + hdr_info->fde_count * 8;
1546   contents = bfd_malloc (size);
1547   if (contents == NULL)
1548     return FALSE;
1549
1550   eh_frame_sec = bfd_get_section_by_name (abfd, ".eh_frame");
1551   if (eh_frame_sec == NULL)
1552     {
1553       free (contents);
1554       return FALSE;
1555     }
1556
1557   memset (contents, 0, EH_FRAME_HDR_SIZE);
1558   contents[0] = 1;                              /* Version.  */
1559   contents[1] = get_elf_backend_data (abfd)->elf_backend_encode_eh_address
1560     (abfd, info, eh_frame_sec, 0, sec, 4,
1561      &encoded_eh_frame);                        /* .eh_frame offset.  */
1562
1563   if (hdr_info->array && hdr_info->array_count == hdr_info->fde_count)
1564     {
1565       contents[2] = DW_EH_PE_udata4;            /* FDE count encoding.  */
1566       contents[3] = DW_EH_PE_datarel | DW_EH_PE_sdata4; /* Search table enc.  */
1567     }
1568   else
1569     {
1570       contents[2] = DW_EH_PE_omit;
1571       contents[3] = DW_EH_PE_omit;
1572     }
1573   bfd_put_32 (abfd, encoded_eh_frame, contents + 4);
1574
1575   if (contents[2] != DW_EH_PE_omit)
1576     {
1577       unsigned int i;
1578
1579       bfd_put_32 (abfd, hdr_info->fde_count, contents + EH_FRAME_HDR_SIZE);
1580       qsort (hdr_info->array, hdr_info->fde_count, sizeof (*hdr_info->array),
1581              vma_compare);
1582       for (i = 0; i < hdr_info->fde_count; i++)
1583         {
1584           bfd_put_32 (abfd,
1585                       hdr_info->array[i].initial_loc
1586                       - sec->output_section->vma,
1587                       contents + EH_FRAME_HDR_SIZE + i * 8 + 4);
1588           bfd_put_32 (abfd,
1589                       hdr_info->array[i].fde - sec->output_section->vma,
1590                       contents + EH_FRAME_HDR_SIZE + i * 8 + 8);
1591         }
1592     }
1593
1594   retval = bfd_set_section_contents (abfd, sec->output_section,
1595                                      contents, (file_ptr) sec->output_offset,
1596                                      sec->size);
1597   free (contents);
1598   return retval;
1599 }
1600
1601 /* Return the width of FDE addresses.  This is the default implementation.  */
1602
1603 unsigned int
1604 _bfd_elf_eh_frame_address_size (bfd *abfd, asection *sec ATTRIBUTE_UNUSED)
1605 {
1606   return elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64 ? 8 : 4;
1607 }
1608
1609 /* Decide whether we can use a PC-relative encoding within the given
1610    EH frame section.  This is the default implementation.  */
1611
1612 bfd_boolean
1613 _bfd_elf_can_make_relative (bfd *input_bfd ATTRIBUTE_UNUSED,
1614                             struct bfd_link_info *info ATTRIBUTE_UNUSED,
1615                             asection *eh_frame_section ATTRIBUTE_UNUSED)
1616 {
1617   return TRUE;
1618 }
1619
1620 /* Select an encoding for the given address.  Preference is given to
1621    PC-relative addressing modes.  */
1622
1623 bfd_byte
1624 _bfd_elf_encode_eh_address (bfd *abfd ATTRIBUTE_UNUSED,
1625                             struct bfd_link_info *info ATTRIBUTE_UNUSED,
1626                             asection *osec, bfd_vma offset,
1627                             asection *loc_sec, bfd_vma loc_offset,
1628                             bfd_vma *encoded)
1629 {
1630   *encoded = osec->vma + offset -
1631     (loc_sec->output_section->vma + loc_sec->output_offset + loc_offset);
1632   return DW_EH_PE_pcrel | DW_EH_PE_sdata4;
1633 }