bfd/elf-eh-frame.c

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