/* NLM (NetWare Loadable Module) executable support for BFD.
- Copyright 1993, 1994, 1995, 1998, 2000, 2001, 2002
- Free Software Foundation, Inc.
+ Copyright 1993, 1994, 1995, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
+ 2005, 2006, 2007 Free Software Foundation, Inc.
Written by Fred Fish @ Cygnus Support, using ELF support as the
template.
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
+ 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,
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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
+ Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
+ MA 02110-1301, USA. */
-#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_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_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 bfd_boolean add_bfd_section
- PARAMS ((bfd *, char *, file_ptr, bfd_size_type, flagword));
-static bfd_boolean nlm_swap_variable_header_in
- PARAMS ((bfd *));
-static bfd_boolean nlm_swap_variable_header_out
- PARAMS ((bfd *));
-static bfd_boolean find_nonzero
- PARAMS ((PTR, size_t));
-static bfd_boolean nlm_swap_auxiliary_headers_in
- PARAMS ((bfd *));
-static bfd_boolean nlm_swap_auxiliary_headers_out
- PARAMS ((bfd *));
-static bfd_boolean nlm_slurp_symbol_table
- PARAMS ((bfd *));
-static bfd_boolean nlm_slurp_reloc_fixups
- PARAMS ((bfd *));
-static bfd_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". */
#define get_word H_GET_32
#endif
-const bfd_target *
-nlm_object_p (abfd)
- bfd *abfd;
-{
- struct nlm_obj_tdata *preserved_tdata = nlm_tdata (abfd);
- bfd_boolean (*backend_object_p) PARAMS ((bfd *));
- PTR 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 = (PTR) bfd_malloc (amt);
- if (x_fxdhdr == NULL)
- goto got_no_match;
-
- if (bfd_bread ((PTR) 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 = (struct nlm_obj_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 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) */
- /* 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;
- }
-
- /* 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);
-}
-
-/* Add a section to the bfd. */
-
-static bfd_boolean
-add_bfd_section (abfd, name, offset, size, flags)
- bfd *abfd;
- char *name;
- file_ptr offset;
- bfd_size_type size;
- 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 ((bfd_vma) 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. */
static bfd_boolean
-nlm_swap_variable_header_in (abfd)
- bfd *abfd;
+nlm_swap_variable_header_in (bfd *abfd)
{
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 ((PTR) &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 ((PTR) nlm_variable_header (abfd)->descriptionText,
+ 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 ((PTR) temp, amt, abfd) != amt)
+ 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 ((PTR) temp, amt, abfd) != amt)
+ 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 ((PTR) 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 ((PTR) & 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 ((PTR) nlm_variable_header (abfd)->screenName,
+ 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 ((PTR) & 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 ((PTR) nlm_variable_header (abfd)->threadName,
+ 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 bfd_boolean
-nlm_swap_variable_header_out (abfd)
- bfd *abfd;
+add_bfd_section (bfd *abfd,
+ char *name,
+ file_ptr offset,
+ bfd_size_type size,
+ flagword flags)
{
- unsigned char 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 ((PTR) & nlm_variable_header (abfd)->descriptionLength, amt,
- abfd) != amt)
- return FALSE;
- amt = nlm_variable_header (abfd)->descriptionLength + 1;
- if (bfd_bwrite ((PTR) 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,
- (bfd_byte *) temp);
- amt = sizeof (temp);
- if (bfd_bwrite ((PTR) temp, amt, abfd) != amt)
- return FALSE;
-
- /* Convert and write the reserved field. */
- put_word (abfd, (bfd_vma) nlm_variable_header (abfd)->reserved,
- (bfd_byte *) temp);
- amt = sizeof (temp);
- if (bfd_bwrite ((PTR) temp, amt, abfd) != amt)
- return FALSE;
+ asection *newsect;
- /* Write the oldThreadName field. This field is a fixed length string. */
- amt = sizeof (nlm_variable_header (abfd)->oldThreadName);
- if (bfd_bwrite ((PTR) nlm_variable_header (abfd)->oldThreadName, amt,
- abfd) != amt)
+ newsect = bfd_make_section_with_flags (abfd, name, flags);
+ if (newsect == NULL)
return FALSE;
- /* Write the screen name length and text members. */
- amt = sizeof (nlm_variable_header (abfd)->screenNameLength);
- if (bfd_bwrite ((PTR) & nlm_variable_header (abfd)->screenNameLength, amt,
- abfd) != amt)
- return FALSE;
- amt = nlm_variable_header (abfd)->screenNameLength + 1;
- if (bfd_bwrite ((PTR) nlm_variable_header (abfd)->screenName, amt,
- abfd) != amt)
- return FALSE;
+ newsect->vma = 0; /* NLM's are relocatable. */
+ newsect->size = size;
+ newsect->filepos = offset;
+ newsect->alignment_power = bfd_log2 ((bfd_vma) 0); /* FIXME */
- /* Write the thread name length and text members. */
- amt = sizeof (nlm_variable_header (abfd)->threadNameLength);
- if (bfd_bwrite ((PTR) & nlm_variable_header (abfd)->threadNameLength, amt,
- abfd) != amt)
- return FALSE;
- amt = nlm_variable_header (abfd)->threadNameLength + 1;
- if (bfd_bwrite ((PTR) nlm_variable_header (abfd)->threadName, amt,
- abfd) != amt)
- return FALSE;
return TRUE;
}
recognize it. */
static bfd_boolean
-nlm_swap_auxiliary_headers_in (abfd)
- bfd *abfd;
+nlm_swap_auxiliary_headers_in (bfd *abfd)
{
char tempstr[16];
file_ptr position;
{
position = bfd_tell (abfd);
amt = sizeof (tempstr);
- if (bfd_bread ((PTR) tempstr, amt, abfd) != amt)
+ if (bfd_bread ((void *) tempstr, amt, abfd) != amt)
return FALSE;
if (bfd_seek (abfd, position, SEEK_SET) != 0)
return FALSE;
- if (strncmp (tempstr, "VeRsIoN#", 8) == 0)
+ if (CONST_STRNEQ (tempstr, "VeRsIoN#"))
{
Nlm_External_Version_Header thdr;
amt = sizeof (thdr);
- if (bfd_bread ((PTR) &thdr, amt, abfd) != amt)
+ 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)->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;
amt = sizeof (thdr);
- if (bfd_bread ((PTR) &thdr, amt, abfd) != amt)
+ 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)->reserved5 =
get_word (abfd, (bfd_byte *) thdr.reserved5);
}
- else if (strncmp (tempstr, "CoPyRiGhT=", 10) == 0)
+ else if (CONST_STRNEQ (tempstr, "CoPyRiGhT="))
{
amt = sizeof (nlm_copyright_header (abfd)->stamp);
- if (bfd_bread ((PTR) nlm_copyright_header (abfd)->stamp,
+ if (bfd_bread ((void *) nlm_copyright_header (abfd)->stamp,
amt, abfd) != amt)
return FALSE;
- if (bfd_bread ((PTR) &(nlm_copyright_header (abfd)
+ 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 ((PTR) nlm_copyright_header (abfd)->copyrightMessage,
+ if (bfd_bread ((void *) nlm_copyright_header (abfd)->copyrightMessage,
amt, abfd) != amt)
return FALSE;
}
- else if (strncmp (tempstr, "CuStHeAd", 8) == 0)
+ else if (CONST_STRNEQ (tempstr, "CuStHeAd"))
{
Nlm_External_Custom_Header thdr;
bfd_size_type hdrLength;
file_ptr dataOffset;
bfd_size_type dataLength;
char dataStamp[8];
- PTR hdr;
+ void * hdr;
/* Read the stamp ("CuStHeAd"). */
amt = sizeof (thdr.stamp);
- if (bfd_bread ((PTR) thdr.stamp, amt, abfd) != amt)
+ 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 ((PTR) thdr.length, amt, abfd) != amt)
+ 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. */
else
{
amt = sizeof (thdr.dataOffset);
- if (bfd_bread ((PTR) thdr.dataOffset, amt, abfd) != amt)
+ if (bfd_bread ((void *) thdr.dataOffset, amt, abfd) != amt)
return FALSE;
dataOffset = get_word (abfd, (bfd_byte *) thdr.dataOffset);
}
else
{
amt = sizeof (thdr.dataLength);
- if (bfd_bread ((PTR) thdr.dataLength, amt, abfd) != amt)
+ if (bfd_bread ((void *) thdr.dataLength, amt, abfd) != amt)
return FALSE;
dataLength = get_word (abfd, (bfd_byte *) thdr.dataLength);
}
else
{
amt = sizeof (dataStamp);
- if (bfd_bread ((PTR) dataStamp, amt, abfd) != amt)
+ if (bfd_bread ((void *) dataStamp, amt, abfd) != amt)
return FALSE;
}
/* If we have found a Cygnus header, process it. Otherwise,
just save the associated data without trying to interpret
it. */
- if (strncmp (dataStamp, "CyGnUsEx", 8) == 0)
+ if (CONST_STRNEQ (dataStamp, "CyGnUsEx"))
{
file_ptr pos;
bfd_byte *contents;
pos = bfd_tell (abfd);
if (bfd_seek (abfd, dataOffset, SEEK_SET) != 0)
return FALSE;
- contents = (bfd_byte *) bfd_alloc (abfd, dataLength);
+ contents = bfd_alloc (abfd, dataLength);
if (contents == NULL)
return FALSE;
if (bfd_bread (contents, dataLength, abfd) != dataLength)
if (bfd_seek (abfd, pos, SEEK_SET) != 0)
return FALSE;
- memcpy (nlm_cygnus_ext_header (abfd), "CyGnUsEx", 8);
+ LITMEMCPY (nlm_cygnus_ext_header (abfd), "CyGnUsEx");
nlm_cygnus_ext_header (abfd)->offset = dataOffset;
nlm_cygnus_ext_header (abfd)->length = dataLength;
null terminated section name
zeroes to adjust to 4 byte boundary
4 byte section data file pointer
- 4 byte section size
- */
+ 4 byte section size. */
name = (char *) p;
l = strlen (name) + 1;
p += 4;
newsec = bfd_make_section_anyway (abfd, name);
- if (newsec == (asection *) NULL)
+ if (newsec == NULL)
return FALSE;
- newsec->_raw_size = size;
+ newsec->size = size;
if (filepos != 0)
{
newsec->filepos = filepos;
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 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) */
+ /* 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;
+ }
+
+ /* 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 bfd_boolean
-find_nonzero (buf, size)
- PTR buf;
- size_t size;
+find_nonzero (void * buf, size_t size)
{
char *p = (char *) buf;
the caller to set up the stamp fields. */
static bfd_boolean
-nlm_swap_auxiliary_headers_out (abfd)
- bfd *abfd;
+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);
+ 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,
(bfd_byte *) thdr.month);
put_word (abfd, (bfd_vma) nlm_version_header (abfd)->day,
(bfd_byte *) thdr.day);
- if (bfd_bwrite ((PTR) &thdr, (bfd_size_type) sizeof (thdr), abfd)
+ if (bfd_bwrite ((void *) &thdr, (bfd_size_type) sizeof (thdr), abfd)
!= sizeof (thdr))
return FALSE;
}
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 ((PTR) nlm_copyright_header (abfd),
+ if (find_nonzero (nlm_copyright_header (abfd),
sizeof (Nlm_Internal_Copyright_Header)))
{
Nlm_External_Copyright_Header thdr;
- memcpy (thdr.stamp, "CoPyRiGhT=", 10);
+ LITMEMCPY (thdr.stamp, "CoPyRiGhT=");
amt = sizeof (thdr.stamp);
- if (bfd_bwrite ((PTR) thdr.stamp, amt, abfd) != amt)
+ if (bfd_bwrite ((void *) thdr.stamp, amt, abfd) != amt)
return FALSE;
thdr.copyrightMessageLength[0] =
nlm_copyright_header (abfd)->copyrightMessageLength;
amt = 1;
- if (bfd_bwrite ((PTR) thdr.copyrightMessageLength, amt, abfd) != amt)
+ 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 ((PTR) nlm_copyright_header (abfd)->copyrightMessage,
+ 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_byte *) thdr.languageID);
put_word (abfd,
(bfd_vma) nlm_extended_header (abfd)->reserved5,
(bfd_byte *) thdr.reserved5);
- if (bfd_bwrite ((PTR) &thdr, (bfd_size_type) sizeof (thdr), abfd)
+ 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;
bfd_boolean ds;
bfd_size_type hdrLength;
- ds = find_nonzero ((PTR) nlm_custom_header (abfd)->dataStamp,
+ ds = find_nonzero (nlm_custom_header (abfd)->dataStamp,
sizeof (nlm_custom_header (abfd)->dataStamp));
- memcpy (thdr.stamp, "CuStHeAd", 8);
+ LITMEMCPY (thdr.stamp, "CuStHeAd");
hdrLength = (2 * NLM_TARGET_LONG_SIZE + (ds ? 8 : 0)
+ nlm_custom_header (abfd)->hdrLength);
put_word (abfd, hdrLength, thdr.length);
{
BFD_ASSERT (nlm_custom_header (abfd)->hdrLength == 0);
amt = sizeof (thdr) - sizeof (thdr.dataStamp);
- if (bfd_bwrite ((PTR) &thdr, amt, abfd) != amt)
+ if (bfd_bwrite ((void *) &thdr, amt, abfd) != amt)
return FALSE;
}
else
memcpy (thdr.dataStamp, nlm_custom_header (abfd)->dataStamp,
sizeof (thdr.dataStamp));
amt = sizeof (thdr);
- if (bfd_bwrite ((PTR) &thdr, amt, abfd) != amt)
+ 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)
}
/* Write out the Cygnus debugging header if there is one. */
- if (find_nonzero ((PTR) nlm_cygnus_ext_header (abfd),
+ if (find_nonzero (nlm_cygnus_ext_header (abfd),
sizeof (Nlm_Internal_Cygnus_Ext_Header)))
{
Nlm_External_Custom_Header thdr;
- memcpy (thdr.stamp, "CuStHeAd", 8);
+ 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);
- memcpy (thdr.dataStamp, "CyGnUsEx", 8);
+ LITMEMCPY (thdr.dataStamp, "CyGnUsEx");
amt = sizeof (thdr);
- if (bfd_bwrite ((PTR) &thdr, amt, abfd) != amt)
+ if (bfd_bwrite ((void *) &thdr, amt, abfd) != amt)
return FALSE;
}
on this size. */
long
-nlm_get_symtab_upper_bound (abfd)
- bfd *abfd;
+nlm_get_symtab_upper_bound (bfd *abfd)
{
Nlm_Internal_Fixed_Header *i_fxdhdrp; /* Nlm file header, internal form. */
long symcount;
+ 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. */
-
-long
-nlm_get_symtab (abfd, alocation)
- 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 = (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;
-{
- bfd_size_type amt = sizeof (nlm_symbol_type);
- nlm_symbol_type *new = (nlm_symbol_type *) bfd_zalloc (abfd, amt);
-
- if (new)
- new->symbol.the_bfd = abfd;
- return &new->symbol;
-}
-
-/* Get symbol information. */
-
-void
-nlm_get_symbol_info (ignore_abfd, symbol, ret)
- bfd *ignore_abfd ATTRIBUTE_UNUSED;
- 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 (abfd, (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. */
static bfd_boolean
-nlm_slurp_symbol_table (abfd)
- bfd *abfd;
+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. */
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) PARAMS ((bfd *, nlm_symbol_type *));
- bfd_boolean (*set_public_section_func) PARAMS ((bfd *, nlm_symbol_type *));
+ 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 FALSE;
amt = totsymcount * sizeof (nlm_symbol_type);
- sym = ((nlm_symbol_type *) bfd_zalloc (abfd, amt));
+ sym = bfd_zalloc (abfd, amt);
if (!sym)
return FALSE;
nlm_set_symbols (abfd, sym);
while (abfd->symcount < symcount)
{
amt = sizeof (symlength);
- if (bfd_bread ((PTR) &symlength, amt, abfd) != amt)
+ 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 ((PTR) sym->symbol.name, amt, abfd) != amt)
+ if (bfd_bread ((void *) sym->symbol.name, amt, abfd) != amt)
return FALSE;
/* Cast away const. */
((char *) (sym->symbol.name))[symlength] = '\0';
amt = sizeof (temp);
- if (bfd_bread ((PTR) temp, amt, abfd) != amt)
+ if (bfd_bread ((void *) temp, amt, abfd) != amt)
return FALSE;
sym->symbol.flags = BSF_GLOBAL | BSF_EXPORT;
sym->symbol.value = get_word (abfd, temp);
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++;
while (abfd->symcount < symcount)
{
amt = sizeof (symtype);
- if (bfd_bread ((PTR) &symtype, amt, abfd) != amt)
+ if (bfd_bread ((void *) &symtype, amt, abfd) != amt)
return FALSE;
amt = sizeof (temp);
- if (bfd_bread ((PTR) temp, amt, abfd) != amt)
+ if (bfd_bread ((void *) temp, amt, abfd) != amt)
return FALSE;
amt = sizeof (symlength);
- if (bfd_bread ((PTR) &symlength, amt, abfd) != amt)
+ 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 ((PTR) sym->symbol.name, amt, abfd) != amt)
+ 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);
+
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;
bfd_get_section_by_name (abfd, NLM_CODE_NAME);
}
else
- {
- sym->symbol.section = bfd_abs_section_ptr;
- }
+ sym->symbol.section = bfd_abs_section_ptr;
+
sym->rcnt = 0;
abfd->symcount++;
sym++;
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.
Imports are relocs against symbols defined in other NLM files. We
section. */
static bfd_boolean
-nlm_slurp_reloc_fixups (abfd)
- bfd *abfd;
+nlm_slurp_reloc_fixups (bfd *abfd)
{
- bfd_boolean (*read_func)
- PARAMS ((bfd *, nlm_symbol_type *, asection **, arelent *));
+ bfd_boolean (*read_func) (bfd *, nlm_symbol_type *, asection **, arelent *);
bfd_size_type count, amt;
arelent *rels;
asection **secs;
count = nlm_fixed_header (abfd)->numberOfRelocationFixups;
amt = count * sizeof (arelent);
- rels = (arelent *) bfd_alloc (abfd, amt);
+ rels = bfd_alloc (abfd, amt);
amt = count * sizeof (asection *);
- secs = (asection **) bfd_alloc (abfd, amt);
+ secs = bfd_alloc (abfd, amt);
if ((rels == NULL || secs == NULL) && count != 0)
return FALSE;
nlm_relocation_fixups (abfd) = rels;
the machine specific reloc information is. */
while (count-- != 0)
{
- if (! (*read_func) (abfd, (nlm_symbol_type *) NULL, secs, rels))
+ if (! (*read_func) (abfd, NULL, secs, rels))
{
nlm_relocation_fixups (abfd) = NULL;
nlm_relocation_fixup_secs (abfd) = NULL;
That will be handled when they are actually read. */
long
-nlm_get_reloc_upper_bound (abfd, sec)
- bfd *abfd;
- asection *sec;
+nlm_get_reloc_upper_bound (bfd *abfd, asection *sec)
{
nlm_symbol_type *syms;
bfd_size_type count;
/* Get the relocs themselves. */
long
-nlm_canonicalize_reloc (abfd, sec, relptr, symbols)
- bfd *abfd;
- asection *sec;
- arelent **relptr;
- asymbol **symbols;
+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);
final values. */
static bfd_boolean
-nlm_compute_section_file_positions (abfd)
- bfd *abfd;
+nlm_compute_section_file_positions (bfd *abfd)
{
file_ptr sofar;
asection *sec;
+ 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_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);
- if (find_nonzero ((PTR) nlm_custom_header (abfd),
+ 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 ((PTR) nlm_cygnus_ext_header (abfd),
+ if (find_nonzero (nlm_cygnus_ext_header (abfd),
sizeof (Nlm_Internal_Cygnus_Ext_Header)))
sofar += sizeof (Nlm_External_Custom_Header);
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_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;
}
}
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);
}
abort ();
}
nlm_fixed_header (abfd)->uninitializedDataSize += add;
- bss_sec->_raw_size += add;
+ bss_sec->size += add;
}
}
variable size header information must be known. */
bfd_boolean
-nlm_set_section_contents (abfd, section, location, offset, count)
- bfd *abfd;
- asection *section;
- PTR location;
- file_ptr offset;
- bfd_size_type count;
+nlm_set_section_contents (bfd *abfd,
+ asection *section,
+ const void * location,
+ file_ptr offset,
+ bfd_size_type count)
{
if (! abfd->output_has_begun
&& ! nlm_compute_section_file_positions (abfd))
if (section->reloc_count != 0)
{
bfd_boolean (*mangle_relocs_func)
- PARAMS ((bfd *, asection *, PTR, bfd_vma, bfd_size_type));
+ (bfd *, asection *, const void *, bfd_vma, bfd_size_type);
mangle_relocs_func = nlm_mangle_relocs_func (abfd);
if (mangle_relocs_func != NULL)
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;
list of outsymbols. */
bfd_boolean
-nlm_write_object_contents (abfd)
- bfd *abfd;
+nlm_write_object_contents (bfd *abfd)
{
asection *sec;
- bfd_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;
- bfd_boolean (*write_prefix_func) PARAMS ((bfd *));
+ bfd_boolean (*write_prefix_func) (bfd *);
unsigned char *fixed_header = NULL;
file_ptr pos;
bfd_size_type amt;
- fixed_header = ((unsigned char *)
- bfd_malloc (nlm_fixed_header_size (abfd)));
+ fixed_header = bfd_malloc (nlm_fixed_header_size (abfd));
if (fixed_header == NULL)
goto error_return;
/* A weak check on whether the section file positions were
reasonable. */
- if (bfd_tell (abfd) > (ufile_ptr) nlm_fixed_header (abfd)->codeImageOffset)
+ if (bfd_tell (abfd) > nlm_fixed_header (abfd)->codeImageOffset)
{
bfd_set_error (bfd_error_invalid_operation);
goto error_return;
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;
symbol, so we must first gather together all the relocs against
external symbols and sort them. */
amt = external_reloc_count * sizeof (struct reloc_and_sec);
- external_relocs = (struct reloc_and_sec *) bfd_alloc (abfd, amt);
- if (external_relocs == (struct reloc_and_sec *) NULL)
+ 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;
BFD_ASSERT (i == external_reloc_count);
/* Sort the external relocs by name. */
- qsort ((PTR) external_relocs, (size_t) 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. */
/* 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_boolean (*write_export_func) PARAMS ((bfd *, asymbol *, bfd_vma));
+ bfd_vma (*get_public_offset_func) (bfd *, asymbol *);
+ bfd_boolean (*write_export_func) (bfd *, asymbol *, bfd_vma);
asymbol **sym_end;
OSDN Git Service
