diff options
Diffstat (limited to 'bfd/nlmcode.h')
| -rw-r--r-- | bfd/nlmcode.h | 2056 |
1 files changed, 2056 insertions, 0 deletions
diff --git a/bfd/nlmcode.h b/bfd/nlmcode.h new file mode 100644 index 00000000000..63ac0c300f7 --- /dev/null +++ b/bfd/nlmcode.h @@ -0,0 +1,2056 @@ +/* NLM (NetWare Loadable Module) executable support for BFD. + Copyright (C) 1993, 94, 95, 1998 Free Software Foundation, Inc. + + Written by Fred Fish @ Cygnus Support, using ELF support as the + template. + +This file is part of BFD, the Binary File Descriptor library. + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + +#include "bfd.h" +#include "sysdep.h" +#include "libbfd.h" +#include "libnlm.h" + +/* The functions in this file do not use the names they appear to use. + This file is actually compiled multiple times, once for each size + of NLM target we are using. At each size we use a different name, + constructed by the macro nlmNAME. For example, the function which + is named nlm_symbol_type below is actually named nlm32_symbol_type + in the final executable. */ + +#define Nlm_External_Fixed_Header NlmNAME(External_Fixed_Header) +#define Nlm_External_Version_Header NlmNAME(External_Version_Header) +#define Nlm_External_Copyright_Header NlmNAME(External_Copyright_Header) +#define Nlm_External_Extended_Header NlmNAME(External_Extended_Header) +#define Nlm_External_Custom_Header NlmNAME(External_Custom_Header) +#define Nlm_External_Cygnus_Ext_Header NlmNAME(External_Cygnus_Ext_Header) + +#define nlm_symbol_type nlmNAME(symbol_type) +#define nlm_get_symtab_upper_bound nlmNAME(get_symtab_upper_bound) +#define nlm_get_symtab nlmNAME(get_symtab) +#define nlm_make_empty_symbol nlmNAME(make_empty_symbol) +#define nlm_print_symbol nlmNAME(print_symbol) +#define nlm_get_symbol_info nlmNAME(get_symbol_info) +#define nlm_get_reloc_upper_bound nlmNAME(get_reloc_upper_bound) +#define nlm_canonicalize_reloc nlmNAME(canonicalize_reloc) +#define nlm_object_p nlmNAME(object_p) +#define nlm_set_section_contents nlmNAME(set_section_contents) +#define nlm_write_object_contents nlmNAME(write_object_contents) + +#define nlm_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 boolean nlm_swap_variable_header_in + PARAMS ((bfd *)); +static boolean nlm_swap_variable_header_out + PARAMS ((bfd *)); +static boolean find_nonzero + PARAMS ((PTR, size_t)); +static boolean nlm_swap_auxiliary_headers_in + PARAMS ((bfd *)); +static boolean nlm_swap_auxiliary_headers_out + PARAMS ((bfd *)); +static boolean nlm_slurp_symbol_table + PARAMS ((bfd *)); +static boolean nlm_slurp_reloc_fixups + PARAMS ((bfd *)); +static boolean nlm_compute_section_file_positions + PARAMS ((bfd *)); +static int nlm_external_reloc_compare + PARAMS ((const void *, const void *)); + +/* Should perhaps use put_offset, put_word, etc. For now, the two versions + can be handled by explicitly specifying 32 bits or "the long type". */ +#if ARCH_SIZE == 64 +#define put_word bfd_h_put_64 +#define get_word bfd_h_get_64 +#endif +#if ARCH_SIZE == 32 +#define put_word bfd_h_put_32 +#define get_word bfd_h_get_32 +#endif + +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; + + /* Some NLM formats have a prefix before the standard NLM fixed + header. */ + backend_object_p = nlm_backend_object_p_func (abfd); + if (backend_object_p) + { + if (!(*backend_object_p) (abfd)) + goto got_wrong_format_error; + } + + /* Read in the fixed length portion of the NLM header in external format. */ + + x_fxdhdr = (PTR) bfd_malloc ((size_t) nlm_fixed_header_size (abfd)); + if (x_fxdhdr == NULL) + goto got_no_match; + + if (bfd_read ((PTR) x_fxdhdr, nlm_fixed_header_size (abfd), 1, abfd) != + nlm_fixed_header_size (abfd)) + { + 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 (i_fxdhdrp->version > 0xFFFF) + goto got_wrong_format_error; + + /* There's no supported way to check for 32 bit versus 64 bit addresses, + so ignore this distinction for now. (FIXME) */ + + /* Swap in the rest of the required header. */ + if (!nlm_swap_variable_header_in (abfd)) + { + if (bfd_get_error () != bfd_error_system_call) + goto got_wrong_format_error; + else + goto got_no_match; + } + + /* Add the sections supplied by all NLM's, and then read in the + auxiliary headers. Reading the auxiliary headers may create + additional sections described in the cygnus_ext header. + From this point on we assume that we have an NLM, and do not + treat errors as indicating the wrong format. */ + + if (!add_bfd_section (abfd, NLM_CODE_NAME, + i_fxdhdrp->codeImageOffset, + i_fxdhdrp->codeImageSize, + (SEC_CODE | SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS + | SEC_RELOC)) + || !add_bfd_section (abfd, NLM_INITIALIZED_DATA_NAME, + i_fxdhdrp->dataImageOffset, + i_fxdhdrp->dataImageSize, + (SEC_DATA | SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS + | SEC_RELOC)) + || !add_bfd_section (abfd, NLM_UNINITIALIZED_DATA_NAME, + (file_ptr) 0, + i_fxdhdrp->uninitializedDataSize, + SEC_ALLOC)) + goto got_no_match; + + if (!nlm_swap_auxiliary_headers_in (abfd)) + goto got_no_match; + + if (nlm_fixed_header (abfd)->numberOfRelocationFixups != 0 + || nlm_fixed_header (abfd)->numberOfExternalReferences != 0) + abfd->flags |= HAS_RELOC; + if (nlm_fixed_header (abfd)->numberOfPublics != 0 + || nlm_fixed_header (abfd)->numberOfDebugRecords != 0 + || nlm_fixed_header (abfd)->numberOfExternalReferences != 0) + abfd->flags |= HAS_SYMS; + + arch = nlm_architecture (abfd); + if (arch != bfd_arch_unknown) + bfd_default_set_arch_mach (abfd, arch, (unsigned long) 0); + + abfd->flags |= EXEC_P; + bfd_get_start_address (abfd) = nlm_fixed_header (abfd)->codeStartOffset; + + return (abfd->xvec); + +got_wrong_format_error: + bfd_set_error (bfd_error_wrong_format); +got_no_match: + nlm_tdata (abfd) = preserved_tdata; + if (new_tdata != NULL) + bfd_release (abfd, new_tdata); + if (x_fxdhdr != NULL) + free (x_fxdhdr); + return (NULL); +} + +/* Add a section to the bfd. */ + +static boolean +add_bfd_section (abfd, name, offset, size, flags) + bfd *abfd; + char *name; + file_ptr offset; + bfd_size_type size; + flagword flags; +{ + asection *newsect; + + newsect = bfd_make_section (abfd, name); + if (newsect == NULL) + { + return (false); + } + newsect->vma = 0; /* NLM's are relocatable. */ + newsect->_raw_size = size; + newsect->filepos = offset; + newsect->flags = flags; + newsect->alignment_power = bfd_log2 (0); /* FIXME */ + return (true); +} + +/* Read and swap in the variable length header. All the fields must + exist in the NLM, and must exist in the order they are read here. */ + +static boolean +nlm_swap_variable_header_in (abfd) + bfd *abfd; +{ + unsigned char temp[NLM_TARGET_LONG_SIZE]; + + /* Read the description length and text members. */ + + if (bfd_read ((PTR) & nlm_variable_header (abfd)->descriptionLength, + sizeof (nlm_variable_header (abfd)->descriptionLength), + 1, abfd) != + sizeof (nlm_variable_header (abfd)->descriptionLength)) + return (false); + if (bfd_read ((PTR) nlm_variable_header (abfd)->descriptionText, + nlm_variable_header (abfd)->descriptionLength + 1, + 1, abfd) != + (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)) + 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)) + return (false); + nlm_variable_header (abfd)->reserved = get_word (abfd, (bfd_byte *) temp); + + /* Read the oldThreadName field. This field is a fixed length string. */ + + if (bfd_read ((PTR) nlm_variable_header (abfd)->oldThreadName, + sizeof (nlm_variable_header (abfd)->oldThreadName), + 1, abfd) != + sizeof (nlm_variable_header (abfd)->oldThreadName)) + return (false); + + /* Read the screen name length and text members. */ + + if (bfd_read ((PTR) & nlm_variable_header (abfd)->screenNameLength, + sizeof (nlm_variable_header (abfd)->screenNameLength), + 1, abfd) != + sizeof (nlm_variable_header (abfd)->screenNameLength)) + return (false); + if (bfd_read ((PTR) nlm_variable_header (abfd)->screenName, + nlm_variable_header (abfd)->screenNameLength + 1, + 1, abfd) != + (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), + 1, abfd) != + 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) != + (bfd_size_type) nlm_variable_header (abfd)->threadNameLength + 1) + return (false); + return (true); +} + +/* Swap and write out the variable length header. All the fields must + exist in the NLM, and must exist in this order. */ + +static boolean +nlm_swap_variable_header_out (abfd) + bfd *abfd; +{ + unsigned char temp[NLM_TARGET_LONG_SIZE]; + + /* Write the description length and text members. */ + + if (bfd_write ((PTR) & nlm_variable_header (abfd)->descriptionLength, + sizeof (nlm_variable_header (abfd)->descriptionLength), + 1, abfd) != + sizeof (nlm_variable_header (abfd)->descriptionLength)) + return (false); + if (bfd_write ((PTR) nlm_variable_header (abfd)->descriptionText, + nlm_variable_header (abfd)->descriptionLength + 1, + 1, abfd) != + (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, + (bfd_byte *) temp); + if (bfd_write ((PTR) temp, sizeof (temp), 1, abfd) != sizeof (temp)) + return (false); + + /* Convert and write the reserved field. */ + + put_word (abfd, (bfd_vma) nlm_variable_header (abfd)->reserved, + (bfd_byte *) temp); + if (bfd_write ((PTR) temp, sizeof (temp), 1, abfd) != sizeof (temp)) + return (false); + + /* Write the oldThreadName field. This field is a fixed length string. */ + + if (bfd_write ((PTR) nlm_variable_header (abfd)->oldThreadName, + sizeof (nlm_variable_header (abfd)->oldThreadName), + 1, abfd) != + sizeof (nlm_variable_header (abfd)->oldThreadName)) + 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), + 1, abfd) != + 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) != + (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), + 1, abfd) != + 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) != + (bfd_size_type) nlm_variable_header (abfd)->threadNameLength + 1) + return (false); + return (true); +} + +/* Read and swap in the contents of all the auxiliary headers. Because of + the braindead design, we have to do strcmps on strings of indeterminate + length to figure out what each auxiliary header is. Even worse, we have + no way of knowing how many auxiliary headers there are or where the end + of the auxiliary headers are, except by finding something that doesn't + look like a known auxiliary header. This means that the first new type + of auxiliary header added will break all existing tools that don't + recognize it. */ + +static boolean +nlm_swap_auxiliary_headers_in (abfd) + bfd *abfd; +{ + char tempstr[16]; + long position; + + for (;;) + { + position = bfd_tell (abfd); + if (bfd_read ((PTR) tempstr, sizeof (tempstr), 1, abfd) != + sizeof (tempstr)) + return (false); + if (bfd_seek (abfd, position, SEEK_SET) == -1) + return (false); + if (strncmp (tempstr, "VeRsIoN#", 8) == 0) + { + Nlm_External_Version_Header thdr; + 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 = + get_word (abfd, (bfd_byte *) thdr.majorVersion); + nlm_version_header (abfd)->minorVersion = + get_word (abfd, (bfd_byte *) thdr.minorVersion); + nlm_version_header (abfd)->revision = + get_word (abfd, (bfd_byte *) thdr.revision); + nlm_version_header (abfd)->year = + get_word (abfd, (bfd_byte *) thdr.year); + nlm_version_header (abfd)->month = + get_word (abfd, (bfd_byte *) thdr.month); + nlm_version_header (abfd)->day = + get_word (abfd, (bfd_byte *) thdr.day); + } + else if (strncmp (tempstr, "MeSsAgEs", 8) == 0) + { + Nlm_External_Extended_Header thdr; + if (bfd_read ((PTR) & thdr, sizeof (thdr), 1, abfd) != sizeof (thdr)) + return (false); + memcpy (nlm_extended_header (abfd)->stamp, thdr.stamp, + sizeof (thdr.stamp)); + nlm_extended_header (abfd)->languageID = + get_word (abfd, (bfd_byte *) thdr.languageID); + nlm_extended_header (abfd)->messageFileOffset = + get_word (abfd, (bfd_byte *) thdr.messageFileOffset); + nlm_extended_header (abfd)->messageFileLength = + get_word (abfd, (bfd_byte *) thdr.messageFileLength); + nlm_extended_header (abfd)->messageCount = + get_word (abfd, (bfd_byte *) thdr.messageCount); + nlm_extended_header (abfd)->helpFileOffset = + get_word (abfd, (bfd_byte *) thdr.helpFileOffset); + nlm_extended_header (abfd)->helpFileLength = + get_word (abfd, (bfd_byte *) thdr.helpFileLength); + nlm_extended_header (abfd)->RPCDataOffset = + get_word (abfd, (bfd_byte *) thdr.RPCDataOffset); + nlm_extended_header (abfd)->RPCDataLength = + get_word (abfd, (bfd_byte *) thdr.RPCDataLength); + nlm_extended_header (abfd)->sharedCodeOffset = + get_word (abfd, (bfd_byte *) thdr.sharedCodeOffset); + nlm_extended_header (abfd)->sharedCodeLength = + get_word (abfd, (bfd_byte *) thdr.sharedCodeLength); + nlm_extended_header (abfd)->sharedDataOffset = + get_word (abfd, (bfd_byte *) thdr.sharedDataOffset); + nlm_extended_header (abfd)->sharedDataLength = + get_word (abfd, (bfd_byte *) thdr.sharedDataLength); + nlm_extended_header (abfd)->sharedRelocationFixupOffset = + get_word (abfd, (bfd_byte *) thdr.sharedRelocationFixupOffset); + nlm_extended_header (abfd)->sharedRelocationFixupCount = + get_word (abfd, (bfd_byte *) thdr.sharedRelocationFixupCount); + nlm_extended_header (abfd)->sharedExternalReferenceOffset = + get_word (abfd, (bfd_byte *) thdr.sharedExternalReferenceOffset); + nlm_extended_header (abfd)->sharedExternalReferenceCount = + get_word (abfd, (bfd_byte *) thdr.sharedExternalReferenceCount); + nlm_extended_header (abfd)->sharedPublicsOffset = + get_word (abfd, (bfd_byte *) thdr.sharedPublicsOffset); + nlm_extended_header (abfd)->sharedPublicsCount = + get_word (abfd, (bfd_byte *) thdr.sharedPublicsCount); + nlm_extended_header (abfd)->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 = + get_word (abfd, (bfd_byte *) thdr.SharedExitProcedureOffset); + nlm_extended_header (abfd)->productID = + get_word (abfd, (bfd_byte *) thdr.productID); + nlm_extended_header (abfd)->reserved0 = + get_word (abfd, (bfd_byte *) thdr.reserved0); + nlm_extended_header (abfd)->reserved1 = + get_word (abfd, (bfd_byte *) thdr.reserved1); + nlm_extended_header (abfd)->reserved2 = + get_word (abfd, (bfd_byte *) thdr.reserved2); + nlm_extended_header (abfd)->reserved3 = + get_word (abfd, (bfd_byte *) thdr.reserved3); + nlm_extended_header (abfd)->reserved4 = + get_word (abfd, (bfd_byte *) thdr.reserved4); + nlm_extended_header (abfd)->reserved5 = + get_word (abfd, (bfd_byte *) thdr.reserved5); + } + else if (strncmp (tempstr, "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 + { + 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 (hdrLength < 2 * NLM_TARGET_LONG_SIZE) + dataLength = 0; + else + { + if (bfd_read ((PTR) thdr.dataLength, 1, + sizeof (thdr.dataLength), abfd) + != sizeof (thdr.dataLength)) + return false; + dataLength = get_word (abfd, (bfd_byte *) thdr.dataLength); + } + 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) + { + 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 + { + break; + } + } + return (true); +} + +/* Return whether there is a non-zero byte in a memory block. */ + +static boolean +find_nonzero (buf, size) + PTR buf; + size_t size; +{ + char *p = (char *) buf; + + while (size-- != 0) + if (*p++ != 0) + return true; + return false; +} + +/* Swap out the contents of the auxiliary headers. We create those + auxiliary headers which have been set non-zero. We do not require + the caller to set up the stamp fields. */ + +static boolean +nlm_swap_auxiliary_headers_out (abfd) + bfd *abfd; +{ + /* Write out the version header if there is one. */ + if (find_nonzero ((PTR) nlm_version_header (abfd), + sizeof (Nlm_Internal_Version_Header))) + { + Nlm_External_Version_Header thdr; + + memcpy (thdr.stamp, "VeRsIoN#", 8); + put_word (abfd, (bfd_vma) nlm_version_header (abfd)->majorVersion, + (bfd_byte *) thdr.majorVersion); + put_word (abfd, (bfd_vma) nlm_version_header (abfd)->minorVersion, + (bfd_byte *) thdr.minorVersion); + put_word (abfd, (bfd_vma) nlm_version_header (abfd)->revision, + (bfd_byte *) thdr.revision); + put_word (abfd, (bfd_vma) nlm_version_header (abfd)->year, + (bfd_byte *) thdr.year); + put_word (abfd, (bfd_vma) nlm_version_header (abfd)->month, + (bfd_byte *) thdr.month); + 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)) + return false; + } + + /* Write out the extended header if there is one. */ + if (find_nonzero ((PTR) nlm_extended_header (abfd), + sizeof (Nlm_Internal_Extended_Header))) + { + Nlm_External_Extended_Header thdr; + + memcpy (thdr.stamp, "MeSsAgEs", 8); + put_word (abfd, + (bfd_vma) nlm_extended_header (abfd)->languageID, + (bfd_byte *) thdr.languageID); + put_word (abfd, + (bfd_vma) nlm_extended_header (abfd)->messageFileOffset, + (bfd_byte *) thdr.messageFileOffset); + put_word (abfd, + (bfd_vma) nlm_extended_header (abfd)->messageFileLength, + (bfd_byte *) thdr.messageFileLength); + put_word (abfd, + (bfd_vma) nlm_extended_header (abfd)->messageCount, + (bfd_byte *) thdr.messageCount); + put_word (abfd, + (bfd_vma) nlm_extended_header (abfd)->helpFileOffset, + (bfd_byte *) thdr.helpFileOffset); + put_word (abfd, + (bfd_vma) nlm_extended_header (abfd)->helpFileLength, + (bfd_byte *) thdr.helpFileLength); + put_word (abfd, + (bfd_vma) nlm_extended_header (abfd)->RPCDataOffset, + (bfd_byte *) thdr.RPCDataOffset); + put_word (abfd, + (bfd_vma) nlm_extended_header (abfd)->RPCDataLength, + (bfd_byte *) thdr.RPCDataLength); + put_word (abfd, + (bfd_vma) nlm_extended_header (abfd)->sharedCodeOffset, + (bfd_byte *) thdr.sharedCodeOffset); + put_word (abfd, + (bfd_vma) nlm_extended_header (abfd)->sharedCodeLength, + (bfd_byte *) thdr.sharedCodeLength); + put_word (abfd, + (bfd_vma) nlm_extended_header (abfd)->sharedDataOffset, + (bfd_byte *) thdr.sharedDataOffset); + put_word (abfd, + (bfd_vma) nlm_extended_header (abfd)->sharedDataLength, + (bfd_byte *) thdr.sharedDataLength); + put_word (abfd, + (bfd_vma) nlm_extended_header (abfd)->sharedRelocationFixupOffset, + (bfd_byte *) thdr.sharedRelocationFixupOffset); + put_word (abfd, + (bfd_vma) nlm_extended_header (abfd)->sharedRelocationFixupCount, + (bfd_byte *) thdr.sharedRelocationFixupCount); + put_word (abfd, + (bfd_vma) nlm_extended_header (abfd)->sharedExternalReferenceOffset, + (bfd_byte *) thdr.sharedExternalReferenceOffset); + put_word (abfd, + (bfd_vma) nlm_extended_header (abfd)->sharedExternalReferenceCount, + (bfd_byte *) thdr.sharedExternalReferenceCount); + put_word (abfd, + (bfd_vma) nlm_extended_header (abfd)->sharedPublicsOffset, + (bfd_byte *) thdr.sharedPublicsOffset); + put_word (abfd, + (bfd_vma) nlm_extended_header (abfd)->sharedPublicsCount, + (bfd_byte *) thdr.sharedPublicsCount); + put_word (abfd, + (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_byte *) thdr.SharedExitProcedureOffset); + put_word (abfd, + (bfd_vma) nlm_extended_header (abfd)->productID, + (bfd_byte *) thdr.productID); + put_word (abfd, + (bfd_vma) nlm_extended_header (abfd)->reserved0, + (bfd_byte *) thdr.reserved0); + put_word (abfd, + (bfd_vma) nlm_extended_header (abfd)->reserved1, + (bfd_byte *) thdr.reserved1); + put_word (abfd, + (bfd_vma) nlm_extended_header (abfd)->reserved2, + (bfd_byte *) thdr.reserved2); + put_word (abfd, + (bfd_vma) nlm_extended_header (abfd)->reserved3, + (bfd_byte *) thdr.reserved3); + put_word (abfd, + (bfd_vma) nlm_extended_header (abfd)->reserved4, + (bfd_byte *) thdr.reserved4); + put_word (abfd, + (bfd_vma) nlm_extended_header (abfd)->reserved5, + (bfd_byte *) thdr.reserved5); + 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. */ + 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_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; +} + +/* We read the NLM's public symbols and use it to generate a bfd symbol + table (hey, it's better than nothing) on a one-for-one basis. Thus + use the number of public symbols as the number of bfd symbols we will + have once we actually get around to reading them in. + + Return the number of bytes required to hold the symtab vector, based on + the count plus 1, since we will NULL terminate the vector allocated based + on this size. */ + +long +nlm_get_symtab_upper_bound (abfd) + bfd *abfd; +{ + Nlm_Internal_Fixed_Header *i_fxdhdrp; /* Nlm file header, internal form */ + long symcount; + long symtab_size = 0; + + i_fxdhdrp = nlm_fixed_header (abfd); + symcount = (i_fxdhdrp->numberOfPublics + + i_fxdhdrp->numberOfDebugRecords + + i_fxdhdrp->numberOfExternalReferences); + symtab_size = (symcount + 1) * (sizeof (asymbol)); + return (symtab_size); +} + +/* Note that bfd_get_symcount is guaranteed to be zero if slurping the + symbol table fails. */ + +long +nlm_get_symtab (abfd, alocation) + bfd *abfd; + asymbol **alocation; +{ + nlm_symbol_type *symbase; + bfd_size_type counter = 0; + + if (nlm_slurp_symbol_table (abfd) == false) + return -1; + symbase = nlm_get_symbols (abfd); + while (counter < bfd_get_symcount (abfd)) + { + *alocation++ = &symbase->symbol; + symbase++; + counter++; + } + *alocation = (asymbol *) NULL; + return bfd_get_symcount (abfd); +} + +/* Make an NLM symbol. There is nothing special to do here. */ + +asymbol * +nlm_make_empty_symbol (abfd) + bfd *abfd; +{ + nlm_symbol_type *new; + + new = (nlm_symbol_type *) bfd_zalloc (abfd, sizeof (nlm_symbol_type)); + if (new) + new->symbol.the_bfd = abfd; + return &new->symbol; +} + +/* Get symbol information. */ + +void +nlm_get_symbol_info (ignore_abfd, symbol, ret) + bfd *ignore_abfd; + asymbol *symbol; + symbol_info *ret; +{ + bfd_symbol_info (symbol, ret); +} + +/* Print symbol information. */ + +void +nlm_print_symbol (abfd, afile, symbol, how) + bfd *abfd; + PTR afile; + asymbol *symbol; + bfd_print_symbol_type how; +{ + FILE *file = (FILE *) afile; + + switch (how) + { + case bfd_print_symbol_name: + case bfd_print_symbol_more: + if (symbol->name) + fprintf (file, "%s", symbol->name); + break; + case bfd_print_symbol_all: + bfd_print_symbol_vandf ((PTR) file, symbol); + fprintf (file, " %-5s", symbol->section->name); + if (symbol->name) + fprintf (file, " %s", symbol->name); + break; + } +} + +/* Slurp in nlm symbol table. + + In the external (in-file) form, NLM export records are variable length, + with the following form: + + 1 byte length of the symbol name (N) + N bytes the symbol name + 4 bytes the symbol offset from start of it's section + + 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. + + When we return, the bfd symcount is either zero or contains the correct + number of symbols. +*/ + +static boolean +nlm_slurp_symbol_table (abfd) + bfd *abfd; +{ + Nlm_Internal_Fixed_Header *i_fxdhdrp; /* Nlm file header, internal form */ + bfd_size_type totsymcount; /* Number of NLM symbols */ + bfd_size_type symcount; /* Counter of NLM symbols */ + nlm_symbol_type *sym; /* Pointer to current bfd symbol */ + unsigned char symlength; /* Symbol length read into here */ + unsigned char symtype; /* Type of debugging symbol */ + bfd_byte temp[NLM_TARGET_LONG_SIZE]; /* Symbol offsets read into here */ + boolean (*read_import_func) PARAMS ((bfd *, nlm_symbol_type *)); + boolean (*set_public_section_func) PARAMS ((bfd *, nlm_symbol_type *)); + + if (nlm_get_symbols (abfd) != NULL) + return (true); + + /* Read each raw NLM symbol, using the information to create a canonical bfd + symbol table entry. + + Note that we allocate the initial bfd canonical symbol buffer based on a + one-to-one mapping of the NLM symbols to canonical symbols. We actually + use all the NLM symbols, so there will be no space left over at the end. + When we have all the symbols, we build the caller's pointer vector. */ + + abfd->symcount = 0; + i_fxdhdrp = nlm_fixed_header (abfd); + 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) + 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. */ + + 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) + != 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'; + 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) + { + /* 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 + { + 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++; + } + + /* Read the debugging records. */ + + if (i_fxdhdrp->numberOfDebugRecords > 0) + { + if (bfd_seek (abfd, i_fxdhdrp->debugInfoOffset, SEEK_SET) == -1) + return (false); + + 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) + { + 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 = + bfd_get_section_by_name (abfd, NLM_CODE_NAME); + } + else + { + sym->symbol.section = bfd_abs_section_ptr; + } + sym->rcnt = 0; + abfd->symcount++; + sym++; + } + } + + /* Read in the import records. We can only do this if we know how + to read relocs for this target. */ + + read_import_func = nlm_read_import_func (abfd); + if (read_import_func != NULL) + { + if (bfd_seek (abfd, i_fxdhdrp->externalReferencesOffset, SEEK_SET) + == -1) + return (false); + + symcount += i_fxdhdrp->numberOfExternalReferences; + while (abfd->symcount < symcount) + { + if ((*read_import_func) (abfd, sym) == false) + return false; + sym++; + abfd->symcount++; + } + } + + return (true); +} + +/* Get the relocs for an NLM file. There are two types of relocs. + Imports are relocs against symbols defined in other NLM files. We + treat these as relocs against global symbols. Relocation fixups + are internal relocs. + + The actual format used to store the relocs is machine specific. */ + +/* Read in the relocation fixup information. This is stored in + nlm_relocation_fixups, an array of arelent structures, and + nlm_relocation_fixup_secs, an array of section pointers. The + section pointers are needed because the relocs are not sorted by + section. */ + +static boolean +nlm_slurp_reloc_fixups (abfd) + bfd *abfd; +{ + boolean (*read_func) PARAMS ((bfd *, nlm_symbol_type *, asection **, + arelent *)); + bfd_size_type count; + arelent *rels; + asection **secs; + + if (nlm_relocation_fixups (abfd) != NULL) + return true; + read_func = nlm_read_reloc_func (abfd); + if (read_func == NULL) + return true; + + if (bfd_seek (abfd, nlm_fixed_header (abfd)->relocationFixupOffset, + SEEK_SET) != 0) + 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) && count != 0) + return false; + nlm_relocation_fixups (abfd) = rels; + nlm_relocation_fixup_secs (abfd) = secs; + + /* We have to read piece by piece, because we don't know how large + the machine specific reloc information is. */ + while (count-- != 0) + { + if ((*read_func) (abfd, (nlm_symbol_type *) NULL, secs, rels) == false) + { + nlm_relocation_fixups (abfd) = NULL; + nlm_relocation_fixup_secs (abfd) = NULL; + return false; + } + ++secs; + ++rels; + } + + return true; +} + +/* Get the number of relocs. This really just returns an upper bound, + since it does not attempt to distinguish them based on the section. + That will be handled when they are actually read. */ + +long +nlm_get_reloc_upper_bound (abfd, sec) + bfd *abfd; + asection *sec; +{ + nlm_symbol_type *syms; + bfd_size_type count; + unsigned int ret; + + /* If we don't know how to read relocs, just return 0. */ + if (nlm_read_reloc_func (abfd) == NULL) + return -1; + /* Make sure we have either the code or the data section. */ + if ((bfd_get_section_flags (abfd, sec) & (SEC_CODE | SEC_DATA)) == 0) + return 0; + + syms = nlm_get_symbols (abfd); + if (syms == NULL) + { + if (nlm_slurp_symbol_table (abfd) == false) + return -1; + syms = nlm_get_symbols (abfd); + } + + ret = nlm_fixed_header (abfd)->numberOfRelocationFixups; + + count = bfd_get_symcount (abfd); + while (count-- != 0) + { + ret += syms->rcnt; + ++syms; + } + + return (ret + 1) * sizeof (arelent *); +} + +/* Get the relocs themselves. */ + +long +nlm_canonicalize_reloc (abfd, sec, relptr, symbols) + bfd *abfd; + asection *sec; + arelent **relptr; + asymbol **symbols; +{ + arelent *rels; + asection **secs; + bfd_size_type count, i; + unsigned int ret; + + /* Get the relocation fixups. */ + rels = nlm_relocation_fixups (abfd); + if (rels == NULL) + { + if (nlm_slurp_reloc_fixups (abfd) == false) + return -1; + rels = nlm_relocation_fixups (abfd); + } + secs = nlm_relocation_fixup_secs (abfd); + + ret = 0; + count = nlm_fixed_header (abfd)->numberOfRelocationFixups; + for (i = 0; i < count; i++, rels++, secs++) + { + if (*secs == sec) + { + *relptr++ = rels; + ++ret; + } + } + + /* Get the import symbols. */ + count = bfd_get_symcount (abfd); + for (i = 0; i < count; i++, symbols++) + { + asymbol *sym; + + sym = *symbols; + if (bfd_asymbol_flavour (sym) == bfd_target_nlm_flavour) + { + nlm_symbol_type *nlm_sym; + bfd_size_type j; + + nlm_sym = (nlm_symbol_type *) sym; + for (j = 0; j < nlm_sym->rcnt; j++) + { + if (nlm_sym->relocs[j].section == sec) + { + *relptr = &nlm_sym->relocs[j].reloc; + (*relptr)->sym_ptr_ptr = symbols; + ++relptr; + ++ret; + } + } + } + } + + *relptr = NULL; + + return ret; +} + +/* Compute the section file positions for an NLM file. All variable + length data in the file headers must be set before this function is + called. If the variable length data is changed later, the + resulting object file will be incorrect. Unfortunately, there is + no way to check this. + + This routine also sets the Size and Offset fields in the fixed + header. + + It also looks over the symbols and moves any common symbols into + the .bss section; NLM has no way to represent a common symbol. + This approach means that either the symbols must already have been + set at this point, or there must be no common symbols. We need to + move the symbols at this point so that mangle_relocs can see the + final values. */ + +static boolean +nlm_compute_section_file_positions (abfd) + bfd *abfd; +{ + file_ptr sofar; + asection *sec; + bfd_vma text, data, bss; + bfd_vma text_low, data_low; + 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 = 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); + + /* The auxiliary headers. */ + if (find_nonzero ((PTR) nlm_version_header (abfd), + sizeof (Nlm_Internal_Version_Header))) + sofar += sizeof (Nlm_External_Version_Header); + if (find_nonzero ((PTR) nlm_extended_header (abfd), + sizeof (Nlm_Internal_Extended_Header))) + sofar += sizeof (Nlm_External_Extended_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); + 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 + positions. This code aligns the sections in the file using the + same alignment restrictions that apply to the sections in memory; + this may not be necessary. */ + text = 0; + text_low = (bfd_vma) - 1; + text_align = 0; + data = 0; + data_low = (bfd_vma) - 1; + data_align = 0; + bss = 0; + other_align = 0; + for (sec = abfd->sections; sec != (asection *) NULL; sec = sec->next) + { + flagword f; + + sec->_raw_size = BFD_ALIGN (sec->_raw_size, 1 << sec->alignment_power); + + f = bfd_get_section_flags (abfd, sec); + if (f & SEC_CODE) + { + text += sec->_raw_size; + if (bfd_get_section_vma (abfd, sec) < text_low) + text_low = bfd_get_section_vma (abfd, sec); + if (sec->alignment_power > text_align) + text_align = sec->alignment_power; + } + else if (f & SEC_DATA) + { + data += sec->_raw_size; + if (bfd_get_section_vma (abfd, sec) < data_low) + data_low = bfd_get_section_vma (abfd, sec); + if (sec->alignment_power > data_align) + data_align = sec->alignment_power; + } + else if (f & SEC_HAS_CONTENTS) + { + if (sec->alignment_power > other_align) + other_align = sec->alignment_power; + } + else if (f & SEC_ALLOC) + bss += sec->_raw_size; + } + + nlm_set_text_low (abfd, text_low); + nlm_set_data_low (abfd, data_low); + + if (nlm_no_uninitialized_data (abfd)) + { + /* This NetWare format does not use uninitialized data. We must + increase the size of the data section. We will never wind up + writing those file locations, so they will remain zero. */ + data += bss; + bss = 0; + } + + text_ptr = BFD_ALIGN (sofar, 1 << text_align); + data_ptr = BFD_ALIGN (text_ptr + text, 1 << data_align); + other_ptr = BFD_ALIGN (data_ptr + data, 1 << other_align); + + /* Fill in some fields in the header for which we now have the + information. */ + nlm_fixed_header (abfd)->codeImageOffset = text_ptr; + nlm_fixed_header (abfd)->codeImageSize = text; + nlm_fixed_header (abfd)->dataImageOffset = data_ptr; + nlm_fixed_header (abfd)->dataImageSize = data; + nlm_fixed_header (abfd)->uninitializedDataSize = bss; + + for (sec = abfd->sections; sec != (asection *) NULL; sec = sec->next) + { + flagword f; + + f = bfd_get_section_flags (abfd, sec); + + if (f & SEC_CODE) + { + sec->filepos = text_ptr; + text_ptr += sec->_raw_size; + } + else if (f & SEC_DATA) + { + sec->filepos = data_ptr; + data_ptr += sec->_raw_size; + } + else if (f & SEC_HAS_CONTENTS) + { + sec->filepos = other_ptr; + other_ptr += sec->_raw_size; + } + } + + nlm_fixed_header (abfd)->relocationFixupOffset = other_ptr; + + /* Move all common symbols into the .bss section. */ + + sym_ptr_ptr = bfd_get_outsymbols (abfd); + if (sym_ptr_ptr != NULL) + { + asymbol **sym_end; + bfd_vma add; + + sym_end = sym_ptr_ptr + bfd_get_symcount (abfd); + add = 0; + for (; sym_ptr_ptr < sym_end; sym_ptr_ptr++) + { + asymbol *sym; + bfd_vma size; + + sym = *sym_ptr_ptr; + + if (!bfd_is_com_section (bfd_get_section (sym))) + continue; + + /* Put the common symbol in the .bss section, and increase + the size of the .bss section by the size of the common + symbol (which is the old value of the symbol). */ + sym->section = bss_sec; + size = sym->value; + sym->value = bss_sec->_raw_size + add; + add += size; + add = BFD_ALIGN (add, 1 << bss_sec->alignment_power); + } + 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; +} + +/* Set the contents of a section. To do this we need to know where + the section is going to be located in the output file. That means + that the sizes of all the sections must be set, and all the + variable size header information must be known. */ + +boolean +nlm_set_section_contents (abfd, section, location, offset, count) + bfd *abfd; + asection *section; + PTR location; + file_ptr offset; + bfd_size_type count; +{ + if (abfd->output_has_begun == false + && nlm_compute_section_file_positions (abfd) == false) + return false; + + if (count == 0) + return true; + + /* i386 NetWare has a very restricted set of relocs. In order for + objcopy to work, the NLM i386 backend needs a chance to rework + the section contents so that its set of relocs will work. If all + the relocs are already acceptable, this will not do anything. */ + if (section->reloc_count != 0) + { + boolean (*mangle_relocs_func) PARAMS ((bfd *, asection *, PTR, + bfd_vma, bfd_size_type)); + + mangle_relocs_func = nlm_mangle_relocs_func (abfd); + if (mangle_relocs_func != NULL) + { + if (!(*mangle_relocs_func) (abfd, section, location, + (bfd_vma) offset, count)) + return false; + } + } + + if (bfd_seek (abfd, (file_ptr) (section->filepos + offset), SEEK_SET) != 0 + || bfd_write (location, 1, count, abfd) != count) + return false; + + return true; +} + +/* We need to sort a list of relocs associated with sections when we + write out the external relocs. */ + +static int +nlm_external_reloc_compare (p1, p2) + const void *p1; + const void *p2; +{ + const struct reloc_and_sec *r1 = (const struct reloc_and_sec *) p1; + const struct reloc_and_sec *r2 = (const struct reloc_and_sec *) p2; + int cmp; + + cmp = strcmp ((*r1->rel->sym_ptr_ptr)->name, + (*r2->rel->sym_ptr_ptr)->name); + if (cmp != 0) + return cmp; + + /* 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: + fixed header + variable header + auxiliary headers + code sections + data sections + other sections (custom data, messages, help, shared NLM, RPC, + module dependencies) + relocation fixups + external references (imports) + public symbols (exports) + debugging records + This is similar to the order used by the NetWare tools; the + difference is that NetWare puts the sections other than code, data + and custom data at the end of the NLM. It is convenient for us to + know where the sections are going to be before worrying about the + size of the other information. + + By the time this function is called, all the section data should + have been output using set_section_contents. Note that custom + data, the message file, the help file, the shared NLM file, the RPC + data, and the module dependencies are all considered to be + sections; the caller is responsible for filling in the offset and + length fields in the NLM headers. The relocation fixups and + imports are both obtained from the list of relocs attached to each + section. The exports and debugging records are obtained from the + list of outsymbols. */ + +boolean +nlm_write_object_contents (abfd) + bfd *abfd; +{ + asection *sec; + 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 *) + bfd_malloc ((size_t) nlm_fixed_header_size (abfd))); + if (fixed_header == NULL) + goto error_return; + + if (abfd->output_has_begun == false + && nlm_compute_section_file_positions (abfd) == false) + goto error_return; + + /* Write out the variable length headers. */ + if (bfd_seek (abfd, + nlm_optional_prefix_size (abfd) + nlm_fixed_header_size (abfd), + SEEK_SET) != 0) + goto error_return; + if (nlm_swap_variable_header_out (abfd) == false + || nlm_swap_auxiliary_headers_out (abfd) == 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_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) + 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_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 + needed when they are written out below. */ + internal_reloc_count = 0; + external_reloc_count = 0; + for (sec = abfd->sections; sec != (asection *) NULL; sec = sec->next) + { + arelent **rel_ptr_ptr, **rel_end; + + if (sec->reloc_count == 0) + continue; + + /* We can only represent relocs within a code or data + section. We ignore them for a debugging section. */ + if ((bfd_get_section_flags (abfd, sec) & (SEC_CODE | SEC_DATA)) == 0) + continue; + + /* We need to know how to write out imports */ + if (write_import_func == NULL) + { + bfd_set_error (bfd_error_invalid_operation); + goto error_return; + } + + rel_ptr_ptr = sec->orelocation; + rel_end = rel_ptr_ptr + sec->reloc_count; + for (; rel_ptr_ptr < rel_end; rel_ptr_ptr++) + { + arelent *rel; + asymbol *sym; + + rel = *rel_ptr_ptr; + sym = *rel->sym_ptr_ptr; + + if (! bfd_is_und_section (bfd_get_section (sym))) + { + ++internal_reloc_count; + if ((*write_import_func) (abfd, sec, rel) == false) + goto error_return; + } + else + ++external_reloc_count; + } + } + nlm_fixed_header (abfd)->numberOfRelocationFixups = internal_reloc_count; + + /* Write out the imports (relocs against external symbols). These + are output as a symbol name followed by all the relocs for that + symbol, so we must first gather together all the relocs against + external symbols and sort them. */ + external_relocs = + (struct reloc_and_sec *) bfd_alloc (abfd, + (external_reloc_count + * sizeof (struct reloc_and_sec))); + if (external_relocs == (struct reloc_and_sec *) NULL) + goto error_return; + i = 0; + for (sec = abfd->sections; sec != (asection *) NULL; sec = sec->next) + { + arelent **rel_ptr_ptr, **rel_end; + + if (sec->reloc_count == 0) + continue; + + rel_ptr_ptr = sec->orelocation; + rel_end = rel_ptr_ptr + sec->reloc_count; + for (; rel_ptr_ptr < rel_end; rel_ptr_ptr++) + { + arelent *rel; + asymbol *sym; + + rel = *rel_ptr_ptr; + sym = *rel->sym_ptr_ptr; + + if (! bfd_is_und_section (bfd_get_section (sym))) + continue; + + external_relocs[i].rel = rel; + external_relocs[i].sec = sec; + ++i; + } + } + + BFD_ASSERT (i == external_reloc_count); + + /* Sort the external relocs by name. */ + qsort ((PTR) external_relocs, (size_t) external_reloc_count, + sizeof (struct reloc_and_sec), nlm_external_reloc_compare); + + /* Write out the external relocs. */ + nlm_fixed_header (abfd)->externalReferencesOffset = bfd_tell (abfd); + c = 0; + i = 0; + while (i < external_reloc_count) + { + arelent *rel; + asymbol *sym; + bfd_size_type j, cnt; + + ++c; + + rel = external_relocs[i].rel; + sym = *rel->sym_ptr_ptr; + + cnt = 0; + for (j = i; + (j < external_reloc_count + && *external_relocs[j].rel->sym_ptr_ptr == sym); + j++) + ++cnt; + + if ((*nlm_write_external_func (abfd)) (abfd, cnt, sym, + &external_relocs[i]) + == false) + goto error_return; + + 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; + bfd_byte temp[NLM_TARGET_LONG_SIZE]; + + sym = *sym_ptr_ptr; + + if ((sym->flags & (BSF_EXPORT | BSF_GLOBAL)) == 0 + || bfd_is_und_section (bfd_get_section (sym))) + continue; + + ++c; + + if (get_public_offset_func) + { + /* Most backends can use the code below, but + unfortunately some use a different scheme. */ + offset = (*get_public_offset_func) (abfd, sym); + } + else + { + 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; + } + } + + if (write_export_func) + { + if ((*write_export_func) (abfd, sym, offset) == false) + goto error_return; + } + else + { + 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; + + /* 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++) + { + 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) + { + 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; + } + } + + /* 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 (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)); + + /* 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. */ + 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); + + if (bfd_seek (abfd, 0, SEEK_SET) != 0) + goto error_return; + + write_prefix_func = nlm_write_prefix_func (abfd); + if (write_prefix_func) + { + if ((*write_prefix_func) (abfd) == false) + 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; +} |