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