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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gdb-7.2/] [bfd/] [elf-eh-frame.c] - Blame information for rev 835

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 330 jeremybenn
/* .eh_frame section optimization.
2
   Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
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
640
                   || cie->version == 3
641
                   || cie->version == 4);
642
          REQUIRE (strlen ((char *) buf) < sizeof (cie->augmentation));
643
 
644
          strcpy (cie->augmentation, (char *) buf);
645
          buf = (bfd_byte *) strchr ((char *) buf, '\0') + 1;
646
          ENSURE_NO_RELOCS (buf);
647
          if (buf[0] == 'e' && buf[1] == 'h')
648
            {
649
              /* GCC < 3.0 .eh_frame CIE */
650
              /* We cannot merge "eh" CIEs because __EXCEPTION_TABLE__
651
                 is private to each CIE, so we don't need it for anything.
652
                 Just skip it.  */
653
              REQUIRE (skip_bytes (&buf, end, ptr_size));
654
              SKIP_RELOCS (buf);
655
            }
656
          if (cie->version >= 4)
657
            {
658
              REQUIRE (buf + 1 < end);
659
              REQUIRE (buf[0] == ptr_size);
660
              REQUIRE (buf[1] == 0);
661
              buf += 2;
662
            }
663
          REQUIRE (read_uleb128 (&buf, end, &cie->code_align));
664
          REQUIRE (read_sleb128 (&buf, end, &cie->data_align));
665
          if (cie->version == 1)
666
            {
667
              REQUIRE (buf < end);
668
              cie->ra_column = *buf++;
669
            }
670
          else
671
            REQUIRE (read_uleb128 (&buf, end, &cie->ra_column));
672
          ENSURE_NO_RELOCS (buf);
673
          cie->lsda_encoding = DW_EH_PE_omit;
674
          cie->fde_encoding = DW_EH_PE_omit;
675
          cie->per_encoding = DW_EH_PE_omit;
676
          aug = cie->augmentation;
677
          if (aug[0] != 'e' || aug[1] != 'h')
678
            {
679
              if (*aug == 'z')
680
                {
681
                  aug++;
682
                  REQUIRE (read_uleb128 (&buf, end, &cie->augmentation_size));
683
                  ENSURE_NO_RELOCS (buf);
684
                }
685
 
686
              while (*aug != '\0')
687
                switch (*aug++)
688
                  {
689
                  case 'L':
690
                    REQUIRE (read_byte (&buf, end, &cie->lsda_encoding));
691
                    ENSURE_NO_RELOCS (buf);
692
                    REQUIRE (get_DW_EH_PE_width (cie->lsda_encoding, ptr_size));
693
                    break;
694
                  case 'R':
695
                    REQUIRE (read_byte (&buf, end, &cie->fde_encoding));
696
                    ENSURE_NO_RELOCS (buf);
697
                    REQUIRE (get_DW_EH_PE_width (cie->fde_encoding, ptr_size));
698
                    break;
699
                  case 'S':
700
                    break;
701
                  case 'P':
702
                    {
703
                      int per_width;
704
 
705
                      REQUIRE (read_byte (&buf, end, &cie->per_encoding));
706
                      per_width = get_DW_EH_PE_width (cie->per_encoding,
707
                                                      ptr_size);
708
                      REQUIRE (per_width);
709
                      if ((cie->per_encoding & 0x70) == DW_EH_PE_aligned)
710
                        {
711
                          length = -(buf - ehbuf) & (per_width - 1);
712
                          REQUIRE (skip_bytes (&buf, end, length));
713
                        }
714
                      this_inf->u.cie.personality_offset = buf - start;
715
                      ENSURE_NO_RELOCS (buf);
716
                      /* Ensure we have a reloc here.  */
717
                      REQUIRE (GET_RELOC (buf));
718
                      cie->personality.reloc_index
719
                        = cookie->rel - cookie->rels;
720
                      /* Cope with MIPS-style composite relocations.  */
721
                      do
722
                        cookie->rel++;
723
                      while (GET_RELOC (buf) != NULL);
724
                      REQUIRE (skip_bytes (&buf, end, per_width));
725
                    }
726
                    break;
727
                  default:
728
                    /* Unrecognized augmentation. Better bail out.  */
729
                    goto free_no_table;
730
                  }
731
            }
732
 
733
          /* For shared libraries, try to get rid of as many RELATIVE relocs
734
             as possible.  */
735
          if (info->shared
736
              && (get_elf_backend_data (abfd)
737
                  ->elf_backend_can_make_relative_eh_frame
738
                  (abfd, info, sec)))
739
            {
740
              if ((cie->fde_encoding & 0x70) == DW_EH_PE_absptr)
741
                this_inf->make_relative = 1;
742
              /* If the CIE doesn't already have an 'R' entry, it's fairly
743
                 easy to add one, provided that there's no aligned data
744
                 after the augmentation string.  */
745
              else if (cie->fde_encoding == DW_EH_PE_omit
746
                       && (cie->per_encoding & 0x70) != DW_EH_PE_aligned)
747
                {
748
                  if (*cie->augmentation == 0)
749
                    this_inf->add_augmentation_size = 1;
750
                  this_inf->u.cie.add_fde_encoding = 1;
751
                  this_inf->make_relative = 1;
752
                }
753
 
754
              if ((cie->lsda_encoding & 0x70) == DW_EH_PE_absptr)
755
                cie->can_make_lsda_relative = 1;
756
            }
757
 
758
          /* If FDE encoding was not specified, it defaults to
759
             DW_EH_absptr.  */
760
          if (cie->fde_encoding == DW_EH_PE_omit)
761
            cie->fde_encoding = DW_EH_PE_absptr;
762
 
763
          initial_insn_length = end - buf;
764
          if (initial_insn_length <= sizeof (cie->initial_instructions))
765
            {
766
              cie->initial_insn_length = initial_insn_length;
767
              memcpy (cie->initial_instructions, buf, initial_insn_length);
768
            }
769
          insns = buf;
770
          buf += initial_insn_length;
771
          ENSURE_NO_RELOCS (buf);
772
 
773
          if (hdr_info->merge_cies)
774
            this_inf->u.cie.u.full_cie = cie;
775
          this_inf->u.cie.per_encoding_relative
776
            = (cie->per_encoding & 0x70) == DW_EH_PE_pcrel;
777
        }
778
      else
