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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.3/] [bfd/] [elflink.c] - Blame information for rev 1181

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

Line No. Rev Author Line
1 1181 sfurman
/* ELF linking support for BFD.
2
   Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002
3
   Free Software Foundation, Inc.
4
 
5
This file is part of BFD, the Binary File Descriptor library.
6
 
7
This program is free software; you can redistribute it and/or modify
8
it under the terms of the GNU General Public License as published by
9
the Free Software Foundation; either version 2 of the License, or
10
(at your option) any later version.
11
 
12
This program is distributed in the hope that it will be useful,
13
but WITHOUT ANY WARRANTY; without even the implied warranty of
14
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
GNU General Public License for more details.
16
 
17
You should have received a copy of the GNU General Public License
18
along with this program; if not, write to the Free Software
19
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
20
 
21
#include "bfd.h"
22
#include "sysdep.h"
23
#include "bfdlink.h"
24
#include "libbfd.h"
25
#define ARCH_SIZE 0
26
#include "elf-bfd.h"
27
 
28
boolean
29
_bfd_elf_create_got_section (abfd, info)
30
     bfd *abfd;
31
     struct bfd_link_info *info;
32
{
33
  flagword flags;
34
  register asection *s;
35
  struct elf_link_hash_entry *h;
36
  struct elf_backend_data *bed = get_elf_backend_data (abfd);
37
  int ptralign;
38
 
39
  /* This function may be called more than once.  */
40
  if (bfd_get_section_by_name (abfd, ".got") != NULL)
41
    return true;
42
 
43
  switch (bed->s->arch_size)
44
    {
45
    case 32:
46
      ptralign = 2;
47
      break;
48
 
49
    case 64:
50
      ptralign = 3;
51
      break;
52
 
53
    default:
54
      bfd_set_error (bfd_error_bad_value);
55
      return false;
56
    }
57
 
58
  flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
59
           | SEC_LINKER_CREATED);
60
 
61
  s = bfd_make_section (abfd, ".got");
62
  if (s == NULL
63
      || !bfd_set_section_flags (abfd, s, flags)
64
      || !bfd_set_section_alignment (abfd, s, ptralign))
65
    return false;
66
 
67
  if (bed->want_got_plt)
68
    {
69
      s = bfd_make_section (abfd, ".got.plt");
70
      if (s == NULL
71
          || !bfd_set_section_flags (abfd, s, flags)
72
          || !bfd_set_section_alignment (abfd, s, ptralign))
73
        return false;
74
    }
75
 
76
  if (bed->want_got_sym)
77
    {
78
      /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
79
         (or .got.plt) section.  We don't do this in the linker script
80
         because we don't want to define the symbol if we are not creating
81
         a global offset table.  */
82
      h = NULL;
83
      if (!(_bfd_generic_link_add_one_symbol
84
            (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL, s,
85
             bed->got_symbol_offset, (const char *) NULL, false,
86
             bed->collect, (struct bfd_link_hash_entry **) &h)))
87
        return false;
88
      h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
89
      h->type = STT_OBJECT;
90
 
91
      if (info->shared
92
          && ! _bfd_elf_link_record_dynamic_symbol (info, h))
93
        return false;
94
 
95
      elf_hash_table (info)->hgot = h;
96
    }
97
 
98
  /* The first bit of the global offset table is the header.  */
99
  s->_raw_size += bed->got_header_size + bed->got_symbol_offset;
100
 
101
  return true;
102
}
103
 
104
/* Create dynamic sections when linking against a dynamic object.  */
105
 
106
boolean
107
_bfd_elf_create_dynamic_sections (abfd, info)
108
     bfd *abfd;
109
     struct bfd_link_info *info;
110
{
111
  flagword flags, pltflags;
112
  register asection *s;
113
  struct elf_backend_data *bed = get_elf_backend_data (abfd);
114
  int ptralign;
115
 
116
  switch (bed->s->arch_size)
117
    {
118
    case 32:
119
      ptralign = 2;
120
      break;
121
 
122
    case 64:
123
      ptralign = 3;
124
      break;
125
 
126
    default:
127
      bfd_set_error (bfd_error_bad_value);
128
      return false;
129
    }
130
 
131
  /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
132
     .rel[a].bss sections.  */
133
 
134
  flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
135
           | SEC_LINKER_CREATED);
