/* NLM (NetWare Loadable Module) executable support for BFD.
- Copyright (C) 1993 Free Software Foundation, Inc.
+ Copyright (C) 1993-2016 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 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 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 3 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.
+ 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. */
+ 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., 51 Franklin Street - Fifth Floor, Boston,
+ MA 02110-1301, USA. */
-#include <string.h> /* For strrchr and friends */
-#include "bfd.h"
#include "sysdep.h"
+#include "bfd.h"
#include "libbfd.h"
#include "libnlm.h"
is named nlm_symbol_type below is actually named nlm32_symbol_type
in the final executable. */
-#define Nlm_External_Fixed_Header NlmNAME(External_Fixed_Header)
-#define Nlm_External_Version_Header NlmNAME(External_Version_Header)
-#define Nlm_External_Copyright_Header NlmNAME(External_Copyright_Header)
-#define Nlm_External_Extended_Header NlmNAME(External_Extended_Header)
-#define Nlm_External_Custom_Header NlmNAME(External_Custom_Header)
-
-#define nlm_symbol_type nlmNAME(symbol_type)
-#define nlm_get_symtab_upper_bound nlmNAME(get_symtab_upper_bound)
-#define nlm_get_symtab nlmNAME(get_symtab)
-#define nlm_make_empty_symbol nlmNAME(make_empty_symbol)
-#define nlm_print_symbol nlmNAME(print_symbol)
-#define nlm_get_symbol_info nlmNAME(get_symbol_info)
-#define nlm_get_reloc_upper_bound nlmNAME(get_reloc_upper_bound)
-#define nlm_canonicalize_reloc nlmNAME(canonicalize_reloc)
-#define nlm_object_p nlmNAME(object_p)
-#define nlm_set_section_contents nlmNAME(set_section_contents)
-#define nlm_write_object_contents nlmNAME(write_object_contents)
+#define Nlm_External_Fixed_Header NlmNAME (External_Fixed_Header)
+#define Nlm_External_Version_Header NlmNAME (External_Version_Header)
+#define Nlm_External_Copyright_Header NlmNAME (External_Copyright_Header)
+#define Nlm_External_Extended_Header NlmNAME (External_Extended_Header)
+#define Nlm_External_Custom_Header NlmNAME (External_Custom_Header)
+#define Nlm_External_Cygnus_Ext_Header NlmNAME (External_Cygnus_Ext_Header)
+
+#define nlm_symbol_type nlmNAME (symbol_type)
+#define nlm_get_symtab_upper_bound nlmNAME (get_symtab_upper_bound)
+#define nlm_canonicalize_symtab nlmNAME (canonicalize_symtab)
+#define nlm_make_empty_symbol nlmNAME (make_empty_symbol)
+#define nlm_print_symbol nlmNAME (print_symbol)
+#define nlm_get_symbol_info nlmNAME (get_symbol_info)
+#define nlm_get_reloc_upper_bound nlmNAME (get_reloc_upper_bound)
+#define nlm_canonicalize_reloc nlmNAME (canonicalize_reloc)
+#define nlm_object_p nlmNAME (object_p)
+#define nlm_set_section_contents nlmNAME (set_section_contents)
+#define nlm_write_object_contents nlmNAME (write_object_contents)
#define nlm_swap_fixed_header_in(abfd,src,dst) \
- (nlm_swap_fixed_header_in_func(abfd))(abfd,src,dst)
+ (nlm_swap_fixed_header_in_func (abfd)) (abfd, src, dst)
#define nlm_swap_fixed_header_out(abfd,src,dst) \
- (nlm_swap_fixed_header_out_func(abfd))(abfd,src,dst)
-
-/* Forward declarations of static functions */
-
-static boolean add_bfd_section
- PARAMS ((bfd *, char *, file_ptr, bfd_size_type, flagword));
-static boolean nlm_swap_variable_header_in
- PARAMS ((bfd *));
-static boolean nlm_swap_variable_header_out
- PARAMS ((bfd *));
-static boolean find_nonzero
- PARAMS ((PTR, size_t));
-static boolean nlm_swap_auxiliary_headers_in
- PARAMS ((bfd *));
-static boolean nlm_swap_auxiliary_headers_out
- PARAMS ((bfd *));
-static boolean nlm_slurp_symbol_table
- PARAMS ((bfd *));
-static boolean nlm_slurp_reloc_fixups
- PARAMS ((bfd *));
-static boolean nlm_compute_section_file_positions
- PARAMS ((bfd *));
-static int nlm_external_reloc_compare
- PARAMS ((const void *, const void *));
+ (nlm_swap_fixed_header_out_func (abfd)) (abfd, src, dst)
/* 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
+#define put_word H_PUT_64
+#define get_word H_GET_64
#endif
#if ARCH_SIZE == 32
-#define put_word bfd_h_put_32
-#define get_word bfd_h_get_32
+#define put_word H_PUT_32
+#define get_word H_GET_32
#endif
-bfd_target *
-DEFUN (nlm_object_p, (abfd), bfd * abfd)
-{
- struct nlm_obj_tdata *preserved_tdata = nlm_tdata (abfd);
- boolean (*backend_object_p) PARAMS ((bfd *));
- PTR x_fxdhdr;
- Nlm_Internal_Fixed_Header *i_fxdhdrp;
- const char *signature;
- enum bfd_architecture arch;
-
- /* Some NLM formats have a prefix before the standard NLM fixed
- header. */
- backend_object_p = nlm_backend_object_p_func (abfd);
- if (backend_object_p)
- {
- if (! (*backend_object_p) (abfd))
- goto got_wrong_format_error;
- }
-
- /* Read in the fixed length portion of the NLM header in external format. */
-
- x_fxdhdr = alloca (nlm_fixed_header_size (abfd));
-
- if (bfd_read ((PTR) x_fxdhdr, nlm_fixed_header_size (abfd), 1, abfd) !=
- nlm_fixed_header_size (abfd))
- {
- bfd_error = system_call_error;
- goto got_no_match;
- }
-
- /* 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;
- goto got_no_match;
- }
-
- i_fxdhdrp = nlm_fixed_header (abfd);
- nlm_swap_fixed_header_in (abfd, x_fxdhdr, i_fxdhdrp);
-
- /* Check to see if we have an NLM file for this backend by matching
- the NLM signature. */
-
- signature = nlm_signature (abfd);
- if (signature != NULL
- && *signature != '\0'
- && strncmp ((char *) i_fxdhdrp->signature, signature,
- NLM_SIGNATURE_SIZE) != 0)
- goto got_wrong_format_error;
-
- /* 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 (i_fxdhdrp->version > 0xFFFF)
- goto got_wrong_format_error;
-
- /* There's no supported way to check for 32 bit versus 64 bit addresses,
- so ignore this distinction for now. (FIXME) */
-
- /* FIXME: Any return(NULL) exits below here will leak memory (tdata).
- And a memory leak also means we lost the real tdata info we wanted
- to save, because it was in the leaked memory. */
-
- /* Swap in the rest of the fixed length header. */
-
- 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
- | SEC_RELOC))
- || !add_bfd_section (abfd, NLM_INITIALIZED_DATA_NAME,
- i_fxdhdrp -> dataImageOffset,
- i_fxdhdrp -> dataImageSize,
- (SEC_DATA | SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
- | SEC_RELOC))
- || !add_bfd_section (abfd, NLM_UNINITIALIZED_DATA_NAME,
- (file_ptr) 0,
- i_fxdhdrp -> uninitializedDataSize,
- SEC_ALLOC))
- goto got_wrong_format_error;
-
- if (nlm_fixed_header (abfd)->numberOfRelocationFixups != 0
- || nlm_fixed_header (abfd)->numberOfExternalReferences != 0)
- abfd->flags |= HAS_RELOC;
- if (nlm_fixed_header (abfd)->numberOfPublics != 0
- || nlm_fixed_header (abfd)->numberOfDebugRecords != 0
- || nlm_fixed_header (abfd)->numberOfExternalReferences != 0)
- abfd->flags |= HAS_SYMS;
-
- arch = nlm_architecture (abfd);
- if (arch != bfd_arch_unknown)
- bfd_default_set_arch_mach (abfd, arch, (unsigned long) 0);
-
- return (abfd -> xvec);
-
- got_wrong_format_error:
- bfd_error = wrong_format;
- got_no_match:
- nlm_tdata (abfd) = preserved_tdata;
- return (NULL);
-}
-
-/* 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);
-}
-
/* 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. */
+ 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)
+static bfd_boolean
+nlm_swap_variable_header_in (bfd *abfd)
{
- unsigned char temp [NLM_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);
+ unsigned char temp[NLM_TARGET_LONG_SIZE];
+ bfd_size_type amt;
+
+ /* Read the description length and text members. */
+ amt = sizeof (nlm_variable_header (abfd)->descriptionLength);
+ if (bfd_bread ((void *) &nlm_variable_header (abfd)->descriptionLength,
+ amt, abfd) != amt)
+ return FALSE;
+ amt = nlm_variable_header (abfd)->descriptionLength + 1;
+ if (bfd_bread ((void *) nlm_variable_header (abfd)->descriptionText,
+ amt, abfd) != amt)
+ return FALSE;
+
+ /* Read and convert the stackSize field. */
+ amt = sizeof (temp);
+ if (bfd_bread ((void *) temp, amt, abfd) != amt)
+ return FALSE;
+ nlm_variable_header (abfd)->stackSize = get_word (abfd, (bfd_byte *) temp);
+
+ /* Read and convert the reserved field. */
+ amt = sizeof (temp);
+ if (bfd_bread ((void *) temp, amt, abfd) != amt)
+ return FALSE;
+ nlm_variable_header (abfd)->reserved = get_word (abfd, (bfd_byte *) temp);
+
+ /* Read the oldThreadName field. This field is a fixed length string. */
+ amt = sizeof (nlm_variable_header (abfd)->oldThreadName);
+ if (bfd_bread ((void *) nlm_variable_header (abfd)->oldThreadName,
+ amt, abfd) != amt)
+ return FALSE;
+
+ /* Read the screen name length and text members. */
+ amt = sizeof (nlm_variable_header (abfd)->screenNameLength);
+ if (bfd_bread ((void *) & nlm_variable_header (abfd)->screenNameLength,
+ amt, abfd) != amt)
+ return FALSE;
+ amt = nlm_variable_header (abfd)->screenNameLength + 1;
+ if (bfd_bread ((void *) nlm_variable_header (abfd)->screenName,
+ amt, abfd) != amt)
+ return FALSE;
+
+ /* Read the thread name length and text members. */
+ amt = sizeof (nlm_variable_header (abfd)->threadNameLength);
+ if (bfd_bread ((void *) & nlm_variable_header (abfd)->threadNameLength,
+ amt, abfd) != amt)
+ return FALSE;
+ amt = nlm_variable_header (abfd)->threadNameLength + 1;
+ if (bfd_bread ((void *) nlm_variable_header (abfd)->threadName,
+ amt, abfd) != amt)
+ return FALSE;
+ return TRUE;
}
-/* Swap and write out the variable length header. All the fields must
- exist in the NLM, and must exist in this order. */
+/* Add a section to the bfd. */
-static boolean
-DEFUN (nlm_swap_variable_header_out, (abfd),
- bfd * abfd)
+static bfd_boolean
+add_bfd_section (bfd *abfd,
+ char *name,
+ file_ptr offset,
+ bfd_size_type size,
+ flagword flags)
{
- unsigned char temp [NLM_TARGET_LONG_SIZE];
-
- /* Write the description length and text members. */
-
- if (bfd_write ((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_write ((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);
- }
-
- /* Convert and write the stackSize field. */
-
- put_word (abfd, (bfd_vma) nlm_variable_header (abfd) -> stackSize,
- (bfd_byte *) temp);
- if (bfd_write ((PTR) temp, sizeof (temp), 1, abfd) != sizeof (temp))
- {
- bfd_error = system_call_error;
- return (false);
- }
-
- /* Convert and write the reserved field. */
-
- put_word (abfd, (bfd_vma) nlm_variable_header (abfd) -> reserved,
- (bfd_byte *) temp);
- if (bfd_write ((PTR) temp, sizeof (temp), 1, abfd) != sizeof (temp))
- {
- bfd_error = system_call_error;
- return (false);
- }
-
- /* Write the oldThreadName field. This field is a fixed length string. */
-
- if (bfd_write ((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);
- }
-
- /* Write the screen name length and text members. */
+ asection *newsect;
- if (bfd_write ((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_write ((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);
- }
+ newsect = bfd_make_section_with_flags (abfd, name, flags);
+ if (newsect == NULL)
+ return FALSE;
- /* Write the thread name length and text members. */
+ newsect->vma = 0; /* NLM's are relocatable. */
+ newsect->size = size;
+ newsect->filepos = offset;
+ newsect->alignment_power = bfd_log2 ((bfd_vma) 0); /* FIXME */
- if (bfd_write ((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_write ((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);
+ return TRUE;
}
/* Read and swap in the contents of all the auxiliary headers. Because of
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. */
+ recognize it. */
-static boolean
-DEFUN (nlm_swap_auxiliary_headers_in, (abfd),
- bfd * abfd)
+static bfd_boolean
+nlm_swap_auxiliary_headers_in (bfd *abfd)
{
- char tempstr [16];
- long position;
+ char tempstr[16];
+ file_ptr position;
+ bfd_size_type amt;
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)
+ amt = sizeof (tempstr);
+ if (bfd_bread ((void *) tempstr, amt, abfd) != amt)
+ return FALSE;
+ if (bfd_seek (abfd, position, SEEK_SET) != 0)
+ return FALSE;
+ if (CONST_STRNEQ (tempstr, "VeRsIoN#"))
{
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,
+
+ amt = sizeof (thdr);
+ if (bfd_bread ((void *) &thdr, amt, abfd) != amt)
+ return FALSE;
+ memcpy (nlm_version_header (abfd)->stamp, thdr.stamp,
sizeof (thdr.stamp));
- nlm_version_header (abfd) -> majorVersion =
+ nlm_version_header (abfd)->majorVersion =
get_word (abfd, (bfd_byte *) thdr.majorVersion);
- nlm_version_header (abfd) -> minorVersion =
+ nlm_version_header (abfd)->minorVersion =
get_word (abfd, (bfd_byte *) thdr.minorVersion);
- nlm_version_header (abfd) -> revision =
+ nlm_version_header (abfd)->revision =
get_word (abfd, (bfd_byte *) thdr.revision);
- nlm_version_header (abfd) -> year =
+ nlm_version_header (abfd)->year =
get_word (abfd, (bfd_byte *) thdr.year);
- nlm_version_header (abfd) -> month =
+ nlm_version_header (abfd)->month =
get_word (abfd, (bfd_byte *) thdr.month);
- nlm_version_header (abfd) -> day =
+ nlm_version_header (abfd)->day =
get_word (abfd, (bfd_byte *) thdr.day);
}
- else if (strncmp (tempstr, "MeSsAgEs", 8) == 0)
+ else if (CONST_STRNEQ (tempstr, "MeSsAgEs"))
{
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,
+
+ amt = sizeof (thdr);
+ if (bfd_bread ((void *) &thdr, amt, abfd) != amt)
+ return FALSE;
+ memcpy (nlm_extended_header (abfd)->stamp, thdr.stamp,
sizeof (thdr.stamp));
- nlm_extended_header (abfd) -> languageID =
+ nlm_extended_header (abfd)->languageID =
get_word (abfd, (bfd_byte *) thdr.languageID);
- nlm_extended_header (abfd) -> messageFileOffset =
+ nlm_extended_header (abfd)->messageFileOffset =
get_word (abfd, (bfd_byte *) thdr.messageFileOffset);
- nlm_extended_header (abfd) -> messageFileLength =
+ nlm_extended_header (abfd)->messageFileLength =
get_word (abfd, (bfd_byte *) thdr.messageFileLength);
- nlm_extended_header (abfd) -> messageCount =
+ nlm_extended_header (abfd)->messageCount =
get_word (abfd, (bfd_byte *) thdr.messageCount);
- nlm_extended_header (abfd) -> helpFileOffset =
+ nlm_extended_header (abfd)->helpFileOffset =
get_word (abfd, (bfd_byte *) thdr.helpFileOffset);
- nlm_extended_header (abfd) -> helpFileLength =
+ nlm_extended_header (abfd)->helpFileLength =
get_word (abfd, (bfd_byte *) thdr.helpFileLength);
- nlm_extended_header (abfd) -> RPCDataOffset =
+ nlm_extended_header (abfd)->RPCDataOffset =
get_word (abfd, (bfd_byte *) thdr.RPCDataOffset);
- nlm_extended_header (abfd) -> RPCDataLength =
+ nlm_extended_header (abfd)->RPCDataLength =
get_word (abfd, (bfd_byte *) thdr.RPCDataLength);
- nlm_extended_header (abfd) -> sharedCodeOffset =
+ nlm_extended_header (abfd)->sharedCodeOffset =
get_word (abfd, (bfd_byte *) thdr.sharedCodeOffset);
- nlm_extended_header (abfd) -> sharedCodeLength =
+ nlm_extended_header (abfd)->sharedCodeLength =
get_word (abfd, (bfd_byte *) thdr.sharedCodeLength);
- nlm_extended_header (abfd) -> sharedDataOffset =
+ nlm_extended_header (abfd)->sharedDataOffset =
get_word (abfd, (bfd_byte *) thdr.sharedDataOffset);
- nlm_extended_header (abfd) -> sharedDataLength =
+ nlm_extended_header (abfd)->sharedDataLength =
get_word (abfd, (bfd_byte *) thdr.sharedDataLength);
- nlm_extended_header (abfd) -> sharedRelocationFixupOffset =
+ nlm_extended_header (abfd)->sharedRelocationFixupOffset =
get_word (abfd, (bfd_byte *) thdr.sharedRelocationFixupOffset);
- nlm_extended_header (abfd) -> sharedRelocationFixupCount =
+ nlm_extended_header (abfd)->sharedRelocationFixupCount =
get_word (abfd, (bfd_byte *) thdr.sharedRelocationFixupCount);
- nlm_extended_header (abfd) -> sharedExternalReferenceOffset =
+ nlm_extended_header (abfd)->sharedExternalReferenceOffset =
get_word (abfd, (bfd_byte *) thdr.sharedExternalReferenceOffset);
- nlm_extended_header (abfd) -> sharedExternalReferenceCount =
+ nlm_extended_header (abfd)->sharedExternalReferenceCount =
get_word (abfd, (bfd_byte *) thdr.sharedExternalReferenceCount);
- nlm_extended_header (abfd) -> sharedPublicsOffset =
+ nlm_extended_header (abfd)->sharedPublicsOffset =
get_word (abfd, (bfd_byte *) thdr.sharedPublicsOffset);
- nlm_extended_header (abfd) -> sharedPublicsCount =
+ nlm_extended_header (abfd)->sharedPublicsCount =
get_word (abfd, (bfd_byte *) thdr.sharedPublicsCount);
- nlm_extended_header (abfd) -> sharedDebugRecordOffset =
+ nlm_extended_header (abfd)->sharedDebugRecordOffset =
get_word (abfd, (bfd_byte *) thdr.sharedDebugRecordOffset);
- nlm_extended_header (abfd) -> sharedDebugRecordCount =
+ nlm_extended_header (abfd)->sharedDebugRecordCount =
get_word (abfd, (bfd_byte *) thdr.sharedDebugRecordCount);
- nlm_extended_header (abfd) -> SharedInitializationOffset =
+ nlm_extended_header (abfd)->SharedInitializationOffset =
get_word (abfd, (bfd_byte *) thdr.sharedInitializationOffset);
- nlm_extended_header (abfd) -> SharedExitProcedureOffset =
+ nlm_extended_header (abfd)->SharedExitProcedureOffset =
get_word (abfd, (bfd_byte *) thdr.SharedExitProcedureOffset);
- nlm_extended_header (abfd) -> productID =
+ nlm_extended_header (abfd)->productID =
get_word (abfd, (bfd_byte *) thdr.productID);
- nlm_extended_header (abfd) -> reserved0 =
+ nlm_extended_header (abfd)->reserved0 =
get_word (abfd, (bfd_byte *) thdr.reserved0);
- nlm_extended_header (abfd) -> reserved1 =
+ nlm_extended_header (abfd)->reserved1 =
get_word (abfd, (bfd_byte *) thdr.reserved1);
- nlm_extended_header (abfd) -> reserved2 =
+ nlm_extended_header (abfd)->reserved2 =
get_word (abfd, (bfd_byte *) thdr.reserved2);
- nlm_extended_header (abfd) -> reserved3 =
+ nlm_extended_header (abfd)->reserved3 =
get_word (abfd, (bfd_byte *) thdr.reserved3);
- nlm_extended_header (abfd) -> reserved4 =
+ nlm_extended_header (abfd)->reserved4 =
get_word (abfd, (bfd_byte *) thdr.reserved4);
- nlm_extended_header (abfd) -> reserved5 =
+ nlm_extended_header (abfd)->reserved5 =
get_word (abfd, (bfd_byte *) thdr.reserved5);
}
- else if (strncmp (tempstr, "CuStHeAd", 8) == 0)
+ else if (CONST_STRNEQ (tempstr, "CoPyRiGhT="))
+ {
+ amt = sizeof (nlm_copyright_header (abfd)->stamp);
+ if (bfd_bread ((void *) nlm_copyright_header (abfd)->stamp,
+ amt, abfd) != amt)
+ return FALSE;
+ if (bfd_bread ((void *) &(nlm_copyright_header (abfd)
+ ->copyrightMessageLength),
+ (bfd_size_type) 1, abfd) != 1)
+ return FALSE;
+ /* The copyright message is a variable length string. */
+ amt = nlm_copyright_header (abfd)->copyrightMessageLength + 1;
+ if (bfd_bread ((void *) nlm_copyright_header (abfd)->copyrightMessage,
+ amt, abfd) != amt)
+ return FALSE;
+ }
+ else if (CONST_STRNEQ (tempstr, "CuStHeAd"))
{
Nlm_External_Custom_Header thdr;
- if (bfd_read ((PTR) &thdr, sizeof (thdr), 1, abfd) != sizeof (thdr))
+ bfd_size_type hdrLength;
+ file_ptr dataOffset;
+ bfd_size_type dataLength;
+ char dataStamp[8];
+ void * hdr;
+
+ /* Read the stamp ("CuStHeAd"). */
+ amt = sizeof (thdr.stamp);
+ if (bfd_bread ((void *) thdr.stamp, amt, abfd) != amt)
+ return FALSE;
+ /* Read the length of this custom header. */
+ amt = sizeof (thdr.length);
+ if (bfd_bread ((void *) thdr.length, amt, abfd) != amt)
+ return FALSE;
+ hdrLength = get_word (abfd, (bfd_byte *) thdr.length);
+ /* Read further fields if we have them. */
+ if (hdrLength < NLM_TARGET_LONG_SIZE)
+ dataOffset = 0;
+ else
{
- bfd_error = system_call_error;
- return (false);
+ amt = sizeof (thdr.dataOffset);
+ if (bfd_bread ((void *) thdr.dataOffset, amt, abfd) != amt)
+ return FALSE;
+ dataOffset = get_word (abfd, (bfd_byte *) thdr.dataOffset);
}
- 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)
- {
- if (bfd_read ((PTR) &nlm_copyright_header (abfd)->stamp,
- sizeof (nlm_copyright_header (abfd)->stamp),
- 1, abfd)
- != sizeof (nlm_copyright_header (abfd)->stamp))
+ if (hdrLength < 2 * NLM_TARGET_LONG_SIZE)
+ dataLength = 0;
+ else
{
- bfd_error = system_call_error;
- return (false);
+ amt = sizeof (thdr.dataLength);
+ if (bfd_bread ((void *) thdr.dataLength, amt, abfd) != amt)
+ return FALSE;
+ dataLength = get_word (abfd, (bfd_byte *) thdr.dataLength);
}
- if (bfd_read ((PTR) &(nlm_copyright_header (abfd)
- ->copyrightMessageLength),
- 1, 1, abfd) != 1)
+ if (hdrLength < 2 * NLM_TARGET_LONG_SIZE + 8)
+ memset (dataStamp, 0, sizeof (dataStamp));
+ else
{
- bfd_error = system_call_error;
- return (false);
+ amt = sizeof (dataStamp);
+ if (bfd_bread ((void *) dataStamp, amt, abfd) != amt)
+ return FALSE;
}
- /* 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)
+
+ /* Read the rest of the header, if any. */
+ if (hdrLength <= 2 * NLM_TARGET_LONG_SIZE + 8)
+ {
+ hdr = NULL;
+ hdrLength = 0;
+ }
+ else
{
- bfd_error = system_call_error;
- return (false);
+ hdrLength -= 2 * NLM_TARGET_LONG_SIZE + 8;
+ hdr = bfd_alloc (abfd, hdrLength);
+ if (hdr == NULL)
+ return FALSE;
+ if (bfd_bread (hdr, hdrLength, abfd) != hdrLength)
+ return FALSE;
+ }
+
+ /* If we have found a Cygnus header, process it. Otherwise,
+ just save the associated data without trying to interpret
+ it. */
+ if (CONST_STRNEQ (dataStamp, "CyGnUsEx"))
+ {
+ file_ptr pos;
+ bfd_byte *contents;
+ bfd_byte *p, *pend;
+
+ BFD_ASSERT (hdrLength == 0 && hdr == NULL);
+
+ pos = bfd_tell (abfd);
+ if (bfd_seek (abfd, dataOffset, SEEK_SET) != 0)
+ return FALSE;
+ contents = bfd_alloc (abfd, dataLength);
+ if (contents == NULL)
+ return FALSE;
+ if (bfd_bread (contents, dataLength, abfd) != dataLength)
+ return FALSE;
+ if (bfd_seek (abfd, pos, SEEK_SET) != 0)
+ return FALSE;
+
+ LITMEMCPY (nlm_cygnus_ext_header (abfd), "CyGnUsEx");
+ nlm_cygnus_ext_header (abfd)->offset = dataOffset;
+ nlm_cygnus_ext_header (abfd)->length = dataLength;
+
+ /* This data this header points to provides a list of
+ the sections which were in the original object file
+ which was converted to become an NLM. We locate
+ those sections and add them to the BFD. Note that
+ this is likely to create a second .text, .data and
+ .bss section; retrieving the sections by name will
+ get the actual NLM sections, which is what we want to
+ happen. The sections from the original file, which
+ may be subsets of the NLM section, can only be found
+ using bfd_map_over_sections. */
+ p = contents;
+ pend = p + dataLength;
+ while (p < pend)
+ {
+ char *name;
+ size_t l;
+ file_ptr filepos;
+ bfd_size_type size;
+ asection *newsec;
+
+ /* The format of this information is
+ null terminated section name
+ zeroes to adjust to 4 byte boundary
+ 4 byte section data file pointer
+ 4 byte section size. */
+
+ name = (char *) p;
+ l = strlen (name) + 1;
+ l = (l + 3) &~ (size_t) 3;
+ p += l;
+ filepos = H_GET_32 (abfd, p);
+ p += 4;
+ size = H_GET_32 (abfd, p);
+ p += 4;
+
+ newsec = bfd_make_section_anyway (abfd, name);
+ if (newsec == NULL)
+ return FALSE;
+ newsec->size = size;
+ if (filepos != 0)
+ {
+ newsec->filepos = filepos;
+ newsec->flags |= SEC_HAS_CONTENTS;
+ }
+ }
+ }
+ else
+ {
+ memcpy (nlm_custom_header (abfd)->stamp, thdr.stamp,
+ sizeof (thdr.stamp));
+ nlm_custom_header (abfd)->hdrLength = hdrLength;
+ nlm_custom_header (abfd)->dataOffset = dataOffset;
+ nlm_custom_header (abfd)->dataLength = dataLength;
+ memcpy (nlm_custom_header (abfd)->dataStamp, dataStamp,
+ sizeof (dataStamp));
+ nlm_custom_header (abfd)->hdr = hdr;
}
}
else
- {
- break;
- }
+ break;
+ }
+ return TRUE;
+}
+
+const bfd_target *
+nlm_object_p (bfd *abfd)
+{
+ struct nlm_obj_tdata *preserved_tdata = nlm_tdata (abfd);
+ bfd_boolean (*backend_object_p) (bfd *);
+ void * x_fxdhdr = NULL;
+ Nlm_Internal_Fixed_Header *i_fxdhdrp;
+ struct nlm_obj_tdata *new_tdata = NULL;
+ const char *signature;
+ enum bfd_architecture arch;
+ bfd_size_type amt;
+
+ /* Some NLM formats have a prefix before the standard NLM fixed
+ header. */
+ backend_object_p = nlm_backend_object_p_func (abfd);
+ if (backend_object_p)
+ {
+ if (!(*backend_object_p) (abfd))
+ goto got_wrong_format_error;
+ }
+
+ /* Read in the fixed length portion of the NLM header in external format. */
+ amt = nlm_fixed_header_size (abfd);
+ x_fxdhdr = bfd_malloc (amt);
+ if (x_fxdhdr == NULL)
+ goto got_no_match;
+
+ if (bfd_bread ((void *) x_fxdhdr, amt, abfd) != amt)
+ {
+ if (bfd_get_error () != bfd_error_system_call)
+ goto got_wrong_format_error;
+ else
+ goto got_no_match;
+ }
+
+ /* Allocate an instance of the nlm_obj_tdata structure and hook it up to
+ the tdata pointer in the bfd. */
+ amt = sizeof (struct nlm_obj_tdata);
+ new_tdata = bfd_zalloc (abfd, amt);
+ if (new_tdata == NULL)
+ goto got_no_match;
+
+ nlm_tdata (abfd) = new_tdata;
+
+ i_fxdhdrp = nlm_fixed_header (abfd);
+ nlm_swap_fixed_header_in (abfd, x_fxdhdr, i_fxdhdrp);
+ free (x_fxdhdr);
+ x_fxdhdr = NULL;
+
+ /* Check to see if we have an NLM file for this backend by matching
+ the NLM signature. */
+ signature = nlm_signature (abfd);
+ if (signature != NULL
+ && *signature != '\0'
+ && strncmp ((char *) i_fxdhdrp->signature, signature,
+ NLM_SIGNATURE_SIZE) != 0)
+ goto got_wrong_format_error;
+
+ /* There's no supported way to discover the endianness of an NLM, so test for
+ a sane version number after doing byte swapping appropriate for this
+ XVEC. (Hack alert!) */
+ if (i_fxdhdrp->version > 0xFFFF)
+ goto got_wrong_format_error;
+
+ /* There's no supported way to check for 32 bit versus 64 bit addresses,
+ so ignore this distinction for now. (FIXME) */
+ /* Swap in the rest of the required header. */
+ if (!nlm_swap_variable_header_in (abfd))
+ {
+ if (bfd_get_error () != bfd_error_system_call)
+ goto got_wrong_format_error;
+ else
+ goto got_no_match;
}
- return (true);
+
+ /* Add the sections supplied by all NLM's, and then read in the
+ auxiliary headers. Reading the auxiliary headers may create
+ additional sections described in the cygnus_ext header.
+ From this point on we assume that we have an NLM, and do not
+ treat errors as indicating the wrong format. */
+ if (!add_bfd_section (abfd, NLM_CODE_NAME,
+ i_fxdhdrp->codeImageOffset,
+ i_fxdhdrp->codeImageSize,
+ (SEC_CODE | SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
+ | SEC_RELOC))
+ || !add_bfd_section (abfd, NLM_INITIALIZED_DATA_NAME,
+ i_fxdhdrp->dataImageOffset,
+ i_fxdhdrp->dataImageSize,
+ (SEC_DATA | SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
+ | SEC_RELOC))
+ || !add_bfd_section (abfd, NLM_UNINITIALIZED_DATA_NAME,
+ (file_ptr) 0,
+ i_fxdhdrp->uninitializedDataSize,
+ SEC_ALLOC))
+ goto got_no_match;
+
+ if (!nlm_swap_auxiliary_headers_in (abfd))
+ goto got_no_match;
+
+ if (nlm_fixed_header (abfd)->numberOfRelocationFixups != 0
+ || nlm_fixed_header (abfd)->numberOfExternalReferences != 0)
+ abfd->flags |= HAS_RELOC;
+ if (nlm_fixed_header (abfd)->numberOfPublics != 0
+ || nlm_fixed_header (abfd)->numberOfDebugRecords != 0
+ || nlm_fixed_header (abfd)->numberOfExternalReferences != 0)
+ abfd->flags |= HAS_SYMS;
+
+ arch = nlm_architecture (abfd);
+ if (arch != bfd_arch_unknown)
+ bfd_default_set_arch_mach (abfd, arch, (unsigned long) 0);
+
+ abfd->flags |= EXEC_P;
+ bfd_get_start_address (abfd) = nlm_fixed_header (abfd)->codeStartOffset;
+
+ return abfd->xvec;
+
+got_wrong_format_error:
+ bfd_set_error (bfd_error_wrong_format);
+got_no_match:
+ nlm_tdata (abfd) = preserved_tdata;
+ if (new_tdata != NULL)
+ bfd_release (abfd, new_tdata);
+ if (x_fxdhdr != NULL)
+ free (x_fxdhdr);
+
+ return NULL;
+}
+
+/* Swap and write out the variable length header. All the fields must
+ exist in the NLM, and must exist in this order. */
+
+static bfd_boolean
+nlm_swap_variable_header_out (bfd *abfd)
+{
+ bfd_byte temp[NLM_TARGET_LONG_SIZE];
+ bfd_size_type amt;
+
+ /* Write the description length and text members. */
+ amt = sizeof (nlm_variable_header (abfd)->descriptionLength);
+ if (bfd_bwrite (& nlm_variable_header (abfd)->descriptionLength, amt,
+ abfd) != amt)
+ return FALSE;
+ amt = nlm_variable_header (abfd)->descriptionLength + 1;
+ if (bfd_bwrite ((void *) nlm_variable_header (abfd)->descriptionText, amt,
+ abfd) != amt)
+ return FALSE;
+
+ /* Convert and write the stackSize field. */
+ put_word (abfd, (bfd_vma) nlm_variable_header (abfd)->stackSize, temp);
+ amt = sizeof (temp);
+ if (bfd_bwrite (temp, amt, abfd) != amt)
+ return FALSE;
+
+ /* Convert and write the reserved field. */
+ put_word (abfd, (bfd_vma) nlm_variable_header (abfd)->reserved, temp);
+ amt = sizeof (temp);
+ if (bfd_bwrite (temp, amt, abfd) != amt)
+ return FALSE;
+
+ /* Write the oldThreadName field. This field is a fixed length string. */
+ amt = sizeof (nlm_variable_header (abfd)->oldThreadName);
+ if (bfd_bwrite (nlm_variable_header (abfd)->oldThreadName, amt,
+ abfd) != amt)
+ return FALSE;
+
+ /* Write the screen name length and text members. */
+ amt = sizeof (nlm_variable_header (abfd)->screenNameLength);
+ if (bfd_bwrite (& nlm_variable_header (abfd)->screenNameLength, amt,
+ abfd) != amt)
+ return FALSE;
+ amt = nlm_variable_header (abfd)->screenNameLength + 1;
+ if (bfd_bwrite (nlm_variable_header (abfd)->screenName, amt, abfd) != amt)
+ return FALSE;
+
+ /* Write the thread name length and text members. */
+ amt = sizeof (nlm_variable_header (abfd)->threadNameLength);
+ if (bfd_bwrite (& nlm_variable_header (abfd)->threadNameLength, amt,
+ abfd) != amt)
+ return FALSE;
+ amt = nlm_variable_header (abfd)->threadNameLength + 1;
+ if (bfd_bwrite (nlm_variable_header (abfd)->threadName, amt, abfd) != amt)
+ return FALSE;
+ return TRUE;
}
/* Return whether there is a non-zero byte in a memory block. */
-static boolean
-find_nonzero (buf, size)
- PTR buf;
- size_t size;
+static bfd_boolean
+find_nonzero (void * buf, size_t size)
{
char *p = (char *) buf;
while (size-- != 0)
if (*p++ != 0)
- return true;
- return false;
+ return TRUE;
+ return FALSE;
}
/* Swap out the contents of the auxiliary headers. We create those
auxiliary headers which have been set non-zero. We do not require
the caller to set up the stamp fields. */
-static boolean
-nlm_swap_auxiliary_headers_out (abfd)
- bfd *abfd;
+static bfd_boolean
+nlm_swap_auxiliary_headers_out (bfd *abfd)
{
+ bfd_size_type amt;
+
/* Write out the version header if there is one. */
- if (find_nonzero ((PTR) nlm_version_header (abfd),
+ if (find_nonzero (nlm_version_header (abfd),
sizeof (Nlm_Internal_Version_Header)))
{
Nlm_External_Version_Header thdr;
- memcpy (thdr.stamp, "VeRsIoN#", 8);
- put_word (abfd, (bfd_vma) nlm_version_header (abfd) -> majorVersion,
+ LITMEMCPY (thdr.stamp, "VeRsIoN#");
+ put_word (abfd, (bfd_vma) nlm_version_header (abfd)->majorVersion,
(bfd_byte *) thdr.majorVersion);
- put_word (abfd, (bfd_vma) nlm_version_header (abfd) -> minorVersion,
+ put_word (abfd, (bfd_vma) nlm_version_header (abfd)->minorVersion,
(bfd_byte *) thdr.minorVersion);
- put_word (abfd, (bfd_vma) nlm_version_header (abfd) -> revision,
+ put_word (abfd, (bfd_vma) nlm_version_header (abfd)->revision,
(bfd_byte *) thdr.revision);
- put_word (abfd, (bfd_vma) nlm_version_header (abfd) -> year,
+ put_word (abfd, (bfd_vma) nlm_version_header (abfd)->year,
(bfd_byte *) thdr.year);
- put_word (abfd, (bfd_vma) nlm_version_header (abfd) -> month,
+ put_word (abfd, (bfd_vma) nlm_version_header (abfd)->month,
(bfd_byte *) thdr.month);
- put_word (abfd, (bfd_vma) nlm_version_header (abfd) -> day,
+ put_word (abfd, (bfd_vma) nlm_version_header (abfd)->day,
(bfd_byte *) thdr.day);
- if (bfd_write ((PTR) &thdr, sizeof (thdr), 1, abfd) != sizeof (thdr))
- {
- bfd_error = system_call_error;
- return false;
- }
+ if (bfd_bwrite ((void *) &thdr, (bfd_size_type) sizeof (thdr), abfd)
+ != sizeof (thdr))
+ return FALSE;
+ }
+
+ /* Note - the CoPyRiGhT tag is emitted before the MeSsAgEs
+ tag in order to make the NW4.x and NW5.x loaders happy. */
+
+ /* Write out the copyright header if there is one. */
+ if (find_nonzero (nlm_copyright_header (abfd),
+ sizeof (Nlm_Internal_Copyright_Header)))
+ {
+ Nlm_External_Copyright_Header thdr;
+
+ LITMEMCPY (thdr.stamp, "CoPyRiGhT=");
+ amt = sizeof (thdr.stamp);
+ if (bfd_bwrite ((void *) thdr.stamp, amt, abfd) != amt)
+ return FALSE;
+ thdr.copyrightMessageLength[0] =
+ nlm_copyright_header (abfd)->copyrightMessageLength;
+ amt = 1;
+ if (bfd_bwrite ((void *) thdr.copyrightMessageLength, amt, abfd) != amt)
+ return FALSE;
+ /* The copyright message is a variable length string. */
+ amt = nlm_copyright_header (abfd)->copyrightMessageLength + 1;
+ if (bfd_bwrite ((void *) nlm_copyright_header (abfd)->copyrightMessage,
+ amt, abfd) != amt)
+ return FALSE;
}
/* Write out the extended header if there is one. */
- if (find_nonzero ((PTR) nlm_extended_header (abfd),
+ if (find_nonzero (nlm_extended_header (abfd),
sizeof (Nlm_Internal_Extended_Header)))
{
Nlm_External_Extended_Header thdr;
- memcpy (thdr.stamp, "MeSsAgEs", 8);
+ LITMEMCPY (thdr.stamp, "MeSsAgEs");
put_word (abfd,
- (bfd_vma) nlm_extended_header (abfd) -> languageID,
+ (bfd_vma) nlm_extended_header (abfd)->languageID,
(bfd_byte *) thdr.languageID);
put_word (abfd,
- (bfd_vma) nlm_extended_header (abfd) -> messageFileOffset,
+ (bfd_vma) nlm_extended_header (abfd)->messageFileOffset,
(bfd_byte *) thdr.messageFileOffset);
put_word (abfd,
- (bfd_vma) nlm_extended_header (abfd) -> messageFileLength,
+ (bfd_vma) nlm_extended_header (abfd)->messageFileLength,
(bfd_byte *) thdr.messageFileLength);
put_word (abfd,
- (bfd_vma) nlm_extended_header (abfd) -> messageCount,
+ (bfd_vma) nlm_extended_header (abfd)->messageCount,
(bfd_byte *) thdr.messageCount);
put_word (abfd,
- (bfd_vma) nlm_extended_header (abfd) -> helpFileOffset,
+ (bfd_vma) nlm_extended_header (abfd)->helpFileOffset,
(bfd_byte *) thdr.helpFileOffset);
put_word (abfd,
- (bfd_vma) nlm_extended_header (abfd) -> helpFileLength,
+ (bfd_vma) nlm_extended_header (abfd)->helpFileLength,
(bfd_byte *) thdr.helpFileLength);
put_word (abfd,
- (bfd_vma) nlm_extended_header (abfd) -> RPCDataOffset,
+ (bfd_vma) nlm_extended_header (abfd)->RPCDataOffset,
(bfd_byte *) thdr.RPCDataOffset);
put_word (abfd,
- (bfd_vma) nlm_extended_header (abfd) -> RPCDataLength,
+ (bfd_vma) nlm_extended_header (abfd)->RPCDataLength,
(bfd_byte *) thdr.RPCDataLength);
put_word (abfd,
- (bfd_vma) nlm_extended_header (abfd) -> sharedCodeOffset,
+ (bfd_vma) nlm_extended_header (abfd)->sharedCodeOffset,
(bfd_byte *) thdr.sharedCodeOffset);
put_word (abfd,
- (bfd_vma) nlm_extended_header (abfd) -> sharedCodeLength,
+ (bfd_vma) nlm_extended_header (abfd)->sharedCodeLength,
(bfd_byte *) thdr.sharedCodeLength);
put_word (abfd,
- (bfd_vma) nlm_extended_header (abfd) -> sharedDataOffset,
+ (bfd_vma) nlm_extended_header (abfd)->sharedDataOffset,
(bfd_byte *) thdr.sharedDataOffset);
put_word (abfd,
- (bfd_vma) nlm_extended_header (abfd) -> sharedDataLength,
+ (bfd_vma) nlm_extended_header (abfd)->sharedDataLength,
(bfd_byte *) thdr.sharedDataLength);
put_word (abfd,
- (bfd_vma) nlm_extended_header (abfd) -> sharedRelocationFixupOffset,
+ (bfd_vma) nlm_extended_header (abfd)->sharedRelocationFixupOffset,
(bfd_byte *) thdr.sharedRelocationFixupOffset);
put_word (abfd,
- (bfd_vma) nlm_extended_header (abfd) -> sharedRelocationFixupCount,
+ (bfd_vma) nlm_extended_header (abfd)->sharedRelocationFixupCount,
(bfd_byte *) thdr.sharedRelocationFixupCount);
put_word (abfd,
- (bfd_vma) nlm_extended_header (abfd) -> sharedExternalReferenceOffset,
+ (bfd_vma) nlm_extended_header (abfd)->sharedExternalReferenceOffset,
(bfd_byte *) thdr.sharedExternalReferenceOffset);
put_word (abfd,
- (bfd_vma) nlm_extended_header (abfd) -> sharedExternalReferenceCount,
+ (bfd_vma) nlm_extended_header (abfd)->sharedExternalReferenceCount,
(bfd_byte *) thdr.sharedExternalReferenceCount);
put_word (abfd,
- (bfd_vma) nlm_extended_header (abfd) -> sharedPublicsOffset,
+ (bfd_vma) nlm_extended_header (abfd)->sharedPublicsOffset,
(bfd_byte *) thdr.sharedPublicsOffset);
put_word (abfd,
- (bfd_vma) nlm_extended_header (abfd) -> sharedPublicsCount,
+ (bfd_vma) nlm_extended_header (abfd)->sharedPublicsCount,
(bfd_byte *) thdr.sharedPublicsCount);
put_word (abfd,
- (bfd_vma) nlm_extended_header (abfd) -> sharedDebugRecordOffset,
+ (bfd_vma) nlm_extended_header (abfd)->sharedDebugRecordOffset,
(bfd_byte *) thdr.sharedDebugRecordOffset);
put_word (abfd,
- (bfd_vma) nlm_extended_header (abfd) -> sharedDebugRecordCount,
+ (bfd_vma) nlm_extended_header (abfd)->sharedDebugRecordCount,
(bfd_byte *) thdr.sharedDebugRecordCount);
put_word (abfd,
- (bfd_vma) nlm_extended_header (abfd) -> SharedInitializationOffset,
+ (bfd_vma) nlm_extended_header (abfd)->SharedInitializationOffset,
(bfd_byte *) thdr.sharedInitializationOffset);
put_word (abfd,
- (bfd_vma) nlm_extended_header (abfd) -> SharedExitProcedureOffset,
+ (bfd_vma) nlm_extended_header (abfd)->SharedExitProcedureOffset,
(bfd_byte *) thdr.SharedExitProcedureOffset);
put_word (abfd,
- (bfd_vma) nlm_extended_header (abfd) -> productID,
+ (bfd_vma) nlm_extended_header (abfd)->productID,
(bfd_byte *) thdr.productID);
put_word (abfd,
- (bfd_vma) nlm_extended_header (abfd) -> reserved0,
+ (bfd_vma) nlm_extended_header (abfd)->reserved0,
(bfd_byte *) thdr.reserved0);
put_word (abfd,
- (bfd_vma) nlm_extended_header (abfd) -> reserved1,
+ (bfd_vma) nlm_extended_header (abfd)->reserved1,
(bfd_byte *) thdr.reserved1);
put_word (abfd,
- (bfd_vma) nlm_extended_header (abfd) -> reserved2,
+ (bfd_vma) nlm_extended_header (abfd)->reserved2,
(bfd_byte *) thdr.reserved2);
put_word (abfd,
- (bfd_vma) nlm_extended_header (abfd) -> reserved3,
+ (bfd_vma) nlm_extended_header (abfd)->reserved3,
(bfd_byte *) thdr.reserved3);
put_word (abfd,
- (bfd_vma) nlm_extended_header (abfd) -> reserved4,
+ (bfd_vma) nlm_extended_header (abfd)->reserved4,
(bfd_byte *) thdr.reserved4);
put_word (abfd,
- (bfd_vma) nlm_extended_header (abfd) -> reserved5,
+ (bfd_vma) nlm_extended_header (abfd)->reserved5,
(bfd_byte *) thdr.reserved5);
- if (bfd_write ((PTR) &thdr, sizeof (thdr), 1, abfd) != sizeof (thdr))
- {
- bfd_error = system_call_error;
- return false;
- }
+ if (bfd_bwrite ((void *) &thdr, (bfd_size_type) sizeof (thdr), abfd)
+ != sizeof (thdr))
+ return FALSE;
}
/* Write out the custom header if there is one. */
- if (find_nonzero ((PTR) nlm_custom_header (abfd),
+ if (find_nonzero (nlm_custom_header (abfd),
sizeof (Nlm_Internal_Custom_Header)))
{
Nlm_External_Custom_Header thdr;
-
- /* Right now we assume the custom header is always the suggested
- format for alternate debugging records. */
- BFD_ASSERT (nlm_custom_header (abfd) -> dataLength == 8);
-
- memcpy (thdr.stamp, "CuStHeAd", 8);
- put_word (abfd, (bfd_vma) nlm_custom_header (abfd) -> dataLength,
- (bfd_byte *) thdr.dataLength);
- put_word (abfd, (bfd_vma) nlm_custom_header (abfd) -> debugRecOffset,
- (bfd_byte *) thdr.debugRecOffset);
- put_word (abfd, (bfd_vma) nlm_custom_header (abfd) -> debugRecLength,
- (bfd_byte *) thdr.debugRecLength);
- if (bfd_write ((PTR) &thdr, sizeof (thdr), 1, abfd) != sizeof (thdr))
- {
- bfd_error = system_call_error;
- return false;
- }
- }
-
- /* Write out the copyright header if there is one. */
- if (find_nonzero ((PTR) nlm_copyright_header (abfd),
- sizeof (Nlm_Internal_Copyright_Header)))
- {
- Nlm_External_Copyright_Header thdr;
-
- memcpy (thdr.stamp, "CoPyRiGhT=", 10);
- if (bfd_write ((PTR) thdr.stamp, sizeof (thdr.stamp), 1, abfd)
- != sizeof (thdr.stamp))
+ bfd_boolean ds;
+ bfd_size_type hdrLength;
+
+ ds = find_nonzero (nlm_custom_header (abfd)->dataStamp,
+ sizeof (nlm_custom_header (abfd)->dataStamp));
+ LITMEMCPY (thdr.stamp, "CuStHeAd");
+ hdrLength = (2 * NLM_TARGET_LONG_SIZE + (ds ? 8 : 0)
+ + nlm_custom_header (abfd)->hdrLength);
+ put_word (abfd, hdrLength, thdr.length);
+ put_word (abfd, (bfd_vma) nlm_custom_header (abfd)->dataOffset,
+ thdr.dataOffset);
+ put_word (abfd, (bfd_vma) nlm_custom_header (abfd)->dataLength,
+ thdr.dataLength);
+ if (! ds)
{
- bfd_error = system_call_error;
- return false;
+ BFD_ASSERT (nlm_custom_header (abfd)->hdrLength == 0);
+ amt = sizeof (thdr) - sizeof (thdr.dataStamp);
+ if (bfd_bwrite ((void *) &thdr, amt, abfd) != amt)
+ return FALSE;
}
- thdr.copyrightMessageLength[0] =
- nlm_copyright_header (abfd)->copyrightMessageLength;
- if (bfd_write ((PTR) thdr.copyrightMessageLength, 1, 1, abfd) != 1)
- {
- bfd_error = system_call_error;
- return false;
- }
- /* The copyright message is a variable length string. */
- if (bfd_write ((PTR) nlm_copyright_header (abfd) -> copyrightMessage,
- nlm_copyright_header (abfd) -> copyrightMessageLength + 1,
- 1, abfd) !=
- nlm_copyright_header (abfd) -> copyrightMessageLength + 1)
+ else
{
- bfd_error = system_call_error;
- return false;
+ memcpy (thdr.dataStamp, nlm_custom_header (abfd)->dataStamp,
+ sizeof (thdr.dataStamp));
+ amt = sizeof (thdr);
+ if (bfd_bwrite ((void *) &thdr, amt, abfd) != amt)
+ return FALSE;
+ amt = nlm_custom_header (abfd)->hdrLength;
+ if (bfd_bwrite (nlm_custom_header (abfd)->hdr, amt, abfd) != amt)
+ return FALSE;
}
}
- return true;
+ /* Write out the Cygnus debugging header if there is one. */
+ if (find_nonzero (nlm_cygnus_ext_header (abfd),
+ sizeof (Nlm_Internal_Cygnus_Ext_Header)))
+ {
+ Nlm_External_Custom_Header thdr;
+
+ LITMEMCPY (thdr.stamp, "CuStHeAd");
+ put_word (abfd, (bfd_vma) 2 * NLM_TARGET_LONG_SIZE + 8,
+ (bfd_byte *) thdr.length);
+ put_word (abfd, (bfd_vma) nlm_cygnus_ext_header (abfd)->offset,
+ (bfd_byte *) thdr.dataOffset);
+ put_word (abfd, (bfd_vma) nlm_cygnus_ext_header (abfd)->length,
+ (bfd_byte *) thdr.dataLength);
+ LITMEMCPY (thdr.dataStamp, "CyGnUsEx");
+ amt = sizeof (thdr);
+ if (bfd_bwrite ((void *) &thdr, amt, abfd) != amt)
+ return FALSE;
+ }
+
+ return TRUE;
}
/* We read the NLM's public symbols and use it to generate a bfd symbol
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. */
+ on this size. */
-unsigned int
-DEFUN (nlm_get_symtab_upper_bound, (abfd), bfd * abfd)
+long
+nlm_get_symtab_upper_bound (bfd *abfd)
{
- Nlm_Internal_Fixed_Header *i_fxdhdrp; /* Nlm file header, internal form */
- unsigned int symcount;
- unsigned int symtab_size = 0;
+ Nlm_Internal_Fixed_Header *i_fxdhdrp; /* Nlm file header, internal form. */
+ long symcount;
+ long symtab_size = 0;
i_fxdhdrp = nlm_fixed_header (abfd);
- symcount = (i_fxdhdrp -> numberOfPublics
- + i_fxdhdrp -> numberOfDebugRecords
- + i_fxdhdrp -> numberOfExternalReferences);
+ symcount = (i_fxdhdrp->numberOfPublics
+ + i_fxdhdrp->numberOfDebugRecords
+ + i_fxdhdrp->numberOfExternalReferences);
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
-nlm_get_symtab (abfd, alocation)
- bfd *abfd;
- asymbol **alocation;
-{
- nlm_symbol_type *symbase;
- bfd_size_type counter = 0;
-
- if (nlm_slurp_symbol_table (abfd) == false)
- return 0;
- symbase = nlm_get_symbols (abfd);
- while (counter < bfd_get_symcount (abfd))
- {
- *alocation++ = &symbase->symbol;
- symbase++;
- counter++;
- }
- *alocation = (asymbol *) NULL;
- return bfd_get_symcount (abfd);
-}
-
-/* Make an NLM symbol. There is nothing special to do here. */
-
-asymbol *
-nlm_make_empty_symbol (abfd)
- bfd * abfd;
-{
- nlm_symbol_type *new;
-
- new = (nlm_symbol_type *) bfd_zalloc (abfd, sizeof (nlm_symbol_type));
- new->symbol.the_bfd = abfd;
- return &new->symbol;
-}
-
-/* Get symbol information. */
-
-void
-nlm_get_symbol_info (ignore_abfd, symbol, ret)
- bfd * ignore_abfd;
- asymbol * symbol;
- symbol_info * ret;
-{
- bfd_symbol_info (symbol, ret);
-}
-
-/* Print symbol information. */
-
-void
-nlm_print_symbol (abfd, afile, symbol, how)
- bfd *abfd;
- PTR afile;
- asymbol *symbol;
- bfd_print_symbol_type how;
-{
- FILE *file = (FILE *) afile;
-
- switch (how)
- {
- case bfd_print_symbol_name:
- case bfd_print_symbol_more:
- if (symbol->name)
- fprintf (file,"%s", symbol->name);
- break;
- case bfd_print_symbol_all:
- bfd_print_symbol_vandf ((PTR) file, symbol);
- fprintf (file, " %-5s", symbol->section->name);
- if (symbol->name)
- fprintf (file," %s", symbol->name);
- break;
- }
+ return symtab_size;
}
/* Slurp in nlm symbol table.
records we also read in the associated reloc information, which is
attached to the symbol.
- The bfd symbols are copied to SYMPTRS.
+ The bfd symbols are copied to SYMvoid *S.
When we return, the bfd symcount is either zero or contains the correct
- number of symbols.
-*/
+ number of symbols. */
-static boolean
-nlm_slurp_symbol_table (abfd)
- bfd *abfd;
+static bfd_boolean
+nlm_slurp_symbol_table (bfd *abfd)
{
- Nlm_Internal_Fixed_Header *i_fxdhdrp; /* Nlm file header, internal form */
- bfd_size_type totsymcount; /* Number of NLM symbols */
- bfd_size_type symcount; /* Counter of NLM symbols */
- nlm_symbol_type *sym; /* Pointer to current bfd symbol */
- unsigned char symlength; /* Symbol length read into here */
- unsigned char symtype; /* Type of debugging symbol */
- bfd_byte temp[NLM_TARGET_LONG_SIZE]; /* Symbol offsets read into here */
- boolean (*read_import_func) PARAMS ((bfd *, nlm_symbol_type *));
- boolean (*set_public_section_func) PARAMS ((bfd *, nlm_symbol_type *));
+ Nlm_Internal_Fixed_Header *i_fxdhdrp; /* Nlm file header, internal form. */
+ bfd_size_type totsymcount; /* Number of NLM symbols. */
+ bfd_size_type symcount; /* Counter of NLM symbols. */
+ nlm_symbol_type *sym; /* Pointer to current bfd symbol. */
+ unsigned char symlength; /* Symbol length read into here. */
+ unsigned char symtype; /* Type of debugging symbol. */
+ bfd_byte temp[NLM_TARGET_LONG_SIZE]; /* Symbol offsets read into here. */
+ bfd_boolean (*read_import_func) (bfd *, nlm_symbol_type *);
+ bfd_boolean (*set_public_section_func) (bfd *, nlm_symbol_type *);
+ bfd_size_type amt;
if (nlm_get_symbols (abfd) != NULL)
- return (true);
+ 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. */
+ When we have all the symbols, we build the caller's pointer vector. */
- abfd -> symcount = 0;
+ abfd->symcount = 0;
i_fxdhdrp = nlm_fixed_header (abfd);
- totsymcount = (i_fxdhdrp -> numberOfPublics
- + i_fxdhdrp -> numberOfDebugRecords
- + i_fxdhdrp -> numberOfExternalReferences);
+ totsymcount = (i_fxdhdrp->numberOfPublics
+ + i_fxdhdrp->numberOfDebugRecords
+ + i_fxdhdrp->numberOfExternalReferences);
if (totsymcount == 0)
- {
- return (true);
- }
+ return TRUE;
- if (bfd_seek (abfd, i_fxdhdrp -> publicsOffset, SEEK_SET) == -1)
- {
- bfd_error = system_call_error;
- return (false);
- }
+ if (bfd_seek (abfd, i_fxdhdrp->publicsOffset, SEEK_SET) != 0)
+ return FALSE;
- sym = ((nlm_symbol_type *)
- bfd_zalloc (abfd, totsymcount * sizeof (nlm_symbol_type)));
+ amt = totsymcount * sizeof (nlm_symbol_type);
+ sym = bfd_zalloc (abfd, amt);
+ if (!sym)
+ return FALSE;
nlm_set_symbols (abfd, sym);
/* 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. */
+ were read. */
set_public_section_func = nlm_set_public_section_func (abfd);
- symcount = i_fxdhdrp -> numberOfPublics;
- while (abfd -> symcount < symcount)
+ symcount = i_fxdhdrp->numberOfPublics;
+ 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);
- }
+ amt = sizeof (symlength);
+ if (bfd_bread ((void *) &symlength, amt, abfd) != amt)
+ return FALSE;
+ amt = symlength;
+ sym->symbol.the_bfd = abfd;
+ sym->symbol.name = bfd_alloc (abfd, amt + 1);
+ if (!sym->symbol.name)
+ return FALSE;
+ if (bfd_bread ((void *) sym->symbol.name, amt, abfd) != amt)
+ return FALSE;
/* Cast away const. */
- ((char *) (sym -> symbol.name))[symlength] = '\0';
- if (bfd_read ((PTR) temp, sizeof (temp), 1, abfd) != sizeof (temp))
- {
- bfd_error = system_call_error;
- return (false);
- }
- sym -> symbol.flags = BSF_GLOBAL | BSF_EXPORT;
- sym -> symbol.value = get_word (abfd, temp);
+ ((char *) (sym->symbol.name))[symlength] = '\0';
+ amt = sizeof (temp);
+ if (bfd_bread ((void *) temp, amt, abfd) != amt)
+ return FALSE;
+ sym->symbol.flags = BSF_GLOBAL | BSF_EXPORT;
+ sym->symbol.value = get_word (abfd, temp);
if (set_public_section_func)
{
/* Most backends can use the code below, but unfortunately
some use a different scheme. */
- if ((*set_public_section_func) (abfd, sym) == false)
- return false;
+ if (! (*set_public_section_func) (abfd, sym))
+ return FALSE;
}
else
{
- if (sym -> symbol.value & NLM_HIBIT)
+ if (sym->symbol.value & NLM_HIBIT)
{
- sym -> symbol.value &= ~NLM_HIBIT;
- sym -> symbol.flags |= BSF_FUNCTION;
- sym -> symbol.section =
+ sym->symbol.value &= ~NLM_HIBIT;
+ 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);
- }
+ sym->symbol.section =
+ bfd_get_section_by_name (abfd, NLM_INITIALIZED_DATA_NAME);
}
- sym -> rcnt = 0;
- abfd -> symcount++;
+ sym->rcnt = 0;
+ abfd->symcount++;
sym++;
}
/* Read the debugging records. */
- if (i_fxdhdrp -> numberOfDebugRecords > 0)
+ if (i_fxdhdrp->numberOfDebugRecords > 0)
{
- if (bfd_seek (abfd, i_fxdhdrp -> debugInfoOffset, SEEK_SET) == -1)
- {
- bfd_error = system_call_error;
- return (false);
- }
+ if (bfd_seek (abfd, i_fxdhdrp->debugInfoOffset, SEEK_SET) != 0)
+ return FALSE;
- symcount += i_fxdhdrp -> numberOfDebugRecords;
- while (abfd -> symcount < symcount)
+ symcount += i_fxdhdrp->numberOfDebugRecords;
+ while (abfd->symcount < symcount)
{
- if ((bfd_read ((PTR) &symtype, sizeof (symtype), 1, abfd)
- != sizeof (symtype))
- || bfd_read ((PTR) temp, sizeof (temp), 1, abfd) != sizeof (temp)
- || (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);
- }
+ amt = sizeof (symtype);
+ if (bfd_bread ((void *) &symtype, amt, abfd) != amt)
+ return FALSE;
+ amt = sizeof (temp);
+ if (bfd_bread ((void *) temp, amt, abfd) != amt)
+ return FALSE;
+ amt = sizeof (symlength);
+ if (bfd_bread ((void *) &symlength, amt, abfd) != amt)
+ return FALSE;
+ amt = symlength;
+ sym->symbol.the_bfd = abfd;
+ sym->symbol.name = bfd_alloc (abfd, amt + 1);
+ if (!sym->symbol.name)
+ return FALSE;
+ if (bfd_bread ((void *) sym->symbol.name, amt, abfd) != amt)
+ return FALSE;
/* Cast away const. */
- ((char *) (sym -> symbol.name))[symlength] = '\0';
- sym -> symbol.flags = BSF_LOCAL;
- sym -> symbol.value = get_word (abfd, temp);
+ ((char *) (sym->symbol.name))[symlength] = '\0';
+ sym->symbol.flags = BSF_LOCAL;
+ sym->symbol.value = get_word (abfd, temp);
+
if (symtype == 0)
- {
- sym -> symbol.section =
- bfd_get_section_by_name (abfd, NLM_INITIALIZED_DATA_NAME);
- }
+ sym->symbol.section =
+ bfd_get_section_by_name (abfd, NLM_INITIALIZED_DATA_NAME);
else if (symtype == 1)
{
- sym -> symbol.flags |= BSF_FUNCTION;
- sym -> symbol.section =
+ sym->symbol.flags |= BSF_FUNCTION;
+ sym->symbol.section =
bfd_get_section_by_name (abfd, NLM_CODE_NAME);
}
else
- {
- sym -> symbol.section = &bfd_abs_section;
- }
- sym -> rcnt = 0;
- abfd -> symcount++;
+ sym->symbol.section = bfd_abs_section_ptr;
+
+ sym->rcnt = 0;
+ abfd->symcount++;
sym++;
}
}
/* Read in the import records. We can only do this if we know how
to read relocs for this target. */
-
read_import_func = nlm_read_import_func (abfd);
if (read_import_func != NULL)
{
- if (bfd_seek (abfd, i_fxdhdrp -> externalReferencesOffset, SEEK_SET)
- == -1)
- {
- bfd_error = system_call_error;
- return (false);
- }
-
- symcount += i_fxdhdrp -> numberOfExternalReferences;
- while (abfd -> symcount < symcount)
+ if (bfd_seek (abfd, i_fxdhdrp->externalReferencesOffset, SEEK_SET) != 0)
+ return FALSE;
+
+ symcount += i_fxdhdrp->numberOfExternalReferences;
+ while (abfd->symcount < symcount)
{
- if ((*read_import_func) (abfd, sym) == false)
- return false;
+ if (! (*read_import_func) (abfd, sym))
+ return FALSE;
sym++;
abfd->symcount++;
}
}
- return (true);
+ return TRUE;
+}
+
+/* Note that bfd_get_symcount is guaranteed to be zero if slurping the
+ symbol table fails. */
+
+long
+nlm_canonicalize_symtab (bfd *abfd, asymbol **alocation)
+{
+ nlm_symbol_type *symbase;
+ bfd_size_type counter = 0;
+
+ if (! nlm_slurp_symbol_table (abfd))
+ return -1;
+ symbase = nlm_get_symbols (abfd);
+ while (counter < bfd_get_symcount (abfd))
+ {
+ *alocation++ = &symbase->symbol;
+ symbase++;
+ counter++;
+ }
+ *alocation = NULL;
+ return bfd_get_symcount (abfd);
+}
+
+/* Make an NLM symbol. There is nothing special to do here. */
+
+asymbol *
+nlm_make_empty_symbol (bfd *abfd)
+{
+ bfd_size_type amt = sizeof (nlm_symbol_type);
+ nlm_symbol_type *new = bfd_zalloc (abfd, amt);
+
+ if (new == NULL)
+ return NULL;
+ new->symbol.the_bfd = abfd;
+ return & new->symbol;
+}
+
+/* Get symbol information. */
+
+void
+nlm_get_symbol_info (bfd *ignore_abfd ATTRIBUTE_UNUSED,
+ asymbol *symbol,
+ symbol_info *ret)
+{
+ bfd_symbol_info (symbol, ret);
+}
+
+/* Print symbol information. */
+
+void
+nlm_print_symbol (bfd *abfd,
+ void * afile,
+ asymbol *symbol,
+ bfd_print_symbol_type how)
+{
+ FILE *file = (FILE *) afile;
+
+ switch (how)
+ {
+ case bfd_print_symbol_name:
+ case bfd_print_symbol_more:
+ if (symbol->name)
+ fprintf (file, "%s", symbol->name);
+ break;
+ case bfd_print_symbol_all:
+ bfd_print_symbol_vandf (abfd, (void *) file, symbol);
+ fprintf (file, " %-5s", symbol->section->name);
+ if (symbol->name)
+ fprintf (file, " %s", symbol->name);
+ break;
+ }
}
\f
/* Get the relocs for an NLM file. There are two types of relocs.
section pointers are needed because the relocs are not sorted by
section. */
-static boolean
-nlm_slurp_reloc_fixups (abfd)
- bfd *abfd;
+static bfd_boolean
+nlm_slurp_reloc_fixups (bfd *abfd)
{
- boolean (*read_func) PARAMS ((bfd *, nlm_symbol_type *, asection **,
- arelent *));
- bfd_size_type count;
+ bfd_boolean (*read_func) (bfd *, nlm_symbol_type *, asection **, arelent *);
+ bfd_size_type count, amt;
arelent *rels;
asection **secs;
if (nlm_relocation_fixups (abfd) != NULL)
- return true;
+ return TRUE;
read_func = nlm_read_reloc_func (abfd);
if (read_func == NULL)
- return true;
+ return TRUE;
if (bfd_seek (abfd, nlm_fixed_header (abfd)->relocationFixupOffset,
SEEK_SET) != 0)
- {
- bfd_error = system_call_error;
- return false;
- }
+ return FALSE;
count = nlm_fixed_header (abfd)->numberOfRelocationFixups;
- rels = (arelent *) bfd_alloc (abfd, count * sizeof (arelent));
- secs = (asection **) bfd_alloc (abfd, count * sizeof (asection *));
- if (rels == NULL || secs == NULL)
- {
- bfd_error = no_memory;
- return false;
- }
+ amt = count * sizeof (arelent);
+ rels = bfd_alloc (abfd, amt);
+ amt = count * sizeof (asection *);
+ secs = bfd_alloc (abfd, amt);
+ if ((rels == NULL || secs == NULL) && count != 0)
+ return FALSE;
nlm_relocation_fixups (abfd) = rels;
nlm_relocation_fixup_secs (abfd) = secs;
the machine specific reloc information is. */
while (count-- != 0)
{
- if ((*read_func) (abfd, (nlm_symbol_type *) NULL, secs, rels) == false)
+ if (! (*read_func) (abfd, NULL, secs, rels))
{
nlm_relocation_fixups (abfd) = NULL;
nlm_relocation_fixup_secs (abfd) = NULL;
- return false;
+ return FALSE;
}
++secs;
++rels;
}
- return true;
+ return TRUE;
}
/* Get the number of relocs. This really just returns an upper bound,
since it does not attempt to distinguish them based on the section.
That will be handled when they are actually read. */
-unsigned int
-nlm_get_reloc_upper_bound (abfd, sec)
- bfd *abfd;
- asection *sec;
+long
+nlm_get_reloc_upper_bound (bfd *abfd, asection *sec)
{
nlm_symbol_type *syms;
bfd_size_type count;
/* If we don't know how to read relocs, just return 0. */
if (nlm_read_reloc_func (abfd) == NULL)
- return 0;
+ return -1;
/* Make sure we have either the code or the data section. */
if ((bfd_get_section_flags (abfd, sec) & (SEC_CODE | SEC_DATA)) == 0)
return 0;
syms = nlm_get_symbols (abfd);
if (syms == NULL)
{
- if (nlm_slurp_symbol_table (abfd) == false)
- return 0;
+ if (! nlm_slurp_symbol_table (abfd))
+ return -1;
syms = nlm_get_symbols (abfd);
}
/* Get the relocs themselves. */
-unsigned int
-nlm_canonicalize_reloc (abfd, sec, relptr, symbols)
- bfd *abfd;
- asection *sec;
- arelent **relptr;
- asymbol **symbols;
+long
+nlm_canonicalize_reloc (bfd *abfd,
+ asection *sec,
+ arelent **relptr,
+ asymbol **symbols)
{
arelent *rels;
asection **secs;
bfd_size_type count, i;
- unsigned int ret;
+ long ret;
/* Get the relocation fixups. */
rels = nlm_relocation_fixups (abfd);
if (rels == NULL)
{
- if (nlm_slurp_reloc_fixups (abfd) == false)
- return 0;
+ if (! nlm_slurp_reloc_fixups (abfd))
+ return -1;
rels = nlm_relocation_fixups (abfd);
- if (rels == NULL)
- return 0;
}
secs = nlm_relocation_fixup_secs (abfd);
*relptr = NULL;
- return ret;
+ return ret;
}
\f
/* Compute the section file positions for an NLM file. All variable
move the symbols at this point so that mangle_relocs can see the
final values. */
-static boolean
-nlm_compute_section_file_positions (abfd)
- bfd *abfd;
+static bfd_boolean
+nlm_compute_section_file_positions (bfd *abfd)
{
file_ptr sofar;
asection *sec;
bfd_vma text, data, bss;
bfd_vma text_low, data_low;
- int text_align, data_align, other_align;
+ unsigned int text_align, data_align, other_align;
file_ptr text_ptr, data_ptr, other_ptr;
asection *bss_sec;
asymbol **sym_ptr_ptr;
- if (abfd->output_has_begun == true)
- return true;
+ if (abfd->output_has_begun)
+ return TRUE;
/* Make sure we have a section to hold uninitialized data. */
bss_sec = bfd_get_section_by_name (abfd, NLM_UNINITIALIZED_DATA_NAME);
if (bss_sec == NULL)
{
- if (! add_bfd_section (abfd, NLM_UNINITIALIZED_DATA_NAME,
- (file_ptr) 0, (bfd_size_type) 0,
- SEC_ALLOC))
- return false;
+ if (!add_bfd_section (abfd, NLM_UNINITIALIZED_DATA_NAME,
+ (file_ptr) 0, (bfd_size_type) 0,
+ SEC_ALLOC))
+ return FALSE;
bss_sec = bfd_get_section_by_name (abfd, NLM_UNINITIALIZED_DATA_NAME);
}
- abfd->output_has_begun = true;
+ abfd->output_has_begun = TRUE;
/* The fixed header. */
sofar = nlm_optional_prefix_size (abfd) + nlm_fixed_header_size (abfd);
/* The variable header. */
sofar += (sizeof (nlm_variable_header (abfd)->descriptionLength)
- + nlm_variable_header (abfd) -> descriptionLength + 1
- + NLM_TARGET_LONG_SIZE /* stackSize */
- + NLM_TARGET_LONG_SIZE /* reserved */
- + sizeof (nlm_variable_header (abfd) -> oldThreadName)
- + sizeof (nlm_variable_header (abfd) -> screenNameLength)
- + nlm_variable_header (abfd) -> screenNameLength + 1
- + sizeof (nlm_variable_header (abfd) -> threadNameLength)
- + nlm_variable_header (abfd) -> threadNameLength + 1);
+ + nlm_variable_header (abfd)->descriptionLength + 1
+ + NLM_TARGET_LONG_SIZE /* stackSize */
+ + NLM_TARGET_LONG_SIZE /* reserved */
+ + sizeof (nlm_variable_header (abfd)->oldThreadName)
+ + sizeof (nlm_variable_header (abfd)->screenNameLength)
+ + nlm_variable_header (abfd)->screenNameLength + 1
+ + sizeof (nlm_variable_header (abfd)->threadNameLength)
+ + nlm_variable_header (abfd)->threadNameLength + 1);
/* The auxiliary headers. */
- if (find_nonzero ((PTR) nlm_version_header (abfd),
+ if (find_nonzero (nlm_version_header (abfd),
sizeof (Nlm_Internal_Version_Header)))
sofar += sizeof (Nlm_External_Version_Header);
- if (find_nonzero ((PTR) nlm_extended_header (abfd),
+ if (find_nonzero (nlm_extended_header (abfd),
sizeof (Nlm_Internal_Extended_Header)))
sofar += sizeof (Nlm_External_Extended_Header);
- if (find_nonzero ((PTR) nlm_custom_header (abfd),
- sizeof (Nlm_Internal_Custom_Header)))
- sofar += sizeof (Nlm_External_Custom_Header);
- if (find_nonzero ((PTR) nlm_copyright_header (abfd),
+ if (find_nonzero (nlm_copyright_header (abfd),
sizeof (Nlm_Internal_Copyright_Header)))
sofar += (sizeof (Nlm_External_Copyright_Header)
- + nlm_copyright_header (abfd) -> copyrightMessageLength + 1);
+ + nlm_copyright_header (abfd)->copyrightMessageLength + 1);
+ if (find_nonzero (nlm_custom_header (abfd),
+ sizeof (Nlm_Internal_Custom_Header)))
+ sofar += (sizeof (Nlm_External_Custom_Header)
+ + nlm_custom_header (abfd)->hdrLength);
+ if (find_nonzero (nlm_cygnus_ext_header (abfd),
+ sizeof (Nlm_Internal_Cygnus_Ext_Header)))
+ sofar += sizeof (Nlm_External_Custom_Header);
/* Compute the section file positions in two passes. First get the
sizes of the text and data sections, and then set the file
same alignment restrictions that apply to the sections in memory;
this may not be necessary. */
text = 0;
- text_low = (bfd_vma) -1;
+ text_low = (bfd_vma) - 1;
text_align = 0;
data = 0;
- data_low = (bfd_vma) -1;
+ data_low = (bfd_vma) - 1;
data_align = 0;
bss = 0;
other_align = 0;
- for (sec = abfd->sections; sec != (asection *) NULL; sec = sec->next)
+ for (sec = abfd->sections; sec != NULL; sec = sec->next)
{
flagword f;
- sec->_raw_size = BFD_ALIGN (sec->_raw_size, 1 << sec->alignment_power);
+ sec->size = BFD_ALIGN (sec->size, 1 << sec->alignment_power);
f = bfd_get_section_flags (abfd, sec);
if (f & SEC_CODE)
{
- text += sec->_raw_size;
+ text += sec->size;
if (bfd_get_section_vma (abfd, sec) < text_low)
text_low = bfd_get_section_vma (abfd, sec);
if (sec->alignment_power > text_align)
}
else if (f & SEC_DATA)
{
- data += sec->_raw_size;
+ data += sec->size;
if (bfd_get_section_vma (abfd, sec) < data_low)
data_low = bfd_get_section_vma (abfd, sec);
if (sec->alignment_power > data_align)
other_align = sec->alignment_power;
}
else if (f & SEC_ALLOC)
- bss += sec->_raw_size;
+ bss += sec->size;
}
nlm_set_text_low (abfd, text_low);
nlm_set_data_low (abfd, data_low);
+ if (nlm_no_uninitialized_data (abfd))
+ {
+ /* This NetWare format does not use uninitialized data. We must
+ increase the size of the data section. We will never wind up
+ writing those file locations, so they will remain zero. */
+ data += bss;
+ bss = 0;
+ }
+
text_ptr = BFD_ALIGN (sofar, 1 << text_align);
data_ptr = BFD_ALIGN (text_ptr + text, 1 << data_align);
other_ptr = BFD_ALIGN (data_ptr + data, 1 << other_align);
nlm_fixed_header (abfd)->dataImageSize = data;
nlm_fixed_header (abfd)->uninitializedDataSize = bss;
- for (sec = abfd->sections; sec != (asection *) NULL; sec = sec->next)
+ for (sec = abfd->sections; sec != NULL; sec = sec->next)
{
flagword f;
if (f & SEC_CODE)
{
sec->filepos = text_ptr;
- text_ptr += sec->_raw_size;
+ text_ptr += sec->size;
}
else if (f & SEC_DATA)
{
sec->filepos = data_ptr;
- data_ptr += sec->_raw_size;
+ data_ptr += sec->size;
}
else if (f & SEC_HAS_CONTENTS)
{
sec->filepos = other_ptr;
- other_ptr += sec->_raw_size;
+ other_ptr += sec->size;
}
}
sym = *sym_ptr_ptr;
- if (! bfd_is_com_section (bfd_get_section (sym)))
+ if (!bfd_is_com_section (bfd_get_section (sym)))
continue;
/* Put the common symbol in the .bss section, and increase
symbol (which is the old value of the symbol). */
sym->section = bss_sec;
size = sym->value;
- sym->value = bss_sec->_raw_size + add;
+ sym->value = bss_sec->size + add;
add += size;
add = BFD_ALIGN (add, 1 << bss_sec->alignment_power);
}
- nlm_fixed_header (abfd)->uninitializedDataSize += add;
- bss_sec->_raw_size += add;
+ if (add != 0)
+ {
+ if (nlm_no_uninitialized_data (abfd))
+ {
+ /* We could handle this case, but so far it hasn't been
+ necessary. */
+ abort ();
+ }
+ nlm_fixed_header (abfd)->uninitializedDataSize += add;
+ bss_sec->size += add;
+ }
}
- return true;
+ return TRUE;
}
/* Set the contents of a section. To do this we need to know where
that the sizes of all the sections must be set, and all the
variable size header information must be known. */
-boolean
-nlm_set_section_contents (abfd, section, location, offset, count)
- bfd *abfd;
- asection *section;
- PTR location;
- file_ptr offset;
- bfd_size_type count;
+bfd_boolean
+nlm_set_section_contents (bfd *abfd,
+ asection *section,
+ const void * location,
+ file_ptr offset,
+ bfd_size_type count)
{
- if (abfd->output_has_begun == false
- && nlm_compute_section_file_positions (abfd) == false)
- return false;
+ if (! abfd->output_has_begun
+ && ! nlm_compute_section_file_positions (abfd))
+ return FALSE;
if (count == 0)
- return true;
+ return TRUE;
/* i386 NetWare has a very restricted set of relocs. In order for
objcopy to work, the NLM i386 backend needs a chance to rework
the relocs are already acceptable, this will not do anything. */
if (section->reloc_count != 0)
{
- boolean (*mangle_relocs_func) PARAMS ((bfd *, asection *, PTR,
- bfd_vma, bfd_size_type));
+ bfd_boolean (*mangle_relocs_func)
+ (bfd *, asection *, const void *, bfd_vma, bfd_size_type);
mangle_relocs_func = nlm_mangle_relocs_func (abfd);
if (mangle_relocs_func != NULL)
{
- if (! (*mangle_relocs_func) (abfd, section, location,
- (bfd_vma) offset, count))
- return false;
+ if (!(*mangle_relocs_func) (abfd, section, location,
+ (bfd_vma) offset, count))
+ return FALSE;
}
}
- if (bfd_seek (abfd, (file_ptr) (section->filepos + offset), SEEK_SET) != 0
- || bfd_write (location, 1, count, abfd) != count)
- {
- bfd_error = system_call_error;
- return false;
- }
+ if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0
+ || bfd_bwrite (location, count, abfd) != count)
+ return FALSE;
- return true;
+ return TRUE;
}
/* We need to sort a list of relocs associated with sections when we
write out the external relocs. */
static int
-nlm_external_reloc_compare (p1, p2)
- const void *p1;
- const void *p2;
+nlm_external_reloc_compare (const void *p1, const void *p2)
{
const struct reloc_and_sec *r1 = (const struct reloc_and_sec *) p1;
const struct reloc_and_sec *r2 = (const struct reloc_and_sec *) p2;
+ int cmp;
+
+ cmp = strcmp ((*r1->rel->sym_ptr_ptr)->name,
+ (*r2->rel->sym_ptr_ptr)->name);
+ if (cmp != 0)
+ return cmp;
- return strcmp ((*r1->rel->sym_ptr_ptr)->name,
- (*r2->rel->sym_ptr_ptr)->name);
+ /* We sort by address within symbol to make the sort more stable and
+ increase the chances that different hosts will generate bit for
+ bit equivalent results. */
+ return (int) (r1->rel->address - r2->rel->address);
}
/* Write out an NLM file. We write out the information in this order:
section. The exports and debugging records are obtained from the
list of outsymbols. */
-boolean
-nlm_write_object_contents (abfd)
- bfd *abfd;
+bfd_boolean
+nlm_write_object_contents (bfd *abfd)
{
asection *sec;
- boolean (*write_import_func) PARAMS ((bfd *, asection *, arelent *));
+ bfd_boolean (*write_import_func) (bfd *, asection *, arelent *);
bfd_size_type external_reloc_count, internal_reloc_count, i, c;
struct reloc_and_sec *external_relocs;
asymbol **sym_ptr_ptr;
file_ptr last;
- boolean (*write_prefix_func) PARAMS ((bfd *));
- unsigned char *fixed_header = alloca (nlm_fixed_header_size (abfd));
+ bfd_boolean (*write_prefix_func) (bfd *);
+ unsigned char *fixed_header = NULL;
+ file_ptr pos;
+ bfd_size_type amt;
- if (abfd->output_has_begun == false
- && nlm_compute_section_file_positions (abfd) == false)
- return false;
+ fixed_header = bfd_malloc (nlm_fixed_header_size (abfd));
+ if (fixed_header == NULL)
+ goto error_return;
+
+ if (! abfd->output_has_begun
+ && ! nlm_compute_section_file_positions (abfd))
+ goto error_return;
/* Write out the variable length headers. */
- if (bfd_seek (abfd,
- nlm_optional_prefix_size (abfd) + nlm_fixed_header_size (abfd),
- SEEK_SET) != 0)
+ pos = nlm_optional_prefix_size (abfd) + nlm_fixed_header_size (abfd);
+ if (bfd_seek (abfd, pos, SEEK_SET) != 0)
+ goto error_return;
+ if (! nlm_swap_variable_header_out (abfd)
+ || ! nlm_swap_auxiliary_headers_out (abfd))
{
- bfd_error = system_call_error;
- return false;
- }
- if (nlm_swap_variable_header_out (abfd) == false
- || nlm_swap_auxiliary_headers_out (abfd) == false)
- {
- bfd_error = system_call_error;
- return false;
+ bfd_set_error (bfd_error_system_call);
+ goto error_return;
}
/* A weak check on whether the section file positions were
reasonable. */
if (bfd_tell (abfd) > nlm_fixed_header (abfd)->codeImageOffset)
{
- bfd_error = invalid_operation;
- return false;
+ bfd_set_error (bfd_error_invalid_operation);
+ goto error_return;
}
/* Advance to the relocs. */
if (bfd_seek (abfd, nlm_fixed_header (abfd)->relocationFixupOffset,
SEEK_SET) != 0)
- {
- bfd_error = system_call_error;
- return false;
- }
+ goto error_return;
/* The format of the relocation entries is dependent upon the
particular target. We use an external routine to write the reloc
needed when they are written out below. */
internal_reloc_count = 0;
external_reloc_count = 0;
- for (sec = abfd->sections; sec != (asection *) NULL; sec = sec->next)
+ for (sec = abfd->sections; sec != NULL; sec = sec->next)
{
arelent **rel_ptr_ptr, **rel_end;
if (sec->reloc_count == 0)
continue;
- /* We can only represent relocs within a code or data
+ /* We can only represent relocs within a code or data
section. We ignore them for a debugging section. */
if ((bfd_get_section_flags (abfd, sec) & (SEC_CODE | SEC_DATA)) == 0)
continue;
/* We need to know how to write out imports */
if (write_import_func == NULL)
{
- bfd_error = invalid_operation;
- return false;
+ bfd_set_error (bfd_error_invalid_operation);
+ goto error_return;
}
rel_ptr_ptr = sec->orelocation;
rel = *rel_ptr_ptr;
sym = *rel->sym_ptr_ptr;
- if (bfd_get_section (sym) != &bfd_und_section)
+ if (! bfd_is_und_section (bfd_get_section (sym)))
{
++internal_reloc_count;
- if ((*write_import_func) (abfd, sec, rel) == false)
- return false;
+ if (! (*write_import_func) (abfd, sec, rel))
+ goto error_return;
}
else
++external_reloc_count;
are output as a symbol name followed by all the relocs for that
symbol, so we must first gather together all the relocs against
external symbols and sort them. */
- external_relocs =
- (struct reloc_and_sec *) bfd_alloc (abfd,
- (external_reloc_count
- * sizeof (struct reloc_and_sec)));
- if (external_relocs == (struct reloc_and_sec *) NULL)
- {
- bfd_error = no_memory;
- return false;
- }
+ amt = external_reloc_count * sizeof (struct reloc_and_sec);
+ external_relocs = bfd_alloc (abfd, amt);
+ if (external_relocs == NULL)
+ goto error_return;
i = 0;
- for (sec = abfd->sections; sec != (asection *) NULL; sec = sec->next)
+ for (sec = abfd->sections; sec != NULL; sec = sec->next)
{
arelent **rel_ptr_ptr, **rel_end;
rel = *rel_ptr_ptr;
sym = *rel->sym_ptr_ptr;
- if (bfd_get_section (sym) != &bfd_und_section)
+ if (! bfd_is_und_section (bfd_get_section (sym)))
continue;
external_relocs[i].rel = rel;
BFD_ASSERT (i == external_reloc_count);
/* Sort the external relocs by name. */
- qsort (external_relocs, external_reloc_count,
+ qsort (external_relocs, (size_t) external_reloc_count,
sizeof (struct reloc_and_sec), nlm_external_reloc_compare);
/* Write out the external relocs. */
j++)
++cnt;
- if ((*nlm_write_external_func (abfd)) (abfd, cnt, sym,
- &external_relocs[i])
- == false)
- return false;
+ if (! (*nlm_write_external_func (abfd)) (abfd, cnt, sym,
+ &external_relocs[i]))
+ goto error_return;
i += cnt;
}
/* Write out the public symbols (exports). */
sym_ptr_ptr = bfd_get_outsymbols (abfd);
- if (sym_ptr_ptr != (asymbol **) NULL)
+ if (sym_ptr_ptr != NULL)
{
- bfd_vma (*get_public_offset_func) PARAMS ((bfd *, asymbol *));
+ bfd_vma (*get_public_offset_func) (bfd *, asymbol *);
+ bfd_boolean (*write_export_func) (bfd *, asymbol *, bfd_vma);
+
asymbol **sym_end;
nlm_fixed_header (abfd)->publicsOffset = bfd_tell (abfd);
get_public_offset_func = nlm_get_public_offset_func (abfd);
+ write_export_func = nlm_write_export_func (abfd);
c = 0;
sym_end = sym_ptr_ptr + bfd_get_symcount (abfd);
for (; sym_ptr_ptr < sym_end; sym_ptr_ptr++)
sym = *sym_ptr_ptr;
if ((sym->flags & (BSF_EXPORT | BSF_GLOBAL)) == 0
- || bfd_get_section (sym) == &bfd_und_section)
+ || bfd_is_und_section (bfd_get_section (sym)))
continue;
++c;
- len = strlen (sym->name);
- if ((bfd_write (&len, sizeof (bfd_byte), 1, abfd)
- != sizeof (bfd_byte))
- || bfd_write (sym->name, len, 1, abfd) != len)
- {
- bfd_error = system_call_error;
- return false;
- }
-
if (get_public_offset_func)
{
/* Most backends can use the code below, but
{
/* We can't handle an exported symbol that is not in
the code or data segment. */
- bfd_error = invalid_operation;
- return false;
+ bfd_set_error (bfd_error_invalid_operation);
+ goto error_return;
}
}
- put_word (abfd, offset, temp);
- if (bfd_write (temp, sizeof (temp), 1, abfd) != sizeof (temp))
+ if (write_export_func)
{
- bfd_error = system_call_error;
- return false;
+ if (! (*write_export_func) (abfd, sym, offset))
+ goto error_return;
}
- }
+ else
+ {
+ len = strlen (sym->name);
+ if ((bfd_bwrite (&len, (bfd_size_type) sizeof (bfd_byte), abfd)
+ != sizeof (bfd_byte))
+ || bfd_bwrite (sym->name, (bfd_size_type) len, abfd) != len)
+ goto error_return;
+
+ put_word (abfd, offset, temp);
+ if (bfd_bwrite (temp, (bfd_size_type) sizeof (temp), abfd)
+ != sizeof (temp))
+ goto error_return;
+ }
+ }
nlm_fixed_header (abfd)->numberOfPublics = c;
/* Write out the debugging records. The NLM conversion program
information. This can not be handled by fiddling with the
symbol table, because exported symbols appear in both the
exported symbol list and the debugging information. */
- if (nlm_fixed_header (abfd)->debugInfoOffset == (file_ptr) -1)
+ if (nlm_fixed_header (abfd)->debugInfoOffset == (file_ptr) - 1)
{
nlm_fixed_header (abfd)->debugInfoOffset = 0;
nlm_fixed_header (abfd)->numberOfDebugRecords = 0;
debugging symbol NLM does not understand at all. */
if ((sym->flags & (BSF_LOCAL | BSF_GLOBAL | BSF_EXPORT)) == 0
|| (sym->flags & BSF_DEBUGGING) != 0
- || bfd_get_section (sym) == &bfd_und_section)
+ || bfd_is_und_section (bfd_get_section (sym)))
continue;
++c;
- offset = sym->value;
+ offset = bfd_asymbol_value (sym);
sec = sym->section;
if (sec->flags & SEC_CODE)
- type = 1;
- else if (sec->flags & SEC_DATA)
- type = 0;
- else if (sec->flags & SEC_ALLOC)
{
+ offset -= nlm_get_text_low (abfd);
+ type = 1;
+ }
+ else if (sec->flags & (SEC_DATA | SEC_ALLOC))
+ {
+ /* SEC_ALLOC is for the .bss section. */
+ offset -= nlm_get_data_low (abfd);
type = 0;
- offset += nlm_fixed_header (abfd)->dataImageSize;
}
else
type = 2;
/* The type is 0 for data, 1 for code, 2 for absolute. */
- if (bfd_write (&type, sizeof (bfd_byte), 1, abfd)
+ if (bfd_bwrite (&type, (bfd_size_type) sizeof (bfd_byte), abfd)
!= sizeof (bfd_byte))
- {
- bfd_error = system_call_error;
- return false;
- }
+ goto error_return;
put_word (abfd, offset, temp);
- if (bfd_write (temp, sizeof (temp), 1, abfd) != sizeof (temp))
- {
- bfd_error = system_call_error;
- return false;
- }
+ if (bfd_bwrite (temp, (bfd_size_type) sizeof (temp), abfd)
+ != sizeof (temp))
+ goto error_return;
len = strlen (sym->name);
- if ((bfd_write (&len, sizeof (bfd_byte), 1, abfd)
+ if ((bfd_bwrite (&len, (bfd_size_type) sizeof (bfd_byte), abfd)
!= sizeof (bfd_byte))
- || bfd_write (sym->name, len, 1, abfd) != len)
- {
- bfd_error = system_call_error;
- return false;
- }
- }
+ || bfd_bwrite (sym->name, (bfd_size_type) len, abfd) != len)
+ goto error_return;
+ }
nlm_fixed_header (abfd)->numberOfDebugRecords = c;
}
}
nlm_fixed_header (abfd)->checkUnloadProcedureOffset -=
nlm_get_text_low (abfd);
- if (bfd_seek (abfd, 0, SEEK_SET) != 0)
- return false;
-
+ if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
+ goto error_return;
+
write_prefix_func = nlm_write_prefix_func (abfd);
if (write_prefix_func)
{
- if ((*write_prefix_func) (abfd) == false)
- return false;
+ if (! (*write_prefix_func) (abfd))
+ goto error_return;
}
- BFD_ASSERT (bfd_tell (abfd) == nlm_optional_prefix_size (abfd));
+ BFD_ASSERT ((bfd_size_type) bfd_tell (abfd)
+ == nlm_optional_prefix_size (abfd));
nlm_swap_fixed_header_out (abfd, nlm_fixed_header (abfd), fixed_header);
- if (bfd_write (fixed_header, nlm_fixed_header_size (abfd), 1, abfd)
+ if (bfd_bwrite (fixed_header, nlm_fixed_header_size (abfd), abfd)
!= nlm_fixed_header_size (abfd))
- {
- bfd_error = system_call_error;
- return false;
- }
+ goto error_return;
+
+ if (fixed_header != NULL)
+ free (fixed_header);
+ return TRUE;
- return true;
+error_return:
+ if (fixed_header != NULL)
+ free (fixed_header);
+ return FALSE;
}
projects / deliverable / binutils-gdb.git / blobdiff