779
        {
780
          asection *rsec;
781
 
782
          /* Find the corresponding CIE.  */
783
          unsigned int cie_offset = this_inf->offset + 4 - hdr_id;
784
          for (cie = local_cies; cie < local_cies + cie_count; cie++)
785
            if (cie_offset == cie->cie_inf->offset)
786
              break;
787
 
788
          /* Ensure this FDE references one of the CIEs in this input
789
             section.  */
790
          REQUIRE (cie != local_cies + cie_count);
791
          this_inf->u.fde.cie_inf = cie->cie_inf;
792
          this_inf->make_relative = cie->cie_inf->make_relative;
793
          this_inf->add_augmentation_size
794
            = cie->cie_inf->add_augmentation_size;
795
 
796
          ENSURE_NO_RELOCS (buf);
797
          REQUIRE (GET_RELOC (buf));
798
 
799
          /* Chain together the FDEs for each section.  */
800
          rsec = _bfd_elf_gc_mark_rsec (info, sec, gc_mark_hook, cookie);
801
          /* RSEC will be NULL if FDE was cleared out as it was belonging to
802
             a discarded SHT_GROUP.  */
803
          if (rsec)
804
            {
805
              REQUIRE (rsec->owner == abfd);
806
              this_inf->u.fde.next_for_section = elf_fde_list (rsec);
807
              elf_fde_list (rsec) = this_inf;
808
            }
809
 
810
          /* Skip the initial location and address range.  */
811
          start = buf;
812
          length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
813
          REQUIRE (skip_bytes (&buf, end, 2 * length));
814
 
815
          /* Skip the augmentation size, if present.  */
816
          if (cie->augmentation[0] == 'z')
817
            REQUIRE (read_uleb128 (&buf, end, &length));
818
          else
819
            length = 0;
820
 
821
          /* Of the supported augmentation characters above, only 'L'
822
             adds augmentation data to the FDE.  This code would need to
823
             be adjusted if any future augmentations do the same thing.  */
824
          if (cie->lsda_encoding != DW_EH_PE_omit)
825
            {
826
              SKIP_RELOCS (buf);
827
              if (cie->can_make_lsda_relative && GET_RELOC (buf))
828
                cie->cie_inf->u.cie.make_lsda_relative = 1;
829
              this_inf->lsda_offset = buf - start;
830
              /* If there's no 'z' augmentation, we don't know where the
831
                 CFA insns begin.  Assume no padding.  */
832
              if (cie->augmentation[0] != 'z')
833
                length = end - buf;
834
            }
835
 
836
          /* Skip over the augmentation data.  */
837
          REQUIRE (skip_bytes (&buf, end, length));
838
          insns = buf;
839
 
840
          buf = last_fde + 4 + hdr_length;
841
 
842
          /* For NULL RSEC (cleared FDE belonging to a discarded section)
843
             the relocations are commonly cleared.  We do not sanity check if
844
             all these relocations are cleared as (1) relocations to
845
             .gcc_except_table will remain uncleared (they will get dropped
846
             with the drop of this unused FDE) and (2) BFD already safely drops
847
             relocations of any type to .eh_frame by
848
             elf_section_ignore_discarded_relocs.
849
             TODO: The .gcc_except_table entries should be also filtered as
850
             .eh_frame entries; or GCC could rather use COMDAT for them.  */
851
          SKIP_RELOCS (buf);
852
        }
853
 
854
      /* Try to interpret the CFA instructions and find the first
855
         padding nop.  Shrink this_inf's size so that it doesn't
856
         include the padding.  */
857
      length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
858
      set_loc_count = 0;
859
      insns_end = skip_non_nops (insns, end, length, &set_loc_count);
860
      /* If we don't understand the CFA instructions, we can't know
861
         what needs to be adjusted there.  */
862
      if (insns_end == NULL
863
          /* For the time being we don't support DW_CFA_set_loc in
864
             CIE instructions.  */
865
          || (set_loc_count && this_inf->cie))
866
        goto free_no_table;
867
      this_inf->size -= end - insns_end;
868
      if (insns_end != end && this_inf->cie)
869
        {
870
          cie->initial_insn_length -= end - insns_end;
871
          cie->length -= end - insns_end;
872
        }
873
      if (set_loc_count
874
          && ((cie->fde_encoding & 0x70) == DW_EH_PE_pcrel
875
              || this_inf->make_relative))
876
        {
877
          unsigned int cnt;
878
          bfd_byte *p;
879
 
880
          this_inf->set_loc = (unsigned int *)
881
              bfd_malloc ((set_loc_count + 1) * sizeof (unsigned int));
882
          REQUIRE (this_inf->set_loc);
883
          this_inf->set_loc[0] = set_loc_count;
884
          p = insns;
885
          cnt = 0;
886
          while (p < end)
887
            {
888
              if (*p == DW_CFA_set_loc)
889
                this_inf->set_loc[++cnt] = p + 1 - start;
890
              REQUIRE (skip_cfa_op (&p, end, length));
891
            }
892
        }
893
 
894
      this_inf->removed = 1;
895
      this_inf->fde_encoding = cie->fde_encoding;
896
      this_inf->lsda_encoding = cie->lsda_encoding;
897
      sec_info->count++;
898
    }
899
  BFD_ASSERT (sec_info->count == num_entries);
900
  BFD_ASSERT (cie_count == num_cies);
901
 
902
  elf_section_data (sec)->sec_info = sec_info;
903
  sec->sec_info_type = ELF_INFO_TYPE_EH_FRAME;
904
  if (hdr_info->merge_cies)
905
    {
906
      sec_info->cies = local_cies;
907
      local_cies = NULL;
908
    }
909
  goto success;
910
 
911
 free_no_table:
912
  (*info->callbacks->einfo)
913
    (_("%P: error in %B(%A); no .eh_frame_hdr table will be created.\n"),
914
     abfd, sec);
915
  hdr_info->table = FALSE;
916
  if (sec_info)
917
    free (sec_info);
918
 success:
919
  if (ehbuf)
920
    free (ehbuf);
921
  if (local_cies)
922
    free (local_cies);
923
#undef REQUIRE
924
}
925
 
926
/* Finish a pass over all .eh_frame sections.  */
927
 
928
void
929
_bfd_elf_end_eh_frame_parsing (struct bfd_link_info *info)
930
{
931
  struct eh_frame_hdr_info *hdr_info;
932
 
933
  hdr_info = &elf_hash_table (info)->eh_info;
934
  hdr_info->parsed_eh_frames = TRUE;
935
}
936
 