136
 
137
  pltflags = flags;
138
  pltflags |= SEC_CODE;
139
  if (bed->plt_not_loaded)
140
    pltflags &= ~ (SEC_CODE | SEC_LOAD | SEC_HAS_CONTENTS);
141
  if (bed->plt_readonly)
142
    pltflags |= SEC_READONLY;
143
 
144
  s = bfd_make_section (abfd, ".plt");
145
  if (s == NULL
146
      || ! bfd_set_section_flags (abfd, s, pltflags)
147
      || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
148
    return false;
149
 
150
  if (bed->want_plt_sym)
151
    {
152
      /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
153
         .plt section.  */
154
      struct elf_link_hash_entry *h = NULL;
155
      if (! (_bfd_generic_link_add_one_symbol
156
             (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
157
              (bfd_vma) 0, (const char *) NULL, false,
158
              get_elf_backend_data (abfd)->collect,
159
              (struct bfd_link_hash_entry **) &h)))
160
        return false;
161
      h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
162
      h->type = STT_OBJECT;
163
 
164
      if (info->shared
165
          && ! _bfd_elf_link_record_dynamic_symbol (info, h))
166
        return false;
167
    }
168
 
169
  s = bfd_make_section (abfd,
170
                        bed->default_use_rela_p ? ".rela.plt" : ".rel.plt");
171
  if (s == NULL
172
      || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
173
      || ! bfd_set_section_alignment (abfd, s, ptralign))
174
    return false;
175
 
176
  if (! _bfd_elf_create_got_section (abfd, info))
177
    return false;
178
 
179
  if (bed->want_dynbss)
180
    {
181
      /* The .dynbss section is a place to put symbols which are defined
182
         by dynamic objects, are referenced by regular objects, and are
183
         not functions.  We must allocate space for them in the process
184
         image and use a R_*_COPY reloc to tell the dynamic linker to
185
         initialize them at run time.  The linker script puts the .dynbss
186
         section into the .bss section of the final image.  */
187
      s = bfd_make_section (abfd, ".dynbss");
188
      if (s == NULL
189
          || ! bfd_set_section_flags (abfd, s, SEC_ALLOC))
190
        return false;
191
 
192
      /* The .rel[a].bss section holds copy relocs.  This section is not
193
     normally needed.  We need to create it here, though, so that the
194
     linker will map it to an output section.  We can't just create it
195
     only if we need it, because we will not know whether we need it
196
     until we have seen all the input files, and the first time the
197
     main linker code calls BFD after examining all the input files
198
     (size_dynamic_sections) the input sections have already been
199
     mapped to the output sections.  If the section turns out not to
200
     be needed, we can discard it later.  We will never need this
201
     section when generating a shared object, since they do not use
202
     copy relocs.  */
203
      if (! info->shared)
204
        {
205
          s = bfd_make_section (abfd,
206
                                (bed->default_use_rela_p
207
                                 ? ".rela.bss" : ".rel.bss"));
208
          if (s == NULL
209
              || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
210
              || ! bfd_set_section_alignment (abfd, s, ptralign))
211
            return false;
212
        }
213
    }
214
 
215
  return true;
216
}
217
 
218
/* Record a new dynamic symbol.  We record the dynamic symbols as we
219
   read the input files, since we need to have a list of all of them
220
   before we can determine the final sizes of the output sections.
221
   Note that we may actually call this function even though we are not
222
   going to output any dynamic symbols; in some cases we know that a
223
   symbol should be in the dynamic symbol table, but only if there is
224
   one.  */
225
 
226
boolean
227
_bfd_elf_link_record_dynamic_symbol (info, h)
228
     struct bfd_link_info *info;
229
     struct elf_link_hash_entry *h;
