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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [bfd/] [coff-m68k.c] - Blame information for rev 225

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* BFD back-end for Motorola 68000 COFF binaries.
2
   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1999,
3 225 jeremybenn
   2000, 2001, 2002, 2003, 2005, 2007, 2008
4 24 jeremybenn
   Free Software Foundation, Inc.
5
   Written by Cygnus Support.
6
 
7
   This file is part of BFD, the Binary File Descriptor library.
8
 
9
   This program is free software; you can redistribute it and/or modify
10
   it under the terms of the GNU General Public License as published by
11
   the Free Software Foundation; either version 3 of the License, or
12
   (at your option) any later version.
13
 
14
   This program is distributed in the hope that it will be useful,
15
   but WITHOUT ANY WARRANTY; without even the implied warranty of
16
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17
   GNU General Public License for more details.
18
 
19
   You should have received a copy of the GNU General Public License
20
   along with this program; if not, write to the Free Software
21
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22
   MA 02110-1301, USA.  */
23
 
24
#include "sysdep.h"
25
#include "bfd.h"
26
#include "libbfd.h"
27
#include "coff/m68k.h"
28
#include "coff/internal.h"
29
#include "libcoff.h"
30
 
31
/* This source file is compiled multiple times for various m68k COFF
32
   variants.  The following macros control its behaviour:
33
 
34
   TARGET_SYM
35
     The C name of the BFD target vector.  The default is m68kcoff_vec.
36
   TARGET_NAME
37
     The user visible target name.  The default is "coff-m68k".
38
   NAMES_HAVE_UNDERSCORE
39
     Whether symbol names have an underscore.
40
   ONLY_DECLARE_RELOCS
41
     Only declare the relocation howto array.  Don't actually compile
42
     it.  The actual array will be picked up in another version of the
43
     file.
44
   STATIC_RELOCS
45
     Make the relocation howto array, and associated functions, static.
46
   COFF_COMMON_ADDEND
47
     If this is defined, then, for a relocation against a common
48
     symbol, the object file holds the value (the size) of the common
49
     symbol.  If this is not defined, then, for a relocation against a
50
     common symbol, the object file holds zero.  */
51
 
52
#define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (2)
53
 
54
#ifndef COFF_PAGE_SIZE
55
/* The page size is a guess based on ELF.  */
56
#define COFF_PAGE_SIZE 0x2000
57
#endif
58
 
59
#ifndef COFF_COMMON_ADDEND
60
#define RELOC_SPECIAL_FN 0
61
#else
62
static bfd_reloc_status_type m68kcoff_common_addend_special_fn
63
  PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
64
static reloc_howto_type *m68kcoff_common_addend_rtype_to_howto
65
  PARAMS ((bfd *, asection *, struct internal_reloc *,
66
           struct coff_link_hash_entry *, struct internal_syment *,
67
           bfd_vma *));
68
#define RELOC_SPECIAL_FN m68kcoff_common_addend_special_fn
69
#endif
70
 
71
static bfd_boolean m68k_coff_is_local_label_name
72
  PARAMS ((bfd *, const char *));
73
 
74
/* On the delta, a symbol starting with L% is local.  We won't see
75
   such a symbol on other platforms, so it should be safe to always
76
   consider it local here.  */
77
 
78
static bfd_boolean
79
m68k_coff_is_local_label_name (abfd, name)
80
     bfd *abfd;
81
     const char *name;
82
{
83
  if (name[0] == 'L' && name[1] == '%')
84
    return TRUE;
85
 
86
  return _bfd_coff_is_local_label_name (abfd, name);
87
}
88
 
89
#ifndef STATIC_RELOCS
90
/* Clean up namespace.  */
91
#define m68kcoff_howto_table    _bfd_m68kcoff_howto_table
92
#define m68k_rtype2howto        _bfd_m68kcoff_rtype2howto
93
#define m68k_howto2rtype        _bfd_m68kcoff_howto2rtype
94
#define m68k_reloc_type_lookup  _bfd_m68kcoff_reloc_type_lookup
95
#define m68k_reloc_name_lookup _bfd_m68kcoff_reloc_name_lookup
96
#endif
97
 
