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