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"
#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_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)
+#define nlm_swap_fixed_header_out(abfd,src,dst) \
+ (nlm_swap_fixed_header_out_func(abfd))(abfd,src,dst)
+
/* Forward declarations of static functions */
static boolean add_bfd_section
PARAMS ((bfd *, char *, file_ptr, bfd_size_type, flagword));
-static void nlm_swap_fixed_header_in
- PARAMS ((bfd *, Nlm_External_Fixed_Header *, Nlm_Internal_Fixed_Header *));
-static void nlm_swap_fixed_header_out
- PARAMS ((bfd *, Nlm_Internal_Fixed_Header *, Nlm_External_Fixed_Header *));
static boolean nlm_swap_variable_header_in
PARAMS ((bfd *));
static boolean nlm_swap_variable_header_out
#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;
{
- Nlm_External_Fixed_Header x_fxdhdr; /* Nlm file header, external form */
- Nlm_Internal_Fixed_Header *i_fxdhdrp; /* Nlm file header, internal form */
+ 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;
+ /* 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. */
- if (bfd_read ((PTR) &x_fxdhdr, sizeof (x_fxdhdr), 1, abfd) !=
- sizeof (x_fxdhdr))
+ x_fxdhdr = (PTR) malloc ((size_t) nlm_fixed_header_size (abfd));
+ if (x_fxdhdr == NULL)
{
- bfd_error = system_call_error;
- return (NULL);
+ bfd_set_error (bfd_error_no_memory);
+ goto got_no_match;
}
- /* Check to see if we have an NLM file by matching the NLM signature. */
-
- if (strncmp (x_fxdhdr.signature, NLM_SIGNATURE, NLM_SIGNATURE_SIZE) != 0)
+ if (bfd_read ((PTR) x_fxdhdr, nlm_fixed_header_size (abfd), 1, abfd) !=
+ nlm_fixed_header_size (abfd))
{
- wrong:
- bfd_error = wrong_format;
- return (NULL);
+ 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. */
+
+ 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. */
+
+ 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 (get_word (abfd, (bfd_byte *) x_fxdhdr.version) > 0xFFFF)
- {
- goto wrong;
- }
+ 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) */
- /* 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)
+ /* Swap in the rest of the required header. */
+ if (!nlm_swap_variable_header_in (abfd))
{
- bfd_error = no_memory;
- return (NULL);
+ if (bfd_get_error () != bfd_error_system_call)
+ goto got_wrong_format_error;
+ else
+ goto got_no_match;
}
- /* FIXME: Any `wrong' exits below here will leak memory (tdata). */
-
- /* Swap in the rest of the fixed length header. */
-
- i_fxdhdrp = nlm_fixed_header (abfd);
- nlm_swap_fixed_header_in (abfd, &x_fxdhdr, i_fxdhdrp);
-
- if (!nlm_swap_variable_header_in (abfd)
- || !nlm_swap_auxiliary_headers_in (abfd)
- || !add_bfd_section (abfd, NLM_CODE_NAME,
- i_fxdhdrp -> codeImageOffset,
- i_fxdhdrp -> codeImageSize,
- (SEC_CODE | SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
- | 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))
- {
- return (NULL);
- }
+ 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)->numberOfDebugRecords != 0
+ || nlm_fixed_header (abfd)->numberOfExternalReferences != 0)
abfd->flags |= HAS_SYMS;
arch = nlm_architecture (abfd);
if (arch != bfd_arch_unknown)
bfd_default_set_arch_mach (abfd, arch, (unsigned long) 0);
- return (abfd -> xvec);
+ 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 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);
}
-/* Translate an NLM fixed length file header in external format into an NLM
- file header in internal format. */
-
-static void
-DEFUN (nlm_swap_fixed_header_in, (abfd, src, dst),
- bfd * abfd AND
- Nlm_External_Fixed_Header * src AND
- Nlm_Internal_Fixed_Header * dst)
-{
- memcpy (dst -> signature, src -> signature, NLM_SIGNATURE_SIZE);
- memcpy (dst -> moduleName, src -> moduleName, NLM_MODULE_NAME_SIZE);
- dst -> version =
- get_word (abfd, (bfd_byte *) src -> version);
- dst -> codeImageOffset =
- get_word (abfd, (bfd_byte *) src -> codeImageOffset);
- dst -> codeImageSize =
- get_word (abfd, (bfd_byte *) src -> codeImageSize);
- dst -> dataImageOffset =
- get_word (abfd, (bfd_byte *) src -> dataImageOffset);
- dst -> dataImageSize =
- get_word (abfd, (bfd_byte *) src -> dataImageSize);
- dst -> uninitializedDataSize =
- get_word (abfd, (bfd_byte *) src -> uninitializedDataSize);
- dst -> customDataOffset =
- get_word (abfd, (bfd_byte *) src -> customDataOffset);
- dst -> customDataSize =
- get_word (abfd, (bfd_byte *) src -> customDataSize);
- dst -> moduleDependencyOffset =
- get_word (abfd, (bfd_byte *) src -> moduleDependencyOffset);
- dst -> numberOfModuleDependencies =
- get_word (abfd, (bfd_byte *) src -> numberOfModuleDependencies);
- dst -> relocationFixupOffset =
- get_word (abfd, (bfd_byte *) src -> relocationFixupOffset);
- dst -> numberOfRelocationFixups =
- get_word (abfd, (bfd_byte *) src -> numberOfRelocationFixups);
- dst -> externalReferencesOffset =
- get_word (abfd, (bfd_byte *) src -> externalReferencesOffset);
- dst -> numberOfExternalReferences =
- get_word (abfd, (bfd_byte *) src -> numberOfExternalReferences);
- dst -> publicsOffset =
- get_word (abfd, (bfd_byte *) src -> publicsOffset);
- dst -> numberOfPublics =
- get_word (abfd, (bfd_byte *) src -> numberOfPublics);
- dst -> debugInfoOffset =
- get_word (abfd, (bfd_byte *) src -> debugInfoOffset);
- dst -> numberOfDebugRecords =
- get_word (abfd, (bfd_byte *) src -> numberOfDebugRecords);
- dst -> codeStartOffset =
- get_word (abfd, (bfd_byte *) src -> codeStartOffset);
- dst -> exitProcedureOffset =
- get_word (abfd, (bfd_byte *) src -> exitProcedureOffset);
- dst -> checkUnloadProcedureOffset =
- get_word (abfd, (bfd_byte *) src -> checkUnloadProcedureOffset);
- dst -> moduleType =
- get_word (abfd, (bfd_byte *) src -> moduleType);
- dst -> flags =
- get_word (abfd, (bfd_byte *) src -> flags);
-}
-
-/* Translate an NLM fixed length file header in internal format into
- an NLM file header in external format. */
-
-static void
-DEFUN (nlm_swap_fixed_header_out, (abfd, src, dst),
- bfd * abfd AND
- Nlm_Internal_Fixed_Header * src AND
- Nlm_External_Fixed_Header * dst)
-{
- memcpy (dst -> signature, src -> signature, NLM_SIGNATURE_SIZE);
- memcpy (dst -> moduleName, src -> moduleName, NLM_MODULE_NAME_SIZE);
- put_word (abfd, (bfd_vma) src -> version,
- (bfd_byte *) dst -> version);
- put_word (abfd, (bfd_vma) src -> codeImageOffset,
- (bfd_byte *) dst -> codeImageOffset);
- put_word (abfd, (bfd_vma) src -> codeImageSize,
- (bfd_byte *) dst -> codeImageSize);
- put_word (abfd, (bfd_vma) src -> dataImageOffset,
- (bfd_byte *) dst -> dataImageOffset);
- put_word (abfd, (bfd_vma) src -> dataImageSize,
- (bfd_byte *) dst -> dataImageSize);
- put_word (abfd, (bfd_vma) src -> uninitializedDataSize,
- (bfd_byte *) dst -> uninitializedDataSize);
- put_word (abfd, (bfd_vma) src -> customDataOffset,
- (bfd_byte *) dst -> customDataOffset);
- put_word (abfd, (bfd_vma) src -> customDataSize,
- (bfd_byte *) dst -> customDataSize);
- put_word (abfd, (bfd_vma) src -> moduleDependencyOffset,
- (bfd_byte *) dst -> moduleDependencyOffset);
- put_word (abfd, (bfd_vma) src -> numberOfModuleDependencies,
- (bfd_byte *) dst -> numberOfModuleDependencies);
- put_word (abfd, (bfd_vma) src -> relocationFixupOffset,
- (bfd_byte *) dst -> relocationFixupOffset);
- put_word (abfd, (bfd_vma) src -> numberOfRelocationFixups,
- (bfd_byte *) dst -> numberOfRelocationFixups);
- put_word (abfd, (bfd_vma) src -> externalReferencesOffset,
- (bfd_byte *) dst -> externalReferencesOffset);
- put_word (abfd, (bfd_vma) src -> numberOfExternalReferences,
- (bfd_byte *) dst -> numberOfExternalReferences);
- put_word (abfd, (bfd_vma) src -> publicsOffset,
- (bfd_byte *) dst -> publicsOffset);
- put_word (abfd, (bfd_vma) src -> numberOfPublics,
- (bfd_byte *) dst -> numberOfPublics);
- put_word (abfd, (bfd_vma) src -> debugInfoOffset,
- (bfd_byte *) dst -> debugInfoOffset);
- put_word (abfd, (bfd_vma) src -> numberOfDebugRecords,
- (bfd_byte *) dst -> numberOfDebugRecords);
- put_word (abfd, (bfd_vma) src -> codeStartOffset,
- (bfd_byte *) dst -> codeStartOffset);
- put_word (abfd, (bfd_vma) src -> exitProcedureOffset,
- (bfd_byte *) dst -> exitProcedureOffset);
- put_word (abfd, (bfd_vma) src -> checkUnloadProcedureOffset,
- (bfd_byte *) dst -> checkUnloadProcedureOffset);
- put_word (abfd, (bfd_vma) src -> moduleType,
- (bfd_byte *) dst -> moduleType);
- put_word (abfd, (bfd_vma) src -> flags,
- (bfd_byte *) dst -> flags);
-}
-
/* Read and swap in the variable length header. All the fields must
exist in the NLM, and must exist in the order they are read here. */
static boolean
-DEFUN (nlm_swap_variable_header_in, (abfd),
- bfd * abfd)
+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_error = system_call_error;
- 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_error = system_call_error;
- 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_error = system_call_error;
- 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_error = system_call_error;
- 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_error = system_call_error;
- 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_error = system_call_error;
- 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_error = system_call_error;
- 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_error = system_call_error;
- 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_error = system_call_error;
- 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_error = system_call_error;
- 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_error = system_call_error;
- 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_error = system_call_error;
- 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_error = system_call_error;
- 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_error = system_call_error;
- 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_error = system_call_error;
- 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_error = system_call_error;
- 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_error = system_call_error;
- 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_error = system_call_error;
- 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;
{
- unsigned 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_error = system_call_error;
- return (false);
- }
+ return (false);
if (bfd_seek (abfd, position, SEEK_SET) == -1)
- {
- bfd_error = system_call_error;
- 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_error = system_call_error;
- 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_error = system_call_error;
- 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) -> SharedInitializationOffset =
+ nlm_extended_header (abfd)->sharedDebugRecordOffset =
+ get_word (abfd, (bfd_byte *) thdr.sharedDebugRecordOffset);
+ nlm_extended_header (abfd)->sharedDebugRecordCount =
+ get_word (abfd, (bfd_byte *) thdr.sharedDebugRecordCount);
+ 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, "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;
- if (bfd_read ((PTR) &thdr, sizeof (thdr), 1, abfd) != sizeof (thdr))
+ bfd_size_type hdrLength;
+ file_ptr dataOffset;
+ bfd_size_type dataLength;
+ char dataStamp[8];
+ 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_error = system_call_error;
- 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);
}
- memcpy (nlm_custom_header (abfd) -> stamp, thdr.stamp,
- sizeof (thdr.stamp));
- nlm_custom_header (abfd) -> dataLength =
- get_word (abfd, (bfd_byte *) thdr.dataLength);
- nlm_custom_header (abfd) -> debugRecOffset =
- get_word (abfd, (bfd_byte *) thdr.debugRecOffset);
- nlm_custom_header (abfd) -> debugRecLength =
- get_word (abfd, (bfd_byte *) thdr.debugRecLength);
- }
- else if (strncmp (tempstr, "CoPyRiGhT=", 10) == 0)
- {
- Nlm_External_Copyright_Header thdr;
- if (bfd_read ((PTR) &thdr, sizeof (thdr), 1, abfd) != sizeof (thdr))
+ if (hdrLength < 2 * NLM_TARGET_LONG_SIZE)
+ dataLength = 0;
+ else
{
- bfd_error = system_call_error;
- 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);
}
- memcpy (nlm_copyright_header (abfd) -> stamp, thdr.stamp,
- sizeof (thdr.stamp));
- nlm_copyright_header (abfd) -> copyrightMessageLength =
- get_word (abfd, (bfd_byte *) thdr.copyrightMessageLength);
- /* The copyright message is a variable length string. */
- if (bfd_read ((PTR) nlm_copyright_header (abfd) -> copyrightMessage,
- nlm_copyright_header (abfd) -> copyrightMessageLength + 1,
- 1, abfd) !=
- nlm_copyright_header (abfd) -> copyrightMessageLength + 1)
+ if (hdrLength < 2 * NLM_TARGET_LONG_SIZE + 8)
+ memset (dataStamp, 0, sizeof (dataStamp));
+ else
+ {
+ 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)
{
- bfd_error = system_call_error;
- return (false);
+ 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_error = system_call_error;
- 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) -> SharedInitializationOffset,
+ (bfd_vma) nlm_extended_header (abfd)->sharedDebugRecordOffset,
+ (bfd_byte *) thdr.sharedDebugRecordOffset);
+ put_word (abfd,
+ (bfd_vma) nlm_extended_header (abfd)->sharedDebugRecordCount,
+ (bfd_byte *) thdr.sharedDebugRecordCount);
+ put_word (abfd,
+ (bfd_vma) nlm_extended_header (abfd)->SharedInitializationOffset,
(bfd_byte *) thdr.sharedInitializationOffset);
put_word (abfd,
- (bfd_vma) nlm_extended_header (abfd) -> SharedExitProcedureOffset,
+ (bfd_vma) nlm_extended_header (abfd)->SharedExitProcedureOffset,
(bfd_byte *) thdr.SharedExitProcedureOffset);
put_word (abfd,
- (bfd_vma) nlm_extended_header (abfd) -> productID,
+ (bfd_vma) nlm_extended_header (abfd)->productID,
(bfd_byte *) thdr.productID);
put_word (abfd,
- (bfd_vma) nlm_extended_header (abfd) -> reserved0,
+ (bfd_vma) nlm_extended_header (abfd)->reserved0,
(bfd_byte *) thdr.reserved0);
put_word (abfd,
- (bfd_vma) nlm_extended_header (abfd) -> reserved1,
+ (bfd_vma) nlm_extended_header (abfd)->reserved1,
(bfd_byte *) thdr.reserved1);
put_word (abfd,
- (bfd_vma) nlm_extended_header (abfd) -> reserved2,
+ (bfd_vma) nlm_extended_header (abfd)->reserved2,
(bfd_byte *) thdr.reserved2);
put_word (abfd,
- (bfd_vma) nlm_extended_header (abfd) -> reserved3,
+ (bfd_vma) nlm_extended_header (abfd)->reserved3,
(bfd_byte *) thdr.reserved3);
put_word (abfd,
- (bfd_vma) nlm_extended_header (abfd) -> reserved4,
+ (bfd_vma) nlm_extended_header (abfd)->reserved4,
(bfd_byte *) thdr.reserved4);
put_word (abfd,
- (bfd_vma) nlm_extended_header (abfd) -> reserved5,
+ (bfd_vma) nlm_extended_header (abfd)->reserved5,
(bfd_byte *) thdr.reserved5);
- if (bfd_write ((PTR) &thdr, sizeof (thdr), 1, abfd) != sizeof (thdr))
- {
- bfd_error = system_call_error;
- return false;
- }
+ if (bfd_write ((PTR) & thdr, sizeof (thdr), 1, abfd) != sizeof (thdr))
+ return false;
+ }
+
+
+ /* Write out the copyright header if there is one. */
+ if (find_nonzero ((PTR) nlm_copyright_header (abfd),
+ sizeof (Nlm_Internal_Copyright_Header)))
+ {
+ Nlm_External_Copyright_Header thdr;
+
+ memcpy (thdr.stamp, "CoPyRiGhT=", 10);
+ if (bfd_write ((PTR) thdr.stamp, sizeof (thdr.stamp), 1, abfd)
+ != sizeof (thdr.stamp))
+ return false;
+ thdr.copyrightMessageLength[0] =
+ nlm_copyright_header (abfd)->copyrightMessageLength;
+ if (bfd_write ((PTR) thdr.copyrightMessageLength, 1, 1, abfd) != 1)
+ return false;
+ /* The copyright message is a variable length string. */
+ if (bfd_write ((PTR) nlm_copyright_header (abfd)->copyrightMessage,
+ nlm_copyright_header (abfd)->copyrightMessageLength + 1,
+ 1, abfd) !=
+ ((bfd_size_type)
+ nlm_copyright_header (abfd)->copyrightMessageLength + 1))
+ return false;
}
/* Write out the custom header if there is one. */
sizeof (Nlm_Internal_Custom_Header)))
{
Nlm_External_Custom_Header thdr;
+ boolean ds;
+ bfd_size_type hdrLength;
- /* Right now we assume the custom header is always the suggested
- format for alternate debugging records. */
- BFD_ASSERT (nlm_custom_header (abfd) -> dataLength == 8);
-
+ ds = find_nonzero ((PTR) nlm_custom_header (abfd)->dataStamp,
+ sizeof (nlm_custom_header (abfd)->dataStamp));
memcpy (thdr.stamp, "CuStHeAd", 8);
- put_word (abfd, (bfd_vma) nlm_custom_header (abfd) -> dataLength,
- (bfd_byte *) thdr.dataLength);
- put_word (abfd, (bfd_vma) nlm_custom_header (abfd) -> debugRecOffset,
- (bfd_byte *) thdr.debugRecOffset);
- put_word (abfd, (bfd_vma) nlm_custom_header (abfd) -> debugRecLength,
- (bfd_byte *) thdr.debugRecLength);
- if (bfd_write ((PTR) &thdr, sizeof (thdr), 1, abfd) != sizeof (thdr))
- {
- bfd_error = system_call_error;
+ 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_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 copyright header if there is one. */
- if (find_nonzero ((PTR) nlm_copyright_header (abfd),
- sizeof (Nlm_Internal_Copyright_Header)))
+ /* 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_Copyright_Header thdr;
+ Nlm_External_Custom_Header thdr;
- memcpy (thdr.stamp, "CoPyRiGhT=", 10);
- put_word (abfd,
- (bfd_vma) nlm_copyright_header (abfd) -> copyrightMessageLength,
- (bfd_byte *) thdr.copyrightMessageLength);
+ 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))
- {
- bfd_error = system_call_error;
- return false;
- }
- /* The copyright message is a variable length string. */
- if (bfd_write ((PTR) nlm_copyright_header (abfd) -> copyrightMessage,
- nlm_copyright_header (abfd) -> copyrightMessageLength + 1,
- 1, abfd) !=
- nlm_copyright_header (abfd) -> copyrightMessageLength + 1)
- {
- bfd_error = system_call_error;
- return false;
- }
+ 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 -> 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;
new = (nlm_symbol_type *) bfd_zalloc (abfd, sizeof (nlm_symbol_type));
- new->symbol.the_bfd = abfd;
+ if (new)
+ new->symbol.the_bfd = abfd;
return &new->symbol;
}
void
nlm_get_symbol_info (ignore_abfd, symbol, ret)
- bfd * ignore_abfd;
- asymbol * symbol;
- symbol_info * ret;
+ bfd *ignore_abfd;
+ asymbol *symbol;
+ symbol_info *ret;
{
bfd_symbol_info (symbol, ret);
}
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;
}
}
N bytes the symbol name
4 bytes the symbol offset from start of it's section
- Note that we currently ignore the internal debug records. There is
- a lot of duplication between the export records and the internal debug
- records. We may in the future, want to merge the information from the
- debug records with the information from the export records to produce
- a more complete symbol table, treating additional information from the
- debug records as static symbols. (FIXME)
-
- We do read in the import records. These are treated as undefined
- symbols. As we read them in we also read in the associated reloc
- information, which is attached to the symbol.
+ We also read in the debugging symbols and import records. Import
+ records are treated as undefined symbols. As we read the import
+ records we also read in the associated reloc information, which is
+ attached to the symbol.
The bfd symbols are copied to SYMPTRS.
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 */
- char symlength; /* Symbol length read into here */
- bfd_size_type rcount; /* Number of relocs */
+ 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_reloc_func) PARAMS ((bfd *, nlm_symbol_type *, asection **,
- arelent *));
+ boolean (*read_import_func) PARAMS ((bfd *, nlm_symbol_type *));
+ boolean (*set_public_section_func) PARAMS ((bfd *, nlm_symbol_type *));
if (nlm_get_symbols (abfd) != NULL)
return (true);
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 -> 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_error = system_call_error;
- 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)
+ return false;
nlm_set_symbols (abfd, sym);
/* We use the bfd's symcount directly as the control count, so that early
termination of the loop leaves the symcount correct for the symbols that
were read. */
- symcount = i_fxdhdrp -> numberOfPublics;
- while (abfd -> symcount < symcount)
+ set_public_section_func = nlm_set_public_section_func (abfd);
+ 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_error = system_call_error;
- return (false);
- }
- sym -> symbol.the_bfd = abfd;
- sym -> symbol.name = bfd_alloc (abfd, symlength + 1);
- if (bfd_read ((PTR) sym -> symbol.name, symlength, 1, abfd)
+ 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_error = system_call_error;
- return (false);
- }
+ return (false);
+ /* Cast away const. */
+ ((char *) (sym->symbol.name))[symlength] = '\0';
if (bfd_read ((PTR) temp, sizeof (temp), 1, abfd) != sizeof (temp))
+ return (false);
+ sym->symbol.flags = BSF_GLOBAL | BSF_EXPORT;
+ sym->symbol.value = get_word (abfd, temp);
+ if (set_public_section_func)
{
- bfd_error = system_call_error;
- return (false);
- }
- sym -> symbol.flags = BSF_GLOBAL | BSF_EXPORT;
- sym -> symbol.value = get_word (abfd, temp);
- if (sym -> symbol.value & NLM_HIBIT)
- {
- sym -> symbol.value &= ~NLM_HIBIT;
- sym -> symbol.flags |= BSF_FUNCTION;
- sym -> symbol.section =
- bfd_get_section_by_name (abfd, NLM_CODE_NAME);
+ /* Most backends can use the code below, but unfortunately
+ some use a different scheme. */
+ if ((*set_public_section_func) (abfd, sym) == false)
+ return false;
}
else
{
- sym -> symbol.section =
- bfd_get_section_by_name (abfd, NLM_INITIALIZED_DATA_NAME);
+ if (sym->symbol.value & NLM_HIBIT)
+ {
+ sym->symbol.value &= ~NLM_HIBIT;
+ sym->symbol.flags |= BSF_FUNCTION;
+ sym->symbol.section =
+ bfd_get_section_by_name (abfd, NLM_CODE_NAME);
+ }
+ else
+ {
+ sym->symbol.section =
+ bfd_get_section_by_name (abfd, NLM_INITIALIZED_DATA_NAME);
+ }
}
- sym -> rcnt = 0;
- abfd -> symcount++;
+ sym->rcnt = 0;
+ abfd->symcount++;
sym++;
}
- /* Read in the import records. We can only do this if we know how
- to read relocs for this target. */
+ /* Read the debugging records. */
- read_reloc_func = nlm_read_reloc_func (abfd);
- if (read_reloc_func != NULL)
+ if (i_fxdhdrp->numberOfDebugRecords > 0)
{
- if (bfd_seek (abfd, i_fxdhdrp -> externalReferencesOffset, SEEK_SET)
- == -1)
- {
- bfd_error = system_call_error;
- return (false);
- }
-
- symcount += i_fxdhdrp -> numberOfExternalReferences;
- while (abfd -> symcount < symcount)
- {
- struct nlm_relent *nlm_relocs;
+ if (bfd_seek (abfd, i_fxdhdrp->debugInfoOffset, SEEK_SET) == -1)
+ return (false);
- if (bfd_read ((PTR) &symlength, sizeof (symlength), 1, abfd)
- != sizeof (symlength))
- {
- bfd_error = system_call_error;
- return (false);
- }
- sym -> symbol.the_bfd = abfd;
- sym -> symbol.name = bfd_alloc (abfd, symlength + 1);
- if (bfd_read ((PTR) sym -> symbol.name, symlength, 1, abfd)
+ symcount += i_fxdhdrp->numberOfDebugRecords;
+ while (abfd->symcount < symcount)
+ {
+ if ((bfd_read ((PTR) & symtype, sizeof (symtype), 1, abfd)
+ != sizeof (symtype))
+ || bfd_read ((PTR) temp, sizeof (temp), 1, abfd) != sizeof (temp)
+ || (bfd_read ((PTR) & symlength, sizeof (symlength), 1, abfd)
+ != sizeof (symlength)))
+ 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)
+ 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)
{
- bfd_error = system_call_error;
- return (false);
+ sym->symbol.section =
+ bfd_get_section_by_name (abfd, NLM_INITIALIZED_DATA_NAME);
}
- sym -> symbol.flags = 0;
- sym -> symbol.value = 0;
- sym -> symbol.section = &bfd_und_section;
- if (bfd_read ((PTR) temp, sizeof (temp), 1, abfd) != sizeof (temp))
+ else if (symtype == 1)
{
- bfd_error = system_call_error;
- return (false);
+ sym->symbol.flags |= BSF_FUNCTION;
+ sym->symbol.section =
+ bfd_get_section_by_name (abfd, NLM_CODE_NAME);
}
- rcount = get_word (abfd, temp);
- nlm_relocs = ((struct nlm_relent *)
- bfd_alloc (abfd, rcount * sizeof (struct nlm_relent)));
- sym -> relocs = nlm_relocs;
- sym -> rcnt = 0;
- while (sym -> rcnt < rcount)
+ else
{
- asection *section;
-
- if ((*read_reloc_func) (abfd, sym, §ion,
- &nlm_relocs -> reloc)
- == false)
- return false;
- nlm_relocs -> section = section;
- nlm_relocs++;
- sym -> rcnt++;
+ sym->symbol.section = bfd_abs_section_ptr;
}
+ sym->rcnt = 0;
+ abfd->symcount++;
+ sym++;
+ }
+ }
+
+ /* Read in the import records. We can only do this if we know how
+ to read relocs for this target. */
- abfd -> symcount++;
+ read_import_func = nlm_read_import_func (abfd);
+ if (read_import_func != NULL)
+ {
+ if (bfd_seek (abfd, i_fxdhdrp->externalReferencesOffset, SEEK_SET)
+ == -1)
+ return (false);
+
+ symcount += i_fxdhdrp->numberOfExternalReferences;
+ while (abfd->symcount < symcount)
+ {
+ if ((*read_import_func) (abfd, sym) == false)
+ return false;
sym++;
+ abfd->symcount++;
}
}
if (bfd_seek (abfd, nlm_fixed_header (abfd)->relocationFixupOffset,
SEEK_SET) != 0)
- {
- bfd_error = system_call_error;
- return false;
- }
+ return false;
count = nlm_fixed_header (abfd)->numberOfRelocationFixups;
rels = (arelent *) bfd_alloc (abfd, count * sizeof (arelent));
secs = (asection **) bfd_alloc (abfd, count * sizeof (asection *));
- if (rels == NULL || secs == NULL)
- {
- bfd_error = no_memory;
- return false;
- }
+ 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;
if (abfd->output_has_begun == true)
return true;
+ /* Make sure we have a section to hold uninitialized data. */
+ bss_sec = bfd_get_section_by_name (abfd, NLM_UNINITIALIZED_DATA_NAME);
+ if (bss_sec == NULL)
+ {
+ if (!add_bfd_section (abfd, NLM_UNINITIALIZED_DATA_NAME,
+ (file_ptr) 0, (bfd_size_type) 0,
+ SEC_ALLOC))
+ return false;
+ bss_sec = bfd_get_section_by_name (abfd, NLM_UNINITIALIZED_DATA_NAME);
+ }
+
abfd->output_has_begun = true;
/* The fixed header. */
- sofar = sizeof (Nlm_External_Fixed_Header);
+ sofar = nlm_optional_prefix_size (abfd) + nlm_fixed_header_size (abfd);
/* The variable header. */
sofar += (sizeof (nlm_variable_header (abfd)->descriptionLength)
- + nlm_variable_header (abfd) -> descriptionLength + 1
- + NLM_TARGET_LONG_SIZE /* stackSize */
- + NLM_TARGET_LONG_SIZE /* reserved */
- + sizeof (nlm_variable_header (abfd) -> oldThreadName)
- + sizeof (nlm_variable_header (abfd) -> screenNameLength)
- + nlm_variable_header (abfd) -> screenNameLength + 1
- + sizeof (nlm_variable_header (abfd) -> threadNameLength)
- + nlm_variable_header (abfd) -> threadNameLength + 1);
+ + nlm_variable_header (abfd)->descriptionLength + 1
+ + NLM_TARGET_LONG_SIZE /* stackSize */
+ + NLM_TARGET_LONG_SIZE /* reserved */
+ + sizeof (nlm_variable_header (abfd)->oldThreadName)
+ + sizeof (nlm_variable_header (abfd)->screenNameLength)
+ + nlm_variable_header (abfd)->screenNameLength + 1
+ + sizeof (nlm_variable_header (abfd)->threadNameLength)
+ + nlm_variable_header (abfd)->threadNameLength + 1);
/* The auxiliary headers. */
if (find_nonzero ((PTR) nlm_version_header (abfd),
if (find_nonzero ((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;
nlm_set_text_low (abfd, text_low);
nlm_set_data_low (abfd, data_low);
+ if (nlm_no_uninitialized_data (abfd))
+ {
+ /* This NetWare format does not use uninitialized data. We must
+ increase the size of the data section. We will never wind up
+ writing those file locations, so they will remain zero. */
+ data += bss;
+ bss = 0;
+ }
+
text_ptr = BFD_ALIGN (sofar, 1 << text_align);
data_ptr = BFD_ALIGN (text_ptr + text, 1 << data_align);
other_ptr = BFD_ALIGN (data_ptr + data, 1 << other_align);
if (sym_ptr_ptr != NULL)
{
asymbol **sym_end;
- asection *bss_sec;
bfd_vma add;
- /* Make sure we have a section to hold uninitialized data. */
- bss_sec = bfd_get_section_by_name (abfd, NLM_UNINITIALIZED_DATA_NAME);
- if (bss_sec == NULL)
- {
- if (! add_bfd_section (abfd, NLM_UNINITIALIZED_DATA_NAME,
- (file_ptr) 0, (bfd_size_type) 0,
- SEC_ALLOC))
- return false;
- bss_sec = bfd_get_section_by_name (abfd,
- NLM_UNINITIALIZED_DATA_NAME);
- bss_sec->vma = data_low + data;
- }
-
sym_end = sym_ptr_ptr + bfd_get_symcount (abfd);
add = 0;
for (; sym_ptr_ptr < sym_end; sym_ptr_ptr++)
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
add += size;
add = BFD_ALIGN (add, 1 << bss_sec->alignment_power);
}
- nlm_fixed_header (abfd)->uninitializedDataSize += add;
- bss_sec->_raw_size += add;
+ if (add != 0)
+ {
+ if (nlm_no_uninitialized_data (abfd))
+ {
+ /* We could handle this case, but so far it hasn't been
+ necessary. */
+ abort ();
+ }
+ nlm_fixed_header (abfd)->uninitializedDataSize += add;
+ bss_sec->_raw_size += add;
+ }
}
return true;
the relocs are already acceptable, this will not do anything. */
if (section->reloc_count != 0)
{
- boolean (*mangle_relocs_func) PARAMS ((bfd *, asection *, PTR data,
- bfd_vma offset,
- bfd_size_type count));
+ boolean (*mangle_relocs_func) PARAMS ((bfd *, asection *, PTR,
+ bfd_vma, bfd_size_type));
mangle_relocs_func = nlm_mangle_relocs_func (abfd);
if (mangle_relocs_func != NULL)
{
- if (! (*mangle_relocs_func) (abfd, section, location,
- (bfd_vma) offset, count))
+ if (!(*mangle_relocs_func) (abfd, section, location,
+ (bfd_vma) offset, count))
return false;
}
}
if (bfd_seek (abfd, (file_ptr) (section->filepos + offset), SEEK_SET) != 0
|| bfd_write (location, 1, count, abfd) != count)
- {
- bfd_error = system_call_error;
- return false;
- }
+ return false;
return true;
}
/* We need to sort a list of relocs associated with sections when we
write out the external relocs. */
-struct reloc_and_sec
-{
- arelent *rel;
- asection *sec;
-};
-
static int
nlm_external_reloc_compare (p1, p2)
const void *p1;
{
const struct reloc_and_sec *r1 = (const struct reloc_and_sec *) p1;
const struct reloc_and_sec *r2 = (const struct reloc_and_sec *) p2;
+ int cmp;
- return strcmp ((*r1->rel->sym_ptr_ptr)->name,
- (*r2->rel->sym_ptr_ptr)->name);
+ cmp = strcmp ((*r1->rel->sym_ptr_ptr)->name,
+ (*r2->rel->sym_ptr_ptr)->name);
+ if (cmp != 0)
+ return cmp;
+
+ /* We sort by address within symbol to make the sort more stable and
+ increase the chances that different hosts will generate bit for
+ bit equivalent results. */
+ return (int) (r1->rel->address - r2->rel->address);
}
/* Write out an NLM file. We write out the information in this order:
nlm_write_object_contents (abfd)
bfd *abfd;
{
- Nlm_External_Fixed_Header fixed_header;
asection *sec;
- boolean (*write_reloc_func) PARAMS ((bfd *, asection *, arelent *));
+ boolean (*write_import_func) PARAMS ((bfd *, asection *, arelent *));
bfd_size_type external_reloc_count, internal_reloc_count, i, c;
struct reloc_and_sec *external_relocs;
asymbol **sym_ptr_ptr;
+ file_ptr last;
+ boolean (*write_prefix_func) PARAMS ((bfd *));
+ unsigned char *fixed_header = NULL;
+
+ fixed_header = ((unsigned char *)
+ malloc ((size_t) nlm_fixed_header_size (abfd)));
+ if (fixed_header == NULL)
+ {
+ bfd_set_error (bfd_error_no_memory);
+ goto error_return;
+ }
if (abfd->output_has_begun == false
&& nlm_compute_section_file_positions (abfd) == false)
- return false;
+ goto error_return;
/* Write out the variable length headers. */
- if (bfd_seek (abfd, sizeof (Nlm_External_Fixed_Header), SEEK_SET) != 0)
- {
- bfd_error = system_call_error;
- return false;
- }
+ if (bfd_seek (abfd,
+ nlm_optional_prefix_size (abfd) + nlm_fixed_header_size (abfd),
+ SEEK_SET) != 0)
+ goto error_return;
if (nlm_swap_variable_header_out (abfd) == false
|| nlm_swap_auxiliary_headers_out (abfd) == false)
{
- bfd_error = system_call_error;
- return false;
+ bfd_set_error (bfd_error_system_call);
+ goto error_return;
}
/* A weak check on whether the section file positions were
reasonable. */
if (bfd_tell (abfd) > nlm_fixed_header (abfd)->codeImageOffset)
{
- bfd_error = invalid_operation;
- return false;
+ bfd_set_error (bfd_error_invalid_operation);
+ goto error_return;
}
/* Advance to the relocs. */
if (bfd_seek (abfd, nlm_fixed_header (abfd)->relocationFixupOffset,
SEEK_SET) != 0)
- {
- bfd_error = system_call_error;
- return false;
- }
+ goto error_return;
/* The format of the relocation entries is dependent upon the
particular target. We use an external routine to write the reloc
out. */
- write_reloc_func = nlm_write_reloc_func (abfd);
+ write_import_func = nlm_write_import_func (abfd);
/* Write out the internal relocation fixups. While we're looping
over the relocs, we also count the external relocs, which is
if (sec->reloc_count == 0)
continue;
- /* We can only represent relocs within a code or data
- section. */
+ /* 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)
- {
- bfd_error = invalid_operation;
- return false;
- }
+ continue;
- /* We need to know how to write out relocs. */
- if (write_reloc_func == NULL)
+ /* We need to know how to write out imports */
+ if (write_import_func == NULL)
{
- bfd_error = invalid_operation;
- return false;
+ bfd_set_error (bfd_error_invalid_operation);
+ goto error_return;
}
rel_ptr_ptr = sec->orelocation;
rel = *rel_ptr_ptr;
sym = *rel->sym_ptr_ptr;
- if (bfd_get_section (sym) != &bfd_und_section)
+ if (! bfd_is_und_section (bfd_get_section (sym)))
{
++internal_reloc_count;
- if ((*write_reloc_func) (abfd, sec, rel) == false)
- return false;
+ if ((*write_import_func) (abfd, sec, rel) == false)
+ goto error_return;
}
else
++external_reloc_count;
(external_reloc_count
* sizeof (struct reloc_and_sec)));
if (external_relocs == (struct reloc_and_sec *) NULL)
- {
- bfd_error = no_memory;
- return false;
- }
+ 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;
BFD_ASSERT (i == external_reloc_count);
/* Sort the external relocs by name. */
- qsort (external_relocs, external_reloc_count,
+ qsort ((PTR) external_relocs, (size_t) external_reloc_count,
sizeof (struct reloc_and_sec), nlm_external_reloc_compare);
/* Write out the external relocs. */
{
arelent *rel;
asymbol *sym;
- bfd_byte len;
bfd_size_type j, cnt;
- bfd_byte temp[NLM_TARGET_LONG_SIZE];
++c;
rel = external_relocs[i].rel;
sym = *rel->sym_ptr_ptr;
- len = strlen (sym->name);
- if ((bfd_write (&len, sizeof (bfd_byte), 1, abfd)
- != sizeof (bfd_byte))
- || bfd_write (sym->name, len, 1, abfd) != len)
- {
- bfd_error = system_call_error;
- return false;
- }
-
cnt = 0;
for (j = i;
(j < external_reloc_count
j++)
++cnt;
- put_word (abfd, (bfd_vma) cnt, temp);
- if (bfd_write (temp, sizeof (temp), 1, abfd) != sizeof (temp))
- {
- bfd_error = system_call_error;
- return false;
- }
+ if ((*nlm_write_external_func (abfd)) (abfd, cnt, sym,
+ &external_relocs[i])
+ == false)
+ goto error_return;
- while (cnt-- != 0)
- {
- if ((*write_reloc_func) (abfd, external_relocs[i].sec,
- external_relocs[i].rel) == false)
- return false;
- ++i;
- }
+ i += cnt;
}
+
nlm_fixed_header (abfd)->numberOfExternalReferences = c;
/* Write out the public symbols (exports). */
sym_ptr_ptr = bfd_get_outsymbols (abfd);
if (sym_ptr_ptr != (asymbol **) NULL)
{
+ bfd_vma (*get_public_offset_func) PARAMS ((bfd *, asymbol *));
+ boolean (*write_export_func) PARAMS ((bfd *, asymbol *, bfd_vma));
+
asymbol **sym_end;
nlm_fixed_header (abfd)->publicsOffset = bfd_tell (abfd);
+ get_public_offset_func = nlm_get_public_offset_func (abfd);
+ write_export_func = nlm_write_export_func (abfd);
c = 0;
sym_end = sym_ptr_ptr + bfd_get_symcount (abfd);
for (; sym_ptr_ptr < sym_end; sym_ptr_ptr++)
asymbol *sym;
bfd_byte len;
bfd_vma offset;
- asection *sec;
bfd_byte temp[NLM_TARGET_LONG_SIZE];
sym = *sym_ptr_ptr;
if ((sym->flags & (BSF_EXPORT | BSF_GLOBAL)) == 0
- || bfd_get_section (sym) == &bfd_und_section)
+ || bfd_is_und_section (bfd_get_section (sym)))
continue;
++c;
- len = strlen (sym->name);
- if ((bfd_write (&len, sizeof (bfd_byte), 1, abfd)
- != sizeof (bfd_byte))
- || bfd_write (sym->name, len, 1, abfd) != len)
- {
- bfd_error = system_call_error;
- return false;
- }
-
- offset = bfd_asymbol_value (sym);
- sec = sym->section;
- if (sec->flags & SEC_CODE)
+ if (get_public_offset_func)
{
- offset -= nlm_get_text_low (abfd);
- offset |= NLM_HIBIT;
- }
- else if (sec->flags & (SEC_DATA | SEC_ALLOC))
- {
- /* SEC_ALLOC is for the .bss section. */
- offset -= nlm_get_data_low (abfd);
+ /* Most backends can use the code below, but
+ unfortunately some use a different scheme. */
+ offset = (*get_public_offset_func) (abfd, sym);
}
else
{
- /* We can't handle an exported symbol that is not in the
- code or data segment. */
- bfd_error = invalid_operation;
- return false;
+ offset = bfd_asymbol_value (sym);
+ sec = sym->section;
+ if (sec->flags & SEC_CODE)
+ {
+ offset -= nlm_get_text_low (abfd);
+ offset |= NLM_HIBIT;
+ }
+ else if (sec->flags & (SEC_DATA | SEC_ALLOC))
+ {
+ /* SEC_ALLOC is for the .bss section. */
+ offset -= nlm_get_data_low (abfd);
+ }
+ else
+ {
+ /* We can't handle an exported symbol that is not in
+ the code or data segment. */
+ bfd_set_error (bfd_error_invalid_operation);
+ goto error_return;
+ }
}
- put_word (abfd, offset, temp);
- if (bfd_write (temp, sizeof (temp), 1, abfd) != sizeof (temp))
+ if (write_export_func)
{
- bfd_error = system_call_error;
- return false;
- }
- }
- nlm_fixed_header (abfd)->numberOfPublics = c;
-
- nlm_fixed_header (abfd)->debugInfoOffset = bfd_tell (abfd);
- c = 0;
- sym_ptr_ptr = bfd_get_outsymbols (abfd);
- sym_end = sym_ptr_ptr + bfd_get_symcount (abfd);
- for (; sym_ptr_ptr < sym_end; sym_ptr_ptr++)
- {
- asymbol *sym;
- bfd_byte type, len;
- bfd_vma offset;
- asection *sec;
- bfd_byte temp[NLM_TARGET_LONG_SIZE];
-
- sym = *sym_ptr_ptr;
-
- /* The NLM notion of a debugging symbol is actually what BFD
- calls a local or global symbol. What BFD calls a
- 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)
- continue;
-
- ++c;
-
- offset = bfd_asymbol_value (sym);
- sec = sym->section;
- if (sec->flags & SEC_CODE)
- {
- offset -= nlm_get_text_low (abfd);
- type = 1;
- }
- else if (sec->flags & (SEC_DATA | SEC_ALLOC))
- {
- offset -= nlm_get_data_low (abfd);
- type = 0;
+ if ((*write_export_func) (abfd, sym, offset) == false)
+ goto error_return;
}
else
- type = 2;
-
- /* 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_error = system_call_error;
- return false;
- }
-
- put_word (abfd, offset, temp);
- if (bfd_write (temp, sizeof (temp), 1, abfd) != sizeof (temp))
- {
- bfd_error = system_call_error;
- return false;
- }
-
- len = strlen (sym->name);
- if ((bfd_write (&len, sizeof (bfd_byte), 1, abfd)
- != sizeof (bfd_byte))
- || bfd_write (sym->name, len, 1, abfd) != len)
{
- bfd_error = system_call_error;
- return false;
+ len = strlen (sym->name);
+ if ((bfd_write (&len, sizeof (bfd_byte), 1, abfd)
+ != sizeof (bfd_byte))
+ || bfd_write (sym->name, len, 1, abfd) != len)
+ goto error_return;
+
+ put_word (abfd, offset, temp);
+ if (bfd_write (temp, sizeof (temp), 1, abfd) != sizeof (temp))
+ goto error_return;
}
+ }
+ nlm_fixed_header (abfd)->numberOfPublics = c;
- /* Exported symbols may get an additional debugging record
- without the prefix. */
- if ((sym->flags & (BSF_EXPORT | BSF_GLOBAL)) != 0)
+ /* Write out the debugging records. The NLM conversion program
+ wants to be able to inhibit this, so as a special hack if
+ debugInfoOffset is set to -1 we don't write any debugging
+ 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)
+ {
+ nlm_fixed_header (abfd)->debugInfoOffset = 0;
+ nlm_fixed_header (abfd)->numberOfDebugRecords = 0;
+ }
+ else
+ {
+ nlm_fixed_header (abfd)->debugInfoOffset = bfd_tell (abfd);
+ c = 0;
+ sym_ptr_ptr = bfd_get_outsymbols (abfd);
+ sym_end = sym_ptr_ptr + bfd_get_symcount (abfd);
+ for (; sym_ptr_ptr < sym_end; sym_ptr_ptr++)
{
- char *s;
-
- s = strchr (sym->name, '@');
- if (s != NULL)
+ asymbol *sym;
+ bfd_byte type, len;
+ bfd_vma offset;
+ bfd_byte temp[NLM_TARGET_LONG_SIZE];
+
+ sym = *sym_ptr_ptr;
+
+ /* The NLM notion of a debugging symbol is actually what
+ BFD calls a local or global symbol. What BFD calls a
+ debugging symbol NLM does not understand at all. */
+ if ((sym->flags & (BSF_LOCAL | BSF_GLOBAL | BSF_EXPORT)) == 0
+ || (sym->flags & BSF_DEBUGGING) != 0
+ || bfd_is_und_section (bfd_get_section (sym)))
+ continue;
+
+ ++c;
+
+ offset = bfd_asymbol_value (sym);
+ sec = sym->section;
+ if (sec->flags & SEC_CODE)
{
- ++c;
-
- if ((bfd_write (&type, sizeof (bfd_byte), 1, abfd)
- != sizeof (bfd_byte))
- || (bfd_write (temp, sizeof (temp), 1, abfd)
- != sizeof (temp)))
- {
- bfd_error = system_call_error;
- return false;
- }
-
- ++s;
-
- len = strlen (s);
- if ((bfd_write (&len, sizeof (bfd_byte), 1, abfd)
- != sizeof (bfd_byte))
- || bfd_write (s, len, 1, abfd) != len)
- {
- bfd_error = system_call_error;
- return false;
- }
+ offset -= nlm_get_text_low (abfd);
+ type = 1;
+ }
+ else if (sec->flags & (SEC_DATA | SEC_ALLOC))
+ {
+ /* SEC_ALLOC is for the .bss section. */
+ offset -= nlm_get_data_low (abfd);
+ type = 0;
}
+ else
+ type = 2;
+
+ /* The type is 0 for data, 1 for code, 2 for absolute. */
+ if (bfd_write (&type, sizeof (bfd_byte), 1, abfd)
+ != sizeof (bfd_byte))
+ goto error_return;
+
+ put_word (abfd, offset, temp);
+ if (bfd_write (temp, sizeof (temp), 1, abfd) != sizeof (temp))
+ 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)
+ goto error_return;
}
- }
- nlm_fixed_header (abfd)->numberOfDebugRecords = c;
+ nlm_fixed_header (abfd)->numberOfDebugRecords = c;
+ }
}
+ /* NLMLINK fills in offset values even if there is no data, so we do
+ the same. */
+ last = bfd_tell (abfd);
+ if (nlm_fixed_header (abfd)->codeImageOffset == 0)
+ nlm_fixed_header (abfd)->codeImageOffset = last;
+ if (nlm_fixed_header (abfd)->dataImageOffset == 0)
+ nlm_fixed_header (abfd)->dataImageOffset = last;
+ if (nlm_fixed_header (abfd)->customDataOffset == 0)
+ nlm_fixed_header (abfd)->customDataOffset = last;
+ if (nlm_fixed_header (abfd)->moduleDependencyOffset == 0)
+ nlm_fixed_header (abfd)->moduleDependencyOffset = last;
+ if (nlm_fixed_header (abfd)->relocationFixupOffset == 0)
+ nlm_fixed_header (abfd)->relocationFixupOffset = last;
+ if (nlm_fixed_header (abfd)->externalReferencesOffset == 0)
+ nlm_fixed_header (abfd)->externalReferencesOffset = last;
+ if (nlm_fixed_header (abfd)->publicsOffset == 0)
+ nlm_fixed_header (abfd)->publicsOffset = last;
+ if (nlm_fixed_header (abfd)->debugInfoOffset == 0)
+ nlm_fixed_header (abfd)->debugInfoOffset = last;
+
/* At this point everything has been written out except the fixed
header. */
- memcpy (nlm_fixed_header (abfd)->signature, NLM_SIGNATURE,
+ memcpy (nlm_fixed_header (abfd)->signature, nlm_signature (abfd),
NLM_SIGNATURE_SIZE);
nlm_fixed_header (abfd)->version = NLM_HEADER_VERSION;
nlm_fixed_header (abfd)->codeStartOffset =
- bfd_get_start_address (abfd) - nlm_get_text_low (abfd);
+ (bfd_get_start_address (abfd)
+ - nlm_get_text_low (abfd));
/* We have no convenient way for the caller to pass in the exit
procedure or the check unload procedure, so the caller must set
the values in the header to the values of the symbols. */
- if (nlm_fixed_header (abfd)->exitProcedureOffset != 0)
- nlm_fixed_header (abfd)->exitProcedureOffset -= nlm_get_text_low (abfd);
+ nlm_fixed_header (abfd)->exitProcedureOffset -= nlm_get_text_low (abfd);
if (nlm_fixed_header (abfd)->checkUnloadProcedureOffset != 0)
nlm_fixed_header (abfd)->checkUnloadProcedureOffset -=
nlm_get_text_low (abfd);
- nlm_swap_fixed_header_out (abfd, nlm_fixed_header (abfd), &fixed_header);
- if (bfd_seek (abfd, 0, SEEK_SET) != 0
- || (bfd_write (&fixed_header, sizeof fixed_header, 1, abfd)
- != sizeof fixed_header))
+ if (bfd_seek (abfd, 0, SEEK_SET) != 0)
+ goto error_return;
+
+ write_prefix_func = nlm_write_prefix_func (abfd);
+ if (write_prefix_func)
{
- bfd_error = system_call_error;
- return false;
+ if ((*write_prefix_func) (abfd) == false)
+ goto error_return;
}
+ 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))
+ goto error_return;
+
+ if (fixed_header != NULL)
+ free (fixed_header);
return true;
+
+error_return:
+ if (fixed_header != NULL)
+ free (fixed_header);
+ return false;
}
projects / deliverable / binutils-gdb.git / blobdiff