937
/* Mark all relocations against CIE or FDE ENT, which occurs in
938
   .eh_frame section SEC.  COOKIE describes the relocations in SEC;
939
   its "rel" field can be changed freely.  */
940
 
941
static bfd_boolean
942
mark_entry (struct bfd_link_info *info, asection *sec,
943
            struct eh_cie_fde *ent, elf_gc_mark_hook_fn gc_mark_hook,
944
            struct elf_reloc_cookie *cookie)
945
{
946
  /* FIXME: octets_per_byte.  */
947
  for (cookie->rel = cookie->rels + ent->reloc_index;
948
       cookie->rel < cookie->relend
949
         && cookie->rel->r_offset < ent->offset + ent->size;
950
       cookie->rel++)
951
    if (!_bfd_elf_gc_mark_reloc (info, sec, gc_mark_hook, cookie))
952
      return FALSE;
953
 
954
  return TRUE;
955
}
956
 
957
/* Mark all the relocations against FDEs that relate to code in input
958
   section SEC.  The FDEs belong to .eh_frame section EH_FRAME, whose
959
   relocations are described by COOKIE.  */
960
 
961
bfd_boolean
962
_bfd_elf_gc_mark_fdes (struct bfd_link_info *info, asection *sec,
963
                       asection *eh_frame, elf_gc_mark_hook_fn gc_mark_hook,
964
                       struct elf_reloc_cookie *cookie)
965
{
966
  struct eh_cie_fde *fde, *cie;
967
 
968
  for (fde = elf_fde_list (sec); fde; fde = fde->u.fde.next_for_section)
969
    {
970
      if (!mark_entry (info, eh_frame, fde, gc_mark_hook, cookie))
971
        return FALSE;
972
 
973
      /* At this stage, all cie_inf fields point to local CIEs, so we
974
         can use the same cookie to refer to them.  */
975
      cie = fde->u.fde.cie_inf;
976
      if (!cie->u.cie.gc_mark)
977
        {
978
          cie->u.cie.gc_mark = 1;
979
          if (!mark_entry (info, eh_frame, cie, gc_mark_hook, cookie))
980
            return FALSE;
981
        }
982
    }
983
  return TRUE;
984
}
985
 
986
/* Input section SEC of ABFD is an .eh_frame section that contains the
987
   CIE described by CIE_INF.  Return a version of CIE_INF that is going
988
   to be kept in the output, adding CIE_INF to the output if necessary.
989
 
990
   HDR_INFO is the .eh_frame_hdr information and COOKIE describes the
991
   relocations in REL.  */
992
 
993
static struct eh_cie_fde *
994
find_merged_cie (bfd *abfd, struct bfd_link_info *info, asection *sec,
995
                 struct eh_frame_hdr_info *hdr_info,
996
                 struct elf_reloc_cookie *cookie,
997
                 struct eh_cie_fde *cie_inf)
998
{
999
  unsigned long r_symndx;
1000
  struct cie *cie, *new_cie;
1001
  Elf_Internal_Rela *rel;
1002
  void **loc;
1003
 
1004
  /* Use CIE_INF if we have already decided to keep it.  */
1005
  if (!cie_inf->removed)
1006
    return cie_inf;
1007
 
1008
  /* If we have merged CIE_INF with another CIE, use that CIE instead.  */
1009
  if (cie_inf->u.cie.merged)
1010
    return cie_inf->u.cie.u.merged_with;
1011
 
1012
  cie = cie_inf->u.cie.u.full_cie;
1013
 
1014
  /* Assume we will need to keep CIE_INF.  */
1015
  cie_inf->removed = 0;
1016
  cie_inf->u.cie.u.sec = sec;
1017
 
1018
  /* If we are not merging CIEs, use CIE_INF.  */
1019
  if (cie == NULL)
1020
    return cie_inf;
1021
 
1022
  if (cie->per_encoding != DW_EH_PE_omit)
1023
    {
1024
      bfd_boolean per_binds_local;
1025
 
1026
      /* Work out the address of personality routine, either as an absolute
1027
         value or as a symbol.  */
1028
      rel = cookie->rels + cie->personality.reloc_index;
1029
      memset (&cie->personality, 0, sizeof (cie->personality));
1030
#ifdef BFD64
1031
      if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64)
1032
        r_symndx = ELF64_R_SYM (rel->r_info);
1033
      else
1034
#endif
1035
        r_symndx = ELF32_R_SYM (rel->r_info);
1036
      if (r_symndx >= cookie->locsymcount
1037
          || ELF_ST_BIND (cookie->locsyms[r_symndx].st_info) != STB_LOCAL)
1038
        {
1039
          struct elf_link_hash_entry *h;
1040
 
1041
          r_symndx -= cookie->extsymoff;
1042
          h = cookie->sym_hashes[r_symndx];
1043
 
1044
          while (h->root.type == bfd_link_hash_indirect
1045
                 || h->root.type == bfd_link_hash_warning)
1046
            h = (struct elf_link_hash_entry *) h->root.u.i.link;
1047
 
1048
          cie->personality.h = h;
1049
          per_binds_local = SYMBOL_REFERENCES_LOCAL (info, h);
1050
        }
1051
      else
1052
        {
1053
          Elf_Internal_Sym *sym;
1054
          asection *sym_sec;
1055
 
1056
          sym = &cookie->locsyms[r_symndx];
1057
          sym_sec = bfd_section_from_elf_index (abfd, sym->st_shndx);
1058
          if (sym_sec == NULL)
1059
            return cie_inf;
1060
 
1061
          if (sym_sec->kept_section != NULL)
1062
            sym_sec = sym_sec->kept_section;
1063
          if (sym_sec->output_section == NULL)
1064
            return cie_inf;
1065
 
1066
          cie->local_personality = 1;
1067
          cie->personality.val = (sym->st_value
1068
                                  + sym_sec->output_offset
1069
                                  + sym_sec->output_section->vma);
1070
          per_binds_local = TRUE;
1071
        }
1072
 
1073
      if (per_binds_local
1074
          && info->shared
1075
          && (cie->per_encoding & 0x70) == DW_EH_PE_absptr
1076
          && (get_elf_backend_data (abfd)
1077
              ->elf_backend_can_make_relative_eh_frame (abfd, info, sec)))
1078
        {
1079
          cie_inf->u.cie.make_per_encoding_relative = 1;
1080
          cie_inf->u.cie.per_encoding_relative = 1;
1081
        }
1082
    }
