path: root/bfd/nlmcode.h

/* NLM (NetWare Loadable Module) executable support for BFD.
   Copyright (C) 1993 Free Software Foundation, Inc.

   Written by Fred Fish @ Cygnus Support, using ELF support as the
   template.

This file is part of BFD, the Binary File Descriptor library.

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
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */

#include <string.h>		/* For strrchr and friends */
#include "bfd.h"
#include "sysdep.h"
#include "libbfd.h"
#include "libnlm.h"

#define Nlm_External_Fixed_Header	NAME(Nlm,External_Fixed_Header)
#define Nlm_External_Version_Header	NAME(Nlm,External_Version_Header)
#define Nlm_External_Copyright_Header	NAME(Nlm,External_Copyright_Header)
#define Nlm_External_Extended_Header	NAME(Nlm,External_Extended_Header)
#define Nlm_External_Custom_Header	NAME(Nlm,External_Custom_Header)

#define nlm_symbol_type			NAME(nlm,symbol_type)

#define nlm_get_symtab_upper_bound	NAME(bfd_nlm,get_symtab_upper_bound)
#define nlm_get_symtab			NAME(bfd_nlm,get_symtab)
#define nlm_make_empty_symbol		NAME(bfd_nlm,make_empty_symbol)
#define nlm_print_symbol		NAME(bfd_nlm,print_symbol)
#define nlm_get_symbol_info		NAME(bfd_nlm,get_symbol_info)
#define nlm_set_arch_mach		NAME(bfd_nlm,set_arch_mach)
#define nlm_object_p			NAME(bfd_nlm,object_p)

#define MSB (~(~(unsigned long)0 >> 1))

/* Forward declarations of static functions */

static boolean add_bfd_section
  PARAMS ((bfd *, char *, file_ptr, bfd_size_type, flagword));

static void nlm_swap_fixed_header_in
  PARAMS ((bfd *, Nlm_External_Fixed_Header *, Nlm_Internal_Fixed_Header *));

static boolean nlm_swap_variable_header_in PARAMS ((bfd *));

static boolean nlm_swap_auxiliary_headers_in PARAMS ((bfd *));

static struct sec *section_from_nlm_index PARAMS ((bfd *, int));

static int nlm_section_from_bfd_section PARAMS ((bfd *, struct sec *));

static boolean nlm_slurp_symbol_table PARAMS ((bfd *, asymbol **));

static int nlm_symbol_from_bfd_symbol
  PARAMS ((bfd *, struct symbol_cache_entry **));

static void nlm_map_symbols PARAMS ((bfd *));

/* Should perhaps use put_offset, put_word, etc.  For now, the two versions
   can be handled by explicitly specifying 32 bits or "the long type".  */
#if ARCH_SIZE == 64
#define put_word	bfd_h_put_64
#define get_word	bfd_h_get_64
#endif
#if ARCH_SIZE == 32
#define put_word	bfd_h_put_32
#define get_word	bfd_h_get_32
#endif

