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

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [bfd/] [format.c] - Diff between revs 14 and 148

Only display areas with differences | Details | Blame | View Log

Rev 14 Rev 148
/* Generic BFD support for file formats.
/* Generic BFD support for file formats.
   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1999, 2000, 2001, 2002,
   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1999, 2000, 2001, 2002,
   2003, 2005, 2007, 2008, 2009 Free Software Foundation, Inc.
   2003, 2005, 2007, 2008, 2009 Free Software Foundation, Inc.
   Written by Cygnus Support.
   Written by Cygnus Support.
 
 
   This file is part of BFD, the Binary File Descriptor library.
   This file is part of BFD, the Binary File Descriptor library.
 
 
   This program is free software; you can redistribute it and/or modify
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.
   (at your option) any later version.
 
 
   This program is distributed in the hope that it will be useful,
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
   GNU General Public License for more details.
 
 
   You should have received a copy of the GNU General Public License
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
   MA 02110-1301, USA.  */
   MA 02110-1301, USA.  */
 
 
 
 
/*
/*
SECTION
SECTION
        File formats
        File formats
 
 
        A format is a BFD concept of high level file contents type. The
        A format is a BFD concept of high level file contents type. The
        formats supported by BFD are:
        formats supported by BFD are:
 
 
        o <<bfd_object>>
        o <<bfd_object>>
 
 
        The BFD may contain data, symbols, relocations and debug info.
        The BFD may contain data, symbols, relocations and debug info.
 
 
        o <<bfd_archive>>
        o <<bfd_archive>>
 
 
        The BFD contains other BFDs and an optional index.
        The BFD contains other BFDs and an optional index.
 
 
        o <<bfd_core>>
        o <<bfd_core>>
 
 
        The BFD contains the result of an executable core dump.
        The BFD contains the result of an executable core dump.
 
 
SUBSECTION
SUBSECTION
        File format functions
        File format functions
*/
*/
 
 
#include "sysdep.h"
#include "sysdep.h"
#include "bfd.h"
#include "bfd.h"
#include "libbfd.h"
#include "libbfd.h"
 
 
/* IMPORT from targets.c.  */
/* IMPORT from targets.c.  */
extern const size_t _bfd_target_vector_entries;
extern const size_t _bfd_target_vector_entries;
 
 
/*
/*
FUNCTION
FUNCTION
        bfd_check_format
        bfd_check_format
 
 
SYNOPSIS
SYNOPSIS
        bfd_boolean bfd_check_format (bfd *abfd, bfd_format format);
        bfd_boolean bfd_check_format (bfd *abfd, bfd_format format);
 
 
DESCRIPTION
DESCRIPTION
        Verify if the file attached to the BFD @var{abfd} is compatible
        Verify if the file attached to the BFD @var{abfd} is compatible
        with the format @var{format} (i.e., one of <<bfd_object>>,
        with the format @var{format} (i.e., one of <<bfd_object>>,
        <<bfd_archive>> or <<bfd_core>>).
        <<bfd_archive>> or <<bfd_core>>).
 
 
        If the BFD has been set to a specific target before the
        If the BFD has been set to a specific target before the
        call, only the named target and format combination is
        call, only the named target and format combination is
        checked. If the target has not been set, or has been set to
        checked. If the target has not been set, or has been set to
        <<default>>, then all the known target backends is
        <<default>>, then all the known target backends is
        interrogated to determine a match.  If the default target
        interrogated to determine a match.  If the default target
        matches, it is used.  If not, exactly one target must recognize
        matches, it is used.  If not, exactly one target must recognize
        the file, or an error results.
        the file, or an error results.
 
 
        The function returns <<TRUE>> on success, otherwise <<FALSE>>
        The function returns <<TRUE>> on success, otherwise <<FALSE>>
        with one of the following error codes:
        with one of the following error codes:
 
 
        o <<bfd_error_invalid_operation>> -
        o <<bfd_error_invalid_operation>> -
        if <<format>> is not one of <<bfd_object>>, <<bfd_archive>> or
        if <<format>> is not one of <<bfd_object>>, <<bfd_archive>> or
        <<bfd_core>>.
        <<bfd_core>>.
 
 
        o <<bfd_error_system_call>> -
        o <<bfd_error_system_call>> -
        if an error occured during a read - even some file mismatches
        if an error occured during a read - even some file mismatches
        can cause bfd_error_system_calls.
        can cause bfd_error_system_calls.
 
 
        o <<file_not_recognised>> -
        o <<file_not_recognised>> -
        none of the backends recognised the file format.
        none of the backends recognised the file format.
 
 
        o <<bfd_error_file_ambiguously_recognized>> -
        o <<bfd_error_file_ambiguously_recognized>> -
        more than one backend recognised the file format.
        more than one backend recognised the file format.
*/
*/
 
 
bfd_boolean
bfd_boolean
bfd_check_format (bfd *abfd, bfd_format format)
bfd_check_format (bfd *abfd, bfd_format format)
{
{
  return bfd_check_format_matches (abfd, format, NULL);
  return bfd_check_format_matches (abfd, format, NULL);
}
}
 
 
/*
/*
FUNCTION
FUNCTION
        bfd_check_format_matches
        bfd_check_format_matches
 
 
SYNOPSIS
SYNOPSIS
        bfd_boolean bfd_check_format_matches
        bfd_boolean bfd_check_format_matches
          (bfd *abfd, bfd_format format, char ***matching);
          (bfd *abfd, bfd_format format, char ***matching);
 
 
DESCRIPTION
DESCRIPTION
        Like <<bfd_check_format>>, except when it returns FALSE with
        Like <<bfd_check_format>>, except when it returns FALSE with
        <<bfd_errno>> set to <<bfd_error_file_ambiguously_recognized>>.  In that
        <<bfd_errno>> set to <<bfd_error_file_ambiguously_recognized>>.  In that
        case, if @var{matching} is not NULL, it will be filled in with
        case, if @var{matching} is not NULL, it will be filled in with
        a NULL-terminated list of the names of the formats that matched,
        a NULL-terminated list of the names of the formats that matched,
        allocated with <<malloc>>.
        allocated with <<malloc>>.
        Then the user may choose a format and try again.
        Then the user may choose a format and try again.
 
 
        When done with the list that @var{matching} points to, the caller
        When done with the list that @var{matching} points to, the caller
        should free it.
        should free it.
*/
*/
 
 
bfd_boolean
bfd_boolean
bfd_check_format_matches (bfd *abfd, bfd_format format, char ***matching)
bfd_check_format_matches (bfd *abfd, bfd_format format, char ***matching)
{
{
  extern const bfd_target binary_vec;
  extern const bfd_target binary_vec;
  const bfd_target * const *target;
  const bfd_target * const *target;
  const bfd_target **matching_vector = NULL;
  const bfd_target **matching_vector = NULL;
  const bfd_target *save_targ, *right_targ, *ar_right_targ;
  const bfd_target *save_targ, *right_targ, *ar_right_targ, *match_targ;
  int match_count;
  int match_count, best_count, best_match;
  int ar_match_index;
  int ar_match_index;
 
 
  if (matching != NULL)
  if (matching != NULL)
    *matching = NULL;
    *matching = NULL;
 
 
  if (!bfd_read_p (abfd)
  if (!bfd_read_p (abfd)
      || (unsigned int) abfd->format >= (unsigned int) bfd_type_end)
      || (unsigned int) abfd->format >= (unsigned int) bfd_type_end)
    {
    {
      bfd_set_error (bfd_error_invalid_operation);
      bfd_set_error (bfd_error_invalid_operation);
      return FALSE;
      return FALSE;
    }
    }
 
 
  if (abfd->format != bfd_unknown)
  if (abfd->format != bfd_unknown)
    return abfd->format == format;
    return abfd->format == format;
 
 
  /* Since the target type was defaulted, check them
  /* Since the target type was defaulted, check them
     all in the hope that one will be uniquely recognized.  */
     all in the hope that one will be uniquely recognized.  */
  save_targ = abfd->xvec;
  save_targ = abfd->xvec;
  match_count = 0;
  match_count = 0;
  ar_match_index = _bfd_target_vector_entries;
  ar_match_index = _bfd_target_vector_entries;
 
 
  if (matching != NULL || *bfd_associated_vector != NULL)
  if (matching != NULL || *bfd_associated_vector != NULL)
    {
    {
      bfd_size_type amt;
      bfd_size_type amt;
 
 
      amt = sizeof (*matching_vector) * 2 * _bfd_target_vector_entries;
      amt = sizeof (*matching_vector) * 2 * _bfd_target_vector_entries;
      matching_vector = (const bfd_target **) bfd_malloc (amt);
      matching_vector = (const bfd_target **) bfd_malloc (amt);
      if (!matching_vector)
      if (!matching_vector)
        return FALSE;
        return FALSE;
    }
    }
 
 
  right_targ = 0;
  right_targ = 0;
  ar_right_targ = 0;
  ar_right_targ = 0;
 
  match_targ = 0;
 
  best_match = 256;
 
  best_count = 0;
 
 
  /* Presume the answer is yes.  */
  /* Presume the answer is yes.  */
  abfd->format = format;
  abfd->format = format;
 
 
  /* If the target type was explicitly specified, just check that target.  */
  /* If the target type was explicitly specified, just check that target.  */
  if (!abfd->target_defaulted)
  if (!abfd->target_defaulted)
    {
    {
      if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)   /* rewind! */
      if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)   /* rewind! */
        goto err_ret;
        goto err_ret;
 
 
      right_targ = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd));
      right_targ = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd));
 
 
      if (right_targ)
      if (right_targ)
        goto ok_ret;
        goto ok_ret;
 
 
      /* For a long time the code has dropped through to check all
      /* For a long time the code has dropped through to check all
         targets if the specified target was wrong.  I don't know why,
         targets if the specified target was wrong.  I don't know why,
         and I'm reluctant to change it.  However, in the case of an
         and I'm reluctant to change it.  However, in the case of an
         archive, it can cause problems.  If the specified target does
         archive, it can cause problems.  If the specified target does
         not permit archives (e.g., the binary target), then we should
         not permit archives (e.g., the binary target), then we should
         not allow some other target to recognize it as an archive, but
         not allow some other target to recognize it as an archive, but
         should instead allow the specified target to recognize it as an
         should instead allow the specified target to recognize it as an
         object.  When I first made this change, it broke the PE target,
         object.  When I first made this change, it broke the PE target,
         because the specified pei-i386 target did not recognize the
         because the specified pei-i386 target did not recognize the
         actual pe-i386 archive.  Since there may be other problems of
         actual pe-i386 archive.  Since there may be other problems of
         this sort, I changed this test to check only for the binary
         this sort, I changed this test to check only for the binary
         target.  */
         target.  */
      if (format == bfd_archive && save_targ == &binary_vec)
      if (format == bfd_archive && save_targ == &binary_vec)
        goto err_unrecog;
        goto err_unrecog;
    }
    }
 
 
  for (target = bfd_target_vector; *target != NULL; target++)
  for (target = bfd_target_vector; *target != NULL; target++)
    {
    {
      const bfd_target *temp;
      const bfd_target *temp;
      bfd_error_type err;
      bfd_error_type err;
 
 
      /* Don't check the default target twice.  */
      /* Don't check the default target twice.  */
      if (*target == &binary_vec
      if (*target == &binary_vec
          || (!abfd->target_defaulted && *target == save_targ))
          || (!abfd->target_defaulted && *target == save_targ)
 
          || (*target)->match_priority > best_match)
        continue;
        continue;
 
 
      abfd->xvec = *target;     /* Change BFD's target temporarily.  */
      abfd->xvec = *target;     /* Change BFD's target temporarily.  */
 
 
      if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
      if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
        goto err_ret;
        goto err_ret;
 
 
      /* If _bfd_check_format neglects to set bfd_error, assume
      /* If _bfd_check_format neglects to set bfd_error, assume
         bfd_error_wrong_format.  We didn't used to even pay any
         bfd_error_wrong_format.  We didn't used to even pay any
         attention to bfd_error, so I suspect that some
         attention to bfd_error, so I suspect that some
         _bfd_check_format might have this problem.  */
         _bfd_check_format might have this problem.  */
      bfd_set_error (bfd_error_wrong_format);
      bfd_set_error (bfd_error_wrong_format);
 
 
      temp = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd));
      temp = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd));
 
      if (temp)
 
        match_targ = temp;
 
 
      if (temp && (abfd->format != bfd_archive || bfd_has_map (abfd)))
      if (temp && (abfd->format != bfd_archive || bfd_has_map (abfd)))
        {
        {
          /* This format checks out as ok!  */
          /* This format checks out as ok!  */
          right_targ = temp;
          right_targ = temp;
 
 
          /* If this is the default target, accept it, even if other
          /* If this is the default target, accept it, even if other
             targets might match.  People who want those other targets
             targets might match.  People who want those other targets
             have to set the GNUTARGET variable.  */
             have to set the GNUTARGET variable.  */
          if (temp == bfd_default_vector[0])
          if (temp == bfd_default_vector[0])
            {
            goto ok_ret;
              match_count = 1;
 
              break;
 
            }
 
 
 
          if (matching_vector)
          if (matching_vector)
            matching_vector[match_count] = temp;
            matching_vector[match_count] = temp;
          match_count++;
          match_count++;
 
 
 
          if (temp->match_priority < best_match)
 
            {
 
              best_match = temp->match_priority;
 
              best_count = 0;
 
            }
 
          best_count++;
        }
        }
      else if (temp
      else if (temp
               || (err = bfd_get_error ()) == bfd_error_wrong_object_format
               || (err = bfd_get_error ()) == bfd_error_wrong_object_format
               || err == bfd_error_file_ambiguously_recognized)
               || err == bfd_error_file_ambiguously_recognized)
        {
        {
          /* An archive with no armap or objects of the wrong type,
          /* An archive with no armap or objects of the wrong type,
             or an ambiguous match.  We want this target to match
             or an ambiguous match.  We want this target to match
             if we get no better matches.  */
             if we get no better matches.  */
          if (ar_right_targ != bfd_default_vector[0])
          if (ar_right_targ != bfd_default_vector[0])
            ar_right_targ = *target;
            ar_right_targ = *target;
          if (matching_vector)
          if (matching_vector)
            matching_vector[ar_match_index] = *target;
            matching_vector[ar_match_index] = *target;
          ar_match_index++;
          ar_match_index++;
        }
        }
      else if (err != bfd_error_wrong_format)
      else if (err != bfd_error_wrong_format)
        goto err_ret;
        goto err_ret;
    }
    }
 
 
 
  if (best_count == 1)
 
    match_count = 1;
 
 
  if (match_count == 0)
  if (match_count == 0)
    {
    {
      /* Try partial matches.  */
      /* Try partial matches.  */
      right_targ = ar_right_targ;
      right_targ = ar_right_targ;
 
 
      if (right_targ == bfd_default_vector[0])
      if (right_targ == bfd_default_vector[0])
        {
        {
          match_count = 1;
          match_count = 1;
        }
        }
      else
      else
        {
        {
          match_count = ar_match_index - _bfd_target_vector_entries;
          match_count = ar_match_index - _bfd_target_vector_entries;
 
 
          if (matching_vector && match_count > 1)
          if (matching_vector && match_count > 1)
            memcpy (matching_vector,
            memcpy (matching_vector,
                    matching_vector + _bfd_target_vector_entries,
                    matching_vector + _bfd_target_vector_entries,
                    sizeof (*matching_vector) * match_count);
                    sizeof (*matching_vector) * match_count);
        }
        }
    }
    }
 
 
  if (match_count > 1)
  if (match_count > 1)
    {
    {
      const bfd_target * const *assoc = bfd_associated_vector;
      const bfd_target * const *assoc = bfd_associated_vector;
 
 
      while ((right_targ = *assoc++) != NULL)
      while ((right_targ = *assoc++) != NULL)
        {
        {
          int i = match_count;
          int i = match_count;
 
 
          while (--i >= 0)
          while (--i >= 0)
            if (matching_vector[i] == right_targ)
            if (matching_vector[i] == right_targ)
              break;
              break;
 
 
          if (i >= 0)
          if (i >= 0)
            {
            {
              match_count = 1;
              match_count = 1;
              break;
              break;
            }
            }
        }
        }
    }
    }
 
 
  if (match_count == 1)
  if (match_count == 1)
    {
    {
    ok_ret:
      abfd->xvec = right_targ;
      abfd->xvec = right_targ;          /* Change BFD's target permanently.  */
      /* If we come out of the loop knowing that the last target that
 
         matched is the one we want, then ABFD should still be in a usable
 
         state (except possibly for XVEC).  */
 
      if (match_targ != right_targ)
 
        {
 
          if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
 
            goto err_ret;
 
          match_targ = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd));
 
        }
 
 
 
    ok_ret:
      /* If the file was opened for update, then `output_has_begun'
      /* If the file was opened for update, then `output_has_begun'
         some time ago when the file was created.  Do not recompute
         some time ago when the file was created.  Do not recompute
         sections sizes or alignments in _bfd_set_section_contents.
         sections sizes or alignments in _bfd_set_section_contents.
         We can not set this flag until after checking the format,
         We can not set this flag until after checking the format,
         because it will interfere with creation of BFD sections.  */
         because it will interfere with creation of BFD sections.  */
      if (abfd->direction == both_direction)
      if (abfd->direction == both_direction)
        abfd->output_has_begun = TRUE;
        abfd->output_has_begun = TRUE;
 
 
      if (matching_vector)
      if (matching_vector)
        free (matching_vector);
        free (matching_vector);
      return TRUE;                      /* File position has moved, BTW.  */
      return TRUE;                      /* File position has moved, BTW.  */
    }
    }
 
 
  if (match_count == 0)
  if (match_count == 0)
    {
    {
    err_unrecog:
    err_unrecog:
      bfd_set_error (bfd_error_file_not_recognized);
      bfd_set_error (bfd_error_file_not_recognized);
    err_ret:
    err_ret:
      abfd->xvec = save_targ;
      abfd->xvec = save_targ;
      abfd->format = bfd_unknown;
      abfd->format = bfd_unknown;
      if (matching_vector)
      if (matching_vector)
        free (matching_vector);
        free (matching_vector);
      return FALSE;
      return FALSE;
    }
    }
 
 
  abfd->xvec = save_targ;               /* Restore original target type.  */
  abfd->xvec = save_targ;               /* Restore original target type.  */
  abfd->format = bfd_unknown;           /* Restore original format.  */
  abfd->format = bfd_unknown;           /* Restore original format.  */
  bfd_set_error (bfd_error_file_ambiguously_recognized);
  bfd_set_error (bfd_error_file_ambiguously_recognized);
 
 
  if (matching)
  if (matching)
    {
    {
      *matching = (char **) matching_vector;
      *matching = (char **) matching_vector;
      matching_vector[match_count] = NULL;
      matching_vector[match_count] = NULL;
      /* Return target names.  This is a little nasty.  Maybe we
      /* Return target names.  This is a little nasty.  Maybe we
         should do another bfd_malloc?  */
         should do another bfd_malloc?  */
      while (--match_count >= 0)
      while (--match_count >= 0)
        {
        {
          const char *name = matching_vector[match_count]->name;
          const char *name = matching_vector[match_count]->name;
          *(const char **) &matching_vector[match_count] = name;
          *(const char **) &matching_vector[match_count] = name;
        }
        }
    }
    }
  return FALSE;
  return FALSE;
}
}
 
 
/*
/*
FUNCTION
FUNCTION
        bfd_set_format
        bfd_set_format
 
 
SYNOPSIS
SYNOPSIS
        bfd_boolean bfd_set_format (bfd *abfd, bfd_format format);
        bfd_boolean bfd_set_format (bfd *abfd, bfd_format format);
 
 
DESCRIPTION
DESCRIPTION
        This function sets the file format of the BFD @var{abfd} to the
        This function sets the file format of the BFD @var{abfd} to the
        format @var{format}. If the target set in the BFD does not
        format @var{format}. If the target set in the BFD does not
        support the format requested, the format is invalid, or the BFD
        support the format requested, the format is invalid, or the BFD
        is not open for writing, then an error occurs.
        is not open for writing, then an error occurs.
*/
*/
 
 
bfd_boolean
bfd_boolean
bfd_set_format (bfd *abfd, bfd_format format)
bfd_set_format (bfd *abfd, bfd_format format)
{
{
  if (bfd_read_p (abfd)
  if (bfd_read_p (abfd)
      || (unsigned int) abfd->format >= (unsigned int) bfd_type_end)
      || (unsigned int) abfd->format >= (unsigned int) bfd_type_end)
    {
    {
      bfd_set_error (bfd_error_invalid_operation);
      bfd_set_error (bfd_error_invalid_operation);
      return FALSE;
      return FALSE;
    }
    }
 
 
  if (abfd->format != bfd_unknown)
  if (abfd->format != bfd_unknown)
    return abfd->format == format;
    return abfd->format == format;
 
 
  /* Presume the answer is yes.  */
  /* Presume the answer is yes.  */
  abfd->format = format;
  abfd->format = format;
 
 
  if (!BFD_SEND_FMT (abfd, _bfd_set_format, (abfd)))
  if (!BFD_SEND_FMT (abfd, _bfd_set_format, (abfd)))
    {
    {
      abfd->format = bfd_unknown;
      abfd->format = bfd_unknown;
      return FALSE;
      return FALSE;
    }
    }
 
 
  return TRUE;
  return TRUE;
}
}
 
 
/*
/*
FUNCTION
FUNCTION
        bfd_format_string
        bfd_format_string
 
 
SYNOPSIS
SYNOPSIS
        const char *bfd_format_string (bfd_format format);
        const char *bfd_format_string (bfd_format format);
 
 
DESCRIPTION
DESCRIPTION
        Return a pointer to a const string
        Return a pointer to a const string
        <<invalid>>, <<object>>, <<archive>>, <<core>>, or <<unknown>>,
        <<invalid>>, <<object>>, <<archive>>, <<core>>, or <<unknown>>,
        depending upon the value of @var{format}.
        depending upon the value of @var{format}.
*/
*/
 
 
const char *
const char *
bfd_format_string (bfd_format format)
bfd_format_string (bfd_format format)
{
{
  if (((int) format < (int) bfd_unknown)
  if (((int) format < (int) bfd_unknown)
      || ((int) format >= (int) bfd_type_end))
      || ((int) format >= (int) bfd_type_end))
    return "invalid";
    return "invalid";
 
 
  switch (format)
  switch (format)
    {
    {
    case bfd_object:
    case bfd_object:
      return "object";          /* Linker/assembler/compiler output.  */
      return "object";          /* Linker/assembler/compiler output.  */
    case bfd_archive:
    case bfd_archive:
      return "archive";         /* Object archive file.  */
      return "archive";         /* Object archive file.  */
    case bfd_core:
    case bfd_core:
      return "core";            /* Core dump.  */
      return "core";            /* Core dump.  */
    default:
    default:
      return "unknown";
      return "unknown";
    }
    }
}
}
 
 

powered by: WebSVN 2.1.0

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