1083
 
1084
  /* See if we can merge this CIE with an earlier one.  */
1085
  cie->output_sec = sec->output_section;
1086
  cie_compute_hash (cie);
1087
  if (hdr_info->cies == NULL)
1088
    {
1089
      hdr_info->cies = htab_try_create (1, cie_hash, cie_eq, free);
1090
      if (hdr_info->cies == NULL)
1091
        return cie_inf;
1092
    }
1093
  loc = htab_find_slot_with_hash (hdr_info->cies, cie, cie->hash, INSERT);
1094
  if (loc == NULL)
1095
    return cie_inf;
1096
 
1097
  new_cie = (struct cie *) *loc;
1098
  if (new_cie == NULL)
1099
    {
1100
      /* Keep CIE_INF and record it in the hash table.  */
1101
      new_cie = (struct cie *) malloc (sizeof (struct cie));
1102
      if (new_cie == NULL)
1103
        return cie_inf;
1104
 
1105
      memcpy (new_cie, cie, sizeof (struct cie));
1106
      *loc = new_cie;
1107
    }
1108
  else
1109
    {
1110
      /* Merge CIE_INF with NEW_CIE->CIE_INF.  */
1111
      cie_inf->removed = 1;
1112
      cie_inf->u.cie.merged = 1;
1113
      cie_inf->u.cie.u.merged_with = new_cie->cie_inf;
1114
      if (cie_inf->u.cie.make_lsda_relative)
1115
        new_cie->cie_inf->u.cie.make_lsda_relative = 1;
1116
    }
1117
  return new_cie->cie_inf;
1118
}
1119
 
1120
/* This function is called for each input file before the .eh_frame
1121
   section is relocated.  It discards duplicate CIEs and FDEs for discarded
1122
   functions.  The function returns TRUE iff any entries have been
1123
   deleted.  */
1124
 
1125
bfd_boolean
1126
_bfd_elf_discard_section_eh_frame
1127
   (bfd *abfd, struct bfd_link_info *info, asection *sec,
1128
    bfd_boolean (*reloc_symbol_deleted_p) (bfd_vma, void *),
1129
    struct elf_reloc_cookie *cookie)
1130
{
1131
  struct eh_cie_fde *ent;
1132
  struct eh_frame_sec_info *sec_info;
1133
  struct eh_frame_hdr_info *hdr_info;
1134
  unsigned int ptr_size, offset;
1135
 
1136
  sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
1137
  if (sec_info == NULL)
1138
    return FALSE;
1139
 
1140
  hdr_info = &elf_hash_table (info)->eh_info;
1141
  for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1142
    if (ent->size == 4)
1143
      /* There should only be one zero terminator, on the last input
1144
         file supplying .eh_frame (crtend.o).  Remove any others.  */
1145
      ent->removed = sec->map_head.s != NULL;
1146
    else if (!ent->cie)
1147
      {
1148
        cookie->rel = cookie->rels + ent->reloc_index;
1149
        /* FIXME: octets_per_byte.  */
1150
        BFD_ASSERT (cookie->rel < cookie->relend
1151
                    && cookie->rel->r_offset == ent->offset + 8);
1152
        if (!(*reloc_symbol_deleted_p) (ent->offset + 8, cookie))
1153
          {
1154
            if (info->shared
1155
                && (((ent->fde_encoding & 0x70) == DW_EH_PE_absptr
1156
                     && ent->make_relative == 0)
1157
                    || (ent->fde_encoding & 0x70) == DW_EH_PE_aligned))
1158
              {
1159
                /* If a shared library uses absolute pointers
1160
                   which we cannot turn into PC relative,
1161
                   don't create the binary search table,
1162
                   since it is affected by runtime relocations.  */
1163
                hdr_info->table = FALSE;
1164
                (*info->callbacks->einfo)
1165
                  (_("%P: fde encoding in %B(%A) prevents .eh_frame_hdr"
1166
                     " table being created.\n"), abfd, sec);
1167
              }
1168
            ent->removed = 0;
1169
            hdr_info->fde_count++;
1170
            ent->u.fde.cie_inf = find_merged_cie (abfd, info, sec, hdr_info,
1171
                                                  cookie, ent->u.fde.cie_inf);
1172
          }
1173
      }
1174
 
1175
  if (sec_info->cies)
1176
    {
1177
      free (sec_info->cies);
1178
      sec_info->cies = NULL;
1179
    }
1180
 
1181
  ptr_size = (get_elf_backend_data (sec->owner)
1182
              ->elf_backend_eh_frame_address_size (sec->owner, sec));
1183
  offset = 0;
1184
  for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1185
    if (!ent->removed)
1186
      {
1187
        ent->new_offset = offset;
1188
        offset += size_of_output_cie_fde (ent, ptr_size);
1189
      }
1190
 
1191
  sec->rawsize = sec->size;
1192
  sec->size = offset;
1193
  return offset != sec->rawsize;
1194
}
1195
 
1196
/* This function is called for .eh_frame_hdr section after
1197
   _bfd_elf_discard_section_eh_frame has been called on all .eh_frame
1198
   input sections.  It finalizes the size of .eh_frame_hdr section.  */
1199
 
1200
bfd_boolean
1201
_bfd_elf_discard_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
1202
{
1203
  struct elf_link_hash_table *htab;
1204
  struct eh_frame_hdr_info *hdr_info;
1205
  asection *sec;
1206
 
1207
  htab = elf_hash_table (info);
1208
  hdr_info = &htab->eh_info;
1209
 
1210
  if (hdr_info->cies != NULL)
1211
    {
1212
      htab_delete (hdr_info->cies);
1213
      hdr_info->cies = NULL;
1214
    }
1215
 
1216
  sec = hdr_info->hdr_sec;
1217
  if (sec == NULL)
1218
    return FALSE;
1219
 
1220
  sec->size = EH_FRAME_HDR_SIZE;
1221
  if (hdr_info->table)
1222
    sec->size += 4 + hdr_info->fde_count * 8;
1223
 
1224
  elf_tdata (abfd)->eh_frame_hdr = sec;
1225
  return TRUE;
1226
}
1227
 
