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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [bfd/] [coffcode.h] - Diff between revs 157 and 225

Go to most recent revision | Show entire file | Details | Blame | View Log

Rev 157 Rev 225
Line 1... Line 1...
/* Support for the generic parts of most COFF variants, for BFD.
/* Support for the generic parts of most COFF variants, for BFD.
   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
   2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
   2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
   Free Software Foundation, Inc.
   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.
 
 
Line 107... Line 107...
        manipulate the i960 relocs.  This code is not in
        manipulate the i960 relocs.  This code is not in
        @file{coffcode.h} because it would not be used by any other
        @file{coffcode.h} because it would not be used by any other
        target.
        target.
 
 
SUBSUBSECTION
SUBSUBSECTION
 
        Coff long section names
 
 
 
        In the standard Coff object format, section names are limited to
 
        the eight bytes available in the @code{s_name} field of the
 
        @code{SCNHDR} section header structure.  The format requires the
 
        field to be NUL-padded, but not necessarily NUL-terminated, so
 
        the longest section names permitted are a full eight characters.
 
 
 
        The Microsoft PE variants of the Coff object file format add
 
        an extension to support the use of long section names.  This
 
        extension is defined in section 4 of the Microsoft PE/COFF
 
        specification (rev 8.1).  If a section name is too long to fit
 
        into the section header's @code{s_name} field, it is instead
 
        placed into the string table, and the @code{s_name} field is
 
        filled with a slash ("/") followed by the ASCII decimal
 
        representation of the offset of the full name relative to the
 
        string table base.
 
 
 
        Note that this implies that the extension can only be used in object
 
        files, as executables do not contain a string table.  The standard
 
        specifies that long section names from objects emitted into executable
 
        images are to be truncated.
 
 
 
        However, as a GNU extension, BFD can generate executable images
 
        that contain a string table and long section names.  This
 
        would appear to be technically valid, as the standard only says
 
        that Coff debugging information is deprecated, not forbidden,
 
        and in practice it works, although some tools that parse PE files
 
        expecting the MS standard format may become confused; @file{PEview} is
 
        one known example.
 
 
 
        The functionality is supported in BFD by code implemented under
 
        the control of the macro @code{COFF_LONG_SECTION_NAMES}.  If not
 
        defined, the format does not support long section names in any way.
 
        If defined, it is used to initialise a flag,
 
        @code{_bfd_coff_long_section_names}, and a hook function pointer,
 
        @code{_bfd_coff_set_long_section_names}, in the Coff backend data
 
        structure.  The flag controls the generation of long section names
 
        in output BFDs at runtime; if it is false, as it will be by default
 
        when generating an executable image, long section names are truncated;
 
        if true, the long section names extension is employed.  The hook
 
        points to a function that allows the value of the flag to be altered
 
        at runtime, on formats that support long section names at all; on
 
        other formats it points to a stub that returns an error indication.
 
 
 
        With input BFDs, the flag is set according to whether any long section
 
        names are detected while reading the section headers.  For a completely
 
        new BFD, the flag is set to the default for the target format.  This
 
        information can be used by a client of the BFD library when deciding
 
        what output format to generate, and means that a BFD that is opened
 
        for read and subsequently converted to a writeable BFD and modified
 
        in-place will retain whatever format it had on input.
 
 
 
        If @code{COFF_LONG_SECTION_NAMES} is simply defined (blank), or is
 
        defined to the value "1", then long section names are enabled by
 
        default; if it is defined to the value zero, they are disabled by
 
        default (but still accepted in input BFDs).  The header @file{coffcode.h}
 
        defines a macro, @code{COFF_DEFAULT_LONG_SECTION_NAMES}, which is
 
        used in the backends to initialise the backend data structure fields
 
        appropriately; see the comments for further detail.
 
 
 
SUBSUBSECTION
        Bit twiddling
        Bit twiddling
 
 
        Each flavour of coff supported in BFD has its own header file
        Each flavour of coff supported in BFD has its own header file
        describing the external layout of the structures. There is also
        describing the external layout of the structures. There is also
        an internal description of the coff layout, in
        an internal description of the coff layout, in
Line 307... Line 369...
 
 
#define STRING_SIZE_SIZE 4
#define STRING_SIZE_SIZE 4
 
 
#define DOT_DEBUG       ".debug"
#define DOT_DEBUG       ".debug"
#define GNU_LINKONCE_WI ".gnu.linkonce.wi."
#define GNU_LINKONCE_WI ".gnu.linkonce.wi."
 
#define DOT_RELOC       ".reloc"
 
 
 
#if defined (COFF_LONG_SECTION_NAMES)
 
/* Needed to expand the inputs to BLANKOR1TOODD.  */
 
#define COFFLONGSECTIONCATHELPER(x,y)    x ## y
 
/* If the input macro Y is blank or '1', return an odd number; if it is
 
   '0', return an even number.  Result undefined in all other cases.  */
 
#define BLANKOR1TOODD(y)                 COFFLONGSECTIONCATHELPER(1,y)
 
/* Defined to numerical 0 or 1 according to whether generation of long
 
   section names is disabled or enabled by default.  */
 
#define COFF_ENABLE_LONG_SECTION_NAMES   (BLANKOR1TOODD(COFF_LONG_SECTION_NAMES) & 1)
 
/* Where long section names are supported, we allow them to be enabled
 
   and disabled at runtime, so select an appropriate hook function for
 
   _bfd_coff_set_long_section_names.  */
 
#define COFF_LONG_SECTION_NAMES_SETTER   bfd_coff_set_long_section_names_allowed
 
#else /* !defined (COFF_LONG_SECTION_NAMES) */
 
/* If long section names are not supported, this stub disallows any
 
   attempt to enable them at run-time.  */
 
#define COFF_LONG_SECTION_NAMES_SETTER   bfd_coff_set_long_section_names_disallowed
 
#endif /* defined (COFF_LONG_SECTION_NAMES) */
 
 
 