bfd_target *
DEFUN (nlm_object_p, (abfd), bfd * abfd)
{
  Nlm_External_Fixed_Header x_fxdhdr;	/* Nlm file header, external form */
  Nlm_Internal_Fixed_Header *i_fxdhdrp;	/* Nlm file header, internal form */
  int shindex;

  /* Read in the fixed length portion of the NLM header in external format.  */

  if (bfd_read ((PTR) &x_fxdhdr, sizeof (x_fxdhdr), 1, abfd) !=
      sizeof (x_fxdhdr))
    {
      bfd_error = system_call_error;
      return (NULL);
    }

  /* Check to see if we have an NLM file by matching the NLM signature. */

  if (strncmp (x_fxdhdr.signature, NLM_SIGNATURE, NLM_SIGNATURE_SIZE) != 0)
    {
    wrong:
      bfd_error = wrong_format;
      return (NULL);
    }

  /* There's no supported way to discover the endianess of an NLM, so test for
     a sane version number after doing byte swapping appropriate for this
     XVEC.  (Hack alert!) */

  if (get_word (abfd, (bfd_byte *) x_fxdhdr.version) > 0xFFFF)
    {
      goto wrong;
    }

  /* There's no supported way to check for 32 bit versus 64 bit addresses,
     so ignore this distinction for now.  (FIXME) */

  /* Allocate an instance of the nlm_obj_tdata structure and hook it up to
     the tdata pointer in the bfd. */

  nlm_tdata (abfd) = (struct nlm_obj_tdata *)
    bfd_zalloc (abfd, sizeof (struct nlm_obj_tdata));
  if (nlm_tdata (abfd) == NULL)
    {
      bfd_error = no_memory;
      return (NULL);
    }

  /* FIXME:  Any `wrong' exits below here will leak memory (tdata).  */

  /* Swap in the rest of the fixed length header. */

  i_fxdhdrp = nlm_fixed_header (abfd);
  nlm_swap_fixed_header_in (abfd, &x_fxdhdr, i_fxdhdrp);

  if (!nlm_swap_variable_header_in (abfd)
      || !nlm_swap_auxiliary_headers_in (abfd)
      || !add_bfd_section (abfd, NLM_CODE_NAME,
			   i_fxdhdrp -> codeImageOffset,
			   i_fxdhdrp -> codeImageSize,
			   SEC_CODE | SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS)
      || !add_bfd_section (abfd, NLM_INITIALIZED_DATA_NAME,
			   i_fxdhdrp -> dataImageOffset,
			   i_fxdhdrp -> dataImageSize,
			   SEC_DATA | SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS)
      || !add_bfd_section (abfd, NLM_UNINITIALIZED_DATA_NAME,
			   (file_ptr) 0,
			   i_fxdhdrp -> uninitializedDataSize,
			   SEC_DATA | SEC_ALLOC))
    {
      return (NULL);
    }

  return (abfd -> xvec);
}

/* Add a section to the bfd. */

static boolean
DEFUN (add_bfd_section, (abfd, name, offset, size, flags),
       bfd *abfd AND
       char *name AND
       file_ptr offset AND
       bfd_size_type size AND
       flagword flags)
{
  asection *newsect;

  newsect = bfd_make_section (abfd, name);
  if (newsect == NULL)
    {
      return (false);
    }
  newsect -> vma = 0;				/* NLM's are relocatable. */
  newsect -> _raw_size = size;
  newsect -> filepos = offset;
  newsect -> flags = flags;
  newsect -> alignment_power = bfd_log2 (0);	/* FIXME */
  return (true);
}


/* Translate an NLM fixed length file header in external format into an NLM
   file header in internal format. */

