bfd/elf-eh-frame.c

   1 /* .eh_frame section optimization.
   2    Copyright (C) 2001-2017 Free Software Foundation, Inc.
   3    Written by Jakub Jelinek <jakub@redhat.com>.
   4
   5    This file is part of BFD, the Binary File Descriptor library.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  20    MA 02110-1301, USA.  */
  21
  22 #include "sysdep.h"
  23 #include "bfd.h"
  24 #include "libbfd.h"
  25 #include "elf-bfd.h"
  26 #include "dwarf2.h"
  27
  28 #define EH_FRAME_HDR_SIZE 8
  29
  30 struct cie
  31 {
  32   unsigned int length;
  33   unsigned int hash;
  34   unsigned char version;
  35   unsigned char local_personality;
  36   char augmentation[20];
  37   bfd_vma code_align;
  38   bfd_signed_vma data_align;
  39   bfd_vma ra_column;
  40   bfd_vma augmentation_size;
  41   union {
  42     struct elf_link_hash_entry *h;
  43     struct {
  44       unsigned int bfd_id;
  45       unsigned int index;
  46     } sym;
  47     unsigned int reloc_index;
  48   } personality;
  49   struct eh_cie_fde *cie_inf;
  50   unsigned char per_encoding;
  51   unsigned char lsda_encoding;
  52   unsigned char fde_encoding;
  53   unsigned char initial_insn_length;
  54   unsigned char can_make_lsda_relative;
  55   unsigned char initial_instructions[50];
  56 };
  57
  58
  59
  60 /* If *ITER hasn't reached END yet, read the next byte into *RESULT and
  61    move onto the next byte.  Return true on success.  */
  62
  63 static inline bfd_boolean
  64 read_byte (bfd_byte **iter, bfd_byte *end, unsigned char *result)
  65 {
  66   if (*iter >= end)
  67     return FALSE;
  68   *result = *((*iter)++);
  69   return TRUE;
  70 }
  71
  72 /* Move *ITER over LENGTH bytes, or up to END, whichever is closer.
  73    Return true it was possible to move LENGTH bytes.  */
  74
  75 static inline bfd_boolean
  76 skip_bytes (bfd_byte **iter, bfd_byte *end, bfd_size_type length)
  77 {
  78   if ((bfd_size_type) (end - *iter) < length)
  79     {
  80       *iter = end;
  81       return FALSE;
  82     }
  83   *iter += length;
  84   return TRUE;
  85 }
  86
  87 /* Move *ITER over an leb128, stopping at END.  Return true if the end
  88    of the leb128 was found.  */
  89
  90 static bfd_boolean
  91 skip_leb128 (bfd_byte **iter, bfd_byte *end)
  92 {
  93   unsigned char byte;
  94   do
  95     if (!read_byte (iter, end, &byte))
  96       return FALSE;
  97   while (byte & 0x80);
  98   return TRUE;
  99 }
 100
 101 /* Like skip_leb128, but treat the leb128 as an unsigned value and
 102    store it in *VALUE.  */
 103
 104 static bfd_boolean
 105 read_uleb128 (bfd_byte **iter, bfd_byte *end, bfd_vma *value)
 106 {
 107   bfd_byte *start, *p;
 108
 109   start = *iter;
 110   if (!skip_leb128 (iter, end))
 111     return FALSE;
 112
 113   p = *iter;
 114   *value = *--p;
 115   while (p > start)
 116     *value = (*value << 7) | (*--p & 0x7f);
 117
 118   return TRUE;
 119 }
 120
 121 /* Like read_uleb128, but for signed values.  */
 122
 123 static bfd_boolean
 124 read_sleb128 (bfd_byte **iter, bfd_byte *end, bfd_signed_vma *value)
 125 {
 126   bfd_byte *start, *p;
 127
 128   start = *iter;
 129   if (!skip_leb128 (iter, end))
 130     return FALSE;
 131
 132   p = *iter;
 133   *value = ((*--p & 0x7f) ^ 0x40) - 0x40;
 134   while (p > start)
 135     *value = (*value << 7) | (*--p & 0x7f);
 136
 137   return TRUE;
 138 }
 139
 140 /* Return 0 if either encoding is variable width, or not yet known to bfd.  */
 141
 142 static
 143 int get_DW_EH_PE_width (int encoding, int ptr_size)
 144 {
 145   /* DW_EH_PE_ values of 0x60 and 0x70 weren't defined at the time .eh_frame
 146      was added to bfd.  */
 147   if ((encoding & 0x60) == 0x60)
 148     return 0;
 149
 150   switch (encoding & 7)
 151     {
 152     case DW_EH_PE_udata2: return 2;
 153     case DW_EH_PE_udata4: return 4;
 154     case DW_EH_PE_udata8: return 8;
 155     case DW_EH_PE_absptr: return ptr_size;
 156     default:
 157       break;
 158     }
 159
 160   return 0;
 161 }
 162
 163 #define get_DW_EH_PE_signed(encoding) (((encoding) & DW_EH_PE_signed) != 0)
 164
 165 /* Read a width sized value from memory.  */
 166
 167 static bfd_vma
 168 read_value (bfd *abfd, bfd_byte *buf, int width, int is_signed)
 169 {
 170   bfd_vma value;
 171
 172   switch (width)
 173     {
 174     case 2:
 175       if (is_signed)
 176         value = bfd_get_signed_16 (abfd, buf);
 177       else
 178         value = bfd_get_16 (abfd, buf);
 179       break;
 180     case 4:
 181       if (is_signed)
 182         value = bfd_get_signed_32 (abfd, buf);
 183       else
 184         value = bfd_get_32 (abfd, buf);
 185       break;
 186     case 8:
 187       if (is_signed)
 188         value = bfd_get_signed_64 (abfd, buf);
 189       else
 190         value = bfd_get_64 (abfd, buf);
 191       break;
 192     default:
 193       BFD_FAIL ();
 194       return 0;
 195     }
 196
 197   return value;
 198 }
 199
 200 /* Store a width sized value to memory.  */
 201
 202 static void
 203 write_value (bfd *abfd, bfd_byte *buf, bfd_vma value, int width)
 204 {
 205   switch (width)
 206     {
 207     case 2: bfd_put_16 (abfd, value, buf); break;
 208     case 4: bfd_put_32 (abfd, value, buf); break;
 209     case 8: bfd_put_64 (abfd, value, buf); break;
 210     default: BFD_FAIL ();
 211     }
 212 }
 213
 214 /* Return one if C1 and C2 CIEs can be merged.  */
 215
 216 static int
 217 cie_eq (const void *e1, const void *e2)
 218 {
 219   const struct cie *c1 = (const struct cie *) e1;
 220   const struct cie *c2 = (const struct cie *) e2;
 221
 222   if (c1->hash == c2->hash
 223       && c1->length == c2->length
 224       && c1->version == c2->version
 225       && c1->local_personality == c2->local_personality
 226       && strcmp (c1->augmentation, c2->augmentation) == 0
 227       && strcmp (c1->augmentation, "eh") != 0
 228       && c1->code_align == c2->code_align
 229       && c1->data_align == c2->data_align
 230       && c1->ra_column == c2->ra_column
 231       && c1->augmentation_size == c2->augmentation_size
 232       && memcmp (&c1->personality, &c2->personality,
 233                  sizeof (c1->personality)) == 0
 234       && (c1->cie_inf->u.cie.u.sec->output_section
 235           == c2->cie_inf->u.cie.u.sec->output_section)
 236       && c1->per_encoding == c2->per_encoding
 237       && c1->lsda_encoding == c2->lsda_encoding
 238       && c1->fde_encoding == c2->fde_encoding
 239       && c1->initial_insn_length == c2->initial_insn_length
 240       && c1->initial_insn_length <= sizeof (c1->initial_instructions)
 241       && memcmp (c1->initial_instructions,
 242                  c2->initial_instructions,
 243                  c1->initial_insn_length) == 0)
 244     return 1;
 245
 246   return 0;
 247 }
 248
 249 static hashval_t
 250 cie_hash (const void *e)
 251 {
 252   const struct cie *c = (const struct cie *) e;
 253   return c->hash;
 254 }
 255
 256 static hashval_t
 257 cie_compute_hash (struct cie *c)
 258 {
 259   hashval_t h = 0;
 260   size_t len;
 261   h = iterative_hash_object (c->length, h);
 262   h = iterative_hash_object (c->version, h);
 263   h = iterative_hash (c->augmentation, strlen (c->augmentation) + 1, h);
 264   h = iterative_hash_object (c->code_align, h);
 265   h = iterative_hash_object (c->data_align, h);
 266   h = iterative_hash_object (c->ra_column, h);
 267   h = iterative_hash_object (c->augmentation_size, h);
 268   h = iterative_hash_object (c->personality, h);
 269   h = iterative_hash_object (c->cie_inf->u.cie.u.sec->output_section, h);
 270   h = iterative_hash_object (c->per_encoding, h);
 271   h = iterative_hash_object (c->lsda_encoding, h);
 272   h = iterative_hash_object (c->fde_encoding, h);
 273   h = iterative_hash_object (c->initial_insn_length, h);
 274   len = c->initial_insn_length;
 275   if (len > sizeof (c->initial_instructions))
 276     len = sizeof (c->initial_instructions);
 277   h = iterative_hash (c->initial_instructions, len, h);
 278   c->hash = h;
 279   return h;
 280 }
 281
 282 /* Return the number of extra bytes that we'll be inserting into
 283    ENTRY's augmentation string.  */
 284
 285 static INLINE unsigned int
 286 extra_augmentation_string_bytes (struct eh_cie_fde *entry)
 287 {
 288   unsigned int size = 0;
 289   if (entry->cie)
 290     {
 291       if (entry->add_augmentation_size)
 292         size++;
 293       if (entry->u.cie.add_fde_encoding)
 294         size++;
 295     }
 296   return size;
 297 }
 298
 299 /* Likewise ENTRY's augmentation data.  */
 300
 301 static INLINE unsigned int
 302 extra_augmentation_data_bytes (struct eh_cie_fde *entry)
 303 {
 304   unsigned int size = 0;
 305   if (entry->add_augmentation_size)
 306     size++;
 307   if (entry->cie && entry->u.cie.add_fde_encoding)
 308     size++;
 309   return size;
 310 }
 311
 312 /* Return the size that ENTRY will have in the output.  */
 313
 314 static unsigned int
 315 size_of_output_cie_fde (struct eh_cie_fde *entry)
 316 {
 317   if (entry->removed)
 318     return 0;
 319   if (entry->size == 4)
 320     return 4;
 321   return (entry->size
 322           + extra_augmentation_string_bytes (entry)
 323           + extra_augmentation_data_bytes (entry));
 324 }
 325
 326 /* Return the offset of the FDE or CIE after ENT.  */
 327
 328 static unsigned int
 329 next_cie_fde_offset (struct eh_cie_fde *ent,
 330                      struct eh_cie_fde *last,
 331                      asection *sec)
 332 {
 333   while (++ent < last)
 334     {
 335       if (!ent->removed)
 336         return ent->new_offset;
 337     }
 338   return sec->size;
 339 }
 340
 341 /* Assume that the bytes between *ITER and END are CFA instructions.
 342    Try to move *ITER past the first instruction and return true on
 343    success.  ENCODED_PTR_WIDTH gives the width of pointer entries.  */
 344
 345 static bfd_boolean
 346 skip_cfa_op (bfd_byte **iter, bfd_byte *end, unsigned int encoded_ptr_width)
 347 {
 348   bfd_byte op;
 349   bfd_vma length;
 350
 351   if (!read_byte (iter, end, &op))
 352     return FALSE;
 353
 354   switch (op & 0xc0 ? op & 0xc0 : op)
 355     {
 356     case DW_CFA_nop:
 357     case DW_CFA_advance_loc:
 358     case DW_CFA_restore:
 359     case DW_CFA_remember_state:
 360     case DW_CFA_restore_state:
 361     case DW_CFA_GNU_window_save:
 362       /* No arguments.  */
 363       return TRUE;
 364
 365     case DW_CFA_offset:
 366     case DW_CFA_restore_extended:
 367     case DW_CFA_undefined:
 368     case DW_CFA_same_value:
 369     case DW_CFA_def_cfa_register:
 370     case DW_CFA_def_cfa_offset:
 371     case DW_CFA_def_cfa_offset_sf:
 372     case DW_CFA_GNU_args_size:
 373       /* One leb128 argument.  */
 374       return skip_leb128 (iter, end);
 375
 376     case DW_CFA_val_offset:
 377     case DW_CFA_val_offset_sf:
 378     case DW_CFA_offset_extended:
 379     case DW_CFA_register:
 380     case DW_CFA_def_cfa:
 381     case DW_CFA_offset_extended_sf:
 382     case DW_CFA_GNU_negative_offset_extended:
 383     case DW_CFA_def_cfa_sf:
 384       /* Two leb128 arguments.  */
 385       return (skip_leb128 (iter, end)
 386               && skip_leb128 (iter, end));
 387
 388     case DW_CFA_def_cfa_expression:
 389       /* A variable-length argument.  */
 390       return (read_uleb128 (iter, end, &length)
 391               && skip_bytes (iter, end, length));
 392
 393     case DW_CFA_expression:
 394     case DW_CFA_val_expression:
 395       /* A leb128 followed by a variable-length argument.  */
 396       return (skip_leb128 (iter, end)
 397               && read_uleb128 (iter, end, &length)
 398               && skip_bytes (iter, end, length));
 399
 400     case DW_CFA_set_loc:
 401       return skip_bytes (iter, end, encoded_ptr_width);
 402
 403     case DW_CFA_advance_loc1:
 404       return skip_bytes (iter, end, 1);
 405
 406     case DW_CFA_advance_loc2:
 407       return skip_bytes (iter, end, 2);
 408
 409     case DW_CFA_advance_loc4:
 410       return skip_bytes (iter, end, 4);
 411
 412     case DW_CFA_MIPS_advance_loc8:
 413       return skip_bytes (iter, end, 8);
 414
 415     default:
 416       return FALSE;
 417     }
 418 }
 419
 420 /* Try to interpret the bytes between BUF and END as CFA instructions.
 421    If every byte makes sense, return a pointer to the first DW_CFA_nop
 422    padding byte, or END if there is no padding.  Return null otherwise.
 423    ENCODED_PTR_WIDTH is as for skip_cfa_op.  */
 424
 425 static bfd_byte *
 426 skip_non_nops (bfd_byte *buf, bfd_byte *end, unsigned int encoded_ptr_width,
 427                unsigned int *set_loc_count)
 428 {
 429   bfd_byte *last;
 430
 431   last = buf;
 432   while (buf < end)
 433     if (*buf == DW_CFA_nop)
 434       buf++;
 435     else
 436       {
 437         if (*buf == DW_CFA_set_loc)
 438           ++*set_loc_count;
 439         if (!skip_cfa_op (&buf, end, encoded_ptr_width))
 440           return 0;
 441         last = buf;
 442       }
 443   return last;
 444 }
 445
 446 /* Convert absolute encoding ENCODING into PC-relative form.
 447    SIZE is the size of a pointer.  */
 448
 449 static unsigned char
 450 make_pc_relative (unsigned char encoding, unsigned int ptr_size)
 451 {
 452   if ((encoding & 0x7f) == DW_EH_PE_absptr)
 453     switch (ptr_size)
 454       {
 455       case 2:
 456         encoding |= DW_EH_PE_sdata2;
 457         break;
 458       case 4:
 459         encoding |= DW_EH_PE_sdata4;
 460         break;
 461       case 8:
 462         encoding |= DW_EH_PE_sdata8;
 463         break;
 464       }
 465   return encoding | DW_EH_PE_pcrel;
 466 }
 467
 468 /*  Examine each .eh_frame_entry section and discard those
 469     those that are marked SEC_EXCLUDE.  */
 470
 471 static void
 472 bfd_elf_discard_eh_frame_entry (struct eh_frame_hdr_info *hdr_info)
 473 {
 474   unsigned int i;
 475   for (i = 0; i < hdr_info->array_count; i++)
 476     {
 477       if (hdr_info->u.compact.entries[i]->flags & SEC_EXCLUDE)
 478         {
 479           unsigned int j;
 480           for (j = i + 1; j < hdr_info->array_count; j++)
 481             hdr_info->u.compact.entries[j-1] = hdr_info->u.compact.entries[j];
 482
 483           hdr_info->array_count--;
 484           hdr_info->u.compact.entries[hdr_info->array_count] = NULL;
 485           i--;
 486         }
 487     }
 488 }
 489
 490 /* Add a .eh_frame_entry section.  */
 491
 492 static void
 493 bfd_elf_record_eh_frame_entry (struct eh_frame_hdr_info *hdr_info,
 494                                  asection *sec)
 495 {
 496   if (hdr_info->array_count == hdr_info->u.compact.allocated_entries)
 497     {
 498       if (hdr_info->u.compact.allocated_entries == 0)
 499         {
 500           hdr_info->frame_hdr_is_compact = TRUE;
 501           hdr_info->u.compact.allocated_entries = 2;
 502           hdr_info->u.compact.entries =
 503             bfd_malloc (hdr_info->u.compact.allocated_entries
 504                         * sizeof (hdr_info->u.compact.entries[0]));
 505         }
 506       else
 507         {
 508           hdr_info->u.compact.allocated_entries *= 2;
 509           hdr_info->u.compact.entries =
 510             bfd_realloc (hdr_info->u.compact.entries,
 511                          hdr_info->u.compact.allocated_entries
 512                            * sizeof (hdr_info->u.compact.entries[0]));
 513         }
 514
 515       BFD_ASSERT (hdr_info->u.compact.entries);
 516     }
 517
 518   hdr_info->u.compact.entries[hdr_info->array_count++] = sec;
 519 }
 520
 521 /* Parse a .eh_frame_entry section.  Figure out which text section it
 522    references.  */
 523
 524 bfd_boolean
 525 _bfd_elf_parse_eh_frame_entry (struct bfd_link_info *info,
 526                                asection *sec, struct elf_reloc_cookie *cookie)
 527 {
 528   struct elf_link_hash_table *htab;
 529   struct eh_frame_hdr_info *hdr_info;
 530   unsigned long r_symndx;
 531   asection *text_sec;
 532
 533   htab = elf_hash_table (info);
 534   hdr_info = &htab->eh_info;
 535
 536   if (sec->size == 0
 537       || sec->sec_info_type != SEC_INFO_TYPE_NONE)
 538     {
 539       return TRUE;
 540     }
 541
 542   if (sec->output_section && bfd_is_abs_section (sec->output_section))
 543     {
 544       /* At least one of the sections is being discarded from the
 545          link, so we should just ignore them.  */
 546       return TRUE;
 547     }
 548
 549   if (cookie->rel == cookie->relend)
 550     return FALSE;
 551
 552   /* The first relocation is the function start.  */
 553   r_symndx = cookie->rel->r_info >> cookie->r_sym_shift;
 554   if (r_symndx == STN_UNDEF)
 555     return FALSE;
 556
 557   text_sec = _bfd_elf_section_for_symbol (cookie, r_symndx, FALSE);
 558
 559   if (text_sec == NULL)
 560     return FALSE;
 561
 562   elf_section_eh_frame_entry (text_sec) = sec;
 563   if (text_sec->output_section
 564       && bfd_is_abs_section (text_sec->output_section))
 565     sec->flags |= SEC_EXCLUDE;
 566
 567   sec->sec_info_type = SEC_INFO_TYPE_EH_FRAME_ENTRY;
 568   elf_section_data (sec)->sec_info = text_sec;
 569   bfd_elf_record_eh_frame_entry (hdr_info, sec);
 570   return TRUE;
 571 }
 572
 573 /* Try to parse .eh_frame section SEC, which belongs to ABFD.  Store the
 574    information in the section's sec_info field on success.  COOKIE
 575    describes the relocations in SEC.  */
 576
 577 void
 578 _bfd_elf_parse_eh_frame (bfd *abfd, struct bfd_link_info *info,
 579                          asection *sec, struct elf_reloc_cookie *cookie)
 580 {
 581 #define REQUIRE(COND)                                   \
 582   do                                                    \
 583     if (!(COND))                                        \
 584       goto free_no_table;                               \
 585   while (0)
 586
 587   bfd_byte *ehbuf = NULL, *buf, *end;
 588   bfd_byte *last_fde;
 589   struct eh_cie_fde *this_inf;
 590   unsigned int hdr_length, hdr_id;
 591   unsigned int cie_count;
 592   struct cie *cie, *local_cies = NULL;
 593   struct elf_link_hash_table *htab;
 594   struct eh_frame_hdr_info *hdr_info;
 595   struct eh_frame_sec_info *sec_info = NULL;
 596   unsigned int ptr_size;
 597   unsigned int num_cies;
 598   unsigned int num_entries;
 599   elf_gc_mark_hook_fn gc_mark_hook;
 600
 601   htab = elf_hash_table (info);
 602   hdr_info = &htab->eh_info;
 603
 604   if (sec->size == 0
 605       || sec->sec_info_type != SEC_INFO_TYPE_NONE)
 606     {
 607       /* This file does not contain .eh_frame information.  */
 608       return;
 609     }
 610
 611   if (bfd_is_abs_section (sec->output_section))
 612     {
 613       /* At least one of the sections is being discarded from the
 614          link, so we should just ignore them.  */
 615       return;
 616     }
 617
 618   /* Read the frame unwind information from abfd.  */
 619
 620   REQUIRE (bfd_malloc_and_get_section (abfd, sec, &ehbuf));
 621
 622   if (sec->size >= 4
 623       && bfd_get_32 (abfd, ehbuf) == 0
 624       && cookie->rel == cookie->relend)
 625     {
 626       /* Empty .eh_frame section.  */
 627       free (ehbuf);
 628       return;
 629     }
 630
 631   /* If .eh_frame section size doesn't fit into int, we cannot handle
 632      it (it would need to use 64-bit .eh_frame format anyway).  */
 633   REQUIRE (sec->size == (unsigned int) sec->size);
 634
 635   ptr_size = (get_elf_backend_data (abfd)
 636               ->elf_backend_eh_frame_address_size (abfd, sec));
 637   REQUIRE (ptr_size != 0);
 638
 639   /* Go through the section contents and work out how many FDEs and
 640      CIEs there are.  */
 641   buf = ehbuf;
 642   end = ehbuf + sec->size;
 643   num_cies = 0;
 644   num_entries = 0;
 645   while (buf != end)
 646     {
 647       num_entries++;
 648
 649       /* Read the length of the entry.  */
 650       REQUIRE (skip_bytes (&buf, end, 4));
 651       hdr_length = bfd_get_32 (abfd, buf - 4);
 652
 653       /* 64-bit .eh_frame is not supported.  */
 654       REQUIRE (hdr_length != 0xffffffff);
 655       if (hdr_length == 0)
 656         break;
 657
 658       REQUIRE (skip_bytes (&buf, end, 4));
 659       hdr_id = bfd_get_32 (abfd, buf - 4);
 660       if (hdr_id == 0)
 661         num_cies++;
 662
 663       REQUIRE (skip_bytes (&buf, end, hdr_length - 4));
 664     }
 665
 666   sec_info = (struct eh_frame_sec_info *)
 667       bfd_zmalloc (sizeof (struct eh_frame_sec_info)
 668                    + (num_entries - 1) * sizeof (struct eh_cie_fde));
 669   REQUIRE (sec_info);
 670
 671   /* We need to have a "struct cie" for each CIE in this section.  */
 672   local_cies = (struct cie *) bfd_zmalloc (num_cies * sizeof (*local_cies));
 673   REQUIRE (local_cies);
 674
 675   /* FIXME: octets_per_byte.  */
 676 #define ENSURE_NO_RELOCS(buf)                           \
 677   while (cookie->rel < cookie->relend                   \
 678          && (cookie->rel->r_offset                      \
 679              < (bfd_size_type) ((buf) - ehbuf)))        \
 680     {                                                   \
 681       REQUIRE (cookie->rel->r_info == 0);               \
 682       cookie->rel++;                                    \
 683     }
 684
 685   /* FIXME: octets_per_byte.  */
 686 #define SKIP_RELOCS(buf)                                \
 687   while (cookie->rel < cookie->relend                   \
 688          && (cookie->rel->r_offset                      \
 689              < (bfd_size_type) ((buf) - ehbuf)))        \
 690     cookie->rel++
 691
 692   /* FIXME: octets_per_byte.  */
 693 #define GET_RELOC(buf)                                  \
 694   ((cookie->rel < cookie->relend                        \
 695     && (cookie->rel->r_offset                           \
 696         == (bfd_size_type) ((buf) - ehbuf)))            \
 697    ? cookie->rel : NULL)
 698
 699   buf = ehbuf;
 700   cie_count = 0;
 701   gc_mark_hook = get_elf_backend_data (abfd)->gc_mark_hook;
 702   while ((bfd_size_type) (buf - ehbuf) != sec->size)
 703     {
 704       char *aug;
 705       bfd_byte *start, *insns, *insns_end;
 706       bfd_size_type length;
 707       unsigned int set_loc_count;
 708
 709       this_inf = sec_info->entry + sec_info->count;
 710       last_fde = buf;
 711
 712       /* Read the length of the entry.  */
 713       REQUIRE (skip_bytes (&buf, ehbuf + sec->size, 4));
 714       hdr_length = bfd_get_32 (abfd, buf - 4);
 715
 716       /* The CIE/FDE must be fully contained in this input section.  */
 717       REQUIRE ((bfd_size_type) (buf - ehbuf) + hdr_length <= sec->size);
 718       end = buf + hdr_length;
 719
 720       this_inf->offset = last_fde - ehbuf;
 721       this_inf->size = 4 + hdr_length;
 722       this_inf->reloc_index = cookie->rel - cookie->rels;
 723
 724       if (hdr_length == 0)
 725         {
 726           /* A zero-length CIE should only be found at the end of
 727              the section.  */
 728           REQUIRE ((bfd_size_type) (buf - ehbuf) == sec->size);
 729           ENSURE_NO_RELOCS (buf);
 730           sec_info->count++;
 731           break;
 732         }
 733
 734       REQUIRE (skip_bytes (&buf, end, 4));
 735       hdr_id = bfd_get_32 (abfd, buf - 4);
 736
 737       if (hdr_id == 0)
 738         {
 739           unsigned int initial_insn_length;
 740
 741           /* CIE  */
 742           this_inf->cie = 1;
 743
 744           /* Point CIE to one of the section-local cie structures.  */
 745           cie = local_cies + cie_count++;
 746
 747           cie->cie_inf = this_inf;
 748           cie->length = hdr_length;
 749           start = buf;
 750           REQUIRE (read_byte (&buf, end, &cie->version));
 751
 752           /* Cannot handle unknown versions.  */
 753           REQUIRE (cie->version == 1
 754                    || cie->version == 3
 755                    || cie->version == 4);
 756           REQUIRE (strlen ((char *) buf) < sizeof (cie->augmentation));
 757
 758           strcpy (cie->augmentation, (char *) buf);
 759           buf = (bfd_byte *) strchr ((char *) buf, '\0') + 1;
 760           ENSURE_NO_RELOCS (buf);
 761           if (buf[0] == 'e' && buf[1] == 'h')
 762             {
 763               /* GCC < 3.0 .eh_frame CIE */
 764               /* We cannot merge "eh" CIEs because __EXCEPTION_TABLE__
 765                  is private to each CIE, so we don't need it for anything.
 766                  Just skip it.  */
 767               REQUIRE (skip_bytes (&buf, end, ptr_size));
 768               SKIP_RELOCS (buf);
 769             }
 770           if (cie->version >= 4)
 771             {
 772               REQUIRE (buf + 1 < end);
 773               REQUIRE (buf[0] == ptr_size);
 774               REQUIRE (buf[1] == 0);
 775               buf += 2;
 776             }
 777           REQUIRE (read_uleb128 (&buf, end, &cie->code_align));
 778           REQUIRE (read_sleb128 (&buf, end, &cie->data_align));
 779           if (cie->version == 1)
 780             {
 781               REQUIRE (buf < end);
 782               cie->ra_column = *buf++;
 783             }
 784           else
 785             REQUIRE (read_uleb128 (&buf, end, &cie->ra_column));
 786           ENSURE_NO_RELOCS (buf);
 787           cie->lsda_encoding = DW_EH_PE_omit;
 788           cie->fde_encoding = DW_EH_PE_omit;
 789           cie->per_encoding = DW_EH_PE_omit;
 790           aug = cie->augmentation;
 791           if (aug[0] != 'e' || aug[1] != 'h')
 792             {
 793               if (*aug == 'z')
 794                 {
 795                   aug++;
 796                   REQUIRE (read_uleb128 (&buf, end, &cie->augmentation_size));
 797                   ENSURE_NO_RELOCS (buf);
 798                 }
 799
 800               while (*aug != '\0')
 801                 switch (*aug++)
 802                   {
 803                   case 'L':
 804                     REQUIRE (read_byte (&buf, end, &cie->lsda_encoding));
 805                     ENSURE_NO_RELOCS (buf);
 806                     REQUIRE (get_DW_EH_PE_width (cie->lsda_encoding, ptr_size));
 807                     break;
 808                   case 'R':
 809                     REQUIRE (read_byte (&buf, end, &cie->fde_encoding));
 810                     ENSURE_NO_RELOCS (buf);
 811                     REQUIRE (get_DW_EH_PE_width (cie->fde_encoding, ptr_size));
 812                     break;
 813                   case 'S':
 814                     break;
 815                   case 'P':
 816                     {
 817                       int per_width;
 818
 819                       REQUIRE (read_byte (&buf, end, &cie->per_encoding));
 820                       per_width = get_DW_EH_PE_width (cie->per_encoding,
 821                                                       ptr_size);
 822                       REQUIRE (per_width);
 823                       if ((cie->per_encoding & 0x70) == DW_EH_PE_aligned)
 824                         {
 825                           length = -(buf - ehbuf) & (per_width - 1);
 826                           REQUIRE (skip_bytes (&buf, end, length));
 827                           if (per_width == 8)
 828                             this_inf->u.cie.per_encoding_aligned8 = 1;
 829                         }
 830                       this_inf->u.cie.personality_offset = buf - start;
 831                       ENSURE_NO_RELOCS (buf);
 832                       /* Ensure we have a reloc here.  */
 833                       REQUIRE (GET_RELOC (buf));
 834                       cie->personality.reloc_index
 835                         = cookie->rel - cookie->rels;
 836                       /* Cope with MIPS-style composite relocations.  */
 837                       do
 838                         cookie->rel++;
 839                       while (GET_RELOC (buf) != NULL);
 840                       REQUIRE (skip_bytes (&buf, end, per_width));
 841                     }
 842                     break;
 843                   default:
 844                     /* Unrecognized augmentation. Better bail out.  */
 845                     goto free_no_table;
 846                   }
 847             }
 848
 849           /* For shared libraries, try to get rid of as many RELATIVE relocs
 850              as possible.  */
 851           if (bfd_link_pic (info)
 852               && (get_elf_backend_data (abfd)
 853                   ->elf_backend_can_make_relative_eh_frame
 854                   (abfd, info, sec)))
 855             {
 856               if ((cie->fde_encoding & 0x70) == DW_EH_PE_absptr)
 857                 this_inf->make_relative = 1;
 858               /* If the CIE doesn't already have an 'R' entry, it's fairly
 859                  easy to add one, provided that there's no aligned data
 860                  after the augmentation string.  */
 861               else if (cie->fde_encoding == DW_EH_PE_omit
 862                        && (cie->per_encoding & 0x70) != DW_EH_PE_aligned)
 863                 {
 864                   if (*cie->augmentation == 0)
 865                     this_inf->add_augmentation_size = 1;
 866                   this_inf->u.cie.add_fde_encoding = 1;
 867                   this_inf->make_relative = 1;
 868                 }
 869
 870               if ((cie->lsda_encoding & 0x70) == DW_EH_PE_absptr)
 871                 cie->can_make_lsda_relative = 1;
 872             }
 873
 874           /* If FDE encoding was not specified, it defaults to
 875              DW_EH_absptr.  */
 876           if (cie->fde_encoding == DW_EH_PE_omit)
 877             cie->fde_encoding = DW_EH_PE_absptr;
 878
 879           initial_insn_length = end - buf;
 880           cie->initial_insn_length = initial_insn_length;
 881           memcpy (cie->initial_instructions, buf,
 882                   initial_insn_length <= sizeof (cie->initial_instructions)
 883                   ? initial_insn_length : sizeof (cie->initial_instructions));
 884           insns = buf;
 885           buf += initial_insn_length;
 886           ENSURE_NO_RELOCS (buf);
 887
 888           if (!bfd_link_relocatable (info))
 889             {
 890               /* Keep info for merging cies.  */
 891               this_inf->u.cie.u.full_cie = cie;
 892               this_inf->u.cie.per_encoding_relative
 893                 = (cie->per_encoding & 0x70) == DW_EH_PE_pcrel;
 894             }
 895         }
 896       else
 897         {
 898           /* Find the corresponding CIE.  */
 899           unsigned int cie_offset = this_inf->offset + 4 - hdr_id;
 900           for (cie = local_cies; cie < local_cies + cie_count; cie++)
 901             if (cie_offset == cie->cie_inf->offset)
 902               break;
 903
 904           /* Ensure this FDE references one of the CIEs in this input
 905              section.  */
 906           REQUIRE (cie != local_cies + cie_count);
 907           this_inf->u.fde.cie_inf = cie->cie_inf;
 908           this_inf->make_relative = cie->cie_inf->make_relative;
 909           this_inf->add_augmentation_size
 910             = cie->cie_inf->add_augmentation_size;
 911
 912           ENSURE_NO_RELOCS (buf);
 913           if ((sec->flags & SEC_LINKER_CREATED) == 0 || cookie->rels != NULL)
 914             {
 915               asection *rsec;
 916
 917               REQUIRE (GET_RELOC (buf));
 918
 919               /* Chain together the FDEs for each section.  */
 920               rsec = _bfd_elf_gc_mark_rsec (info, sec, gc_mark_hook,
 921                                             cookie, NULL);
 922               /* RSEC will be NULL if FDE was cleared out as it was belonging to
 923                  a discarded SHT_GROUP.  */
 924               if (rsec)
 925                 {
 926                   REQUIRE (rsec->owner == abfd);
 927                   this_inf->u.fde.next_for_section = elf_fde_list (rsec);
 928                   elf_fde_list (rsec) = this_inf;
 929                 }
 930             }
 931
 932           /* Skip the initial location and address range.  */
 933           start = buf;
 934           length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
 935           REQUIRE (skip_bytes (&buf, end, 2 * length));
 936
 937           SKIP_RELOCS (buf - length);
 938           if (!GET_RELOC (buf - length)
 939               && read_value (abfd, buf - length, length, FALSE) == 0)
 940             {
 941               (*info->callbacks->minfo)
 942                 /* xgettext:c-format */
 943                 (_("discarding zero address range FDE in %B(%A).\n"),
 944                  abfd, sec);
 945               this_inf->u.fde.cie_inf = NULL;
 946             }
 947
 948           /* Skip the augmentation size, if present.  */
 949           if (cie->augmentation[0] == 'z')
 950             REQUIRE (read_uleb128 (&buf, end, &length));
 951           else
 952             length = 0;
 953
 954           /* Of the supported augmentation characters above, only 'L'
 955              adds augmentation data to the FDE.  This code would need to
 956              be adjusted if any future augmentations do the same thing.  */
 957           if (cie->lsda_encoding != DW_EH_PE_omit)
 958             {
 959               SKIP_RELOCS (buf);
 960               if (cie->can_make_lsda_relative && GET_RELOC (buf))
 961                 cie->cie_inf->u.cie.make_lsda_relative = 1;
 962               this_inf->lsda_offset = buf - start;
 963               /* If there's no 'z' augmentation, we don't know where the
 964                  CFA insns begin.  Assume no padding.  */
 965               if (cie->augmentation[0] != 'z')
 966                 length = end - buf;
 967             }
 968
 969           /* Skip over the augmentation data.  */
 970           REQUIRE (skip_bytes (&buf, end, length));
 971           insns = buf;
 972
 973           buf = last_fde + 4 + hdr_length;
 974
 975           /* For NULL RSEC (cleared FDE belonging to a discarded section)
 976              the relocations are commonly cleared.  We do not sanity check if
 977              all these relocations are cleared as (1) relocations to
 978              .gcc_except_table will remain uncleared (they will get dropped
 979              with the drop of this unused FDE) and (2) BFD already safely drops
 980              relocations of any type to .eh_frame by
 981              elf_section_ignore_discarded_relocs.
 982              TODO: The .gcc_except_table entries should be also filtered as
 983              .eh_frame entries; or GCC could rather use COMDAT for them.  */
 984           SKIP_RELOCS (buf);
 985         }
 986
 987       /* Try to interpret the CFA instructions and find the first
 988          padding nop.  Shrink this_inf's size so that it doesn't
 989          include the padding.  */
 990       length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
 991       set_loc_count = 0;
 992       insns_end = skip_non_nops (insns, end, length, &set_loc_count);
 993       /* If we don't understand the CFA instructions, we can't know
 994          what needs to be adjusted there.  */
 995       if (insns_end == NULL
 996           /* For the time being we don't support DW_CFA_set_loc in
 997              CIE instructions.  */
 998           || (set_loc_count && this_inf->cie))
 999         goto free_no_table;
1000       this_inf->size -= end - insns_end;
1001       if (insns_end != end && this_inf->cie)
1002         {
1003           cie->initial_insn_length -= end - insns_end;
1004           cie->length -= end - insns_end;
1005         }
1006       if (set_loc_count
1007           && ((cie->fde_encoding & 0x70) == DW_EH_PE_pcrel
1008               || this_inf->make_relative))
1009         {
1010           unsigned int cnt;
1011           bfd_byte *p;
1012
1013           this_inf->set_loc = (unsigned int *)
1014               bfd_malloc ((set_loc_count + 1) * sizeof (unsigned int));
1015           REQUIRE (this_inf->set_loc);
1016           this_inf->set_loc[0] = set_loc_count;
1017           p = insns;
1018           cnt = 0;
1019           while (p < end)
1020             {
1021               if (*p == DW_CFA_set_loc)
1022                 this_inf->set_loc[++cnt] = p + 1 - start;
1023               REQUIRE (skip_cfa_op (&p, end, length));
1024             }
1025         }
1026
1027       this_inf->removed = 1;
1028       this_inf->fde_encoding = cie->fde_encoding;
1029       this_inf->lsda_encoding = cie->lsda_encoding;
1030       sec_info->count++;
1031     }
1032   BFD_ASSERT (sec_info->count == num_entries);
1033   BFD_ASSERT (cie_count == num_cies);
1034
1035   elf_section_data (sec)->sec_info = sec_info;
1036   sec->sec_info_type = SEC_INFO_TYPE_EH_FRAME;
1037   if (!bfd_link_relocatable (info))
1038     {
1039       /* Keep info for merging cies.  */
1040       sec_info->cies = local_cies;
1041       local_cies = NULL;
1042     }
1043   goto success;
1044
1045  free_no_table:
1046   (*info->callbacks->einfo)
1047     /* xgettext:c-format */
1048     (_("%P: error in %B(%A); no .eh_frame_hdr table will be created.\n"),
1049      abfd, sec);
1050   hdr_info->u.dwarf.table = FALSE;
1051   if (sec_info)
1052     free (sec_info);
1053  success:
1054   if (ehbuf)
1055     free (ehbuf);
1056   if (local_cies)
1057     free (local_cies);
1058 #undef REQUIRE
1059 }
1060
1061 /* Order eh_frame_hdr entries by the VMA of their text section.  */
1062
1063 static int
1064 cmp_eh_frame_hdr (const void *a, const void *b)
1065 {
1066   bfd_vma text_a;
1067   bfd_vma text_b;
1068   asection *sec;
1069
1070   sec = *(asection *const *)a;
1071   sec = (asection *) elf_section_data (sec)->sec_info;
1072   text_a = sec->output_section->vma + sec->output_offset;
1073   sec = *(asection *const *)b;
1074   sec = (asection *) elf_section_data (sec)->sec_info;
1075   text_b = sec->output_section->vma + sec->output_offset;
1076
1077   if (text_a < text_b)
1078     return -1;
1079   return text_a > text_b;
1080
1081 }
1082
1083 /* Add space for a CANTUNWIND terminator to SEC if the text sections
1084    referenced by it and NEXT are not contiguous, or NEXT is NULL.  */
1085
1086 static void
1087 add_eh_frame_hdr_terminator (asection *sec,
1088                              asection *next)
1089 {
1090   bfd_vma end;
1091   bfd_vma next_start;
1092   asection *text_sec;
1093
1094   if (next)
1095     {
1096       /* See if there is a gap (presumably a text section without unwind info)
1097          between these two entries.  */
1098       text_sec = (asection *) elf_section_data (sec)->sec_info;
1099       end = text_sec->output_section->vma + text_sec->output_offset
1100             + text_sec->size;
1101       text_sec = (asection *) elf_section_data (next)->sec_info;
1102       next_start = text_sec->output_section->vma + text_sec->output_offset;
1103       if (end == next_start)
1104         return;
1105     }
1106
1107   /* Add space for a CANTUNWIND terminator.  */
1108   if (!sec->rawsize)
1109     sec->rawsize = sec->size;
1110
1111   bfd_set_section_size (sec->owner, sec, sec->size + 8);
1112 }
1113
1114 /* Finish a pass over all .eh_frame_entry sections.  */
1115
1116 bfd_boolean
1117 _bfd_elf_end_eh_frame_parsing (struct bfd_link_info *info)
1118 {
1119   struct eh_frame_hdr_info *hdr_info;
1120   unsigned int i;
1121
1122   hdr_info = &elf_hash_table (info)->eh_info;
1123
1124   if (info->eh_frame_hdr_type != COMPACT_EH_HDR
1125       || hdr_info->array_count == 0)
1126     return FALSE;
1127
1128   bfd_elf_discard_eh_frame_entry (hdr_info);
1129
1130   qsort (hdr_info->u.compact.entries, hdr_info->array_count,
1131          sizeof (asection *), cmp_eh_frame_hdr);
1132
1133   for (i = 0; i < hdr_info->array_count - 1; i++)
1134     {
1135       add_eh_frame_hdr_terminator (hdr_info->u.compact.entries[i],
1136                                    hdr_info->u.compact.entries[i + 1]);
1137     }
1138
1139   /* Add a CANTUNWIND terminator after the last entry.  */
1140   add_eh_frame_hdr_terminator (hdr_info->u.compact.entries[i], NULL);
1141   return TRUE;
1142 }
1143
1144 /* Mark all relocations against CIE or FDE ENT, which occurs in
1145    .eh_frame section SEC.  COOKIE describes the relocations in SEC;
1146    its "rel" field can be changed freely.  */
1147
1148 static bfd_boolean
1149 mark_entry (struct bfd_link_info *info, asection *sec,
1150             struct eh_cie_fde *ent, elf_gc_mark_hook_fn gc_mark_hook,
1151             struct elf_reloc_cookie *cookie)
1152 {
1153   /* FIXME: octets_per_byte.  */
1154   for (cookie->rel = cookie->rels + ent->reloc_index;
1155        cookie->rel < cookie->relend
1156          && cookie->rel->r_offset < ent->offset + ent->size;
1157        cookie->rel++)
1158     if (!_bfd_elf_gc_mark_reloc (info, sec, gc_mark_hook, cookie))
1159       return FALSE;
1160
1161   return TRUE;
1162 }
1163
1164 /* Mark all the relocations against FDEs that relate to code in input
1165    section SEC.  The FDEs belong to .eh_frame section EH_FRAME, whose
1166    relocations are described by COOKIE.  */
1167
1168 bfd_boolean
1169 _bfd_elf_gc_mark_fdes (struct bfd_link_info *info, asection *sec,
1170                        asection *eh_frame, elf_gc_mark_hook_fn gc_mark_hook,
1171                        struct elf_reloc_cookie *cookie)
1172 {
1173   struct eh_cie_fde *fde, *cie;
1174
1175   for (fde = elf_fde_list (sec); fde; fde = fde->u.fde.next_for_section)
1176     {
1177       if (!mark_entry (info, eh_frame, fde, gc_mark_hook, cookie))
1178         return FALSE;
1179
1180       /* At this stage, all cie_inf fields point to local CIEs, so we
1181          can use the same cookie to refer to them.  */
1182       cie = fde->u.fde.cie_inf;
1183       if (cie != NULL && !cie->u.cie.gc_mark)
1184         {
1185           cie->u.cie.gc_mark = 1;
1186           if (!mark_entry (info, eh_frame, cie, gc_mark_hook, cookie))
1187             return FALSE;
1188         }
1189     }
1190   return TRUE;
1191 }
1192
1193 /* Input section SEC of ABFD is an .eh_frame section that contains the
1194    CIE described by CIE_INF.  Return a version of CIE_INF that is going
1195    to be kept in the output, adding CIE_INF to the output if necessary.
1196
1197    HDR_INFO is the .eh_frame_hdr information and COOKIE describes the
1198    relocations in REL.  */
1199
1200 static struct eh_cie_fde *
1201 find_merged_cie (bfd *abfd, struct bfd_link_info *info, asection *sec,
1202                  struct eh_frame_hdr_info *hdr_info,
1203                  struct elf_reloc_cookie *cookie,
1204                  struct eh_cie_fde *cie_inf)
1205 {
1206   unsigned long r_symndx;
1207   struct cie *cie, *new_cie;
1208   Elf_Internal_Rela *rel;
1209   void **loc;
1210
1211   /* Use CIE_INF if we have already decided to keep it.  */
1212   if (!cie_inf->removed)
1213     return cie_inf;
1214
1215   /* If we have merged CIE_INF with another CIE, use that CIE instead.  */
1216   if (cie_inf->u.cie.merged)
1217     return cie_inf->u.cie.u.merged_with;
1218
1219   cie = cie_inf->u.cie.u.full_cie;
1220
1221   /* Assume we will need to keep CIE_INF.  */
1222   cie_inf->removed = 0;
1223   cie_inf->u.cie.u.sec = sec;
1224
1225   /* If we are not merging CIEs, use CIE_INF.  */
1226   if (cie == NULL)
1227     return cie_inf;
1228
1229   if (cie->per_encoding != DW_EH_PE_omit)
1230     {
1231       bfd_boolean per_binds_local;
1232
1233       /* Work out the address of personality routine, or at least
1234          enough info that we could calculate the address had we made a
1235          final section layout.  The symbol on the reloc is enough,
1236          either the hash for a global, or (bfd id, index) pair for a
1237          local.  The assumption here is that no one uses addends on
1238          the reloc.  */
1239       rel = cookie->rels + cie->personality.reloc_index;
1240       memset (&cie->personality, 0, sizeof (cie->personality));
1241 #ifdef BFD64
1242       if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64)
1243         r_symndx = ELF64_R_SYM (rel->r_info);
1244       else
1245 #endif
1246         r_symndx = ELF32_R_SYM (rel->r_info);
1247       if (r_symndx >= cookie->locsymcount
1248           || ELF_ST_BIND (cookie->locsyms[r_symndx].st_info) != STB_LOCAL)
1249         {
1250           struct elf_link_hash_entry *h;
1251
1252           r_symndx -= cookie->extsymoff;
1253           h = cookie->sym_hashes[r_symndx];
1254
1255           while (h->root.type == bfd_link_hash_indirect
1256                  || h->root.type == bfd_link_hash_warning)
1257             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1258
1259           cie->personality.h = h;
1260           per_binds_local = SYMBOL_REFERENCES_LOCAL (info, h);
1261         }
1262       else
1263         {
1264           Elf_Internal_Sym *sym;
1265           asection *sym_sec;
1266
1267           sym = &cookie->locsyms[r_symndx];
1268           sym_sec = bfd_section_from_elf_index (abfd, sym->st_shndx);
1269           if (sym_sec == NULL)
1270             return cie_inf;
1271
1272           if (sym_sec->kept_section != NULL)
1273             sym_sec = sym_sec->kept_section;
1274           if (sym_sec->output_section == NULL)
1275             return cie_inf;
1276
1277           cie->local_personality = 1;
1278           cie->personality.sym.bfd_id = abfd->id;
1279           cie->personality.sym.index = r_symndx;
1280           per_binds_local = TRUE;
1281         }
1282
1283       if (per_binds_local
1284           && bfd_link_pic (info)
1285           && (cie->per_encoding & 0x70) == DW_EH_PE_absptr
1286           && (get_elf_backend_data (abfd)
1287               ->elf_backend_can_make_relative_eh_frame (abfd, info, sec)))
1288         {
1289           cie_inf->u.cie.make_per_encoding_relative = 1;
1290           cie_inf->u.cie.per_encoding_relative = 1;
1291         }
1292     }
1293
1294   /* See if we can merge this CIE with an earlier one.  */
1295   cie_compute_hash (cie);
1296   if (hdr_info->u.dwarf.cies == NULL)
1297     {
1298       hdr_info->u.dwarf.cies = htab_try_create (1, cie_hash, cie_eq, free);
1299       if (hdr_info->u.dwarf.cies == NULL)
1300         return cie_inf;
1301     }
1302   loc = htab_find_slot_with_hash (hdr_info->u.dwarf.cies, cie,
1303                                   cie->hash, INSERT);
1304   if (loc == NULL)
1305     return cie_inf;
1306
1307   new_cie = (struct cie *) *loc;
1308   if (new_cie == NULL)
1309     {
1310       /* Keep CIE_INF and record it in the hash table.  */
1311       new_cie = (struct cie *) malloc (sizeof (struct cie));
1312       if (new_cie == NULL)
1313         return cie_inf;
1314
1315       memcpy (new_cie, cie, sizeof (struct cie));
1316       *loc = new_cie;
1317     }
1318   else
1319     {
1320       /* Merge CIE_INF with NEW_CIE->CIE_INF.  */
1321       cie_inf->removed = 1;
1322       cie_inf->u.cie.merged = 1;
1323       cie_inf->u.cie.u.merged_with = new_cie->cie_inf;
1324       if (cie_inf->u.cie.make_lsda_relative)
1325         new_cie->cie_inf->u.cie.make_lsda_relative = 1;
1326     }
1327   return new_cie->cie_inf;
1328 }
1329
1330 /* This function is called for each input file before the .eh_frame
1331    section is relocated.  It discards duplicate CIEs and FDEs for discarded
1332    functions.  The function returns TRUE iff any entries have been
1333    deleted.  */
1334
1335 bfd_boolean
1336 _bfd_elf_discard_section_eh_frame
1337    (bfd *abfd, struct bfd_link_info *info, asection *sec,
1338     bfd_boolean (*reloc_symbol_deleted_p) (bfd_vma, void *),
1339     struct elf_reloc_cookie *cookie)
1340 {
1341   struct eh_cie_fde *ent;
1342   struct eh_frame_sec_info *sec_info;
1343   struct eh_frame_hdr_info *hdr_info;
1344   unsigned int ptr_size, offset, eh_alignment;
1345
1346   if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME)
1347     return FALSE;
1348
1349   sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
1350   if (sec_info == NULL)
1351     return FALSE;
1352
1353   ptr_size = (get_elf_backend_data (sec->owner)
1354               ->elf_backend_eh_frame_address_size (sec->owner, sec));
1355
1356   hdr_info = &elf_hash_table (info)->eh_info;
1357   for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1358     if (ent->size == 4)
1359       /* There should only be one zero terminator, on the last input
1360          file supplying .eh_frame (crtend.o).  Remove any others.  */
1361       ent->removed = sec->map_head.s != NULL;
1362     else if (!ent->cie && ent->u.fde.cie_inf != NULL)
1363       {
1364         bfd_boolean keep;
1365         if ((sec->flags & SEC_LINKER_CREATED) != 0 && cookie->rels == NULL)
1366           {
1367             unsigned int width
1368               = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1369             bfd_vma value
1370               = read_value (abfd, sec->contents + ent->offset + 8 + width,
1371                             width, get_DW_EH_PE_signed (ent->fde_encoding));
1372             keep = value != 0;
1373           }
1374         else
1375           {
1376             cookie->rel = cookie->rels + ent->reloc_index;
1377             /* FIXME: octets_per_byte.  */
1378             BFD_ASSERT (cookie->rel < cookie->relend
1379                         && cookie->rel->r_offset == ent->offset + 8);
1380             keep = !(*reloc_symbol_deleted_p) (ent->offset + 8, cookie);
1381           }
1382         if (keep)
1383           {
1384             if (bfd_link_pic (info)
1385                 && (((ent->fde_encoding & 0x70) == DW_EH_PE_absptr
1386                      && ent->make_relative == 0)
1387                     || (ent->fde_encoding & 0x70) == DW_EH_PE_aligned))
1388               {
1389                 static int num_warnings_issued = 0;
1390
1391                 /* If a shared library uses absolute pointers
1392                    which we cannot turn into PC relative,
1393                    don't create the binary search table,
1394                    since it is affected by runtime relocations.  */
1395                 hdr_info->u.dwarf.table = FALSE;
1396                 if (num_warnings_issued < 10)
1397                   {
1398                     (*info->callbacks->einfo)
1399                       /* xgettext:c-format */
1400                       (_("%P: FDE encoding in %B(%A) prevents .eh_frame_hdr"
1401                          " table being created.\n"), abfd, sec);
1402                     num_warnings_issued ++;
1403                   }
1404                 else if (num_warnings_issued == 10)
1405                   {
1406                     (*info->callbacks->einfo)
1407                       (_("%P: Further warnings about FDE encoding preventing .eh_frame_hdr generation dropped.\n"));
1408                     num_warnings_issued ++;
1409                   }
1410               }
1411             ent->removed = 0;
1412             hdr_info->u.dwarf.fde_count++;
1413             ent->u.fde.cie_inf = find_merged_cie (abfd, info, sec, hdr_info,
1414                                                   cookie, ent->u.fde.cie_inf);
1415           }
1416       }
1417
1418   if (sec_info->cies)
1419     {
1420       free (sec_info->cies);
1421       sec_info->cies = NULL;
1422     }
1423
1424   /* It may be that some .eh_frame input section has greater alignment
1425      than other .eh_frame sections.  In that case we run the risk of
1426      padding with zeros before that section, which would be seen as a
1427      zero terminator.  Alignment padding must be added *inside* the
1428      last FDE instead.  For other FDEs we align according to their
1429      encoding, in order to align FDE address range entries naturally.  */
1430   offset = 0;
1431   for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1432     if (!ent->removed)
1433       {
1434         eh_alignment = 4;
1435         if (ent->size == 4)
1436           ;
1437         else if (ent->cie)
1438           {
1439             if (ent->u.cie.per_encoding_aligned8)
1440               eh_alignment = 8;
1441           }
1442         else
1443           {
1444             eh_alignment = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1445             if (eh_alignment < 4)
1446               eh_alignment = 4;
1447           }
1448         offset = (offset + eh_alignment - 1) & -eh_alignment;
1449         ent->new_offset = offset;
1450         offset += size_of_output_cie_fde (ent);
1451       }
1452
1453   /* Pad the last FDE out to the output section alignment if there are
1454      following sections, in order to ensure no padding between this
1455      section and the next.  (Relies on the output section alignment
1456      being the maximum of all input sections alignments, which is the
1457      case unless someone is overriding alignment via scripts.)  */
1458   eh_alignment = 4;
1459   if (sec->map_head.s != NULL
1460       && (sec->map_head.s->size != 4
1461           || sec->map_head.s->map_head.s != NULL))
1462     eh_alignment = 1 << sec->output_section->alignment_power;
1463   offset = (offset + eh_alignment - 1) & -eh_alignment;
1464   sec->rawsize = sec->size;
1465   sec->size = offset;
1466   return offset != sec->rawsize;
1467 }
1468
1469 /* This function is called for .eh_frame_hdr section after
1470    _bfd_elf_discard_section_eh_frame has been called on all .eh_frame
1471    input sections.  It finalizes the size of .eh_frame_hdr section.  */
1472
1473 bfd_boolean
1474 _bfd_elf_discard_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
1475 {
1476   struct elf_link_hash_table *htab;
1477   struct eh_frame_hdr_info *hdr_info;
1478   asection *sec;
1479
1480   htab = elf_hash_table (info);
1481   hdr_info = &htab->eh_info;
1482
1483   if (!hdr_info->frame_hdr_is_compact && hdr_info->u.dwarf.cies != NULL)
1484     {
1485       htab_delete (hdr_info->u.dwarf.cies);
1486       hdr_info->u.dwarf.cies = NULL;
1487     }
1488
1489   sec = hdr_info->hdr_sec;
1490   if (sec == NULL)
1491     return FALSE;
1492
1493   if (info->eh_frame_hdr_type == COMPACT_EH_HDR)
1494     {
1495       /* For compact frames we only add the header.  The actual table comes
1496          from the .eh_frame_entry sections.  */
1497       sec->size = 8;
1498     }
1499   else
1500     {
1501       sec->size = EH_FRAME_HDR_SIZE;
1502       if (hdr_info->u.dwarf.table)
1503         sec->size += 4 + hdr_info->u.dwarf.fde_count * 8;
1504     }
1505
1506   elf_eh_frame_hdr (abfd) = sec;
1507   return TRUE;
1508 }
1509
1510 /* Return true if there is at least one non-empty .eh_frame section in
1511    input files.  Can only be called after ld has mapped input to
1512    output sections, and before sections are stripped.  */
1513
1514 bfd_boolean
1515 _bfd_elf_eh_frame_present (struct bfd_link_info *info)
1516 {
1517   asection *eh = bfd_get_section_by_name (info->output_bfd, ".eh_frame");
1518
1519   if (eh == NULL)
1520     return FALSE;
1521
1522   /* Count only sections which have at least a single CIE or FDE.
1523      There cannot be any CIE or FDE <= 8 bytes.  */
1524   for (eh = eh->map_head.s; eh != NULL; eh = eh->map_head.s)
1525     if (eh->size > 8)
1526       return TRUE;
1527
1528   return FALSE;
1529 }
1530
1531 /* Return true if there is at least one .eh_frame_entry section in
1532    input files.  */
1533
1534 bfd_boolean
1535 _bfd_elf_eh_frame_entry_present (struct bfd_link_info *info)
1536 {
1537   asection *o;
1538   bfd *abfd;
1539
1540   for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link.next)
1541     {
1542       for (o = abfd->sections; o; o = o->next)
1543         {
1544           const char *name = bfd_get_section_name (abfd, o);
1545
1546           if (strcmp (name, ".eh_frame_entry")
1547               && !bfd_is_abs_section (o->output_section))
1548             return TRUE;
1549         }
1550     }
1551   return FALSE;
1552 }
1553
1554 /* This function is called from size_dynamic_sections.
1555    It needs to decide whether .eh_frame_hdr should be output or not,
1556    because when the dynamic symbol table has been sized it is too late
1557    to strip sections.  */
1558
1559 bfd_boolean
1560 _bfd_elf_maybe_strip_eh_frame_hdr (struct bfd_link_info *info)
1561 {
1562   struct elf_link_hash_table *htab;
1563   struct eh_frame_hdr_info *hdr_info;
1564   struct bfd_link_hash_entry *bh = NULL;
1565   struct elf_link_hash_entry *h;
1566
1567   htab = elf_hash_table (info);
1568   hdr_info = &htab->eh_info;
1569   if (hdr_info->hdr_sec == NULL)
1570     return TRUE;
1571
1572   if (bfd_is_abs_section (hdr_info->hdr_sec->output_section)
1573       || info->eh_frame_hdr_type == 0
1574       || (info->eh_frame_hdr_type == DWARF2_EH_HDR
1575           && !_bfd_elf_eh_frame_present (info))
1576       || (info->eh_frame_hdr_type == COMPACT_EH_HDR
1577           && !_bfd_elf_eh_frame_entry_present (info)))
1578     {
1579       hdr_info->hdr_sec->flags |= SEC_EXCLUDE;
1580       hdr_info->hdr_sec = NULL;
1581       return TRUE;
1582     }
1583
1584   /* Add a hidden symbol so that systems without access to PHDRs can
1585      find the table.  */
1586   if (! (_bfd_generic_link_add_one_symbol
1587          (info, info->output_bfd, "__GNU_EH_FRAME_HDR", BSF_LOCAL,
1588           hdr_info->hdr_sec, 0, NULL, FALSE, FALSE, &bh)))
1589     return FALSE;
1590
1591   h = (struct elf_link_hash_entry *) bh;
1592   h->def_regular = 1;
1593   h->other = STV_HIDDEN;
1594   get_elf_backend_data
1595     (info->output_bfd)->elf_backend_hide_symbol (info, h, TRUE);
1596
1597   if (!hdr_info->frame_hdr_is_compact)
1598     hdr_info->u.dwarf.table = TRUE;
1599   return TRUE;
1600 }
1601
1602 /* Adjust an address in the .eh_frame section.  Given OFFSET within
1603    SEC, this returns the new offset in the adjusted .eh_frame section,
1604    or -1 if the address refers to a CIE/FDE which has been removed
1605    or to offset with dynamic relocation which is no longer needed.  */
1606
1607 bfd_vma
1608 _bfd_elf_eh_frame_section_offset (bfd *output_bfd ATTRIBUTE_UNUSED,
1609                                   struct bfd_link_info *info ATTRIBUTE_UNUSED,
1610                                   asection *sec,
1611                                   bfd_vma offset)
1612 {
1613   struct eh_frame_sec_info *sec_info;
1614   unsigned int lo, hi, mid;
1615
1616   if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME)
1617     return offset;
1618   sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
1619
1620   if (offset >= sec->rawsize)
1621     return offset - sec->rawsize + sec->size;
1622
1623   lo = 0;
1624   hi = sec_info->count;
1625   mid = 0;
1626   while (lo < hi)
1627     {
1628       mid = (lo + hi) / 2;
1629       if (offset < sec_info->entry[mid].offset)
1630         hi = mid;
1631       else if (offset
1632                >= sec_info->entry[mid].offset + sec_info->entry[mid].size)
1633         lo = mid + 1;
1634       else
1635         break;
1636     }
1637
1638   BFD_ASSERT (lo < hi);
1639
1640   /* FDE or CIE was removed.  */
1641   if (sec_info->entry[mid].removed)
1642     return (bfd_vma) -1;
1643
1644   /* If converting personality pointers to DW_EH_PE_pcrel, there will be
1645      no need for run-time relocation against the personality field.  */
1646   if (sec_info->entry[mid].cie
1647       && sec_info->entry[mid].u.cie.make_per_encoding_relative
1648       && offset == (sec_info->entry[mid].offset + 8
1649                     + sec_info->entry[mid].u.cie.personality_offset))
1650     return (bfd_vma) -2;
1651
1652   /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1653      relocation against FDE's initial_location field.  */
1654   if (!sec_info->entry[mid].cie
1655       && sec_info->entry[mid].make_relative
1656       && offset == sec_info->entry[mid].offset + 8)
1657     return (bfd_vma) -2;
1658
1659   /* If converting LSDA pointers to DW_EH_PE_pcrel, there will be no need
1660      for run-time relocation against LSDA field.  */
1661   if (!sec_info->entry[mid].cie
1662       && sec_info->entry[mid].u.fde.cie_inf->u.cie.make_lsda_relative
1663       && offset == (sec_info->entry[mid].offset + 8
1664                     + sec_info->entry[mid].lsda_offset))
1665     return (bfd_vma) -2;
1666
1667   /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1668      relocation against DW_CFA_set_loc's arguments.  */
1669   if (sec_info->entry[mid].set_loc
1670       && sec_info->entry[mid].make_relative
1671       && (offset >= sec_info->entry[mid].offset + 8
1672                     + sec_info->entry[mid].set_loc[1]))
1673     {
1674       unsigned int cnt;
1675
1676       for (cnt = 1; cnt <= sec_info->entry[mid].set_loc[0]; cnt++)
1677         if (offset == sec_info->entry[mid].offset + 8
1678                       + sec_info->entry[mid].set_loc[cnt])
1679           return (bfd_vma) -2;
1680     }
1681
1682   /* Any new augmentation bytes go before the first relocation.  */
1683   return (offset + sec_info->entry[mid].new_offset
1684           - sec_info->entry[mid].offset
1685           + extra_augmentation_string_bytes (sec_info->entry + mid)
1686           + extra_augmentation_data_bytes (sec_info->entry + mid));
1687 }
1688
1689 /* Write out .eh_frame_entry section.  Add CANTUNWIND terminator if needed.
1690    Also check that the contents look sane.  */
1691
1692 bfd_boolean
1693 _bfd_elf_write_section_eh_frame_entry (bfd *abfd, struct bfd_link_info *info,
1694                                        asection *sec, bfd_byte *contents)
1695 {
1696   const struct elf_backend_data *bed;
1697   bfd_byte cantunwind[8];
1698   bfd_vma addr;
1699   bfd_vma last_addr;
1700   bfd_vma offset;
1701   asection *text_sec = (asection *) elf_section_data (sec)->sec_info;
1702
1703   if (!sec->rawsize)
1704     sec->rawsize = sec->size;
1705
1706   BFD_ASSERT (sec->sec_info_type == SEC_INFO_TYPE_EH_FRAME_ENTRY);
1707
1708   /* Check to make sure that the text section corresponding to this eh_frame_entry
1709      section has not been excluded.  In particular, mips16 stub entries will be
1710      excluded outside of the normal process.  */
1711   if (sec->flags & SEC_EXCLUDE
1712       || text_sec->flags & SEC_EXCLUDE)
1713     return TRUE;
1714
1715   if (!bfd_set_section_contents (abfd, sec->output_section, contents,
1716                                  sec->output_offset, sec->rawsize))
1717       return FALSE;
1718
1719   last_addr = bfd_get_signed_32 (abfd, contents);
1720   /* Check that all the entries are in order.  */
1721   for (offset = 8; offset < sec->rawsize; offset += 8)
1722     {
1723       addr = bfd_get_signed_32 (abfd, contents + offset) + offset;
1724       if (addr <= last_addr)
1725         {
1726           /* xgettext:c-format */
1727           _bfd_error_handler (_("%B: %A not in order"), sec->owner, sec);
1728           return FALSE;
1729         }
1730
1731       last_addr = addr;
1732     }
1733
1734   addr = text_sec->output_section->vma + text_sec->output_offset
1735          + text_sec->size;
1736   addr &= ~1;
1737   addr -= (sec->output_section->vma + sec->output_offset + sec->rawsize);
1738   if (addr & 1)
1739     {
1740       /* xgettext:c-format */
1741       _bfd_error_handler (_("%B: %A invalid input section size"),
1742                           sec->owner, sec);
1743       bfd_set_error (bfd_error_bad_value);
1744       return FALSE;
1745     }
1746   if (last_addr >= addr + sec->rawsize)
1747     {
1748       /* xgettext:c-format */
1749       _bfd_error_handler (_("%B: %A points past end of text section"),
1750                           sec->owner, sec);
1751       bfd_set_error (bfd_error_bad_value);
1752       return FALSE;
1753     }
1754
1755   if (sec->size == sec->rawsize)
1756     return TRUE;
1757
1758   bed = get_elf_backend_data (abfd);
1759   BFD_ASSERT (sec->size == sec->rawsize + 8);
1760   BFD_ASSERT ((addr & 1) == 0);
1761   BFD_ASSERT (bed->cant_unwind_opcode);
1762
1763   bfd_put_32 (abfd, addr, cantunwind);
1764   bfd_put_32 (abfd, (*bed->cant_unwind_opcode) (info), cantunwind + 4);
1765   return bfd_set_section_contents (abfd, sec->output_section, cantunwind,
1766                                    sec->output_offset + sec->rawsize, 8);
1767 }
1768
1769 /* Write out .eh_frame section.  This is called with the relocated
1770    contents.  */
1771
1772 bfd_boolean
1773 _bfd_elf_write_section_eh_frame (bfd *abfd,
1774                                  struct bfd_link_info *info,
1775                                  asection *sec,
1776                                  bfd_byte *contents)
1777 {
1778   struct eh_frame_sec_info *sec_info;
1779   struct elf_link_hash_table *htab;
1780   struct eh_frame_hdr_info *hdr_info;
1781   unsigned int ptr_size;
1782   struct eh_cie_fde *ent, *last_ent;
1783
1784   if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME)
1785     /* FIXME: octets_per_byte.  */
1786     return bfd_set_section_contents (abfd, sec->output_section, contents,
1787                                      sec->output_offset, sec->size);
1788
1789   ptr_size = (get_elf_backend_data (abfd)
1790               ->elf_backend_eh_frame_address_size (abfd, sec));
1791   BFD_ASSERT (ptr_size != 0);
1792
1793   sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
1794   htab = elf_hash_table (info);
1795   hdr_info = &htab->eh_info;
1796
1797   if (hdr_info->u.dwarf.table && hdr_info->u.dwarf.array == NULL)
1798     {
1799       hdr_info->frame_hdr_is_compact = FALSE;
1800       hdr_info->u.dwarf.array = (struct eh_frame_array_ent *)
1801         bfd_malloc (hdr_info->u.dwarf.fde_count
1802                     * sizeof (*hdr_info->u.dwarf.array));
1803     }
1804   if (hdr_info->u.dwarf.array == NULL)
1805     hdr_info = NULL;
1806
1807   /* The new offsets can be bigger or smaller than the original offsets.
1808      We therefore need to make two passes over the section: one backward
1809      pass to move entries up and one forward pass to move entries down.
1810      The two passes won't interfere with each other because entries are
1811      not reordered  */
1812   for (ent = sec_info->entry + sec_info->count; ent-- != sec_info->entry;)
1813     if (!ent->removed && ent->new_offset > ent->offset)
1814       memmove (contents + ent->new_offset, contents + ent->offset, ent->size);
1815
1816   for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1817     if (!ent->removed && ent->new_offset < ent->offset)
1818       memmove (contents + ent->new_offset, contents + ent->offset, ent->size);
1819
1820   last_ent = sec_info->entry + sec_info->count;
1821   for (ent = sec_info->entry; ent < last_ent; ++ent)
1822     {
1823       unsigned char *buf, *end;
1824       unsigned int new_size;
1825
1826       if (ent->removed)
1827         continue;
1828
1829       if (ent->size == 4)
1830         {
1831           /* Any terminating FDE must be at the end of the section.  */
1832           BFD_ASSERT (ent == last_ent - 1);
1833           continue;
1834         }
1835
1836       buf = contents + ent->new_offset;
1837       end = buf + ent->size;
1838       new_size = next_cie_fde_offset (ent, last_ent, sec) - ent->new_offset;
1839
1840       /* Update the size.  It may be shrinked.  */
1841       bfd_put_32 (abfd, new_size - 4, buf);
1842
1843       /* Filling the extra bytes with DW_CFA_nops.  */
1844       if (new_size != ent->size)
1845         memset (end, 0, new_size - ent->size);
1846
1847       if (ent->cie)
1848         {
1849           /* CIE */
1850           if (ent->make_relative
1851               || ent->u.cie.make_lsda_relative
1852               || ent->u.cie.per_encoding_relative)
1853             {
1854               char *aug;
1855               unsigned int action, extra_string, extra_data;
1856               unsigned int per_width, per_encoding;
1857
1858               /* Need to find 'R' or 'L' augmentation's argument and modify
1859                  DW_EH_PE_* value.  */
1860               action = ((ent->make_relative ? 1 : 0)
1861                         | (ent->u.cie.make_lsda_relative ? 2 : 0)
1862                         | (ent->u.cie.per_encoding_relative ? 4 : 0));
1863               extra_string = extra_augmentation_string_bytes (ent);
1864               extra_data = extra_augmentation_data_bytes (ent);
1865
1866               /* Skip length, id and version.  */
1867               buf += 9;
1868               aug = (char *) buf;
1869               buf += strlen (aug) + 1;
1870               skip_leb128 (&buf, end);
1871               skip_leb128 (&buf, end);
1872               skip_leb128 (&buf, end);
1873               if (*aug == 'z')
1874                 {
1875                   /* The uleb128 will always be a single byte for the kind
1876                      of augmentation strings that we're prepared to handle.  */
1877                   *buf++ += extra_data;
1878                   aug++;
1879                 }
1880
1881               /* Make room for the new augmentation string and data bytes.  */
1882               memmove (buf + extra_string + extra_data, buf, end - buf);
1883               memmove (aug + extra_string, aug, buf - (bfd_byte *) aug);
1884               buf += extra_string;
1885               end += extra_string + extra_data;
1886
1887               if (ent->add_augmentation_size)
1888                 {
1889                   *aug++ = 'z';
1890                   *buf++ = extra_data - 1;
1891                 }
1892               if (ent->u.cie.add_fde_encoding)
1893                 {
1894                   BFD_ASSERT (action & 1);
1895                   *aug++ = 'R';
1896                   *buf++ = make_pc_relative (DW_EH_PE_absptr, ptr_size);
1897                   action &= ~1;
1898                 }
1899
1900               while (action)
1901                 switch (*aug++)
1902                   {
1903                   case 'L':
1904                     if (action & 2)
1905                       {
1906                         BFD_ASSERT (*buf == ent->lsda_encoding);
1907                         *buf = make_pc_relative (*buf, ptr_size);
1908                         action &= ~2;
1909                       }
1910                     buf++;
1911                     break;
1912                   case 'P':
1913                     if (ent->u.cie.make_per_encoding_relative)
1914                       *buf = make_pc_relative (*buf, ptr_size);
1915                     per_encoding = *buf++;
1916                     per_width = get_DW_EH_PE_width (per_encoding, ptr_size);
1917                     BFD_ASSERT (per_width != 0);
1918                     BFD_ASSERT (((per_encoding & 0x70) == DW_EH_PE_pcrel)
1919                                 == ent->u.cie.per_encoding_relative);
1920                     if ((per_encoding & 0x70) == DW_EH_PE_aligned)
1921                       buf = (contents
1922                              + ((buf - contents + per_width - 1)
1923                                 & ~((bfd_size_type) per_width - 1)));
1924                     if (action & 4)
1925                       {
1926                         bfd_vma val;
1927
1928                         val = read_value (abfd, buf, per_width,
1929                                           get_DW_EH_PE_signed (per_encoding));
1930                         if (ent->u.cie.make_per_encoding_relative)
1931                           val -= (sec->output_section->vma
1932                                   + sec->output_offset
1933                                   + (buf - contents));
1934                         else
1935                           {
1936                             val += (bfd_vma) ent->offset - ent->new_offset;
1937                             val -= extra_string + extra_data;
1938                           }
1939                         write_value (abfd, buf, val, per_width);
1940                         action &= ~4;
1941                       }
1942                     buf += per_width;
1943                     break;
1944                   case 'R':
1945                     if (action & 1)
1946                       {
1947                         BFD_ASSERT (*buf == ent->fde_encoding);
1948                         *buf = make_pc_relative (*buf, ptr_size);
1949                         action &= ~1;
1950                       }
1951                     buf++;
1952                     break;
1953                   case 'S':
1954                     break;
1955                   default:
1956                     BFD_FAIL ();
1957                   }
1958             }
1959         }
1960       else
1961         {
1962           /* FDE */
1963           bfd_vma value, address;
1964           unsigned int width;
1965           bfd_byte *start;
1966           struct eh_cie_fde *cie;
1967
1968           /* Skip length.  */
1969           cie = ent->u.fde.cie_inf;
1970           buf += 4;
1971           value = ((ent->new_offset + sec->output_offset + 4)
1972                    - (cie->new_offset + cie->u.cie.u.sec->output_offset));
1973           bfd_put_32 (abfd, value, buf);
1974           if (bfd_link_relocatable (info))
1975             continue;
1976           buf += 4;
1977           width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1978           value = read_value (abfd, buf, width,
1979                               get_DW_EH_PE_signed (ent->fde_encoding));
1980           address = value;
1981           if (value)
1982             {
1983               switch (ent->fde_encoding & 0x70)
1984                 {
1985                 case DW_EH_PE_textrel:
1986                   BFD_ASSERT (hdr_info == NULL);
1987                   break;
1988                 case DW_EH_PE_datarel:
1989                   {
1990                     switch (abfd->arch_info->arch)
1991                       {
1992                       case bfd_arch_ia64:
1993                         BFD_ASSERT (elf_gp (abfd) != 0);
1994                         address += elf_gp (abfd);
1995                         break;
1996                       default:
1997                         (*info->callbacks->einfo)
1998                           (_("%P: DW_EH_PE_datarel unspecified"
1999                              " for this architecture.\n"));
2000                         /* Fall thru */
2001                       case bfd_arch_frv:
2002                       case bfd_arch_i386:
2003                         BFD_ASSERT (htab->hgot != NULL
2004                                     && ((htab->hgot->root.type
2005                                          == bfd_link_hash_defined)
2006                                         || (htab->hgot->root.type
2007                                             == bfd_link_hash_defweak)));
2008                         address
2009                           += (htab->hgot->root.u.def.value
2010                               + htab->hgot->root.u.def.section->output_offset
2011                               + (htab->hgot->root.u.def.section->output_section
2012                                  ->vma));
2013                         break;
2014                       }
2015                   }
2016                   break;
2017                 case DW_EH_PE_pcrel:
2018                   value += (bfd_vma) ent->offset - ent->new_offset;
2019                   address += (sec->output_section->vma
2020                               + sec->output_offset
2021                               + ent->offset + 8);
2022                   break;
2023                 }
2024               if (ent->make_relative)
2025                 value -= (sec->output_section->vma
2026                           + sec->output_offset
2027                           + ent->new_offset + 8);
2028               write_value (abfd, buf, value, width);
2029             }
2030
2031           start = buf;
2032
2033           if (hdr_info)
2034             {
2035               /* The address calculation may overflow, giving us a
2036                  value greater than 4G on a 32-bit target when
2037                  dwarf_vma is 64-bit.  */
2038               if (sizeof (address) > 4 && ptr_size == 4)
2039                 address &= 0xffffffff;
2040               hdr_info->u.dwarf.array[hdr_info->array_count].initial_loc
2041                 = address;
2042               hdr_info->u.dwarf.array[hdr_info->array_count].range
2043                 = read_value (abfd, buf + width, width, FALSE);
2044               hdr_info->u.dwarf.array[hdr_info->array_count++].fde
2045                 = (sec->output_section->vma
2046                    + sec->output_offset
2047                    + ent->new_offset);
2048             }
2049
2050           if ((ent->lsda_encoding & 0x70) == DW_EH_PE_pcrel
2051               || cie->u.cie.make_lsda_relative)
2052             {
2053               buf += ent->lsda_offset;
2054               width = get_DW_EH_PE_width (ent->lsda_encoding, ptr_size);
2055               value = read_value (abfd, buf, width,
2056                                   get_DW_EH_PE_signed (ent->lsda_encoding));
2057               if (value)
2058                 {
2059                   if ((ent->lsda_encoding & 0x70) == DW_EH_PE_pcrel)
2060                     value += (bfd_vma) ent->offset - ent->new_offset;
2061                   else if (cie->u.cie.make_lsda_relative)
2062                     value -= (sec->output_section->vma
2063                               + sec->output_offset
2064                               + ent->new_offset + 8 + ent->lsda_offset);
2065                   write_value (abfd, buf, value, width);
2066                 }
2067             }
2068           else if (ent->add_augmentation_size)
2069             {
2070               /* Skip the PC and length and insert a zero byte for the
2071                  augmentation size.  */
2072               buf += width * 2;
2073               memmove (buf + 1, buf, end - buf);
2074               *buf = 0;
2075             }
2076
2077           if (ent->set_loc)
2078             {
2079               /* Adjust DW_CFA_set_loc.  */
2080               unsigned int cnt;
2081               bfd_vma new_offset;
2082
2083               width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
2084               new_offset = ent->new_offset + 8
2085                            + extra_augmentation_string_bytes (ent)
2086                            + extra_augmentation_data_bytes (ent);
2087
2088               for (cnt = 1; cnt <= ent->set_loc[0]; cnt++)
2089                 {
2090                   buf = start + ent->set_loc[cnt];
2091
2092                   value = read_value (abfd, buf, width,
2093                                       get_DW_EH_PE_signed (ent->fde_encoding));
2094                   if (!value)
2095                     continue;
2096
2097                   if ((ent->fde_encoding & 0x70) == DW_EH_PE_pcrel)
2098                     value += (bfd_vma) ent->offset + 8 - new_offset;
2099                   if (ent->make_relative)
2100                     value -= (sec->output_section->vma
2101                               + sec->output_offset
2102                               + new_offset + ent->set_loc[cnt]);
2103                   write_value (abfd, buf, value, width);
2104                 }
2105             }
2106         }
2107     }
2108
2109   /* FIXME: octets_per_byte.  */
2110   return bfd_set_section_contents (abfd, sec->output_section,
2111                                    contents, (file_ptr) sec->output_offset,
2112                                    sec->size);
2113 }
2114
2115 /* Helper function used to sort .eh_frame_hdr search table by increasing
2116    VMA of FDE initial location.  */
2117
2118 static int
2119 vma_compare (const void *a, const void *b)
2120 {
2121   const struct eh_frame_array_ent *p = (const struct eh_frame_array_ent *) a;
2122   const struct eh_frame_array_ent *q = (const struct eh_frame_array_ent *) b;
2123   if (p->initial_loc > q->initial_loc)
2124     return 1;
2125   if (p->initial_loc < q->initial_loc)
2126     return -1;
2127   if (p->range > q->range)
2128     return 1;
2129   if (p->range < q->range)
2130     return -1;
2131   return 0;
2132 }
2133
2134 /* Reorder .eh_frame_entry sections to match the associated text sections.
2135    This routine is called during the final linking step, just before writing
2136    the contents.  At this stage, sections in the eh_frame_hdr_info are already
2137    sorted in order of increasing text section address and so we simply need
2138    to make the .eh_frame_entrys follow that same order.  Note that it is
2139    invalid for a linker script to try to force a particular order of
2140    .eh_frame_entry sections.  */
2141
2142 bfd_boolean
2143 _bfd_elf_fixup_eh_frame_hdr (struct bfd_link_info *info)
2144 {
2145   asection *sec = NULL;
2146   asection *osec;
2147   struct eh_frame_hdr_info *hdr_info;
2148   unsigned int i;
2149   bfd_vma offset;
2150   struct bfd_link_order *p;
2151
2152   hdr_info = &elf_hash_table (info)->eh_info;
2153
2154   if (hdr_info->hdr_sec == NULL
2155       || info->eh_frame_hdr_type != COMPACT_EH_HDR
2156       || hdr_info->array_count == 0)
2157     return TRUE;
2158
2159   /* Change section output offsets to be in text section order.  */
2160   offset = 8;
2161   osec = hdr_info->u.compact.entries[0]->output_section;
2162   for (i = 0; i < hdr_info->array_count; i++)
2163     {
2164       sec = hdr_info->u.compact.entries[i];
2165       if (sec->output_section != osec)
2166         {
2167           _bfd_error_handler
2168             (_("Invalid output section for .eh_frame_entry: %A"),
2169              sec->output_section);
2170           return FALSE;
2171         }
2172       sec->output_offset = offset;
2173       offset += sec->size;
2174     }
2175
2176
2177   /* Fix the link_order to match.  */
2178   for (p = sec->output_section->map_head.link_order; p != NULL; p = p->next)
2179     {
2180       if (p->type != bfd_indirect_link_order)
2181         abort();
2182
2183       p->offset = p->u.indirect.section->output_offset;
2184       if (p->next != NULL)
2185         i--;
2186     }
2187
2188   if (i != 0)
2189     {
2190       _bfd_error_handler
2191         (_("Invalid contents in %A section"), osec);
2192       return FALSE;
2193     }
2194
2195   return TRUE;
2196 }
2197
2198 /* The .eh_frame_hdr format for Compact EH frames:
2199    ubyte version                (2)
2200    ubyte eh_ref_enc             (DW_EH_PE_* encoding of typinfo references)
2201    uint32_t count               (Number of entries in table)
2202    [array from .eh_frame_entry sections]  */
2203
2204 static bfd_boolean
2205 write_compact_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
2206 {
2207   struct elf_link_hash_table *htab;
2208   struct eh_frame_hdr_info *hdr_info;
2209   asection *sec;
2210   const struct elf_backend_data *bed;
2211   bfd_vma count;
2212   bfd_byte contents[8];
2213   unsigned int i;
2214
2215   htab = elf_hash_table (info);
2216   hdr_info = &htab->eh_info;
2217   sec = hdr_info->hdr_sec;
2218
2219   if (sec->size != 8)
2220     abort();
2221
2222   for (i = 0; i < sizeof (contents); i++)
2223     contents[i] = 0;
2224
2225   contents[0] = COMPACT_EH_HDR;
2226   bed = get_elf_backend_data (abfd);
2227
2228   BFD_ASSERT (bed->compact_eh_encoding);
2229   contents[1] = (*bed->compact_eh_encoding) (info);
2230
2231   count = (sec->output_section->size - 8) / 8;
2232   bfd_put_32 (abfd, count, contents + 4);
2233   return bfd_set_section_contents (abfd, sec->output_section, contents,
2234                                    (file_ptr) sec->output_offset, sec->size);
2235 }
2236
2237 /* The .eh_frame_hdr format for DWARF frames:
2238
2239    ubyte version                (currently 1)
2240    ubyte eh_frame_ptr_enc       (DW_EH_PE_* encoding of pointer to start of
2241                                  .eh_frame section)
2242    ubyte fde_count_enc          (DW_EH_PE_* encoding of total FDE count
2243                                  number (or DW_EH_PE_omit if there is no
2244                                  binary search table computed))
2245    ubyte table_enc              (DW_EH_PE_* encoding of binary search table,
2246                                  or DW_EH_PE_omit if not present.
2247                                  DW_EH_PE_datarel is using address of
2248                                  .eh_frame_hdr section start as base)
2249    [encoded] eh_frame_ptr       (pointer to start of .eh_frame section)
2250    optionally followed by:
2251    [encoded] fde_count          (total number of FDEs in .eh_frame section)
2252    fde_count x [encoded] initial_loc, fde
2253                                 (array of encoded pairs containing
2254                                  FDE initial_location field and FDE address,
2255                                  sorted by increasing initial_loc).  */
2256
2257 static bfd_boolean
2258 write_dwarf_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
2259 {
2260   struct elf_link_hash_table *htab;
2261   struct eh_frame_hdr_info *hdr_info;
2262   asection *sec;
2263   bfd_boolean retval = TRUE;
2264
2265   htab = elf_hash_table (info);
2266   hdr_info = &htab->eh_info;
2267   sec = hdr_info->hdr_sec;
2268   bfd_byte *contents;
2269   asection *eh_frame_sec;
2270   bfd_size_type size;
2271   bfd_vma encoded_eh_frame;
2272
2273   size = EH_FRAME_HDR_SIZE;
2274   if (hdr_info->u.dwarf.array
2275       && hdr_info->array_count == hdr_info->u.dwarf.fde_count)
2276     size += 4 + hdr_info->u.dwarf.fde_count * 8;
2277   contents = (bfd_byte *) bfd_malloc (size);
2278   if (contents == NULL)
2279     return FALSE;
2280
2281   eh_frame_sec = bfd_get_section_by_name (abfd, ".eh_frame");
2282   if (eh_frame_sec == NULL)
2283     {
2284       free (contents);
2285       return FALSE;
2286     }
2287
2288   memset (contents, 0, EH_FRAME_HDR_SIZE);
2289   /* Version.  */
2290   contents[0] = 1;
2291   /* .eh_frame offset.  */
2292   contents[1] = get_elf_backend_data (abfd)->elf_backend_encode_eh_address
2293     (abfd, info, eh_frame_sec, 0, sec, 4, &encoded_eh_frame);
2294
2295   if (hdr_info->u.dwarf.array
2296       && hdr_info->array_count == hdr_info->u.dwarf.fde_count)
2297     {
2298       /* FDE count encoding.  */
2299       contents[2] = DW_EH_PE_udata4;
2300       /* Search table encoding.  */
2301       contents[3] = DW_EH_PE_datarel | DW_EH_PE_sdata4;
2302     }
2303   else
2304     {
2305       contents[2] = DW_EH_PE_omit;
2306       contents[3] = DW_EH_PE_omit;
2307     }
2308   bfd_put_32 (abfd, encoded_eh_frame, contents + 4);
2309
2310   if (contents[2] != DW_EH_PE_omit)
2311     {
2312       unsigned int i;
2313       bfd_boolean overlap, overflow;
2314
2315       bfd_put_32 (abfd, hdr_info->u.dwarf.fde_count,
2316                   contents + EH_FRAME_HDR_SIZE);
2317       qsort (hdr_info->u.dwarf.array, hdr_info->u.dwarf.fde_count,
2318              sizeof (*hdr_info->u.dwarf.array), vma_compare);
2319       overlap = FALSE;
2320       overflow = FALSE;
2321       for (i = 0; i < hdr_info->u.dwarf.fde_count; i++)
2322         {
2323           bfd_vma val;
2324
2325           val = hdr_info->u.dwarf.array[i].initial_loc
2326             - sec->output_section->vma;
2327           val = ((val & 0xffffffff) ^ 0x80000000) - 0x80000000;
2328           if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64
2329               && (hdr_info->u.dwarf.array[i].initial_loc
2330                   != sec->output_section->vma + val))
2331             overflow = TRUE;
2332           bfd_put_32 (abfd, val, contents + EH_FRAME_HDR_SIZE + i * 8 + 4);
2333           val = hdr_info->u.dwarf.array[i].fde - sec->output_section->vma;
2334           val = ((val & 0xffffffff) ^ 0x80000000) - 0x80000000;
2335           if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64
2336               && (hdr_info->u.dwarf.array[i].fde
2337                   != sec->output_section->vma + val))
2338             overflow = TRUE;
2339           bfd_put_32 (abfd, val, contents + EH_FRAME_HDR_SIZE + i * 8 + 8);
2340           if (i != 0
2341               && (hdr_info->u.dwarf.array[i].initial_loc
2342                   < (hdr_info->u.dwarf.array[i - 1].initial_loc
2343                      + hdr_info->u.dwarf.array[i - 1].range)))
2344             overlap = TRUE;
2345         }
2346       if (overflow)
2347         (*info->callbacks->einfo) (_("%P: .eh_frame_hdr entry overflow.\n"));
2348       if (overlap)
2349         (*info->callbacks->einfo)
2350           (_("%P: .eh_frame_hdr refers to overlapping FDEs.\n"));
2351       if (overflow || overlap)
2352         {
2353           bfd_set_error (bfd_error_bad_value);
2354           retval = FALSE;
2355         }
2356     }
2357
2358   /* FIXME: octets_per_byte.  */
2359   if (!bfd_set_section_contents (abfd, sec->output_section, contents,
2360                                  (file_ptr) sec->output_offset,
2361                                  sec->size))
2362     retval = FALSE;
2363   free (contents);
2364
2365   if (hdr_info->u.dwarf.array != NULL)
2366     free (hdr_info->u.dwarf.array);
2367   return retval;
2368 }
2369
2370 /* Write out .eh_frame_hdr section.  This must be called after
2371    _bfd_elf_write_section_eh_frame has been called on all input
2372    .eh_frame sections.  */
2373
2374 bfd_boolean
2375 _bfd_elf_write_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
2376 {
2377   struct elf_link_hash_table *htab;
2378   struct eh_frame_hdr_info *hdr_info;
2379   asection *sec;
2380
2381   htab = elf_hash_table (info);
2382   hdr_info = &htab->eh_info;
2383   sec = hdr_info->hdr_sec;
2384
2385   if (info->eh_frame_hdr_type == 0 || sec == NULL)
2386     return TRUE;
2387
2388   if (info->eh_frame_hdr_type == COMPACT_EH_HDR)
2389     return write_compact_eh_frame_hdr (abfd, info);
2390   else
2391     return write_dwarf_eh_frame_hdr (abfd, info);
2392 }
2393
2394 /* Return the width of FDE addresses.  This is the default implementation.  */
2395
2396 unsigned int
2397 _bfd_elf_eh_frame_address_size (bfd *abfd, asection *sec ATTRIBUTE_UNUSED)
2398 {
2399   return elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64 ? 8 : 4;
2400 }
2401
2402 /* Decide whether we can use a PC-relative encoding within the given
2403    EH frame section.  This is the default implementation.  */
2404
2405 bfd_boolean
2406 _bfd_elf_can_make_relative (bfd *input_bfd ATTRIBUTE_UNUSED,
2407                             struct bfd_link_info *info ATTRIBUTE_UNUSED,
2408                             asection *eh_frame_section ATTRIBUTE_UNUSED)
2409 {
2410   return TRUE;
2411 }
2412
2413 /* Select an encoding for the given address.  Preference is given to
2414    PC-relative addressing modes.  */
2415
2416 bfd_byte
2417 _bfd_elf_encode_eh_address (bfd *abfd ATTRIBUTE_UNUSED,
2418                             struct bfd_link_info *info ATTRIBUTE_UNUSED,
2419                             asection *osec, bfd_vma offset,
2420                             asection *loc_sec, bfd_vma loc_offset,
2421                             bfd_vma *encoded)
2422 {
2423   *encoded = osec->vma + offset -
2424     (loc_sec->output_section->vma + loc_sec->output_offset + loc_offset);
2425   return DW_EH_PE_pcrel | DW_EH_PE_sdata4;
2426 }