230
{
231
  if (h->dynindx == -1)
232
    {
233
      struct elf_strtab_hash *dynstr;
234
      char *p, *alc;
235
      const char *name;
236
      boolean copy;
237
      bfd_size_type indx;
238
 
239
      /* XXX: The ABI draft says the linker must turn hidden and
240
         internal symbols into STB_LOCAL symbols when producing the
241
         DSO. However, if ld.so honors st_other in the dynamic table,
242
         this would not be necessary.  */
243
      switch (ELF_ST_VISIBILITY (h->other))
244
        {
245
        case STV_INTERNAL:
246
        case STV_HIDDEN:
247
          if (h->root.type != bfd_link_hash_undefined
248
              && h->root.type != bfd_link_hash_undefweak)
249
            {
250
              h->elf_link_hash_flags |= ELF_LINK_FORCED_LOCAL;
251
              return true;
252
            }
253
 
254
        default:
255
          break;
256
        }
257
 
258
      h->dynindx = elf_hash_table (info)->dynsymcount;
259
      ++elf_hash_table (info)->dynsymcount;
260
 
261
      dynstr = elf_hash_table (info)->dynstr;
262
      if (dynstr == NULL)
263
        {
264
          /* Create a strtab to hold the dynamic symbol names.  */
265
          elf_hash_table (info)->dynstr = dynstr = _bfd_elf_strtab_init ();
266
          if (dynstr == NULL)
267
            return false;
268
        }
269
 
270
      /* We don't put any version information in the dynamic string
271
         table.  */
272
      name = h->root.root.string;
273
      p = strchr (name, ELF_VER_CHR);
274
      if (p == NULL)
275
        {
276
          alc = NULL;
277
          copy = false;
278
        }
279
      else
280
        {
281
          size_t len = p - name + 1;
282
 
283
          alc = bfd_malloc ((bfd_size_type) len);
284
          if (alc == NULL)
285
            return false;
286
          memcpy (alc, name, len - 1);
287
          alc[len - 1] = '\0';
288
          name = alc;
289
          copy = true;
290
        }
291
 
292
      indx = _bfd_elf_strtab_add (dynstr, name, copy);
293
 
294
      if (alc != NULL)
295
        free (alc);
296
 
297
      if (indx == (bfd_size_type) -1)
298
        return false;
299
      h->dynstr_index = indx;
300
    }
301
 
302
  return true;
303
}
304
 
305
/* Record a new local dynamic symbol.  Returns 0 on failure, 1 on
306
   success, and 2 on a failure caused by attempting to record a symbol
307
   in a discarded section, eg. a discarded link-once section symbol.  */
308
 
309
int
310
elf_link_record_local_dynamic_symbol (info, input_bfd, input_indx)
311
     struct bfd_link_info *info;
312
     bfd *input_bfd;
313
     long input_indx;