1228
/* This function is called from size_dynamic_sections.
1229
   It needs to decide whether .eh_frame_hdr should be output or not,
1230
   because when the dynamic symbol table has been sized it is too late
1231
   to strip sections.  */
1232
 
1233
bfd_boolean
1234
_bfd_elf_maybe_strip_eh_frame_hdr (struct bfd_link_info *info)
1235
{
1236
  asection *o;
1237
  bfd *abfd;
1238
  struct elf_link_hash_table *htab;
1239
  struct eh_frame_hdr_info *hdr_info;
1240
 
1241
  htab = elf_hash_table (info);
1242
  hdr_info = &htab->eh_info;
1243
  if (hdr_info->hdr_sec == NULL)
1244
    return TRUE;
1245
 
1246
  if (bfd_is_abs_section (hdr_info->hdr_sec->output_section))
1247
    {
1248
      hdr_info->hdr_sec = NULL;
1249
      return TRUE;
1250
    }
1251
 
1252
  abfd = NULL;
1253
  if (info->eh_frame_hdr)
1254
    for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link_next)
1255
      {
1256
        /* Count only sections which have at least a single CIE or FDE.
1257
           There cannot be any CIE or FDE <= 8 bytes.  */
1258
        o = bfd_get_section_by_name (abfd, ".eh_frame");
1259
        if (o && o->size > 8 && !bfd_is_abs_section (o->output_section))
1260
          break;
1261
      }
1262
 
1263
  if (abfd == NULL)
1264
    {
1265
      hdr_info->hdr_sec->flags |= SEC_EXCLUDE;
1266
      hdr_info->hdr_sec = NULL;
1267
      return TRUE;
1268
    }
1269
 
1270
  hdr_info->table = TRUE;
1271
  return TRUE;
1272
}
1273
 
1274
/* Adjust an address in the .eh_frame section.  Given OFFSET within
1275
   SEC, this returns the new offset in the adjusted .eh_frame section,
1276
   or -1 if the address refers to a CIE/FDE which has been removed
1277
   or to offset with dynamic relocation which is no longer needed.  */
1278
 
1279
bfd_vma
1280
_bfd_elf_eh_frame_section_offset (bfd *output_bfd ATTRIBUTE_UNUSED,
1281
                                  struct bfd_link_info *info ATTRIBUTE_UNUSED,
1282
                                  asection *sec,
1283
                                  bfd_vma offset)
1284
{
1285
  struct eh_frame_sec_info *sec_info;
1286
  unsigned int lo, hi, mid;
1287
 
1288
  if (sec->sec_info_type != ELF_INFO_TYPE_EH_FRAME)
1289
    return offset;
1290
  sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
1291
 
1292
  if (offset >= sec->rawsize)
1293
    return offset - sec->rawsize + sec->size;
1294
 
1295
  lo = 0;
1296
  hi = sec_info->count;
1297
  mid = 0;
1298
  while (lo < hi)
1299
    {
1300
      mid = (lo + hi) / 2;
1301
      if (offset < sec_info->entry[mid].offset)
1302
        hi = mid;
1303
      else if (offset
1304
               >= sec_info->entry[mid].offset + sec_info->entry[mid].size)
1305
        lo = mid + 1;
1306
      else
1307
        break;
1308
    }
1309
 
1310
  BFD_ASSERT (lo < hi);
1311
 
1312
  /* FDE or CIE was removed.  */
1313
  if (sec_info->entry[mid].removed)
1314
    return (bfd_vma) -1;
1315
 
1316
  /* If converting personality pointers to DW_EH_PE_pcrel, there will be
1317
     no need for run-time relocation against the personality field.  */
1318
  if (sec_info->entry[mid].cie
1319
      && sec_info->entry[mid].u.cie.make_per_encoding_relative
1320
      && offset == (sec_info->entry[mid].offset + 8
1321
                    + sec_info->entry[mid].u.cie.personality_offset))
1322
    return (bfd_vma) -2;
1323
 
1324
  /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1325
     relocation against FDE's initial_location field.  */
1326
  if (!sec_info->entry[mid].cie
1327
      && sec_info->entry[mid].make_relative
1328
      && offset == sec_info->entry[mid].offset + 8)
1329
    return (bfd_vma) -2;
1330
 
1331
  /* If converting LSDA pointers to DW_EH_PE_pcrel, there will be no need
1332
     for run-time relocation against LSDA field.  */
1333
  if (!sec_info->entry[mid].cie
1334
      && sec_info->entry[mid].u.fde.cie_inf->u.cie.make_lsda_relative
1335
      && offset == (sec_info->entry[mid].offset + 8
1336
                    + sec_info->entry[mid].lsda_offset))
1337
    return (bfd_vma) -2;
1338
 
1339
  /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1340
     relocation against DW_CFA_set_loc's arguments.  */
1341
  if (sec_info->entry[mid].set_loc
1342
      && sec_info->entry[mid].make_relative
1343
      && (offset >= sec_info->entry[mid].offset + 8
1344
                    + sec_info->entry[mid].set_loc[1]))
1345
    {
1346
      unsigned int cnt;
1347
 
1348
      for (cnt = 1; cnt <= sec_info->entry[mid].set_loc[0]; cnt++)
1349
        if (offset == sec_info->entry[mid].offset + 8
1350
                      + sec_info->entry[mid].set_loc[cnt])
1351
          return (bfd_vma) -2;
1352
    }
1353
 
1354
  /* Any new augmentation bytes go before the first relocation.  */
1355
  return (offset + sec_info->entry[mid].new_offset
1356
          - sec_info->entry[mid].offset
1357
          + extra_augmentation_string_bytes (sec_info->entry + mid)
1358
          + extra_augmentation_data_bytes (sec_info->entry + mid));
1359
}
1360
 
1361
/* Write out .eh_frame section.  This is called with the relocated
1362
   contents.  */
1363
 
1364
bfd_boolean
1365
_bfd_elf_write_section_eh_frame (bfd *abfd,
1366
                                 struct bfd_link_info *info,
1367
                                 asection *sec,
1368
                                 bfd_byte *contents)