static void
DEFUN (nlm_swap_fixed_header_in, (abfd, src, dst),
       bfd * abfd AND
       Nlm_External_Fixed_Header * src AND
       Nlm_Internal_Fixed_Header * dst)
{
  memcpy (dst -> signature, src -> signature, NLM_SIGNATURE_SIZE);
  memcpy (dst -> moduleName, src -> moduleName, NLM_MODULE_NAME_SIZE);
  dst -> version =
    get_word (abfd, (bfd_byte *) src -> version);
  dst -> codeImageOffset =
    get_word (abfd, (bfd_byte *) src -> codeImageOffset);
  dst -> codeImageSize =
    get_word (abfd, (bfd_byte *) src -> codeImageSize);
  dst -> dataImageOffset =
    get_word (abfd, (bfd_byte *) src -> dataImageOffset);
  dst -> dataImageSize =
    get_word (abfd, (bfd_byte *) src -> dataImageSize);
  dst -> uninitializedDataSize =
    get_word (abfd, (bfd_byte *) src -> uninitializedDataSize);
  dst -> customDataOffset =
    get_word (abfd, (bfd_byte *) src -> customDataOffset);
  dst -> customDataSize =
    get_word (abfd, (bfd_byte *) src -> customDataSize);
  dst -> moduleDependencyOffset =
    get_word (abfd, (bfd_byte *) src -> moduleDependencyOffset);
  dst -> numberOfModuleDependencies =
    get_word (abfd, (bfd_byte *) src -> numberOfModuleDependencies);
  dst -> relocationFixupOffset =
    get_word (abfd, (bfd_byte *) src -> relocationFixupOffset);
  dst -> numberOfRelocationFixups =
    get_word (abfd, (bfd_byte *) src -> numberOfRelocationFixups);
  dst -> externalReferencesOffset =
    get_word (abfd, (bfd_byte *) src -> externalReferencesOffset);
  dst -> numberOfExternalReferences =
    get_word (abfd, (bfd_byte *) src -> numberOfExternalReferences);
  dst -> publicsOffset =
    get_word (abfd, (bfd_byte *) src -> publicsOffset);
  dst -> numberOfPublics =
    get_word (abfd, (bfd_byte *) src -> numberOfPublics);
  dst -> debugInfoOffset =
    get_word (abfd, (bfd_byte *) src -> debugInfoOffset);
  dst -> numberOfDebugRecords =
    get_word (abfd, (bfd_byte *) src -> numberOfDebugRecords);
  dst -> codeStartOffset =
    get_word (abfd, (bfd_byte *) src -> codeStartOffset);
  dst -> exitProcedureOffset =
    get_word (abfd, (bfd_byte *) src -> exitProcedureOffset);
  dst -> checkUnloadProcedureOffset =
    get_word (abfd, (bfd_byte *) src -> checkUnloadProcedureOffset);
  dst -> moduleType =
    get_word (abfd, (bfd_byte *) src -> moduleType);
  dst -> flags = 
    get_word (abfd, (bfd_byte *) src -> flags);
}

/* Read and swap in the variable length header.  All the fields must
   exist in the NLM, and must exist in the order they are read here. */

static boolean
DEFUN (nlm_swap_variable_header_in, (abfd),
       bfd * abfd)
{
  unsigned char temp [TARGET_LONG_SIZE];

  /* Read the description length and text members. */

  if (bfd_read ((PTR) &nlm_variable_header (abfd) -> descriptionLength,
		sizeof (nlm_variable_header (abfd) -> descriptionLength),
		1, abfd) !=
      sizeof (nlm_variable_header (abfd) -> descriptionLength))
    {
      bfd_error = system_call_error;
      return (false);
    }
  if (bfd_read ((PTR) nlm_variable_header (abfd) -> descriptionText,
		nlm_variable_header (abfd) -> descriptionLength + 1,
		1, abfd) !=
      nlm_variable_header (abfd) -> descriptionLength + 1)
    {
      bfd_error = system_call_error;
      return (false);
    }

  /* Read and convert the stackSize field. */

  if (bfd_read ((PTR) temp, sizeof (temp), 1, abfd) != sizeof (temp))
    {
      bfd_error = system_call_error;
      return (false);
    }
  nlm_variable_header (abfd) -> stackSize = get_word (abfd, (bfd_byte *) temp);

  /* Read and convert the reserved field. */

  if (bfd_read ((PTR) temp, sizeof (temp), 1, abfd) != sizeof (temp))
    {
      bfd_error = system_call_error;
      return (false);
    }
  nlm_variable_header (abfd) -> reserved = get_word (abfd, (bfd_byte *) temp);

  /* Read the oldThreadName field.  This field is a fixed length string. */

  if (bfd_read ((PTR) nlm_variable_header (abfd) -> oldThreadName,
		sizeof (nlm_variable_header (abfd) -> oldThreadName),
		1, abfd) !=
      sizeof (nlm_variable_header (abfd) -> oldThreadName))
    {
      bfd_error = system_call_error;
      return (false);
    }

  /* Read the screen name length and text members. */

  if (bfd_read ((PTR) &nlm_variable_header (abfd) -> screenNameLength,
		sizeof (nlm_variable_header (abfd) -> screenNameLength),
		1, abfd) !=
      sizeof (nlm_variable_header (abfd) -> screenNameLength))
    {
      bfd_error = system_call_error;
      return (false);
    }
  if (bfd_read ((PTR) nlm_variable_header (abfd) -> screenName,
		nlm_variable_header (abfd) -> screenNameLength + 1,
		1, abfd) !=
      nlm_variable_header (abfd) -> screenNameLength + 1)
    {
      bfd_error = system_call_error;
      return (false);
    }

  /* Read the thread name length and text members. */

  if (bfd_read ((PTR) &nlm_variable_header (abfd) -> threadNameLength,
		sizeof (nlm_variable_header (abfd) -> threadNameLength),
		1, abfd) !=
      sizeof (nlm_variable_header (abfd) -> threadNameLength))
    {
      bfd_error = system_call_error;
      return (false);
    }
  if (bfd_read ((PTR) nlm_variable_header (abfd) -> threadName,
		nlm_variable_header (abfd) -> threadNameLength + 1,
		1, abfd) !=
      nlm_variable_header (abfd) -> threadNameLength + 1)
    {
      bfd_error = system_call_error;
      return (false);
    }
  return (true);
}