98
#ifdef ONLY_DECLARE_RELOCS
99
extern reloc_howto_type m68kcoff_howto_table[];
100
#else
101
#ifdef STATIC_RELOCS
102
static
103
#endif
104
reloc_howto_type m68kcoff_howto_table[] =
105
  {
106
    HOWTO (R_RELBYTE,          0,  0,     8,  FALSE, 0, complain_overflow_bitfield, RELOC_SPECIAL_FN, "8", TRUE, 0x000000ff,0x000000ff, FALSE),
107
    HOWTO (R_RELWORD,          0,  1,    16, FALSE, 0, complain_overflow_bitfield, RELOC_SPECIAL_FN, "16",        TRUE, 0x0000ffff,0x0000ffff, FALSE),
108
    HOWTO (R_RELLONG,          0,  2,    32, FALSE, 0, complain_overflow_bitfield, RELOC_SPECIAL_FN, "32",        TRUE, 0xffffffff,0xffffffff, FALSE),
109
    HOWTO (R_PCRBYTE,          0,  0,     8,  TRUE,  0, complain_overflow_signed,   RELOC_SPECIAL_FN, "DISP8",    TRUE, 0x000000ff,0x000000ff, FALSE),
110
    HOWTO (R_PCRWORD,          0,  1,    16, TRUE,  0, complain_overflow_signed,   RELOC_SPECIAL_FN, "DISP16",   TRUE, 0x0000ffff,0x0000ffff, FALSE),
111
    HOWTO (R_PCRLONG,          0,  2,    32, TRUE,  0, complain_overflow_signed,   RELOC_SPECIAL_FN, "DISP32",   TRUE, 0xffffffff,0xffffffff, FALSE),
112
    HOWTO (R_RELLONG_NEG,      0, -2,    32, FALSE, 0, complain_overflow_bitfield, RELOC_SPECIAL_FN, "-32",       TRUE, 0xffffffff,0xffffffff, FALSE),
113
  };
114
#endif /* not ONLY_DECLARE_RELOCS */
115
 
116
#ifndef BADMAG
117
#define BADMAG(x) M68KBADMAG(x)
118
#endif
119
#define M68 1           /* Customize coffcode.h */
120
 
121
/* Turn a howto into a reloc number */
122
 
123
#ifdef ONLY_DECLARE_RELOCS
124
extern void m68k_rtype2howto PARAMS ((arelent *internal, int relocentry));
125
extern int m68k_howto2rtype PARAMS ((reloc_howto_type *));
126
extern reloc_howto_type *m68k_reloc_type_lookup
127
  PARAMS ((bfd *, bfd_reloc_code_real_type));
128
extern reloc_howto_type *m68k_reloc_name_lookup
129
  PARAMS ((bfd *, const char *));
130
#else
131
 
132
#ifdef STATIC_RELOCS
133
#define STAT_REL static
134
#else
135
#define STAT_REL
136
#endif
137
 
138
STAT_REL reloc_howto_type * m68k_reloc_type_lookup PARAMS ((bfd *, bfd_reloc_code_real_type));
139
STAT_REL reloc_howto_type * m68k_reloc_name_lookup PARAMS ((bfd *, const char *));
140
STAT_REL int m68k_howto2rtype PARAMS ((reloc_howto_type *));
141
STAT_REL void m68k_rtype2howto PARAMS ((arelent *, int));
142
 
143
 
144
STAT_REL void
145
m68k_rtype2howto(internal, relocentry)
146
     arelent *internal;
147
     int relocentry;
148
{
149
  switch (relocentry)
150
    {
151
    case R_RELBYTE:     internal->howto = m68kcoff_howto_table + 0; break;
152
    case R_RELWORD:     internal->howto = m68kcoff_howto_table + 1; break;
153
    case R_RELLONG:     internal->howto = m68kcoff_howto_table + 2; break;
154
    case R_PCRBYTE:     internal->howto = m68kcoff_howto_table + 3; break;
155
    case R_PCRWORD:     internal->howto = m68kcoff_howto_table + 4; break;
156
    case R_PCRLONG:     internal->howto = m68kcoff_howto_table + 5; break;
157
    case R_RELLONG_NEG: internal->howto = m68kcoff_howto_table + 6; break;
158
    }
159
}
160
 