/* Define a macro that can be used to initialise both the fields relating
 
   to long section names in the backend data struct simultaneously.  */
 
#if COFF_ENABLE_LONG_SECTION_NAMES
 
#define COFF_DEFAULT_LONG_SECTION_NAMES  (TRUE), COFF_LONG_SECTION_NAMES_SETTER
 
#else /* !COFF_ENABLE_LONG_SECTION_NAMES */
 
#define COFF_DEFAULT_LONG_SECTION_NAMES  (FALSE), COFF_LONG_SECTION_NAMES_SETTER
 
#endif /* COFF_ENABLE_LONG_SECTION_NAMES */
 
 
 
#if defined (COFF_LONG_SECTION_NAMES)
 
static bfd_boolean bfd_coff_set_long_section_names_allowed
 
  (bfd *, int);
 
#else /* !defined (COFF_LONG_SECTION_NAMES) */
 
static bfd_boolean bfd_coff_set_long_section_names_disallowed
 
  (bfd *, int);
 
#endif /* defined (COFF_LONG_SECTION_NAMES) */
static long sec_to_styp_flags
static long sec_to_styp_flags
  (const char *, flagword);
  (const char *, flagword);
static bfd_boolean styp_to_sec_flags
static bfd_boolean styp_to_sec_flags
  (bfd *, void *, const char *, asection *, flagword *);
  (bfd *, void *, const char *, asection *, flagword *);
static bfd_boolean coff_bad_format_hook
static bfd_boolean coff_bad_format_hook
Line 370... Line 467...
  (bfd *, void * );
  (bfd *, void * );
#endif
#endif


/* void warning(); */
/* void warning(); */
 
 
 
#if defined (COFF_LONG_SECTION_NAMES)
 
static bfd_boolean
 
bfd_coff_set_long_section_names_allowed (bfd *abfd, int enable)
 
{
 
  coff_backend_info (abfd)->_bfd_coff_long_section_names = enable;
 
  return TRUE;
 
}
 
#else /* !defined (COFF_LONG_SECTION_NAMES) */
 
static bfd_boolean
 
bfd_coff_set_long_section_names_disallowed (bfd *abfd, int enable)
 
{
 
  (void) abfd;
 
  (void) enable;
 
  return FALSE;
 
}
 
#endif /* defined (COFF_LONG_SECTION_NAMES) */
 
 
/* Return a word with STYP_* (scnhdr.s_flags) flags set to represent
/* Return a word with STYP_* (scnhdr.s_flags) flags set to represent
   the incoming SEC_* flags.  The inverse of this function is
   the incoming SEC_* flags.  The inverse of this function is
   styp_to_sec_flags().  NOTE: If you add to/change this routine, you
   styp_to_sec_flags().  NOTE: If you add to/change this routine, you
   should probably mirror the changes in styp_to_sec_flags().  */
   should probably mirror the changes in styp_to_sec_flags().  */
 
 
Line 530... Line 644...
     but there are more IMAGE_SCN_* flags.  */
     but there are more IMAGE_SCN_* flags.  */
 
 
  /* FIXME: There is no gas syntax to specify the debug section flag.  */
  /* FIXME: There is no gas syntax to specify the debug section flag.  */
  if (CONST_STRNEQ (sec_name, DOT_DEBUG)
  if (CONST_STRNEQ (sec_name, DOT_DEBUG)
      || CONST_STRNEQ (sec_name, GNU_LINKONCE_WI))
      || CONST_STRNEQ (sec_name, GNU_LINKONCE_WI))
    sec_flags = SEC_DEBUGGING;
    sec_flags = SEC_DEBUGGING | SEC_READONLY;
 
 
  /* skip LOAD */
  /* skip LOAD */
  /* READONLY later */
  /* READONLY later */
  /* skip RELOC */
  /* skip RELOC */
  if ((sec_flags & SEC_CODE) != 0)
  if ((sec_flags & SEC_CODE) != 0)
Line 559... Line 673...
  if (sec_flags & SEC_LINK_ONCE)
  if (sec_flags & SEC_LINK_ONCE)
    styp_flags |= IMAGE_SCN_LNK_COMDAT;
    styp_flags |= IMAGE_SCN_LNK_COMDAT;
  /* skip LINK_DUPLICATES */
  /* skip LINK_DUPLICATES */
  /* skip LINKER_CREATED */
  /* skip LINKER_CREATED */
 
 
  if (sec_flags & (SEC_ALLOC | SEC_LOAD))
  if ((sec_flags & SEC_COFF_NOREAD) == 0)
    {
    styp_flags |= IMAGE_SCN_MEM_READ;     /* Invert NOREAD for read.  */
      /* For now, the read/write bits are mapped onto SEC_READONLY, even
 
         though the semantics don't quite match.  The bits from the input
 
         are retained in pei_section_data(abfd, section)->pe_flags.  */
 
      styp_flags |= IMAGE_SCN_MEM_READ;       /* Always readable.  */
 
      if ((sec_flags & SEC_READONLY) == 0)
      if ((sec_flags & SEC_READONLY) == 0)
        styp_flags |= IMAGE_SCN_MEM_WRITE;    /* Invert READONLY for write.  */
        styp_flags |= IMAGE_SCN_MEM_WRITE;    /* Invert READONLY for write.  */
      if (sec_flags & SEC_CODE)
      if (sec_flags & SEC_CODE)
        styp_flags |= IMAGE_SCN_MEM_EXECUTE;  /* CODE->EXECUTE.  */
        styp_flags |= IMAGE_SCN_MEM_EXECUTE;  /* CODE->EXECUTE.  */
      if (sec_flags & SEC_COFF_SHARED)
      if (sec_flags & SEC_COFF_SHARED)
        styp_flags |= IMAGE_SCN_MEM_SHARED;   /* Shared remains meaningful.  */
        styp_flags |= IMAGE_SCN_MEM_SHARED;   /* Shared remains meaningful.  */
    }
 
 
 
  return styp_flags;
  return styp_flags;
}
}
 
 
#endif /* COFF_WITH_PE */
#endif /* COFF_WITH_PE */
Line 834... Line 943...
 
 
                   Here, we think we've found the first one,
                   Here, we think we've found the first one,
                   but there's some checking we can do to be
                   but there's some checking we can do to be
                   sure.  */
                   sure.  */
 
 
                if (! (isym.n_sclass == C_STAT
                if (! ((isym.n_sclass == C_STAT
 
                        || isym.n_sclass == C_EXT)
                       && isym.n_type == T_NULL
                       && isym.n_type == T_NULL
                       && isym.n_value == 0))
                       && isym.n_value == 0))
                  abort ();
                  abort ();
 
 
                /* FIXME LATER: MSVC generates section names
                /* FIXME LATER: MSVC generates section names
                   like .text for comdats.  Gas generates
                   like .text for comdats.  Gas generates
                   names like .text$foo__Fv (in the case of a
                   names like .text$foo__Fv (in the case of a
                   function).  See comment above for more.  */
                   function).  See comment above for more.  */
 
 
                if (strcmp (name, symname) != 0)
                if (isym.n_sclass == C_STAT && strcmp (name, symname) != 0)
                  _bfd_error_handler (_("%B: warning: COMDAT symbol '%s' does not match section name '%s'"),
                  _bfd_error_handler (_("%B: warning: COMDAT symbol '%s' does not match section name '%s'"),
                                      abfd, symname, name);
                                      abfd, symname, name);
 
 
                seen_state = 1;
                seen_state = 1;
 
 