1369
{
1370
  struct eh_frame_sec_info *sec_info;
1371
  struct elf_link_hash_table *htab;
1372
  struct eh_frame_hdr_info *hdr_info;
1373
  unsigned int ptr_size;
1374
  struct eh_cie_fde *ent;
1375
 
1376
  if (sec->sec_info_type != ELF_INFO_TYPE_EH_FRAME)
1377
    /* FIXME: octets_per_byte.  */
1378
    return bfd_set_section_contents (abfd, sec->output_section, contents,
1379
                                     sec->output_offset, sec->size);
1380
 
1381
  ptr_size = (get_elf_backend_data (abfd)
1382
              ->elf_backend_eh_frame_address_size (abfd, sec));
1383
  BFD_ASSERT (ptr_size != 0);
1384
 
1385
  sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
1386
  htab = elf_hash_table (info);
1387
  hdr_info = &htab->eh_info;
1388
 
1389
  if (hdr_info->table && hdr_info->array == NULL)
1390
    hdr_info->array = (struct eh_frame_array_ent *)
1391
        bfd_malloc (hdr_info->fde_count * sizeof(*hdr_info->array));
1392
  if (hdr_info->array == NULL)
1393
    hdr_info = NULL;
1394
 
1395
  /* The new offsets can be bigger or smaller than the original offsets.
1396
     We therefore need to make two passes over the section: one backward
1397
     pass to move entries up and one forward pass to move entries down.
1398
     The two passes won't interfere with each other because entries are
1399
     not reordered  */
1400
  for (ent = sec_info->entry + sec_info->count; ent-- != sec_info->entry;)
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
    if (!ent->removed && ent->new_offset < ent->offset)
1406
      memmove (contents + ent->new_offset, contents + ent->offset, ent->size);
1407
 
1408
  for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1409
    {
1410
      unsigned char *buf, *end;
1411
      unsigned int new_size;
1412
 
1413
      if (ent->removed)
1414
        continue;
1415
 
1416
      if (ent->size == 4)
1417
        {
1418
          /* Any terminating FDE must be at the end of the section.  */
1419
          BFD_ASSERT (ent == sec_info->entry + sec_info->count - 1);
1420
          continue;
1421
        }
1422
 
1423
      buf = contents + ent->new_offset;
1424
      end = buf + ent->size;
1425
      new_size = size_of_output_cie_fde (ent, ptr_size);
1426
 
1427
      /* Update the size.  It may be shrinked.  */
1428
      bfd_put_32 (abfd, new_size - 4, buf);
1429
 
1430
      /* Filling the extra bytes with DW_CFA_nops.  */
1431
      if (new_size != ent->size)
1432
        memset (end, 0, new_size - ent->size);
1433
 
1434
      if (ent->cie)
1435
        {
1436
          /* CIE */
1437
          if (ent->make_relative
1438
              || ent->u.cie.make_lsda_relative
1439
              || ent->u.cie.per_encoding_relative)
1440
            {
1441
              char *aug;
1442
              unsigned int action, extra_string, extra_data;
1443
              unsigned int per_width, per_encoding;
1444
 
1445
              /* Need to find 'R' or 'L' augmentation's argument and modify
1446
                 DW_EH_PE_* value.  */
1447
              action = ((ent->make_relative ? 1 : 0)
1448
                        | (ent->u.cie.make_lsda_relative ? 2 : 0)
1449
                        | (ent->u.cie.per_encoding_relative ? 4 : 0));
1450
              extra_string = extra_augmentation_string_bytes (ent);
1451
              extra_data = extra_augmentation_data_bytes (ent);
1452
 
1453
              /* Skip length, id and version.  */
1454
              buf += 9;
1455
              aug = (char *) buf;
1456
              buf += strlen (aug) + 1;
1457
              skip_leb128 (&buf, end);
1458
              skip_leb128 (&buf, end);
1459
              skip_leb128 (&buf, end);
1460
              if (*aug == 'z')
1461
                {
1462
                  /* The uleb128 will always be a single byte for the kind
1463
                     of augmentation strings that we're prepared to handle.  */
1464
                  *buf++ += extra_data;
1465
                  aug++;
1466
                }
1467
 
1468
              /* Make room for the new augmentation string and data bytes.  */
1469
              memmove (buf + extra_string + extra_data, buf, end - buf);
1470
              memmove (aug + extra_string, aug, buf - (bfd_byte *) aug);
1471
              buf += extra_string;
1472
              end += extra_string + extra_data;
1473
 
1474
              if (ent->add_augmentation_size)
1475
                {
1476
                  *aug++ = 'z';
1477
                  *buf++ = extra_data - 1;
1478
                }
1479
              if (ent->u.cie.add_fde_encoding)
1480
                {
1481
                  BFD_ASSERT (action & 1);
1482
                  *aug++ = 'R';
1483
                  *buf++ = make_pc_relative (DW_EH_PE_absptr, ptr_size);
1484
                  action &= ~1;
1485
                }
1486
 
1487
              while (action)
1488
                switch (*aug++)
1489
                  {
1490
                  case 'L':
1491
                    if (action & 2)
1492
                      {
1493
                        BFD_ASSERT (*buf == ent->lsda_encoding);
1494
                        *buf = make_pc_relative (*buf, ptr_size);
1495
                        action &= ~2;
1496
                      }
1497
                    buf++;
1498
                    break;
1499
                  case 'P':
1500
                    if (ent->u.cie.make_per_encoding_relative)
1501
                      *buf = make_pc_relative (*buf, ptr_size);
1502
                    per_encoding = *buf++;
1503
                    per_width = get_DW_EH_PE_width (per_encoding, ptr_size);
1504
                    BFD_ASSERT (per_width != 0);
1505
                    BFD_ASSERT (((per_encoding & 0x70) == DW_EH_PE_pcrel)
1506
                                == ent->u.cie.per_encoding_relative);
1507
                    if ((per_encoding & 0x70) == DW_EH_PE_aligned)
1508
                      buf = (contents
1509
                             + ((buf - contents + per_width - 1)
1510
                                & ~((bfd_size_type) per_width - 1)));
1511
                    if (action & 4)
1512
                      {
1513
                        bfd_vma val;
1514
 
1515
                        val = read_value (abfd, buf, per_width,
1516
                                          get_DW_EH_PE_signed (per_encoding));
1517
                        if (ent->u.cie.make_per_encoding_relative)
1518
                          val -= (sec->output_section->vma
1519
                                  + sec->output_offset
1520
                                  + (buf - contents));
1521
                        else
1522
                          {
1523
                            val += (bfd_vma) ent->offset - ent->new_offset;
1524
                            val -= extra_string + extra_data;
1525
                          }
1526
                        write_value (abfd, buf, val, per_width);
1527
                        action &= ~4;
1528
                      }
1529
                    buf += per_width;
1530
                    break;
1531
                  case 'R':
1532
                    if (action & 1)
1533
                      {
1534
                        BFD_ASSERT (*buf == ent->fde_encoding);
1535
                        *buf = make_pc_relative (*buf, ptr_size);
1536
                        action &= ~1;
1537
                      }
1538
                    buf++;
1539
                    break;
1540
                  case 'S':
1541
                    break;
1542
                  default:
1543
                    BFD_FAIL ();
1544
                  }
1545
            }
1546
        }
1547
      else
1548
        {
1549
          /* FDE */
1550
          bfd_vma value, address;
1551
          unsigned int width;
1552
          bfd_byte *start;
1553
          struct eh_cie_fde *cie;
1554
 
1555
          /* Skip length.  */
1556
          cie = ent->u.fde.cie_inf;
1557
          buf += 4;
1558
          value = ((ent->new_offset + sec->output_offset + 4)
1559
                   - (cie->new_offset + cie->u.cie.u.sec->output_offset));
1560
          bfd_put_32 (abfd, value, buf);
1561
          buf += 4;
1562
          width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1563
          value = read_value (abfd, buf, width,
1564
                              get_DW_EH_PE_signed (ent->fde_encoding));
1565
          address = value;
1566
          if (value)
1567
            {
1568
              switch (ent->fde_encoding & 0x70)
1569
                {
1570
                case DW_EH_PE_textrel:
1571
                  BFD_ASSERT (hdr_info == NULL);
1572
                  break;
1573
                case DW_EH_PE_datarel:
1574
                  {
1575
                    asection *got = bfd_get_section_by_name (abfd, ".got");
1576
 
1577
                    BFD_ASSERT (got != NULL);
1578
                    address += got->vma;
1579
                  }
1580
                  break;
1581
                case DW_EH_PE_pcrel:
1582
                  value += (bfd_vma) ent->offset - ent->new_offset;
1583
                  address += (sec->output_section->vma
1584
                              + sec->output_offset
1585
                              + ent->offset + 8);
1586
                  break;
1587
                }
1588
              if (ent->make_relative)
1589
                value -= (sec->output_section->vma
1590
                          + sec->output_offset
1591
                          + ent->new_offset + 8);
1592
              write_value (abfd, buf, value, width);
1593
            }
1594
 
1595
          start = buf;
1596
 
1597
          if (hdr_info)
1598
            {
1599
              hdr_info->array[hdr_info->array_count].initial_loc = address;
1600
              hdr_info->array[hdr_info->array_count++].fde
1601
                = (sec->output_section->vma
1602
                   + sec->output_offset
1603
                   + ent->new_offset);
1604
            }
1605
 
1606
          if ((ent->lsda_encoding & 0x70) == DW_EH_PE_pcrel
1607
              || cie->u.cie.make_lsda_relative)
1608
            {
1609
              buf += ent->lsda_offset;
1610
              width = get_DW_EH_PE_width (ent->lsda_encoding, ptr_size);
1611
              value = read_value (abfd, buf, width,
1612
                                  get_DW_EH_PE_signed (ent->lsda_encoding));
1613
              if (value)
1614
                {
1615
                  if ((ent->lsda_encoding & 0x70) == DW_EH_PE_pcrel)
1616
                    value += (bfd_vma) ent->offset - ent->new_offset;
1617
                  else if (cie->u.cie.make_lsda_relative)
1618
                    value -= (sec->output_section->vma
1619
                              + sec->output_offset
1620
                              + ent->new_offset + 8 + ent->lsda_offset);
1621
                  write_value (abfd, buf, value, width);
1622
                }
1623
            }
1624
          else if (ent->add_augmentation_size)
1625
            {
1626
              /* Skip the PC and length and insert a zero byte for the
1627
                 augmentation size.  */
1628
              buf += width * 2;
1629
              memmove (buf + 1, buf, end - buf);
1630
              *buf = 0;
1631
            }
1632
 
1633
          if (ent->set_loc)
1634
            {
1635
              /* Adjust DW_CFA_set_loc.  */
1636
              unsigned int cnt;
1637
              bfd_vma new_offset;
1638
 
1639
              width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1640
              new_offset = ent->new_offset + 8
1641
                           + extra_augmentation_string_bytes (ent)
1642
                           + extra_augmentation_data_bytes (ent);
1643
 
1644
              for (cnt = 1; cnt <= ent->set_loc[0]; cnt++)
1645
                {
1646
                  buf = start + ent->set_loc[cnt];
1647
 
1648
                  value = read_value (abfd, buf, width,
1649
                                      get_DW_EH_PE_signed (ent->fde_encoding));
1650
                  if (!value)
1651
                    continue;
1652
 
1653
                  if ((ent->fde_encoding & 0x70) == DW_EH_PE_pcrel)
1654
                    value += (bfd_vma) ent->offset + 8 - new_offset;
1655
                  if (ent->make_relative)
1656
                    value -= (sec->output_section->vma
1657
                              + sec->output_offset
1658
                              + new_offset + ent->set_loc[cnt]);
1659
                  write_value (abfd, buf, value, width);
1660
                }
1661
            }
1662
        }
1663
    }
1664
 
1665
  /* We don't align the section to its section alignment since the
1666
     runtime library only expects all CIE/FDE records aligned at
1667
     the pointer size. _bfd_elf_discard_section_eh_frame should
1668
     have padded CIE/FDE records to multiple of pointer size with
1669
     size_of_output_cie_fde.  */
1670
  if ((sec->size % ptr_size) != 0)
1671
    abort ();
1672
 
1673
  /* FIXME: octets_per_byte.  */
1674
  return bfd_set_section_contents (abfd, sec->output_section,
1675
                                   contents, (file_ptr) sec->output_offset,
1676
                                   sec->size);
1677
}
1678
 
