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