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

   1 /* .eh_frame section optimization.
   2    Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
   3    Free Software Foundation, Inc.
   4    Written by Jakub Jelinek <jakub@redhat.com>.
   5
   6    This file is part of BFD, the Binary File Descriptor library.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  21    MA 02110-1301, USA.  */
  22
  23 #include "sysdep.h"
  24 #include "bfd.h"
  25 #include "libbfd.h"
  26 #include "elf-bfd.h"
  27 #include "dwarf2.h"
  28
  29 #define EH_FRAME_HDR_SIZE 8
  30
  31 struct cie
  32 {
  33   unsigned int length;
  34   unsigned int hash;
  35   unsigned char version;
  36   unsigned char local_personality;
  37   char augmentation[20];
  38   bfd_vma code_align;
  39   bfd_signed_vma data_align;
  40   bfd_vma ra_column;
  41   bfd_vma augmentation_size;
  42   union {
  43     struct elf_link_hash_entry *h;
  44     bfd_vma val;
  45     unsigned int reloc_index;
  46   } personality;
  47   asection *output_sec;
  48   struct eh_cie_fde *cie_inf;
  49   unsigned char per_encoding;
  50   unsigned char lsda_encoding;
  51   unsigned char fde_encoding;
  52   unsigned char initial_insn_length;
  53   unsigned char can_make_lsda_relative;
  54   unsigned char initial_instructions[50];
  55 };
  56
  57
  58
  59 /* If *ITER hasn't reached END yet, read the next byte into *RESULT and
  60    move onto the next byte.  Return true on success.  */
  61
  62 static inline bfd_boolean
  63 read_byte (bfd_byte **iter, bfd_byte *end, unsigned char *result)
  64 {
  65   if (*iter >= end)
  66     return FALSE;
  67   *result = *((*iter)++);
  68   return TRUE;
  69 }
  70
  71 /* Move *ITER over LENGTH bytes, or up to END, whichever is closer.
  72    Return true it was possible to move LENGTH bytes.  */
  73
  74 static inline bfd_boolean
  75 skip_bytes (bfd_byte **iter, bfd_byte *end, bfd_size_type length)
  76 {
  77   if ((bfd_size_type) (end - *iter) < length)
  78     {
  79       *iter = end;
  80       return FALSE;
  81     }
  82   *iter += length;
  83   return TRUE;
  84 }
  85
  86 /* Move *ITER over an leb128, stopping at END.  Return true if the end
  87    of the leb128 was found.  */
  88
  89 static bfd_boolean
  90 skip_leb128 (bfd_byte **iter, bfd_byte *end)
  91 {
  92   unsigned char byte;
  93   do
  94     if (!read_byte (iter, end, &byte))
  95       return FALSE;
  96   while (byte & 0x80);
  97   return TRUE;
  98 }
  99
 100 /* Like skip_leb128, but treat the leb128 as an unsigned value and
 101    store it in *VALUE.  */
 102
 103 static bfd_boolean
 104 read_uleb128 (bfd_byte **iter, bfd_byte *end, bfd_vma *value)
 105 {
 106   bfd_byte *start, *p;
 107
 108   start = *iter;
 109   if (!skip_leb128 (iter, end))
 110     return FALSE;
 111
 112   p = *iter;
 113   *value = *--p;
 114   while (p > start)
 115     *value = (*value << 7) | (*--p & 0x7f);
 116
 117   return TRUE;
 118 }
 119
 120 /* Like read_uleb128, but for signed values.  */
 121
 122 static bfd_boolean
 123 read_sleb128 (bfd_byte **iter, bfd_byte *end, bfd_signed_vma *value)
 124 {
 125   bfd_byte *start, *p;
 126
 127   start = *iter;
 128   if (!skip_leb128 (iter, end))
 129     return FALSE;
 130
 131   p = *iter;
 132   *value = ((*--p & 0x7f) ^ 0x40) - 0x40;
 133   while (p > start)
 134     *value = (*value << 7) | (*--p & 0x7f);
 135
 136   return TRUE;
 137 }
 138
 139 /* Return 0 if either encoding is variable width, or not yet known to bfd.  */
 140
 141 static
 142 int get_DW_EH_PE_width (int encoding, int ptr_size)
 143 {
 144   /* DW_EH_PE_ values of 0x60 and 0x70 weren't defined at the time .eh_frame
 145      was added to bfd.  */
 146   if ((encoding & 0x60) == 0x60)
 147     return 0;
 148
 149   switch (encoding & 7)
 150     {
 151     case DW_EH_PE_udata2: return 2;
 152     case DW_EH_PE_udata4: return 4;
 153     case DW_EH_PE_udata8: return 8;
 154     case DW_EH_PE_absptr: return ptr_size;
 155     default:
 156       break;
 157     }
 158
 159   return 0;
 160 }
 161
 162 #define get_DW_EH_PE_signed(encoding) (((encoding) & DW_EH_PE_signed) != 0)
 163
 164 /* Read a width sized value from memory.  */
 165
 166 static bfd_vma
 167 read_value (bfd *abfd, bfd_byte *buf, int width, int is_signed)
 168 {
 169   bfd_vma value;
 170
 171   switch (width)
 172     {
 173     case 2:
 174       if (is_signed)
 175         value = bfd_get_signed_16 (abfd, buf);
 176       else
 177         value = bfd_get_16 (abfd, buf);
 178       break;
 179     case 4:
 180       if (is_signed)
 181         value = bfd_get_signed_32 (abfd, buf);
 182       else
 183         value = bfd_get_32 (abfd, buf);
 184       break;
 185     case 8:
 186       if (is_signed)
 187         value = bfd_get_signed_64 (abfd, buf);
 188       else
 189         value = bfd_get_64 (abfd, buf);
 190       break;
 191     default:
 192       BFD_FAIL ();
 193       return 0;
 194     }
 195
 196   return value;
 197 }
 198
 199 /* Store a width sized value to memory.  */
 200
 201 static void
 202 write_value (bfd *abfd, bfd_byte *buf, bfd_vma value, int width)
 203 {
 204   switch (width)
 205     {
 206     case 2: bfd_put_16 (abfd, value, buf); break;
 207     case 4: bfd_put_32 (abfd, value, buf); break;
 208     case 8: bfd_put_64 (abfd, value, buf); break;
 209     default: BFD_FAIL ();
 210     }
 211 }
 212
 213 /* Return one if C1 and C2 CIEs can be merged.  */
 214
 215 static int
 216 cie_eq (const void *e1, const void *e2)
 217 {
 218   const struct cie *c1 = (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 != ELF_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 = ELF_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 != ELF_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_tdata (abfd)->eh_frame_hdr = sec;
1247   return TRUE;
1248 }
1249
1250 /* This function is called from size_dynamic_sections.
1251    It needs to decide whether .eh_frame_hdr should be output or not,
1252    because when the dynamic symbol table has been sized it is too late
1253    to strip sections.  */
1254
1255 bfd_boolean
1256 _bfd_elf_maybe_strip_eh_frame_hdr (struct bfd_link_info *info)
1257 {
1258   asection *o;
1259   bfd *abfd;
1260   struct elf_link_hash_table *htab;
1261   struct eh_frame_hdr_info *hdr_info;
1262
1263   htab = elf_hash_table (info);
1264   hdr_info = &htab->eh_info;
1265   if (hdr_info->hdr_sec == NULL)
1266     return TRUE;
1267
1268   if (bfd_is_abs_section (hdr_info->hdr_sec->output_section))
1269     {
1270       hdr_info->hdr_sec = NULL;
1271       return TRUE;
1272     }
1273
1274   abfd = NULL;
1275   if (info->eh_frame_hdr)
1276     for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link_next)
1277       {
1278         /* Count only sections which have at least a single CIE or FDE.
1279            There cannot be any CIE or FDE <= 8 bytes.  */
1280         o = bfd_get_section_by_name (abfd, ".eh_frame");
1281         if (o && o->size > 8 && !bfd_is_abs_section (o->output_section))
1282           break;
1283       }
1284
1285   if (abfd == NULL)
1286     {
1287       hdr_info->hdr_sec->flags |= SEC_EXCLUDE;
1288       hdr_info->hdr_sec = NULL;
1289       return TRUE;
1290     }
1291
1292   hdr_info->table = TRUE;
1293   return TRUE;
1294 }
1295
1296 /* Adjust an address in the .eh_frame section.  Given OFFSET within
1297    SEC, this returns the new offset in the adjusted .eh_frame section,
1298    or -1 if the address refers to a CIE/FDE which has been removed
1299    or to offset with dynamic relocation which is no longer needed.  */
1300
1301 bfd_vma
1302 _bfd_elf_eh_frame_section_offset (bfd *output_bfd ATTRIBUTE_UNUSED,
1303                                   struct bfd_link_info *info ATTRIBUTE_UNUSED,
1304                                   asection *sec,
1305                                   bfd_vma offset)
1306 {
1307   struct eh_frame_sec_info *sec_info;
1308   unsigned int lo, hi, mid;
1309
1310   if (sec->sec_info_type != ELF_INFO_TYPE_EH_FRAME)
1311     return offset;
1312   sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
1313
1314   if (offset >= sec->rawsize)
1315     return offset - sec->rawsize + sec->size;
1316
1317   lo = 0;
1318   hi = sec_info->count;
1319   mid = 0;
1320   while (lo < hi)
1321     {
1322       mid = (lo + hi) / 2;
1323       if (offset < sec_info->entry[mid].offset)
1324         hi = mid;
1325       else if (offset
1326                >= sec_info->entry[mid].offset + sec_info->entry[mid].size)
1327         lo = mid + 1;
1328       else
1329         break;
1330     }
1331
1332   BFD_ASSERT (lo < hi);
1333
1334   /* FDE or CIE was removed.  */
1335   if (sec_info->entry[mid].removed)
1336     return (bfd_vma) -1;
1337
1338   /* If converting personality pointers to DW_EH_PE_pcrel, there will be
1339      no need for run-time relocation against the personality field.  */
1340   if (sec_info->entry[mid].cie
1341       && sec_info->entry[mid].u.cie.make_per_encoding_relative
1342       && offset == (sec_info->entry[mid].offset + 8
1343                     + sec_info->entry[mid].u.cie.personality_offset))
1344     return (bfd_vma) -2;
1345
1346   /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1347      relocation against FDE's initial_location field.  */
1348   if (!sec_info->entry[mid].cie
1349       && sec_info->entry[mid].make_relative
1350       && offset == sec_info->entry[mid].offset + 8)
1351     return (bfd_vma) -2;
1352
1353   /* If converting LSDA pointers to DW_EH_PE_pcrel, there will be no need
1354      for run-time relocation against LSDA field.  */
1355   if (!sec_info->entry[mid].cie
1356       && sec_info->entry[mid].u.fde.cie_inf->u.cie.make_lsda_relative
1357       && offset == (sec_info->entry[mid].offset + 8
1358                     + sec_info->entry[mid].lsda_offset))
1359     return (bfd_vma) -2;
1360
1361   /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1362      relocation against DW_CFA_set_loc's arguments.  */
1363   if (sec_info->entry[mid].set_loc
1364       && sec_info->entry[mid].make_relative
1365       && (offset >= sec_info->entry[mid].offset + 8
1366                     + sec_info->entry[mid].set_loc[1]))
1367     {
1368       unsigned int cnt;
1369
1370       for (cnt = 1; cnt <= sec_info->entry[mid].set_loc[0]; cnt++)
1371         if (offset == sec_info->entry[mid].offset + 8
1372                       + sec_info->entry[mid].set_loc[cnt])
1373           return (bfd_vma) -2;
1374     }
1375
1376   /* Any new augmentation bytes go before the first relocation.  */
1377   return (offset + sec_info->entry[mid].new_offset
1378           - sec_info->entry[mid].offset
1379           + extra_augmentation_string_bytes (sec_info->entry + mid)
1380           + extra_augmentation_data_bytes (sec_info->entry + mid));
1381 }
1382
1383 /* Write out .eh_frame section.  This is called with the relocated
1384    contents.  */
1385
1386 bfd_boolean
1387 _bfd_elf_write_section_eh_frame (bfd *abfd,
1388                                  struct bfd_link_info *info,
1389                                  asection *sec,
1390                                  bfd_byte *contents)
1391 {
1392   struct eh_frame_sec_info *sec_info;
1393   struct elf_link_hash_table *htab;
1394   struct eh_frame_hdr_info *hdr_info;
1395   unsigned int ptr_size;
1396   struct eh_cie_fde *ent;
1397
1398   if (sec->sec_info_type != ELF_INFO_TYPE_EH_FRAME)
1399     /* FIXME: octets_per_byte.  */
1400     return bfd_set_section_contents (abfd, sec->output_section, contents,
1401                                      sec->output_offset, sec->size);
1402
1403   ptr_size = (get_elf_backend_data (abfd)
1404               ->elf_backend_eh_frame_address_size (abfd, sec));
1405   BFD_ASSERT (ptr_size != 0);
1406
1407   sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
1408   htab = elf_hash_table (info);
1409   hdr_info = &htab->eh_info;
1410
1411   if (hdr_info->table && hdr_info->array == NULL)
1412     hdr_info->array = (struct eh_frame_array_ent *)
1413         bfd_malloc (hdr_info->fde_count * sizeof(*hdr_info->array));
1414   if (hdr_info->array == NULL)
1415     hdr_info = NULL;
1416
1417   /* The new offsets can be bigger or smaller than the original offsets.
1418      We therefore need to make two passes over the section: one backward
1419      pass to move entries up and one forward pass to move entries down.
1420      The two passes won't interfere with each other because entries are
1421      not reordered  */
1422   for (ent = sec_info->entry + sec_info->count; ent-- != sec_info->entry;)
1423     if (!ent->removed && ent->new_offset > ent->offset)
1424       memmove (contents + ent->new_offset, contents + ent->offset, ent->size);
1425
1426   for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1427     if (!ent->removed && ent->new_offset < ent->offset)
1428       memmove (contents + ent->new_offset, contents + ent->offset, ent->size);
1429
1430   for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1431     {
1432       unsigned char *buf, *end;
1433       unsigned int new_size;
1434
1435       if (ent->removed)
1436         continue;
1437
1438       if (ent->size == 4)
1439         {
1440           /* Any terminating FDE must be at the end of the section.  */
1441           BFD_ASSERT (ent == sec_info->entry + sec_info->count - 1);
1442           continue;
1443         }
1444
1445       buf = contents + ent->new_offset;
1446       end = buf + ent->size;
1447       new_size = size_of_output_cie_fde (ent, ptr_size);
1448
1449       /* Update the size.  It may be shrinked.  */
1450       bfd_put_32 (abfd, new_size - 4, buf);
1451
1452       /* Filling the extra bytes with DW_CFA_nops.  */
1453       if (new_size != ent->size)
1454         memset (end, 0, new_size - ent->size);
1455
1456       if (ent->cie)
1457         {
1458           /* CIE */
1459           if (ent->make_relative
1460               || ent->u.cie.make_lsda_relative
1461               || ent->u.cie.per_encoding_relative)
1462             {
1463               char *aug;
1464               unsigned int action, extra_string, extra_data;
1465               unsigned int per_width, per_encoding;
1466
1467               /* Need to find 'R' or 'L' augmentation's argument and modify
1468                  DW_EH_PE_* value.  */
1469               action = ((ent->make_relative ? 1 : 0)
1470                         | (ent->u.cie.make_lsda_relative ? 2 : 0)
1471                         | (ent->u.cie.per_encoding_relative ? 4 : 0));
1472               extra_string = extra_augmentation_string_bytes (ent);
1473               extra_data = extra_augmentation_data_bytes (ent);
1474
1475               /* Skip length, id and version.  */
1476               buf += 9;
1477               aug = (char *) buf;
1478               buf += strlen (aug) + 1;
1479               skip_leb128 (&buf, end);
1480               skip_leb128 (&buf, end);
1481               skip_leb128 (&buf, end);
1482               if (*aug == 'z')
1483                 {
1484                   /* The uleb128 will always be a single byte for the kind
1485                      of augmentation strings that we're prepared to handle.  */
1486                   *buf++ += extra_data;
1487                   aug++;
1488                 }
1489
1490               /* Make room for the new augmentation string and data bytes.  */
1491               memmove (buf + extra_string + extra_data, buf, end - buf);
1492               memmove (aug + extra_string, aug, buf - (bfd_byte *) aug);
1493               buf += extra_string;
1494               end += extra_string + extra_data;
1495
1496               if (ent->add_augmentation_size)
1497                 {
1498                   *aug++ = 'z';
1499                   *buf++ = extra_data - 1;
1500                 }
1501               if (ent->u.cie.add_fde_encoding)
1502                 {
1503                   BFD_ASSERT (action & 1);
1504                   *aug++ = 'R';
1505                   *buf++ = make_pc_relative (DW_EH_PE_absptr, ptr_size);
1506                   action &= ~1;
1507                 }
1508
1509               while (action)
1510                 switch (*aug++)
1511                   {
1512                   case 'L':
1513                     if (action & 2)
1514                       {
1515                         BFD_ASSERT (*buf == ent->lsda_encoding);
1516                         *buf = make_pc_relative (*buf, ptr_size);
1517                         action &= ~2;
1518                       }
1519                     buf++;
1520                     break;
1521                   case 'P':
1522                     if (ent->u.cie.make_per_encoding_relative)
1523                       *buf = make_pc_relative (*buf, ptr_size);
1524                     per_encoding = *buf++;
1525                     per_width = get_DW_EH_PE_width (per_encoding, ptr_size);
1526                     BFD_ASSERT (per_width != 0);
1527                     BFD_ASSERT (((per_encoding & 0x70) == DW_EH_PE_pcrel)
1528                                 == ent->u.cie.per_encoding_relative);
1529                     if ((per_encoding & 0x70) == DW_EH_PE_aligned)
1530                       buf = (contents
1531                              + ((buf - contents + per_width - 1)
1532                                 & ~((bfd_size_type) per_width - 1)));
1533                     if (action & 4)
1534                       {
1535                         bfd_vma val;
1536
1537                         val = read_value (abfd, buf, per_width,
1538                                           get_DW_EH_PE_signed (per_encoding));
1539                         if (ent->u.cie.make_per_encoding_relative)
1540                           val -= (sec->output_section->vma
1541                                   + sec->output_offset
1542                                   + (buf - contents));
1543                         else
1544                           {
1545                             val += (bfd_vma) ent->offset - ent->new_offset;
1546                             val -= extra_string + extra_data;
1547                           }
1548                         write_value (abfd, buf, val, per_width);
1549                         action &= ~4;
1550                       }
1551                     buf += per_width;
1552                     break;
1553                   case 'R':
1554                     if (action & 1)
1555                       {
1556                         BFD_ASSERT (*buf == ent->fde_encoding);
1557                         *buf = make_pc_relative (*buf, ptr_size);
1558                         action &= ~1;
1559                       }
1560                     buf++;
1561                     break;
1562                   case 'S':
1563                     break;
1564                   default:
1565                     BFD_FAIL ();
1566                   }
1567             }
1568         }
1569       else
1570         {
1571           /* FDE */
1572           bfd_vma value, address;
1573           unsigned int width;
1574           bfd_byte *start;
1575           struct eh_cie_fde *cie;
1576
1577           /* Skip length.  */
1578           cie = ent->u.fde.cie_inf;
1579           buf += 4;
1580           value = ((ent->new_offset + sec->output_offset + 4)
1581                    - (cie->new_offset + cie->u.cie.u.sec->output_offset));
1582           bfd_put_32 (abfd, value, buf);
1583           buf += 4;
1584           width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1585           value = read_value (abfd, buf, width,
1586                               get_DW_EH_PE_signed (ent->fde_encoding));
1587           address = value;
1588           if (value)
1589             {
1590               switch (ent->fde_encoding & 0x70)
1591                 {
1592                 case DW_EH_PE_textrel:
1593                   BFD_ASSERT (hdr_info == NULL);
1594                   break;
1595                 case DW_EH_PE_datarel:
1596                   {
1597                     switch (abfd->arch_info->arch)
1598                       {
1599                       case bfd_arch_ia64:
1600                         BFD_ASSERT (elf_gp (abfd) != 0);
1601                         address += elf_gp (abfd);
1602                         break;
1603                       default:
1604                         (*info->callbacks->einfo)
1605                           (_("%P: DW_EH_PE_datarel unspecified"
1606                              " for this architecture.\n"));
1607                         /* Fall thru */
1608                       case bfd_arch_frv:
1609                       case bfd_arch_i386:
1610                         BFD_ASSERT (htab->hgot != NULL
1611                                     && ((htab->hgot->root.type
1612                                          == bfd_link_hash_defined)
1613                                         || (htab->hgot->root.type
1614                                             == bfd_link_hash_defweak)));
1615                         address
1616                           += (htab->hgot->root.u.def.value
1617                               + htab->hgot->root.u.def.section->output_offset
1618                               + (htab->hgot->root.u.def.section->output_section
1619                                  ->vma));
1620                         break;
1621                       }
1622                   }
1623                   break;
1624                 case DW_EH_PE_pcrel:
1625                   value += (bfd_vma) ent->offset - ent->new_offset;
1626                   address += (sec->output_section->vma
1627                               + sec->output_offset
1628                               + ent->offset + 8);
1629                   break;
1630                 }
1631               if (ent->make_relative)
1632                 value -= (sec->output_section->vma
1633                           + sec->output_offset
1634                           + ent->new_offset + 8);
1635               write_value (abfd, buf, value, width);
1636             }
1637
1638           start = buf;
1639
1640           if (hdr_info)
1641             {
1642               /* The address calculation may overflow, giving us a
1643                  value greater than 4G on a 32-bit target when
1644                  dwarf_vma is 64-bit.  */
1645               if (sizeof (address) > 4 && ptr_size == 4)
1646                 address &= 0xffffffff;
1647               hdr_info->array[hdr_info->array_count].initial_loc = address;
1648               hdr_info->array[hdr_info->array_count++].fde
1649                 = (sec->output_section->vma
1650                    + sec->output_offset
1651                    + ent->new_offset);
1652             }
1653
1654           if ((ent->lsda_encoding & 0x70) == DW_EH_PE_pcrel
1655               || cie->u.cie.make_lsda_relative)
1656             {
1657               buf += ent->lsda_offset;
1658               width = get_DW_EH_PE_width (ent->lsda_encoding, ptr_size);
1659               value = read_value (abfd, buf, width,
1660                                   get_DW_EH_PE_signed (ent->lsda_encoding));
1661               if (value)
1662                 {
1663                   if ((ent->lsda_encoding & 0x70) == DW_EH_PE_pcrel)
1664                     value += (bfd_vma) ent->offset - ent->new_offset;
1665                   else if (cie->u.cie.make_lsda_relative)
1666                     value -= (sec->output_section->vma
1667                               + sec->output_offset
1668                               + ent->new_offset + 8 + ent->lsda_offset);
1669                   write_value (abfd, buf, value, width);
1670                 }
1671             }
1672           else if (ent->add_augmentation_size)
1673             {
1674               /* Skip the PC and length and insert a zero byte for the
1675                  augmentation size.  */
1676               buf += width * 2;
1677               memmove (buf + 1, buf, end - buf);
1678               *buf = 0;
1679             }
1680
1681           if (ent->set_loc)
1682             {
1683               /* Adjust DW_CFA_set_loc.  */
1684               unsigned int cnt;
1685               bfd_vma new_offset;
1686
1687               width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1688               new_offset = ent->new_offset + 8
1689                            + extra_augmentation_string_bytes (ent)
1690                            + extra_augmentation_data_bytes (ent);
1691
1692               for (cnt = 1; cnt <= ent->set_loc[0]; cnt++)
1693                 {
1694                   buf = start + ent->set_loc[cnt];
1695
1696                   value = read_value (abfd, buf, width,
1697                                       get_DW_EH_PE_signed (ent->fde_encoding));
1698                   if (!value)
1699                     continue;
1700
1701                   if ((ent->fde_encoding & 0x70) == DW_EH_PE_pcrel)
1702                     value += (bfd_vma) ent->offset + 8 - new_offset;
1703                   if (ent->make_relative)
1704                     value -= (sec->output_section->vma
1705                               + sec->output_offset
1706                               + new_offset + ent->set_loc[cnt]);
1707                   write_value (abfd, buf, value, width);
1708                 }
1709             }
1710         }
1711     }
1712
1713   /* We don't align the section to its section alignment since the
1714      runtime library only expects all CIE/FDE records aligned at
1715      the pointer size. _bfd_elf_discard_section_eh_frame should
1716      have padded CIE/FDE records to multiple of pointer size with
1717      size_of_output_cie_fde.  */
1718   if ((sec->size % ptr_size) != 0)
1719     abort ();
1720
1721   /* FIXME: octets_per_byte.  */
1722   return bfd_set_section_contents (abfd, sec->output_section,
1723                                    contents, (file_ptr) sec->output_offset,
1724                                    sec->size);
1725 }
1726
1727 /* Helper function used to sort .eh_frame_hdr search table by increasing
1728    VMA of FDE initial location.  */
1729
1730 static int
1731 vma_compare (const void *a, const void *b)
1732 {
1733   const struct eh_frame_array_ent *p = (const struct eh_frame_array_ent *) a;
1734   const struct eh_frame_array_ent *q = (const struct eh_frame_array_ent *) b;
1735   if (p->initial_loc > q->initial_loc)
1736     return 1;
1737   if (p->initial_loc < q->initial_loc)
1738     return -1;
1739   return 0;
1740 }
1741
1742 /* Write out .eh_frame_hdr section.  This must be called after
1743    _bfd_elf_write_section_eh_frame has been called on all input
1744    .eh_frame sections.
1745    .eh_frame_hdr format:
1746    ubyte version                (currently 1)
1747    ubyte eh_frame_ptr_enc       (DW_EH_PE_* encoding of pointer to start of
1748                                  .eh_frame section)
1749    ubyte fde_count_enc          (DW_EH_PE_* encoding of total FDE count
1750                                  number (or DW_EH_PE_omit if there is no
1751                                  binary search table computed))
1752    ubyte table_enc              (DW_EH_PE_* encoding of binary search table,
1753                                  or DW_EH_PE_omit if not present.
1754                                  DW_EH_PE_datarel is using address of
1755                                  .eh_frame_hdr section start as base)
1756    [encoded] eh_frame_ptr       (pointer to start of .eh_frame section)
1757    optionally followed by:
1758    [encoded] fde_count          (total number of FDEs in .eh_frame section)
1759    fde_count x [encoded] initial_loc, fde
1760                                 (array of encoded pairs containing
1761                                  FDE initial_location field and FDE address,
1762                                  sorted by increasing initial_loc).  */
1763
1764 bfd_boolean
1765 _bfd_elf_write_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
1766 {
1767   struct elf_link_hash_table *htab;
1768   struct eh_frame_hdr_info *hdr_info;
1769   asection *sec;
1770   bfd_byte *contents;
1771   asection *eh_frame_sec;
1772   bfd_size_type size;
1773   bfd_boolean retval;
1774   bfd_vma encoded_eh_frame;
1775
1776   htab = elf_hash_table (info);
1777   hdr_info = &htab->eh_info;
1778   sec = hdr_info->hdr_sec;
1779   if (sec == NULL)
1780     return TRUE;
1781
1782   size = EH_FRAME_HDR_SIZE;
1783   if (hdr_info->array && hdr_info->array_count == hdr_info->fde_count)
1784     size += 4 + hdr_info->fde_count * 8;
1785   contents = (bfd_byte *) bfd_malloc (size);
1786   if (contents == NULL)
1787     return FALSE;
1788
1789   eh_frame_sec = bfd_get_section_by_name (abfd, ".eh_frame");
1790   if (eh_frame_sec == NULL)
1791     {
1792       free (contents);
1793       return FALSE;
1794     }
1795
1796   memset (contents, 0, EH_FRAME_HDR_SIZE);
1797   contents[0] = 1;                              /* Version.  */
1798   contents[1] = get_elf_backend_data (abfd)->elf_backend_encode_eh_address
1799     (abfd, info, eh_frame_sec, 0, sec, 4,
1800      &encoded_eh_frame);                        /* .eh_frame offset.  */
1801
1802   if (hdr_info->array && hdr_info->array_count == hdr_info->fde_count)
1803     {
1804       contents[2] = DW_EH_PE_udata4;            /* FDE count encoding.  */
1805       contents[3] = DW_EH_PE_datarel | DW_EH_PE_sdata4; /* Search table enc.  */
1806     }
1807   else
1808     {
1809       contents[2] = DW_EH_PE_omit;
1810       contents[3] = DW_EH_PE_omit;
1811     }
1812   bfd_put_32 (abfd, encoded_eh_frame, contents + 4);
1813
1814   if (contents[2] != DW_EH_PE_omit)
1815     {
1816       unsigned int i;
1817
1818       bfd_put_32 (abfd, hdr_info->fde_count, contents + EH_FRAME_HDR_SIZE);
1819       qsort (hdr_info->array, hdr_info->fde_count, sizeof (*hdr_info->array),
1820              vma_compare);
1821       for (i = 0; i < hdr_info->fde_count; i++)
1822         {
1823           bfd_put_32 (abfd,
1824                       hdr_info->array[i].initial_loc
1825                       - sec->output_section->vma,
1826                       contents + EH_FRAME_HDR_SIZE + i * 8 + 4);
1827           bfd_put_32 (abfd,
1828                       hdr_info->array[i].fde - sec->output_section->vma,
1829                       contents + EH_FRAME_HDR_SIZE + i * 8 + 8);
1830         }
1831     }
1832
1833   /* FIXME: octets_per_byte.  */
1834   retval = bfd_set_section_contents (abfd, sec->output_section,
1835                                      contents, (file_ptr) sec->output_offset,
1836                                      sec->size);
1837   free (contents);
1838   return retval;
1839 }
1840
1841 /* Return the width of FDE addresses.  This is the default implementation.  */
1842
1843 unsigned int
1844 _bfd_elf_eh_frame_address_size (bfd *abfd, asection *sec ATTRIBUTE_UNUSED)
1845 {
1846   return elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64 ? 8 : 4;
1847 }
1848
1849 /* Decide whether we can use a PC-relative encoding within the given
1850    EH frame section.  This is the default implementation.  */
1851
1852 bfd_boolean
1853 _bfd_elf_can_make_relative (bfd *input_bfd ATTRIBUTE_UNUSED,
1854                             struct bfd_link_info *info ATTRIBUTE_UNUSED,
1855                             asection *eh_frame_section ATTRIBUTE_UNUSED)
1856 {
1857   return TRUE;
1858 }
1859
1860 /* Select an encoding for the given address.  Preference is given to
1861    PC-relative addressing modes.  */
1862
1863 bfd_byte
1864 _bfd_elf_encode_eh_address (bfd *abfd ATTRIBUTE_UNUSED,
1865                             struct bfd_link_info *info ATTRIBUTE_UNUSED,
1866                             asection *osec, bfd_vma offset,
1867                             asection *loc_sec, bfd_vma loc_offset,
1868                             bfd_vma *encoded)
1869 {
1870   *encoded = osec->vma + offset -
1871     (loc_sec->output_section->vma + loc_sec->output_offset + loc_offset);
1872   return DW_EH_PE_pcrel | DW_EH_PE_sdata4;
1873 }