1679
/* Helper function used to sort .eh_frame_hdr search table by increasing
1680
   VMA of FDE initial location.  */
1681
 
1682
static int
1683
vma_compare (const void *a, const void *b)
1684
{
1685
  const struct eh_frame_array_ent *p = (const struct eh_frame_array_ent *) a;
1686
  const struct eh_frame_array_ent *q = (const struct eh_frame_array_ent *) b;
1687
  if (p->initial_loc > q->initial_loc)
1688
    return 1;
1689
  if (p->initial_loc < q->initial_loc)
1690
    return -1;
1691
  return 0;
1692
}
1693
 
1694
/* Write out .eh_frame_hdr section.  This must be called after
1695
   _bfd_elf_write_section_eh_frame has been called on all input
1696
   .eh_frame sections.
1697
   .eh_frame_hdr format:
1698
   ubyte version                (currently 1)
1699
   ubyte eh_frame_ptr_enc       (DW_EH_PE_* encoding of pointer to start of
1700
                                 .eh_frame section)
1701
   ubyte fde_count_enc          (DW_EH_PE_* encoding of total FDE count
1702
                                 number (or DW_EH_PE_omit if there is no
1703
                                 binary search table computed))
1704
   ubyte table_enc              (DW_EH_PE_* encoding of binary search table,
1705
                                 or DW_EH_PE_omit if not present.
1706
                                 DW_EH_PE_datarel is using address of
1707
                                 .eh_frame_hdr section start as base)
1708
   [encoded] eh_frame_ptr       (pointer to start of .eh_frame section)
1709
   optionally followed by:
1710
   [encoded] fde_count          (total number of FDEs in .eh_frame section)
1711
   fde_count x [encoded] initial_loc, fde
1712
                                (array of encoded pairs containing
1713
                                 FDE initial_location field and FDE address,
1714
                                 sorted by increasing initial_loc).  */