161
STAT_REL int
162
m68k_howto2rtype (internal)
163
     reloc_howto_type *internal;
164
{
165
  if (internal->pc_relative)
166
    {
167
      switch (internal->bitsize)
168
        {
169
        case 32: return R_PCRLONG;
170
        case 16: return R_PCRWORD;
171
        case 8: return R_PCRBYTE;
172
        }
173
    }
174
  else
175
    {
176
      switch (internal->bitsize)
177
        {
178
        case 32: return R_RELLONG;
179
        case 16: return R_RELWORD;
180
        case 8: return R_RELBYTE;
181
        }
182
    }
183
  return R_RELLONG;
184
}
185
 
186
STAT_REL reloc_howto_type *
187
m68k_reloc_type_lookup (abfd, code)
188
     bfd *abfd ATTRIBUTE_UNUSED;
189
     bfd_reloc_code_real_type code;
190
{
191
  switch (code)
192
    {
193
    default:                    return NULL;
194
    case BFD_RELOC_8:           return m68kcoff_howto_table + 0;
195
    case BFD_RELOC_16:          return m68kcoff_howto_table + 1;
196
    case BFD_RELOC_CTOR:
197
    case BFD_RELOC_32:          return m68kcoff_howto_table + 2;
198
    case BFD_RELOC_8_PCREL:     return m68kcoff_howto_table + 3;
199
    case BFD_RELOC_16_PCREL:    return m68kcoff_howto_table + 4;
200
    case BFD_RELOC_32_PCREL:    return m68kcoff_howto_table + 5;
201
      /* FIXME: There doesn't seem to be a code for R_RELLONG_NEG.  */
202
    }
203
  /*NOTREACHED*/
204
}
205
 
206
STAT_REL reloc_howto_type *
207
m68k_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
208
                        const char *r_name)
209
{
210
  unsigned int i;
211
 
212
  for (i = 0;
213
       i < sizeof (m68kcoff_howto_table) / sizeof (m68kcoff_howto_table[0]);
214
       i++)
215
    if (m68kcoff_howto_table[i].name != NULL
216
        && strcasecmp (m68kcoff_howto_table[i].name, r_name) == 0)
217
      return &m68kcoff_howto_table[i];
218
 
219
  return NULL;
220
}
221
 
222
#endif /* not ONLY_DECLARE_RELOCS */
223
 
224
#define RTYPE2HOWTO(internal, relocentry) \
225
  m68k_rtype2howto(internal, (relocentry)->r_type)
226
 
227
#define SELECT_RELOC(external, internal) \
228
  external.r_type = m68k_howto2rtype (internal)
229
 
230
#define coff_bfd_reloc_type_lookup m68k_reloc_type_lookup
231
#define coff_bfd_reloc_name_lookup m68k_reloc_name_lookup
232
 
233
#ifndef COFF_COMMON_ADDEND
234
#ifndef coff_rtype_to_howto
235
 
236
#define coff_rtype_to_howto m68kcoff_rtype_to_howto
237
 
238
static reloc_howto_type *m68kcoff_rtype_to_howto
239
  PARAMS ((bfd *, asection *, struct internal_reloc *,
240
           struct coff_link_hash_entry *, struct internal_syment *,
241
           bfd_vma *));
242
 
243
static reloc_howto_type *
244
m68kcoff_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
245
     bfd *abfd ATTRIBUTE_UNUSED;
246
     asection *sec;
247
     struct internal_reloc *rel;
248
     struct coff_link_hash_entry *h ATTRIBUTE_UNUSED;
249
     struct internal_syment *sym ATTRIBUTE_UNUSED;
250
     bfd_vma *addendp;
251
{
252
  arelent relent;
253
  reloc_howto_type *howto;
254
 
255
  relent.howto = NULL;
256
  RTYPE2HOWTO (&relent, rel);
257
 
258
  howto = relent.howto;
259
 
260
  if (howto != NULL && howto->pc_relative)
261
    *addendp += sec->vma;
262
 
263
  return howto;
264
}
265
 
