bfd/elf-eh-frame.c

   1 /* .eh_frame section optimization.
   2    Copyright 2001, 2002, 2003, 2004 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 2 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 #include "bfd.h"
  22 #include "sysdep.h"
  23 #include "libbfd.h"
  24 #include "elf-bfd.h"
  25 #include "elf/dwarf2.h"
  26
  27 #define EH_FRAME_HDR_SIZE 8
  28
  29 /* Helper function for reading uleb128 encoded data.  */
  30
  31 static bfd_vma
  32 read_unsigned_leb128 (bfd *abfd ATTRIBUTE_UNUSED,
  33                       char *buf,
  34                       unsigned int *bytes_read_ptr)
  35 {
  36   bfd_vma result;
  37   unsigned int num_read;
  38   int shift;
  39   unsigned char byte;
  40
  41   result = 0;
  42   shift = 0;
  43   num_read = 0;
  44   do
  45     {
  46       byte = bfd_get_8 (abfd, (bfd_byte *) buf);
  47       buf++;
  48       num_read++;
  49       result |= (((bfd_vma) byte & 0x7f) << shift);
  50       shift += 7;
  51     }
  52   while (byte & 0x80);
  53   *bytes_read_ptr = num_read;
  54   return result;
  55 }
  56
  57 /* Helper function for reading sleb128 encoded data.  */
  58
  59 static bfd_signed_vma
  60 read_signed_leb128 (bfd *abfd ATTRIBUTE_UNUSED,
  61                     char *buf,
  62                     unsigned int * bytes_read_ptr)
  63 {
  64   bfd_vma result;
  65   int shift;
  66   int num_read;
  67   unsigned char byte;
  68
  69   result = 0;
  70   shift = 0;
  71   num_read = 0;
  72   do
  73     {
  74       byte = bfd_get_8 (abfd, (bfd_byte *) buf);
  75       buf ++;
  76       num_read ++;
  77       result |= (((bfd_vma) byte & 0x7f) << shift);
  78       shift += 7;
  79     }
  80   while (byte & 0x80);
  81   if (byte & 0x40)
  82     result |= (((bfd_vma) -1) << (shift - 7)) << 7;
  83   *bytes_read_ptr = num_read;
  84   return result;
  85 }
  86
  87 #define read_uleb128(VAR, BUF)                                  \
  88 do                                                              \
  89   {                                                             \
  90     (VAR) = read_unsigned_leb128 (abfd, buf, &leb128_tmp);      \
  91     (BUF) += leb128_tmp;                                        \
  92   }                                                             \
  93 while (0)
  94
  95 #define read_sleb128(VAR, BUF)                                  \
  96 do                                                              \
  97   {                                                             \
  98     (VAR) = read_signed_leb128 (abfd, buf, &leb128_tmp);        \
  99     (BUF) += leb128_tmp;                                        \
 100   }                                                             \
 101 while (0)
 102
 103 /* Return 0 if either encoding is variable width, or not yet known to bfd.  */
 104
 105 static
 106 int get_DW_EH_PE_width (int encoding, int ptr_size)
 107 {
 108   /* DW_EH_PE_ values of 0x60 and 0x70 weren't defined at the time .eh_frame
 109      was added to bfd.  */
 110   if ((encoding & 0x60) == 0x60)
 111     return 0;
 112
 113   switch (encoding & 7)
 114     {
 115     case DW_EH_PE_udata2: return 2;
 116     case DW_EH_PE_udata4: return 4;
 117     case DW_EH_PE_udata8: return 8;
 118     case DW_EH_PE_absptr: return ptr_size;
 119     default:
 120       break;
 121     }
 122
 123   return 0;
 124 }
 125
 126 #define get_DW_EH_PE_signed(encoding) (((encoding) & DW_EH_PE_signed) != 0)
 127
 128 /* Read a width sized value from memory.  */
 129
 130 static bfd_vma
 131 read_value (bfd *abfd, bfd_byte *buf, int width, int is_signed)
 132 {
 133   bfd_vma value;
 134
 135   switch (width)
 136     {
 137     case 2:
 138       if (is_signed)
 139         value = bfd_get_signed_16 (abfd, buf);
 140       else
 141         value = bfd_get_16 (abfd, buf);
 142       break;
 143     case 4:
 144       if (is_signed)
 145         value = bfd_get_signed_32 (abfd, buf);
 146       else
 147         value = bfd_get_32 (abfd, buf);
 148       break;
 149     case 8:
 150       if (is_signed)
 151         value = bfd_get_signed_64 (abfd, buf);
 152       else
 153         value = bfd_get_64 (abfd, buf);
 154       break;
 155     default:
 156       BFD_FAIL ();
 157       return 0;
 158     }
 159
 160   return value;
 161 }
 162
 163 /* Store a width sized value to memory.  */
 164
 165 static void
 166 write_value (bfd *abfd, bfd_byte *buf, bfd_vma value, int width)
 167 {
 168   switch (width)
 169     {
 170     case 2: bfd_put_16 (abfd, value, buf); break;
 171     case 4: bfd_put_32 (abfd, value, buf); break;
 172     case 8: bfd_put_64 (abfd, value, buf); break;
 173     default: BFD_FAIL ();
 174     }
 175 }
 176
 177 /* Return zero if C1 and C2 CIEs can be merged.  */
 178
 179 static
 180 int cie_compare (struct cie *c1, struct cie *c2)
 181 {
 182   if (c1->hdr.length == c2->hdr.length
 183       && c1->version == c2->version
 184       && strcmp (c1->augmentation, c2->augmentation) == 0
 185       && strcmp (c1->augmentation, "eh") != 0
 186       && c1->code_align == c2->code_align
 187       && c1->data_align == c2->data_align
 188       && c1->ra_column == c2->ra_column
 189       && c1->augmentation_size == c2->augmentation_size
 190       && c1->personality == c2->personality
 191       && c1->per_encoding == c2->per_encoding
 192       && c1->lsda_encoding == c2->lsda_encoding
 193       && c1->fde_encoding == c2->fde_encoding
 194       && c1->initial_insn_length == c2->initial_insn_length
 195       && memcmp (c1->initial_instructions,
 196                  c2->initial_instructions,
 197                  c1->initial_insn_length) == 0)
 198     return 0;
 199
 200   return 1;
 201 }
 202
 203 /* This function is called for each input file before the .eh_frame
 204    section is relocated.  It discards duplicate CIEs and FDEs for discarded
 205    functions.  The function returns TRUE iff any entries have been
 206    deleted.  */
 207
 208 bfd_boolean
 209 _bfd_elf_discard_section_eh_frame
 210    (bfd *abfd, struct bfd_link_info *info, asection *sec,
 211     bfd_boolean (*reloc_symbol_deleted_p) (bfd_vma, void *),
 212     struct elf_reloc_cookie *cookie)
 213 {
 214   bfd_byte *ehbuf = NULL, *buf;
 215   bfd_byte *last_cie, *last_fde;
 216   struct cie_header hdr;
 217   struct cie cie;
 218   struct elf_link_hash_table *htab;
 219   struct eh_frame_hdr_info *hdr_info;
 220   struct eh_frame_sec_info *sec_info = NULL;
 221   unsigned int leb128_tmp;
 222   unsigned int cie_usage_count, last_cie_ndx, i, offset;
 223   unsigned int make_relative, make_lsda_relative;
 224   bfd_size_type new_size;
 225   unsigned int ptr_size;
 226
 227   if (sec->_raw_size == 0)
 228     {
 229       /* This file does not contain .eh_frame information.  */
 230       return FALSE;
 231     }
 232
 233   if ((sec->output_section != NULL
 234        && bfd_is_abs_section (sec->output_section)))
 235     {
 236       /* At least one of the sections is being discarded from the
 237          link, so we should just ignore them.  */
 238       return FALSE;
 239     }
 240
 241   htab = elf_hash_table (info);
 242   hdr_info = &htab->eh_info;
 243
 244   /* Read the frame unwind information from abfd.  */
 245
 246   ehbuf = bfd_malloc (sec->_raw_size);
 247   if (ehbuf == NULL)
 248     goto free_no_table;
 249
 250   if (! bfd_get_section_contents (abfd, sec, ehbuf, 0, sec->_raw_size))
 251     goto free_no_table;
 252
 253   if (sec->_raw_size >= 4
 254       && bfd_get_32 (abfd, ehbuf) == 0
 255       && cookie->rel == cookie->relend)
 256     {
 257       /* Empty .eh_frame section.  */
 258       free (ehbuf);
 259       return FALSE;
 260     }
 261
 262   /* If .eh_frame section size doesn't fit into int, we cannot handle
 263      it (it would need to use 64-bit .eh_frame format anyway).  */
 264   if (sec->_raw_size != (unsigned int) sec->_raw_size)
 265     goto free_no_table;
 266
 267   ptr_size = (elf_elfheader (abfd)->e_ident[EI_CLASS]
 268               == ELFCLASS64) ? 8 : 4;
 269   buf = ehbuf;
 270   last_cie = NULL;
 271   last_cie_ndx = 0;
 272   memset (&cie, 0, sizeof (cie));
 273   cie_usage_count = 0;
 274   new_size = sec->_raw_size;
 275   make_relative = hdr_info->last_cie.make_relative;
 276   make_lsda_relative = hdr_info->last_cie.make_lsda_relative;
 277   sec_info = bfd_zmalloc (sizeof (struct eh_frame_sec_info)
 278                           + 99 * sizeof (struct eh_cie_fde));
 279   if (sec_info == NULL)
 280     goto free_no_table;
 281   sec_info->alloced = 100;
 282
 283 #define ENSURE_NO_RELOCS(buf)                           \
 284   if (cookie->rel < cookie->relend                      \
 285       && (cookie->rel->r_offset                         \
 286           < (bfd_size_type) ((buf) - ehbuf))            \
 287       && cookie->rel->r_info != 0)                      \
 288     goto free_no_table
 289
 290 #define SKIP_RELOCS(buf)                                \
 291   while (cookie->rel < cookie->relend                   \
 292          && (cookie->rel->r_offset                      \
 293              < (bfd_size_type) ((buf) - ehbuf)))        \
 294     cookie->rel++
 295
 296 #define GET_RELOC(buf)                                  \
 297   ((cookie->rel < cookie->relend                        \
 298     && (cookie->rel->r_offset                           \
 299         == (bfd_size_type) ((buf) - ehbuf)))            \
 300    ? cookie->rel : NULL)
 301
 302   for (;;)
 303     {
 304       unsigned char *aug;
 305
 306       if (sec_info->count == sec_info->alloced)
 307         {
 308           sec_info = bfd_realloc (sec_info,
 309                                   sizeof (struct eh_frame_sec_info)
 310                                   + (sec_info->alloced + 99)
 311                                      * sizeof (struct eh_cie_fde));
 312           if (sec_info == NULL)
 313             goto free_no_table;
 314
 315           memset (&sec_info->entry[sec_info->alloced], 0,
 316                   100 * sizeof (struct eh_cie_fde));
 317           sec_info->alloced += 100;
 318         }
 319
 320       last_fde = buf;
 321       /* If we are at the end of the section, we still need to decide
 322          on whether to output or discard last encountered CIE (if any).  */
 323       if ((bfd_size_type) (buf - ehbuf) == sec->_raw_size)
 324         hdr.id = (unsigned int) -1;
 325       else
 326         {
 327           if ((bfd_size_type) (buf + 4 - ehbuf) > sec->_raw_size)
 328             /* No space for CIE/FDE header length.  */
 329             goto free_no_table;
 330
 331           hdr.length = bfd_get_32 (abfd, buf);
 332           if (hdr.length == 0xffffffff)
 333             /* 64-bit .eh_frame is not supported.  */
 334             goto free_no_table;
 335           buf += 4;
 336           if ((bfd_size_type) (buf - ehbuf) + hdr.length > sec->_raw_size)
 337             /* CIE/FDE not contained fully in this .eh_frame input section.  */
 338             goto free_no_table;
 339
 340           sec_info->entry[sec_info->count].offset = last_fde - ehbuf;
 341           sec_info->entry[sec_info->count].size = 4 + hdr.length;
 342
 343           if (hdr.length == 0)
 344             {
 345               /* CIE with length 0 must be only the last in the section.  */
 346               if ((bfd_size_type) (buf - ehbuf) < sec->_raw_size)
 347                 goto free_no_table;
 348               ENSURE_NO_RELOCS (buf);
 349               sec_info->count++;
 350               /* Now just finish last encountered CIE processing and break
 351                  the loop.  */
 352               hdr.id = (unsigned int) -1;
 353             }
 354           else
 355             {
 356               hdr.id = bfd_get_32 (abfd, buf);
 357               buf += 4;
 358               if (hdr.id == (unsigned int) -1)
 359                 goto free_no_table;
 360             }
 361         }
 362
 363       if (hdr.id == 0 || hdr.id == (unsigned int) -1)
 364         {
 365           unsigned int initial_insn_length;
 366
 367           /* CIE  */
 368           if (last_cie != NULL)
 369             {
 370               /* Now check if this CIE is identical to the last CIE,
 371                  in which case we can remove it provided we adjust
 372                  all FDEs.  Also, it can be removed if we have removed
 373                  all FDEs using it.  */
 374               if ((!info->relocatable
 375                    && hdr_info->last_cie_sec
 376                    && (sec->output_section
 377                        == hdr_info->last_cie_sec->output_section)
 378                    && cie_compare (&cie, &hdr_info->last_cie) == 0)
 379                   || cie_usage_count == 0)
 380                 {
 381                   new_size -= cie.hdr.length + 4;
 382                   sec_info->entry[last_cie_ndx].removed = 1;
 383                   sec_info->entry[last_cie_ndx].sec = hdr_info->last_cie_sec;
 384                   sec_info->entry[last_cie_ndx].new_offset
 385                     = hdr_info->last_cie_offset;
 386                 }
 387               else
 388                 {
 389                   hdr_info->last_cie = cie;
 390                   hdr_info->last_cie_sec = sec;
 391                   hdr_info->last_cie_offset = last_cie - ehbuf;
 392                   sec_info->entry[last_cie_ndx].make_relative
 393                     = cie.make_relative;
 394                   sec_info->entry[last_cie_ndx].make_lsda_relative
 395                     = cie.make_lsda_relative;
 396                   sec_info->entry[last_cie_ndx].per_encoding_relative
 397                     = (cie.per_encoding & 0x70) == DW_EH_PE_pcrel;
 398                 }
 399             }
 400
 401           if (hdr.id == (unsigned int) -1)
 402             break;
 403
 404           last_cie_ndx = sec_info->count;
 405           sec_info->entry[sec_info->count].cie = 1;
 406
 407           cie_usage_count = 0;
 408           memset (&cie, 0, sizeof (cie));
 409           cie.hdr = hdr;
 410           cie.version = *buf++;
 411
 412           /* Cannot handle unknown versions.  */
 413           if (cie.version != 1 && cie.version != 3)
 414             goto free_no_table;
 415           if (strlen (buf) > sizeof (cie.augmentation) - 1)
 416             goto free_no_table;
 417
 418           strcpy (cie.augmentation, buf);
 419           buf = strchr (buf, '\0') + 1;
 420           ENSURE_NO_RELOCS (buf);
 421           if (buf[0] == 'e' && buf[1] == 'h')
 422             {
 423               /* GCC < 3.0 .eh_frame CIE */
 424               /* We cannot merge "eh" CIEs because __EXCEPTION_TABLE__
 425                  is private to each CIE, so we don't need it for anything.
 426                  Just skip it.  */
 427               buf += ptr_size;
 428               SKIP_RELOCS (buf);
 429             }
 430           read_uleb128 (cie.code_align, buf);
 431           read_sleb128 (cie.data_align, buf);
 432           if (cie.version == 1)
 433             cie.ra_column = *buf++;
 434           else
 435             read_uleb128 (cie.ra_column, buf);
 436           ENSURE_NO_RELOCS (buf);
 437           cie.lsda_encoding = DW_EH_PE_omit;
 438           cie.fde_encoding = DW_EH_PE_omit;
 439           cie.per_encoding = DW_EH_PE_omit;
 440           aug = cie.augmentation;
 441           if (aug[0] != 'e' || aug[1] != 'h')
 442             {
 443               if (*aug == 'z')
 444                 {
 445                   aug++;
 446                   read_uleb128 (cie.augmentation_size, buf);
 447                   ENSURE_NO_RELOCS (buf);
 448                 }
 449
 450               while (*aug != '\0')
 451                 switch (*aug++)
 452                   {
 453                   case 'L':
 454                     cie.lsda_encoding = *buf++;
 455                     ENSURE_NO_RELOCS (buf);
 456                     if (get_DW_EH_PE_width (cie.lsda_encoding, ptr_size) == 0)
 457                       goto free_no_table;
 458                     break;
 459                   case 'R':
 460                     cie.fde_encoding = *buf++;
 461                     ENSURE_NO_RELOCS (buf);
 462                     if (get_DW_EH_PE_width (cie.fde_encoding, ptr_size) == 0)
 463                       goto free_no_table;
 464                     break;
 465                   case 'P':
 466                     {
 467                       int per_width;
 468
 469                       cie.per_encoding = *buf++;
 470                       per_width = get_DW_EH_PE_width (cie.per_encoding,
 471                                                       ptr_size);
 472                       if (per_width == 0)
 473                         goto free_no_table;
 474                       if ((cie.per_encoding & 0xf0) == DW_EH_PE_aligned)
 475                         buf = (ehbuf
 476                                + ((buf - ehbuf + per_width - 1)
 477                                   & ~((bfd_size_type) per_width - 1)));
 478                       ENSURE_NO_RELOCS (buf);
 479                       /* Ensure we have a reloc here, against
 480                          a global symbol.  */
 481                       if (GET_RELOC (buf) != NULL)
 482                         {
 483                           unsigned long r_symndx;
 484
 485 #ifdef BFD64
 486                           if (ptr_size == 8)
 487                             r_symndx = ELF64_R_SYM (cookie->rel->r_info);
 488                           else
 489 #endif
 490                             r_symndx = ELF32_R_SYM (cookie->rel->r_info);
 491                           if (r_symndx >= cookie->locsymcount)
 492                             {
 493                               struct elf_link_hash_entry *h;
 494
 495                               r_symndx -= cookie->extsymoff;
 496                               h = cookie->sym_hashes[r_symndx];
 497
 498                               while (h->root.type == bfd_link_hash_indirect
 499                                      || h->root.type == bfd_link_hash_warning)
 500                                 h = (struct elf_link_hash_entry *)
 501                                     h->root.u.i.link;
 502
 503                               cie.personality = h;
 504                             }
 505                           cookie->rel++;
 506                         }
 507                       buf += per_width;
 508                     }
 509                     break;
 510                   default:
 511                     /* Unrecognized augmentation. Better bail out.  */
 512                     goto free_no_table;
 513                   }
 514             }
 515
 516           /* For shared libraries, try to get rid of as many RELATIVE relocs
 517              as possible.  */
 518           if (info->shared
 519               && (get_elf_backend_data (abfd)
 520                   ->elf_backend_can_make_relative_eh_frame
 521                   (abfd, info, sec))
 522               && (cie.fde_encoding & 0xf0) == DW_EH_PE_absptr)
 523             cie.make_relative = 1;
 524
 525           if (info->shared
 526               && (get_elf_backend_data (abfd)
 527                   ->elf_backend_can_make_lsda_relative_eh_frame
 528                   (abfd, info, sec))
 529               && (cie.lsda_encoding & 0xf0) == DW_EH_PE_absptr)
 530             cie.make_lsda_relative = 1;
 531
 532           /* If FDE encoding was not specified, it defaults to
 533              DW_EH_absptr.  */
 534           if (cie.fde_encoding == DW_EH_PE_omit)
 535             cie.fde_encoding = DW_EH_PE_absptr;
 536
 537           initial_insn_length = cie.hdr.length - (buf - last_fde - 4);
 538           if (initial_insn_length <= 50)
 539             {
 540               cie.initial_insn_length = initial_insn_length;
 541               memcpy (cie.initial_instructions, buf, initial_insn_length);
 542             }
 543           buf += initial_insn_length;
 544           ENSURE_NO_RELOCS (buf);
 545           last_cie = last_fde;
 546         }
 547       else
 548         {
 549           /* Ensure this FDE uses the last CIE encountered.  */
 550           if (last_cie == NULL
 551               || hdr.id != (unsigned int) (buf - 4 - last_cie))
 552             goto free_no_table;
 553
 554           ENSURE_NO_RELOCS (buf);
 555           if (GET_RELOC (buf) == NULL)
 556             /* This should not happen.  */
 557             goto free_no_table;
 558           if ((*reloc_symbol_deleted_p) (buf - ehbuf, cookie))
 559             {
 560               /* This is a FDE against a discarded section.  It should
 561                  be deleted.  */
 562               new_size -= hdr.length + 4;
 563               sec_info->entry[sec_info->count].removed = 1;
 564             }
 565           else
 566             {
 567               if (info->shared
 568                   && (((cie.fde_encoding & 0xf0) == DW_EH_PE_absptr
 569                        && cie.make_relative == 0)
 570                       || (cie.fde_encoding & 0xf0) == DW_EH_PE_aligned))
 571                 {
 572                   /* If a shared library uses absolute pointers
 573                      which we cannot turn into PC relative,
 574                      don't create the binary search table,
 575                      since it is affected by runtime relocations.  */
 576                   hdr_info->table = FALSE;
 577                 }
 578               cie_usage_count++;
 579               hdr_info->fde_count++;
 580             }
 581           if (cie.lsda_encoding != DW_EH_PE_omit)
 582             {
 583               unsigned int dummy;
 584
 585               aug = buf;
 586               buf += 2 * get_DW_EH_PE_width (cie.fde_encoding, ptr_size);
 587               if (cie.augmentation[0] == 'z')
 588                 read_uleb128 (dummy, buf);
 589               /* If some new augmentation data is added before LSDA
 590                  in FDE augmentation area, this need to be adjusted.  */
 591               sec_info->entry[sec_info->count].lsda_offset = (buf - aug);
 592             }
 593           buf = last_fde + 4 + hdr.length;
 594           SKIP_RELOCS (buf);
 595         }
 596
 597       sec_info->entry[sec_info->count].fde_encoding = cie.fde_encoding;
 598       sec_info->entry[sec_info->count].lsda_encoding = cie.lsda_encoding;
 599       sec_info->count++;
 600     }
 601
 602   elf_section_data (sec)->sec_info = sec_info;
 603   sec->sec_info_type = ELF_INFO_TYPE_EH_FRAME;
 604
 605   /* Ok, now we can assign new offsets.  */
 606   offset = 0;
 607   last_cie_ndx = 0;
 608   for (i = 0; i < sec_info->count; i++)
 609     {
 610       if (! sec_info->entry[i].removed)
 611         {
 612           sec_info->entry[i].new_offset = offset;
 613           offset += sec_info->entry[i].size;
 614           if (sec_info->entry[i].cie)
 615             {
 616               last_cie_ndx = i;
 617               make_relative = sec_info->entry[i].make_relative;
 618               make_lsda_relative = sec_info->entry[i].make_lsda_relative;
 619             }
 620           else
 621             {
 622               sec_info->entry[i].make_relative = make_relative;
 623               sec_info->entry[i].make_lsda_relative = make_lsda_relative;
 624               sec_info->entry[i].per_encoding_relative = 0;
 625             }
 626         }
 627       else if (sec_info->entry[i].cie && sec_info->entry[i].sec == sec)
 628         {
 629           /* Need to adjust new_offset too.  */
 630           BFD_ASSERT (sec_info->entry[last_cie_ndx].offset
 631                       == sec_info->entry[i].new_offset);
 632           sec_info->entry[i].new_offset
 633             = sec_info->entry[last_cie_ndx].new_offset;
 634         }
 635     }
 636   if (hdr_info->last_cie_sec == sec)
 637     {
 638       BFD_ASSERT (sec_info->entry[last_cie_ndx].offset
 639                   == hdr_info->last_cie_offset);
 640       hdr_info->last_cie_offset = sec_info->entry[last_cie_ndx].new_offset;
 641     }
 642
 643   /* FIXME: Currently it is not possible to shrink sections to zero size at
 644      this point, so build a fake minimal CIE.  */
 645   if (new_size == 0)
 646     new_size = 16;
 647
 648   /* Shrink the sec as needed.  */
 649   sec->_cooked_size = new_size;
 650   if (sec->_cooked_size == 0)
 651     sec->flags |= SEC_EXCLUDE;
 652
 653   free (ehbuf);
 654   return new_size != sec->_raw_size;
 655
 656 free_no_table:
 657   if (ehbuf)
 658     free (ehbuf);
 659   if (sec_info)
 660     free (sec_info);
 661   hdr_info->table = FALSE;
 662   hdr_info->last_cie.hdr.length = 0;
 663   return FALSE;
 664 }
 665
 666 /* This function is called for .eh_frame_hdr section after
 667    _bfd_elf_discard_section_eh_frame has been called on all .eh_frame
 668    input sections.  It finalizes the size of .eh_frame_hdr section.  */
 669
 670 bfd_boolean
 671 _bfd_elf_discard_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
 672 {
 673   struct elf_link_hash_table *htab;
 674   struct eh_frame_hdr_info *hdr_info;
 675   asection *sec;
 676
 677   htab = elf_hash_table (info);
 678   hdr_info = &htab->eh_info;
 679   sec = hdr_info->hdr_sec;
 680   if (sec == NULL)
 681     return FALSE;
 682
 683   sec->_cooked_size = EH_FRAME_HDR_SIZE;
 684   if (hdr_info->table)
 685     sec->_cooked_size += 4 + hdr_info->fde_count * 8;
 686
 687   /* Request program headers to be recalculated.  */
 688   elf_tdata (abfd)->program_header_size = 0;
 689   elf_tdata (abfd)->eh_frame_hdr = sec;
 690   return TRUE;
 691 }
 692
 693 /* This function is called from size_dynamic_sections.
 694    It needs to decide whether .eh_frame_hdr should be output or not,
 695    because later on it is too late for calling _bfd_strip_section_from_output,
 696    since dynamic symbol table has been sized.  */
 697
 698 bfd_boolean
 699 _bfd_elf_maybe_strip_eh_frame_hdr (struct bfd_link_info *info)
 700 {
 701   asection *o;
 702   bfd *abfd;
 703   struct elf_link_hash_table *htab;
 704   struct eh_frame_hdr_info *hdr_info;
 705
 706   htab = elf_hash_table (info);
 707   hdr_info = &htab->eh_info;
 708   if (hdr_info->hdr_sec == NULL)
 709     return TRUE;
 710
 711   if (bfd_is_abs_section (hdr_info->hdr_sec->output_section))
 712     {
 713       hdr_info->hdr_sec = NULL;
 714       return TRUE;
 715     }
 716
 717   abfd = NULL;
 718   if (info->eh_frame_hdr)
 719     for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link_next)
 720       {
 721         /* Count only sections which have at least a single CIE or FDE.
 722            There cannot be any CIE or FDE <= 8 bytes.  */
 723         o = bfd_get_section_by_name (abfd, ".eh_frame");
 724         if (o && o->_raw_size > 8 && !bfd_is_abs_section (o->output_section))
 725           break;
 726       }
 727
 728   if (abfd == NULL)
 729     {
 730       _bfd_strip_section_from_output (info, hdr_info->hdr_sec);
 731       hdr_info->hdr_sec = NULL;
 732       return TRUE;
 733     }
 734
 735   hdr_info->table = TRUE;
 736   return TRUE;
 737 }
 738
 739 /* Adjust an address in the .eh_frame section.  Given OFFSET within
 740    SEC, this returns the new offset in the adjusted .eh_frame section,
 741    or -1 if the address refers to a CIE/FDE which has been removed
 742    or to offset with dynamic relocation which is no longer needed.  */
 743
 744 bfd_vma
 745 _bfd_elf_eh_frame_section_offset (bfd *output_bfd ATTRIBUTE_UNUSED,
 746                                   asection *sec,
 747                                   bfd_vma offset)
 748 {
 749   struct eh_frame_sec_info *sec_info;
 750   unsigned int lo, hi, mid;
 751
 752   if (sec->sec_info_type != ELF_INFO_TYPE_EH_FRAME)
 753     return offset;
 754   sec_info = elf_section_data (sec)->sec_info;
 755
 756   if (offset >= sec->_raw_size)
 757     return offset - (sec->_cooked_size - sec->_raw_size);
 758
 759   lo = 0;
 760   hi = sec_info->count;
 761   mid = 0;
 762   while (lo < hi)
 763     {
 764       mid = (lo + hi) / 2;
 765       if (offset < sec_info->entry[mid].offset)
 766         hi = mid;
 767       else if (offset
 768                >= sec_info->entry[mid].offset + sec_info->entry[mid].size)
 769         lo = mid + 1;
 770       else
 771         break;
 772     }
 773
 774   BFD_ASSERT (lo < hi);
 775
 776   /* FDE or CIE was removed.  */
 777   if (sec_info->entry[mid].removed)
 778     return (bfd_vma) -1;
 779
 780   /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
 781      relocation against FDE's initial_location field.  */
 782   if (sec_info->entry[mid].make_relative
 783       && ! sec_info->entry[mid].cie
 784       && offset == sec_info->entry[mid].offset + 8)
 785     return (bfd_vma) -2;
 786
 787   /* If converting LSDA pointers to DW_EH_PE_pcrel, there will be no need
 788      for run-time relocation against LSDA field.  */
 789   if (sec_info->entry[mid].make_lsda_relative
 790       && ! sec_info->entry[mid].cie
 791       && (offset == (sec_info->entry[mid].offset + 8
 792                      + sec_info->entry[mid].lsda_offset)))
 793     return (bfd_vma) -2;
 794
 795   return (offset + sec_info->entry[mid].new_offset
 796           - sec_info->entry[mid].offset);
 797 }
 798
 799 /* Write out .eh_frame section.  This is called with the relocated
 800    contents.  */
 801
 802 bfd_boolean
 803 _bfd_elf_write_section_eh_frame (bfd *abfd,
 804                                  struct bfd_link_info *info,
 805                                  asection *sec,
 806                                  bfd_byte *contents)
 807 {
 808   struct eh_frame_sec_info *sec_info;
 809   struct elf_link_hash_table *htab;
 810   struct eh_frame_hdr_info *hdr_info;
 811   unsigned int i;
 812   bfd_byte *p, *buf;
 813   unsigned int leb128_tmp;
 814   unsigned int cie_offset = 0;
 815   unsigned int ptr_size;
 816
 817   ptr_size = (elf_elfheader (sec->owner)->e_ident[EI_CLASS]
 818               == ELFCLASS64) ? 8 : 4;
 819
 820   if (sec->sec_info_type != ELF_INFO_TYPE_EH_FRAME)
 821     return bfd_set_section_contents (abfd, sec->output_section, contents,
 822                                      sec->output_offset, sec->_raw_size);
 823   sec_info = elf_section_data (sec)->sec_info;
 824   htab = elf_hash_table (info);
 825   hdr_info = &htab->eh_info;
 826   if (hdr_info->table && hdr_info->array == NULL)
 827     hdr_info->array
 828       = bfd_malloc (hdr_info->fde_count * sizeof(*hdr_info->array));
 829   if (hdr_info->array == NULL)
 830     hdr_info = NULL;
 831
 832   p = contents;
 833   for (i = 0; i < sec_info->count; ++i)
 834     {
 835       if (sec_info->entry[i].removed)
 836         {
 837           if (sec_info->entry[i].cie)
 838             {
 839               /* If CIE is removed due to no remaining FDEs referencing it
 840                  and there were no CIEs kept before it, sec_info->entry[i].sec
 841                  will be zero.  */
 842               if (sec_info->entry[i].sec == NULL)
 843                 cie_offset = 0;
 844               else
 845                 {
 846                   cie_offset = sec_info->entry[i].new_offset;
 847                   cie_offset += (sec_info->entry[i].sec->output_section->vma
 848                                  + sec_info->entry[i].sec->output_offset
 849                                  - sec->output_section->vma
 850                                  - sec->output_offset);
 851                 }
 852             }
 853           continue;
 854         }
 855
 856       if (sec_info->entry[i].cie)
 857         {
 858           /* CIE */
 859           cie_offset = sec_info->entry[i].new_offset;
 860           if (sec_info->entry[i].make_relative
 861               || sec_info->entry[i].make_lsda_relative
 862               || sec_info->entry[i].per_encoding_relative)
 863             {
 864               unsigned char *aug;
 865               unsigned int action;
 866               unsigned int dummy, per_width, per_encoding;
 867
 868               /* Need to find 'R' or 'L' augmentation's argument and modify
 869                  DW_EH_PE_* value.  */
 870               action = (sec_info->entry[i].make_relative ? 1 : 0)
 871                        | (sec_info->entry[i].make_lsda_relative ? 2 : 0)
 872                        | (sec_info->entry[i].per_encoding_relative ? 4 : 0);
 873               buf = contents + sec_info->entry[i].offset;
 874               /* Skip length, id and version.  */
 875               buf += 9;
 876               aug = buf;
 877               buf = strchr (buf, '\0') + 1;
 878               read_uleb128 (dummy, buf);
 879               read_sleb128 (dummy, buf);
 880               read_uleb128 (dummy, buf);
 881               if (*aug == 'z')
 882                 {
 883                   read_uleb128 (dummy, buf);
 884                   aug++;
 885                 }
 886
 887               while (action)
 888                 switch (*aug++)
 889                   {
 890                   case 'L':
 891                     if (action & 2)
 892                       {
 893                         BFD_ASSERT (*buf == sec_info->entry[i].lsda_encoding);
 894                         *buf |= DW_EH_PE_pcrel;
 895                         action &= ~2;
 896                       }
 897                     buf++;
 898                     break;
 899                   case 'P':
 900                     per_encoding = *buf++;
 901                     per_width = get_DW_EH_PE_width (per_encoding,
 902                                                     ptr_size);
 903                     BFD_ASSERT (per_width != 0);
 904                     BFD_ASSERT (((per_encoding & 0x70) == DW_EH_PE_pcrel)
 905                                 == sec_info->entry[i].per_encoding_relative);
 906                     if ((per_encoding & 0xf0) == DW_EH_PE_aligned)
 907                       buf = (contents
 908                              + ((buf - contents + per_width - 1)
 909                                 & ~((bfd_size_type) per_width - 1)));
 910                     if (action & 4)
 911                       {
 912                         bfd_vma value;
 913
 914                         value = read_value (abfd, buf, per_width,
 915                                             get_DW_EH_PE_signed
 916                                             (per_encoding));
 917                         value += (sec_info->entry[i].offset
 918                                   - sec_info->entry[i].new_offset);
 919                         write_value (abfd, buf, value, per_width);
 920                         action &= ~4;
 921                       }
 922                     buf += per_width;
 923                     break;
 924                   case 'R':
 925                     if (action & 1)
 926                       {
 927                         BFD_ASSERT (*buf == sec_info->entry[i].fde_encoding);
 928                         *buf |= DW_EH_PE_pcrel;
 929                         action &= ~1;
 930                       }
 931                     buf++;
 932                     break;
 933                   default:
 934                     BFD_FAIL ();
 935                   }
 936             }
 937         }
 938       else if (sec_info->entry[i].size > 4)
 939         {
 940           /* FDE */
 941           bfd_vma value = 0, address;
 942           unsigned int width;
 943
 944           buf = contents + sec_info->entry[i].offset;
 945           /* Skip length.  */
 946           buf += 4;
 947           bfd_put_32 (abfd,
 948                       sec_info->entry[i].new_offset + 4 - cie_offset, buf);
 949           buf += 4;
 950           width = get_DW_EH_PE_width (sec_info->entry[i].fde_encoding,
 951                                       ptr_size);
 952           address = value = read_value (abfd, buf, width,
 953                                         get_DW_EH_PE_signed
 954                                         (sec_info->entry[i].fde_encoding));
 955           if (value)
 956             {
 957               switch (sec_info->entry[i].fde_encoding & 0xf0)
 958                 {
 959                 case DW_EH_PE_indirect:
 960                 case DW_EH_PE_textrel:
 961                   BFD_ASSERT (hdr_info == NULL);
 962                   break;
 963                 case DW_EH_PE_datarel:
 964                   {
 965                     asection *got = bfd_get_section_by_name (abfd, ".got");
 966
 967                     BFD_ASSERT (got != NULL);
 968                     address += got->vma;
 969                   }
 970                   break;
 971                 case DW_EH_PE_pcrel:
 972                   value += (sec_info->entry[i].offset
 973                             - sec_info->entry[i].new_offset);
 974                   address += (sec->output_section->vma + sec->output_offset
 975                               + sec_info->entry[i].offset + 8);
 976                   break;
 977                 }
 978               if (sec_info->entry[i].make_relative)
 979                 value -= (sec->output_section->vma + sec->output_offset
 980                           + sec_info->entry[i].new_offset + 8);
 981               write_value (abfd, buf, value, width);
 982             }
 983
 984           if (hdr_info)
 985             {
 986               hdr_info->array[hdr_info->array_count].initial_loc = address;
 987               hdr_info->array[hdr_info->array_count++].fde
 988                 = (sec->output_section->vma + sec->output_offset
 989                    + sec_info->entry[i].new_offset);
 990             }
 991
 992           if ((sec_info->entry[i].lsda_encoding & 0xf0) == DW_EH_PE_pcrel
 993               || sec_info->entry[i].make_lsda_relative)
 994             {
 995               buf += sec_info->entry[i].lsda_offset;
 996               width = get_DW_EH_PE_width (sec_info->entry[i].lsda_encoding,
 997                                           ptr_size);
 998               value = read_value (abfd, buf, width,
 999                                   get_DW_EH_PE_signed
1000                                   (sec_info->entry[i].lsda_encoding));
1001               if (value)
1002                 {
1003                   if ((sec_info->entry[i].lsda_encoding & 0xf0)
1004                       == DW_EH_PE_pcrel)
1005                     value += (sec_info->entry[i].offset
1006                               - sec_info->entry[i].new_offset);
1007                   else if (sec_info->entry[i].make_lsda_relative)
1008                     value -= (sec->output_section->vma + sec->output_offset
1009                               + sec_info->entry[i].new_offset + 8
1010                               + sec_info->entry[i].lsda_offset);
1011                   write_value (abfd, buf, value, width);
1012                 }
1013             }
1014         }
1015       else
1016         /* Terminating FDE must be at the end of .eh_frame section only.  */
1017         BFD_ASSERT (i == sec_info->count - 1);
1018
1019       BFD_ASSERT (p == contents + sec_info->entry[i].new_offset);
1020       memmove (p, contents + sec_info->entry[i].offset,
1021                sec_info->entry[i].size);
1022       p += sec_info->entry[i].size;
1023     }
1024
1025   /* FIXME: Once _bfd_elf_discard_section_eh_frame will be able to
1026      shrink sections to zero size, this won't be needed any more.  */
1027   if (p == contents && sec->_cooked_size == 16)
1028     {
1029       bfd_put_32 (abfd, 12, p);         /* Fake CIE length */
1030       bfd_put_32 (abfd, 0, p + 4);      /* Fake CIE id */
1031       p[8] = 1;                         /* Fake CIE version */
1032       memset (p + 9, 0, 7);             /* Fake CIE augmentation, 3xleb128
1033                                            and 3xDW_CFA_nop as pad  */
1034       p += 16;
1035     }
1036   else
1037     {
1038       unsigned int alignment = 1 << sec->alignment_power;
1039       unsigned int pad = sec->_cooked_size % alignment;
1040
1041       /* Don't pad beyond the raw size of the output section. It
1042          can happen at the last input section.  */
1043       if (pad
1044           && ((sec->output_offset + sec->_cooked_size + pad)
1045               <= sec->output_section->_raw_size))
1046         {
1047           /* Find the last CIE/FDE.  */
1048           for (i = sec_info->count - 1; i > 0; i--)
1049             if (! sec_info->entry[i].removed)
1050               break;
1051
1052           /* The size of the last CIE/FDE must be at least 4.  */
1053           if (sec_info->entry[i].removed
1054               || sec_info->entry[i].size < 4)
1055             abort ();
1056
1057           pad = alignment - pad;
1058
1059           buf = contents + sec_info->entry[i].new_offset;
1060
1061           /* Update length.  */
1062           sec_info->entry[i].size += pad;
1063           bfd_put_32 (abfd, sec_info->entry[i].size - 4, buf);
1064
1065           /* Pad it with DW_CFA_nop  */
1066           memset (p, 0, pad);
1067           p += pad;
1068
1069           sec->_cooked_size += pad;
1070         }
1071     }
1072
1073   BFD_ASSERT ((bfd_size_type) (p - contents) == sec->_cooked_size);
1074
1075   return bfd_set_section_contents (abfd, sec->output_section,
1076                                    contents, (file_ptr) sec->output_offset,
1077                                    sec->_cooked_size);
1078 }
1079
1080 /* Helper function used to sort .eh_frame_hdr search table by increasing
1081    VMA of FDE initial location.  */
1082
1083 static int
1084 vma_compare (const void *a, const void *b)
1085 {
1086   const struct eh_frame_array_ent *p = a;
1087   const struct eh_frame_array_ent *q = b;
1088   if (p->initial_loc > q->initial_loc)
1089     return 1;
1090   if (p->initial_loc < q->initial_loc)
1091     return -1;
1092   return 0;
1093 }
1094
1095 /* Write out .eh_frame_hdr section.  This must be called after
1096    _bfd_elf_write_section_eh_frame has been called on all input
1097    .eh_frame sections.
1098    .eh_frame_hdr format:
1099    ubyte version                (currently 1)
1100    ubyte eh_frame_ptr_enc       (DW_EH_PE_* encoding of pointer to start of
1101                                  .eh_frame section)
1102    ubyte fde_count_enc          (DW_EH_PE_* encoding of total FDE count
1103                                  number (or DW_EH_PE_omit if there is no
1104                                  binary search table computed))
1105    ubyte table_enc              (DW_EH_PE_* encoding of binary search table,
1106                                  or DW_EH_PE_omit if not present.
1107                                  DW_EH_PE_datarel is using address of
1108                                  .eh_frame_hdr section start as base)
1109    [encoded] eh_frame_ptr       (pointer to start of .eh_frame section)
1110    optionally followed by:
1111    [encoded] fde_count          (total number of FDEs in .eh_frame section)
1112    fde_count x [encoded] initial_loc, fde
1113                                 (array of encoded pairs containing
1114                                  FDE initial_location field and FDE address,
1115                                  sorted by increasing initial_loc).  */
1116
1117 bfd_boolean
1118 _bfd_elf_write_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
1119 {
1120   struct elf_link_hash_table *htab;
1121   struct eh_frame_hdr_info *hdr_info;
1122   asection *sec;
1123   bfd_byte *contents;
1124   asection *eh_frame_sec;
1125   bfd_size_type size;
1126   bfd_boolean retval;
1127   bfd_vma encoded_eh_frame;
1128
1129   htab = elf_hash_table (info);
1130   hdr_info = &htab->eh_info;
1131   sec = hdr_info->hdr_sec;
1132   if (sec == NULL)
1133     return TRUE;
1134
1135   size = EH_FRAME_HDR_SIZE;
1136   if (hdr_info->array && hdr_info->array_count == hdr_info->fde_count)
1137     size += 4 + hdr_info->fde_count * 8;
1138   contents = bfd_malloc (size);
1139   if (contents == NULL)
1140     return FALSE;
1141
1142   eh_frame_sec = bfd_get_section_by_name (abfd, ".eh_frame");
1143   if (eh_frame_sec == NULL)
1144     {
1145       free (contents);
1146       return FALSE;
1147     }
1148
1149   memset (contents, 0, EH_FRAME_HDR_SIZE);
1150   contents[0] = 1;                              /* Version.  */
1151   contents[1] = get_elf_backend_data (abfd)->elf_backend_encode_eh_address
1152     (abfd, info, eh_frame_sec, 0, sec, 4,
1153      &encoded_eh_frame);                        /* .eh_frame offset.  */
1154
1155   if (hdr_info->array && hdr_info->array_count == hdr_info->fde_count)
1156     {
1157       contents[2] = DW_EH_PE_udata4;            /* FDE count encoding.  */
1158       contents[3] = DW_EH_PE_datarel | DW_EH_PE_sdata4; /* Search table enc.  */
1159     }
1160   else
1161     {
1162       contents[2] = DW_EH_PE_omit;
1163       contents[3] = DW_EH_PE_omit;
1164     }
1165   bfd_put_32 (abfd, encoded_eh_frame, contents + 4);
1166
1167   if (contents[2] != DW_EH_PE_omit)
1168     {
1169       unsigned int i;
1170
1171       bfd_put_32 (abfd, hdr_info->fde_count, contents + EH_FRAME_HDR_SIZE);
1172       qsort (hdr_info->array, hdr_info->fde_count, sizeof (*hdr_info->array),
1173              vma_compare);
1174       for (i = 0; i < hdr_info->fde_count; i++)
1175         {
1176           bfd_put_32 (abfd,
1177                       hdr_info->array[i].initial_loc
1178                       - sec->output_section->vma,
1179                       contents + EH_FRAME_HDR_SIZE + i * 8 + 4);
1180           bfd_put_32 (abfd,
1181                       hdr_info->array[i].fde - sec->output_section->vma,
1182                       contents + EH_FRAME_HDR_SIZE + i * 8 + 8);
1183         }
1184     }
1185
1186   retval = bfd_set_section_contents (abfd, sec->output_section,
1187                                      contents, (file_ptr) sec->output_offset,
1188                                      sec->_cooked_size);
1189   free (contents);
1190   return retval;
1191 }
1192
1193 /* Decide whether we can use a PC-relative encoding within the given
1194    EH frame section.  This is the default implementation.  */
1195
1196 bfd_boolean
1197 _bfd_elf_can_make_relative (bfd *input_bfd ATTRIBUTE_UNUSED,
1198                             struct bfd_link_info *info ATTRIBUTE_UNUSED,
1199                             asection *eh_frame_section ATTRIBUTE_UNUSED)
1200 {
1201   return TRUE;
1202 }
1203
1204 /* Select an encoding for the given address.  Preference is given to
1205    PC-relative addressing modes.  */
1206
1207 bfd_byte
1208 _bfd_elf_encode_eh_address (bfd *abfd ATTRIBUTE_UNUSED,
1209                             struct bfd_link_info *info ATTRIBUTE_UNUSED,
1210                             asection *osec, bfd_vma offset,
1211                             asection *loc_sec, bfd_vma loc_offset,
1212                             bfd_vma *encoded)
1213 {
1214   *encoded = osec->vma + offset -
1215     (loc_sec->output_section->vma + loc_sec->output_offset + loc_offset);
1216   return DW_EH_PE_pcrel | DW_EH_PE_sdata4;
1217 }