Line 957... Line 1067...
                   Intel puts the two adjacent, but Alpha (at
                   Intel puts the two adjacent, but Alpha (at
                   least) spreads them out.  */
                   least) spreads them out.  */
 
 
                amt = sizeof (struct coff_comdat_info);
                amt = sizeof (struct coff_comdat_info);
                coff_section_data (abfd, section)->comdat
                coff_section_data (abfd, section)->comdat
                  = bfd_alloc (abfd, amt);
                  = (struct coff_comdat_info *) bfd_alloc (abfd, amt);
                if (coff_section_data (abfd, section)->comdat == NULL)
                if (coff_section_data (abfd, section)->comdat == NULL)
                  abort ();
                  abort ();
 
 
                coff_section_data (abfd, section)->comdat->symbol =
                coff_section_data (abfd, section)->comdat->symbol =
                  (esym - esymstart) / bfd_coff_symesz (abfd);
                  (esym - esymstart) / bfd_coff_symesz (abfd);
 
 
                amt = strlen (symname) + 1;
                amt = strlen (symname) + 1;
                newname = bfd_alloc (abfd, amt);
                newname = (char *) bfd_alloc (abfd, amt);
                if (newname == NULL)
                if (newname == NULL)
                  abort ();
                  abort ();
 
 
                strcpy (newname, symname);
                strcpy (newname, symname);
                coff_section_data (abfd, section)->comdat->name
                coff_section_data (abfd, section)->comdat->name
