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