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