diff options
Diffstat (limited to 'binutils/nlmconv.c')
| -rw-r--r-- | binutils/nlmconv.c | 877 |
1 files changed, 877 insertions, 0 deletions
diff --git a/binutils/nlmconv.c b/binutils/nlmconv.c new file mode 100644 index 0000000..9c1755e --- /dev/null +++ b/binutils/nlmconv.c @@ -0,0 +1,877 @@ +/* nlmconv.c -- NLM conversion program + Copyright (C) 1993 Free Software Foundation, Inc. + +This file is part of GNU Binutils. + +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., 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/* Written by Ian Lance Taylor <ian@cygnus.com>. + + This program can be used to convert any appropriate object file + into a NetWare Loadable Module (an NLM). It will accept a linker + specification file which is identical to that accepted by the + NetWare linker, NLMLINK, except that the INPUT command, normally + used to give a list of object files to link together, is not used. + This program will convert only a single object file. */ + +#include <ansidecl.h> +#include <stdio.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <assert.h> +#include <getopt.h> +#include <bfd.h> +#include "sysdep.h" +#include "bucomm.h" +/* Internal BFD NLM header. */ +#include "libnlm.h" +#include "nlmconv.h" + +/* If strerror is just a macro, we want to use the one from libiberty + since it will handle undefined values. */ +#undef strerror +extern char *strerror (); + +/* Global variables. */ + +/* The name used to invoke the program. */ +char *program_name; + +/* The version number. */ +extern char *program_version; + +/* The symbols table. */ +static asymbol **symbols; + +/* Local variables. */ + +/* The list of long options. */ +static struct option long_options[] = +{ + { "header-info", required_argument, 0, 'T' }, + { "help", no_argument, 0, 'H' }, + { "input-format", required_argument, 0, 'I' }, + { "output-format", required_argument, 0, 'O' }, + { "version", no_argument, 0, 'v' }, + { NULL, no_argument, 0, 0 } +}; + +/* Local routines. */ + +static void show_help PARAMS ((void)); +static void show_usage PARAMS ((FILE *, int)); +static const char *select_output_format PARAMS ((enum bfd_architecture, + long, boolean)); +static void setup_sections PARAMS ((bfd *, asection *, PTR)); +static void copy_sections PARAMS ((bfd *, asection *, PTR)); +static void mangle_relocs PARAMS ((bfd *, arelent **, + bfd_size_type, char *, + bfd_size_type)); +static void i386_mangle_relocs PARAMS ((bfd *, arelent **, bfd_size_type, + char *, bfd_size_type)); + +/* The main routine. */ + +int +main (argc, argv) + int argc; + char **argv; +{ + int opt; + const char *input_format = NULL; + const char *output_format = NULL; + const char *header_file = NULL; + bfd *inbfd; + bfd *outbfd; + unsigned int symcount; + unsigned int i; + char inlead, outlead; + boolean gotstart, gotexit, gotcheck; + struct stat st; + FILE *custom_data, *help_data, *message_data, *rpc_data; + bfd_size_type custom_size, help_size, message_size, module_size, rpc_size; + asection *custom_section, *help_section, *message_section, *module_section; + asection *rpc_section; + int len; + + program_name = argv[0]; + + bfd_init (); + + while ((opt = getopt_long (argc, argv, "HI:O:T:v", long_options, (int *) 0)) + != EOF) + { + switch (opt) + { + case 'H': + show_help (); + /*NOTREACHED*/ + case 'I': + input_format = optarg; + break; + case 'O': + output_format = optarg; + break; + case 'T': + header_file = optarg; + break; + case 'v': + printf ("GNU %s version %s\n", program_name, program_version); + exit (0); + /*NOTREACHED*/ + case 0: + break; + default: + show_usage (stderr, 1); + /*NOTREACHED*/ + } + } + + if (optind + 2 != argc) + show_usage (stderr, 1); + + if (strcmp (argv[optind], argv[optind + 1]) == 0) + { + fprintf (stderr, "%s: input and output files must be different\n", + program_name); + exit (1); + } + + inbfd = bfd_openr (argv[optind], input_format); + if (inbfd == NULL) + bfd_fatal (argv[optind]); + + if (! bfd_check_format (inbfd, bfd_object)) + bfd_fatal (argv[optind]); + + if (output_format == NULL) + output_format = select_output_format (bfd_get_arch (inbfd), + bfd_get_mach (inbfd), + inbfd->xvec->byteorder_big_p); + + assert (output_format != NULL); + outbfd = bfd_openw (argv[optind + 1], output_format); + if (outbfd == NULL) + bfd_fatal (argv[optind + 1]); + if (! bfd_set_format (outbfd, bfd_object)) + bfd_fatal (argv[optind + 1]); + + assert (outbfd->xvec->flavour == bfd_target_nlm_flavour); + + if (bfd_arch_get_compatible (inbfd, outbfd) == NULL) + fprintf (stderr, + "%s: warning:input and output formats are not compatible\n", + program_name); + + /* Initialize the header information to default values. */ + fixed_hdr = nlm_fixed_header (outbfd); + var_hdr = nlm_variable_header (outbfd); + version_hdr = nlm_version_header (outbfd); + copyright_hdr = nlm_copyright_header (outbfd); + extended_hdr = nlm_extended_header (outbfd); + check_procedure = NULL; + custom_file = NULL; + debug_info = false; + exit_procedure = "_Stop"; + export_symbols = NULL; + map_file = NULL; + full_map = false; + help_file = NULL; + import_symbols = NULL; + message_file = NULL; + modules = NULL; + sharelib_file = NULL; + start_procedure = "_Prelude"; + verbose = false; + rpc_file = NULL; + + parse_errors = 0; + + /* Parse the header file (if there is one). */ + if (header_file != NULL) + { + if (! nlmlex_file (header_file) + || yyparse () != 0 + || parse_errors != 0) + exit (1); + } + + /* Start copying the input BFD to the output BFD. */ + if (! bfd_set_file_flags (outbfd, bfd_get_file_flags (inbfd))) + bfd_fatal (bfd_get_filename (outbfd)); + + symbols = (asymbol **) xmalloc (get_symtab_upper_bound (inbfd)); + symcount = bfd_canonicalize_symtab (inbfd, symbols); + + /* Adjust symbol information. */ + inlead = bfd_get_symbol_leading_char (inbfd); + outlead = bfd_get_symbol_leading_char (outbfd); + gotstart = false; + gotexit = false; + gotcheck = false; + for (i = 0; i < symcount; i++) + { + register asymbol *sym; + + sym = symbols[i]; + + /* Add or remove a leading underscore. */ + if (inlead != outlead) + { + if (inlead != '\0') + { + if (bfd_asymbol_name (sym)[0] == inlead) + { + if (outlead == '\0') + ++sym->name; + else + { + char *new; + + new = xmalloc (strlen (bfd_asymbol_name (sym)) + 1); + new[0] = outlead; + strcpy (new + 1, bfd_asymbol_name (sym) + 1); + sym->name = new; + } + } + } + else + { + char *new; + + new = xmalloc (strlen (bfd_asymbol_name (sym)) + 2); + new[0] = outlead; + strcpy (new + 1, bfd_asymbol_name (sym)); + sym->name = new; + } + } + + /* If this is a global symbol, see if it's in the export list. + Change the prefix if necessary. */ + if ((sym->flags & (BSF_EXPORT | BSF_GLOBAL)) != 0 + && export_symbols != NULL) + { + register struct string_list *l; + + for (l = export_symbols; l != NULL; l = l->next) + { + if (strcmp (l->string, bfd_asymbol_name (sym)) == 0) + break; + else + { + char *zbase; + + zbase = strchr (l->string, '@'); + if (zbase != NULL + && strcmp (zbase + 1, bfd_asymbol_name (sym)) == 0) + { + sym->name = l->string; + break; + } + } + } + if (l == NULL) + fprintf (stderr, + "%s: warning: symbol %s exported but not in export list\n", + program_name, bfd_asymbol_name (sym)); + } + + /* If it's an undefined symbol, see if it's on the import list. + Change the prefix if necessary. */ + if (bfd_get_section (sym) == &bfd_und_section + && import_symbols != NULL) + { + register struct string_list *l; + + for (l = import_symbols; l != NULL; l = l->next) + { + if (strcmp (l->string, bfd_asymbol_name (sym)) == 0) + break; + else + { + char *zbase; + + zbase = strchr (l->string, '@'); + if (zbase != NULL + && strcmp (zbase + 1, bfd_asymbol_name (sym)) == 0) + { + sym->name = l->string; + break; + } + } + } + if (l == NULL) + fprintf (stderr, + "%s: warning: symbol %s imported but not in import list\n", + program_name, bfd_asymbol_name (sym)); + } + + /* See if it's one of the special named symbols. */ + if (strcmp (bfd_asymbol_name (sym), start_procedure) == 0) + { + if (! bfd_set_start_address (outbfd, bfd_asymbol_value (sym))) + bfd_fatal ("set start address"); + gotstart = true; + } + if (strcmp (bfd_asymbol_name (sym), exit_procedure) == 0) + { + nlm_fixed_header (outbfd)->exitProcedureOffset = + bfd_asymbol_value (sym); + gotexit = true; + } + if (check_procedure != NULL + && strcmp (bfd_asymbol_name (sym), check_procedure) == 0) + { + nlm_fixed_header (outbfd)->checkUnloadProcedureOffset = + bfd_asymbol_value (sym); + gotcheck = true; + } + } + + bfd_set_symtab (outbfd, symbols, symcount); + + if (! gotstart) + fprintf (stderr, "%s: warning: START procedure %s not defined\n", + program_name, start_procedure); + if (! gotexit) + fprintf (stderr, "%s: warning: EXIT procedure %s not defined\n", + program_name, exit_procedure); + if (check_procedure != NULL + && ! gotcheck) + fprintf (stderr, "%s: warning: CHECK procedure %s not defined\n", + program_name, check_procedure); + + /* Set up the sections. */ + bfd_map_over_sections (inbfd, setup_sections, (PTR) outbfd); + + /* Add additional sections required for the header information. */ + if (custom_file != NULL) + { + custom_data = fopen (custom_file, "r"); + if (custom_data == NULL + || fstat (fileno (custom_data), &st) < 0) + { + fprintf (stderr, "%s:%s: %s\n", program_name, custom_file, + strerror (errno)); + custom_file = NULL; + } + else + { + custom_size = st.st_size; + custom_section = bfd_make_section (outbfd, ".nlmcustom"); + if (custom_section == NULL + || ! bfd_set_section_size (outbfd, custom_section, custom_size) + || ! bfd_set_section_flags (outbfd, custom_section, + SEC_HAS_CONTENTS)) + bfd_fatal ("custom section"); + } + } + if (help_file != NULL) + { + help_data = fopen (help_file, "r"); + if (help_data == NULL + || fstat (fileno (help_data), &st) < 0) + { + fprintf (stderr, "%s:%s: %s\n", program_name, help_file, + strerror (errno)); + help_file = NULL; + } + else + { + help_size = st.st_size; + help_section = bfd_make_section (outbfd, ".nlmhelp"); + if (help_section == NULL + || ! bfd_set_section_size (outbfd, help_section, help_size) + || ! bfd_set_section_flags (outbfd, help_section, + SEC_HAS_CONTENTS)) + bfd_fatal ("help section"); + strncpy (nlm_extended_header (outbfd)->stamp, "MeSsAgEs", 8); + } + } + if (message_file != NULL) + { + message_data = fopen (message_file, "r"); + if (message_data == NULL + || fstat (fileno (message_data), &st) < 0) + { + fprintf (stderr, "%s:%s: %s\n", program_name, message_file, + strerror (errno)); + message_file = NULL; + } + else + { + message_size = st.st_size; + message_section = bfd_make_section (outbfd, ".nlmmessages"); + if (message_section == NULL + || ! bfd_set_section_size (outbfd, message_section, message_size) + || ! bfd_set_section_flags (outbfd, message_section, + SEC_HAS_CONTENTS)) + bfd_fatal ("message section"); + strncpy (nlm_extended_header (outbfd)->stamp, "MeSsAgEs", 8); + } + } + if (modules != NULL) + { + struct string_list *l; + + module_size = 0; + for (l = modules; l != NULL; l = l->next) + module_size += strlen (l->string) + 1; + module_section = bfd_make_section (outbfd, ".nlmmodules"); + if (module_section == NULL + || ! bfd_set_section_size (outbfd, module_section, module_size) + || ! bfd_set_section_flags (outbfd, module_section, + SEC_HAS_CONTENTS)) + bfd_fatal ("module section"); + } + if (rpc_file != NULL) + { + rpc_data = fopen (rpc_file, "r"); + if (rpc_data == NULL + || fstat (fileno (rpc_data), &st) < 0) + { + fprintf (stderr, "%s:%s: %s\n", program_name, rpc_file, + strerror (errno)); + rpc_file = NULL; + } + else + { + rpc_size = st.st_size; + rpc_section = bfd_make_section (outbfd, ".nlmrpc"); + if (rpc_section == NULL + || ! bfd_set_section_size (outbfd, rpc_section, rpc_size) + || ! bfd_set_section_flags (outbfd, rpc_section, + SEC_HAS_CONTENTS)) + bfd_fatal ("rpc section"); + strncpy (nlm_extended_header (outbfd)->stamp, "MeSsAgEs", 8); + } + } + + /* Copy over the sections. */ + bfd_map_over_sections (inbfd, copy_sections, (PTR) outbfd); + + /* Finish up the header information. */ + if (custom_file != NULL) + { + PTR data; + + data = xmalloc (custom_size); + if (fread (data, 1, custom_size, custom_data) != custom_size) + fprintf (stderr, "%s:%s: read: %s\n", program_name, custom_file, + strerror (errno)); + else + { + if (! bfd_set_section_contents (outbfd, custom_section, data, + (file_ptr) 0, custom_size)) + bfd_fatal ("custom section"); + nlm_fixed_header (outbfd)->customDataOffset = + custom_section->filepos; + nlm_fixed_header (outbfd)->customDataSize = custom_size; + } + free (data); + } + if (! debug_info) + { + /* As a special hack, the backend recognizes a debugInfoOffset + of -1 to mean that it should not output any debugging + information. This can not be handling by fiddling with the + symbol table because exported symbols appear in both the + export information and the debugging information. */ + nlm_fixed_header (outbfd)->debugInfoOffset = (file_ptr) -1; + } + if (map_file != NULL) + fprintf (stderr, + "%s: MAP and FULLMAP are not supported; try ld -M\n", + program_name); + if (help_file != NULL) + { + PTR data; + + data = xmalloc (help_size); + if (fread (data, 1, help_size, help_data) != help_size) + fprintf (stderr, "%s:%s: read: %s\n", program_name, help_file, + strerror (errno)); + else + { + if (! bfd_set_section_contents (outbfd, help_section, data, + (file_ptr) 0, help_size)) + bfd_fatal ("help section"); + nlm_extended_header (outbfd)->helpFileOffset = + help_section->filepos; + nlm_extended_header (outbfd)->helpFileLength = help_size; + } + free (data); + } + if (message_file != NULL) + { + PTR data; + + data = xmalloc (message_size); + if (fread (data, 1, message_size, message_data) != message_size) + fprintf (stderr, "%s:%s: read: %s\n", program_name, message_file, + strerror (errno)); + else + { + if (! bfd_set_section_contents (outbfd, message_section, data, + (file_ptr) 0, message_size)) + bfd_fatal ("message section"); + nlm_extended_header (outbfd)->messageFileOffset = + message_section->filepos; + nlm_extended_header (outbfd)->messageFileLength = message_size; + + /* FIXME: Are these offsets correct on all platforms? Are + they 32 bits on all platforms? What endianness? */ + nlm_extended_header (outbfd)->languageID = + bfd_h_get_32 (outbfd, (bfd_byte *) data + 106); + nlm_extended_header (outbfd)->messageCount = + bfd_h_get_32 (outbfd, (bfd_byte *) data + 110); + } + free (data); + } + if (modules != NULL) + { + PTR data; + char *set; + struct string_list *l; + bfd_size_type c; + + data = xmalloc (module_size); + c = 0; + set = (char *) data; + for (l = modules; l != NULL; l = l->next) + { + *set = strlen (l->string); + strncpy (set + 1, l->string, *set); + set += *set + 1; + ++c; + } + if (! bfd_set_section_contents (outbfd, module_section, data, + (file_ptr) 0, module_size)) + bfd_fatal ("module section"); + nlm_fixed_header (outbfd)->moduleDependencyOffset = + module_section->filepos; + nlm_fixed_header (outbfd)->numberOfModuleDependencies = c; + } + if (rpc_file != NULL) + { + PTR data; + + data = xmalloc (rpc_size); + if (fread (data, 1, rpc_size, rpc_data) != rpc_size) + fprintf (stderr, "%s:%s: read: %s\n", program_name, rpc_file, + strerror (errno)); + else + { + if (! bfd_set_section_contents (outbfd, rpc_section, data, + (file_ptr) 0, rpc_size)) + bfd_fatal ("rpc section"); + nlm_extended_header (outbfd)->RPCDataOffset = + rpc_section->filepos; + nlm_extended_header (outbfd)->RPCDataLength = rpc_size; + } + free (data); + } + len = strlen (argv[optind + 1]); + if (len > NLM_MODULE_NAME_SIZE - 2) + len = NLM_MODULE_NAME_SIZE - 2; + nlm_fixed_header (outbfd)->moduleName[0] = len; + strncpy (nlm_fixed_header (outbfd)->moduleName + 1, argv[optind + 1], + NLM_MODULE_NAME_SIZE - 2); + nlm_fixed_header (outbfd)->moduleName[NLM_MODULE_NAME_SIZE - 1] = '\0'; + strncpy (nlm_variable_header (outbfd)->oldThreadName, " LONG", + NLM_OLD_THREAD_NAME_LENGTH); + + if (! bfd_close (outbfd)) + bfd_fatal (argv[optind + 1]); + if (! bfd_close (inbfd)) + bfd_fatal (argv[optind]); + + return 0; +} + +/* Display a help message and exit. */ + +static void +show_help () +{ + printf ("%s: Convert an object file into a NetWare Loadable Module\n", + program_name); + show_usage (stdout, 0); +} + +/* Show a usage message and exit. */ + +static void +show_usage (file, status) + FILE *file; + int status; +{ + fprintf (file, "\ +Usage: %s [-Hv] [-I format] [-O format] [-T header-file]\n\ + [--input-format=format] [--output-format=format]\n\ + [--header-file=file] [--help] [--version]\n\ + in-file out-file\n", + program_name); + exit (status); +} + +/* Select the output format based on the input architecture, machine, + and endianness. This chooses the appropriate NLM target. */ + +static const char * +select_output_format (arch, mach, bigendian) + enum bfd_architecture arch; + long mach; + boolean bigendian; +{ + switch (arch) + { + case bfd_arch_i386: + return "nlm32-i386"; + default: + fprintf (stderr, "%s: no default NLM format for %s\n", + program_name, bfd_printable_arch_mach (arch, mach)); + exit (1); + /* Avoid warning. */ + return NULL; + } + /*NOTREACHED*/ +} + +/* The BFD sections are copied in two passes. This function sets up + the section name, size, etc. */ + +static void +setup_sections (inbfd, insec, data_ptr) + bfd *inbfd; + asection *insec; + PTR data_ptr; +{ + bfd *outbfd = (bfd *) data_ptr; + asection *outsec; + + outsec = bfd_get_section_by_name (outbfd, bfd_section_name (inbfd, insec)); + if (outsec == NULL) + { + outsec = bfd_make_section (outbfd, bfd_section_name (inbfd, insec)); + if (outsec == NULL) + bfd_fatal ("make section"); + } + + insec->output_section = outsec; + insec->output_offset = 0; + + if (! bfd_set_section_size (outbfd, outsec, + bfd_section_size (inbfd, insec))) + bfd_fatal ("set section size"); + + if (! bfd_set_section_vma (outbfd, outsec, + bfd_section_vma (inbfd, insec))) + bfd_fatal ("set section vma"); + + if (! bfd_set_section_alignment (outbfd, outsec, + bfd_section_alignment (inbfd, insec))) + bfd_fatal ("set section alignment"); + + if (! bfd_set_section_flags (outbfd, outsec, + bfd_get_section_flags (inbfd, insec))) + bfd_fatal ("set section flags"); +} + +/* Copy the section contents. */ + +static void +copy_sections (inbfd, insec, data_ptr) + bfd *inbfd; + asection *insec; + PTR data_ptr; +{ + bfd *outbfd = (bfd *) data_ptr; + asection *outsec; + bfd_size_type size; + PTR contents; + bfd_size_type reloc_size; + + outsec = bfd_get_section_by_name (outbfd, bfd_section_name (inbfd, insec)); + assert (outsec != NULL); + + size = bfd_get_section_size_before_reloc (insec); + if (size == 0) + return; + + /* FIXME: Why are these necessary? */ + insec->_cooked_size = insec->_raw_size; + insec->reloc_done = true; + + if ((bfd_get_section_flags (inbfd, insec) & SEC_HAS_CONTENTS) == 0) + contents = NULL; + else + { + contents = xmalloc (size); + if (! bfd_get_section_contents (inbfd, insec, contents, + (file_ptr) 0, size)) + bfd_fatal (bfd_get_filename (inbfd)); + } + + reloc_size = bfd_get_reloc_upper_bound (inbfd, insec); + if (reloc_size == 0) + bfd_set_reloc (outbfd, outsec, (arelent **) NULL, 0); + else + { + arelent **relocs; + bfd_size_type reloc_count; + + relocs = (arelent **) xmalloc (reloc_size); + reloc_count = bfd_canonicalize_reloc (inbfd, insec, relocs, symbols); + mangle_relocs (outbfd, relocs, reloc_count, (char *) contents, size); + bfd_set_reloc (outbfd, outsec, relocs, reloc_count); + } + + if (contents != NULL) + { + if (! bfd_set_section_contents (outbfd, outsec, contents, + (file_ptr) 0, size)) + bfd_fatal (bfd_get_filename (outbfd)); + free (contents); + } +} + +/* Some, perhaps all, NetWare targets require changing the relocs used + by the input formats. */ + +static void +mangle_relocs (outbfd, relocs, reloc_count, contents, contents_size) + bfd *outbfd; + arelent **relocs; + bfd_size_type reloc_count; + char *contents; + bfd_size_type contents_size; +{ + switch (bfd_get_arch (outbfd)) + { + case bfd_arch_i386: + i386_mangle_relocs (outbfd, relocs, reloc_count, contents, + contents_size); + break; + default: + break; + } +} + +/* NetWare on the i386 supports a restricted set of relocs, which are + different from those used on other i386 targets. This routine + converts the relocs. It is, obviously, very target dependent. At + the moment, the nlm32-i386 backend performs similar translations; + however, it is more reliable and efficient to do them here. */ + +static reloc_howto_type nlm_i386_pcrel_howto = + HOWTO (1, /* type */ + 0, /* rightshift */ + 2, /* size (0 = byte, 1 = short, 2 = long) */ + 32, /* bitsize */ + true, /* pc_relative */ + 0, /* bitpos */ + complain_overflow_signed, /* complain_on_overflow */ + 0, /* special_function */ + "DISP32", /* name */ + true, /* partial_inplace */ + 0xffffffff, /* src_mask */ + 0xffffffff, /* dst_mask */ + true); /* pcrel_offset */ + +static void +i386_mangle_relocs (outbfd, relocs, reloc_count, contents, contents_size) + bfd *outbfd; + arelent **relocs; + bfd_size_type reloc_count; + char *contents; + bfd_size_type contents_size; +{ + while (reloc_count-- != 0) + { + arelent *rel; + asymbol *sym; + bfd_vma addend; + + rel = *relocs++; + sym = *rel->sym_ptr_ptr; + + /* Note that no serious harm will ensue if we fail to change a + reloc. The backend will fail when writing out the reloc. */ + + /* Make sure this reloc is within the data we have. We use only + 4 byte relocs here, so we insist on having 4 bytes. */ + if (rel->address + 4 > contents_size) + continue; + + /* NetWare doesn't support reloc addends, so we get rid of them + here by simply adding them into the object data. We handle + the symbol value, if any, the same way. */ + addend = rel->addend; + if (! bfd_is_com_section (bfd_get_section (sym))) + addend += sym->value; + + if (addend != 0 + && rel->howto != NULL + && rel->howto->rightshift == 0 + && rel->howto->size == 2 + && rel->howto->bitsize == 32 + && rel->howto->bitpos == 0 + && rel->howto->src_mask == 0xffffffff + && rel->howto->dst_mask == 0xffffffff) + { + bfd_vma val; + + val = bfd_get_32 (outbfd, contents + rel->address); + val += addend; + bfd_put_32 (outbfd, val, contents + rel->address); + + /* Adjust the reloc for the changes we just made. */ + rel->addend = 0; + if (! bfd_is_com_section (bfd_get_section (sym)) + && sym->value != 0) + rel->sym_ptr_ptr = bfd_get_section (sym)->symbol_ptr_ptr; + } + + /* NetWare uses a reloc with pcrel_offset set. We adjust + pc_relative relocs accordingly. We are going to change the + howto field, so we can only do this if the current one is + compatible. We should check that special_function is NULL + here, but at the moment coff-i386 uses a special_function + which does not affect what we are doing here. */ + if (rel->howto != NULL + && rel->howto->pc_relative + && ! rel->howto->pcrel_offset + && rel->howto->rightshift == 0 + && rel->howto->size == 2 + && rel->howto->bitsize == 32 + && rel->howto->bitpos == 0 + && rel->howto->src_mask == 0xffffffff + && rel->howto->dst_mask == 0xffffffff) + { + bfd_vma val; + + /* When pcrel_offset is not set, it means that the negative + of the address of the memory location is stored in the + memory location. We must add it back in. */ + val = bfd_get_32 (outbfd, contents + rel->address); + val += rel->address; + bfd_put_32 (outbfd, val, contents + rel->address); + + /* We must change to a new howto. */ + rel->howto = &nlm_i386_pcrel_howto; + } + } +} |