266
#endif /* ! defined (coff_rtype_to_howto) */
267
#endif /* ! defined (COFF_COMMON_ADDEND) */
268
 
269
#ifdef COFF_COMMON_ADDEND
270
 
271
/* If COFF_COMMON_ADDEND is defined, then when using m68k COFF the
272
   value stored in the .text section for a reference to a common
273
   symbol is the value itself plus any desired offset.  (taken from
274
   work done by Ian Taylor, Cygnus Support, for I386 COFF).  */
275
 
276
/* If we are producing relocatable output, we need to do some
277
   adjustments to the object file that are not done by the
278
   bfd_perform_relocation function.  This function is called by every
279
   reloc type to make any required adjustments.  */
280
 
281
static bfd_reloc_status_type
282
m68kcoff_common_addend_special_fn (abfd, reloc_entry, symbol, data,
283
                                   input_section, output_bfd, error_message)
284
     bfd *abfd;
285
     arelent *reloc_entry;
286
     asymbol *symbol;
287
     PTR data;
288
     asection *input_section ATTRIBUTE_UNUSED;
289
     bfd *output_bfd;
290
     char **error_message ATTRIBUTE_UNUSED;
291
{
292
  symvalue diff;
293
 
294
  if (output_bfd == (bfd *) NULL)
295
    return bfd_reloc_continue;
296
 
297
  if (bfd_is_com_section (symbol->section))
298
    {
299
      /* We are relocating a common symbol.  The current value in the
300
         object file is ORIG + OFFSET, where ORIG is the value of the
301
         common symbol as seen by the object file when it was compiled
302
         (this may be zero if the symbol was undefined) and OFFSET is
303
         the offset into the common symbol (normally zero, but may be
304
         non-zero when referring to a field in a common structure).
305
         ORIG is the negative of reloc_entry->addend, which is set by
306
         the CALC_ADDEND macro below.  We want to replace the value in
307
         the object file with NEW + OFFSET, where NEW is the value of
308
         the common symbol which we are going to put in the final
309
         object file.  NEW is symbol->value.  */
310
      diff = symbol->value + reloc_entry->addend;
311
    }
312
  else
313
    {
314
      /* For some reason bfd_perform_relocation always effectively
315
         ignores the addend for a COFF target when producing
316
         relocatable output.  This seems to be always wrong for 386
317
         COFF, so we handle the addend here instead.  */
318
      diff = reloc_entry->addend;
319
    }
320
 
321
#define DOIT(x) \
322
  x = ((x & ~howto->dst_mask) | (((x & howto->src_mask) + diff) & howto->dst_mask))
323
 
324
  if (diff != 0)
325
    {
326
      reloc_howto_type *howto = reloc_entry->howto;
327
      unsigned char *addr = (unsigned char *) data + reloc_entry->address;
328
 
329
      switch (howto->size)
330
        {
331
        case 0:
332
          {
333
            char x = bfd_get_8 (abfd, addr);
334
            DOIT (x);
335
            bfd_put_8 (abfd, x, addr);
336
          }
337
          break;
338
 
339
        case 1:
340
          {
341
            short x = bfd_get_16 (abfd, addr);
342
            DOIT (x);
343
            bfd_put_16 (abfd, (bfd_vma) x, addr);
344
          }
345
          break;
346
 
347
        case 2:
348
          {
349
            long x = bfd_get_32 (abfd, addr);
350
            DOIT (x);
351
            bfd_put_32 (abfd, (bfd_vma) x, addr);
352
          }
353
          break;
354
 
355
        default:
356
          abort ();
357
        }
358
    }
359
 
360
  /* Now let bfd_perform_relocation finish everything up.  */
361
  return bfd_reloc_continue;
362
}
363
 
364
/* Compute the addend of a reloc.  If the reloc is to a common symbol,
365
   the object file contains the value of the common symbol.  By the
366
   time this is called, the linker may be using a different symbol
367
   from a different object file with a different value.  Therefore, we
368
   hack wildly to locate the original symbol from this file so that we
369
   can make the correct adjustment.  This macro sets coffsym to the
370
   symbol from the original file, and uses it to set the addend value
371
   correctly.  If this is not a common symbol, the usual addend
372
   calculation is done, except that an additional tweak is needed for
373
   PC relative relocs.
374
   FIXME: This macro refers to symbols and asect; these are from the
375
   calling function, not the macro arguments.  */
