Subversion Repositories Kolibri OS

Rev

Rev 5197 | Blame | Compare with Previous | Last modification | View Log | RSS feed

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