314
{
315
  bfd_size_type amt;
316
  struct elf_link_local_dynamic_entry *entry;
317
  struct elf_link_hash_table *eht;
318
  struct elf_strtab_hash *dynstr;
319
  unsigned long dynstr_index;
320
  char *name;
321
  Elf_External_Sym_Shndx eshndx;
322
  char esym[sizeof (Elf64_External_Sym)];
323
 
324
  if (! is_elf_hash_table (info))
325
    return 0;
326
 
327
  /* See if the entry exists already.  */
328
  for (entry = elf_hash_table (info)->dynlocal; entry ; entry = entry->next)
329
    if (entry->input_bfd == input_bfd && entry->input_indx == input_indx)
330
      return 1;
331
 
332
  amt = sizeof (*entry);
333
  entry = (struct elf_link_local_dynamic_entry *) bfd_alloc (input_bfd, amt);
334
  if (entry == NULL)
335
    return 0;
336
 
337
  /* Go find the symbol, so that we can find it's name.  */
338
  if (!bfd_elf_get_elf_syms (input_bfd, &elf_tdata (input_bfd)->symtab_hdr,
339
                             (size_t) 1, (size_t) input_indx,
340
                             &entry->isym, esym, &eshndx))
341
    {
342
      bfd_release (input_bfd, entry);
343
      return 0;
344
    }
345
 
346
  if (entry->isym.st_shndx != SHN_UNDEF
347
      && (entry->isym.st_shndx < SHN_LORESERVE
348
          || entry->isym.st_shndx > SHN_HIRESERVE))
349
    {
350
      asection *s;
351
 
352
      s = bfd_section_from_elf_index (input_bfd, entry->isym.st_shndx);
353
      if (s == NULL || bfd_is_abs_section (s->output_section))
354
        {
355
          /* We can still bfd_release here as nothing has done another
356
             bfd_alloc.  We can't do this later in this function.  */
357
          bfd_release (input_bfd, entry);
358
          return 2;
359
        }
360
    }
361
 
362
  name = (bfd_elf_string_from_elf_section
363
          (input_bfd, elf_tdata (input_bfd)->symtab_hdr.sh_link,
364
           entry->isym.st_name));
365
 
366
  dynstr = elf_hash_table (info)->dynstr;
367
  if (dynstr == NULL)
368
    {
369
      /* Create a strtab to hold the dynamic symbol names.  */
370
      elf_hash_table (info)->dynstr = dynstr = _bfd_elf_strtab_init ();
371
      if (dynstr == NULL)
372
        return 0;
373
    }
374
 
375
  dynstr_index = _bfd_elf_strtab_add (dynstr, name, false);
376
  if (dynstr_index == (unsigned long) -1)
377
    return 0;
378
  entry->isym.st_name = dynstr_index;
379
 
380
  eht = elf_hash_table (info);
381
 
382
  entry->next = eht->dynlocal;
383
  eht->dynlocal = entry;
384
  entry->input_bfd = input_bfd;
385
  entry->input_indx = input_indx;
386
  eht->dynsymcount++;
387
 
388
  /* Whatever binding the symbol had before, it's now local.  */
389
  entry->isym.st_info
390
    = ELF_ST_INFO (STB_LOCAL, ELF_ST_TYPE (entry->isym.st_info));
391
 
392
  /* The dynindx will be set at the end of size_dynamic_sections.  */
393
 
394
  return 1;
395
}
396
 
397
/* Return the dynindex of a local dynamic symbol.  */
398
 
399
long
400
_bfd_elf_link_lookup_local_dynindx (info, input_bfd, input_indx)
401
     struct bfd_link_info *info;
402
     bfd *input_bfd;
403
     long input_indx;
404
{
405
  struct elf_link_local_dynamic_entry *e;
406
 
407
  for (e = elf_hash_table (info)->dynlocal; e ; e = e->next)
408
    if (e->input_bfd == input_bfd && e->input_indx == input_indx)
409
      return e->dynindx;
410
  return -1;
411
}
412
 
413
/* This function is used to renumber the dynamic symbols, if some of
414
   them are removed because they are marked as local.  This is called
415
   via elf_link_hash_traverse.  */
416
 
417
static boolean elf_link_renumber_hash_table_dynsyms
418
  PARAMS ((struct elf_link_hash_entry *, PTR));
419
 
420
static boolean
421
elf_link_renumber_hash_table_dynsyms (h, data)
422
     struct elf_link_hash_entry *h;
423
     PTR data;
424
{
425
  size_t *count = (size_t *) data;
426
 
427
  if (h->root.type == bfd_link_hash_warning)
428
    h = (struct elf_link_hash_entry *) h->root.u.i.link;
429
 
430
  if (h->dynindx != -1)
431
    h->dynindx = ++(*count);
432
 
433
  return true;
434
}
435
 
436
/* Assign dynsym indices.  In a shared library we generate a section
437
   symbol for each output section, which come first.  Next come all of
438
   the back-end allocated local dynamic syms, followed by the rest of
439
   the global symbols.  */
440
 
441
unsigned long
442
_bfd_elf_link_renumber_dynsyms (output_bfd, info)
443
     bfd *output_bfd;
444
     struct bfd_link_info *info;
