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 "elf/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           REQUIRE (rsec && rsec->owner == abfd);
 770           this_inf->u.fde.next_for_section = elf_fde_list (rsec);
 771           elf_fde_list (rsec) = this_inf;
 772
 773           /* Skip the initial location and address range.  */
 774           start = buf;
 775           length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
 776           REQUIRE (skip_bytes (&buf, end, 2 * length));
 777
 778           /* Skip the augmentation size, if present.  */
 779           if (cie->augmentation[0] == 'z')
 780             REQUIRE (read_uleb128 (&buf, end, &length));
 781           else
 782             length = 0;
 783
 784           /* Of the supported augmentation characters above, only 'L'
 785              adds augmentation data to the FDE.  This code would need to
 786              be adjusted if any future augmentations do the same thing.  */
 787           if (cie->lsda_encoding != DW_EH_PE_omit)
 788             {
 789               SKIP_RELOCS (buf);
 790               if (cie->can_make_lsda_relative && GET_RELOC (buf))
 791                 cie->cie_inf->u.cie.make_lsda_relative = 1;
 792               this_inf->lsda_offset = buf - start;
 793               /* If there's no 'z' augmentation, we don't know where the
 794                  CFA insns begin.  Assume no padding.  */
 795               if (cie->augmentation[0] != 'z')
 796                 length = end - buf;
 797             }
 798
 799           /* Skip over the augmentation data.  */
 800           REQUIRE (skip_bytes (&buf, end, length));
 801           insns = buf;
 802
 803           buf = last_fde + 4 + hdr_length;
 804           SKIP_RELOCS (buf);
 805         }
 806
 807       /* Try to interpret the CFA instructions and find the first
 808          padding nop.  Shrink this_inf's size so that it doesn't
 809          include the padding.  */
 810       length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
 811       set_loc_count = 0;
 812       insns_end = skip_non_nops (insns, end, length, &set_loc_count);
 813       /* If we don't understand the CFA instructions, we can't know
 814          what needs to be adjusted there.  */
 815       if (insns_end == NULL
 816           /* For the time being we don't support DW_CFA_set_loc in
 817              CIE instructions.  */
 818           || (set_loc_count && this_inf->cie))
 819         goto free_no_table;
 820       this_inf->size -= end - insns_end;
 821       if (insns_end != end && this_inf->cie)
 822         {
 823           cie->initial_insn_length -= end - insns_end;
 824           cie->length -= end - insns_end;
 825         }
 826       if (set_loc_count
 827           && ((cie->fde_encoding & 0xf0) == DW_EH_PE_pcrel
 828               || this_inf->make_relative))
 829         {
 830           unsigned int cnt;
 831           bfd_byte *p;
 832
 833           this_inf->set_loc = bfd_malloc ((set_loc_count + 1)
 834                                           * sizeof (unsigned int));
 835           REQUIRE (this_inf->set_loc);
 836           this_inf->set_loc[0] = set_loc_count;
 837           p = insns;
 838           cnt = 0;
 839           while (p < end)
 840             {
 841               if (*p == DW_CFA_set_loc)
 842                 this_inf->set_loc[++cnt] = p + 1 - start;
 843               REQUIRE (skip_cfa_op (&p, end, length));
 844             }
 845         }
 846
 847       this_inf->removed = 1;
 848       this_inf->fde_encoding = cie->fde_encoding;
 849       this_inf->lsda_encoding = cie->lsda_encoding;
 850       sec_info->count++;
 851     }
 852   BFD_ASSERT (sec_info->count == num_entries);
 853   BFD_ASSERT (cie_count == num_cies);
 854
 855   elf_section_data (sec)->sec_info = sec_info;
 856   sec->sec_info_type = ELF_INFO_TYPE_EH_FRAME;
 857   if (hdr_info->merge_cies)
 858     {
 859       sec_info->cies = local_cies;
 860       local_cies = NULL;
 861     }
 862   goto success;
 863
 864  free_no_table:
 865   (*info->callbacks->einfo)
 866     (_("%P: error in %B(%A); no .eh_frame_hdr table will be created.\n"),
 867      abfd, sec);
 868   hdr_info->table = FALSE;
 869   if (sec_info)
 870     free (sec_info);
 871  success:
 872   if (ehbuf)
 873     free (ehbuf);
 874   if (local_cies)
 875     free (local_cies);
 876 #undef REQUIRE
 877 }
 878
 879 /* Finish a pass over all .eh_frame sections.  */
 880
 881 void
 882 _bfd_elf_end_eh_frame_parsing (struct bfd_link_info *info)
 883 {
 884   struct eh_frame_hdr_info *hdr_info;
 885
 886   hdr_info = &elf_hash_table (info)->eh_info;
 887   hdr_info->parsed_eh_frames = TRUE;
 888 }
 889
 890 /* Mark all relocations against CIE or FDE ENT, which occurs in
 891    .eh_frame section SEC.  COOKIE describes the relocations in SEC;
 892    its "rel" field can be changed freely.  */
 893
 894 static bfd_boolean
 895 mark_entry (struct bfd_link_info *info, asection *sec,
 896             struct eh_cie_fde *ent, elf_gc_mark_hook_fn gc_mark_hook,
 897             struct elf_reloc_cookie *cookie)
 898 {
 899   for (cookie->rel = cookie->rels + ent->reloc_index;
 900        cookie->rel < cookie->relend
 901          && cookie->rel->r_offset < ent->offset + ent->size;
 902        cookie->rel++)
 903     if (!_bfd_elf_gc_mark_reloc (info, sec, gc_mark_hook, cookie))
 904       return FALSE;
 905
 906   return TRUE;
 907 }
 908
 909 /* Mark all the relocations against FDEs that relate to code in input
 910    section SEC.  The FDEs belong to .eh_frame section EH_FRAME, whose
 911    relocations are described by COOKIE.  */
 912
 913 bfd_boolean
 914 _bfd_elf_gc_mark_fdes (struct bfd_link_info *info, asection *sec,
 915                        asection *eh_frame, elf_gc_mark_hook_fn gc_mark_hook,
 916                        struct elf_reloc_cookie *cookie)
 917 {
 918   struct eh_cie_fde *fde, *cie;
 919
 920   for (fde = elf_fde_list (sec); fde; fde = fde->u.fde.next_for_section)
 921     {
 922       if (!mark_entry (info, eh_frame, fde, gc_mark_hook, cookie))
 923         return FALSE;
 924
 925       /* At this stage, all cie_inf fields point to local CIEs, so we
 926          can use the same cookie to refer to them.  */
 927       cie = fde->u.fde.cie_inf;
 928       if (!cie->u.cie.gc_mark)
 929         {
 930           cie->u.cie.gc_mark = 1;
 931           if (!mark_entry (info, eh_frame, cie, gc_mark_hook, cookie))
 932             return FALSE;
 933         }
 934     }
 935   return TRUE;
 936 }
 937
 938 /* Input section SEC of ABFD is an .eh_frame section that contains the
 939    CIE described by CIE_INF.  Return a version of CIE_INF that is going
 940    to be kept in the output, adding CIE_INF to the output if necessary.
 941
 942    HDR_INFO is the .eh_frame_hdr information and COOKIE describes the
 943    relocations in REL.  */
 944
 945 static struct eh_cie_fde *
 946 find_merged_cie (bfd *abfd, asection *sec,
 947                  struct eh_frame_hdr_info *hdr_info,
 948                  struct elf_reloc_cookie *cookie,
 949                  struct eh_cie_fde *cie_inf)
 950 {
 951   unsigned long r_symndx;
 952   struct cie *cie, *new_cie;
 953   Elf_Internal_Rela *rel;
 954   void **loc;
 955
 956   /* Use CIE_INF if we have already decided to keep it.  */
 957   if (!cie_inf->removed)
 958     return cie_inf;
 959
 960   /* If we have merged CIE_INF with another CIE, use that CIE instead.  */
 961   if (cie_inf->u.cie.merged)
 962     return cie_inf->u.cie.u.merged_with;
 963
 964   cie = cie_inf->u.cie.u.full_cie;
 965
 966   /* Assume we will need to keep CIE_INF.  */
 967   cie_inf->removed = 0;
 968   cie_inf->u.cie.u.sec = sec;
 969
 970   /* If we are not merging CIEs, use CIE_INF.  */
 971   if (cie == NULL)
 972     return cie_inf;
 973
 974   if (cie->per_encoding != DW_EH_PE_omit)
 975     {
 976       /* Work out the address of personality routine, either as an absolute
 977          value or as a symbol.  */
 978       rel = cookie->rels + cie->personality.reloc_index;
 979       memset (&cie->personality, 0, sizeof (cie->personality));
 980 #ifdef BFD64
 981       if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64)
 982         r_symndx = ELF64_R_SYM (rel->r_info);
 983       else
 984 #endif
 985         r_symndx = ELF32_R_SYM (rel->r_info);
 986       if (r_symndx >= cookie->locsymcount
 987           || ELF_ST_BIND (cookie->locsyms[r_symndx].st_info) != STB_LOCAL)
 988         {
 989           struct elf_link_hash_entry *h;
 990
 991           r_symndx -= cookie->extsymoff;
 992           h = cookie->sym_hashes[r_symndx];
 993
 994           while (h->root.type == bfd_link_hash_indirect
 995                  || h->root.type == bfd_link_hash_warning)
 996             h = (struct elf_link_hash_entry *) h->root.u.i.link;
 997
 998           cie->personality.h = h;
 999         }
1000       else
1001         {
1002           Elf_Internal_Sym *sym;
1003           asection *sym_sec;
1004
1005           sym = &cookie->locsyms[r_symndx];
1006           sym_sec = bfd_section_from_elf_index (abfd, sym->st_shndx);
1007           if (sym_sec == NULL)
1008             return cie_inf;
1009
1010           if (sym_sec->kept_section != NULL)
1011             sym_sec = sym_sec->kept_section;
1012           if (sym_sec->output_section == NULL)
1013             return cie_inf;
1014
1015           cie->local_personality = 1;
1016           cie->personality.val = (sym->st_value
1017                                   + sym_sec->output_offset
1018                                   + sym_sec->output_section->vma);
1019         }
1020     }
1021
1022   /* See if we can merge this CIE with an earlier one.  */
1023   cie->output_sec = sec->output_section;
1024   cie_compute_hash (cie);
1025   if (hdr_info->cies == NULL)
1026     {
1027       hdr_info->cies = htab_try_create (1, cie_hash, cie_eq, free);
1028       if (hdr_info->cies == NULL)
1029         return cie_inf;
1030     }
1031   loc = htab_find_slot_with_hash (hdr_info->cies, cie, cie->hash, INSERT);
1032   if (loc == NULL)
1033     return cie_inf;
1034
1035   new_cie = (struct cie *) *loc;
1036   if (new_cie == NULL)
1037     {
1038       /* Keep CIE_INF and record it in the hash table.  */
1039       new_cie = malloc (sizeof (struct cie));
1040       if (new_cie == NULL)
1041         return cie_inf;
1042
1043       memcpy (new_cie, cie, sizeof (struct cie));
1044       *loc = new_cie;
1045     }
1046   else
1047     {
1048       /* Merge CIE_INF with NEW_CIE->CIE_INF.  */
1049       cie_inf->removed = 1;
1050       cie_inf->u.cie.merged = 1;
1051       cie_inf->u.cie.u.merged_with = new_cie->cie_inf;
1052       if (cie_inf->u.cie.make_lsda_relative)
1053         new_cie->cie_inf->u.cie.make_lsda_relative = 1;
1054     }
1055   return new_cie->cie_inf;
1056 }
1057
1058 /* This function is called for each input file before the .eh_frame
1059    section is relocated.  It discards duplicate CIEs and FDEs for discarded
1060    functions.  The function returns TRUE iff any entries have been
1061    deleted.  */
1062
1063 bfd_boolean
1064 _bfd_elf_discard_section_eh_frame
1065    (bfd *abfd, struct bfd_link_info *info, asection *sec,
1066     bfd_boolean (*reloc_symbol_deleted_p) (bfd_vma, void *),
1067     struct elf_reloc_cookie *cookie)
1068 {
1069   struct eh_cie_fde *ent;
1070   struct eh_frame_sec_info *sec_info;
1071   struct eh_frame_hdr_info *hdr_info;
1072   unsigned int ptr_size, offset;
1073
1074   sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
1075   if (sec_info == NULL)
1076     return FALSE;
1077
1078   hdr_info = &elf_hash_table (info)->eh_info;
1079   for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1080     if (ent->size == 4)
1081       /* There should only be one zero terminator, on the last input
1082          file supplying .eh_frame (crtend.o).  Remove any others.  */
1083       ent->removed = sec->map_head.s != NULL;
1084     else if (!ent->cie)
1085       {
1086         cookie->rel = cookie->rels + ent->reloc_index;
1087         BFD_ASSERT (cookie->rel < cookie->relend
1088                     && cookie->rel->r_offset == ent->offset + 8);
1089         if (!(*reloc_symbol_deleted_p) (ent->offset + 8, cookie))
1090           {
1091             if (info->shared
1092                 && (((ent->fde_encoding & 0xf0) == DW_EH_PE_absptr
1093                      && ent->make_relative == 0)
1094                     || (ent->fde_encoding & 0xf0) == DW_EH_PE_aligned))
1095               {
1096                 /* If a shared library uses absolute pointers
1097                    which we cannot turn into PC relative,
1098                    don't create the binary search table,
1099                    since it is affected by runtime relocations.  */
1100                 hdr_info->table = FALSE;
1101                 (*info->callbacks->einfo)
1102                   (_("%P: fde encoding in %B(%A) prevents .eh_frame_hdr"
1103                      " table being created.\n"), abfd, sec);
1104               }
1105             ent->removed = 0;
1106             hdr_info->fde_count++;
1107             ent->u.fde.cie_inf = find_merged_cie (abfd, sec, hdr_info, cookie,
1108                                                   ent->u.fde.cie_inf);
1109           }
1110       }
1111
1112   if (sec_info->cies)
1113     {
1114       free (sec_info->cies);
1115       sec_info->cies = NULL;
1116     }
1117
1118   ptr_size = (get_elf_backend_data (sec->owner)
1119               ->elf_backend_eh_frame_address_size (sec->owner, sec));
1120   offset = 0;
1121   for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1122     if (!ent->removed)
1123       {
1124         ent->new_offset = offset;
1125         offset += size_of_output_cie_fde (ent, ptr_size);
1126       }
1127
1128   sec->rawsize = sec->size;
1129   sec->size = offset;
1130   return offset != sec->rawsize;
1131 }
1132
1133 /* This function is called for .eh_frame_hdr section after
1134    _bfd_elf_discard_section_eh_frame has been called on all .eh_frame
1135    input sections.  It finalizes the size of .eh_frame_hdr section.  */
1136
1137 bfd_boolean
1138 _bfd_elf_discard_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
1139 {
1140   struct elf_link_hash_table *htab;
1141   struct eh_frame_hdr_info *hdr_info;
1142   asection *sec;
1143
1144   htab = elf_hash_table (info);
1145   hdr_info = &htab->eh_info;
1146
1147   if (hdr_info->cies != NULL)
1148     {
1149       htab_delete (hdr_info->cies);
1150       hdr_info->cies = NULL;
1151     }
1152
1153   sec = hdr_info->hdr_sec;
1154   if (sec == NULL)
1155     return FALSE;
1156
1157   sec->size = EH_FRAME_HDR_SIZE;
1158   if (hdr_info->table)
1159     sec->size += 4 + hdr_info->fde_count * 8;
1160
1161   elf_tdata (abfd)->eh_frame_hdr = sec;
1162   return TRUE;
1163 }
1164
1165 /* This function is called from size_dynamic_sections.
1166    It needs to decide whether .eh_frame_hdr should be output or not,
1167    because when the dynamic symbol table has been sized it is too late
1168    to strip sections.  */
1169
1170 bfd_boolean
1171 _bfd_elf_maybe_strip_eh_frame_hdr (struct bfd_link_info *info)
1172 {
1173   asection *o;
1174   bfd *abfd;
1175   struct elf_link_hash_table *htab;
1176   struct eh_frame_hdr_info *hdr_info;
1177
1178   htab = elf_hash_table (info);
1179   hdr_info = &htab->eh_info;
1180   if (hdr_info->hdr_sec == NULL)
1181     return TRUE;
1182
1183   if (bfd_is_abs_section (hdr_info->hdr_sec->output_section))
1184     {
1185       hdr_info->hdr_sec = NULL;
1186       return TRUE;
1187     }
1188
1189   abfd = NULL;
1190   if (info->eh_frame_hdr)
1191     for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link_next)
1192       {
1193         /* Count only sections which have at least a single CIE or FDE.
1194            There cannot be any CIE or FDE <= 8 bytes.  */
1195         o = bfd_get_section_by_name (abfd, ".eh_frame");
1196         if (o && o->size > 8 && !bfd_is_abs_section (o->output_section))
1197           break;
1198       }
1199
1200   if (abfd == NULL)
1201     {
1202       hdr_info->hdr_sec->flags |= SEC_EXCLUDE;
1203       hdr_info->hdr_sec = NULL;
1204       return TRUE;
1205     }
1206
1207   hdr_info->table = TRUE;
1208   return TRUE;
1209 }
1210
1211 /* Adjust an address in the .eh_frame section.  Given OFFSET within
1212    SEC, this returns the new offset in the adjusted .eh_frame section,
1213    or -1 if the address refers to a CIE/FDE which has been removed
1214    or to offset with dynamic relocation which is no longer needed.  */
1215
1216 bfd_vma
1217 _bfd_elf_eh_frame_section_offset (bfd *output_bfd ATTRIBUTE_UNUSED,
1218                                   struct bfd_link_info *info,
1219                                   asection *sec,
1220                                   bfd_vma offset)
1221 {
1222   struct eh_frame_sec_info *sec_info;
1223   struct elf_link_hash_table *htab;
1224   struct eh_frame_hdr_info *hdr_info;
1225   unsigned int lo, hi, mid;
1226
1227   if (sec->sec_info_type != ELF_INFO_TYPE_EH_FRAME)
1228     return offset;
1229   sec_info = elf_section_data (sec)->sec_info;
1230
1231   if (offset >= sec->rawsize)
1232     return offset - sec->rawsize + sec->size;
1233
1234   htab = elf_hash_table (info);
1235   hdr_info = &htab->eh_info;
1236
1237   lo = 0;
1238   hi = sec_info->count;
1239   mid = 0;
1240   while (lo < hi)
1241     {
1242       mid = (lo + hi) / 2;
1243       if (offset < sec_info->entry[mid].offset)
1244         hi = mid;
1245       else if (offset
1246                >= sec_info->entry[mid].offset + sec_info->entry[mid].size)
1247         lo = mid + 1;
1248       else
1249         break;
1250     }
1251
1252   BFD_ASSERT (lo < hi);
1253
1254   /* FDE or CIE was removed.  */
1255   if (sec_info->entry[mid].removed)
1256     return (bfd_vma) -1;
1257
1258   /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1259      relocation against FDE's initial_location field.  */
1260   if (!sec_info->entry[mid].cie
1261       && sec_info->entry[mid].make_relative
1262       && offset == sec_info->entry[mid].offset + 8)
1263     return (bfd_vma) -2;
1264
1265   /* If converting LSDA pointers to DW_EH_PE_pcrel, there will be no need
1266      for run-time relocation against LSDA field.  */
1267   if (!sec_info->entry[mid].cie
1268       && sec_info->entry[mid].u.fde.cie_inf->u.cie.make_lsda_relative
1269       && offset == (sec_info->entry[mid].offset + 8
1270                     + sec_info->entry[mid].lsda_offset))
1271     return (bfd_vma) -2;
1272
1273   /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1274      relocation against DW_CFA_set_loc's arguments.  */
1275   if (sec_info->entry[mid].set_loc
1276       && sec_info->entry[mid].make_relative
1277       && (offset >= sec_info->entry[mid].offset + 8
1278                     + sec_info->entry[mid].set_loc[1]))
1279     {
1280       unsigned int cnt;
1281
1282       for (cnt = 1; cnt <= sec_info->entry[mid].set_loc[0]; cnt++)
1283         if (offset == sec_info->entry[mid].offset + 8
1284                       + sec_info->entry[mid].set_loc[cnt])
1285           return (bfd_vma) -2;
1286     }
1287
1288   /* Any new augmentation bytes go before the first relocation.  */
1289   return (offset + sec_info->entry[mid].new_offset
1290           - sec_info->entry[mid].offset
1291           + extra_augmentation_string_bytes (sec_info->entry + mid)
1292           + extra_augmentation_data_bytes (sec_info->entry + mid));
1293 }
1294
1295 /* Write out .eh_frame section.  This is called with the relocated
1296    contents.  */
1297
1298 bfd_boolean
1299 _bfd_elf_write_section_eh_frame (bfd *abfd,
1300                                  struct bfd_link_info *info,
1301                                  asection *sec,
1302                                  bfd_byte *contents)
1303 {
1304   struct eh_frame_sec_info *sec_info;
1305   struct elf_link_hash_table *htab;
1306   struct eh_frame_hdr_info *hdr_info;
1307   unsigned int ptr_size;
1308   struct eh_cie_fde *ent;
1309
1310   if (sec->sec_info_type != ELF_INFO_TYPE_EH_FRAME)
1311     return bfd_set_section_contents (abfd, sec->output_section, contents,
1312                                      sec->output_offset, sec->size);
1313
1314   ptr_size = (get_elf_backend_data (abfd)
1315               ->elf_backend_eh_frame_address_size (abfd, sec));
1316   BFD_ASSERT (ptr_size != 0);
1317
1318   sec_info = elf_section_data (sec)->sec_info;
1319   htab = elf_hash_table (info);
1320   hdr_info = &htab->eh_info;
1321
1322   if (hdr_info->table && hdr_info->array == NULL)
1323     hdr_info->array
1324       = bfd_malloc (hdr_info->fde_count * sizeof(*hdr_info->array));
1325   if (hdr_info->array == NULL)
1326     hdr_info = NULL;
1327
1328   /* The new offsets can be bigger or smaller than the original offsets.
1329      We therefore need to make two passes over the section: one backward
1330      pass to move entries up and one forward pass to move entries down.
1331      The two passes won't interfere with each other because entries are
1332      not reordered  */
1333   for (ent = sec_info->entry + sec_info->count; ent-- != sec_info->entry;)
1334     if (!ent->removed && ent->new_offset > ent->offset)
1335       memmove (contents + ent->new_offset, contents + ent->offset, ent->size);
1336
1337   for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1338     if (!ent->removed && ent->new_offset < ent->offset)
1339       memmove (contents + ent->new_offset, contents + ent->offset, ent->size);
1340
1341   for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1342     {
1343       unsigned char *buf, *end;
1344       unsigned int new_size;
1345
1346       if (ent->removed)
1347         continue;
1348
1349       if (ent->size == 4)
1350         {
1351           /* Any terminating FDE must be at the end of the section.  */
1352           BFD_ASSERT (ent == sec_info->entry + sec_info->count - 1);
1353           continue;
1354         }
1355
1356       buf = contents + ent->new_offset;
1357       end = buf + ent->size;
1358       new_size = size_of_output_cie_fde (ent, ptr_size);
1359
1360       /* Update the size.  It may be shrinked.  */
1361       bfd_put_32 (abfd, new_size - 4, buf);
1362
1363       /* Filling the extra bytes with DW_CFA_nops.  */
1364       if (new_size != ent->size)
1365         memset (end, 0, new_size - ent->size);
1366
1367       if (ent->cie)
1368         {
1369           /* CIE */
1370           if (ent->make_relative
1371               || ent->u.cie.make_lsda_relative
1372               || ent->u.cie.per_encoding_relative)
1373             {
1374               char *aug;
1375               unsigned int action, extra_string, extra_data;
1376               unsigned int per_width, per_encoding;
1377
1378               /* Need to find 'R' or 'L' augmentation's argument and modify
1379                  DW_EH_PE_* value.  */
1380               action = ((ent->make_relative ? 1 : 0)
1381                         | (ent->u.cie.make_lsda_relative ? 2 : 0)
1382                         | (ent->u.cie.per_encoding_relative ? 4 : 0));
1383               extra_string = extra_augmentation_string_bytes (ent);
1384               extra_data = extra_augmentation_data_bytes (ent);
1385
1386               /* Skip length, id and version.  */
1387               buf += 9;
1388               aug = (char *) buf;
1389               buf += strlen (aug) + 1;
1390               skip_leb128 (&buf, end);
1391               skip_leb128 (&buf, end);
1392               skip_leb128 (&buf, end);
1393               if (*aug == 'z')
1394                 {
1395                   /* The uleb128 will always be a single byte for the kind
1396                      of augmentation strings that we're prepared to handle.  */
1397                   *buf++ += extra_data;
1398                   aug++;
1399                 }
1400
1401               /* Make room for the new augmentation string and data bytes.  */
1402               memmove (buf + extra_string + extra_data, buf, end - buf);
1403               memmove (aug + extra_string, aug, buf - (bfd_byte *) aug);
1404               buf += extra_string;
1405               end += extra_string + extra_data;
1406
1407               if (ent->add_augmentation_size)
1408                 {
1409                   *aug++ = 'z';
1410                   *buf++ = extra_data - 1;
1411                 }
1412               if (ent->u.cie.add_fde_encoding)
1413                 {
1414                   BFD_ASSERT (action & 1);
1415                   *aug++ = 'R';
1416                   *buf++ = DW_EH_PE_pcrel;
1417                   action &= ~1;
1418                 }
1419
1420               while (action)
1421                 switch (*aug++)
1422                   {
1423                   case 'L':
1424                     if (action & 2)
1425                       {
1426                         BFD_ASSERT (*buf == ent->lsda_encoding);
1427                         *buf |= DW_EH_PE_pcrel;
1428                         action &= ~2;
1429                       }
1430                     buf++;
1431                     break;
1432                   case 'P':
1433                     per_encoding = *buf++;
1434                     per_width = get_DW_EH_PE_width (per_encoding, ptr_size);
1435                     BFD_ASSERT (per_width != 0);
1436                     BFD_ASSERT (((per_encoding & 0x70) == DW_EH_PE_pcrel)
1437                                 == ent->u.cie.per_encoding_relative);
1438                     if ((per_encoding & 0xf0) == DW_EH_PE_aligned)
1439                       buf = (contents
1440                              + ((buf - contents + per_width - 1)
1441                                 & ~((bfd_size_type) per_width - 1)));
1442                     if (action & 4)
1443                       {
1444                         bfd_vma val;
1445
1446                         val = read_value (abfd, buf, per_width,
1447                                           get_DW_EH_PE_signed (per_encoding));
1448                         val += (bfd_vma) ent->offset - ent->new_offset;
1449                         val -= extra_string + extra_data;
1450                         write_value (abfd, buf, val, per_width);
1451                         action &= ~4;
1452                       }
1453                     buf += per_width;
1454                     break;
1455                   case 'R':
1456                     if (action & 1)
1457                       {
1458                         BFD_ASSERT (*buf == ent->fde_encoding);
1459                         *buf |= DW_EH_PE_pcrel;
1460                         action &= ~1;
1461                       }
1462                     buf++;
1463                     break;
1464                   case 'S':
1465                     break;
1466                   default:
1467                     BFD_FAIL ();
1468                   }
1469             }
1470         }
1471       else
1472         {
1473           /* FDE */
1474           bfd_vma value, address;
1475           unsigned int width;
1476           bfd_byte *start;
1477           struct eh_cie_fde *cie;
1478
1479           /* Skip length.  */
1480           cie = ent->u.fde.cie_inf;
1481           buf += 4;
1482           value = ((ent->new_offset + sec->output_offset + 4)
1483                    - (cie->new_offset + cie->u.cie.u.sec->output_offset));
1484           bfd_put_32 (abfd, value, buf);
1485           buf += 4;
1486           width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1487           value = read_value (abfd, buf, width,
1488                               get_DW_EH_PE_signed (ent->fde_encoding));
1489           address = value;
1490           if (value)
1491             {
1492               switch (ent->fde_encoding & 0xf0)
1493                 {
1494                 case DW_EH_PE_indirect:
1495                 case DW_EH_PE_textrel:
1496                   BFD_ASSERT (hdr_info == NULL);
1497                   break;
1498                 case DW_EH_PE_datarel:
1499                   {
1500                     asection *got = bfd_get_section_by_name (abfd, ".got");
1501
1502                     BFD_ASSERT (got != NULL);
1503                     address += got->vma;
1504                   }
1505                   break;
1506                 case DW_EH_PE_pcrel:
1507                   value += (bfd_vma) ent->offset - ent->new_offset;
1508                   address += (sec->output_section->vma
1509                               + sec->output_offset
1510                               + ent->offset + 8);
1511                   break;
1512                 }
1513               if (ent->make_relative)
1514                 value -= (sec->output_section->vma
1515                           + sec->output_offset
1516                           + ent->new_offset + 8);
1517               write_value (abfd, buf, value, width);
1518             }
1519
1520           start = buf;
1521
1522           if (hdr_info)
1523             {
1524               hdr_info->array[hdr_info->array_count].initial_loc = address;
1525               hdr_info->array[hdr_info->array_count++].fde
1526                 = (sec->output_section->vma
1527                    + sec->output_offset
1528                    + ent->new_offset);
1529             }
1530
1531           if ((ent->lsda_encoding & 0xf0) == DW_EH_PE_pcrel
1532               || cie->u.cie.make_lsda_relative)
1533             {
1534               buf += ent->lsda_offset;
1535               width = get_DW_EH_PE_width (ent->lsda_encoding, ptr_size);
1536               value = read_value (abfd, buf, width,
1537                                   get_DW_EH_PE_signed (ent->lsda_encoding));
1538               if (value)
1539                 {
1540                   if ((ent->lsda_encoding & 0xf0) == DW_EH_PE_pcrel)
1541                     value += (bfd_vma) ent->offset - ent->new_offset;
1542                   else if (cie->u.cie.make_lsda_relative)
1543                     value -= (sec->output_section->vma
1544                               + sec->output_offset
1545                               + ent->new_offset + 8 + ent->lsda_offset);
1546                   write_value (abfd, buf, value, width);
1547                 }
1548             }
1549           else if (ent->add_augmentation_size)
1550             {
1551               /* Skip the PC and length and insert a zero byte for the
1552                  augmentation size.  */
1553               buf += width * 2;
1554               memmove (buf + 1, buf, end - buf);
1555               *buf = 0;
1556             }
1557
1558           if (ent->set_loc)
1559             {
1560               /* Adjust DW_CFA_set_loc.  */
1561               unsigned int cnt, width;
1562               bfd_vma new_offset;
1563
1564               width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1565               new_offset = ent->new_offset + 8
1566                            + extra_augmentation_string_bytes (ent)
1567                            + extra_augmentation_data_bytes (ent);
1568
1569               for (cnt = 1; cnt <= ent->set_loc[0]; cnt++)
1570                 {
1571                   bfd_vma value;
1572                   buf = start + ent->set_loc[cnt];
1573
1574                   value = read_value (abfd, buf, width,
1575                                       get_DW_EH_PE_signed (ent->fde_encoding));
1576                   if (!value)
1577                     continue;
1578
1579                   if ((ent->fde_encoding & 0xf0) == DW_EH_PE_pcrel)
1580                     value += (bfd_vma) ent->offset + 8 - new_offset;
1581                   if (ent->make_relative)
1582                     value -= (sec->output_section->vma
1583                               + sec->output_offset
1584                               + new_offset + ent->set_loc[cnt]);
1585                   write_value (abfd, buf, value, width);
1586                 }
1587             }
1588         }
1589     }
1590
1591   /* We don't align the section to its section alignment since the
1592      runtime library only expects all CIE/FDE records aligned at
1593      the pointer size. _bfd_elf_discard_section_eh_frame should
1594      have padded CIE/FDE records to multiple of pointer size with
1595      size_of_output_cie_fde.  */
1596   if ((sec->size % ptr_size) != 0)
1597     abort ();
1598
1599   return bfd_set_section_contents (abfd, sec->output_section,
1600                                    contents, (file_ptr) sec->output_offset,
1601                                    sec->size);
1602 }
1603
1604 /* Helper function used to sort .eh_frame_hdr search table by increasing
1605    VMA of FDE initial location.  */
1606
1607 static int
1608 vma_compare (const void *a, const void *b)
1609 {
1610   const struct eh_frame_array_ent *p = a;
1611   const struct eh_frame_array_ent *q = b;
1612   if (p->initial_loc > q->initial_loc)
1613     return 1;
1614   if (p->initial_loc < q->initial_loc)
1615     return -1;
1616   return 0;
1617 }
1618
1619 /* Write out .eh_frame_hdr section.  This must be called after
1620    _bfd_elf_write_section_eh_frame has been called on all input
1621    .eh_frame sections.
1622    .eh_frame_hdr format:
1623    ubyte version                (currently 1)
1624    ubyte eh_frame_ptr_enc       (DW_EH_PE_* encoding of pointer to start of
1625                                  .eh_frame section)
1626    ubyte fde_count_enc          (DW_EH_PE_* encoding of total FDE count
1627                                  number (or DW_EH_PE_omit if there is no
1628                                  binary search table computed))
1629    ubyte table_enc              (DW_EH_PE_* encoding of binary search table,
1630                                  or DW_EH_PE_omit if not present.
1631                                  DW_EH_PE_datarel is using address of
1632                                  .eh_frame_hdr section start as base)
1633    [encoded] eh_frame_ptr       (pointer to start of .eh_frame section)
1634    optionally followed by:
1635    [encoded] fde_count          (total number of FDEs in .eh_frame section)
1636    fde_count x [encoded] initial_loc, fde
1637                                 (array of encoded pairs containing
1638                                  FDE initial_location field and FDE address,
1639                                  sorted by increasing initial_loc).  */
1640
1641 bfd_boolean
1642 _bfd_elf_write_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
1643 {
1644   struct elf_link_hash_table *htab;
1645   struct eh_frame_hdr_info *hdr_info;
1646   asection *sec;
1647   bfd_byte *contents;
1648   asection *eh_frame_sec;
1649   bfd_size_type size;
1650   bfd_boolean retval;
1651   bfd_vma encoded_eh_frame;
1652
1653   htab = elf_hash_table (info);
1654   hdr_info = &htab->eh_info;
1655   sec = hdr_info->hdr_sec;
1656   if (sec == NULL)
1657     return TRUE;
1658
1659   size = EH_FRAME_HDR_SIZE;
1660   if (hdr_info->array && hdr_info->array_count == hdr_info->fde_count)
1661     size += 4 + hdr_info->fde_count * 8;
1662   contents = bfd_malloc (size);
1663   if (contents == NULL)
1664     return FALSE;
1665
1666   eh_frame_sec = bfd_get_section_by_name (abfd, ".eh_frame");
1667   if (eh_frame_sec == NULL)
1668     {
1669       free (contents);
1670       return FALSE;
1671     }
1672
1673   memset (contents, 0, EH_FRAME_HDR_SIZE);
1674   contents[0] = 1;                              /* Version.  */
1675   contents[1] = get_elf_backend_data (abfd)->elf_backend_encode_eh_address
1676     (abfd, info, eh_frame_sec, 0, sec, 4,
1677      &encoded_eh_frame);                        /* .eh_frame offset.  */
1678
1679   if (hdr_info->array && hdr_info->array_count == hdr_info->fde_count)
1680     {
1681       contents[2] = DW_EH_PE_udata4;            /* FDE count encoding.  */
1682       contents[3] = DW_EH_PE_datarel | DW_EH_PE_sdata4; /* Search table enc.  */
1683     }
1684   else
1685     {
1686       contents[2] = DW_EH_PE_omit;
1687       contents[3] = DW_EH_PE_omit;
1688     }
1689   bfd_put_32 (abfd, encoded_eh_frame, contents + 4);
1690
1691   if (contents[2] != DW_EH_PE_omit)
1692     {
1693       unsigned int i;
1694
1695       bfd_put_32 (abfd, hdr_info->fde_count, contents + EH_FRAME_HDR_SIZE);
1696       qsort (hdr_info->array, hdr_info->fde_count, sizeof (*hdr_info->array),
1697              vma_compare);
1698       for (i = 0; i < hdr_info->fde_count; i++)
1699         {
1700           bfd_put_32 (abfd,
1701                       hdr_info->array[i].initial_loc
1702                       - sec->output_section->vma,
1703                       contents + EH_FRAME_HDR_SIZE + i * 8 + 4);
1704           bfd_put_32 (abfd,
1705                       hdr_info->array[i].fde - sec->output_section->vma,
1706                       contents + EH_FRAME_HDR_SIZE + i * 8 + 8);
1707         }
1708     }
1709
1710   retval = bfd_set_section_contents (abfd, sec->output_section,
1711                                      contents, (file_ptr) sec->output_offset,
1712                                      sec->size);
1713   free (contents);
1714   return retval;
1715 }
1716
1717 /* Return the width of FDE addresses.  This is the default implementation.  */
1718
1719 unsigned int
1720 _bfd_elf_eh_frame_address_size (bfd *abfd, asection *sec ATTRIBUTE_UNUSED)
1721 {
1722   return elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64 ? 8 : 4;
1723 }
1724
1725 /* Decide whether we can use a PC-relative encoding within the given
1726    EH frame section.  This is the default implementation.  */
1727
1728 bfd_boolean
1729 _bfd_elf_can_make_relative (bfd *input_bfd ATTRIBUTE_UNUSED,
1730                             struct bfd_link_info *info ATTRIBUTE_UNUSED,
1731                             asection *eh_frame_section ATTRIBUTE_UNUSED)
1732 {
1733   return TRUE;
1734 }
1735
1736 /* Select an encoding for the given address.  Preference is given to
1737    PC-relative addressing modes.  */
1738
1739 bfd_byte
1740 _bfd_elf_encode_eh_address (bfd *abfd ATTRIBUTE_UNUSED,
1741                             struct bfd_link_info *info ATTRIBUTE_UNUSED,
1742                             asection *osec, bfd_vma offset,
1743                             asection *loc_sec, bfd_vma loc_offset,
1744                             bfd_vma *encoded)
1745 {
1746   *encoded = osec->vma + offset -
1747     (loc_sec->output_section->vma + loc_sec->output_offset + loc_offset);
1748   return DW_EH_PE_pcrel | DW_EH_PE_sdata4;
1749 }