376
 
377
#define CALC_ADDEND(abfd, ptr, reloc, cache_ptr)                \
378
  {                                                             \
379
    coff_symbol_type *coffsym = (coff_symbol_type *) NULL;      \
380
    if (ptr && bfd_asymbol_bfd (ptr) != abfd)                   \
381
      coffsym = (obj_symbols (abfd)                             \
382
                 + (cache_ptr->sym_ptr_ptr - symbols));         \
383
    else if (ptr)                                               \
384
      coffsym = coff_symbol_from (abfd, ptr);                   \
385
    if (coffsym != (coff_symbol_type *) NULL                    \
386
        && coffsym->native->u.syment.n_scnum == 0)               \
387
      cache_ptr->addend = - coffsym->native->u.syment.n_value;  \
388
    else if (ptr && bfd_asymbol_bfd (ptr) == abfd               \
389
             && ptr->section != (asection *) NULL)              \
390
      cache_ptr->addend = - (ptr->section->vma + ptr->value);   \
391
    else                                                        \
392
      cache_ptr->addend = 0;                                     \
393
    if (ptr && (reloc.r_type == R_PCRBYTE                       \
394
                || reloc.r_type == R_PCRWORD                    \
395
                || reloc.r_type == R_PCRLONG))                  \
396
      cache_ptr->addend += asect->vma;                          \
397
  }
398
 
399
#ifndef coff_rtype_to_howto
400
 
401
/* coff-m68k.c uses the special COFF backend linker.  We need to
402
   adjust common symbols.  */
403
 
404
static reloc_howto_type *
405
m68kcoff_common_addend_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
406
     bfd *abfd ATTRIBUTE_UNUSED;
407
     asection *sec;
408
     struct internal_reloc *rel;
409
     struct coff_link_hash_entry *h;
410
     struct internal_syment *sym;
411
     bfd_vma *addendp;
412
{
413
  arelent relent;
414
  reloc_howto_type *howto;
415
 
416
  relent.howto = NULL;
417
  RTYPE2HOWTO (&relent, rel);
418
 
419
  howto = relent.howto;
420
 
421
  if (howto->pc_relative)
422
    *addendp += sec->vma;
423
 
424
  if (sym != NULL && sym->n_scnum == 0 && sym->n_value != 0)
425
    {
426
      /* This is a common symbol.  The section contents include the
427
         size (sym->n_value) as an addend.  The relocate_section
428
         function will be adding in the final value of the symbol.  We
429
         need to subtract out the current size in order to get the
430
         correct result.  */
431
      BFD_ASSERT (h != NULL);
432
      *addendp -= sym->n_value;
433
    }
434
 
435
  /* If the output symbol is common (in which case this must be a
436
     relocatable link), we need to add in the final size of the
437
     common symbol.  */
438
  if (h != NULL && h->root.type == bfd_link_hash_common)
439
    *addendp += h->root.u.c.size;
440
 
441
  return howto;
442
}
443
 
444
#define coff_rtype_to_howto m68kcoff_common_addend_rtype_to_howto
445
 
446
#endif /* ! defined (coff_rtype_to_howto) */
447
 
448
#endif /* COFF_COMMON_ADDEND */
449
 
450
#if !defined ONLY_DECLARE_RELOCS && ! defined STATIC_RELOCS
451
/* Given a .data section and a .emreloc in-memory section, store
452
   relocation information into the .emreloc section which can be
453
   used at runtime to relocate the section.  This is called by the
454
   linker when the --embedded-relocs switch is used.  This is called
455
   after the add_symbols entry point has been called for all the
456
   objects, and before the final_link entry point is called.  */
457
 
458
bfd_boolean
459
bfd_m68k_coff_create_embedded_relocs (abfd, info, datasec, relsec, errmsg)
460
     bfd *abfd;
461
     struct bfd_link_info *info;
462
     asection *datasec;