445
{
446
  unsigned long dynsymcount = 0;
447
 
448
  if (info->shared)
449
    {
450
      asection *p;
451
      for (p = output_bfd->sections; p ; p = p->next)
452
        if ((p->flags & SEC_EXCLUDE) == 0)
453
          elf_section_data (p)->dynindx = ++dynsymcount;
454
    }
455
 
456
  if (elf_hash_table (info)->dynlocal)
457
    {
458
      struct elf_link_local_dynamic_entry *p;
459
      for (p = elf_hash_table (info)->dynlocal; p ; p = p->next)
460
        p->dynindx = ++dynsymcount;
461
    }
462
 
463
  elf_link_hash_traverse (elf_hash_table (info),
464
                          elf_link_renumber_hash_table_dynsyms,
465
                          &dynsymcount);
466
 
467
  /* There is an unused NULL entry at the head of the table which
468
     we must account for in our count.  Unless there weren't any
469
     symbols, which means we'll have no table at all.  */
470
  if (dynsymcount != 0)
471
    ++dynsymcount;
472
 
473
  return elf_hash_table (info)->dynsymcount = dynsymcount;
474
}
475
 
476
/* Create a special linker section, or return a pointer to a linker
477
   section already created */
478
 
479
elf_linker_section_t *
480
_bfd_elf_create_linker_section (abfd, info, which, defaults)
481
     bfd *abfd;
482
     struct bfd_link_info *info;
483
     enum elf_linker_section_enum which;
484
     elf_linker_section_t *defaults;
485
{
486
  bfd *dynobj = elf_hash_table (info)->dynobj;
487
  elf_linker_section_t *lsect;
488
 
489
  /* Record the first bfd section that needs the special section */
490
  if (!dynobj)
491
    dynobj = elf_hash_table (info)->dynobj = abfd;
492
 
493
  /* If this is the first time, create the section */
494
  lsect = elf_linker_section (dynobj, which);
495
  if (!lsect)
496
    {
497
      asection *s;
498
      bfd_size_type amt = sizeof (elf_linker_section_t);
499
 
500
      lsect = (elf_linker_section_t *) bfd_alloc (dynobj, amt);
501
 
502
      *lsect = *defaults;
503
      elf_linker_section (dynobj, which) = lsect;
504
      lsect->which = which;
505
      lsect->hole_written_p = false;
506
 
507
      /* See if the sections already exist */
508
      lsect->section = s = bfd_get_section_by_name (dynobj, lsect->name);
509
      if (!s || (s->flags & defaults->flags) != defaults->flags)
510
        {
511
          lsect->section = s = bfd_make_section_anyway (dynobj, lsect->name);
512
 
513
          if (s == NULL)
514
            return (elf_linker_section_t *)0;
515
 
516
          bfd_set_section_flags (dynobj, s, defaults->flags);
517
          bfd_set_section_alignment (dynobj, s, lsect->alignment);
518
        }
519
      else if (bfd_get_section_alignment (dynobj, s) < lsect->alignment)
520
        bfd_set_section_alignment (dynobj, s, lsect->alignment);
521
 
522
      s->_raw_size = align_power (s->_raw_size, lsect->alignment);
523
 
524
      /* Is there a hole we have to provide?  If so check whether the segment is
525
         too big already */
526
      if (lsect->hole_size)
527
        {
528
          lsect->hole_offset = s->_raw_size;
529
          s->_raw_size += lsect->hole_size;
530
          if (lsect->hole_offset > lsect->max_hole_offset)
531
            {
532
              (*_bfd_error_handler) (_("%s: Section %s is too large to add hole of %ld bytes"),
533
                                     bfd_get_filename (abfd),
534
                                     lsect->name,
535
                                     (long) lsect->hole_size);
536
 
537
              bfd_set_error (bfd_error_bad_value);
538
              return (elf_linker_section_t *)0;
539
            }
540
        }
541
 
542
#ifdef DEBUG
543
      fprintf (stderr, "Creating section %s, current size = %ld\n",
544
               lsect->name, (long)s->_raw_size);
545
#endif
546
 
547
      if (lsect->sym_name)
548
        {
549
          struct elf_link_hash_entry *h = NULL;
550
#ifdef DEBUG
551
          fprintf (stderr, "Adding %s to section %s\n",
552
                   lsect->sym_name,
553
                   lsect->name);
554
#endif
555
          h = (struct elf_link_hash_entry *)
556
            bfd_link_hash_lookup (info->hash, lsect->sym_name, false, false, false);
557
 
558
          if ((h == NULL || h->root.type == bfd_link_hash_undefined)
559
              && !(_bfd_generic_link_add_one_symbol (info,
560
                                                     abfd,
561
                                                     lsect->sym_name,
562
                                                     BSF_GLOBAL,
563
                                                     s,
564
                                                     ((lsect->hole_size)
565
                                                      ? s->_raw_size - lsect->hole_size + lsect->sym_offset
566
                                                      : lsect->sym_offset),
567
                                                     (const char *) NULL,
568
                                                     false,
569
                                                     get_elf_backend_data (abfd)->collect,
570
                                                     (struct bfd_link_hash_entry **) &h)))
571
            return (elf_linker_section_t *)0;
572
 
573
          if ((defaults->which != LINKER_SECTION_SDATA)
574
              && (defaults->which != LINKER_SECTION_SDATA2))
575
            h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_DYNAMIC;
576
 
577
          h->type = STT_OBJECT;
578
          lsect->sym_hash = h;
579
 
580
          if (info->shared
581
              && ! _bfd_elf_link_record_dynamic_symbol (info, h))
582
            return (elf_linker_section_t *)0;
583
        }
584
    }
585
 
586
#if 0
587
  /* This does not make sense.  The sections which may exist in the
588
     object file have nothing to do with the sections we want to
589
     create.  */
590
 
591
  /* Find the related sections if they have been created */
592
  if (lsect->bss_name && !lsect->bss_section)
593
    lsect->bss_section = bfd_get_section_by_name (dynobj, lsect->bss_name);
594
 
595
  if (lsect->rel_name && !lsect->rel_section)
596
    lsect->rel_section = bfd_get_section_by_name (dynobj, lsect->rel_name);
597
#endif
598
 
599
  return lsect;
600
}
601
 
