contrib/binutils-2.24/bfd/elf-eh-frame.c

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