Line 1010... Line 1120...
  bfd_boolean result = TRUE;
  bfd_boolean result = TRUE;
 
 
  /* Assume read only unless IMAGE_SCN_MEM_WRITE is specified.  */
  /* Assume read only unless IMAGE_SCN_MEM_WRITE is specified.  */
  sec_flags = SEC_READONLY;
  sec_flags = SEC_READONLY;
 
 
 
  /* If section disallows read, then set the NOREAD flag. */
 
  if ((styp_flags & IMAGE_SCN_MEM_READ) == 0)
 
    sec_flags |= SEC_COFF_NOREAD;
 
 
  /* Process each flag bit in styp_flags in turn.  */
  /* Process each flag bit in styp_flags in turn.  */
  while (styp_flags)
  while (styp_flags)
    {
    {
      long flag = styp_flags & - styp_flags;
      long flag = styp_flags & - styp_flags;
      char * unhandled = NULL;
      char * unhandled = NULL;
Line 1042... Line 1156...
        case STYP_NOLOAD:
        case STYP_NOLOAD:
          sec_flags |= SEC_NEVER_LOAD;
          sec_flags |= SEC_NEVER_LOAD;
          break;
          break;
#endif
#endif
        case IMAGE_SCN_MEM_READ:
        case IMAGE_SCN_MEM_READ:
          /* Ignored, assume it always to be true.  */
          sec_flags &= ~SEC_COFF_NOREAD;
          break;
          break;
        case IMAGE_SCN_TYPE_NO_PAD:
        case IMAGE_SCN_TYPE_NO_PAD:
          /* Skip.  */
          /* Skip.  */
          break;
          break;
        case IMAGE_SCN_LNK_OTHER:
        case IMAGE_SCN_LNK_OTHER:
Line 1067... Line 1181...
          break;
          break;
        case IMAGE_SCN_MEM_WRITE:
        case IMAGE_SCN_MEM_WRITE:
          sec_flags &= ~ SEC_READONLY;
          sec_flags &= ~ SEC_READONLY;
          break;
          break;
        case IMAGE_SCN_MEM_DISCARDABLE:
        case IMAGE_SCN_MEM_DISCARDABLE:
          /* The MS PE spec sets the DISCARDABLE flag on .reloc sections
          /* The MS PE spec says that debug sections are DISCARDABLE,
             but we do not want them to be labelled as debug section, since
             but the presence of a DISCARDABLE flag does not necessarily
             then strip would remove them.  */
             mean that a given section contains debug information.  Thus
          if (! CONST_STRNEQ (name, ".reloc"))
             we only set the SEC_DEBUGGING flag on sections that we
 
             recognise as containing debug information.  */
 
             if (CONST_STRNEQ (name, DOT_DEBUG)
 
#ifdef _COMMENT
 
              || strcmp (name, _COMMENT) == 0
 
#endif
 
#ifdef COFF_LONG_SECTION_NAMES
 
              || CONST_STRNEQ (name, GNU_LINKONCE_WI)
 
#endif
 
              || CONST_STRNEQ (name, ".stab"))
            sec_flags |= SEC_DEBUGGING;
            sec_flags |= SEC_DEBUGGING;
          break;
          break;
        case IMAGE_SCN_MEM_SHARED:
        case IMAGE_SCN_MEM_SHARED:
          sec_flags |= SEC_COFF_SHARED;
          sec_flags |= SEC_COFF_SHARED;
          break;
          break;
Line 1203... Line 1326...
.  unsigned int _bfd_auxesz;
.  unsigned int _bfd_auxesz;
.  unsigned int _bfd_relsz;
.  unsigned int _bfd_relsz;
.  unsigned int _bfd_linesz;
.  unsigned int _bfd_linesz;
.  unsigned int _bfd_filnmlen;
.  unsigned int _bfd_filnmlen;
.  bfd_boolean _bfd_coff_long_filenames;
.  bfd_boolean _bfd_coff_long_filenames;
 
.
.  bfd_boolean _bfd_coff_long_section_names;
.  bfd_boolean _bfd_coff_long_section_names;
 
.  bfd_boolean (*_bfd_coff_set_long_section_names)
 
.    (bfd *, int);
 
.
.  unsigned int _bfd_coff_default_section_alignment_power;
.  unsigned int _bfd_coff_default_section_alignment_power;
.  bfd_boolean _bfd_coff_force_symnames_in_strings;
.  bfd_boolean _bfd_coff_force_symnames_in_strings;
.  unsigned int _bfd_coff_debug_string_prefix_length;
.  unsigned int _bfd_coff_debug_string_prefix_length;
.
.
.  void (*_bfd_coff_swap_filehdr_in)
.  void (*_bfd_coff_swap_filehdr_in)
Line 1290... Line 1417...
.    (bfd *, struct coff_final_link_info *);
.    (bfd *, struct coff_final_link_info *);
.
.
.  bfd_boolean (*_bfd_coff_final_link_postscript)
.  bfd_boolean (*_bfd_coff_final_link_postscript)
.    (bfd *, struct coff_final_link_info *);
.    (bfd *, struct coff_final_link_info *);
.
.
 
.  bfd_boolean (*_bfd_coff_print_pdata)
 
.    (bfd *, void *);
 
.
.} bfd_coff_backend_data;
.} bfd_coff_backend_data;
.
.
.#define coff_backend_info(abfd) \
.#define coff_backend_info(abfd) \
.  ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
.  ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
.
.
Line 1337... Line 1467...
.#define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen)
.#define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen)
.#define bfd_coff_long_filenames(abfd) \
.#define bfd_coff_long_filenames(abfd) \
.  (coff_backend_info (abfd)->_bfd_coff_long_filenames)
.  (coff_backend_info (abfd)->_bfd_coff_long_filenames)
.#define bfd_coff_long_section_names(abfd) \
.#define bfd_coff_long_section_names(abfd) \
.  (coff_backend_info (abfd)->_bfd_coff_long_section_names)
.  (coff_backend_info (abfd)->_bfd_coff_long_section_names)
 
.#define bfd_coff_set_long_section_names(abfd, enable) \
 
.  ((coff_backend_info (abfd)->_bfd_coff_set_long_section_names) (abfd, enable))
.#define bfd_coff_default_section_alignment_power(abfd) \
.#define bfd_coff_default_section_alignment_power(abfd) \
.  (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
.  (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
.#define bfd_coff_swap_filehdr_in(abfd, i,o) \
.#define bfd_coff_swap_filehdr_in(abfd, i,o) \
.  ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
.  ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
.
.
Line 1422... Line 1554...
.#define bfd_coff_link_output_has_begun(a,p) \
.#define bfd_coff_link_output_has_begun(a,p) \
.  ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a, p))
.  ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a, p))
.#define bfd_coff_final_link_postscript(a,p) \
.#define bfd_coff_final_link_postscript(a,p) \
.  ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a, p))
.  ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a, p))
.
.
 
.#define bfd_coff_have_print_pdata(a) \
 
.  (coff_backend_info (a)->_bfd_coff_print_pdata)
 
.#define bfd_coff_print_pdata(a,p) \
 
.  ((coff_backend_info (a)->_bfd_coff_print_pdata) (a, p))
 
.
 
.{* Macro: Returns true if the bfd is a PE executable as opposed to a
 
.   PE object file.  *}
 
.#define bfd_pei_p(abfd) \
 