463
     asection *relsec;
464
     char **errmsg;
465
{
466
  char *extsyms;
467
  bfd_size_type symesz;
468
  struct internal_reloc *irel, *irelend;
469
  bfd_byte *p;
470
  bfd_size_type amt;
471
 
472
  BFD_ASSERT (! info->relocatable);
473
 
474
  *errmsg = NULL;
475
 
476
  if (datasec->reloc_count == 0)
477
    return TRUE;
478
 
479
  extsyms = obj_coff_external_syms (abfd);
480
  symesz = bfd_coff_symesz (abfd);
481
 
482
  irel = _bfd_coff_read_internal_relocs (abfd, datasec, TRUE, NULL, FALSE,
483
                                         NULL);
484
  irelend = irel + datasec->reloc_count;
485
 
486
  amt = (bfd_size_type) datasec->reloc_count * 12;
487
  relsec->contents = (bfd_byte *) bfd_alloc (abfd, amt);
488
  if (relsec->contents == NULL)
489
    return FALSE;
490
 
491
  p = relsec->contents;
492
 
493
  for (; irel < irelend; irel++, p += 12)
494
    {
495
      asection *targetsec;
496
 
497
      /* We are going to write a four byte longword into the runtime
498
       reloc section.  The longword will be the address in the data
499
       section which must be relocated.  It is followed by the name
500
       of the target section NUL-padded or truncated to 8
501
       characters.  */
502
 
503
      /* We can only relocate absolute longword relocs at run time.  */
504
      if (irel->r_type != R_RELLONG)
505
        {
506
          *errmsg = _("unsupported reloc type");
507
          bfd_set_error (bfd_error_bad_value);
508
          return FALSE;
509
        }
510
 
511
      if (irel->r_symndx == -1)
512
        targetsec = bfd_abs_section_ptr;
513
      else
514
        {
515
          struct coff_link_hash_entry *h;
516
 
517
          h = obj_coff_sym_hashes (abfd)[irel->r_symndx];
518
          if (h == NULL)
519
            {
520
              struct internal_syment isym;
521
 
522
              bfd_coff_swap_sym_in (abfd, extsyms + symesz * irel->r_symndx,
523
                                    &isym);
524
              targetsec = coff_section_from_bfd_index (abfd, isym.n_scnum);
525
            }
526
          else if (h->root.type == bfd_link_hash_defined
527
                   || h->root.type == bfd_link_hash_defweak)
528
            targetsec = h->root.u.def.section;
529
          else
530
            targetsec = NULL;
531
        }
532
 
533
      bfd_put_32 (abfd,
534
                  (irel->r_vaddr - datasec->vma + datasec->output_offset), p);
535
      memset (p + 4, 0, 8);
536
      if (targetsec != NULL)
537
        strncpy ((char *) p + 4, targetsec->output_section->name, 8);
538
    }
539
 
540
  return TRUE;
541
}
542
#endif /* neither ONLY_DECLARE_RELOCS not STATIC_RELOCS  */
543
 
544
#define coff_bfd_is_local_label_name m68k_coff_is_local_label_name
545
 
546
#define coff_relocate_section _bfd_coff_generic_relocate_section
547
 
548 225 jeremybenn
#ifndef bfd_pe_print_pdata
549
#define bfd_pe_print_pdata      NULL
550
#endif
551
 
552 24 jeremybenn
#include "coffcode.h"
553
 
554
#ifndef TARGET_SYM
555
#define TARGET_SYM m68kcoff_vec
556
#endif
557
 
558
#ifndef TARGET_NAME
559
#define TARGET_NAME "coff-m68k"
560
#endif
561
 
562
#ifdef NAMES_HAVE_UNDERSCORE
563
CREATE_BIG_COFF_TARGET_VEC (TARGET_SYM, TARGET_NAME, D_PAGED, 0, '_', NULL, COFF_SWAP_TABLE)
564
#else
565
CREATE_BIG_COFF_TARGET_VEC (TARGET_SYM, TARGET_NAME, D_PAGED, 0, 0, NULL, COFF_SWAP_TABLE)
566
#endif

powered by: WebSVN 2.1.0

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