1 /* .eh_frame section optimization.
2    Copyright (C) 2001-2016 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
read_byte(bfd_byte ** iter,bfd_byte * end,unsigned char * result)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
skip_bytes(bfd_byte ** iter,bfd_byte * end,bfd_size_type length)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
skip_leb128(bfd_byte ** iter,bfd_byte * end)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
read_uleb128(bfd_byte ** iter,bfd_byte * end,bfd_vma * value)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
read_sleb128(bfd_byte ** iter,bfd_byte * end,bfd_signed_vma * value)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
get_DW_EH_PE_width(int encoding,int ptr_size)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
read_value(bfd * abfd,bfd_byte * buf,int width,int is_signed)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
write_value(bfd * abfd,bfd_byte * buf,bfd_vma value,int width)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
cie_eq(const void * e1,const void * e2)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
cie_hash(const void * e)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
cie_compute_hash(struct cie * c)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
extra_augmentation_string_bytes(struct eh_cie_fde * entry)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
extra_augmentation_data_bytes(struct eh_cie_fde * entry)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
size_of_output_cie_fde(struct eh_cie_fde * entry,unsigned int alignment)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
skip_cfa_op(bfd_byte ** iter,bfd_byte * end,unsigned int encoded_ptr_width)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 *
skip_non_nops(bfd_byte * buf,bfd_byte * end,unsigned int encoded_ptr_width,unsigned int * set_loc_count)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
make_pc_relative(unsigned char encoding,unsigned int ptr_size)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
bfd_elf_discard_eh_frame_entry(struct eh_frame_hdr_info * hdr_info)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
bfd_elf_record_eh_frame_entry(struct eh_frame_hdr_info * hdr_info,asection * sec)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
_bfd_elf_parse_eh_frame_entry(struct bfd_link_info * info,asection * sec,struct elf_reloc_cookie * cookie)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
_bfd_elf_parse_eh_frame(bfd * abfd,struct bfd_link_info * info,asection * sec,struct elf_reloc_cookie * cookie)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
cmp_eh_frame_hdr(const void * a,const void * b)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
add_eh_frame_hdr_terminator(asection * sec,asection * next)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
_bfd_elf_end_eh_frame_parsing(struct bfd_link_info * info)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
mark_entry(struct bfd_link_info * info,asection * sec,struct eh_cie_fde * ent,elf_gc_mark_hook_fn gc_mark_hook,struct elf_reloc_cookie * cookie)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
_bfd_elf_gc_mark_fdes(struct bfd_link_info * info,asection * sec,asection * eh_frame,elf_gc_mark_hook_fn gc_mark_hook,struct elf_reloc_cookie * cookie)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 *
find_merged_cie(bfd * abfd,struct bfd_link_info * info,asection * sec,struct eh_frame_hdr_info * hdr_info,struct elf_reloc_cookie * cookie,struct eh_cie_fde * cie_inf)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
_bfd_elf_discard_section_eh_frame(bfd * abfd,struct bfd_link_info * info,asection * sec,bfd_boolean (* reloc_symbol_deleted_p)(bfd_vma,void *),struct elf_reloc_cookie * cookie)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 		static int num_warnings_issued = 0;
1373 
1374 		/* If a shared library uses absolute pointers
1375 		   which we cannot turn into PC relative,
1376 		   don't create the binary search table,
1377 		   since it is affected by runtime relocations.  */
1378 		hdr_info->u.dwarf.table = FALSE;
1379 		if (num_warnings_issued < 10)
1380 		  {
1381 		    (*info->callbacks->einfo)
1382 		      (_("%P: FDE encoding in %B(%A) prevents .eh_frame_hdr"
1383 			 " table being created.\n"), abfd, sec);
1384 		    num_warnings_issued ++;
1385 		  }
1386 		else if (num_warnings_issued == 10)
1387 		  {
1388 		    (*info->callbacks->einfo)
1389 		      (_("%P: Further warnings about FDE encoding preventing .eh_frame_hdr generation dropped.\n"));
1390 		    num_warnings_issued ++;
1391 		  }
1392 	      }
1393 	    ent->removed = 0;
1394 	    hdr_info->u.dwarf.fde_count++;
1395 	    ent->u.fde.cie_inf = find_merged_cie (abfd, info, sec, hdr_info,
1396 						  cookie, ent->u.fde.cie_inf);
1397 	  }
1398       }
1399 
1400   if (sec_info->cies)
1401     {
1402       free (sec_info->cies);
1403       sec_info->cies = NULL;
1404     }
1405 
1406   offset = 0;
1407   for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1408     if (!ent->removed)
1409       {
1410 	ent->new_offset = offset;
1411 	offset += size_of_output_cie_fde (ent, ptr_size);
1412       }
1413 
1414   sec->rawsize = sec->size;
1415   sec->size = offset;
1416   return offset != sec->rawsize;
1417 }
1418 
1419 /* This function is called for .eh_frame_hdr section after
1420    _bfd_elf_discard_section_eh_frame has been called on all .eh_frame
1421    input sections.  It finalizes the size of .eh_frame_hdr section.  */
1422 
1423 bfd_boolean
_bfd_elf_discard_section_eh_frame_hdr(bfd * abfd,struct bfd_link_info * info)1424 _bfd_elf_discard_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
1425 {
1426   struct elf_link_hash_table *htab;
1427   struct eh_frame_hdr_info *hdr_info;
1428   asection *sec;
1429 
1430   htab = elf_hash_table (info);
1431   hdr_info = &htab->eh_info;
1432 
1433   if (!hdr_info->frame_hdr_is_compact && hdr_info->u.dwarf.cies != NULL)
1434     {
1435       htab_delete (hdr_info->u.dwarf.cies);
1436       hdr_info->u.dwarf.cies = NULL;
1437     }
1438 
1439   sec = hdr_info->hdr_sec;
1440   if (sec == NULL)
1441     return FALSE;
1442 
1443   if (info->eh_frame_hdr_type == COMPACT_EH_HDR)
1444     {
1445       /* For compact frames we only add the header.  The actual table comes
1446          from the .eh_frame_entry sections.  */
1447       sec->size = 8;
1448     }
1449   else
1450     {
1451       sec->size = EH_FRAME_HDR_SIZE;
1452       if (hdr_info->u.dwarf.table)
1453 	sec->size += 4 + hdr_info->u.dwarf.fde_count * 8;
1454     }
1455 
1456   elf_eh_frame_hdr (abfd) = sec;
1457   return TRUE;
1458 }
1459 
1460 /* Return true if there is at least one non-empty .eh_frame section in
1461    input files.  Can only be called after ld has mapped input to
1462    output sections, and before sections are stripped.  */
1463 
1464 bfd_boolean
_bfd_elf_eh_frame_present(struct bfd_link_info * info)1465 _bfd_elf_eh_frame_present (struct bfd_link_info *info)
1466 {
1467   asection *eh = bfd_get_section_by_name (info->output_bfd, ".eh_frame");
1468 
1469   if (eh == NULL)
1470     return FALSE;
1471 
1472   /* Count only sections which have at least a single CIE or FDE.
1473      There cannot be any CIE or FDE <= 8 bytes.  */
1474   for (eh = eh->map_head.s; eh != NULL; eh = eh->map_head.s)
1475     if (eh->size > 8)
1476       return TRUE;
1477 
1478   return FALSE;
1479 }
1480 
1481 /* Return true if there is at least one .eh_frame_entry section in
1482    input files.  */
1483 
1484 bfd_boolean
_bfd_elf_eh_frame_entry_present(struct bfd_link_info * info)1485 _bfd_elf_eh_frame_entry_present (struct bfd_link_info *info)
1486 {
1487   asection *o;
1488   bfd *abfd;
1489 
1490   for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link.next)
1491     {
1492       for (o = abfd->sections; o; o = o->next)
1493 	{
1494 	  const char *name = bfd_get_section_name (abfd, o);
1495 
1496 	  if (strcmp (name, ".eh_frame_entry")
1497 	      && !bfd_is_abs_section (o->output_section))
1498 	    return TRUE;
1499 	}
1500     }
1501   return FALSE;
1502 }
1503 
1504 /* This function is called from size_dynamic_sections.
1505    It needs to decide whether .eh_frame_hdr should be output or not,
1506    because when the dynamic symbol table has been sized it is too late
1507    to strip sections.  */
1508 
1509 bfd_boolean
_bfd_elf_maybe_strip_eh_frame_hdr(struct bfd_link_info * info)1510 _bfd_elf_maybe_strip_eh_frame_hdr (struct bfd_link_info *info)
1511 {
1512   struct elf_link_hash_table *htab;
1513   struct eh_frame_hdr_info *hdr_info;
1514   struct bfd_link_hash_entry *bh = NULL;
1515   struct elf_link_hash_entry *h;
1516 
1517   htab = elf_hash_table (info);
1518   hdr_info = &htab->eh_info;
1519   if (hdr_info->hdr_sec == NULL)
1520     return TRUE;
1521 
1522   if (bfd_is_abs_section (hdr_info->hdr_sec->output_section)
1523       || info->eh_frame_hdr_type == 0
1524       || (info->eh_frame_hdr_type == DWARF2_EH_HDR
1525 	  && !_bfd_elf_eh_frame_present (info))
1526       || (info->eh_frame_hdr_type == COMPACT_EH_HDR
1527 	  && !_bfd_elf_eh_frame_entry_present (info)))
1528     {
1529       hdr_info->hdr_sec->flags |= SEC_EXCLUDE;
1530       hdr_info->hdr_sec = NULL;
1531       return TRUE;
1532     }
1533 
1534   /* Add a hidden symbol so that systems without access to PHDRs can
1535      find the table.  */
1536   if (! (_bfd_generic_link_add_one_symbol
1537 	 (info, info->output_bfd, "__GNU_EH_FRAME_HDR", BSF_LOCAL,
1538 	  hdr_info->hdr_sec, 0, NULL, FALSE, FALSE, &bh)))
1539     return FALSE;
1540 
1541   h = (struct elf_link_hash_entry *) bh;
1542   h->def_regular = 1;
1543   h->other = STV_HIDDEN;
1544   get_elf_backend_data
1545     (info->output_bfd)->elf_backend_hide_symbol (info, h, TRUE);
1546 
1547   if (!hdr_info->frame_hdr_is_compact)
1548     hdr_info->u.dwarf.table = TRUE;
1549   return TRUE;
1550 }
1551 
1552 /* Adjust an address in the .eh_frame section.  Given OFFSET within
1553    SEC, this returns the new offset in the adjusted .eh_frame section,
1554    or -1 if the address refers to a CIE/FDE which has been removed
1555    or to offset with dynamic relocation which is no longer needed.  */
1556 
1557 bfd_vma
_bfd_elf_eh_frame_section_offset(bfd * output_bfd ATTRIBUTE_UNUSED,struct bfd_link_info * info ATTRIBUTE_UNUSED,asection * sec,bfd_vma offset)1558 _bfd_elf_eh_frame_section_offset (bfd *output_bfd ATTRIBUTE_UNUSED,
1559 				  struct bfd_link_info *info ATTRIBUTE_UNUSED,
1560 				  asection *sec,
1561 				  bfd_vma offset)
1562 {
1563   struct eh_frame_sec_info *sec_info;
1564   unsigned int lo, hi, mid;
1565 
1566   if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME)
1567     return offset;
1568   sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
1569 
1570   if (offset >= sec->rawsize)
1571     return offset - sec->rawsize + sec->size;
1572 
1573   lo = 0;
1574   hi = sec_info->count;
1575   mid = 0;
1576   while (lo < hi)
1577     {
1578       mid = (lo + hi) / 2;
1579       if (offset < sec_info->entry[mid].offset)
1580 	hi = mid;
1581       else if (offset
1582 	       >= sec_info->entry[mid].offset + sec_info->entry[mid].size)
1583 	lo = mid + 1;
1584       else
1585 	break;
1586     }
1587 
1588   BFD_ASSERT (lo < hi);
1589 
1590   /* FDE or CIE was removed.  */
1591   if (sec_info->entry[mid].removed)
1592     return (bfd_vma) -1;
1593 
1594   /* If converting personality pointers to DW_EH_PE_pcrel, there will be
1595      no need for run-time relocation against the personality field.  */
1596   if (sec_info->entry[mid].cie
1597       && sec_info->entry[mid].u.cie.make_per_encoding_relative
1598       && offset == (sec_info->entry[mid].offset + 8
1599 		    + sec_info->entry[mid].u.cie.personality_offset))
1600     return (bfd_vma) -2;
1601 
1602   /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1603      relocation against FDE's initial_location field.  */
1604   if (!sec_info->entry[mid].cie
1605       && sec_info->entry[mid].make_relative
1606       && offset == sec_info->entry[mid].offset + 8)
1607     return (bfd_vma) -2;
1608 
1609   /* If converting LSDA pointers to DW_EH_PE_pcrel, there will be no need
1610      for run-time relocation against LSDA field.  */
1611   if (!sec_info->entry[mid].cie
1612       && sec_info->entry[mid].u.fde.cie_inf->u.cie.make_lsda_relative
1613       && offset == (sec_info->entry[mid].offset + 8
1614 		    + sec_info->entry[mid].lsda_offset))
1615     return (bfd_vma) -2;
1616 
1617   /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1618      relocation against DW_CFA_set_loc's arguments.  */
1619   if (sec_info->entry[mid].set_loc
1620       && sec_info->entry[mid].make_relative
1621       && (offset >= sec_info->entry[mid].offset + 8
1622 		    + sec_info->entry[mid].set_loc[1]))
1623     {
1624       unsigned int cnt;
1625 
1626       for (cnt = 1; cnt <= sec_info->entry[mid].set_loc[0]; cnt++)
1627 	if (offset == sec_info->entry[mid].offset + 8
1628 		      + sec_info->entry[mid].set_loc[cnt])
1629 	  return (bfd_vma) -2;
1630     }
1631 
1632   /* Any new augmentation bytes go before the first relocation.  */
1633   return (offset + sec_info->entry[mid].new_offset
1634 	  - sec_info->entry[mid].offset
1635 	  + extra_augmentation_string_bytes (sec_info->entry + mid)
1636 	  + extra_augmentation_data_bytes (sec_info->entry + mid));
1637 }
1638 
1639 /* Write out .eh_frame_entry section.  Add CANTUNWIND terminator if needed.
1640    Also check that the contents look sane.  */
1641 
1642 bfd_boolean
_bfd_elf_write_section_eh_frame_entry(bfd * abfd,struct bfd_link_info * info,asection * sec,bfd_byte * contents)1643 _bfd_elf_write_section_eh_frame_entry (bfd *abfd, struct bfd_link_info *info,
1644 				       asection *sec, bfd_byte *contents)
1645 {
1646   const struct elf_backend_data *bed;
1647   bfd_byte cantunwind[8];
1648   bfd_vma addr;
1649   bfd_vma last_addr;
1650   bfd_vma offset;
1651   asection *text_sec = (asection *) elf_section_data (sec)->sec_info;
1652 
1653   if (!sec->rawsize)
1654     sec->rawsize = sec->size;
1655 
1656   BFD_ASSERT (sec->sec_info_type == SEC_INFO_TYPE_EH_FRAME_ENTRY);
1657 
1658   /* Check to make sure that the text section corresponding to this eh_frame_entry
1659      section has not been excluded.  In particular, mips16 stub entries will be
1660      excluded outside of the normal process.  */
1661   if (sec->flags & SEC_EXCLUDE
1662       || text_sec->flags & SEC_EXCLUDE)
1663     return TRUE;
1664 
1665   if (!bfd_set_section_contents (abfd, sec->output_section, contents,
1666 				 sec->output_offset, sec->rawsize))
1667       return FALSE;
1668 
1669   last_addr = bfd_get_signed_32 (abfd, contents);
1670   /* Check that all the entries are in order.  */
1671   for (offset = 8; offset < sec->rawsize; offset += 8)
1672     {
1673       addr = bfd_get_signed_32 (abfd, contents + offset) + offset;
1674       if (addr <= last_addr)
1675 	{
1676 	  (*_bfd_error_handler) (_("%B: %s not in order"), sec->owner, sec->name);
1677 	  return FALSE;
1678 	}
1679 
1680       last_addr = addr;
1681     }
1682 
1683   addr = text_sec->output_section->vma + text_sec->output_offset
1684 	 + text_sec->size;
1685   addr &= ~1;
1686   addr -= (sec->output_section->vma + sec->output_offset + sec->rawsize);
1687   if (addr & 1)
1688     {
1689       (*_bfd_error_handler) (_("%B: %s invalid input section size"),
1690 			     sec->owner, sec->name);
1691       bfd_set_error (bfd_error_bad_value);
1692       return FALSE;
1693     }
1694   if (last_addr >= addr + sec->rawsize)
1695     {
1696       (*_bfd_error_handler) (_("%B: %s points past end of text section"),
1697 			     sec->owner, sec->name);
1698       bfd_set_error (bfd_error_bad_value);
1699       return FALSE;
1700     }
1701 
1702   if (sec->size == sec->rawsize)
1703     return TRUE;
1704 
1705   bed = get_elf_backend_data (abfd);
1706   BFD_ASSERT (sec->size == sec->rawsize + 8);
1707   BFD_ASSERT ((addr & 1) == 0);
1708   BFD_ASSERT (bed->cant_unwind_opcode);
1709 
1710   bfd_put_32 (abfd, addr, cantunwind);
1711   bfd_put_32 (abfd, (*bed->cant_unwind_opcode) (info), cantunwind + 4);
1712   return bfd_set_section_contents (abfd, sec->output_section, cantunwind,
1713 				   sec->output_offset + sec->rawsize, 8);
1714 }
1715 
1716 /* Write out .eh_frame section.  This is called with the relocated
1717    contents.  */
1718 
1719 bfd_boolean
_bfd_elf_write_section_eh_frame(bfd * abfd,struct bfd_link_info * info,asection * sec,bfd_byte * contents)1720 _bfd_elf_write_section_eh_frame (bfd *abfd,
1721 				 struct bfd_link_info *info,
1722 				 asection *sec,
1723 				 bfd_byte *contents)
1724 {
1725   struct eh_frame_sec_info *sec_info;
1726   struct elf_link_hash_table *htab;
1727   struct eh_frame_hdr_info *hdr_info;
1728   unsigned int ptr_size;
1729   struct eh_cie_fde *ent;
1730   bfd_size_type sec_size;
1731 
1732   if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME)
1733     /* FIXME: octets_per_byte.  */
1734     return bfd_set_section_contents (abfd, sec->output_section, contents,
1735 				     sec->output_offset, sec->size);
1736 
1737   ptr_size = (get_elf_backend_data (abfd)
1738 	      ->elf_backend_eh_frame_address_size (abfd, sec));
1739   BFD_ASSERT (ptr_size != 0);
1740 
1741   sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
1742   htab = elf_hash_table (info);
1743   hdr_info = &htab->eh_info;
1744 
1745   if (hdr_info->u.dwarf.table && hdr_info->u.dwarf.array == NULL)
1746     {
1747       hdr_info->frame_hdr_is_compact = FALSE;
1748       hdr_info->u.dwarf.array = (struct eh_frame_array_ent *)
1749         bfd_malloc (hdr_info->u.dwarf.fde_count
1750 		    * sizeof (*hdr_info->u.dwarf.array));
1751     }
1752   if (hdr_info->u.dwarf.array == NULL)
1753     hdr_info = NULL;
1754 
1755   /* The new offsets can be bigger or smaller than the original offsets.
1756      We therefore need to make two passes over the section: one backward
1757      pass to move entries up and one forward pass to move entries down.
1758      The two passes won't interfere with each other because entries are
1759      not reordered  */
1760   for (ent = sec_info->entry + sec_info->count; ent-- != sec_info->entry;)
1761     if (!ent->removed && ent->new_offset > ent->offset)
1762       memmove (contents + ent->new_offset, contents + ent->offset, ent->size);
1763 
1764   for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1765     if (!ent->removed && ent->new_offset < ent->offset)
1766       memmove (contents + ent->new_offset, contents + ent->offset, ent->size);
1767 
1768   for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1769     {
1770       unsigned char *buf, *end;
1771       unsigned int new_size;
1772 
1773       if (ent->removed)
1774 	continue;
1775 
1776       if (ent->size == 4)
1777 	{
1778 	  /* Any terminating FDE must be at the end of the section.  */
1779 	  BFD_ASSERT (ent == sec_info->entry + sec_info->count - 1);
1780 	  continue;
1781 	}
1782 
1783       buf = contents + ent->new_offset;
1784       end = buf + ent->size;
1785       new_size = size_of_output_cie_fde (ent, ptr_size);
1786 
1787       /* Update the size.  It may be shrinked.  */
1788       bfd_put_32 (abfd, new_size - 4, buf);
1789 
1790       /* Filling the extra bytes with DW_CFA_nops.  */
1791       if (new_size != ent->size)
1792 	memset (end, 0, new_size - ent->size);
1793 
1794       if (ent->cie)
1795 	{
1796 	  /* CIE */
1797 	  if (ent->make_relative
1798 	      || ent->u.cie.make_lsda_relative
1799 	      || ent->u.cie.per_encoding_relative)
1800 	    {
1801 	      char *aug;
1802 	      unsigned int action, extra_string, extra_data;
1803 	      unsigned int per_width, per_encoding;
1804 
1805 	      /* Need to find 'R' or 'L' augmentation's argument and modify
1806 		 DW_EH_PE_* value.  */
1807 	      action = ((ent->make_relative ? 1 : 0)
1808 			| (ent->u.cie.make_lsda_relative ? 2 : 0)
1809 			| (ent->u.cie.per_encoding_relative ? 4 : 0));
1810 	      extra_string = extra_augmentation_string_bytes (ent);
1811 	      extra_data = extra_augmentation_data_bytes (ent);
1812 
1813 	      /* Skip length, id and version.  */
1814 	      buf += 9;
1815 	      aug = (char *) buf;
1816 	      buf += strlen (aug) + 1;
1817 	      skip_leb128 (&buf, end);
1818 	      skip_leb128 (&buf, end);
1819 	      skip_leb128 (&buf, end);
1820 	      if (*aug == 'z')
1821 		{
1822 		  /* The uleb128 will always be a single byte for the kind
1823 		     of augmentation strings that we're prepared to handle.  */
1824 		  *buf++ += extra_data;
1825 		  aug++;
1826 		}
1827 
1828 	      /* Make room for the new augmentation string and data bytes.  */
1829 	      memmove (buf + extra_string + extra_data, buf, end - buf);
1830 	      memmove (aug + extra_string, aug, buf - (bfd_byte *) aug);
1831 	      buf += extra_string;
1832 	      end += extra_string + extra_data;
1833 
1834 	      if (ent->add_augmentation_size)
1835 		{
1836 		  *aug++ = 'z';
1837 		  *buf++ = extra_data - 1;
1838 		}
1839 	      if (ent->u.cie.add_fde_encoding)
1840 		{
1841 		  BFD_ASSERT (action & 1);
1842 		  *aug++ = 'R';
1843 		  *buf++ = make_pc_relative (DW_EH_PE_absptr, ptr_size);
1844 		  action &= ~1;
1845 		}
1846 
1847 	      while (action)
1848 		switch (*aug++)
1849 		  {
1850 		  case 'L':
1851 		    if (action & 2)
1852 		      {
1853 			BFD_ASSERT (*buf == ent->lsda_encoding);
1854 			*buf = make_pc_relative (*buf, ptr_size);
1855 			action &= ~2;
1856 		      }
1857 		    buf++;
1858 		    break;
1859 		  case 'P':
1860 		    if (ent->u.cie.make_per_encoding_relative)
1861 		      *buf = make_pc_relative (*buf, ptr_size);
1862 		    per_encoding = *buf++;
1863 		    per_width = get_DW_EH_PE_width (per_encoding, ptr_size);
1864 		    BFD_ASSERT (per_width != 0);
1865 		    BFD_ASSERT (((per_encoding & 0x70) == DW_EH_PE_pcrel)
1866 				== ent->u.cie.per_encoding_relative);
1867 		    if ((per_encoding & 0x70) == DW_EH_PE_aligned)
1868 		      buf = (contents
1869 			     + ((buf - contents + per_width - 1)
1870 				& ~((bfd_size_type) per_width - 1)));
1871 		    if (action & 4)
1872 		      {
1873 			bfd_vma val;
1874 
1875 			val = read_value (abfd, buf, per_width,
1876 					  get_DW_EH_PE_signed (per_encoding));
1877 			if (ent->u.cie.make_per_encoding_relative)
1878 			  val -= (sec->output_section->vma
1879 				  + sec->output_offset
1880 				  + (buf - contents));
1881 			else
1882 			  {
1883 			    val += (bfd_vma) ent->offset - ent->new_offset;
1884 			    val -= extra_string + extra_data;
1885 			  }
1886 			write_value (abfd, buf, val, per_width);
1887 			action &= ~4;
1888 		      }
1889 		    buf += per_width;
1890 		    break;
1891 		  case 'R':
1892 		    if (action & 1)
1893 		      {
1894 			BFD_ASSERT (*buf == ent->fde_encoding);
1895 			*buf = make_pc_relative (*buf, ptr_size);
1896 			action &= ~1;
1897 		      }
1898 		    buf++;
1899 		    break;
1900 		  case 'S':
1901 		    break;
1902 		  default:
1903 		    BFD_FAIL ();
1904 		  }
1905 	    }
1906 	}
1907       else
1908 	{
1909 	  /* FDE */
1910 	  bfd_vma value, address;
1911 	  unsigned int width;
1912 	  bfd_byte *start;
1913 	  struct eh_cie_fde *cie;
1914 
1915 	  /* Skip length.  */
1916 	  cie = ent->u.fde.cie_inf;
1917 	  buf += 4;
1918 	  value = ((ent->new_offset + sec->output_offset + 4)
1919 		   - (cie->new_offset + cie->u.cie.u.sec->output_offset));
1920 	  bfd_put_32 (abfd, value, buf);
1921 	  if (bfd_link_relocatable (info))
1922 	    continue;
1923 	  buf += 4;
1924 	  width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1925 	  value = read_value (abfd, buf, width,
1926 			      get_DW_EH_PE_signed (ent->fde_encoding));
1927 	  address = value;
1928 	  if (value)
1929 	    {
1930 	      switch (ent->fde_encoding & 0x70)
1931 		{
1932 		case DW_EH_PE_textrel:
1933 		  BFD_ASSERT (hdr_info == NULL);
1934 		  break;
1935 		case DW_EH_PE_datarel:
1936 		  {
1937 		    switch (abfd->arch_info->arch)
1938 		      {
1939 		      case bfd_arch_ia64:
1940 			BFD_ASSERT (elf_gp (abfd) != 0);
1941 			address += elf_gp (abfd);
1942 			break;
1943 		      default:
1944 			(*info->callbacks->einfo)
1945 			  (_("%P: DW_EH_PE_datarel unspecified"
1946 			     " for this architecture.\n"));
1947 			/* Fall thru */
1948 		      case bfd_arch_frv:
1949 		      case bfd_arch_i386:
1950 			BFD_ASSERT (htab->hgot != NULL
1951 				    && ((htab->hgot->root.type
1952 					 == bfd_link_hash_defined)
1953 					|| (htab->hgot->root.type
1954 					    == bfd_link_hash_defweak)));
1955 			address
1956 			  += (htab->hgot->root.u.def.value
1957 			      + htab->hgot->root.u.def.section->output_offset
1958 			      + (htab->hgot->root.u.def.section->output_section
1959 				 ->vma));
1960 			break;
1961 		      }
1962 		  }
1963 		  break;
1964 		case DW_EH_PE_pcrel:
1965 		  value += (bfd_vma) ent->offset - ent->new_offset;
1966 		  address += (sec->output_section->vma
1967 			      + sec->output_offset
1968 			      + ent->offset + 8);
1969 		  break;
1970 		}
1971 	      if (ent->make_relative)
1972 		value -= (sec->output_section->vma
1973 			  + sec->output_offset
1974 			  + ent->new_offset + 8);
1975 	      write_value (abfd, buf, value, width);
1976 	    }
1977 
1978 	  start = buf;
1979 
1980 	  if (hdr_info)
1981 	    {
1982 	      /* The address calculation may overflow, giving us a
1983 		 value greater than 4G on a 32-bit target when
1984 		 dwarf_vma is 64-bit.  */
1985 	      if (sizeof (address) > 4 && ptr_size == 4)
1986 		address &= 0xffffffff;
1987 	      hdr_info->u.dwarf.array[hdr_info->array_count].initial_loc
1988 		= address;
1989 	      hdr_info->u.dwarf.array[hdr_info->array_count].range
1990 		= read_value (abfd, buf + width, width, FALSE);
1991 	      hdr_info->u.dwarf.array[hdr_info->array_count++].fde
1992 		= (sec->output_section->vma
1993 		   + sec->output_offset
1994 		   + ent->new_offset);
1995 	    }
1996 
1997 	  if ((ent->lsda_encoding & 0x70) == DW_EH_PE_pcrel
1998 	      || cie->u.cie.make_lsda_relative)
1999 	    {
2000 	      buf += ent->lsda_offset;
2001 	      width = get_DW_EH_PE_width (ent->lsda_encoding, ptr_size);
2002 	      value = read_value (abfd, buf, width,
2003 				  get_DW_EH_PE_signed (ent->lsda_encoding));
2004 	      if (value)
2005 		{
2006 		  if ((ent->lsda_encoding & 0x70) == DW_EH_PE_pcrel)
2007 		    value += (bfd_vma) ent->offset - ent->new_offset;
2008 		  else if (cie->u.cie.make_lsda_relative)
2009 		    value -= (sec->output_section->vma
2010 			      + sec->output_offset
2011 			      + ent->new_offset + 8 + ent->lsda_offset);
2012 		  write_value (abfd, buf, value, width);
2013 		}
2014 	    }
2015 	  else if (ent->add_augmentation_size)
2016 	    {
2017 	      /* Skip the PC and length and insert a zero byte for the
2018 		 augmentation size.  */
2019 	      buf += width * 2;
2020 	      memmove (buf + 1, buf, end - buf);
2021 	      *buf = 0;
2022 	    }
2023 
2024 	  if (ent->set_loc)
2025 	    {
2026 	      /* Adjust DW_CFA_set_loc.  */
2027 	      unsigned int cnt;
2028 	      bfd_vma new_offset;
2029 
2030 	      width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
2031 	      new_offset = ent->new_offset + 8
2032 			   + extra_augmentation_string_bytes (ent)
2033 			   + extra_augmentation_data_bytes (ent);
2034 
2035 	      for (cnt = 1; cnt <= ent->set_loc[0]; cnt++)
2036 		{
2037 		  buf = start + ent->set_loc[cnt];
2038 
2039 		  value = read_value (abfd, buf, width,
2040 				      get_DW_EH_PE_signed (ent->fde_encoding));
2041 		  if (!value)
2042 		    continue;
2043 
2044 		  if ((ent->fde_encoding & 0x70) == DW_EH_PE_pcrel)
2045 		    value += (bfd_vma) ent->offset + 8 - new_offset;
2046 		  if (ent->make_relative)
2047 		    value -= (sec->output_section->vma
2048 			      + sec->output_offset
2049 			      + new_offset + ent->set_loc[cnt]);
2050 		  write_value (abfd, buf, value, width);
2051 		}
2052 	    }
2053 	}
2054     }
2055 
2056   /* We don't align the section to its section alignment since the
2057      runtime library only expects all CIE/FDE records aligned at
2058      the pointer size. _bfd_elf_discard_section_eh_frame should
2059      have padded CIE/FDE records to multiple of pointer size with
2060      size_of_output_cie_fde.  */
2061   sec_size = sec->size;
2062   if (sec_info->count != 0
2063       && sec_info->entry[sec_info->count - 1].size == 4)
2064     sec_size -= 4;
2065   if ((sec_size % ptr_size) != 0)
2066     abort ();
2067 
2068   /* FIXME: octets_per_byte.  */
2069   return bfd_set_section_contents (abfd, sec->output_section,
2070 				   contents, (file_ptr) sec->output_offset,
2071 				   sec->size);
2072 }
2073 
2074 /* Helper function used to sort .eh_frame_hdr search table by increasing
2075    VMA of FDE initial location.  */
2076 
2077 static int
vma_compare(const void * a,const void * b)2078 vma_compare (const void *a, const void *b)
2079 {
2080   const struct eh_frame_array_ent *p = (const struct eh_frame_array_ent *) a;
2081   const struct eh_frame_array_ent *q = (const struct eh_frame_array_ent *) b;
2082   if (p->initial_loc > q->initial_loc)
2083     return 1;
2084   if (p->initial_loc < q->initial_loc)
2085     return -1;
2086   if (p->range > q->range)
2087     return 1;
2088   if (p->range < q->range)
2089     return -1;
2090   return 0;
2091 }
2092 
2093 /* Reorder .eh_frame_entry sections to match the associated text sections.
2094    This routine is called during the final linking step, just before writing
2095    the contents.  At this stage, sections in the eh_frame_hdr_info are already
2096    sorted in order of increasing text section address and so we simply need
2097    to make the .eh_frame_entrys follow that same order.  Note that it is
2098    invalid for a linker script to try to force a particular order of
2099    .eh_frame_entry sections.  */
2100 
2101 bfd_boolean
_bfd_elf_fixup_eh_frame_hdr(struct bfd_link_info * info)2102 _bfd_elf_fixup_eh_frame_hdr (struct bfd_link_info *info)
2103 {
2104   asection *sec = NULL;
2105   asection *osec;
2106   struct eh_frame_hdr_info *hdr_info;
2107   unsigned int i;
2108   bfd_vma offset;
2109   struct bfd_link_order *p;
2110 
2111   hdr_info = &elf_hash_table (info)->eh_info;
2112 
2113   if (hdr_info->hdr_sec == NULL
2114       || info->eh_frame_hdr_type != COMPACT_EH_HDR
2115       || hdr_info->array_count == 0)
2116     return TRUE;
2117 
2118   /* Change section output offsets to be in text section order.  */
2119   offset = 8;
2120   osec = hdr_info->u.compact.entries[0]->output_section;
2121   for (i = 0; i < hdr_info->array_count; i++)
2122     {
2123       sec = hdr_info->u.compact.entries[i];
2124       if (sec->output_section != osec)
2125 	{
2126 	  (*_bfd_error_handler)
2127 	    (_("Invalid output section for .eh_frame_entry: %s"),
2128 	     sec->output_section->name);
2129 	  return FALSE;
2130 	}
2131       sec->output_offset = offset;
2132       offset += sec->size;
2133     }
2134 
2135 
2136   /* Fix the link_order to match.  */
2137   for (p = sec->output_section->map_head.link_order; p != NULL; p = p->next)
2138     {
2139       if (p->type != bfd_indirect_link_order)
2140 	abort();
2141 
2142       p->offset = p->u.indirect.section->output_offset;
2143       if (p->next != NULL)
2144         i--;
2145     }
2146 
2147   if (i != 0)
2148     {
2149       (*_bfd_error_handler)
2150 	(_("Invalid contents in %s section"), osec->name);
2151       return FALSE;
2152     }
2153 
2154   return TRUE;
2155 }
2156 
2157 /* The .eh_frame_hdr format for Compact EH frames:
2158    ubyte version		(2)
2159    ubyte eh_ref_enc		(DW_EH_PE_* encoding of typinfo references)
2160    uint32_t count		(Number of entries in table)
2161    [array from .eh_frame_entry sections]  */
2162 
2163 static bfd_boolean
write_compact_eh_frame_hdr(bfd * abfd,struct bfd_link_info * info)2164 write_compact_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
2165 {
2166   struct elf_link_hash_table *htab;
2167   struct eh_frame_hdr_info *hdr_info;
2168   asection *sec;
2169   const struct elf_backend_data *bed;
2170   bfd_vma count;
2171   bfd_byte contents[8];
2172   unsigned int i;
2173 
2174   htab = elf_hash_table (info);
2175   hdr_info = &htab->eh_info;
2176   sec = hdr_info->hdr_sec;
2177 
2178   if (sec->size != 8)
2179     abort();
2180 
2181   for (i = 0; i < sizeof (contents); i++)
2182     contents[i] = 0;
2183 
2184   contents[0] = COMPACT_EH_HDR;
2185   bed = get_elf_backend_data (abfd);
2186 
2187   BFD_ASSERT (bed->compact_eh_encoding);
2188   contents[1] = (*bed->compact_eh_encoding) (info);
2189 
2190   count = (sec->output_section->size - 8) / 8;
2191   bfd_put_32 (abfd, count, contents + 4);
2192   return bfd_set_section_contents (abfd, sec->output_section, contents,
2193 				   (file_ptr) sec->output_offset, sec->size);
2194 }
2195 
2196 /* The .eh_frame_hdr format for DWARF frames:
2197 
2198    ubyte version		(currently 1)
2199    ubyte eh_frame_ptr_enc  	(DW_EH_PE_* encoding of pointer to start of
2200 				 .eh_frame section)
2201    ubyte fde_count_enc		(DW_EH_PE_* encoding of total FDE count
2202 				 number (or DW_EH_PE_omit if there is no
2203 				 binary search table computed))
2204    ubyte table_enc		(DW_EH_PE_* encoding of binary search table,
2205 				 or DW_EH_PE_omit if not present.
2206 				 DW_EH_PE_datarel is using address of
2207 				 .eh_frame_hdr section start as base)
2208    [encoded] eh_frame_ptr	(pointer to start of .eh_frame section)
2209    optionally followed by:
2210    [encoded] fde_count		(total number of FDEs in .eh_frame section)
2211    fde_count x [encoded] initial_loc, fde
2212 				(array of encoded pairs containing
2213 				 FDE initial_location field and FDE address,
2214 				 sorted by increasing initial_loc).  */
2215 
2216 static bfd_boolean
write_dwarf_eh_frame_hdr(bfd * abfd,struct bfd_link_info * info)2217 write_dwarf_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
2218 {
2219   struct elf_link_hash_table *htab;
2220   struct eh_frame_hdr_info *hdr_info;
2221   asection *sec;
2222   bfd_boolean retval = TRUE;
2223 
2224   htab = elf_hash_table (info);
2225   hdr_info = &htab->eh_info;
2226   sec = hdr_info->hdr_sec;
2227   bfd_byte *contents;
2228   asection *eh_frame_sec;
2229   bfd_size_type size;
2230   bfd_vma encoded_eh_frame;
2231 
2232   size = EH_FRAME_HDR_SIZE;
2233   if (hdr_info->u.dwarf.array
2234       && hdr_info->array_count == hdr_info->u.dwarf.fde_count)
2235     size += 4 + hdr_info->u.dwarf.fde_count * 8;
2236   contents = (bfd_byte *) bfd_malloc (size);
2237   if (contents == NULL)
2238     return FALSE;
2239 
2240   eh_frame_sec = bfd_get_section_by_name (abfd, ".eh_frame");
2241   if (eh_frame_sec == NULL)
2242     {
2243       free (contents);
2244       return FALSE;
2245     }
2246 
2247   memset (contents, 0, EH_FRAME_HDR_SIZE);
2248   /* Version.  */
2249   contents[0] = 1;
2250   /* .eh_frame offset.  */
2251   contents[1] = get_elf_backend_data (abfd)->elf_backend_encode_eh_address
2252     (abfd, info, eh_frame_sec, 0, sec, 4, &encoded_eh_frame);
2253 
2254   if (hdr_info->u.dwarf.array
2255       && hdr_info->array_count == hdr_info->u.dwarf.fde_count)
2256     {
2257       /* FDE count encoding.  */
2258       contents[2] = DW_EH_PE_udata4;
2259       /* Search table encoding.  */
2260       contents[3] = DW_EH_PE_datarel | DW_EH_PE_sdata4;
2261     }
2262   else
2263     {
2264       contents[2] = DW_EH_PE_omit;
2265       contents[3] = DW_EH_PE_omit;
2266     }
2267   bfd_put_32 (abfd, encoded_eh_frame, contents + 4);
2268 
2269   if (contents[2] != DW_EH_PE_omit)
2270     {
2271       unsigned int i;
2272       bfd_boolean overlap, overflow;
2273 
2274       bfd_put_32 (abfd, hdr_info->u.dwarf.fde_count,
2275 		  contents + EH_FRAME_HDR_SIZE);
2276       qsort (hdr_info->u.dwarf.array, hdr_info->u.dwarf.fde_count,
2277 	     sizeof (*hdr_info->u.dwarf.array), vma_compare);
2278       overlap = FALSE;
2279       overflow = FALSE;
2280       for (i = 0; i < hdr_info->u.dwarf.fde_count; i++)
2281 	{
2282 	  bfd_vma val;
2283 
2284 	  val = hdr_info->u.dwarf.array[i].initial_loc
2285 	    - sec->output_section->vma;
2286 	  val = ((val & 0xffffffff) ^ 0x80000000) - 0x80000000;
2287 	  if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64
2288 	      && (hdr_info->u.dwarf.array[i].initial_loc
2289 		  != sec->output_section->vma + val))
2290 	    overflow = TRUE;
2291 	  bfd_put_32 (abfd, val, contents + EH_FRAME_HDR_SIZE + i * 8 + 4);
2292 	  val = hdr_info->u.dwarf.array[i].fde - sec->output_section->vma;
2293 	  val = ((val & 0xffffffff) ^ 0x80000000) - 0x80000000;
2294 	  if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64
2295 	      && (hdr_info->u.dwarf.array[i].fde
2296 		  != sec->output_section->vma + val))
2297 	    overflow = TRUE;
2298 	  bfd_put_32 (abfd, val, contents + EH_FRAME_HDR_SIZE + i * 8 + 8);
2299 	  if (i != 0
2300 	      && (hdr_info->u.dwarf.array[i].initial_loc
2301 		  < (hdr_info->u.dwarf.array[i - 1].initial_loc
2302 		     + hdr_info->u.dwarf.array[i - 1].range)))
2303 	    overlap = TRUE;
2304 	}
2305       if (overflow)
2306 	(*info->callbacks->einfo) (_("%P: .eh_frame_hdr entry overflow.\n"));
2307       if (overlap)
2308 	(*info->callbacks->einfo)
2309 	  (_("%P: .eh_frame_hdr refers to overlapping FDEs.\n"));
2310       if (overflow || overlap)
2311 	{
2312 	  bfd_set_error (bfd_error_bad_value);
2313 	  retval = FALSE;
2314 	}
2315     }
2316 
2317   /* FIXME: octets_per_byte.  */
2318   if (!bfd_set_section_contents (abfd, sec->output_section, contents,
2319 				 (file_ptr) sec->output_offset,
2320 				 sec->size))
2321     retval = FALSE;
2322   free (contents);
2323 
2324   if (hdr_info->u.dwarf.array != NULL)
2325     free (hdr_info->u.dwarf.array);
2326   return retval;
2327 }
2328 
2329 /* Write out .eh_frame_hdr section.  This must be called after
2330    _bfd_elf_write_section_eh_frame has been called on all input
2331    .eh_frame sections.  */
2332 
2333 bfd_boolean
_bfd_elf_write_section_eh_frame_hdr(bfd * abfd,struct bfd_link_info * info)2334 _bfd_elf_write_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
2335 {
2336   struct elf_link_hash_table *htab;
2337   struct eh_frame_hdr_info *hdr_info;
2338   asection *sec;
2339 
2340   htab = elf_hash_table (info);
2341   hdr_info = &htab->eh_info;
2342   sec = hdr_info->hdr_sec;
2343 
2344   if (info->eh_frame_hdr_type == 0 || sec == NULL)
2345     return TRUE;
2346 
2347   if (info->eh_frame_hdr_type == COMPACT_EH_HDR)
2348     return write_compact_eh_frame_hdr (abfd, info);
2349   else
2350     return write_dwarf_eh_frame_hdr (abfd, info);
2351 }
2352 
2353 /* Return the width of FDE addresses.  This is the default implementation.  */
2354 
2355 unsigned int
_bfd_elf_eh_frame_address_size(bfd * abfd,asection * sec ATTRIBUTE_UNUSED)2356 _bfd_elf_eh_frame_address_size (bfd *abfd, asection *sec ATTRIBUTE_UNUSED)
2357 {
2358   return elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64 ? 8 : 4;
2359 }
2360 
2361 /* Decide whether we can use a PC-relative encoding within the given
2362    EH frame section.  This is the default implementation.  */
2363 
2364 bfd_boolean
_bfd_elf_can_make_relative(bfd * input_bfd ATTRIBUTE_UNUSED,struct bfd_link_info * info ATTRIBUTE_UNUSED,asection * eh_frame_section ATTRIBUTE_UNUSED)2365 _bfd_elf_can_make_relative (bfd *input_bfd ATTRIBUTE_UNUSED,
2366 			    struct bfd_link_info *info ATTRIBUTE_UNUSED,
2367 			    asection *eh_frame_section ATTRIBUTE_UNUSED)
2368 {
2369   return TRUE;
2370 }
2371 
2372 /* Select an encoding for the given address.  Preference is given to
2373    PC-relative addressing modes.  */
2374 
2375 bfd_byte
_bfd_elf_encode_eh_address(bfd * abfd ATTRIBUTE_UNUSED,struct bfd_link_info * info ATTRIBUTE_UNUSED,asection * osec,bfd_vma offset,asection * loc_sec,bfd_vma loc_offset,bfd_vma * encoded)2376 _bfd_elf_encode_eh_address (bfd *abfd ATTRIBUTE_UNUSED,
2377 			    struct bfd_link_info *info ATTRIBUTE_UNUSED,
2378 			    asection *osec, bfd_vma offset,
2379 			    asection *loc_sec, bfd_vma loc_offset,
2380 			    bfd_vma *encoded)
2381 {
2382   *encoded = osec->vma + offset -
2383     (loc_sec->output_section->vma + loc_sec->output_offset + loc_offset);
2384   return DW_EH_PE_pcrel | DW_EH_PE_sdata4;
2385 }
2386