/* Read and swap in the contents of all the auxiliary headers.  Because of
   the braindead design, we have to do strcmps on strings of indeterminate
   length to figure out what each auxiliary header is.  Even worse, we have
   no way of knowing how many auxiliary headers there are or where the end
   of the auxiliary headers are, except by finding something that doesn't
   look like a known auxiliary header.  This means that the first new type
   of auxiliary header added will break all existing tools that don't
   recognize it. */

static boolean
DEFUN (nlm_swap_auxiliary_headers_in, (abfd),
       bfd * abfd)
{
  unsigned char temp [TARGET_LONG_SIZE];
  unsigned char tempstr [16];
  long position;

  for (;;)
    {
      position = bfd_tell (abfd);
      if (bfd_read ((PTR) tempstr, sizeof (tempstr), 1, abfd) !=
	  sizeof (tempstr))
	{
	  bfd_error = system_call_error;
	  return (false);
	}
      if (bfd_seek (abfd, position, SEEK_SET) == -1)
	{
	  bfd_error = system_call_error;
	  return (false);
	}
      if (strncmp (tempstr, "VeRsIoN#", 8) == 0)
	{
	  Nlm_External_Version_Header thdr;
	  if (bfd_read ((PTR) &thdr, sizeof (thdr), 1, abfd) != sizeof (thdr))
	    {
	      bfd_error = system_call_error;
	      return (false);
	    }
	  memcpy (nlm_version_header (abfd) -> stamp, thdr.stamp,
		  sizeof (thdr.stamp));
	  nlm_version_header (abfd) -> majorVersion =
	    get_word (abfd, (bfd_byte *) thdr.majorVersion);
	  nlm_version_header (abfd) -> minorVersion =
	    get_word (abfd, (bfd_byte *) thdr.minorVersion);
	  nlm_version_header (abfd) -> revision =
	    get_word (abfd, (bfd_byte *) thdr.revision);
	  nlm_version_header (abfd) -> year =
	    get_word (abfd, (bfd_byte *) thdr.year);
	  nlm_version_header (abfd) -> month =
	    get_word (abfd, (bfd_byte *) thdr.month);
	  nlm_version_header (abfd) -> day =
	    get_word (abfd, (bfd_byte *) thdr.day);
	}
      else if (strncmp (tempstr, "MeSsAgEs", 8) == 0)
	{
	  Nlm_External_Extended_Header thdr;
	  if (bfd_read ((PTR) &thdr, sizeof (thdr), 1, abfd) != sizeof (thdr))
	    {
	      bfd_error = system_call_error;
	      return (false);
	    }
	  memcpy (nlm_extended_header (abfd) -> stamp, thdr.stamp,
		  sizeof (thdr.stamp));
	  nlm_extended_header (abfd) -> languageID =
	    get_word (abfd, (bfd_byte *) thdr.languageID);
	  nlm_extended_header (abfd) -> messageFileOffset =
	    get_word (abfd, (bfd_byte *) thdr.messageFileOffset);
	  nlm_extended_header (abfd) -> messageFileLength =
	    get_word (abfd, (bfd_byte *) thdr.messageFileLength);
	  nlm_extended_header (abfd) -> messageCount =
	    get_word (abfd, (bfd_byte *) thdr.messageCount);
	  nlm_extended_header (abfd) -> helpFileOffset =
	    get_word (abfd, (bfd_byte *) thdr.helpFileOffset);
	  nlm_extended_header (abfd) -> helpFileLength =
	    get_word (abfd, (bfd_byte *) thdr.helpFileLength);
	  nlm_extended_header (abfd) -> RPCDataOffset =
	    get_word (abfd, (bfd_byte *) thdr.RPCDataOffset);
	  nlm_extended_header (abfd) -> RPCDataLength =
	    get_word (abfd, (bfd_byte *) thdr.RPCDataLength);
	  nlm_extended_header (abfd) -> sharedCodeOffset =
	    get_word (abfd, (bfd_byte *) thdr.sharedCodeOffset);
	  nlm_extended_header (abfd) -> sharedCodeLength =
	    get_word (abfd, (bfd_byte *) thdr.sharedCodeLength);
	  nlm_extended_header (abfd) -> sharedDataOffset =
	    get_word (abfd, (bfd_byte *) thdr.sharedDataOffset);
	  nlm_extended_header (abfd) -> sharedDataLength =
	    get_word (abfd, (bfd_byte *) thdr.sharedDataLength);
	  nlm_extended_header (abfd) -> sharedRelocationFixupOffset =
	    get_word (abfd, (bfd_byte *) thdr.sharedRelocationFixupOffset);
	  nlm_extended_header (abfd) -> sharedRelocationFixupCount =
	    get_word (abfd, (bfd_byte *) thdr.sharedRelocationFixupCount);
	  nlm_extended_header (abfd) -> sharedExternalReferenceOffset =
	    get_word (abfd, (bfd_byte *) thdr.sharedExternalReferenceOffset);
	  nlm_extended_header (abfd) -> sharedExternalReferenceCount =
	    get_word (abfd, (bfd_byte *) thdr.sharedExternalReferenceCount);
	  nlm_extended_header (abfd) -> sharedPublicsOffset =
	    get_word (abfd, (bfd_byte *) thdr.sharedPublicsOffset);
	  nlm_extended_header (abfd) -> sharedPublicsCount =
	    get_word (abfd, (bfd_byte *) thdr.sharedPublicsCount);
	  nlm_extended_header (abfd) -> SharedInitializationOffset =
	    get_word (abfd, (bfd_byte *) thdr.sharedInitializationOffset);
	  nlm_extended_header (abfd) -> SharedExitProcedureOffset =
	    get_word (abfd, (bfd_byte *) thdr.SharedExitProcedureOffset);
	  nlm_extended_header (abfd) -> productID =
	    get_word (abfd, (bfd_byte *) thdr.productID);
	  nlm_extended_header (abfd) -> reserved0 =
	    get_word (abfd, (bfd_byte *) thdr.reserved0);
	  nlm_extended_header (abfd) -> reserved1 =
	    get_word (abfd, (bfd_byte *) thdr.reserved1);
	  nlm_extended_header (abfd) -> reserved2 =
	    get_word (abfd, (bfd_byte *) thdr.reserved2);
	  nlm_extended_header (abfd) -> reserved3 =
	    get_word (abfd, (bfd_byte *) thdr.reserved3);
	  nlm_extended_header (abfd) -> reserved4 =
	    get_word (abfd, (bfd_byte *) thdr.reserved4);
	  nlm_extended_header (abfd) -> reserved5 =
	    get_word (abfd, (bfd_byte *) thdr.reserved5);
	}
      else if (strncmp (tempstr, "CuStHeAd", 8) == 0)
	{
	  Nlm_External_Custom_Header thdr;
	  if (bfd_read ((PTR) &thdr, sizeof (thdr), 1, abfd) != sizeof (thdr))
	    {
	      bfd_error = system_call_error;
	      return (false);
	    }
	  memcpy (nlm_custom_header (abfd) -> stamp, thdr.stamp,
		  sizeof (thdr.stamp));
	  nlm_custom_header (abfd) -> dataLength =
	    get_word (abfd, (bfd_byte *) thdr.dataLength);
	  nlm_custom_header (abfd) -> debugRecOffset =
	    get_word (abfd, (bfd_byte *) thdr.debugRecOffset);
	  nlm_custom_header (abfd) -> debugRecLength =
	    get_word (abfd, (bfd_byte *) thdr.debugRecLength);
	}
      else if (strncmp (tempstr, "CoPyRiGhT=", 10) == 0)
	{
	  Nlm_External_Copyright_Header thdr;
	  if (bfd_read ((PTR) &thdr, sizeof (thdr), 1, abfd) != sizeof (thdr))
	    {
	      bfd_error = system_call_error;
	      return (false);
	    }
	  memcpy (nlm_copyright_header (abfd) -> stamp, thdr.stamp,
		  sizeof (thdr.stamp));
	  nlm_copyright_header (abfd) -> copyrightMessageLength =
	    get_word (abfd, (bfd_byte *) thdr.copyrightMessageLength);
	  /* The copyright message is a variable length string. */
	  if (bfd_read ((PTR) nlm_copyright_header (abfd) -> copyrightMessage,
			nlm_copyright_header (abfd) -> copyrightMessageLength + 1,
			1, abfd) !=
	      nlm_copyright_header (abfd) -> copyrightMessageLength + 1)
	    {
	      bfd_error = system_call_error;
	      return (false);
	    }
	}
      else
	{
	  break;
	}
    }
}