602
/* Find a linker generated pointer with a given addend and type.  */
603
 
604
elf_linker_section_pointers_t *
605
_bfd_elf_find_pointer_linker_section (linker_pointers, addend, which)
606
     elf_linker_section_pointers_t *linker_pointers;
607
     bfd_vma addend;
608
     elf_linker_section_enum_t which;
609
{
610
  for ( ; linker_pointers != NULL; linker_pointers = linker_pointers->next)
611
    {
612
      if (which == linker_pointers->which && addend == linker_pointers->addend)
613
        return linker_pointers;
614
    }
615
 
616
  return (elf_linker_section_pointers_t *)0;
617
}
618
 
619
/* Make the .rela section corresponding to the generated linker section.  */
620
 
621
boolean
622
_bfd_elf_make_linker_section_rela (dynobj, lsect, alignment)
623
     bfd *dynobj;
624
     elf_linker_section_t *lsect;
625
     int alignment;
626
{
627
  if (lsect->rel_section)
628
    return true;
629
 
630
  lsect->rel_section = bfd_get_section_by_name (dynobj, lsect->rel_name);
631
  if (lsect->rel_section == NULL)
632
    {
633
      lsect->rel_section = bfd_make_section (dynobj, lsect->rel_name);
634
      if (lsect->rel_section == NULL
635
          || ! bfd_set_section_flags (dynobj,
636
                                      lsect->rel_section,
637
                                      (SEC_ALLOC
638
                                       | SEC_LOAD
639
                                       | SEC_HAS_CONTENTS
640
                                       | SEC_IN_MEMORY
641
                                       | SEC_LINKER_CREATED
642
                                       | SEC_READONLY))
643
          || ! bfd_set_section_alignment (dynobj, lsect->rel_section, alignment))
644
        return false;
645
    }
646
 
647
  return true;
648
}

powered by: WebSVN 2.1.0

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