Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed

  1. /* .eh_frame section optimization.
  2.    Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011,
  3.    2012 Free Software Foundation, Inc.
  4.    Written by Jakub Jelinek <jakub@redhat.com>.
  5.  
  6.    This file is part of BFD, the Binary File Descriptor library.
  7.  
  8.    This program is free software; you can redistribute it and/or modify
  9.    it under the terms of the GNU General Public License as published by
  10.    the Free Software Foundation; either version 3 of the License, or
  11.    (at your option) any later version.
  12.  
  13.    This program is distributed in the hope that it will be useful,
  14.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16.    GNU General Public License for more details.
  17.  
  18.    You should have received a copy of the GNU General Public License
  19.    along with this program; if not, write to the Free Software
  20.    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  21.    MA 02110-1301, USA.  */
  22.  
  23. #include "sysdep.h"
  24. #include "bfd.h"
  25. #include "libbfd.h"
  26. #include "elf-bfd.h"
  27. #include "dwarf2.h"
  28.  
  29. #define EH_FRAME_HDR_SIZE 8
  30.  
  31. struct cie
  32. {
  33.   unsigned int length;
  34.   unsigned int hash;
  35.   unsigned char version;
  36.   unsigned char local_personality;
  37.   char augmentation[20];
  38.   bfd_vma code_align;
  39.   bfd_signed_vma data_align;
  40.   bfd_vma ra_column;
  41.   bfd_vma augmentation_size;
  42.   union {
  43.     struct elf_link_hash_entry *h;
  44.     bfd_vma val;
  45.     unsigned int reloc_index;
  46.   } personality;
  47.   asection *output_sec;
  48.   struct eh_cie_fde *cie_inf;
  49.   unsigned char per_encoding;
  50.   unsigned char lsda_encoding;
  51.   unsigned char fde_encoding;
  52.   unsigned char initial_insn_length;
  53.   unsigned char can_make_lsda_relative;
  54.   unsigned char initial_instructions[50];
  55. };
  56.  
  57.  
  58.  
  59. /* If *ITER hasn't reached END yet, read the next byte into *RESULT and
  60.    move onto the next byte.  Return true on success.  */
  61.  
  62. static inline bfd_boolean
  63. read_byte (bfd_byte **iter, bfd_byte *end, unsigned char *result)
  64. {
  65.   if (*iter >= end)
  66.     return FALSE;
  67.   *result = *((*iter)++);
  68.   return TRUE;
  69. }
  70.  
  71. /* Move *ITER over LENGTH bytes, or up to END, whichever is closer.
  72.    Return true it was possible to move LENGTH bytes.  */
  73.  
  74. static inline bfd_boolean
  75. skip_bytes (bfd_byte **iter, bfd_byte *end, bfd_size_type length)
  76. {
  77.   if ((bfd_size_type) (end - *iter) < length)
  78.     {
  79.       *iter = end;
  80.       return FALSE;
  81.     }
  82.   *iter += length;
  83.   return TRUE;
  84. }
  85.  
  86. /* Move *ITER over an leb128, stopping at END.  Return true if the end
  87.    of the leb128 was found.  */
  88.  
  89. static bfd_boolean
  90. skip_leb128 (bfd_byte **iter, bfd_byte *end)
  91. {
  92.   unsigned char byte;
  93.   do
  94.     if (!read_byte (iter, end, &byte))
  95.       return FALSE;
  96.   while (byte & 0x80);
  97.   return TRUE;
  98. }
  99.  
  100. /* Like skip_leb128, but treat the leb128 as an unsigned value and
  101.    store it in *VALUE.  */
  102.  
  103. static bfd_boolean
  104. read_uleb128 (bfd_byte **iter, bfd_byte *end, bfd_vma *value)
  105. {
  106.   bfd_byte *start, *p;
  107.  
  108.   start = *iter;
  109.   if (!skip_leb128 (iter, end))
  110.     return FALSE;
  111.  
  112.   p = *iter;
  113.   *value = *--p;
  114.   while (p > start)
  115.     *value = (*value << 7) | (*--p & 0x7f);
  116.  
  117.   return TRUE;
  118. }
  119.  
  120. /* Like read_uleb128, but for signed values.  */
  121.  
  122. static bfd_boolean
  123. read_sleb128 (bfd_byte **iter, bfd_byte *end, bfd_signed_vma *value)
  124. {
  125.   bfd_byte *start, *p;
  126.  
  127.   start = *iter;
  128.   if (!skip_leb128 (iter, end))
  129.     return FALSE;
  130.  
  131.   p = *iter;
  132.   *value = ((*--p & 0x7f) ^ 0x40) - 0x40;
  133.   while (p > start)
  134.     *value = (*value << 7) | (*--p & 0x7f);
  135.  
  136.   return TRUE;
  137. }
  138.  
  139. /* Return 0 if either encoding is variable width, or not yet known to bfd.  */
  140.  
  141. static
  142. int get_DW_EH_PE_width (int encoding, int ptr_size)
  143. {
  144.   /* DW_EH_PE_ values of 0x60 and 0x70 weren't defined at the time .eh_frame
  145.      was added to bfd.  */
  146.   if ((encoding & 0x60) == 0x60)
  147.     return 0;
  148.  
  149.   switch (encoding & 7)
  150.     {
  151.     case DW_EH_PE_udata2: return 2;
  152.     case DW_EH_PE_udata4: return 4;
  153.     case DW_EH_PE_udata8: return 8;
  154.     case DW_EH_PE_absptr: return ptr_size;
  155.     default:
  156.       break;
  157.     }
  158.  
  159.   return 0;
  160. }
  161.  
  162. #define get_DW_EH_PE_signed(encoding) (((encoding) & DW_EH_PE_signed) != 0)
  163.  
  164. /* Read a width sized value from memory.  */
  165.  
  166. static bfd_vma
  167. read_value (bfd *abfd, bfd_byte *buf, int width, int is_signed)
  168. {
  169.   bfd_vma value;
  170.  
  171.   switch (width)
  172.     {
  173.     case 2:
  174.       if (is_signed)
  175.         value = bfd_get_signed_16 (abfd, buf);
  176.       else
  177.         value = bfd_get_16 (abfd, buf);
  178.       break;
  179.     case 4:
  180.       if (is_signed)
  181.         value = bfd_get_signed_32 (abfd, buf);
  182.       else
  183.         value = bfd_get_32 (abfd, buf);
  184.       break;
  185.     case 8:
  186.       if (is_signed)
  187.         value = bfd_get_signed_64 (abfd, buf);
  188.       else
  189.         value = bfd_get_64 (abfd, buf);
  190.       break;
  191.     default:
  192.       BFD_FAIL ();
  193.       return 0;
  194.     }
  195.  
  196.   return value;
  197. }
  198.  
  199. /* Store a width sized value to memory.  */
  200.  
  201. static void
  202. write_value (bfd *abfd, bfd_byte *buf, bfd_vma value, int width)
  203. {
  204.   switch (width)
  205.     {
  206.     case 2: bfd_put_16 (abfd, value, buf); break;
  207.     case 4: bfd_put_32 (abfd, value, buf); break;
  208.     case 8: bfd_put_64 (abfd, value, buf); break;
  209.     default: BFD_FAIL ();
  210.     }
  211. }
  212.  
  213. /* Return one if C1 and C2 CIEs can be merged.  */
  214.  
  215. static int
  216. cie_eq (const void *e1, const void *e2)
  217. {
  218.   const struct cie *c1 = (const struct cie *) e1;
  219.   const struct cie *c2 = (const struct cie *) e2;
  220.  
  221.   if (c1->hash == c2->hash
  222.       && c1->length == c2->length
  223.       && c1->version == c2->version
  224.       && c1->local_personality == c2->local_personality
  225.       && strcmp (c1->augmentation, c2->augmentation) == 0
  226.       && strcmp (c1->augmentation, "eh") != 0
  227.       && c1->code_align == c2->code_align
  228.       && c1->data_align == c2->data_align
  229.       && c1->ra_column == c2->ra_column
  230.       && c1->augmentation_size == c2->augmentation_size
  231.       && memcmp (&c1->personality, &c2->personality,
  232.                  sizeof (c1->personality)) == 0
  233.       && c1->output_sec == c2->output_sec
  234.       && c1->per_encoding == c2->per_encoding
  235.       && c1->lsda_encoding == c2->lsda_encoding
  236.       && c1->fde_encoding == c2->fde_encoding
  237.       && c1->initial_insn_length == c2->initial_insn_length
  238.       && memcmp (c1->initial_instructions,
  239.                  c2->initial_instructions,
  240.                  c1->initial_insn_length) == 0)
  241.     return 1;
  242.  
  243.   return 0;
  244. }
  245.  
  246. static hashval_t
  247. cie_hash (const void *e)
  248. {
  249.   const struct cie *c = (const struct cie *) e;
  250.   return c->hash;
  251. }
  252.  
  253. static hashval_t
  254. cie_compute_hash (struct cie *c)
  255. {
  256.   hashval_t h = 0;
  257.   h = iterative_hash_object (c->length, h);
  258.   h = iterative_hash_object (c->version, h);
  259.   h = iterative_hash (c->augmentation, strlen (c->augmentation) + 1, h);
  260.   h = iterative_hash_object (c->code_align, h);
  261.   h = iterative_hash_object (c->data_align, h);
  262.   h = iterative_hash_object (c->ra_column, h);
  263.   h = iterative_hash_object (c->augmentation_size, h);
  264.   h = iterative_hash_object (c->personality, h);
  265.   h = iterative_hash_object (c->output_sec, h);
  266.   h = iterative_hash_object (c->per_encoding, h);
  267.   h = iterative_hash_object (c->lsda_encoding, h);
  268.   h = iterative_hash_object (c->fde_encoding, h);
  269.   h = iterative_hash_object (c->initial_insn_length, h);
  270.   h = iterative_hash (c->initial_instructions, c->initial_insn_length, h);
  271.   c->hash = h;
  272.   return h;
  273. }
  274.  
  275. /* Return the number of extra bytes that we'll be inserting into
  276.    ENTRY's augmentation string.  */
  277.  
  278. static INLINE unsigned int
  279. extra_augmentation_string_bytes (struct eh_cie_fde *entry)
  280. {
  281.   unsigned int size = 0;
  282.   if (entry->cie)
  283.     {
  284.       if (entry->add_augmentation_size)
  285.         size++;
  286.       if (entry->u.cie.add_fde_encoding)
  287.         size++;
  288.     }
  289.   return size;
  290. }
  291.  
  292. /* Likewise ENTRY's augmentation data.  */
  293.  
  294. static INLINE unsigned int
  295. extra_augmentation_data_bytes (struct eh_cie_fde *entry)
  296. {
  297.   unsigned int size = 0;
  298.   if (entry->add_augmentation_size)
  299.     size++;
  300.   if (entry->cie && entry->u.cie.add_fde_encoding)
  301.     size++;
  302.   return size;
  303. }
  304.  
  305. /* Return the size that ENTRY will have in the output.  ALIGNMENT is the
  306.    required alignment of ENTRY in bytes.  */
  307.  
  308. static unsigned int
  309. size_of_output_cie_fde (struct eh_cie_fde *entry, unsigned int alignment)
  310. {
  311.   if (entry->removed)
  312.     return 0;
  313.   if (entry->size == 4)
  314.     return 4;
  315.   return (entry->size
  316.           + extra_augmentation_string_bytes (entry)
  317.           + extra_augmentation_data_bytes (entry)
  318.           + alignment - 1) & -alignment;
  319. }
  320.  
  321. /* Assume that the bytes between *ITER and END are CFA instructions.
  322.    Try to move *ITER past the first instruction and return true on
  323.    success.  ENCODED_PTR_WIDTH gives the width of pointer entries.  */
  324.  
  325. static bfd_boolean
  326. skip_cfa_op (bfd_byte **iter, bfd_byte *end, unsigned int encoded_ptr_width)
  327. {
  328.   bfd_byte op;
  329.   bfd_vma length;
  330.  
  331.   if (!read_byte (iter, end, &op))
  332.     return FALSE;
  333.  
  334.   switch (op & 0xc0 ? op & 0xc0 : op)
  335.     {
  336.     case DW_CFA_nop:
  337.     case DW_CFA_advance_loc:
  338.     case DW_CFA_restore:
  339.     case DW_CFA_remember_state:
  340.     case DW_CFA_restore_state:
  341.     case DW_CFA_GNU_window_save:
  342.       /* No arguments.  */
  343.       return TRUE;
  344.  
  345.     case DW_CFA_offset:
  346.     case DW_CFA_restore_extended:
  347.     case DW_CFA_undefined:
  348.     case DW_CFA_same_value:
  349.     case DW_CFA_def_cfa_register:
  350.     case DW_CFA_def_cfa_offset:
  351.     case DW_CFA_def_cfa_offset_sf:
  352.     case DW_CFA_GNU_args_size:
  353.       /* One leb128 argument.  */
  354.       return skip_leb128 (iter, end);
  355.  
  356.     case DW_CFA_val_offset:
  357.     case DW_CFA_val_offset_sf:
  358.     case DW_CFA_offset_extended:
  359.     case DW_CFA_register:
  360.     case DW_CFA_def_cfa:
  361.     case DW_CFA_offset_extended_sf:
  362.     case DW_CFA_GNU_negative_offset_extended:
  363.     case DW_CFA_def_cfa_sf:
  364.       /* Two leb128 arguments.  */
  365.       return (skip_leb128 (iter, end)
  366.               && skip_leb128 (iter, end));
  367.  
  368.     case DW_CFA_def_cfa_expression:
  369.       /* A variable-length argument.  */
  370.       return (read_uleb128 (iter, end, &length)
  371.               && skip_bytes (iter, end, length));
  372.  
  373.     case DW_CFA_expression:
  374.     case DW_CFA_val_expression:
  375.       /* A leb128 followed by a variable-length argument.  */
  376.       return (skip_leb128 (iter, end)
  377.               && read_uleb128 (iter, end, &length)
  378.               && skip_bytes (iter, end, length));
  379.  
  380.     case DW_CFA_set_loc:
  381.       return skip_bytes (iter, end, encoded_ptr_width);
  382.  
  383.     case DW_CFA_advance_loc1:
  384.       return skip_bytes (iter, end, 1);
  385.  
  386.     case DW_CFA_advance_loc2:
  387.       return skip_bytes (iter, end, 2);
  388.  
  389.     case DW_CFA_advance_loc4:
  390.       return skip_bytes (iter, end, 4);
  391.  
  392.     case DW_CFA_MIPS_advance_loc8:
  393.       return skip_bytes (iter, end, 8);
  394.  
  395.     default:
  396.       return FALSE;
  397.     }
  398. }
  399.  
  400. /* Try to interpret the bytes between BUF and END as CFA instructions.
  401.    If every byte makes sense, return a pointer to the first DW_CFA_nop
  402.    padding byte, or END if there is no padding.  Return null otherwise.
  403.    ENCODED_PTR_WIDTH is as for skip_cfa_op.  */
  404.  
  405. static bfd_byte *
  406. skip_non_nops (bfd_byte *buf, bfd_byte *end, unsigned int encoded_ptr_width,
  407.                unsigned int *set_loc_count)
  408. {
  409.   bfd_byte *last;
  410.  
  411.   last = buf;
  412.   while (buf < end)
  413.     if (*buf == DW_CFA_nop)
  414.       buf++;
  415.     else
  416.       {
  417.         if (*buf == DW_CFA_set_loc)
  418.           ++*set_loc_count;
  419.         if (!skip_cfa_op (&buf, end, encoded_ptr_width))
  420.           return 0;
  421.         last = buf;
  422.       }
  423.   return last;
  424. }
  425.  
  426. /* Convert absolute encoding ENCODING into PC-relative form.
  427.    SIZE is the size of a pointer.  */
  428.  
  429. static unsigned char
  430. make_pc_relative (unsigned char encoding, unsigned int ptr_size)
  431. {
  432.   if ((encoding & 0x7f) == DW_EH_PE_absptr)
  433.     switch (ptr_size)
  434.       {
  435.       case 2:
  436.         encoding |= DW_EH_PE_sdata2;
  437.         break;
  438.       case 4:
  439.         encoding |= DW_EH_PE_sdata4;
  440.         break;
  441.       case 8:
  442.         encoding |= DW_EH_PE_sdata8;
  443.         break;
  444.       }
  445.   return encoding | DW_EH_PE_pcrel;
  446. }
  447.  
  448. /* Called before calling _bfd_elf_parse_eh_frame on every input bfd's
  449.    .eh_frame section.  */
  450.  
  451. void
  452. _bfd_elf_begin_eh_frame_parsing (struct bfd_link_info *info)
  453. {
  454.   struct eh_frame_hdr_info *hdr_info;
  455.  
  456.   hdr_info = &elf_hash_table (info)->eh_info;
  457.   hdr_info->merge_cies = !info->relocatable;
  458. }
  459.  
  460. /* Try to parse .eh_frame section SEC, which belongs to ABFD.  Store the
  461.    information in the section's sec_info field on success.  COOKIE
  462.    describes the relocations in SEC.  */
  463.  
  464. void
  465. _bfd_elf_parse_eh_frame (bfd *abfd, struct bfd_link_info *info,
  466.                          asection *sec, struct elf_reloc_cookie *cookie)
  467. {
  468. #define REQUIRE(COND)                                   \
  469.   do                                                    \
  470.     if (!(COND))                                        \
  471.       goto free_no_table;                               \
  472.   while (0)
  473.  
  474.   bfd_byte *ehbuf = NULL, *buf, *end;
  475.   bfd_byte *last_fde;
  476.   struct eh_cie_fde *this_inf;
  477.   unsigned int hdr_length, hdr_id;
  478.   unsigned int cie_count;
  479.   struct cie *cie, *local_cies = NULL;
  480.   struct elf_link_hash_table *htab;
  481.   struct eh_frame_hdr_info *hdr_info;
  482.   struct eh_frame_sec_info *sec_info = NULL;
  483.   unsigned int ptr_size;
  484.   unsigned int num_cies;
  485.   unsigned int num_entries;
  486.   elf_gc_mark_hook_fn gc_mark_hook;
  487.  
  488.   htab = elf_hash_table (info);
  489.   hdr_info = &htab->eh_info;
  490.   if (hdr_info->parsed_eh_frames)
  491.     return;
  492.  
  493.   if (sec->size == 0
  494.       || sec->sec_info_type != SEC_INFO_TYPE_NONE)
  495.     {
  496.       /* This file does not contain .eh_frame information.  */
  497.       return;
  498.     }
  499.  
  500.   if (bfd_is_abs_section (sec->output_section))
  501.     {
  502.       /* At least one of the sections is being discarded from the
  503.          link, so we should just ignore them.  */
  504.       return;
  505.     }
  506.  
  507.   /* Read the frame unwind information from abfd.  */
  508.  
  509.   REQUIRE (bfd_malloc_and_get_section (abfd, sec, &ehbuf));
  510.  
  511.   if (sec->size >= 4
  512.       && bfd_get_32 (abfd, ehbuf) == 0
  513.       && cookie->rel == cookie->relend)
  514.     {
  515.       /* Empty .eh_frame section.  */
  516.       free (ehbuf);
  517.       return;
  518.     }
  519.  
  520.   /* If .eh_frame section size doesn't fit into int, we cannot handle
  521.      it (it would need to use 64-bit .eh_frame format anyway).  */
  522.   REQUIRE (sec->size == (unsigned int) sec->size);
  523.  
  524.   ptr_size = (get_elf_backend_data (abfd)
  525.               ->elf_backend_eh_frame_address_size (abfd, sec));
  526.   REQUIRE (ptr_size != 0);
  527.  
  528.   /* Go through the section contents and work out how many FDEs and
  529.      CIEs there are.  */
  530.   buf = ehbuf;
  531.   end = ehbuf + sec->size;
  532.   num_cies = 0;
  533.   num_entries = 0;
  534.   while (buf != end)
  535.     {
  536.       num_entries++;
  537.  
  538.       /* Read the length of the entry.  */
  539.       REQUIRE (skip_bytes (&buf, end, 4));
  540.       hdr_length = bfd_get_32 (abfd, buf - 4);
  541.  
  542.       /* 64-bit .eh_frame is not supported.  */
  543.       REQUIRE (hdr_length != 0xffffffff);
  544.       if (hdr_length == 0)
  545.         break;
  546.  
  547.       REQUIRE (skip_bytes (&buf, end, 4));
  548.       hdr_id = bfd_get_32 (abfd, buf - 4);
  549.       if (hdr_id == 0)
  550.         num_cies++;
  551.  
  552.       REQUIRE (skip_bytes (&buf, end, hdr_length - 4));
  553.     }
  554.  
  555.   sec_info = (struct eh_frame_sec_info *)
  556.       bfd_zmalloc (sizeof (struct eh_frame_sec_info)
  557.                    + (num_entries - 1) * sizeof (struct eh_cie_fde));
  558.   REQUIRE (sec_info);
  559.  
  560.   /* We need to have a "struct cie" for each CIE in this section.  */
  561.   local_cies = (struct cie *) bfd_zmalloc (num_cies * sizeof (*local_cies));
  562.   REQUIRE (local_cies);
  563.  
  564.   /* FIXME: octets_per_byte.  */
  565. #define ENSURE_NO_RELOCS(buf)                           \
  566.   REQUIRE (!(cookie->rel < cookie->relend               \
  567.              && (cookie->rel->r_offset                  \
  568.                  < (bfd_size_type) ((buf) - ehbuf))     \
  569.              && cookie->rel->r_info != 0))
  570.  
  571.   /* FIXME: octets_per_byte.  */
  572. #define SKIP_RELOCS(buf)                                \
  573.   while (cookie->rel < cookie->relend                   \
  574.          && (cookie->rel->r_offset                      \
  575.              < (bfd_size_type) ((buf) - ehbuf)))        \
  576.     cookie->rel++
  577.  
  578.   /* FIXME: octets_per_byte.  */
  579. #define GET_RELOC(buf)                                  \
  580.   ((cookie->rel < cookie->relend                        \
  581.     && (cookie->rel->r_offset                           \
  582.         == (bfd_size_type) ((buf) - ehbuf)))            \
  583.    ? cookie->rel : NULL)
  584.  
  585.   buf = ehbuf;
  586.   cie_count = 0;
  587.   gc_mark_hook = get_elf_backend_data (abfd)->gc_mark_hook;
  588.   while ((bfd_size_type) (buf - ehbuf) != sec->size)
  589.     {
  590.       char *aug;
  591.       bfd_byte *start, *insns, *insns_end;
  592.       bfd_size_type length;
  593.       unsigned int set_loc_count;
  594.  
  595.       this_inf = sec_info->entry + sec_info->count;
  596.       last_fde = buf;
  597.  
  598.       /* Read the length of the entry.  */
  599.       REQUIRE (skip_bytes (&buf, ehbuf + sec->size, 4));
  600.       hdr_length = bfd_get_32 (abfd, buf - 4);
  601.  
  602.       /* The CIE/FDE must be fully contained in this input section.  */
  603.       REQUIRE ((bfd_size_type) (buf - ehbuf) + hdr_length <= sec->size);
  604.       end = buf + hdr_length;
  605.  
  606.       this_inf->offset = last_fde - ehbuf;
  607.       this_inf->size = 4 + hdr_length;
  608.       this_inf->reloc_index = cookie->rel - cookie->rels;
  609.  
  610.       if (hdr_length == 0)
  611.         {
  612.           /* A zero-length CIE should only be found at the end of
  613.              the section.  */
  614.           REQUIRE ((bfd_size_type) (buf - ehbuf) == sec->size);
  615.           ENSURE_NO_RELOCS (buf);
  616.           sec_info->count++;
  617.           break;
  618.         }
  619.  
  620.       REQUIRE (skip_bytes (&buf, end, 4));
  621.       hdr_id = bfd_get_32 (abfd, buf - 4);
  622.  
  623.       if (hdr_id == 0)
  624.         {
  625.           unsigned int initial_insn_length;
  626.  
  627.           /* CIE  */
  628.           this_inf->cie = 1;
  629.  
  630.           /* Point CIE to one of the section-local cie structures.  */
  631.           cie = local_cies + cie_count++;
  632.  
  633.           cie->cie_inf = this_inf;
  634.           cie->length = hdr_length;
  635.           cie->output_sec = sec->output_section;
  636.           start = buf;
  637.           REQUIRE (read_byte (&buf, end, &cie->version));
  638.  
  639.           /* Cannot handle unknown versions.  */
  640.           REQUIRE (cie->version == 1
  641.                    || cie->version == 3
  642.                    || cie->version == 4);
  643.           REQUIRE (strlen ((char *) buf) < sizeof (cie->augmentation));
  644.  
  645.           strcpy (cie->augmentation, (char *) buf);
  646.           buf = (bfd_byte *) strchr ((char *) buf, '\0') + 1;
  647.           ENSURE_NO_RELOCS (buf);
  648.           if (buf[0] == 'e' && buf[1] == 'h')
  649.             {
  650.               /* GCC < 3.0 .eh_frame CIE */
  651.               /* We cannot merge "eh" CIEs because __EXCEPTION_TABLE__
  652.                  is private to each CIE, so we don't need it for anything.
  653.                  Just skip it.  */
  654.               REQUIRE (skip_bytes (&buf, end, ptr_size));
  655.               SKIP_RELOCS (buf);
  656.             }
  657.           if (cie->version >= 4)
  658.             {
  659.               REQUIRE (buf + 1 < end);
  660.               REQUIRE (buf[0] == ptr_size);
  661.               REQUIRE (buf[1] == 0);
  662.               buf += 2;
  663.             }
  664.           REQUIRE (read_uleb128 (&buf, end, &cie->code_align));
  665.           REQUIRE (read_sleb128 (&buf, end, &cie->data_align));
  666.           if (cie->version == 1)
  667.             {
  668.               REQUIRE (buf < end);
  669.               cie->ra_column = *buf++;
  670.             }
  671.           else
  672.             REQUIRE (read_uleb128 (&buf, end, &cie->ra_column));
  673.           ENSURE_NO_RELOCS (buf);
  674.           cie->lsda_encoding = DW_EH_PE_omit;
  675.           cie->fde_encoding = DW_EH_PE_omit;
  676.           cie->per_encoding = DW_EH_PE_omit;
  677.           aug = cie->augmentation;
  678.           if (aug[0] != 'e' || aug[1] != 'h')
  679.             {
  680.               if (*aug == 'z')
  681.                 {
  682.                   aug++;
  683.                   REQUIRE (read_uleb128 (&buf, end, &cie->augmentation_size));
  684.                   ENSURE_NO_RELOCS (buf);
  685.                 }
  686.  
  687.               while (*aug != '\0')
  688.                 switch (*aug++)
  689.                   {
  690.                   case 'L':
  691.                     REQUIRE (read_byte (&buf, end, &cie->lsda_encoding));
  692.                     ENSURE_NO_RELOCS (buf);
  693.                     REQUIRE (get_DW_EH_PE_width (cie->lsda_encoding, ptr_size));
  694.                     break;
  695.                   case 'R':
  696.                     REQUIRE (read_byte (&buf, end, &cie->fde_encoding));
  697.                     ENSURE_NO_RELOCS (buf);
  698.                     REQUIRE (get_DW_EH_PE_width (cie->fde_encoding, ptr_size));
  699.                     break;
  700.                   case 'S':
  701.                     break;
  702.                   case 'P':
  703.                     {
  704.                       int per_width;
  705.  
  706.                       REQUIRE (read_byte (&buf, end, &cie->per_encoding));
  707.                       per_width = get_DW_EH_PE_width (cie->per_encoding,
  708.                                                       ptr_size);
  709.                       REQUIRE (per_width);
  710.                       if ((cie->per_encoding & 0x70) == DW_EH_PE_aligned)
  711.                         {
  712.                           length = -(buf - ehbuf) & (per_width - 1);
  713.                           REQUIRE (skip_bytes (&buf, end, length));
  714.                         }
  715.                       this_inf->u.cie.personality_offset = buf - start;
  716.                       ENSURE_NO_RELOCS (buf);
  717.                       /* Ensure we have a reloc here.  */
  718.                       REQUIRE (GET_RELOC (buf));
  719.                       cie->personality.reloc_index
  720.                         = cookie->rel - cookie->rels;
  721.                       /* Cope with MIPS-style composite relocations.  */
  722.                       do
  723.                         cookie->rel++;
  724.                       while (GET_RELOC (buf) != NULL);
  725.                       REQUIRE (skip_bytes (&buf, end, per_width));
  726.                     }
  727.                     break;
  728.                   default:
  729.                     /* Unrecognized augmentation. Better bail out.  */
  730.                     goto free_no_table;
  731.                   }
  732.             }
  733.  
  734.           /* For shared libraries, try to get rid of as many RELATIVE relocs
  735.              as possible.  */
  736.           if (info->shared
  737.               && (get_elf_backend_data (abfd)
  738.                   ->elf_backend_can_make_relative_eh_frame
  739.                   (abfd, info, sec)))
  740.             {
  741.               if ((cie->fde_encoding & 0x70) == DW_EH_PE_absptr)
  742.                 this_inf->make_relative = 1;
  743.               /* If the CIE doesn't already have an 'R' entry, it's fairly
  744.                  easy to add one, provided that there's no aligned data
  745.                  after the augmentation string.  */
  746.               else if (cie->fde_encoding == DW_EH_PE_omit
  747.                        && (cie->per_encoding & 0x70) != DW_EH_PE_aligned)
  748.                 {
  749.                   if (*cie->augmentation == 0)
  750.                     this_inf->add_augmentation_size = 1;
  751.                   this_inf->u.cie.add_fde_encoding = 1;
  752.                   this_inf->make_relative = 1;
  753.                 }
  754.  
  755.               if ((cie->lsda_encoding & 0x70) == DW_EH_PE_absptr)
  756.                 cie->can_make_lsda_relative = 1;
  757.             }
  758.  
  759.           /* If FDE encoding was not specified, it defaults to
  760.              DW_EH_absptr.  */
  761.           if (cie->fde_encoding == DW_EH_PE_omit)
  762.             cie->fde_encoding = DW_EH_PE_absptr;
  763.  
  764.           initial_insn_length = end - buf;
  765.           if (initial_insn_length <= sizeof (cie->initial_instructions))
  766.             {
  767.               cie->initial_insn_length = initial_insn_length;
  768.               memcpy (cie->initial_instructions, buf, initial_insn_length);
  769.             }
  770.           insns = buf;
  771.           buf += initial_insn_length;
  772.           ENSURE_NO_RELOCS (buf);
  773.  
  774.           if (hdr_info->merge_cies)
  775.             this_inf->u.cie.u.full_cie = cie;
  776.           this_inf->u.cie.per_encoding_relative
  777.             = (cie->per_encoding & 0x70) == DW_EH_PE_pcrel;
  778.         }
  779.       else
  780.         {
  781.           /* Find the corresponding CIE.  */
  782.           unsigned int cie_offset = this_inf->offset + 4 - hdr_id;
  783.           for (cie = local_cies; cie < local_cies + cie_count; cie++)
  784.             if (cie_offset == cie->cie_inf->offset)
  785.               break;
  786.  
  787.           /* Ensure this FDE references one of the CIEs in this input
  788.              section.  */
  789.           REQUIRE (cie != local_cies + cie_count);
  790.           this_inf->u.fde.cie_inf = cie->cie_inf;
  791.           this_inf->make_relative = cie->cie_inf->make_relative;
  792.           this_inf->add_augmentation_size
  793.             = cie->cie_inf->add_augmentation_size;
  794.  
  795.           ENSURE_NO_RELOCS (buf);
  796.           if ((sec->flags & SEC_LINKER_CREATED) == 0 || cookie->rels != NULL)
  797.             {
  798.               asection *rsec;
  799.  
  800.               REQUIRE (GET_RELOC (buf));
  801.  
  802.               /* Chain together the FDEs for each section.  */
  803.               rsec = _bfd_elf_gc_mark_rsec (info, sec, gc_mark_hook, cookie);
  804.               /* RSEC will be NULL if FDE was cleared out as it was belonging to
  805.                  a discarded SHT_GROUP.  */
  806.               if (rsec)
  807.                 {
  808.                   REQUIRE (rsec->owner == abfd);
  809.                   this_inf->u.fde.next_for_section = elf_fde_list (rsec);
  810.                   elf_fde_list (rsec) = this_inf;
  811.                 }
  812.             }
  813.  
  814.           /* Skip the initial location and address range.  */
  815.           start = buf;
  816.           length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
  817.           REQUIRE (skip_bytes (&buf, end, 2 * length));
  818.  
  819.           /* Skip the augmentation size, if present.  */
  820.           if (cie->augmentation[0] == 'z')
  821.             REQUIRE (read_uleb128 (&buf, end, &length));
  822.           else
  823.             length = 0;
  824.  
  825.           /* Of the supported augmentation characters above, only 'L'
  826.              adds augmentation data to the FDE.  This code would need to
  827.              be adjusted if any future augmentations do the same thing.  */
  828.           if (cie->lsda_encoding != DW_EH_PE_omit)
  829.             {
  830.               SKIP_RELOCS (buf);
  831.               if (cie->can_make_lsda_relative && GET_RELOC (buf))
  832.                 cie->cie_inf->u.cie.make_lsda_relative = 1;
  833.               this_inf->lsda_offset = buf - start;
  834.               /* If there's no 'z' augmentation, we don't know where the
  835.                  CFA insns begin.  Assume no padding.  */
  836.               if (cie->augmentation[0] != 'z')
  837.                 length = end - buf;
  838.             }
  839.  
  840.           /* Skip over the augmentation data.  */
  841.           REQUIRE (skip_bytes (&buf, end, length));
  842.           insns = buf;
  843.  
  844.           buf = last_fde + 4 + hdr_length;
  845.  
  846.           /* For NULL RSEC (cleared FDE belonging to a discarded section)
  847.              the relocations are commonly cleared.  We do not sanity check if
  848.              all these relocations are cleared as (1) relocations to
  849.              .gcc_except_table will remain uncleared (they will get dropped
  850.              with the drop of this unused FDE) and (2) BFD already safely drops
  851.              relocations of any type to .eh_frame by
  852.              elf_section_ignore_discarded_relocs.
  853.              TODO: The .gcc_except_table entries should be also filtered as
  854.              .eh_frame entries; or GCC could rather use COMDAT for them.  */
  855.           SKIP_RELOCS (buf);
  856.         }
  857.  
  858.       /* Try to interpret the CFA instructions and find the first
  859.          padding nop.  Shrink this_inf's size so that it doesn't
  860.          include the padding.  */
  861.       length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
  862.       set_loc_count = 0;
  863.       insns_end = skip_non_nops (insns, end, length, &set_loc_count);
  864.       /* If we don't understand the CFA instructions, we can't know
  865.          what needs to be adjusted there.  */
  866.       if (insns_end == NULL
  867.           /* For the time being we don't support DW_CFA_set_loc in
  868.              CIE instructions.  */
  869.           || (set_loc_count && this_inf->cie))
  870.         goto free_no_table;
  871.       this_inf->size -= end - insns_end;
  872.       if (insns_end != end && this_inf->cie)
  873.         {
  874.           cie->initial_insn_length -= end - insns_end;
  875.           cie->length -= end - insns_end;
  876.         }
  877.       if (set_loc_count
  878.           && ((cie->fde_encoding & 0x70) == DW_EH_PE_pcrel
  879.               || this_inf->make_relative))
  880.         {
  881.           unsigned int cnt;
  882.           bfd_byte *p;
  883.  
  884.           this_inf->set_loc = (unsigned int *)
  885.               bfd_malloc ((set_loc_count + 1) * sizeof (unsigned int));
  886.           REQUIRE (this_inf->set_loc);
  887.           this_inf->set_loc[0] = set_loc_count;
  888.           p = insns;
  889.           cnt = 0;
  890.           while (p < end)
  891.             {
  892.               if (*p == DW_CFA_set_loc)
  893.                 this_inf->set_loc[++cnt] = p + 1 - start;
  894.               REQUIRE (skip_cfa_op (&p, end, length));
  895.             }
  896.         }
  897.  
  898.       this_inf->removed = 1;
  899.       this_inf->fde_encoding = cie->fde_encoding;
  900.       this_inf->lsda_encoding = cie->lsda_encoding;
  901.       sec_info->count++;
  902.     }
  903.   BFD_ASSERT (sec_info->count == num_entries);
  904.   BFD_ASSERT (cie_count == num_cies);
  905.  
  906.   elf_section_data (sec)->sec_info = sec_info;
  907.   sec->sec_info_type = SEC_INFO_TYPE_EH_FRAME;
  908.   if (hdr_info->merge_cies)
  909.     {
  910.       sec_info->cies = local_cies;
  911.       local_cies = NULL;
  912.     }
  913.   goto success;
  914.  
  915.  free_no_table:
  916.   (*info->callbacks->einfo)
  917.     (_("%P: error in %B(%A); no .eh_frame_hdr table will be created.\n"),
  918.      abfd, sec);
  919.   hdr_info->table = FALSE;
  920.   if (sec_info)
  921.     free (sec_info);
  922.  success:
  923.   if (ehbuf)
  924.     free (ehbuf);
  925.   if (local_cies)
  926.     free (local_cies);
  927. #undef REQUIRE
  928. }
  929.  
  930. /* Finish a pass over all .eh_frame sections.  */
  931.  
  932. void
  933. _bfd_elf_end_eh_frame_parsing (struct bfd_link_info *info)
  934. {
  935.   struct eh_frame_hdr_info *hdr_info;
  936.  
  937.   hdr_info = &elf_hash_table (info)->eh_info;
  938.   hdr_info->parsed_eh_frames = TRUE;
  939. }
  940.  
  941. /* Mark all relocations against CIE or FDE ENT, which occurs in
  942.    .eh_frame section SEC.  COOKIE describes the relocations in SEC;
  943.    its "rel" field can be changed freely.  */
  944.  
  945. static bfd_boolean
  946. mark_entry (struct bfd_link_info *info, asection *sec,
  947.             struct eh_cie_fde *ent, elf_gc_mark_hook_fn gc_mark_hook,
  948.             struct elf_reloc_cookie *cookie)
  949. {
  950.   /* FIXME: octets_per_byte.  */
  951.   for (cookie->rel = cookie->rels + ent->reloc_index;
  952.        cookie->rel < cookie->relend
  953.          && cookie->rel->r_offset < ent->offset + ent->size;
  954.        cookie->rel++)
  955.     if (!_bfd_elf_gc_mark_reloc (info, sec, gc_mark_hook, cookie))
  956.       return FALSE;
  957.  
  958.   return TRUE;
  959. }
  960.  
  961. /* Mark all the relocations against FDEs that relate to code in input
  962.    section SEC.  The FDEs belong to .eh_frame section EH_FRAME, whose
  963.    relocations are described by COOKIE.  */
  964.  
  965. bfd_boolean
  966. _bfd_elf_gc_mark_fdes (struct bfd_link_info *info, asection *sec,
  967.                        asection *eh_frame, elf_gc_mark_hook_fn gc_mark_hook,
  968.                        struct elf_reloc_cookie *cookie)
  969. {
  970.   struct eh_cie_fde *fde, *cie;
  971.  
  972.   for (fde = elf_fde_list (sec); fde; fde = fde->u.fde.next_for_section)
  973.     {
  974.       if (!mark_entry (info, eh_frame, fde, gc_mark_hook, cookie))
  975.         return FALSE;
  976.  
  977.       /* At this stage, all cie_inf fields point to local CIEs, so we
  978.          can use the same cookie to refer to them.  */
  979.       cie = fde->u.fde.cie_inf;
  980.       if (!cie->u.cie.gc_mark)
  981.         {
  982.           cie->u.cie.gc_mark = 1;
  983.           if (!mark_entry (info, eh_frame, cie, gc_mark_hook, cookie))
  984.             return FALSE;
  985.         }
  986.     }
  987.   return TRUE;
  988. }
  989.  
  990. /* Input section SEC of ABFD is an .eh_frame section that contains the
  991.    CIE described by CIE_INF.  Return a version of CIE_INF that is going
  992.    to be kept in the output, adding CIE_INF to the output if necessary.
  993.  
  994.    HDR_INFO is the .eh_frame_hdr information and COOKIE describes the
  995.    relocations in REL.  */
  996.  
  997. static struct eh_cie_fde *
  998. find_merged_cie (bfd *abfd, struct bfd_link_info *info, asection *sec,
  999.                  struct eh_frame_hdr_info *hdr_info,
  1000.                  struct elf_reloc_cookie *cookie,
  1001.                  struct eh_cie_fde *cie_inf)
  1002. {
  1003.   unsigned long r_symndx;
  1004.   struct cie *cie, *new_cie;
  1005.   Elf_Internal_Rela *rel;
  1006.   void **loc;
  1007.  
  1008.   /* Use CIE_INF if we have already decided to keep it.  */
  1009.   if (!cie_inf->removed)
  1010.     return cie_inf;
  1011.  
  1012.   /* If we have merged CIE_INF with another CIE, use that CIE instead.  */
  1013.   if (cie_inf->u.cie.merged)
  1014.     return cie_inf->u.cie.u.merged_with;
  1015.  
  1016.   cie = cie_inf->u.cie.u.full_cie;
  1017.  
  1018.   /* Assume we will need to keep CIE_INF.  */
  1019.   cie_inf->removed = 0;
  1020.   cie_inf->u.cie.u.sec = sec;
  1021.  
  1022.   /* If we are not merging CIEs, use CIE_INF.  */
  1023.   if (cie == NULL)
  1024.     return cie_inf;
  1025.  
  1026.   if (cie->per_encoding != DW_EH_PE_omit)
  1027.     {
  1028.       bfd_boolean per_binds_local;
  1029.  
  1030.       /* Work out the address of personality routine, either as an absolute
  1031.          value or as a symbol.  */
  1032.       rel = cookie->rels + cie->personality.reloc_index;
  1033.       memset (&cie->personality, 0, sizeof (cie->personality));
  1034. #ifdef BFD64
  1035.       if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64)
  1036.         r_symndx = ELF64_R_SYM (rel->r_info);
  1037.       else
  1038. #endif
  1039.         r_symndx = ELF32_R_SYM (rel->r_info);
  1040.       if (r_symndx >= cookie->locsymcount
  1041.           || ELF_ST_BIND (cookie->locsyms[r_symndx].st_info) != STB_LOCAL)
  1042.         {
  1043.           struct elf_link_hash_entry *h;
  1044.  
  1045.           r_symndx -= cookie->extsymoff;
  1046.           h = cookie->sym_hashes[r_symndx];
  1047.  
  1048.           while (h->root.type == bfd_link_hash_indirect
  1049.                  || h->root.type == bfd_link_hash_warning)
  1050.             h = (struct elf_link_hash_entry *) h->root.u.i.link;
  1051.  
  1052.           cie->personality.h = h;
  1053.           per_binds_local = SYMBOL_REFERENCES_LOCAL (info, h);
  1054.         }
  1055.       else
  1056.         {
  1057.           Elf_Internal_Sym *sym;
  1058.           asection *sym_sec;
  1059.  
  1060.           sym = &cookie->locsyms[r_symndx];
  1061.           sym_sec = bfd_section_from_elf_index (abfd, sym->st_shndx);
  1062.           if (sym_sec == NULL)
  1063.             return cie_inf;
  1064.  
  1065.           if (sym_sec->kept_section != NULL)
  1066.             sym_sec = sym_sec->kept_section;
  1067.           if (sym_sec->output_section == NULL)
  1068.             return cie_inf;
  1069.  
  1070.           cie->local_personality = 1;
  1071.           cie->personality.val = (sym->st_value
  1072.                                   + sym_sec->output_offset
  1073.                                   + sym_sec->output_section->vma);
  1074.           per_binds_local = TRUE;
  1075.         }
  1076.  
  1077.       if (per_binds_local
  1078.           && info->shared
  1079.           && (cie->per_encoding & 0x70) == DW_EH_PE_absptr
  1080.           && (get_elf_backend_data (abfd)
  1081.               ->elf_backend_can_make_relative_eh_frame (abfd, info, sec)))
  1082.         {
  1083.           cie_inf->u.cie.make_per_encoding_relative = 1;
  1084.           cie_inf->u.cie.per_encoding_relative = 1;
  1085.         }
  1086.     }
  1087.  
  1088.   /* See if we can merge this CIE with an earlier one.  */
  1089.   cie->output_sec = sec->output_section;
  1090.   cie_compute_hash (cie);
  1091.   if (hdr_info->cies == NULL)
  1092.     {
  1093.       hdr_info->cies = htab_try_create (1, cie_hash, cie_eq, free);
  1094.       if (hdr_info->cies == NULL)
  1095.         return cie_inf;
  1096.     }
  1097.   loc = htab_find_slot_with_hash (hdr_info->cies, cie, cie->hash, INSERT);
  1098.   if (loc == NULL)
  1099.     return cie_inf;
  1100.  
  1101.   new_cie = (struct cie *) *loc;
  1102.   if (new_cie == NULL)
  1103.     {
  1104.       /* Keep CIE_INF and record it in the hash table.  */
  1105.       new_cie = (struct cie *) malloc (sizeof (struct cie));
  1106.       if (new_cie == NULL)
  1107.         return cie_inf;
  1108.  
  1109.       memcpy (new_cie, cie, sizeof (struct cie));
  1110.       *loc = new_cie;
  1111.     }
  1112.   else
  1113.     {
  1114.       /* Merge CIE_INF with NEW_CIE->CIE_INF.  */
  1115.       cie_inf->removed = 1;
  1116.       cie_inf->u.cie.merged = 1;
  1117.       cie_inf->u.cie.u.merged_with = new_cie->cie_inf;
  1118.       if (cie_inf->u.cie.make_lsda_relative)
  1119.         new_cie->cie_inf->u.cie.make_lsda_relative = 1;
  1120.     }
  1121.   return new_cie->cie_inf;
  1122. }
  1123.  
  1124. /* This function is called for each input file before the .eh_frame
  1125.    section is relocated.  It discards duplicate CIEs and FDEs for discarded
  1126.    functions.  The function returns TRUE iff any entries have been
  1127.    deleted.  */
  1128.  
  1129. bfd_boolean
  1130. _bfd_elf_discard_section_eh_frame
  1131.    (bfd *abfd, struct bfd_link_info *info, asection *sec,
  1132.     bfd_boolean (*reloc_symbol_deleted_p) (bfd_vma, void *),
  1133.     struct elf_reloc_cookie *cookie)
  1134. {
  1135.   struct eh_cie_fde *ent;
  1136.   struct eh_frame_sec_info *sec_info;
  1137.   struct eh_frame_hdr_info *hdr_info;
  1138.   unsigned int ptr_size, offset;
  1139.  
  1140.   if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME)
  1141.     return FALSE;
  1142.  
  1143.   sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
  1144.   if (sec_info == NULL)
  1145.     return FALSE;
  1146.  
  1147.   ptr_size = (get_elf_backend_data (sec->owner)
  1148.               ->elf_backend_eh_frame_address_size (sec->owner, sec));
  1149.  
  1150.   hdr_info = &elf_hash_table (info)->eh_info;
  1151.   for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
  1152.     if (ent->size == 4)
  1153.       /* There should only be one zero terminator, on the last input
  1154.          file supplying .eh_frame (crtend.o).  Remove any others.  */
  1155.       ent->removed = sec->map_head.s != NULL;
  1156.     else if (!ent->cie)
  1157.       {
  1158.         bfd_boolean keep;
  1159.         if ((sec->flags & SEC_LINKER_CREATED) != 0 && cookie->rels == NULL)
  1160.           {
  1161.             unsigned int width
  1162.               = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
  1163.             bfd_vma value
  1164.               = read_value (abfd, sec->contents + ent->offset + 8 + width,
  1165.                             width, get_DW_EH_PE_signed (ent->fde_encoding));
  1166.             keep = value != 0;
  1167.           }
  1168.         else
  1169.           {
  1170.             cookie->rel = cookie->rels + ent->reloc_index;
  1171.             /* FIXME: octets_per_byte.  */
  1172.             BFD_ASSERT (cookie->rel < cookie->relend
  1173.                         && cookie->rel->r_offset == ent->offset + 8);
  1174.             keep = !(*reloc_symbol_deleted_p) (ent->offset + 8, cookie);
  1175.           }
  1176.         if (keep)
  1177.           {
  1178.             if (info->shared
  1179.                 && (((ent->fde_encoding & 0x70) == DW_EH_PE_absptr
  1180.                      && ent->make_relative == 0)
  1181.                     || (ent->fde_encoding & 0x70) == DW_EH_PE_aligned))
  1182.               {
  1183.                 /* If a shared library uses absolute pointers
  1184.                    which we cannot turn into PC relative,
  1185.                    don't create the binary search table,
  1186.                    since it is affected by runtime relocations.  */
  1187.                 hdr_info->table = FALSE;
  1188.                 (*info->callbacks->einfo)
  1189.                   (_("%P: fde encoding in %B(%A) prevents .eh_frame_hdr"
  1190.                      " table being created.\n"), abfd, sec);
  1191.               }
  1192.             ent->removed = 0;
  1193.             hdr_info->fde_count++;
  1194.             ent->u.fde.cie_inf = find_merged_cie (abfd, info, sec, hdr_info,
  1195.                                                   cookie, ent->u.fde.cie_inf);
  1196.           }
  1197.       }
  1198.  
  1199.   if (sec_info->cies)
  1200.     {
  1201.       free (sec_info->cies);
  1202.       sec_info->cies = NULL;
  1203.     }
  1204.  
  1205.   offset = 0;
  1206.   for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
  1207.     if (!ent->removed)
  1208.       {
  1209.         ent->new_offset = offset;
  1210.         offset += size_of_output_cie_fde (ent, ptr_size);
  1211.       }
  1212.  
  1213.   sec->rawsize = sec->size;
  1214.   sec->size = offset;
  1215.   return offset != sec->rawsize;
  1216. }
  1217.  
  1218. /* This function is called for .eh_frame_hdr section after
  1219.    _bfd_elf_discard_section_eh_frame has been called on all .eh_frame
  1220.    input sections.  It finalizes the size of .eh_frame_hdr section.  */
  1221.  
  1222. bfd_boolean
  1223. _bfd_elf_discard_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
  1224. {
  1225.   struct elf_link_hash_table *htab;
  1226.   struct eh_frame_hdr_info *hdr_info;
  1227.   asection *sec;
  1228.  
  1229.   htab = elf_hash_table (info);
  1230.   hdr_info = &htab->eh_info;
  1231.  
  1232.   if (hdr_info->cies != NULL)
  1233.     {
  1234.       htab_delete (hdr_info->cies);
  1235.       hdr_info->cies = NULL;
  1236.     }
  1237.  
  1238.   sec = hdr_info->hdr_sec;
  1239.   if (sec == NULL)
  1240.     return FALSE;
  1241.  
  1242.   sec->size = EH_FRAME_HDR_SIZE;
  1243.   if (hdr_info->table)
  1244.     sec->size += 4 + hdr_info->fde_count * 8;
  1245.  
  1246.   elf_eh_frame_hdr (abfd) = sec;
  1247.   return TRUE;
  1248. }
  1249.  
  1250. /* Return true if there is at least one non-empty .eh_frame section in
  1251.    input files.  Can only be called after ld has mapped input to
  1252.    output sections, and before sections are stripped.  */
  1253. bfd_boolean
  1254. _bfd_elf_eh_frame_present (struct bfd_link_info *info)
  1255. {
  1256.   asection *eh = bfd_get_section_by_name (info->output_bfd, ".eh_frame");
  1257.  
  1258.   if (eh == NULL)
  1259.     return FALSE;
  1260.  
  1261.   /* Count only sections which have at least a single CIE or FDE.
  1262.      There cannot be any CIE or FDE <= 8 bytes.  */
  1263.   for (eh = eh->map_head.s; eh != NULL; eh = eh->map_head.s)
  1264.     if (eh->size > 8)
  1265.       return TRUE;
  1266.  
  1267.   return FALSE;
  1268. }
  1269.  
  1270. /* This function is called from size_dynamic_sections.
  1271.    It needs to decide whether .eh_frame_hdr should be output or not,
  1272.    because when the dynamic symbol table has been sized it is too late
  1273.    to strip sections.  */
  1274.  
  1275. bfd_boolean
  1276. _bfd_elf_maybe_strip_eh_frame_hdr (struct bfd_link_info *info)
  1277. {
  1278.   struct elf_link_hash_table *htab;
  1279.   struct eh_frame_hdr_info *hdr_info;
  1280.  
  1281.   htab = elf_hash_table (info);
  1282.   hdr_info = &htab->eh_info;
  1283.   if (hdr_info->hdr_sec == NULL)
  1284.     return TRUE;
  1285.  
  1286.   if (bfd_is_abs_section (hdr_info->hdr_sec->output_section)
  1287.       || !info->eh_frame_hdr
  1288.       || !_bfd_elf_eh_frame_present (info))
  1289.     {
  1290.       hdr_info->hdr_sec->flags |= SEC_EXCLUDE;
  1291.       hdr_info->hdr_sec = NULL;
  1292.       return TRUE;
  1293.     }
  1294.  
  1295.   hdr_info->table = TRUE;
  1296.   return TRUE;
  1297. }
  1298.  
  1299. /* Adjust an address in the .eh_frame section.  Given OFFSET within
  1300.    SEC, this returns the new offset in the adjusted .eh_frame section,
  1301.    or -1 if the address refers to a CIE/FDE which has been removed
  1302.    or to offset with dynamic relocation which is no longer needed.  */
  1303.  
  1304. bfd_vma
  1305. _bfd_elf_eh_frame_section_offset (bfd *output_bfd ATTRIBUTE_UNUSED,
  1306.                                   struct bfd_link_info *info ATTRIBUTE_UNUSED,
  1307.                                   asection *sec,
  1308.                                   bfd_vma offset)
  1309. {
  1310.   struct eh_frame_sec_info *sec_info;
  1311.   unsigned int lo, hi, mid;
  1312.  
  1313.   if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME)
  1314.     return offset;
  1315.   sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
  1316.  
  1317.   if (offset >= sec->rawsize)
  1318.     return offset - sec->rawsize + sec->size;
  1319.  
  1320.   lo = 0;
  1321.   hi = sec_info->count;
  1322.   mid = 0;
  1323.   while (lo < hi)
  1324.     {
  1325.       mid = (lo + hi) / 2;
  1326.       if (offset < sec_info->entry[mid].offset)
  1327.         hi = mid;
  1328.       else if (offset
  1329.                >= sec_info->entry[mid].offset + sec_info->entry[mid].size)
  1330.         lo = mid + 1;
  1331.       else
  1332.         break;
  1333.     }
  1334.  
  1335.   BFD_ASSERT (lo < hi);
  1336.  
  1337.   /* FDE or CIE was removed.  */
  1338.   if (sec_info->entry[mid].removed)
  1339.     return (bfd_vma) -1;
  1340.  
  1341.   /* If converting personality pointers to DW_EH_PE_pcrel, there will be
  1342.      no need for run-time relocation against the personality field.  */
  1343.   if (sec_info->entry[mid].cie
  1344.       && sec_info->entry[mid].u.cie.make_per_encoding_relative
  1345.       && offset == (sec_info->entry[mid].offset + 8
  1346.                     + sec_info->entry[mid].u.cie.personality_offset))
  1347.     return (bfd_vma) -2;
  1348.  
  1349.   /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
  1350.      relocation against FDE's initial_location field.  */
  1351.   if (!sec_info->entry[mid].cie
  1352.       && sec_info->entry[mid].make_relative
  1353.       && offset == sec_info->entry[mid].offset + 8)
  1354.     return (bfd_vma) -2;
  1355.  
  1356.   /* If converting LSDA pointers to DW_EH_PE_pcrel, there will be no need
  1357.      for run-time relocation against LSDA field.  */
  1358.   if (!sec_info->entry[mid].cie
  1359.       && sec_info->entry[mid].u.fde.cie_inf->u.cie.make_lsda_relative
  1360.       && offset == (sec_info->entry[mid].offset + 8
  1361.                     + sec_info->entry[mid].lsda_offset))
  1362.     return (bfd_vma) -2;
  1363.  
  1364.   /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
  1365.      relocation against DW_CFA_set_loc's arguments.  */
  1366.   if (sec_info->entry[mid].set_loc
  1367.       && sec_info->entry[mid].make_relative
  1368.       && (offset >= sec_info->entry[mid].offset + 8
  1369.                     + sec_info->entry[mid].set_loc[1]))
  1370.     {
  1371.       unsigned int cnt;
  1372.  
  1373.       for (cnt = 1; cnt <= sec_info->entry[mid].set_loc[0]; cnt++)
  1374.         if (offset == sec_info->entry[mid].offset + 8
  1375.                       + sec_info->entry[mid].set_loc[cnt])
  1376.           return (bfd_vma) -2;
  1377.     }
  1378.  
  1379.   /* Any new augmentation bytes go before the first relocation.  */
  1380.   return (offset + sec_info->entry[mid].new_offset
  1381.           - sec_info->entry[mid].offset
  1382.           + extra_augmentation_string_bytes (sec_info->entry + mid)
  1383.           + extra_augmentation_data_bytes (sec_info->entry + mid));
  1384. }
  1385.  
  1386. /* Write out .eh_frame section.  This is called with the relocated
  1387.    contents.  */
  1388.  
  1389. bfd_boolean
  1390. _bfd_elf_write_section_eh_frame (bfd *abfd,
  1391.                                  struct bfd_link_info *info,
  1392.                                  asection *sec,
  1393.                                  bfd_byte *contents)
  1394. {
  1395.   struct eh_frame_sec_info *sec_info;
  1396.   struct elf_link_hash_table *htab;
  1397.   struct eh_frame_hdr_info *hdr_info;
  1398.   unsigned int ptr_size;
  1399.   struct eh_cie_fde *ent;
  1400.  
  1401.   if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME)
  1402.     /* FIXME: octets_per_byte.  */
  1403.     return bfd_set_section_contents (abfd, sec->output_section, contents,
  1404.                                      sec->output_offset, sec->size);
  1405.  
  1406.   ptr_size = (get_elf_backend_data (abfd)
  1407.               ->elf_backend_eh_frame_address_size (abfd, sec));
  1408.   BFD_ASSERT (ptr_size != 0);
  1409.  
  1410.   sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
  1411.   htab = elf_hash_table (info);
  1412.   hdr_info = &htab->eh_info;
  1413.  
  1414.   if (hdr_info->table && hdr_info->array == NULL)
  1415.     hdr_info->array = (struct eh_frame_array_ent *)
  1416.         bfd_malloc (hdr_info->fde_count * sizeof(*hdr_info->array));
  1417.   if (hdr_info->array == NULL)
  1418.     hdr_info = NULL;
  1419.  
  1420.   /* The new offsets can be bigger or smaller than the original offsets.
  1421.      We therefore need to make two passes over the section: one backward
  1422.      pass to move entries up and one forward pass to move entries down.
  1423.      The two passes won't interfere with each other because entries are
  1424.      not reordered  */
  1425.   for (ent = sec_info->entry + sec_info->count; ent-- != sec_info->entry;)
  1426.     if (!ent->removed && ent->new_offset > ent->offset)
  1427.       memmove (contents + ent->new_offset, contents + ent->offset, ent->size);
  1428.  
  1429.   for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
  1430.     if (!ent->removed && ent->new_offset < ent->offset)
  1431.       memmove (contents + ent->new_offset, contents + ent->offset, ent->size);
  1432.  
  1433.   for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
  1434.     {
  1435.       unsigned char *buf, *end;
  1436.       unsigned int new_size;
  1437.  
  1438.       if (ent->removed)
  1439.         continue;
  1440.  
  1441.       if (ent->size == 4)
  1442.         {
  1443.           /* Any terminating FDE must be at the end of the section.  */
  1444.           BFD_ASSERT (ent == sec_info->entry + sec_info->count - 1);
  1445.           continue;
  1446.         }
  1447.  
  1448.       buf = contents + ent->new_offset;
  1449.       end = buf + ent->size;
  1450.       new_size = size_of_output_cie_fde (ent, ptr_size);
  1451.  
  1452.       /* Update the size.  It may be shrinked.  */
  1453.       bfd_put_32 (abfd, new_size - 4, buf);
  1454.  
  1455.       /* Filling the extra bytes with DW_CFA_nops.  */
  1456.       if (new_size != ent->size)
  1457.         memset (end, 0, new_size - ent->size);
  1458.  
  1459.       if (ent->cie)
  1460.         {
  1461.           /* CIE */
  1462.           if (ent->make_relative
  1463.               || ent->u.cie.make_lsda_relative
  1464.               || ent->u.cie.per_encoding_relative)
  1465.             {
  1466.               char *aug;
  1467.               unsigned int action, extra_string, extra_data;
  1468.               unsigned int per_width, per_encoding;
  1469.  
  1470.               /* Need to find 'R' or 'L' augmentation's argument and modify
  1471.                  DW_EH_PE_* value.  */
  1472.               action = ((ent->make_relative ? 1 : 0)
  1473.                         | (ent->u.cie.make_lsda_relative ? 2 : 0)
  1474.                         | (ent->u.cie.per_encoding_relative ? 4 : 0));
  1475.               extra_string = extra_augmentation_string_bytes (ent);
  1476.               extra_data = extra_augmentation_data_bytes (ent);
  1477.  
  1478.               /* Skip length, id and version.  */
  1479.               buf += 9;
  1480.               aug = (char *) buf;
  1481.               buf += strlen (aug) + 1;
  1482.               skip_leb128 (&buf, end);
  1483.               skip_leb128 (&buf, end);
  1484.               skip_leb128 (&buf, end);
  1485.               if (*aug == 'z')
  1486.                 {
  1487.                   /* The uleb128 will always be a single byte for the kind
  1488.                      of augmentation strings that we're prepared to handle.  */
  1489.                   *buf++ += extra_data;
  1490.                   aug++;
  1491.                 }
  1492.  
  1493.               /* Make room for the new augmentation string and data bytes.  */
  1494.               memmove (buf + extra_string + extra_data, buf, end - buf);
  1495.               memmove (aug + extra_string, aug, buf - (bfd_byte *) aug);
  1496.               buf += extra_string;
  1497.               end += extra_string + extra_data;
  1498.  
  1499.               if (ent->add_augmentation_size)
  1500.                 {
  1501.                   *aug++ = 'z';
  1502.                   *buf++ = extra_data - 1;
  1503.                 }
  1504.               if (ent->u.cie.add_fde_encoding)
  1505.                 {
  1506.                   BFD_ASSERT (action & 1);
  1507.                   *aug++ = 'R';
  1508.                   *buf++ = make_pc_relative (DW_EH_PE_absptr, ptr_size);
  1509.                   action &= ~1;
  1510.                 }
  1511.  
  1512.               while (action)
  1513.                 switch (*aug++)
  1514.                   {
  1515.                   case 'L':
  1516.                     if (action & 2)
  1517.                       {
  1518.                         BFD_ASSERT (*buf == ent->lsda_encoding);
  1519.                         *buf = make_pc_relative (*buf, ptr_size);
  1520.                         action &= ~2;
  1521.                       }
  1522.                     buf++;
  1523.                     break;
  1524.                   case 'P':
  1525.                     if (ent->u.cie.make_per_encoding_relative)
  1526.                       *buf = make_pc_relative (*buf, ptr_size);
  1527.                     per_encoding = *buf++;
  1528.                     per_width = get_DW_EH_PE_width (per_encoding, ptr_size);
  1529.                     BFD_ASSERT (per_width != 0);
  1530.                     BFD_ASSERT (((per_encoding & 0x70) == DW_EH_PE_pcrel)
  1531.                                 == ent->u.cie.per_encoding_relative);
  1532.                     if ((per_encoding & 0x70) == DW_EH_PE_aligned)
  1533.                       buf = (contents
  1534.                              + ((buf - contents + per_width - 1)
  1535.                                 & ~((bfd_size_type) per_width - 1)));
  1536.                     if (action & 4)
  1537.                       {
  1538.                         bfd_vma val;
  1539.  
  1540.                         val = read_value (abfd, buf, per_width,
  1541.                                           get_DW_EH_PE_signed (per_encoding));
  1542.                         if (ent->u.cie.make_per_encoding_relative)
  1543.                           val -= (sec->output_section->vma
  1544.                                   + sec->output_offset
  1545.                                   + (buf - contents));
  1546.                         else
  1547.                           {
  1548.                             val += (bfd_vma) ent->offset - ent->new_offset;
  1549.                             val -= extra_string + extra_data;
  1550.                           }
  1551.                         write_value (abfd, buf, val, per_width);
  1552.                         action &= ~4;
  1553.                       }
  1554.                     buf += per_width;
  1555.                     break;
  1556.                   case 'R':
  1557.                     if (action & 1)
  1558.                       {
  1559.                         BFD_ASSERT (*buf == ent->fde_encoding);
  1560.                         *buf = make_pc_relative (*buf, ptr_size);
  1561.                         action &= ~1;
  1562.                       }
  1563.                     buf++;
  1564.                     break;
  1565.                   case 'S':
  1566.                     break;
  1567.                   default:
  1568.                     BFD_FAIL ();
  1569.                   }
  1570.             }
  1571.         }
  1572.       else
  1573.         {
  1574.           /* FDE */
  1575.           bfd_vma value, address;
  1576.           unsigned int width;
  1577.           bfd_byte *start;
  1578.           struct eh_cie_fde *cie;
  1579.  
  1580.           /* Skip length.  */
  1581.           cie = ent->u.fde.cie_inf;
  1582.           buf += 4;
  1583.           value = ((ent->new_offset + sec->output_offset + 4)
  1584.                    - (cie->new_offset + cie->u.cie.u.sec->output_offset));
  1585.           bfd_put_32 (abfd, value, buf);
  1586.           buf += 4;
  1587.           width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
  1588.           value = read_value (abfd, buf, width,
  1589.                               get_DW_EH_PE_signed (ent->fde_encoding));
  1590.           address = value;
  1591.           if (value)
  1592.             {
  1593.               switch (ent->fde_encoding & 0x70)
  1594.                 {
  1595.                 case DW_EH_PE_textrel:
  1596.                   BFD_ASSERT (hdr_info == NULL);
  1597.                   break;
  1598.                 case DW_EH_PE_datarel:
  1599.                   {
  1600.                     switch (abfd->arch_info->arch)
  1601.                       {
  1602.                       case bfd_arch_ia64:
  1603.                         BFD_ASSERT (elf_gp (abfd) != 0);
  1604.                         address += elf_gp (abfd);
  1605.                         break;
  1606.                       default:
  1607.                         (*info->callbacks->einfo)
  1608.                           (_("%P: DW_EH_PE_datarel unspecified"
  1609.                              " for this architecture.\n"));
  1610.                         /* Fall thru */
  1611.                       case bfd_arch_frv:
  1612.                       case bfd_arch_i386:
  1613.                         BFD_ASSERT (htab->hgot != NULL
  1614.                                     && ((htab->hgot->root.type
  1615.                                          == bfd_link_hash_defined)
  1616.                                         || (htab->hgot->root.type
  1617.                                             == bfd_link_hash_defweak)));
  1618.                         address
  1619.                           += (htab->hgot->root.u.def.value
  1620.                               + htab->hgot->root.u.def.section->output_offset
  1621.                               + (htab->hgot->root.u.def.section->output_section
  1622.                                  ->vma));
  1623.                         break;
  1624.                       }
  1625.                   }
  1626.                   break;
  1627.                 case DW_EH_PE_pcrel:
  1628.                   value += (bfd_vma) ent->offset - ent->new_offset;
  1629.                   address += (sec->output_section->vma
  1630.                               + sec->output_offset
  1631.                               + ent->offset + 8);
  1632.                   break;
  1633.                 }
  1634.               if (ent->make_relative)
  1635.                 value -= (sec->output_section->vma
  1636.                           + sec->output_offset
  1637.                           + ent->new_offset + 8);
  1638.               write_value (abfd, buf, value, width);
  1639.             }
  1640.  
  1641.           start = buf;
  1642.  
  1643.           if (hdr_info)
  1644.             {
  1645.               /* The address calculation may overflow, giving us a
  1646.                  value greater than 4G on a 32-bit target when
  1647.                  dwarf_vma is 64-bit.  */
  1648.               if (sizeof (address) > 4 && ptr_size == 4)
  1649.                 address &= 0xffffffff;
  1650.               hdr_info->array[hdr_info->array_count].initial_loc = address;
  1651.               hdr_info->array[hdr_info->array_count++].fde
  1652.                 = (sec->output_section->vma
  1653.                    + sec->output_offset
  1654.                    + ent->new_offset);
  1655.             }
  1656.  
  1657.           if ((ent->lsda_encoding & 0x70) == DW_EH_PE_pcrel
  1658.               || cie->u.cie.make_lsda_relative)
  1659.             {
  1660.               buf += ent->lsda_offset;
  1661.               width = get_DW_EH_PE_width (ent->lsda_encoding, ptr_size);
  1662.               value = read_value (abfd, buf, width,
  1663.                                   get_DW_EH_PE_signed (ent->lsda_encoding));
  1664.               if (value)
  1665.                 {
  1666.                   if ((ent->lsda_encoding & 0x70) == DW_EH_PE_pcrel)
  1667.                     value += (bfd_vma) ent->offset - ent->new_offset;
  1668.                   else if (cie->u.cie.make_lsda_relative)
  1669.                     value -= (sec->output_section->vma
  1670.                               + sec->output_offset
  1671.                               + ent->new_offset + 8 + ent->lsda_offset);
  1672.                   write_value (abfd, buf, value, width);
  1673.                 }
  1674.             }
  1675.           else if (ent->add_augmentation_size)
  1676.             {
  1677.               /* Skip the PC and length and insert a zero byte for the
  1678.                  augmentation size.  */
  1679.               buf += width * 2;
  1680.               memmove (buf + 1, buf, end - buf);
  1681.               *buf = 0;
  1682.             }
  1683.  
  1684.           if (ent->set_loc)
  1685.             {
  1686.               /* Adjust DW_CFA_set_loc.  */
  1687.               unsigned int cnt;
  1688.               bfd_vma new_offset;
  1689.  
  1690.               width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
  1691.               new_offset = ent->new_offset + 8
  1692.                            + extra_augmentation_string_bytes (ent)
  1693.                            + extra_augmentation_data_bytes (ent);
  1694.  
  1695.               for (cnt = 1; cnt <= ent->set_loc[0]; cnt++)
  1696.                 {
  1697.                   buf = start + ent->set_loc[cnt];
  1698.  
  1699.                   value = read_value (abfd, buf, width,
  1700.                                       get_DW_EH_PE_signed (ent->fde_encoding));
  1701.                   if (!value)
  1702.                     continue;
  1703.  
  1704.                   if ((ent->fde_encoding & 0x70) == DW_EH_PE_pcrel)
  1705.                     value += (bfd_vma) ent->offset + 8 - new_offset;
  1706.                   if (ent->make_relative)
  1707.                     value -= (sec->output_section->vma
  1708.                               + sec->output_offset
  1709.                               + new_offset + ent->set_loc[cnt]);
  1710.                   write_value (abfd, buf, value, width);
  1711.                 }
  1712.             }
  1713.         }
  1714.     }
  1715.  
  1716.   /* We don't align the section to its section alignment since the
  1717.      runtime library only expects all CIE/FDE records aligned at
  1718.      the pointer size. _bfd_elf_discard_section_eh_frame should
  1719.      have padded CIE/FDE records to multiple of pointer size with
  1720.      size_of_output_cie_fde.  */
  1721.   if ((sec->size % ptr_size) != 0)
  1722.     abort ();
  1723.  
  1724.   /* FIXME: octets_per_byte.  */
  1725.   return bfd_set_section_contents (abfd, sec->output_section,
  1726.                                    contents, (file_ptr) sec->output_offset,
  1727.                                    sec->size);
  1728. }
  1729.  
  1730. /* Helper function used to sort .eh_frame_hdr search table by increasing
  1731.    VMA of FDE initial location.  */
  1732.  
  1733. static int
  1734. vma_compare (const void *a, const void *b)
  1735. {
  1736.   const struct eh_frame_array_ent *p = (const struct eh_frame_array_ent *) a;
  1737.   const struct eh_frame_array_ent *q = (const struct eh_frame_array_ent *) b;
  1738.   if (p->initial_loc > q->initial_loc)
  1739.     return 1;
  1740.   if (p->initial_loc < q->initial_loc)
  1741.     return -1;
  1742.   return 0;
  1743. }
  1744.  
  1745. /* Write out .eh_frame_hdr section.  This must be called after
  1746.    _bfd_elf_write_section_eh_frame has been called on all input
  1747.    .eh_frame sections.
  1748.    .eh_frame_hdr format:
  1749.    ubyte version                (currently 1)
  1750.    ubyte eh_frame_ptr_enc       (DW_EH_PE_* encoding of pointer to start of
  1751.                                  .eh_frame section)
  1752.    ubyte fde_count_enc          (DW_EH_PE_* encoding of total FDE count
  1753.                                  number (or DW_EH_PE_omit if there is no
  1754.                                  binary search table computed))
  1755.    ubyte table_enc              (DW_EH_PE_* encoding of binary search table,
  1756.                                  or DW_EH_PE_omit if not present.
  1757.                                  DW_EH_PE_datarel is using address of
  1758.                                  .eh_frame_hdr section start as base)
  1759.    [encoded] eh_frame_ptr       (pointer to start of .eh_frame section)
  1760.    optionally followed by:
  1761.    [encoded] fde_count          (total number of FDEs in .eh_frame section)
  1762.    fde_count x [encoded] initial_loc, fde
  1763.                                 (array of encoded pairs containing
  1764.                                  FDE initial_location field and FDE address,
  1765.                                  sorted by increasing initial_loc).  */
  1766.  
  1767. bfd_boolean
  1768. _bfd_elf_write_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
  1769. {
  1770.   struct elf_link_hash_table *htab;
  1771.   struct eh_frame_hdr_info *hdr_info;
  1772.   asection *sec;
  1773.   bfd_boolean retval = TRUE;
  1774.  
  1775.   htab = elf_hash_table (info);
  1776.   hdr_info = &htab->eh_info;
  1777.   sec = hdr_info->hdr_sec;
  1778.  
  1779.   if (info->eh_frame_hdr && sec != NULL)
  1780.     {
  1781.       bfd_byte *contents;
  1782.       asection *eh_frame_sec;
  1783.       bfd_size_type size;
  1784.       bfd_vma encoded_eh_frame;
  1785.  
  1786.       size = EH_FRAME_HDR_SIZE;
  1787.       if (hdr_info->array && hdr_info->array_count == hdr_info->fde_count)
  1788.         size += 4 + hdr_info->fde_count * 8;
  1789.       contents = (bfd_byte *) bfd_malloc (size);
  1790.       if (contents == NULL)
  1791.         return FALSE;
  1792.  
  1793.       eh_frame_sec = bfd_get_section_by_name (abfd, ".eh_frame");
  1794.       if (eh_frame_sec == NULL)
  1795.         {
  1796.           free (contents);
  1797.           return FALSE;
  1798.         }
  1799.  
  1800.       memset (contents, 0, EH_FRAME_HDR_SIZE);
  1801.       /* Version.  */
  1802.       contents[0] = 1;
  1803.       /* .eh_frame offset.  */
  1804.       contents[1] = get_elf_backend_data (abfd)->elf_backend_encode_eh_address
  1805.         (abfd, info, eh_frame_sec, 0, sec, 4, &encoded_eh_frame);
  1806.  
  1807.       if (hdr_info->array && hdr_info->array_count == hdr_info->fde_count)
  1808.         {
  1809.           /* FDE count encoding.  */
  1810.           contents[2] = DW_EH_PE_udata4;
  1811.           /* Search table encoding.  */
  1812.           contents[3] = DW_EH_PE_datarel | DW_EH_PE_sdata4;
  1813.         }
  1814.       else
  1815.         {
  1816.           contents[2] = DW_EH_PE_omit;
  1817.           contents[3] = DW_EH_PE_omit;
  1818.         }
  1819.       bfd_put_32 (abfd, encoded_eh_frame, contents + 4);
  1820.  
  1821.       if (contents[2] != DW_EH_PE_omit)
  1822.         {
  1823.           unsigned int i;
  1824.  
  1825.           bfd_put_32 (abfd, hdr_info->fde_count, contents + EH_FRAME_HDR_SIZE);
  1826.           qsort (hdr_info->array, hdr_info->fde_count,
  1827.                  sizeof (*hdr_info->array), vma_compare);
  1828.           for (i = 0; i < hdr_info->fde_count; i++)
  1829.             {
  1830.               bfd_put_32 (abfd,
  1831.                           hdr_info->array[i].initial_loc
  1832.                           - sec->output_section->vma,
  1833.                           contents + EH_FRAME_HDR_SIZE + i * 8 + 4);
  1834.               bfd_put_32 (abfd,
  1835.                           hdr_info->array[i].fde - sec->output_section->vma,
  1836.                           contents + EH_FRAME_HDR_SIZE + i * 8 + 8);
  1837.             }
  1838.         }
  1839.  
  1840.       /* FIXME: octets_per_byte.  */
  1841.       retval = bfd_set_section_contents (abfd, sec->output_section, contents,
  1842.                                          (file_ptr) sec->output_offset,
  1843.                                          sec->size);
  1844.       free (contents);
  1845.     }
  1846.   if (hdr_info->array != NULL)
  1847.     free (hdr_info->array);
  1848.   return retval;
  1849. }
  1850.  
  1851. /* Return the width of FDE addresses.  This is the default implementation.  */
  1852.  
  1853. unsigned int
  1854. _bfd_elf_eh_frame_address_size (bfd *abfd, asection *sec ATTRIBUTE_UNUSED)
  1855. {
  1856.   return elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64 ? 8 : 4;
  1857. }
  1858.  
  1859. /* Decide whether we can use a PC-relative encoding within the given
  1860.    EH frame section.  This is the default implementation.  */
  1861.  
  1862. bfd_boolean
  1863. _bfd_elf_can_make_relative (bfd *input_bfd ATTRIBUTE_UNUSED,
  1864.                             struct bfd_link_info *info ATTRIBUTE_UNUSED,
  1865.                             asection *eh_frame_section ATTRIBUTE_UNUSED)
  1866. {
  1867.   return TRUE;
  1868. }
  1869.  
  1870. /* Select an encoding for the given address.  Preference is given to
  1871.    PC-relative addressing modes.  */
  1872.  
  1873. bfd_byte
  1874. _bfd_elf_encode_eh_address (bfd *abfd ATTRIBUTE_UNUSED,
  1875.                             struct bfd_link_info *info ATTRIBUTE_UNUSED,
  1876.                             asection *osec, bfd_vma offset,
  1877.                             asection *loc_sec, bfd_vma loc_offset,
  1878.                             bfd_vma *encoded)
  1879. {
  1880.   *encoded = osec->vma + offset -
  1881.     (loc_sec->output_section->vma + loc_sec->output_offset + loc_offset);
  1882.   return DW_EH_PE_pcrel | DW_EH_PE_sdata4;
  1883. }
  1884.