/* We read the NLM's public symbols and use it to generate a bfd symbol
   table (hey, it's better than nothing) on a one-for-one basis.  Thus
   use the number of public symbols as the number of bfd symbols we will
   have once we actually get around to reading them in.

   Return the number of bytes required to hold the symtab vector, based on
   the count plus 1, since we will NULL terminate the vector allocated based
   on this size. */

unsigned int
DEFUN (nlm_get_symtab_upper_bound, (abfd), bfd * abfd)
{
  Nlm_Internal_Fixed_Header *i_fxdhdrp;	/* Nlm file header, internal form */
  unsigned int symcount;
  unsigned int symtab_size = 0;

  i_fxdhdrp = nlm_fixed_header (abfd);
  symcount = i_fxdhdrp -> numberOfPublics;
  symtab_size = (symcount + 1) * (sizeof (asymbol));
  return (symtab_size);
}

/* Note that bfd_get_symcount is guaranteed to be zero if slurping the
   symbol table fails. */

unsigned int
DEFUN (nlm_get_symtab, (abfd, alocation),
       bfd *abfd AND
       asymbol **alocation)
{
  nlm_slurp_symbol_table (abfd, alocation);
  return (bfd_get_symcount (abfd));
}

asymbol *
DEFUN (nlm_make_empty_symbol, (abfd),		/* FIXME! */
      bfd * abfd)
{
  asymbol *new = (asymbol *) bfd_zalloc (abfd, sizeof (asymbol));
  new -> the_bfd = abfd;
  return new;
}