.  (CONST_STRNEQ ((abfd)->xvec->name, "pei-"))
*/
*/
 
 
/* See whether the magic number matches.  */
/* See whether the magic number matches.  */
 
 
static bfd_boolean
static bfd_boolean
Line 1569... Line 1710...
     related info.
     related info.
 
 
     @@ The 10 is a guess at a plausible maximum number of aux entries
     @@ The 10 is a guess at a plausible maximum number of aux entries
     (but shouldn't be a constant).  */
     (but shouldn't be a constant).  */
  amt = sizeof (combined_entry_type) * 10;
  amt = sizeof (combined_entry_type) * 10;
  native = bfd_zalloc (abfd, amt);
  native = (combined_entry_type *) bfd_zalloc (abfd, amt);
  if (native == NULL)
  if (native == NULL)
    return FALSE;
    return FALSE;
 
 
  /* We don't need to set up n_name, n_value, or n_scnum in the native
  /* We don't need to set up n_name, n_value, or n_scnum in the native
     symbol information, since they'll be overridden by the BFD symbol
     symbol information, since they'll be overridden by the BFD symbol
Line 1849... Line 1990...
     defines coff_mkobject_hook.  */
     defines coff_mkobject_hook.  */
  if ((internal_f->f_flags & IMAGE_FILE_DEBUG_STRIPPED) == 0)
  if ((internal_f->f_flags & IMAGE_FILE_DEBUG_STRIPPED) == 0)
    abfd->flags |= HAS_DEBUG;
    abfd->flags |= HAS_DEBUG;
#endif
#endif
 
 
 
  if ((internal_f->f_flags & F_GO32STUB) != 0)
 
    coff->go32stub = (char *) bfd_alloc (abfd, (bfd_size_type) GO32_STUBSIZE);
 
  if (coff->go32stub != NULL)
 
    memcpy (coff->go32stub, internal_f->go32stub, GO32_STUBSIZE);
 
 
  return coff;
  return coff;
}
}
#endif
#endif
 
 
/* Determine the machine architecture and type.  FIXME: This is target
/* Determine the machine architecture and type.  FIXME: This is target
Line 2286... Line 2432...
 
 
#ifdef XCOFF64
#ifdef XCOFF64
#define FORCE_SYMNAMES_IN_STRINGS
#define FORCE_SYMNAMES_IN_STRINGS
#endif
#endif
 
 
/* Handle the csect auxent of a C_EXT or C_HIDEXT symbol.  */
/* Handle the csect auxent of a C_EXT, C_AIX_WEAKEXT or C_HIDEXT symbol.  */
 
 
static bfd_boolean
static bfd_boolean
coff_pointerize_aux_hook (bfd *abfd ATTRIBUTE_UNUSED,
coff_pointerize_aux_hook (bfd *abfd ATTRIBUTE_UNUSED,
                          combined_entry_type *table_base,
                          combined_entry_type *table_base,
                          combined_entry_type *symbol,
                          combined_entry_type *symbol,
                          unsigned int indaux,
                          unsigned int indaux,
                          combined_entry_type *aux)
                          combined_entry_type *aux)
{
{
  int class = symbol->u.syment.n_sclass;
  int n_sclass = symbol->u.syment.n_sclass;
 
 
  if ((class == C_EXT || class == C_HIDEXT)
  if (CSECT_SYM_P (n_sclass)
      && indaux + 1 == symbol->u.syment.n_numaux)
      && indaux + 1 == symbol->u.syment.n_numaux)
    {
    {
      if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) == XTY_LD)
      if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) == XTY_LD)
        {
        {
          aux->u.auxent.x_csect.x_scnlen.p =
          aux->u.auxent.x_csect.x_scnlen.p =
Line 2355... Line 2501...
                combined_entry_type *symbol ATTRIBUTE_UNUSED,
                combined_entry_type *symbol ATTRIBUTE_UNUSED,
                combined_entry_type *aux ATTRIBUTE_UNUSED,
                combined_entry_type *aux ATTRIBUTE_UNUSED,
                unsigned int indaux ATTRIBUTE_UNUSED)
                unsigned int indaux ATTRIBUTE_UNUSED)
{
{
#ifdef RS6000COFF_C
#ifdef RS6000COFF_C
  if ((symbol->u.syment.n_sclass == C_EXT
  if (CSECT_SYM_P (symbol->u.syment.n_sclass)
       || symbol->u.syment.n_sclass == C_HIDEXT)
 
      && indaux + 1 == symbol->u.syment.n_numaux)
      && indaux + 1 == symbol->u.syment.n_numaux)
    {
    {
      /* This is a csect entry.  */
      /* This is a csect entry.  */
      fprintf (file, "AUX ");
      fprintf (file, "AUX ");
      if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) != XTY_LD)
      if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) != XTY_LD)
Line 3045... Line 3190...
    asection **section_list;
    asection **section_list;
    unsigned int i;
    unsigned int i;
    int target_index;
    int target_index;
    bfd_size_type amt;
    bfd_size_type amt;
 
 
 
#ifdef COFF_PAGE_SIZE
 
    /* Clear D_PAGED if section alignment is smaller than
 
       COFF_PAGE_SIZE.  */
 
   if (pe_data (abfd)->pe_opthdr.SectionAlignment < COFF_PAGE_SIZE)
 
     abfd->flags &= ~D_PAGED;
 
#endif
 
 
    count = 0;
    count = 0;
    for (current = abfd->sections; current != NULL; current = current->next)
    for (current = abfd->sections; current != NULL; current = current->next)
      ++count;
      ++count;
 
 
    /* We allocate an extra cell to simplify the final loop.  */
    /* We allocate an extra cell to simplify the final loop.  */
    amt = sizeof (struct asection *) * (count + 1);
    amt = sizeof (struct asection *) * (count + 1);
    section_list = bfd_malloc (amt);
    section_list = (asection **) bfd_malloc (amt);
    if (section_list == NULL)
    if (section_list == NULL)
      return FALSE;
      return FALSE;
 
 
    i = 0;
    i = 0;
    for (current = abfd->sections; current != NULL; current = current->next)
    for (current = abfd->sections; current != NULL; current = current->next)
