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