void
DEFUN (nlm_get_symbol_info, (ignore_abfd, symbol, ret),
       bfd * ignore_abfd AND
       asymbol * symbol AND
       symbol_info * ret)
{
  bfd_symbol_info (symbol, ret);
}

boolean
DEFUN (nlm_set_arch_mach, (abfd, arch, machine),
       bfd * abfd AND
       enum bfd_architecture arch AND
       unsigned long machine)
{
   return false;
}

/* Slurp in nlm symbol table.

   In the external (in-file) form, NLM export records are variable length,
   with the following form:

	1 byte		length of the symbol name (N)
	N bytes		the symbol name
	4 bytes		the symbol offset from start of it's section

   Note that we currently ignore the internal debug records.  There is
   a lot of duplication between the export records and the internal debug
   records.  We may in the future, want to merge the information from the
   debug records with the information from the export records to produce
   a more complete symbol table, treating additional information from the
   debug records as static symbols. (FIXME)

   If SYMPTRS is non-NULL, the bfd symbols are copied to where it points.

   When we return, the bfd symcount is either zero or contains the correct
   number of symbols.
*/

static boolean
DEFUN (nlm_slurp_symbol_table, (abfd, symptrs),
       bfd *abfd AND
       asymbol **symptrs)	/* Buffer for generated bfd symbols */
{
  Nlm_Internal_Fixed_Header *i_fxdhdrp;	/* Nlm file header, internal form */
  int symcount;				/* Number of external NLM symbols */
  int idx;
  nlm_symbol_type *sym;			/* Pointer to current bfd symbol */
  nlm_symbol_type *symbase;		/* Buffer for generated bfd symbols */
  char symlength;			/* Symbol length read into here */
  long symoffset;			/* Symbol offset read into here */

  if (bfd_get_outsymbols (abfd) != NULL)
    {
      return (true);
    }

  /* Read each raw NLM symbol, using the information to create a canonical bfd
     symbol table entry.

     Note that we allocate the initial bfd canonical symbol buffer based on a
     one-to-one mapping of the NLM symbols to canonical symbols.  We actually
     use all the NLM symbols, so there will be no space left over at the end.
     When we have all the symbols, we build the caller's pointer vector. */

  abfd -> symcount = 0;
  i_fxdhdrp = nlm_fixed_header (abfd);
  symcount = i_fxdhdrp -> numberOfPublics;
  if (symcount == 0)
    {
      return (true);
    }
  if (bfd_seek (abfd, i_fxdhdrp -> publicsOffset, SEEK_SET) == -1)
    {
      bfd_error = system_call_error;
      return (false);
    }
  symbase = (nlm_symbol_type *)
    bfd_zalloc (abfd, symcount * sizeof (nlm_symbol_type));
  sym = symbase;

  /* We use the bfd's symcount directly as the control count, so that early
     termination of the loop leaves the symcount correct for the symbols that
     were read. */

  while (abfd -> symcount < symcount)
    {
      if (bfd_read ((PTR) &symlength, sizeof (symlength), 1, abfd)
	  != sizeof (symlength))
	{
	  bfd_error = system_call_error;
	  return (false);
	}
      sym -> symbol.the_bfd = abfd;
      sym -> symbol.name = bfd_alloc (abfd, symlength + 1);
      if (bfd_read ((PTR) sym -> symbol.name, symlength, 1, abfd)
	  != symlength)
	{
	  bfd_error = system_call_error;
	  return (false);
	}
      if (bfd_read ((PTR) &symoffset, sizeof (symoffset), 1, abfd)
	  != sizeof (symoffset))
	{
	  bfd_error = system_call_error;
	  return (false);
	}
      sym -> symbol.flags = BSF_GLOBAL | BSF_EXPORT;
      sym -> symbol.value = get_word (abfd, (bfd_byte *) &symoffset);
      if (sym -> symbol.value & MSB)
	{
	  sym -> symbol.value &= ~MSB;
	  sym -> symbol.flags |= BSF_FUNCTION;
	  sym -> symbol.section =
	    bfd_get_section_by_name (abfd, NLM_CODE_NAME);
	}
      else
	{
	  sym -> symbol.section =
	    bfd_get_section_by_name (abfd, NLM_INITIALIZED_DATA_NAME);
	}
      abfd -> symcount++;
      sym++;
    }

  /* Fill in the user's symbol pointer vector if needed.  */

  if (symptrs != NULL)
    {
      sym = symbase;
      symcount = abfd -> symcount;
      while (symcount-- > 0)
	{
	  *symptrs++ = &sym -> symbol;
	  sym++;
	}
      *symptrs = NULL;		/* Final NULL pointer */
    }

  return (true);
}