Line 3477... Line 3629...
    {
    {
      struct internal_scnhdr section;
      struct internal_scnhdr section;
      bfd_boolean is_reloc_section = FALSE;
      bfd_boolean is_reloc_section = FALSE;
 
 
#ifdef COFF_IMAGE_WITH_PE
#ifdef COFF_IMAGE_WITH_PE
      if (strcmp (current->name, ".reloc") == 0)
      if (strcmp (current->name, DOT_RELOC) == 0)
        {
        {
          is_reloc_section = TRUE;
          is_reloc_section = TRUE;
          hasrelocs = TRUE;
          hasrelocs = TRUE;
          pe_data (abfd)->has_reloc_section = 1;
          pe_data (abfd)->has_reloc_section = 1;
        }
        }
Line 3492... Line 3644...
      strncpy (section.s_name, current->name, SCNNMLEN);
      strncpy (section.s_name, current->name, SCNNMLEN);
 
 
#ifdef COFF_LONG_SECTION_NAMES
#ifdef COFF_LONG_SECTION_NAMES
      /* Handle long section names as in PE.  This must be compatible
      /* Handle long section names as in PE.  This must be compatible
         with the code in coff_write_symbols and _bfd_coff_final_link.  */
         with the code in coff_write_symbols and _bfd_coff_final_link.  */
 
      if (bfd_coff_long_section_names (abfd))
      {
      {
        size_t len;
        size_t len;
 
 
        len = strlen (current->name);
        len = strlen (current->name);
        if (len > SCNNMLEN)
        if (len > SCNNMLEN)
          {
          {
            memset (section.s_name, 0, SCNNMLEN);
              /* The s_name field is defined to be NUL-padded but need not be
            sprintf (section.s_name, "/%lu", (unsigned long) string_size);
                 NUL-terminated.  We use a temporary buffer so that we can still
 
                 sprintf all eight chars without splatting a terminating NUL
 
                 over the first byte of the following member (s_paddr).  */
 
              char s_name_buf[SCNNMLEN + 1];
 
 
 
              /* An inherent limitation of the /nnnnnnn notation used to indicate
 
                 the offset of the long name in the string table is that we
 
                 cannot address entries beyone the ten million byte boundary.  */
 
              if (string_size >= 10000000)
 
                {
 
                  bfd_set_error (bfd_error_file_too_big);
 
                  (*_bfd_error_handler)
 
                    (_("%B: section %s: string table overflow at offset %ld"),
 
                    abfd, current->name, string_size);
 
                  return FALSE;
 
                }
 
 
 
              /* snprintf not strictly necessary now we've verified the value
 
                 has less than eight ASCII digits, but never mind.  */
 
              snprintf (s_name_buf, SCNNMLEN + 1, "/%lu", (unsigned long) string_size);
 
              /* Then strncpy takes care of any padding for us.  */
 
              strncpy (section.s_name, s_name_buf, SCNNMLEN);
            string_size += len + 1;
            string_size += len + 1;
            long_section_names = TRUE;
            long_section_names = TRUE;
          }
          }
      }
      }
#endif
#endif
Line 3518... Line 3692...
      section.s_vaddr = current->vma;
      section.s_vaddr = current->vma;
      section.s_paddr = current->lma;
      section.s_paddr = current->lma;
      section.s_size =  current->size;
      section.s_size =  current->size;
#ifdef coff_get_section_load_page
#ifdef coff_get_section_load_page
      section.s_page = coff_get_section_load_page (current);
      section.s_page = coff_get_section_load_page (current);
 
#else
 
      section.s_page = 0;
#endif
#endif
 
 
#ifdef COFF_WITH_PE
#ifdef COFF_WITH_PE
      section.s_paddr = 0;
      section.s_paddr = 0;
#endif
#endif
Line 4098... Line 4274...
 
 
  {
  {
    char * buff;
    char * buff;
    bfd_size_type amount = bfd_coff_filhsz (abfd);
    bfd_size_type amount = bfd_coff_filhsz (abfd);
 
 
    buff = bfd_malloc (amount);
    buff = (char *) bfd_malloc (amount);
    if (buff == NULL)
    if (buff == NULL)
      return FALSE;
      return FALSE;
 
 
    bfd_coff_swap_filehdr_out (abfd, & internal_f, buff);
    bfd_coff_swap_filehdr_out (abfd, & internal_f, buff);
    amount = bfd_bwrite (buff, amount, abfd);
    amount = bfd_bwrite (buff, amount, abfd);
Line 4118... Line 4294...
      /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
      /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
         include/coff/pe.h sets AOUTSZ == sizeof (PEAOUTHDR)).  */
         include/coff/pe.h sets AOUTSZ == sizeof (PEAOUTHDR)).  */
      char * buff;
      char * buff;
      bfd_size_type amount = bfd_coff_aoutsz (abfd);
      bfd_size_type amount = bfd_coff_aoutsz (abfd);
 
 
      buff = bfd_malloc (amount);
      buff = (char *) bfd_malloc (amount);
      if (buff == NULL)
      if (buff == NULL)
        return FALSE;
        return FALSE;
 
 
      coff_swap_aouthdr_out (abfd, & internal_a, buff);
      coff_swap_aouthdr_out (abfd, & internal_a, buff);
      amount = bfd_bwrite (buff, amount, abfd);
      amount = bfd_bwrite (buff, amount, abfd);
Line 4286... Line 4462...
  unsigned int nbr_func;
  unsigned int nbr_func;
  LINENO *src;
  LINENO *src;
 
 
  BFD_ASSERT (asect->lineno == NULL);
  BFD_ASSERT (asect->lineno == NULL);
 
 
 
  amt = ((bfd_size_type) asect->lineno_count + 1) * sizeof (alent);
 
  lineno_cache = (alent *) bfd_alloc (abfd, amt);
 
  if (lineno_cache == NULL)
 
    return FALSE;
 
 
  amt = (bfd_size_type) bfd_coff_linesz (abfd) * asect->lineno_count;
  amt = (bfd_size_type) bfd_coff_linesz (abfd) * asect->lineno_count;
  native_lineno = (LINENO *) buy_and_read (abfd, asect->line_filepos, amt);
  native_lineno = (LINENO *) buy_and_read (abfd, asect->line_filepos, amt);
  if (native_lineno == NULL)
  if (native_lineno == NULL)
    {
    {
      (*_bfd_error_handler)
      (*_bfd_error_handler)
        (_("%B: warning: line number table read failed"), abfd);
        (_("%B: warning: line number table read failed"), abfd);
 
      bfd_release (abfd, lineno_cache);
      return FALSE;
      return FALSE;
    }
    }
 
 
  amt = ((bfd_size_type) asect->lineno_count + 1) * sizeof (alent);
 
  lineno_cache = bfd_alloc (abfd, amt);
 
  if (lineno_cache == NULL)
 
    return FALSE;
 
 
 
  cache_ptr = lineno_cache;
  cache_ptr = lineno_cache;
 
  asect->lineno = lineno_cache;
  src = native_lineno;
  src = native_lineno;
  nbr_func = 0;
  nbr_func = 0;
 
 
  for (counter = 0; counter < asect->lineno_count; counter++)
  for (counter = 0; counter < asect->lineno_count; counter++)
    {
    {
Line 4354... Line 4532...
 
 
      cache_ptr++;
      cache_ptr++;
      src++;
      src++;
    }
    }
  cache_ptr->line_number = 0;
  cache_ptr->line_number = 0;
 
  bfd_release (abfd, native_lineno);
 
 
  /* On some systems (eg AIX5.3) the lineno table may not be sorted.  */
  /* On some systems (eg AIX5.3) the lineno table may not be sorted.  */
  if (!ordered)
  if (!ordered)
    {
    {
      /* Sort the table.  */
      /* Sort the table.  */
      alent **func_table;
      alent **func_table;
      alent *n_lineno_cache;
      alent *n_lineno_cache;
 
 
      /* Create a table of functions.  */
      /* Create a table of functions.  */
      func_table = bfd_malloc (nbr_func * sizeof (alent *));
      func_table = (alent **) bfd_alloc (abfd, nbr_func * sizeof (alent *));
      if (func_table != NULL)
      if (func_table != NULL)
        {
        {
          alent **p = func_table;
          alent **p = func_table;
          unsigned int i;
          unsigned int i;
 
 
Line 4377... Line 4556...
 
 
          /* Sort by functions.  */
          /* Sort by functions.  */
          qsort (func_table, nbr_func, sizeof (alent *), coff_sort_func_alent);
          qsort (func_table, nbr_func, sizeof (alent *), coff_sort_func_alent);
 
 
          /* Create the new sorted table.  */
          /* Create the new sorted table.  */
          n_lineno_cache = bfd_alloc (abfd, amt);
          amt = ((bfd_size_type) asect->lineno_count + 1) * sizeof (alent);
 
          n_lineno_cache = (alent *) bfd_alloc (abfd, amt);
          if (n_lineno_cache != NULL)
          if (n_lineno_cache != NULL)
            {
            {
              alent *n_cache_ptr = n_lineno_cache;
              alent *n_cache_ptr = n_lineno_cache;
 
 
              for (i = 0; i < nbr_func; i++)
              for (i = 0; i < nbr_func; i++)
Line 4399... Line 4579...
                  /* Copy the line number entries.  */
                  /* Copy the line number entries.  */
                  while (old_ptr->line_number != 0)
                  while (old_ptr->line_number != 0)
                    *n_cache_ptr++ = *old_ptr++;
                    *n_cache_ptr++ = *old_ptr++;
                }
                }
              n_cache_ptr->line_number = 0;
              n_cache_ptr->line_number = 0;
              bfd_release (abfd, lineno_cache);
              memcpy (lineno_cache, n_lineno_cache, amt);
              lineno_cache = n_lineno_cache;
 
            }
            }
          free (func_table);
          bfd_release (abfd, func_table);
        }
        }
    }
    }
 
 
  asect->lineno = lineno_cache;
 
  bfd_release (abfd, native_lineno);
 
  return TRUE;
  return TRUE;
}
}
 
 
/* Slurp in the symbol table, converting it to generic form.  Note
/* Slurp in the symbol table, converting it to generic form.  Note
   that if coff_relocate_section is defined, the linker will read
   that if coff_relocate_section is defined, the linker will read
Line 4434... Line 4611...
    return FALSE;
    return FALSE;
 
 
  /* Allocate enough room for all the symbols in cached form.  */
  /* Allocate enough room for all the symbols in cached form.  */
  amt = obj_raw_syment_count (abfd);
  amt = obj_raw_syment_count (abfd);
  amt *= sizeof (coff_symbol_type);
  amt *= sizeof (coff_symbol_type);
  cached_area = bfd_alloc (abfd, amt);
  cached_area = (coff_symbol_type *) bfd_alloc (abfd, amt);
  if (cached_area == NULL)
  if (cached_area == NULL)
    return FALSE;
    return FALSE;
 
 
  amt = obj_raw_syment_count (abfd);
  amt = obj_raw_syment_count (abfd);
  amt *= sizeof (unsigned int);
  amt *= sizeof (unsigned int);
  table_ptr = bfd_alloc (abfd, amt);
  table_ptr = (unsigned int *) bfd_alloc (abfd, amt);
 
 
  if (table_ptr == NULL)
  if (table_ptr == NULL)
    return FALSE;
    return FALSE;
  else
  else
    {
    {
Line 4932... Line 5109...
    return FALSE;
    return FALSE;
 
 
  amt = (bfd_size_type) bfd_coff_relsz (abfd) * asect->reloc_count;
  amt = (bfd_size_type) bfd_coff_relsz (abfd) * asect->reloc_count;
  native_relocs = (RELOC *) buy_and_read (abfd, asect->rel_filepos, amt);
  native_relocs = (RELOC *) buy_and_read (abfd, asect->rel_filepos, amt);
  amt = (bfd_size_type) asect->reloc_count * sizeof (arelent);
  amt = (bfd_size_type) asect->reloc_count * sizeof (arelent);
  reloc_cache = bfd_alloc (abfd, amt);
  reloc_cache = (arelent *) bfd_alloc (abfd, amt);
 
 
  if (reloc_cache == NULL || native_relocs == NULL)
  if (reloc_cache == NULL || native_relocs == NULL)
    return FALSE;
    return FALSE;
 
 
  for (idx = 0; idx < asect->reloc_count; idx++)
  for (idx = 0; idx < asect->reloc_count; idx++)
Line 5224... Line 5401...
#endif
#endif
#ifndef coff_SWAP_scnhdr_in
#ifndef coff_SWAP_scnhdr_in
#define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
#define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
#endif
#endif
 
 
static const bfd_coff_backend_data bfd_coff_std_swap_table ATTRIBUTE_UNUSED =
static bfd_coff_backend_data bfd_coff_std_swap_table ATTRIBUTE_UNUSED =
{
{
  coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
  coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
  coff_SWAP_aux_out, coff_SWAP_sym_out,
  coff_SWAP_aux_out, coff_SWAP_sym_out,
  coff_SWAP_lineno_out, coff_SWAP_reloc_out,
  coff_SWAP_lineno_out, coff_SWAP_reloc_out,
  coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
  coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
Line 5237... Line 5414...
#ifdef COFF_LONG_FILENAMES
#ifdef COFF_LONG_FILENAMES
  TRUE,
  TRUE,
#else
#else
  FALSE,
  FALSE,
#endif
#endif
#ifdef COFF_LONG_SECTION_NAMES
  COFF_DEFAULT_LONG_SECTION_NAMES,
  TRUE,
 
#else
 
  FALSE,
 
#endif
 
  COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
  COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
#ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
#ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
  TRUE,
  TRUE,
#else
#else
  FALSE,
  FALSE,
Line 5261... Line 5434...
  coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
  coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
  coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
  coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
  coff_classify_symbol, coff_compute_section_file_positions,
  coff_classify_symbol, coff_compute_section_file_positions,
  coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
  coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
  coff_adjust_symndx, coff_link_add_one_symbol,
  coff_adjust_symndx, coff_link_add_one_symbol,
  coff_link_output_has_begun, coff_final_link_postscript
  coff_link_output_has_begun, coff_final_link_postscript,
 
  bfd_pe_print_pdata
};
};
 
 
#ifdef TICOFF
#ifdef TICOFF
/* COFF0 differs in file/section header size and relocation entry size.  */
/* COFF0 differs in file/section header size and relocation entry size.  */
 
 
static const bfd_coff_backend_data ticoff0_swap_table =
static bfd_coff_backend_data ticoff0_swap_table =
{
{
  coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
  coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
  coff_SWAP_aux_out, coff_SWAP_sym_out,
  coff_SWAP_aux_out, coff_SWAP_sym_out,
  coff_SWAP_lineno_out, coff_SWAP_reloc_out,
  coff_SWAP_lineno_out, coff_SWAP_reloc_out,
  coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
  coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
Line 5280... Line 5454...
#ifdef COFF_LONG_FILENAMES
#ifdef COFF_LONG_FILENAMES
  TRUE,
  TRUE,
#else
#else
  FALSE,
  FALSE,
#endif
#endif
#ifdef COFF_LONG_SECTION_NAMES
  COFF_DEFAULT_LONG_SECTION_NAMES,
  TRUE,
 
#else
 
  FALSE,
 
#endif
 
  COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
  COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
#ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
#ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
  TRUE,
  TRUE,
#else
#else
  FALSE,
  FALSE,
Line 5304... Line 5474...
  coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
  coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
  coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
  coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
  coff_classify_symbol, coff_compute_section_file_positions,
  coff_classify_symbol, coff_compute_section_file_positions,
  coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
  coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
  coff_adjust_symndx, coff_link_add_one_symbol,
  coff_adjust_symndx, coff_link_add_one_symbol,
  coff_link_output_has_begun, coff_final_link_postscript
  coff_link_output_has_begun, coff_final_link_postscript,
 
  bfd_pe_print_pdata
};
};
#endif
#endif
 
 
#ifdef TICOFF
#ifdef TICOFF
/* COFF1 differs in section header size.  */
/* COFF1 differs in section header size.  */
 
 
static const bfd_coff_backend_data ticoff1_swap_table =
static bfd_coff_backend_data ticoff1_swap_table =
{
{
  coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
  coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
  coff_SWAP_aux_out, coff_SWAP_sym_out,
  coff_SWAP_aux_out, coff_SWAP_sym_out,
  coff_SWAP_lineno_out, coff_SWAP_reloc_out,
  coff_SWAP_lineno_out, coff_SWAP_reloc_out,
  coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
  coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
Line 5324... Line 5495...
#ifdef COFF_LONG_FILENAMES
#ifdef COFF_LONG_FILENAMES
  TRUE,
  TRUE,
#else
#else
  FALSE,
  FALSE,
#endif
#endif
#ifdef COFF_LONG_SECTION_NAMES
  COFF_DEFAULT_LONG_SECTION_NAMES,
  TRUE,
 
#else
 
  FALSE,
 
#endif
 
  COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
  COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
#ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
#ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
  TRUE,
  TRUE,
#else
#else
  FALSE,
  FALSE,
Line 5348... Line 5515...
  coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
  coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
  coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
  coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
  coff_classify_symbol, coff_compute_section_file_positions,
  coff_classify_symbol, coff_compute_section_file_positions,
  coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
  coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
  coff_adjust_symndx, coff_link_add_one_symbol,
  coff_adjust_symndx, coff_link_add_one_symbol,
  coff_link_output_has_begun, coff_final_link_postscript
  coff_link_output_has_begun, coff_final_link_postscript,
 
  bfd_pe_print_pdata    /* huh */
};
};
#endif
#endif
 
 
#ifndef coff_close_and_cleanup
#ifndef coff_close_and_cleanup
#define coff_close_and_cleanup              _bfd_generic_close_and_cleanup
#define coff_close_and_cleanup              _bfd_generic_close_and_cleanup
Line 5447... Line 5615...
#ifndef coff_section_already_linked
#ifndef coff_section_already_linked
#define coff_section_already_linked \
#define coff_section_already_linked \
  _bfd_generic_section_already_linked
  _bfd_generic_section_already_linked
#endif
#endif
 
 
 
#ifndef coff_bfd_define_common_symbol
 
#define coff_bfd_define_common_symbol       bfd_generic_define_common_symbol
 
#endif
 
 
#define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE)     \
#define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE)     \
const bfd_target VAR =                                                  \
const bfd_target VAR =                                                  \
{                                                                       \
{                                                                       \
  NAME ,                                                                \
  NAME ,                                                                \
  bfd_target_coff_flavour,                                              \
  bfd_target_coff_flavour,                                              \

powered by: WebSVN 2.1.0

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