OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.1/] [bfd/] [elf-eh-frame.c] - Blame information for rev 227

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.