1715
 
1716
bfd_boolean
1717
_bfd_elf_write_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
1718
{
1719
  struct elf_link_hash_table *htab;
1720
  struct eh_frame_hdr_info *hdr_info;
1721
  asection *sec;
1722
  bfd_byte *contents;
1723
  asection *eh_frame_sec;
1724
  bfd_size_type size;
1725
  bfd_boolean retval;
1726
  bfd_vma encoded_eh_frame;
1727
 
1728
  htab = elf_hash_table (info);
1729
  hdr_info = &htab->eh_info;
1730
  sec = hdr_info->hdr_sec;
1731
  if (sec == NULL)
1732
    return TRUE;
1733
 
1734
  size = EH_FRAME_HDR_SIZE;
1735
  if (hdr_info->array && hdr_info->array_count == hdr_info->fde_count)
1736
    size += 4 + hdr_info->fde_count * 8;
1737
  contents = (bfd_byte *) bfd_malloc (size);
1738
  if (contents == NULL)
1739
    return FALSE;
1740
 
1741
  eh_frame_sec = bfd_get_section_by_name (abfd, ".eh_frame");
1742
  if (eh_frame_sec == NULL)
1743
    {
1744
      free (contents);
1745
      return FALSE;
1746
    }
1747
 
1748
  memset (contents, 0, EH_FRAME_HDR_SIZE);
1749
  contents[0] = 1;                               /* Version.  */
1750
  contents[1] = get_elf_backend_data (abfd)->elf_backend_encode_eh_address
1751
    (abfd, info, eh_frame_sec, 0, sec, 4,
1752
     &encoded_eh_frame);                        /* .eh_frame offset.  */
1753
 
1754
  if (hdr_info->array && hdr_info->array_count == hdr_info->fde_count)
1755
    {
1756
      contents[2] = DW_EH_PE_udata4;            /* FDE count encoding.  */
1757
      contents[3] = DW_EH_PE_datarel | DW_EH_PE_sdata4; /* Search table enc.  */
1758
    }
1759
  else
1760
    {
1761
      contents[2] = DW_EH_PE_omit;
1762
      contents[3] = DW_EH_PE_omit;
1763
    }
1764
  bfd_put_32 (abfd, encoded_eh_frame, contents + 4);
1765
 
1766
  if (contents[2] != DW_EH_PE_omit)
1767
    {
1768
      unsigned int i;
1769
 
1770
      bfd_put_32 (abfd, hdr_info->fde_count, contents + EH_FRAME_HDR_SIZE);
1771
      qsort (hdr_info->array, hdr_info->fde_count, sizeof (*hdr_info->array),
1772
             vma_compare);
1773
      for (i = 0; i < hdr_info->fde_count; i++)
1774
        {
1775
          bfd_put_32 (abfd,
1776
                      hdr_info->array[i].initial_loc
1777
                      - sec->output_section->vma,
1778
                      contents + EH_FRAME_HDR_SIZE + i * 8 + 4);
1779
          bfd_put_32 (abfd,
1780
                      hdr_info->array[i].fde - sec->output_section->vma,
1781
                      contents + EH_FRAME_HDR_SIZE + i * 8 + 8);
1782
        }
1783
    }
1784
 
1785
  /* FIXME: octets_per_byte.  */
1786
  retval = bfd_set_section_contents (abfd, sec->output_section,
1787
                                     contents, (file_ptr) sec->output_offset,
1788
                                     sec->size);
1789
  free (contents);
1790
  return retval;
1791
}
1792
 
1793
/* Return the width of FDE addresses.  This is the default implementation.  */
1794
 
1795
unsigned int
1796
_bfd_elf_eh_frame_address_size (bfd *abfd, asection *sec ATTRIBUTE_UNUSED)
1797
{
1798
  return elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64 ? 8 : 4;
1799
}
1800
 
1801
/* Decide whether we can use a PC-relative encoding within the given
1802
   EH frame section.  This is the default implementation.  */
1803
 
1804
bfd_boolean
1805
_bfd_elf_can_make_relative (bfd *input_bfd ATTRIBUTE_UNUSED,
1806
                            struct bfd_link_info *info ATTRIBUTE_UNUSED,
1807
                            asection *eh_frame_section ATTRIBUTE_UNUSED)
1808
{
1809
  return TRUE;
1810
}
1811
 
1812
/* Select an encoding for the given address.  Preference is given to
1813
   PC-relative addressing modes.  */
1814
 
1815
bfd_byte
1816
_bfd_elf_encode_eh_address (bfd *abfd ATTRIBUTE_UNUSED,
1817
                            struct bfd_link_info *info ATTRIBUTE_UNUSED,
1818
                            asection *osec, bfd_vma offset,
1819
                            asection *loc_sec, bfd_vma loc_offset,
1820
                            bfd_vma *encoded)
1821
{
1822
  *encoded = osec->vma + offset -
1823
    (loc_sec->output_section->vma + loc_sec->output_offset + loc_offset);
1824
  return DW_EH_PE_pcrel | DW_EH_PE_sdata4;
1825
}

powered by: WebSVN 2.1.0

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