/* NLM (NetWare Loadable Module) executable support for BFD.
- Copyright (C) 1993 Free Software Foundation, Inc.
+ Copyright (C) 1993, 94, 95, 98, 1999 Free Software Foundation, Inc.
Written by Fred Fish @ Cygnus Support, using ELF support as the
template.
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. */
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
-#include <string.h> /* For strrchr and friends */
#include "bfd.h"
#include "sysdep.h"
#include "libbfd.h"
#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 get_word bfd_h_get_32
#endif
-bfd_target *
-DEFUN (nlm_object_p, (abfd), bfd * abfd)
+const bfd_target *
+nlm_object_p (abfd)
+ bfd *abfd;
{
struct nlm_obj_tdata *preserved_tdata = nlm_tdata (abfd);
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;
backend_object_p = nlm_backend_object_p_func (abfd);
if (backend_object_p)
{
- if (! (*backend_object_p) (abfd))
+ 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 = (PTR) malloc (nlm_fixed_header_size (abfd));
+ x_fxdhdr = (PTR) bfd_malloc ((size_t) nlm_fixed_header_size (abfd));
if (x_fxdhdr == NULL)
- {
- bfd_set_error (bfd_error_no_memory);
- goto got_no_match;
- }
+ goto got_no_match;
if (bfd_read ((PTR) x_fxdhdr, nlm_fixed_header_size (abfd), 1, abfd) !=
nlm_fixed_header_size (abfd))
- goto got_wrong_format_error;
+ {
+ 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. */
- nlm_tdata (abfd) = (struct nlm_obj_tdata *)
- bfd_zalloc (abfd, sizeof (struct nlm_obj_tdata));
- if (nlm_tdata (abfd) == NULL)
- {
- bfd_set_error (bfd_error_no_memory);
- goto got_no_match;
- }
+ new_tdata = ((struct nlm_obj_tdata *)
+ bfd_zalloc (abfd, sizeof (struct nlm_obj_tdata)));
+ 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. */
/* 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. */
+ /* 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;
+ }
- 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 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,
+ 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,
+ i_fxdhdrp->uninitializedDataSize,
SEC_ALLOC))
- goto got_wrong_format_error;
+ 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)
if (arch != bfd_arch_unknown)
bfd_default_set_arch_mach (abfd, arch, (unsigned long) 0);
- if (x_fxdhdr != NULL)
- free (x_fxdhdr);
- return (abfd -> xvec);
+ abfd->flags |= EXEC_P;
+ bfd_get_start_address (abfd) = nlm_fixed_header (abfd)->codeStartOffset;
+
+ return (abfd->xvec);
- got_wrong_format_error:
+got_wrong_format_error:
bfd_set_error (bfd_error_wrong_format);
- got_no_match:
+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 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)
+add_bfd_section (abfd, name, offset, size, flags)
+ bfd *abfd;
+ char *name;
+ file_ptr offset;
+ bfd_size_type size;
+ flagword flags;
{
asection *newsect;
{
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 */
+ 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);
}
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)
+nlm_swap_variable_header_in (abfd)
+ bfd *abfd;
{
- unsigned char temp [NLM_TARGET_LONG_SIZE];
+ 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),
+ if (bfd_read ((PTR) & nlm_variable_header (abfd)->descriptionLength,
+ sizeof (nlm_variable_header (abfd)->descriptionLength),
1, abfd) !=
- sizeof (nlm_variable_header (abfd) -> descriptionLength))
- {
- bfd_set_error (bfd_error_system_call);
- return (false);
- }
- if (bfd_read ((PTR) nlm_variable_header (abfd) -> descriptionText,
- nlm_variable_header (abfd) -> descriptionLength + 1,
+ sizeof (nlm_variable_header (abfd)->descriptionLength))
+ 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_set_error (bfd_error_system_call);
- return (false);
- }
+ (bfd_size_type) nlm_variable_header (abfd)->descriptionLength + 1)
+ return (false);
/* Read and convert the stackSize field. */
if (bfd_read ((PTR) temp, sizeof (temp), 1, abfd) != sizeof (temp))
- {
- bfd_set_error (bfd_error_system_call);
- return (false);
- }
- nlm_variable_header (abfd) -> stackSize = get_word (abfd, (bfd_byte *) temp);
+ 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_set_error (bfd_error_system_call);
- return (false);
- }
- nlm_variable_header (abfd) -> reserved = get_word (abfd, (bfd_byte *) temp);
+ 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),
+ if (bfd_read ((PTR) nlm_variable_header (abfd)->oldThreadName,
+ sizeof (nlm_variable_header (abfd)->oldThreadName),
1, abfd) !=
- sizeof (nlm_variable_header (abfd) -> oldThreadName))
- {
- bfd_set_error (bfd_error_system_call);
- return (false);
- }
+ sizeof (nlm_variable_header (abfd)->oldThreadName))
+ 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),
+ if (bfd_read ((PTR) & nlm_variable_header (abfd)->screenNameLength,
+ sizeof (nlm_variable_header (abfd)->screenNameLength),
1, abfd) !=
- sizeof (nlm_variable_header (abfd) -> screenNameLength))
- {
- bfd_set_error (bfd_error_system_call);
- return (false);
- }
- if (bfd_read ((PTR) nlm_variable_header (abfd) -> screenName,
- nlm_variable_header (abfd) -> screenNameLength + 1,
+ sizeof (nlm_variable_header (abfd)->screenNameLength))
+ 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_set_error (bfd_error_system_call);
- return (false);
- }
+ (bfd_size_type) nlm_variable_header (abfd)->screenNameLength + 1)
+ 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),
+ if (bfd_read ((PTR) & nlm_variable_header (abfd)->threadNameLength,
+ sizeof (nlm_variable_header (abfd)->threadNameLength),
1, abfd) !=
- sizeof (nlm_variable_header (abfd) -> threadNameLength))
- {
- bfd_set_error (bfd_error_system_call);
- return (false);
- }
- if (bfd_read ((PTR) nlm_variable_header (abfd) -> threadName,
- nlm_variable_header (abfd) -> threadNameLength + 1,
+ sizeof (nlm_variable_header (abfd)->threadNameLength))
+ 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_set_error (bfd_error_system_call);
- return (false);
- }
+ (bfd_size_type) nlm_variable_header (abfd)->threadNameLength + 1)
+ return (false);
return (true);
}
exist in the NLM, and must exist in this order. */
static boolean
-DEFUN (nlm_swap_variable_header_out, (abfd),
- bfd * abfd)
+nlm_swap_variable_header_out (abfd)
+ bfd *abfd;
{
- unsigned char temp [NLM_TARGET_LONG_SIZE];
+ 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),
+ if (bfd_write ((PTR) & nlm_variable_header (abfd)->descriptionLength,
+ sizeof (nlm_variable_header (abfd)->descriptionLength),
1, abfd) !=
- sizeof (nlm_variable_header (abfd) -> descriptionLength))
- {
- bfd_set_error (bfd_error_system_call);
- return (false);
- }
- if (bfd_write ((PTR) nlm_variable_header (abfd) -> descriptionText,
- nlm_variable_header (abfd) -> descriptionLength + 1,
+ sizeof (nlm_variable_header (abfd)->descriptionLength))
+ 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_set_error (bfd_error_system_call);
- return (false);
- }
+ (bfd_size_type) nlm_variable_header (abfd)->descriptionLength + 1)
+ return (false);
/* Convert and write the stackSize field. */
- put_word (abfd, (bfd_vma) nlm_variable_header (abfd) -> stackSize,
+ 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_set_error (bfd_error_system_call);
- return (false);
- }
+ return (false);
/* Convert and write the reserved field. */
- put_word (abfd, (bfd_vma) nlm_variable_header (abfd) -> reserved,
+ 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_set_error (bfd_error_system_call);
- return (false);
- }
+ 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),
+ if (bfd_write ((PTR) nlm_variable_header (abfd)->oldThreadName,
+ sizeof (nlm_variable_header (abfd)->oldThreadName),
1, abfd) !=
- sizeof (nlm_variable_header (abfd) -> oldThreadName))
- {
- bfd_set_error (bfd_error_system_call);
- return (false);
- }
+ sizeof (nlm_variable_header (abfd)->oldThreadName))
+ return (false);
/* Write the screen name length and text members. */
- if (bfd_write ((PTR) &nlm_variable_header (abfd) -> screenNameLength,
- sizeof (nlm_variable_header (abfd) -> screenNameLength),
+ if (bfd_write ((PTR) & nlm_variable_header (abfd)->screenNameLength,
+ sizeof (nlm_variable_header (abfd)->screenNameLength),
1, abfd) !=
- sizeof (nlm_variable_header (abfd) -> screenNameLength))
- {
- bfd_set_error (bfd_error_system_call);
- return (false);
- }
- if (bfd_write ((PTR) nlm_variable_header (abfd) -> screenName,
- nlm_variable_header (abfd) -> screenNameLength + 1,
+ sizeof (nlm_variable_header (abfd)->screenNameLength))
+ 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_set_error (bfd_error_system_call);
- return (false);
- }
+ (bfd_size_type) nlm_variable_header (abfd)->screenNameLength + 1)
+ return (false);
/* Write the thread name length and text members. */
- if (bfd_write ((PTR) &nlm_variable_header (abfd) -> threadNameLength,
- sizeof (nlm_variable_header (abfd) -> threadNameLength),
+ if (bfd_write ((PTR) & nlm_variable_header (abfd)->threadNameLength,
+ sizeof (nlm_variable_header (abfd)->threadNameLength),
1, abfd) !=
- sizeof (nlm_variable_header (abfd) -> threadNameLength))
- {
- bfd_set_error (bfd_error_system_call);
- return (false);
- }
- if (bfd_write ((PTR) nlm_variable_header (abfd) -> threadName,
- nlm_variable_header (abfd) -> threadNameLength + 1,
+ sizeof (nlm_variable_header (abfd)->threadNameLength))
+ 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_set_error (bfd_error_system_call);
- return (false);
- }
+ (bfd_size_type) nlm_variable_header (abfd)->threadNameLength + 1)
+ return (false);
return (true);
}
recognize it. */
static boolean
-DEFUN (nlm_swap_auxiliary_headers_in, (abfd),
- bfd * abfd)
+nlm_swap_auxiliary_headers_in (abfd)
+ bfd *abfd;
{
- char tempstr [16];
+ char tempstr[16];
long position;
for (;;)
position = bfd_tell (abfd);
if (bfd_read ((PTR) tempstr, sizeof (tempstr), 1, abfd) !=
sizeof (tempstr))
- {
- bfd_set_error (bfd_error_system_call);
- return (false);
- }
+ return (false);
if (bfd_seek (abfd, position, SEEK_SET) == -1)
- {
- bfd_set_error (bfd_error_system_call);
- return (false);
- }
+ return (false);
if (strncmp (tempstr, "VeRsIoN#", 8) == 0)
{
Nlm_External_Version_Header thdr;
- if (bfd_read ((PTR) &thdr, sizeof (thdr), 1, abfd) != sizeof (thdr))
- {
- bfd_set_error (bfd_error_system_call);
- return (false);
- }
- memcpy (nlm_version_header (abfd) -> stamp, thdr.stamp,
+ if (bfd_read ((PTR) & thdr, sizeof (thdr), 1, abfd) != sizeof (thdr))
+ 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)
{
Nlm_External_Extended_Header thdr;
- if (bfd_read ((PTR) &thdr, sizeof (thdr), 1, abfd) != sizeof (thdr))
- {
- bfd_set_error (bfd_error_system_call);
- return (false);
- }
- memcpy (nlm_extended_header (abfd) -> stamp, thdr.stamp,
+ if (bfd_read ((PTR) & thdr, sizeof (thdr), 1, abfd) != sizeof (thdr))
+ 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)
- {
- Nlm_External_Custom_Header thdr;
- if (bfd_read ((PTR) &thdr, sizeof (thdr), 1, abfd) != sizeof (thdr))
- {
- bfd_set_error (bfd_error_system_call);
- return (false);
- }
- memcpy (nlm_custom_header (abfd) -> stamp, thdr.stamp,
- sizeof (thdr.stamp));
- nlm_custom_header (abfd) -> dataLength =
- get_word (abfd, (bfd_byte *) thdr.dataLength);
- nlm_custom_header (abfd) -> debugRecOffset =
- get_word (abfd, (bfd_byte *) thdr.debugRecOffset);
- nlm_custom_header (abfd) -> debugRecLength =
- get_word (abfd, (bfd_byte *) thdr.debugRecLength);
- }
else if (strncmp (tempstr, "CoPyRiGhT=", 10) == 0)
{
if (bfd_read ((PTR) nlm_copyright_header (abfd)->stamp,
sizeof (nlm_copyright_header (abfd)->stamp),
1, abfd)
!= sizeof (nlm_copyright_header (abfd)->stamp))
+ return (false);
+ if (bfd_read ((PTR) & (nlm_copyright_header (abfd)
+ ->copyrightMessageLength),
+ 1, 1, abfd) != 1)
+ 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) !=
+ ((bfd_size_type)
+ nlm_copyright_header (abfd)->copyrightMessageLength + 1))
+ return (false);
+ }
+ else if (strncmp (tempstr, "CuStHeAd", 8) == 0)
+ {
+ Nlm_External_Custom_Header thdr;
+ bfd_size_type hdrLength;
+ file_ptr dataOffset;
+ bfd_size_type dataLength;
+ char dataStamp[8];
+ PTR hdr;
+
+ /* Read the stamp ("CuStHeAd"). */
+ if (bfd_read ((PTR) thdr.stamp, 1, sizeof (thdr.stamp), abfd)
+ != sizeof (thdr.stamp))
+ return false;
+ /* Read the length of this custom header. */
+ if (bfd_read ((PTR) thdr.length, 1, sizeof (thdr.length), abfd)
+ != sizeof (thdr.length))
+ 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_set_error (bfd_error_system_call);
- return (false);
+ if (bfd_read ((PTR) thdr.dataOffset, 1,
+ sizeof (thdr.dataOffset), abfd)
+ != sizeof (thdr.dataOffset))
+ return false;
+ dataOffset = get_word (abfd, (bfd_byte *) thdr.dataOffset);
}
- if (bfd_read ((PTR) &(nlm_copyright_header (abfd)
- ->copyrightMessageLength),
- 1, 1, abfd) != 1)
+ if (hdrLength < 2 * NLM_TARGET_LONG_SIZE)
+ dataLength = 0;
+ else
{
- bfd_set_error (bfd_error_system_call);
- return (false);
+ if (bfd_read ((PTR) thdr.dataLength, 1,
+ sizeof (thdr.dataLength), abfd)
+ != sizeof (thdr.dataLength))
+ return false;
+ dataLength = get_word (abfd, (bfd_byte *) thdr.dataLength);
}
- /* 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)
+ if (hdrLength < 2 * NLM_TARGET_LONG_SIZE + 8)
+ memset (dataStamp, 0, sizeof (dataStamp));
+ else
{
- bfd_set_error (bfd_error_system_call);
- return (false);
+ if (bfd_read ((PTR) dataStamp, 1, sizeof (dataStamp), abfd)
+ != sizeof (dataStamp))
+ return false;
+ }
+
+ /* Read the rest of the header, if any. */
+ if (hdrLength <= 2 * NLM_TARGET_LONG_SIZE + 8)
+ {
+ hdr = NULL;
+ hdrLength = 0;
+ }
+ else
+ {
+ hdrLength -= 2 * NLM_TARGET_LONG_SIZE + 8;
+ hdr = bfd_alloc (abfd, hdrLength);
+ if (hdr == NULL)
+ return false;
+ if (bfd_read (hdr, 1, 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 (strncmp (dataStamp, "CyGnUsEx", 8) == 0)
+ {
+ 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_byte *) bfd_alloc (abfd, dataLength);
+ if (contents == NULL)
+ return false;
+ if (bfd_read (contents, 1, dataLength, abfd) != dataLength)
+ return false;
+ if (bfd_seek (abfd, pos, SEEK_SET) != 0)
+ return false;
+
+ memcpy (nlm_cygnus_ext_header (abfd), "CyGnUsEx", 8);
+ 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) &~ 3;
+ p += l;
+ filepos = bfd_h_get_32 (abfd, p);
+ p += 4;
+ size = bfd_h_get_32 (abfd, p);
+ p += 4;
+
+ newsec = bfd_make_section_anyway (abfd, name);
+ if (newsec == (asection *) NULL)
+ return false;
+ newsec->_raw_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
Nlm_External_Version_Header thdr;
memcpy (thdr.stamp, "VeRsIoN#", 8);
- put_word (abfd, (bfd_vma) nlm_version_header (abfd) -> majorVersion,
+ 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_set_error (bfd_error_system_call);
- return false;
- }
+ if (bfd_write ((PTR) & thdr, sizeof (thdr), 1, abfd) != sizeof (thdr))
+ return false;
}
/* Write out the extended header if there is one. */
memcpy (thdr.stamp, "MeSsAgEs", 8);
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_set_error (bfd_error_system_call);
- return false;
- }
+ if (bfd_write ((PTR) & thdr, sizeof (thdr), 1, abfd) != sizeof (thdr))
+ return false;
}
- /* Write out the custom header if there is one. */
- if (find_nonzero ((PTR) 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_set_error (bfd_error_system_call);
- return false;
- }
- }
/* Write out the copyright header if there is one. */
if (find_nonzero ((PTR) nlm_copyright_header (abfd),
memcpy (thdr.stamp, "CoPyRiGhT=", 10);
if (bfd_write ((PTR) thdr.stamp, sizeof (thdr.stamp), 1, abfd)
!= sizeof (thdr.stamp))
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
thdr.copyrightMessageLength[0] =
nlm_copyright_header (abfd)->copyrightMessageLength;
if (bfd_write ((PTR) thdr.copyrightMessageLength, 1, 1, abfd) != 1)
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ 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,
+ if (bfd_write ((PTR) nlm_copyright_header (abfd)->copyrightMessage,
+ nlm_copyright_header (abfd)->copyrightMessageLength + 1,
1, abfd) !=
- nlm_copyright_header (abfd) -> copyrightMessageLength + 1)
+ ((bfd_size_type)
+ nlm_copyright_header (abfd)->copyrightMessageLength + 1))
+ return false;
+ }
+
+ /* Write out the custom header if there is one. */
+ if (find_nonzero ((PTR) nlm_custom_header (abfd),
+ sizeof (Nlm_Internal_Custom_Header)))
+ {
+ Nlm_External_Custom_Header thdr;
+ boolean ds;
+ bfd_size_type hdrLength;
+
+ ds = find_nonzero ((PTR) nlm_custom_header (abfd)->dataStamp,
+ sizeof (nlm_custom_header (abfd)->dataStamp));
+ memcpy (thdr.stamp, "CuStHeAd", 8);
+ 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_set_error (bfd_error_system_call);
- return false;
+ BFD_ASSERT (nlm_custom_header (abfd)->hdrLength == 0);
+ if (bfd_write ((PTR) &thdr, 1,
+ sizeof (thdr) - sizeof (thdr.dataStamp), abfd)
+ != sizeof (thdr) - sizeof (thdr.dataStamp))
+ return false;
+ }
+ else
+ {
+ memcpy (thdr.dataStamp, nlm_custom_header (abfd)->dataStamp,
+ sizeof (thdr.dataStamp));
+ if (bfd_write ((PTR) &thdr, sizeof (thdr), 1, abfd) != sizeof (thdr))
+ return false;
+ if (bfd_write (nlm_custom_header (abfd)->hdr, 1,
+ nlm_custom_header (abfd)->hdrLength, abfd)
+ != nlm_custom_header (abfd)->hdrLength)
+ return false;
}
}
+ /* Write out the Cygnus debugging header if there is one. */
+ if (find_nonzero ((PTR) nlm_cygnus_ext_header (abfd),
+ sizeof (Nlm_Internal_Cygnus_Ext_Header)))
+ {
+ Nlm_External_Custom_Header thdr;
+
+ memcpy (thdr.stamp, "CuStHeAd", 8);
+ 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);
+ if (bfd_write ((PTR) &thdr, sizeof (thdr), 1, abfd) != sizeof (thdr))
+ return false;
+ }
+
return true;
}
the count plus 1, since we will NULL terminate the vector allocated based
on this size. */
-unsigned int
-DEFUN (nlm_get_symtab_upper_bound, (abfd), bfd * abfd)
+long
+nlm_get_symtab_upper_bound (abfd)
+ bfd *abfd;
{
Nlm_Internal_Fixed_Header *i_fxdhdrp; /* Nlm file header, internal form */
- unsigned int symcount;
- unsigned int symtab_size = 0;
+ 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
+long
nlm_get_symtab (abfd, alocation)
bfd *abfd;
asymbol **alocation;
bfd_size_type counter = 0;
if (nlm_slurp_symbol_table (abfd) == false)
- return 0;
+ return -1;
symbase = nlm_get_symbols (abfd);
while (counter < bfd_get_symcount (abfd))
{
asymbol *
nlm_make_empty_symbol (abfd)
- bfd * abfd;
+ bfd *abfd;
{
nlm_symbol_type *new;
void
nlm_get_symbol_info (ignore_abfd, symbol, ret)
- bfd * ignore_abfd;
- asymbol * symbol;
- symbol_info * ret;
+ bfd *ignore_abfd ATTRIBUTE_UNUSED;
+ asymbol *symbol;
+ symbol_info *ret;
{
bfd_symbol_info (symbol, ret);
}
void
nlm_print_symbol (abfd, afile, symbol, how)
- bfd *abfd;
+ bfd *abfd ATTRIBUTE_UNUSED;
PTR afile;
asymbol *symbol;
bfd_print_symbol_type how;
case bfd_print_symbol_name:
case bfd_print_symbol_more:
if (symbol->name)
- fprintf (file,"%s", 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);
+ fprintf (file, " %s", symbol->name);
break;
}
}
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_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 *));
use all the NLM symbols, so there will be no space left over at the end.
When we have all the symbols, we build the caller's pointer vector. */
- abfd -> symcount = 0;
+ 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);
}
- if (bfd_seek (abfd, i_fxdhdrp -> publicsOffset, SEEK_SET) == -1)
- {
- bfd_set_error (bfd_error_system_call);
- return (false);
- }
+ if (bfd_seek (abfd, i_fxdhdrp->publicsOffset, SEEK_SET) == -1)
+ return (false);
sym = ((nlm_symbol_type *)
bfd_zalloc (abfd, totsymcount * sizeof (nlm_symbol_type)));
if (!sym)
- {
- bfd_set_error (bfd_error_no_memory);
- return false;
- }
+ return false;
nlm_set_symbols (abfd, sym);
/* We use the bfd's symcount directly as the control count, so that early
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)
+ if (bfd_read ((PTR) & symlength, sizeof (symlength), 1, abfd)
!= sizeof (symlength))
- {
- bfd_set_error (bfd_error_system_call);
- return (false);
- }
- sym -> symbol.the_bfd = abfd;
- sym -> symbol.name = bfd_alloc (abfd, symlength + 1);
- if (!sym -> symbol.name)
- {
- bfd_set_error (bfd_error_no_memory);
- return false;
- }
- if (bfd_read ((PTR) sym -> symbol.name, symlength, 1, abfd)
+ return (false);
+ sym->symbol.the_bfd = abfd;
+ sym->symbol.name = bfd_alloc (abfd, symlength + 1);
+ if (!sym->symbol.name)
+ return false;
+ if (bfd_read ((PTR) sym->symbol.name, symlength, 1, abfd)
!= symlength)
- {
- bfd_set_error (bfd_error_system_call);
- return (false);
- }
+ return (false);
/* Cast away const. */
- ((char *) (sym -> symbol.name))[symlength] = '\0';
+ ((char *) (sym->symbol.name))[symlength] = '\0';
if (bfd_read ((PTR) temp, sizeof (temp), 1, abfd) != sizeof (temp))
- {
- bfd_set_error (bfd_error_system_call);
- return (false);
- }
- sym -> symbol.flags = BSF_GLOBAL | BSF_EXPORT;
- sym -> symbol.value = get_word (abfd, temp);
+ 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
}
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 =
+ 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_set_error (bfd_error_system_call);
- return (false);
- }
+ if (bfd_seek (abfd, i_fxdhdrp->debugInfoOffset, SEEK_SET) == -1)
+ 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)
+ 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)
+ || bfd_read ((PTR) temp, sizeof (temp), 1, abfd) != sizeof (temp)
+ || (bfd_read ((PTR) & symlength, sizeof (symlength), 1, abfd)
!= sizeof (symlength)))
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
- sym -> symbol.the_bfd = abfd;
- sym -> symbol.name = bfd_alloc (abfd, symlength + 1);
- if (!sym -> symbol.name)
- {
- bfd_set_error (bfd_error_no_memory);
- return false;
- }
- if (bfd_read ((PTR) sym -> symbol.name, symlength, 1, abfd)
+ return false;
+ sym->symbol.the_bfd = abfd;
+ sym->symbol.name = bfd_alloc (abfd, symlength + 1);
+ if (!sym->symbol.name)
+ return false;
+ if (bfd_read ((PTR) sym->symbol.name, symlength, 1, abfd)
!= symlength)
- {
- bfd_set_error (bfd_error_system_call);
- return (false);
- }
+ 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 =
+ 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->symbol.section = bfd_abs_section_ptr;
}
- sym -> rcnt = 0;
- abfd -> symcount++;
+ sym->rcnt = 0;
+ abfd->symcount++;
sym++;
}
}
read_import_func = nlm_read_import_func (abfd);
if (read_import_func != NULL)
{
- if (bfd_seek (abfd, i_fxdhdrp -> externalReferencesOffset, SEEK_SET)
+ if (bfd_seek (abfd, i_fxdhdrp->externalReferencesOffset, SEEK_SET)
== -1)
- {
- bfd_set_error (bfd_error_system_call);
- return (false);
- }
-
- symcount += i_fxdhdrp -> numberOfExternalReferences;
- while (abfd -> symcount < symcount)
+ return (false);
+
+ symcount += i_fxdhdrp->numberOfExternalReferences;
+ while (abfd->symcount < symcount)
{
if ((*read_import_func) (abfd, sym) == false)
return false;
if (bfd_seek (abfd, nlm_fixed_header (abfd)->relocationFixupOffset,
SEEK_SET) != 0)
- {
- bfd_set_error (bfd_error_system_call);
- 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_set_error (bfd_error_no_memory);
- return false;
- }
+ if ((rels == NULL || secs == NULL) && count != 0)
+ return false;
nlm_relocation_fixups (abfd) = rels;
nlm_relocation_fixup_secs (abfd) = secs;
since it does not attempt to distinguish them based on the section.
That will be handled when they are actually read. */
-unsigned int
+long
nlm_get_reloc_upper_bound (abfd, sec)
bfd *abfd;
asection *sec;
/* 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;
if (syms == NULL)
{
if (nlm_slurp_symbol_table (abfd) == false)
- return 0;
+ return -1;
syms = nlm_get_symbols (abfd);
}
/* Get the relocs themselves. */
-unsigned int
+long
nlm_canonicalize_reloc (abfd, sec, relptr, symbols)
bfd *abfd;
asection *sec;
if (rels == NULL)
{
if (nlm_slurp_reloc_fixups (abfd) == false)
- return 0;
+ 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
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;
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))
+ 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);
}
/* 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 ((PTR) 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),
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 ((PTR) 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),
+ 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;
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
mangle_relocs_func = nlm_mangle_relocs_func (abfd);
if (mangle_relocs_func != NULL)
{
- if (! (*mangle_relocs_func) (abfd, section, location,
- (bfd_vma) offset, count))
+ 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_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
return true;
}
boolean (*write_prefix_func) PARAMS ((bfd *));
unsigned char *fixed_header = NULL;
- fixed_header = (unsigned char *) malloc (nlm_fixed_header_size (abfd));
+ fixed_header = ((unsigned char *)
+ bfd_malloc ((size_t) nlm_fixed_header_size (abfd)));
if (fixed_header == NULL)
- {
- bfd_set_error (bfd_error_no_memory);
- goto error_return;
- }
+ goto error_return;
if (abfd->output_has_begun == false
&& nlm_compute_section_file_positions (abfd) == false)
/* Write out the variable length headers. */
if (bfd_seek (abfd,
- nlm_optional_prefix_size (abfd) + nlm_fixed_header_size (abfd),
+ nlm_optional_prefix_size (abfd) + nlm_fixed_header_size (abfd),
SEEK_SET) != 0)
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ goto error_return;
if (nlm_swap_variable_header_out (abfd) == false
|| nlm_swap_auxiliary_headers_out (abfd) == false)
{
/* Advance to the relocs. */
if (bfd_seek (abfd, nlm_fixed_header (abfd)->relocationFixupOffset,
SEEK_SET) != 0)
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ goto error_return;
/* The format of the relocation entries is dependent upon the
particular target. We use an external routine to write the reloc
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;
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)
(external_reloc_count
* sizeof (struct reloc_and_sec)));
if (external_relocs == (struct reloc_and_sec *) NULL)
- {
- bfd_set_error (bfd_error_no_memory);
- goto error_return;
- }
+ goto error_return;
i = 0;
for (sec = abfd->sections; sec != (asection *) NULL; sec = sec->next)
{
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;
if (sym_ptr_ptr != (asymbol **) NULL)
{
bfd_vma (*get_public_offset_func) PARAMS ((bfd *, asymbol *));
- boolean (*write_export_func) PARAMS ((bfd*, asymbol *, bfd_vma));
+ boolean (*write_export_func) PARAMS ((bfd *, asymbol *, bfd_vma));
asymbol **sym_end;
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;
if ((bfd_write (&len, sizeof (bfd_byte), 1, abfd)
!= sizeof (bfd_byte))
|| bfd_write (sym->name, len, 1, abfd) != len)
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
-
+ goto error_return;
+
put_word (abfd, offset, temp);
if (bfd_write (temp, sizeof (temp), 1, abfd) != sizeof (temp))
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
- }
+ goto error_return;
+ }
}
nlm_fixed_header (abfd)->numberOfPublics = c;
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;
/* The type is 0 for data, 1 for code, 2 for absolute. */
if (bfd_write (&type, sizeof (bfd_byte), 1, abfd)
!= sizeof (bfd_byte))
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ goto error_return;
put_word (abfd, offset, temp);
if (bfd_write (temp, sizeof (temp), 1, abfd) != sizeof (temp))
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ goto error_return;
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_set_error (bfd_error_system_call);
- goto error_return;
- }
- }
+ goto error_return;
+ }
nlm_fixed_header (abfd)->numberOfDebugRecords = c;
}
}
if (bfd_seek (abfd, 0, SEEK_SET) != 0)
goto error_return;
-
+
write_prefix_func = nlm_write_prefix_func (abfd);
if (write_prefix_func)
{
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)
!= nlm_fixed_header_size (abfd))
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ goto error_return;
if (fixed_header != NULL)
free (fixed_header);
return true;
- error_return:
+error_return:
if (fixed_header != NULL)
free (fixed_header);
return false;
projects / deliverable / binutils-gdb.git / blobdiff