X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=binutils%2Fnlmconv.c;h=8cb4c814c74d9ddd557951f1202c436b45760406;hb=c2274b2767dba3175e585bd17f9f4a93b56cdc63;hp=94d36580240e568475aaa12ecf8a988f2e6c8289;hpb=e70f2bde6f7c829b936727150a55c105bb8be9f4;p=deliverable%2Fbinutils-gdb.git diff --git a/binutils/nlmconv.c b/binutils/nlmconv.c index 94d3658024..8cb4c814c7 100644 --- a/binutils/nlmconv.c +++ b/binutils/nlmconv.c @@ -1,5 +1,6 @@ /* nlmconv.c -- NLM conversion program - Copyright (C) 1993 Free Software Foundation, Inc. + Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001 + Free Software Foundation, Inc. This file is part of GNU Binutils. @@ -15,50 +16,52 @@ 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. */ +Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ /* Written by Ian Lance Taylor . 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. */ + NetWare linker, NLMLINK. */ + +/* AIX requires this to be the first thing in the file. */ +#ifndef __GNUC__ +# ifdef _AIX + #pragma alloca +#endif +#endif + +#include "bfd.h" +#include "libiberty.h" +#include "bucomm.h" +#include "safe-ctype.h" #include -#include #include -#include -#include #include #include #include #include -#include -#include "sysdep.h" -#include "bucomm.h" + /* Internal BFD NLM header. */ #include "libnlm.h" #include "nlmconv.h" -/* Needed for Alpha support. */ +#ifdef NLMCONV_ALPHA #include "coff/sym.h" #include "coff/ecoff.h" +#endif /* 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 (); +extern char *strerror PARAMS ((int)); #ifndef localtime extern struct tm *localtime (); #endif -#ifndef getenv -extern char *getenv (); -#endif - #ifndef SEEK_SET #define SEEK_SET 0 #endif @@ -74,9 +77,6 @@ extern char *getenv (); /* The name used to invoke the program. */ char *program_name; -/* The version number. */ -extern char *program_version; - /* Local variables. */ /* Whether to print out debugging information (currently just controls @@ -86,6 +86,20 @@ static int debug; /* The symbol table. */ static asymbol **symbols; +/* A section we create in the output file to hold pointers to where + the sections of the input file end up. We will put a pointer to + this section in the NLM header. These is an entry for each input + section. The format is + null terminated section name + zeroes to adjust to 4 byte boundary + 4 byte section data file pointer + 4 byte section size + We don't need a version number. The way we find this information + is by finding a stamp in the NLM header information. If we need to + change the format of this information, we can simply change the + stamp. */ +static asection *secsec; + /* A temporary file name to be unlinked on exit. Actually, for most errors, we leave it around. It's not clear whether that is helpful or not. */ @@ -115,22 +129,32 @@ static const char *select_output_format PARAMS ((enum bfd_architecture, static void setup_sections PARAMS ((bfd *, asection *, PTR)); static void copy_sections PARAMS ((bfd *, asection *, PTR)); static void mangle_relocs PARAMS ((bfd *, asection *, arelent ***, - bfd_size_type *, char *, + long *, char *, bfd_size_type)); +static void default_mangle_relocs PARAMS ((bfd *, asection *, arelent ***, + long *, char *, + bfd_size_type)); +static char *link_inputs PARAMS ((struct string_list *, char *)); + +#ifdef NLMCONV_I386 static void i386_mangle_relocs PARAMS ((bfd *, asection *, arelent ***, - bfd_size_type *, char *, + long *, char *, bfd_size_type)); +#endif + +#ifdef NLMCONV_ALPHA static void alpha_mangle_relocs PARAMS ((bfd *, asection *, arelent ***, - bfd_size_type *, char *, + long *, char *, bfd_size_type)); -static void default_mangle_relocs PARAMS ((bfd *, asection *, arelent ***, - bfd_size_type *, char *, +#endif + +#ifdef NLMCONV_POWERPC +static void powerpc_build_stubs PARAMS ((bfd *, bfd *, asymbol ***, long *)); +static void powerpc_resolve_stubs PARAMS ((bfd *, bfd *)); +static void powerpc_mangle_relocs PARAMS ((bfd *, asection *, arelent ***, + long *, char *, bfd_size_type)); -static char *link_inputs PARAMS ((struct string_list *, char *)); -static const char *choose_temp_base_try PARAMS ((const char *, - const char *)); -static void choose_temp_base PARAMS ((void)); -static int pexecute PARAMS ((char *, char *[])); +#endif /* The main routine. */ @@ -153,28 +177,54 @@ main (argc, argv) bfd *inbfd; bfd *outbfd; asymbol **newsyms, **outsyms; - unsigned int symcount, newsymalloc, newsymcount; - asection *bss_sec, *data_sec; + long symcount, newsymalloc, newsymcount; + long symsize; + asection *text_sec, *bss_sec, *data_sec; bfd_vma vma; bfd_size_type align; asymbol *endsym; - unsigned int i; + long i; char inlead, outlead; boolean gotstart, gotexit, gotcheck; struct stat st; - FILE *custom_data, *help_data, *message_data, *rpc_data, *shared_data; - size_t custom_size, help_size, message_size, module_size, rpc_size; - asection *custom_section, *help_section, *message_section, *module_section; - asection *rpc_section, *shared_section; + FILE *custom_data = NULL; + FILE *help_data = NULL; + FILE *message_data = NULL; + FILE *rpc_data = NULL; + FILE *shared_data = NULL; + size_t custom_size = 0; + size_t help_size = 0; + size_t message_size = 0; + size_t module_size = 0; + size_t rpc_size = 0; + asection *custom_section = NULL; + asection *help_section = NULL; + asection *message_section = NULL; + asection *module_section = NULL; + asection *rpc_section = NULL; + asection *shared_section = NULL; bfd *sharedbfd; - size_t shared_offset, shared_size; + size_t shared_offset = 0; + size_t shared_size = 0; Nlm_Internal_Fixed_Header sharedhdr; int len; char *modname; + char **matching; + +#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES) + setlocale (LC_MESSAGES, ""); +#endif +#if defined (HAVE_SETLOCALE) + setlocale (LC_CTYPE, ""); +#endif + bindtextdomain (PACKAGE, LOCALEDIR); + textdomain (PACKAGE); program_name = argv[0]; + xmalloc_set_program_name (program_name); bfd_init (); + set_default_bfd_target (); while ((opt = getopt_long (argc, argv, "dhI:l:O:T:V", long_options, (int *) NULL)) @@ -201,8 +251,7 @@ main (argc, argv) header_file = optarg; break; case 'V': - printf ("GNU %s version %s\n", program_name, program_version); - exit (0); + print_version ("nlmconv"); /*NOTREACHED*/ case 0: break; @@ -226,10 +275,7 @@ main (argc, argv) show_usage (stderr, 1); if (strcmp (input_file, output_file) == 0) { - fprintf (stderr, - "%s: input and output files must be different\n", - program_name); - exit (1); + fatal (_("input and output files must be different")); } } } @@ -276,10 +322,7 @@ main (argc, argv) { if (input_file != NULL) { - fprintf (stderr, - "%s: input file named both on command line and with INPUT\n", - program_name); - exit (1); + fatal (_("input file named both on command line and with INPUT")); } if (input_files->next == NULL) input_file = input_files->string; @@ -288,7 +331,7 @@ main (argc, argv) } else if (input_file == NULL) { - fprintf (stderr, "%s: no input file\n", program_name); + non_fatal (_("no input file")); show_usage (stderr, 1); } @@ -296,13 +339,21 @@ main (argc, argv) if (inbfd == NULL) bfd_fatal (input_file); - if (! bfd_check_format (inbfd, bfd_object)) - bfd_fatal (input_file); + if (! bfd_check_format_matches (inbfd, bfd_object, &matching)) + { + bfd_nonfatal (input_file); + if (bfd_get_error () == bfd_error_file_ambiguously_recognized) + { + list_matching_formats (matching); + free (matching); + } + exit (1); + } if (output_format == NULL) output_format = select_output_format (bfd_get_arch (inbfd), bfd_get_mach (inbfd), - inbfd->xvec->byteorder_big_p); + bfd_big_endian (inbfd)); assert (output_format != NULL); @@ -310,8 +361,7 @@ main (argc, argv) Otherwise use the file named in the OUTPUT statement. */ if (output_file == NULL) { - fprintf (stderr, "%s: no name for output file\n", - program_name); + non_fatal (_("no name for output file")); show_usage (stderr, 1); } @@ -321,12 +371,10 @@ main (argc, argv) if (! bfd_set_format (outbfd, bfd_object)) bfd_fatal (output_file); - assert (outbfd->xvec->flavour == bfd_target_nlm_flavour); + assert (bfd_get_flavour (outbfd) == 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); + non_fatal (_("warning: input and output formats are not compatible")); /* Move the values read from the command file into outbfd. */ *nlm_fixed_header (outbfd) = fixed_hdr_struct; @@ -339,8 +387,13 @@ main (argc, argv) 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)); + symsize = bfd_get_symtab_upper_bound (inbfd); + if (symsize < 0) + bfd_fatal (input_file); + symbols = (asymbol **) xmalloc (symsize); symcount = bfd_canonicalize_symtab (inbfd, symbols); + if (symcount < 0) + bfd_fatal (input_file); /* Make sure we have a .bss section. */ bss_sec = bfd_get_section_by_name (outbfd, NLM_UNINITIALIZED_DATA_NAME); @@ -350,12 +403,34 @@ main (argc, argv) if (bss_sec == NULL || ! bfd_set_section_flags (outbfd, bss_sec, SEC_ALLOC) || ! bfd_set_section_alignment (outbfd, bss_sec, 1)) - bfd_fatal ("make .bss section"); + bfd_fatal (_("make .bss section")); } + /* We store the original section names in the .nlmsections section, + so that programs which understand it can resurrect the original + sections from the NLM. We will put a pointer to .nlmsections in + the NLM header area. */ + secsec = bfd_make_section (outbfd, ".nlmsections"); + if (secsec == NULL) + bfd_fatal (_("make .nlmsections section")); + if (! bfd_set_section_flags (outbfd, secsec, SEC_HAS_CONTENTS)) + bfd_fatal (_("set .nlmsections flags")); + +#ifdef NLMCONV_POWERPC + /* For PowerPC NetWare we need to build stubs for calls to undefined + symbols. Because each stub requires an entry in the TOC section + which must be at the same location as other entries in the TOC + section, we must do this before determining where the TOC section + goes in setup_sections. */ + if (bfd_get_arch (inbfd) == bfd_arch_powerpc) + powerpc_build_stubs (inbfd, outbfd, &symbols, &symcount); +#endif + /* Set up the sections. */ bfd_map_over_sections (inbfd, setup_sections, (PTR) outbfd); + text_sec = bfd_get_section_by_name (outbfd, NLM_CODE_NAME); + /* The .bss section immediately follows the .data section. */ data_sec = bfd_get_section_by_name (outbfd, NLM_INITIALIZED_DATA_NAME); if (data_sec != NULL) @@ -367,14 +442,14 @@ main (argc, argv) add = ((vma + align - 1) &~ (align - 1)) - vma; vma += add; if (! bfd_set_section_vma (outbfd, bss_sec, vma)) - bfd_fatal ("set .bss vma"); + bfd_fatal (_("set .bss vma")); if (add != 0) { bfd_size_type data_size; data_size = bfd_get_section_size_before_reloc (data_sec); if (! bfd_set_section_size (outbfd, data_sec, data_size + add)) - bfd_fatal ("set .data size"); + bfd_fatal (_("set .data size")); } } @@ -452,8 +527,9 @@ main (argc, argv) /* Force _edata and _end to be defined. This would normally be done by the linker, but the manipulation of the common symbols will confuse it. */ - if (bfd_asymbol_name (sym)[0] == '_' - && bfd_get_section (sym) == &bfd_und_section) + if ((sym->flags & BSF_DEBUGGING) == 0 + && bfd_asymbol_name (sym)[0] == '_' + && bfd_is_und_section (bfd_get_section (sym))) { if (strcmp (bfd_asymbol_name (sym), "_edata") == 0) { @@ -465,7 +541,22 @@ main (argc, argv) sym->section = bss_sec; endsym = sym; } - } + +#ifdef NLMCONV_POWERPC + /* For PowerPC NetWare, we define __GOT0. This is the start + of the .got section. */ + if (bfd_get_arch (inbfd) == bfd_arch_powerpc + && strcmp (bfd_asymbol_name (sym), "__GOT0") == 0) + { + asection *got_sec; + + got_sec = bfd_get_section_by_name (inbfd, ".got"); + assert (got_sec != (asection *) NULL); + sym->value = got_sec->output_offset; + sym->section = got_sec->output_section; + } +#endif + } /* If this is a global symbol, check the export list. */ if ((sym->flags & (BSF_EXPORT | BSF_GLOBAL)) != 0) @@ -493,7 +584,7 @@ main (argc, argv) { newsymalloc += 10; newsyms = ((asymbol **) - xrealloc (newsyms, + xrealloc ((PTR) newsyms, (newsymalloc * sizeof (asymbol *)))); } @@ -516,7 +607,7 @@ main (argc, argv) /* 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) + if (bfd_is_und_section (bfd_get_section (sym))) { register struct string_list *l; @@ -538,35 +629,60 @@ main (argc, argv) } } if (l == NULL) - fprintf (stderr, - "%s: warning: symbol %s imported but not in import list\n", - program_name, bfd_asymbol_name (sym)); + non_fatal (_("warning: symbol %s imported but not in import list"), + 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) + if ((sym->flags & BSF_DEBUGGING) == 0) { - nlm_fixed_header (outbfd)->checkUnloadProcedureOffset = - bfd_asymbol_value (sym); - gotcheck = true; + bfd_vma val; + + /* FIXME: If these symbols are not in the .text section, we + add the .text section size to the value. This may not be + correct for all targets. I'm not sure how this should + really be handled. */ + if (strcmp (bfd_asymbol_name (sym), start_procedure) == 0) + { + val = bfd_asymbol_value (sym); + if (bfd_get_section (sym) == data_sec + && text_sec != (asection *) NULL) + val += bfd_section_size (outbfd, text_sec); + if (! bfd_set_start_address (outbfd, val)) + bfd_fatal (_("set start address")); + gotstart = true; + } + if (strcmp (bfd_asymbol_name (sym), exit_procedure) == 0) + { + val = bfd_asymbol_value (sym); + if (bfd_get_section (sym) == data_sec + && text_sec != (asection *) NULL) + val += bfd_section_size (outbfd, text_sec); + nlm_fixed_header (outbfd)->exitProcedureOffset = val; + gotexit = true; + } + if (check_procedure != NULL + && strcmp (bfd_asymbol_name (sym), check_procedure) == 0) + { + val = bfd_asymbol_value (sym); + if (bfd_get_section (sym) == data_sec + && text_sec != (asection *) NULL) + val += bfd_section_size (outbfd, text_sec); + nlm_fixed_header (outbfd)->checkUnloadProcedureOffset = val; + gotcheck = true; + } } } if (endsym != NULL) - endsym->value = bfd_get_section_size_before_reloc (bss_sec); + { + endsym->value = bfd_get_section_size_before_reloc (bss_sec); + + /* FIXME: If any relocs referring to _end use inplace addends, + then I think they need to be updated. This is handled by + i386_mangle_relocs. Is it needed for any other object + formats? */ + } if (newsymcount == 0) outsyms = symbols; @@ -582,15 +698,11 @@ main (argc, argv) bfd_set_symtab (outbfd, outsyms, symcount + newsymcount); if (! gotstart) - fprintf (stderr, "%s: warning: START procedure %s not defined\n", - program_name, start_procedure); + non_fatal (_("warning: START procedure %s not defined"), 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); + non_fatal (_("warning: EXIT procedure %s not defined"), exit_procedure); + if (check_procedure != NULL && ! gotcheck) + non_fatal (_("warning: CHECK procedure %s not defined"), check_procedure); /* Add additional sections required for the header information. */ if (custom_file != NULL) @@ -611,7 +723,7 @@ main (argc, argv) || ! bfd_set_section_size (outbfd, custom_section, custom_size) || ! bfd_set_section_flags (outbfd, custom_section, SEC_HAS_CONTENTS)) - bfd_fatal ("custom section"); + bfd_fatal (_("custom section")); } } if (help_file != NULL) @@ -632,7 +744,7 @@ main (argc, argv) || ! bfd_set_section_size (outbfd, help_section, help_size) || ! bfd_set_section_flags (outbfd, help_section, SEC_HAS_CONTENTS)) - bfd_fatal ("help section"); + bfd_fatal (_("help section")); strncpy (nlm_extended_header (outbfd)->stamp, "MeSsAgEs", 8); } } @@ -654,7 +766,7 @@ main (argc, argv) || ! bfd_set_section_size (outbfd, message_section, message_size) || ! bfd_set_section_flags (outbfd, message_section, SEC_HAS_CONTENTS)) - bfd_fatal ("message section"); + bfd_fatal (_("message section")); strncpy (nlm_extended_header (outbfd)->stamp, "MeSsAgEs", 8); } } @@ -670,7 +782,7 @@ main (argc, argv) || ! bfd_set_section_size (outbfd, module_section, module_size) || ! bfd_set_section_flags (outbfd, module_section, SEC_HAS_CONTENTS)) - bfd_fatal ("module section"); + bfd_fatal (_("module section")); } if (rpc_file != NULL) { @@ -690,7 +802,7 @@ main (argc, argv) || ! bfd_set_section_size (outbfd, rpc_section, rpc_size) || ! bfd_set_section_flags (outbfd, rpc_section, SEC_HAS_CONTENTS)) - bfd_fatal ("rpc section"); + bfd_fatal (_("rpc section")); strncpy (nlm_extended_header (outbfd)->stamp, "MeSsAgEs", 8); } } @@ -701,7 +813,7 @@ main (argc, argv) || ! bfd_check_format (sharedbfd, bfd_object)) { fprintf (stderr, "%s:%s: %s\n", program_name, sharelib_file, - bfd_errmsg (bfd_error)); + bfd_errmsg (bfd_get_error ())); sharelib_file = NULL; } else @@ -723,16 +835,22 @@ main (argc, argv) need. However, we would have to figure out the sizes of the external and public information, and that can not be done without reading through them. */ + if (sharedhdr.uninitializedDataSize > 0) + { + /* There is no place to record this information. */ + non_fatal (_("%s: warning: shared libraries can not have uninitialized data"), + sharelib_file); + } shared_offset = st.st_size; - if (shared_offset > sharedhdr.codeImageOffset) + if (shared_offset > (size_t) sharedhdr.codeImageOffset) shared_offset = sharedhdr.codeImageOffset; - if (shared_offset > sharedhdr.dataImageOffset) + if (shared_offset > (size_t) sharedhdr.dataImageOffset) shared_offset = sharedhdr.dataImageOffset; - if (shared_offset > sharedhdr.relocationFixupOffset) + if (shared_offset > (size_t) sharedhdr.relocationFixupOffset) shared_offset = sharedhdr.relocationFixupOffset; - if (shared_offset > sharedhdr.externalReferencesOffset) + if (shared_offset > (size_t) sharedhdr.externalReferencesOffset) shared_offset = sharedhdr.externalReferencesOffset; - if (shared_offset > sharedhdr.publicsOffset) + if (shared_offset > (size_t) sharedhdr.publicsOffset) shared_offset = sharedhdr.publicsOffset; shared_size = st.st_size - shared_offset; shared_section = bfd_make_section (outbfd, ".nlmshared"); @@ -741,7 +859,7 @@ main (argc, argv) shared_size) || ! bfd_set_section_flags (outbfd, shared_section, SEC_HAS_CONTENTS)) - bfd_fatal ("shared section"); + bfd_fatal (_("shared section")); strncpy (nlm_extended_header (outbfd)->stamp, "MeSsAgEs", 8); } } @@ -749,13 +867,14 @@ main (argc, argv) /* Check whether a version was given. */ if (strncmp (version_hdr->stamp, "VeRsIoN#", 8) != 0) - fprintf (stderr, "%s: warning: No version number given\n", - program_name); + non_fatal (_("warning: No version number given")); /* At least for now, always create an extended header, because that is what NLMLINK does. */ strncpy (nlm_extended_header (outbfd)->stamp, "MeSsAgEs", 8); + strncpy (nlm_cygnus_ext_header (outbfd)->stamp, "CyGnUsEx", 8); + /* If the date was not given, force it in. */ if (nlm_version_header (outbfd)->month == 0 && nlm_version_header (outbfd)->day == 0 @@ -772,6 +891,12 @@ main (argc, argv) strncpy (version_hdr->stamp, "VeRsIoN#", 8); } +#ifdef NLMCONV_POWERPC + /* Resolve the stubs we build for PowerPC NetWare. */ + if (bfd_get_arch (inbfd) == bfd_arch_powerpc) + powerpc_resolve_stubs (inbfd, outbfd); +#endif + /* Copy over the sections. */ bfd_map_over_sections (inbfd, copy_sections, (PTR) outbfd); @@ -782,13 +907,12 @@ main (argc, argv) 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)); + non_fatal (_("%s: read: %s"), custom_file, strerror (errno)); else { if (! bfd_set_section_contents (outbfd, custom_section, data, (file_ptr) 0, custom_size)) - bfd_fatal ("custom section"); + bfd_fatal (_("custom section")); nlm_fixed_header (outbfd)->customDataOffset = custom_section->filepos; nlm_fixed_header (outbfd)->customDataSize = custom_size; @@ -805,22 +929,19 @@ main (argc, argv) nlm_fixed_header (outbfd)->debugInfoOffset = (file_ptr) -1; } if (map_file != NULL) - fprintf (stderr, - "%s: warning: MAP and FULLMAP are not supported; try ld -M\n", - program_name); + non_fatal (_("warning: MAP and FULLMAP are not supported; try ld -M")); 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)); + non_fatal (_("%s: read: %s"), help_file, strerror (errno)); else { if (! bfd_set_section_contents (outbfd, help_section, data, (file_ptr) 0, help_size)) - bfd_fatal ("help section"); + bfd_fatal (_("help section")); nlm_extended_header (outbfd)->helpFileOffset = help_section->filepos; nlm_extended_header (outbfd)->helpFileLength = help_size; @@ -833,13 +954,12 @@ main (argc, argv) 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)); + non_fatal (_("%s: read: %s"), message_file, strerror (errno)); else { if (! bfd_set_section_contents (outbfd, message_section, data, (file_ptr) 0, message_size)) - bfd_fatal ("message section"); + bfd_fatal (_("message section")); nlm_extended_header (outbfd)->messageFileOffset = message_section->filepos; nlm_extended_header (outbfd)->messageFileLength = message_size; @@ -872,7 +992,7 @@ main (argc, argv) } if (! bfd_set_section_contents (outbfd, module_section, data, (file_ptr) 0, module_size)) - bfd_fatal ("module section"); + bfd_fatal (_("module section")); nlm_fixed_header (outbfd)->moduleDependencyOffset = module_section->filepos; nlm_fixed_header (outbfd)->numberOfModuleDependencies = c; @@ -883,13 +1003,12 @@ main (argc, argv) 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)); + non_fatal (_("%s: read: %s"), rpc_file, strerror (errno)); else { if (! bfd_set_section_contents (outbfd, rpc_section, data, (file_ptr) 0, rpc_size)) - bfd_fatal ("rpc section"); + bfd_fatal (_("rpc section")); nlm_extended_header (outbfd)->RPCDataOffset = rpc_section->filepos; nlm_extended_header (outbfd)->RPCDataLength = rpc_size; @@ -903,13 +1022,12 @@ main (argc, argv) data = xmalloc (shared_size); if (fseek (shared_data, shared_offset, SEEK_SET) != 0 || fread (data, 1, shared_size, shared_data) != shared_size) - fprintf (stderr, "%s:%s: read: %s\n", program_name, sharelib_file, - strerror (errno)); + non_fatal (_("%s: read: %s"), sharelib_file, strerror (errno)); else { if (! bfd_set_section_contents (outbfd, shared_section, data, (file_ptr) 0, shared_size)) - bfd_fatal ("shared section"); + bfd_fatal (_("shared section")); } nlm_extended_header (outbfd)->sharedCodeOffset = sharedhdr.codeImageOffset - shared_offset + shared_section->filepos; @@ -956,12 +1074,14 @@ main (argc, argv) for (modname = nlm_fixed_header (outbfd)->moduleName; *modname != '\0'; modname++) - if (islower (*modname)) - *modname = toupper (*modname); + *modname = TOUPPER (*modname); strncpy (nlm_variable_header (outbfd)->oldThreadName, " LONG", NLM_OLD_THREAD_NAME_LENGTH); + nlm_cygnus_ext_header (outbfd)->offset = secsec->filepos; + nlm_cygnus_ext_header (outbfd)->length = bfd_section_size (outbfd, secsec); + if (! bfd_close (outbfd)) bfd_fatal (output_file); if (! bfd_close (inbfd)) @@ -978,7 +1098,7 @@ main (argc, argv) static void show_help () { - printf ("%s: Convert an object file into a NetWare Loadable Module\n", + printf (_("%s: Convert an object file into a NetWare Loadable Module\n"), program_name); show_usage (stdout, 0); } @@ -990,13 +1110,15 @@ show_usage (file, status) FILE *file; int status; { - fprintf (file, "\ + fprintf (file, _("\ Usage: %s [-dhV] [-I bfdname] [-O bfdname] [-T header-file] [-l linker]\n\ [--input-target=bfdname] [--output-target=bfdname]\n\ [--header-file=file] [--linker=linker] [--debug]\n\ [--help] [--version]\n\ - [in-file [out-file]]\n", + [in-file [out-file]]\n"), program_name); + if (status == 0) + fprintf (file, _("Report bugs to %s\n"), REPORT_BUGS_TO); exit (status); } @@ -1007,22 +1129,29 @@ static const char * select_output_format (arch, mach, bigendian) enum bfd_architecture arch; unsigned long mach; - boolean bigendian; + boolean bigendian ATTRIBUTE_UNUSED; { switch (arch) { +#ifdef NLMCONV_I386 case bfd_arch_i386: return "nlm32-i386"; +#endif +#ifdef NLMCONV_SPARC case bfd_arch_sparc: return "nlm32-sparc"; +#endif +#ifdef NLMCONV_ALPHA case bfd_arch_alpha: return "nlm32-alpha"; +#endif +#ifdef NLMCONV_POWERPC + case bfd_arch_powerpc: + return "nlm32-powerpc"; +#endif 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; + fatal (_("support not compiled in for %s"), + bfd_printable_arch_mach (arch, mach)); } /*NOTREACHED*/ } @@ -1033,7 +1162,7 @@ select_output_format (arch, mach, bigendian) static void setup_sections (inbfd, insec, data_ptr) - bfd *inbfd; + bfd *inbfd ATTRIBUTE_UNUSED; asection *insec; PTR data_ptr; { @@ -1044,13 +1173,7 @@ setup_sections (inbfd, insec, data_ptr) bfd_vma offset; bfd_size_type align; bfd_size_type add; - - /* FIXME: We don't want to copy the .reginfo section of an ECOFF - file. However, I don't have a good way to describe this section. - We do want to copy the section when using objcopy. */ - if (bfd_get_flavour (inbfd) == bfd_target_ecoff_flavour - && strcmp (bfd_section_name (inbfd, insec), ".reginfo") == 0) - return; + bfd_size_type secsecsize; f = bfd_get_section_flags (inbfd, insec); if (f & SEC_CODE) @@ -1067,7 +1190,7 @@ setup_sections (inbfd, insec, data_ptr) { outsec = bfd_make_section (outbfd, outname); if (outsec == NULL) - bfd_fatal ("make section"); + bfd_fatal (_("make section")); } insec->output_section = outsec; @@ -1081,18 +1204,28 @@ setup_sections (inbfd, insec, data_ptr) (bfd_section_size (outbfd, outsec) + bfd_section_size (inbfd, insec) + add))) - bfd_fatal ("set section size"); + bfd_fatal (_("set section size")); if ((bfd_section_alignment (inbfd, insec) > bfd_section_alignment (outbfd, outsec)) && ! bfd_set_section_alignment (outbfd, outsec, bfd_section_alignment (inbfd, insec))) - bfd_fatal ("set section alignment"); + bfd_fatal (_("set section alignment")); - if (! bfd_set_section_flags (outbfd, outsec, f)) - bfd_fatal ("set section flags"); + if (! bfd_set_section_flags (outbfd, outsec, + f | bfd_get_section_flags (outbfd, outsec))) + bfd_fatal (_("set section flags")); bfd_set_reloc (outbfd, outsec, (arelent **) NULL, 0); + + /* For each input section we allocate space for an entry in + .nlmsections. */ + secsecsize = bfd_section_size (outbfd, secsec); + secsecsize += strlen (bfd_section_name (inbfd, insec)) + 1; + secsecsize = (secsecsize + 3) &~ 3; + secsecsize += 8; + if (! bfd_set_section_size (outbfd, secsec, secsecsize)) + bfd_fatal (_("set .nlmsections size")); } /* Copy the section contents. */ @@ -1103,25 +1236,22 @@ copy_sections (inbfd, insec, data_ptr) asection *insec; PTR data_ptr; { + static bfd_size_type secsecoff = 0; bfd *outbfd = (bfd *) data_ptr; + const char *inname; asection *outsec; bfd_size_type size; PTR contents; - bfd_size_type reloc_size; + long reloc_size; + bfd_byte buf[4]; + bfd_size_type add; - /* FIXME: We don't want to copy the .reginfo section of an ECOFF - file. However, I don't have a good way to describe this section. - We do want to copy the section when using objcopy. */ - if (bfd_get_flavour (inbfd) == bfd_target_ecoff_flavour - && strcmp (bfd_section_name (inbfd, insec), ".reginfo") == 0) - return; + inname = bfd_section_name (inbfd, insec); outsec = insec->output_section; 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; @@ -1138,13 +1268,17 @@ copy_sections (inbfd, insec, data_ptr) } reloc_size = bfd_get_reloc_upper_bound (inbfd, insec); + if (reloc_size < 0) + bfd_fatal (bfd_get_filename (inbfd)); if (reloc_size != 0) { arelent **relocs; - bfd_size_type reloc_count; + long reloc_count; relocs = (arelent **) xmalloc (reloc_size); reloc_count = bfd_canonicalize_reloc (inbfd, insec, relocs, symbols); + if (reloc_count < 0) + bfd_fatal (bfd_get_filename (inbfd)); mangle_relocs (outbfd, insec, &relocs, &reloc_count, (char *) contents, size); @@ -1155,11 +1289,11 @@ copy_sections (inbfd, insec, data_ptr) arelent **combined; total_count = reloc_count + outsec->reloc_count; - combined = (arelent **) xmalloc (total_count * sizeof (arelent)); + combined = (arelent **) xmalloc (total_count * sizeof (arelent *)); memcpy (combined, outsec->orelocation, - outsec->reloc_count * sizeof (arelent)); + outsec->reloc_count * sizeof (arelent *)); memcpy (combined + outsec->reloc_count, relocs, - (size_t) (reloc_count * sizeof (arelent))); + (size_t) (reloc_count * sizeof (arelent *))); free (outsec->orelocation); reloc_count = total_count; relocs = combined; @@ -1175,6 +1309,34 @@ copy_sections (inbfd, insec, data_ptr) bfd_fatal (bfd_get_filename (outbfd)); free (contents); } + + /* Add this section to .nlmsections. */ + if (! bfd_set_section_contents (outbfd, secsec, (PTR) inname, secsecoff, + strlen (inname) + 1)) + bfd_fatal (_("set .nlmsection contents")); + secsecoff += strlen (inname) + 1; + + add = ((secsecoff + 3) &~ 3) - secsecoff; + if (add != 0) + { + bfd_h_put_32 (outbfd, (bfd_vma) 0, buf); + if (! bfd_set_section_contents (outbfd, secsec, buf, secsecoff, add)) + bfd_fatal (_("set .nlmsection contents")); + secsecoff += add; + } + + if (contents != NULL) + bfd_h_put_32 (outbfd, (bfd_vma) outsec->filepos, buf); + else + bfd_h_put_32 (outbfd, (bfd_vma) 0, buf); + if (! bfd_set_section_contents (outbfd, secsec, buf, secsecoff, 4)) + bfd_fatal (_("set .nlmsection contents")); + secsecoff += 4; + + bfd_h_put_32 (outbfd, (bfd_vma) size, buf); + if (! bfd_set_section_contents (outbfd, secsec, buf, secsecoff, 4)) + bfd_fatal (_("set .nlmsection contents")); + secsecoff += 4; } /* Some, perhaps all, NetWare targets require changing the relocs used @@ -1186,20 +1348,30 @@ mangle_relocs (outbfd, insec, relocs_ptr, reloc_count_ptr, contents, bfd *outbfd; asection *insec; arelent ***relocs_ptr; - bfd_size_type *reloc_count_ptr; + long *reloc_count_ptr; char *contents; bfd_size_type contents_size; { switch (bfd_get_arch (outbfd)) { +#ifdef NLMCONV_I386 case bfd_arch_i386: i386_mangle_relocs (outbfd, insec, relocs_ptr, reloc_count_ptr, contents, contents_size); break; +#endif +#ifdef NLMCONV_ALPHA case bfd_arch_alpha: alpha_mangle_relocs (outbfd, insec, relocs_ptr, reloc_count_ptr, contents, contents_size); break; +#endif +#ifdef NLMCONV_POWERPC + case bfd_arch_powerpc: + powerpc_mangle_relocs (outbfd, insec, relocs_ptr, reloc_count_ptr, + contents, contents_size); + break; +#endif default: default_mangle_relocs (outbfd, insec, relocs_ptr, reloc_count_ptr, contents, contents_size); @@ -1214,18 +1386,18 @@ mangle_relocs (outbfd, insec, relocs_ptr, reloc_count_ptr, contents, static void default_mangle_relocs (outbfd, insec, relocs_ptr, reloc_count_ptr, contents, contents_size) - bfd *outbfd; + bfd *outbfd ATTRIBUTE_UNUSED; asection *insec; arelent ***relocs_ptr; - bfd_size_type *reloc_count_ptr; - char *contents; - bfd_size_type contents_size; + long *reloc_count_ptr; + char *contents ATTRIBUTE_UNUSED; + bfd_size_type contents_size ATTRIBUTE_UNUSED; { if (insec->output_offset != 0) { - bfd_size_type reloc_count; + long reloc_count; register arelent **relocs; - register bfd_size_type i; + register long i; reloc_count = *reloc_count_ptr; relocs = *relocs_ptr; @@ -1233,6 +1405,8 @@ default_mangle_relocs (outbfd, insec, relocs_ptr, reloc_count_ptr, contents, (*relocs)->address += insec->output_offset; } } + +#ifdef NLMCONV_I386 /* NetWare on the i386 supports a restricted set of relocs, which are different from those used on other i386 targets. This routine @@ -1261,11 +1435,11 @@ i386_mangle_relocs (outbfd, insec, relocs_ptr, reloc_count_ptr, contents, bfd *outbfd; asection *insec; arelent ***relocs_ptr; - bfd_size_type *reloc_count_ptr; + long *reloc_count_ptr; char *contents; bfd_size_type contents_size; { - bfd_size_type reloc_count, i; + long reloc_count, i; arelent **relocs; reloc_count = *reloc_count_ptr; @@ -1354,7 +1528,7 @@ i386_mangle_relocs (outbfd, insec, relocs_ptr, reloc_count_ptr, contents, /* Adjust the reloc for the changes we just made. */ rel->addend = 0; - if (bfd_get_section (sym) != &bfd_und_section) + if (! bfd_is_und_section (bfd_get_section (sym))) rel->sym_ptr_ptr = bfd_get_section (sym)->symbol_ptr_ptr; } @@ -1389,6 +1563,10 @@ i386_mangle_relocs (outbfd, insec, relocs_ptr, reloc_count_ptr, contents, } } +#endif /* NLMCONV_I386 */ + +#ifdef NLMCONV_ALPHA + /* On the Alpha the first reloc for every section must be a special relocs which hold the GP address. Also, the first reloc in the file must be a special reloc which holds the address of the .lita @@ -1416,11 +1594,11 @@ alpha_mangle_relocs (outbfd, insec, relocs_ptr, reloc_count_ptr, contents, bfd *outbfd; asection *insec; register arelent ***relocs_ptr; - bfd_size_type *reloc_count_ptr; - char *contents; - bfd_size_type contents_size; + long *reloc_count_ptr; + char *contents ATTRIBUTE_UNUSED; + bfd_size_type contents_size ATTRIBUTE_UNUSED; { - bfd_size_type old_reloc_count; + long old_reloc_count; arelent **old_relocs; register arelent **relocs; @@ -1450,7 +1628,7 @@ alpha_mangle_relocs (outbfd, insec, relocs_ptr, reloc_count_ptr, contents, } *relocs = (arelent *) xmalloc (sizeof (arelent)); - (*relocs)->sym_ptr_ptr = bfd_abs_section.symbol_ptr_ptr; + (*relocs)->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; (*relocs)->address = nlm_alpha_backend_data (outbfd)->lita_address; (*relocs)->addend = nlm_alpha_backend_data (outbfd)->lita_size + 1; (*relocs)->howto = &nlm32_alpha_nw_howto; @@ -1458,25 +1636,13 @@ alpha_mangle_relocs (outbfd, insec, relocs_ptr, reloc_count_ptr, contents, ++(*reloc_count_ptr); } - /* Get the GP value from bfd. It is in the .reginfo section. */ + /* Get the GP value from bfd. */ if (nlm_alpha_backend_data (outbfd)->gp == 0) - { - bfd *inbfd; - asection *reginfo_sec; - struct ecoff_reginfo sreginfo; - - inbfd = insec->owner; - assert (bfd_get_flavour (inbfd) == bfd_target_ecoff_flavour); - reginfo_sec = bfd_get_section_by_name (inbfd, REGINFO); - if (reginfo_sec != (asection *) NULL - && bfd_get_section_contents (inbfd, reginfo_sec, - (PTR) &sreginfo, (file_ptr) 0, - sizeof sreginfo) != false) - nlm_alpha_backend_data (outbfd)->gp = sreginfo.gp_value; - } + nlm_alpha_backend_data (outbfd)->gp = + bfd_ecoff_get_gp_value (insec->owner); *relocs = (arelent *) xmalloc (sizeof (arelent)); - (*relocs)->sym_ptr_ptr = bfd_abs_section.symbol_ptr_ptr; + (*relocs)->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; (*relocs)->address = nlm_alpha_backend_data (outbfd)->gp; (*relocs)->addend = 0; (*relocs)->howto = &nlm32_alpha_nw_howto; @@ -1493,19 +1659,435 @@ alpha_mangle_relocs (outbfd, insec, relocs_ptr, reloc_count_ptr, contents, { register bfd_size_type i; - for (i = 0; i < old_reloc_count; i++, relocs++) + for (i = 0; i < (bfd_size_type) old_reloc_count; i++, relocs++) (*relocs)->address += insec->output_offset; } } + +#endif /* NLMCONV_ALPHA */ + +#ifdef NLMCONV_POWERPC + +/* We keep a linked list of stubs which we must build. Because BFD + requires us to know the sizes of all sections before we can set the + contents of any, we must figure out which stubs we want to build + before we can actually build any of them. */ + +struct powerpc_stub +{ + /* Next stub in linked list. */ + struct powerpc_stub *next; + + /* Symbol whose value is the start of the stub. This is a symbol + whose name begins with `.'. */ + asymbol *start; + + /* Symbol we are going to create a reloc against. This is a symbol + with the same name as START but without the leading `.'. */ + asymbol *reloc; + + /* The TOC index for this stub. This is the index into the TOC + section at which the reloc is created. */ + unsigned int toc_index; +}; + +/* The linked list of stubs. */ + +static struct powerpc_stub *powerpc_stubs; + +/* This is what a stub looks like. The first instruction will get + adjusted with the correct TOC index. */ + +static unsigned long powerpc_stub_insns[] = +{ + 0x81820000, /* lwz r12,0(r2) */ + 0x90410014, /* stw r2,20(r1) */ + 0x800c0000, /* lwz r0,0(r12) */ + 0x804c0004, /* lwz r2,r(r12) */ + 0x7c0903a6, /* mtctr r0 */ + 0x4e800420, /* bctr */ + 0, /* Traceback table. */ + 0xc8000, + 0 +}; + +#define POWERPC_STUB_INSN_COUNT \ + (sizeof powerpc_stub_insns / sizeof powerpc_stub_insns[0]) + +#define POWERPC_STUB_SIZE (4 * POWERPC_STUB_INSN_COUNT) + +/* Each stub uses a four byte TOC entry. */ +#define POWERPC_STUB_TOC_ENTRY_SIZE (4) + +/* The original size of the .got section. */ +static bfd_size_type powerpc_initial_got_size; + +/* Look for all undefined symbols beginning with `.', and prepare to + build a stub for each one. */ + +static void +powerpc_build_stubs (inbfd, outbfd, symbols_ptr, symcount_ptr) + bfd *inbfd; + bfd *outbfd ATTRIBUTE_UNUSED; + asymbol ***symbols_ptr; + long *symcount_ptr; +{ + asection *stub_sec; + asection *got_sec; + unsigned int got_base; + long i; + long symcount; + long stubcount; + + /* Make a section to hold stubs. We don't set SEC_HAS_CONTENTS for + the section to prevent copy_sections from reading from it. */ + stub_sec = bfd_make_section (inbfd, ".stubs"); + if (stub_sec == (asection *) NULL + || ! bfd_set_section_flags (inbfd, stub_sec, + (SEC_CODE + | SEC_RELOC + | SEC_ALLOC + | SEC_LOAD)) + || ! bfd_set_section_alignment (inbfd, stub_sec, 2)) + bfd_fatal (".stubs"); + + /* Get the TOC section, which is named .got. */ + got_sec = bfd_get_section_by_name (inbfd, ".got"); + if (got_sec == (asection *) NULL) + { + got_sec = bfd_make_section (inbfd, ".got"); + if (got_sec == (asection *) NULL + || ! bfd_set_section_flags (inbfd, got_sec, + (SEC_DATA + | SEC_RELOC + | SEC_ALLOC + | SEC_LOAD + | SEC_HAS_CONTENTS)) + || ! bfd_set_section_alignment (inbfd, got_sec, 2)) + bfd_fatal (".got"); + } + + powerpc_initial_got_size = bfd_section_size (inbfd, got_sec); + got_base = powerpc_initial_got_size; + got_base = (got_base + 3) &~ 3; + + stubcount = 0; + + symcount = *symcount_ptr; + for (i = 0; i < symcount; i++) + { + asymbol *sym; + asymbol *newsym; + char *newname; + struct powerpc_stub *item; + + sym = (*symbols_ptr)[i]; + + /* We must make a stub for every undefined symbol whose name + starts with '.'. */ + if (bfd_asymbol_name (sym)[0] != '.' + || ! bfd_is_und_section (bfd_get_section (sym))) + continue; + + /* Make a new undefined symbol with the same name but without + the leading `.'. */ + newsym = (asymbol *) xmalloc (sizeof (asymbol)); + *newsym = *sym; + newname = (char *) xmalloc (strlen (bfd_asymbol_name (sym))); + strcpy (newname, bfd_asymbol_name (sym) + 1); + newsym->name = newname; + + /* Define the `.' symbol to be in the stub section. */ + sym->section = stub_sec; + sym->value = stubcount * POWERPC_STUB_SIZE; + /* We set the BSF_DYNAMIC flag here so that we can check it when + we are mangling relocs. FIXME: This is a hack. */ + sym->flags = BSF_LOCAL | BSF_DYNAMIC; + + /* Add this stub to the linked list. */ + item = (struct powerpc_stub *) xmalloc (sizeof (struct powerpc_stub)); + item->start = sym; + item->reloc = newsym; + item->toc_index = got_base + stubcount * POWERPC_STUB_TOC_ENTRY_SIZE; + + item->next = powerpc_stubs; + powerpc_stubs = item; + + ++stubcount; + } + + if (stubcount > 0) + { + asymbol **s; + struct powerpc_stub *l; + + /* Add the new symbols we just created to the symbol table. */ + *symbols_ptr = (asymbol **) xrealloc ((char *) *symbols_ptr, + ((symcount + stubcount) + * sizeof (asymbol))); + *symcount_ptr += stubcount; + s = &(*symbols_ptr)[symcount]; + for (l = powerpc_stubs; l != (struct powerpc_stub *) NULL; l = l->next) + *s++ = l->reloc; + + /* Set the size of the .stubs section and increase the size of + the .got section. */ + if (! bfd_set_section_size (inbfd, stub_sec, + stubcount * POWERPC_STUB_SIZE) + || ! bfd_set_section_size (inbfd, got_sec, + (got_base + + (stubcount + * POWERPC_STUB_TOC_ENTRY_SIZE)))) + bfd_fatal (_("stub section sizes")); + } +} + +/* Resolve all the stubs for PowerPC NetWare. We fill in the contents + of the output section, and create new relocs in the TOC. */ + +static void +powerpc_resolve_stubs (inbfd, outbfd) + bfd *inbfd; + bfd *outbfd; +{ + bfd_byte buf[POWERPC_STUB_SIZE]; + unsigned int i; + unsigned int stubcount; + arelent **relocs; + asection *got_sec; + arelent **r; + struct powerpc_stub *l; + + if (powerpc_stubs == (struct powerpc_stub *) NULL) + return; + + for (i = 0; i < POWERPC_STUB_INSN_COUNT; i++) + bfd_put_32 (outbfd, (bfd_vma) powerpc_stub_insns[i], buf + i * 4); + + got_sec = bfd_get_section_by_name (inbfd, ".got"); + assert (got_sec != (asection *) NULL); + assert (got_sec->output_section->orelocation == (arelent **) NULL); + + stubcount = 0; + for (l = powerpc_stubs; l != (struct powerpc_stub *) NULL; l = l->next) + ++stubcount; + relocs = (arelent **) xmalloc (stubcount * sizeof (arelent *)); + + r = relocs; + for (l = powerpc_stubs; l != (struct powerpc_stub *) NULL; l = l->next) + { + arelent *reloc; + + /* Adjust the first instruction to use the right TOC index. */ + bfd_put_32 (outbfd, (bfd_vma) powerpc_stub_insns[0] + l->toc_index, buf); + + /* Write this stub out. */ + if (! bfd_set_section_contents (outbfd, + bfd_get_section (l->start), + buf, + l->start->value, + POWERPC_STUB_SIZE)) + bfd_fatal (_("writing stub")); + + /* Create a new reloc for the TOC entry. */ + reloc = (arelent *) xmalloc (sizeof (arelent)); + reloc->sym_ptr_ptr = &l->reloc; + reloc->address = l->toc_index + got_sec->output_offset; + reloc->addend = 0; + reloc->howto = bfd_reloc_type_lookup (inbfd, BFD_RELOC_32); + + *r++ = reloc; + } + + bfd_set_reloc (outbfd, got_sec->output_section, relocs, stubcount); +} + +/* Adjust relocation entries for PowerPC NetWare. We do not output + TOC relocations. The object code already contains the offset from + the TOC pointer. When the function is called, the TOC register, + r2, will be set to the correct TOC value, so there is no need for + any further reloc. */ + +/*ARGSUSED*/ +static void +powerpc_mangle_relocs (outbfd, insec, relocs_ptr, reloc_count_ptr, contents, + contents_size) + bfd *outbfd; + asection *insec; + register arelent ***relocs_ptr; + long *reloc_count_ptr; + char *contents; + bfd_size_type contents_size ATTRIBUTE_UNUSED; +{ + reloc_howto_type *toc_howto; + long reloc_count; + register arelent **relocs; + register long i; + + toc_howto = bfd_reloc_type_lookup (insec->owner, BFD_RELOC_PPC_TOC16); + if (toc_howto == (reloc_howto_type *) NULL) + abort (); + + /* If this is the .got section, clear out all the contents beyond + the initial size. We must do this here because copy_sections is + going to write out whatever we return in the contents field. */ + if (strcmp (bfd_get_section_name (insec->owner, insec), ".got") == 0) + memset (contents + powerpc_initial_got_size, 0, + (size_t) (bfd_get_section_size_after_reloc (insec) + - powerpc_initial_got_size)); + + reloc_count = *reloc_count_ptr; + relocs = *relocs_ptr; + for (i = 0; i < reloc_count; i++) + { + arelent *rel; + asymbol *sym; + bfd_vma sym_value; + + rel = *relocs++; + sym = *rel->sym_ptr_ptr; + + /* Convert any relocs against the .bss section into relocs + against the .data section. */ + if (strcmp (bfd_get_section_name (outbfd, bfd_get_section (sym)), + NLM_UNINITIALIZED_DATA_NAME) == 0) + { + asection *datasec; + + datasec = bfd_get_section_by_name (outbfd, + NLM_INITIALIZED_DATA_NAME); + if (datasec != NULL) + { + rel->addend += (bfd_get_section_vma (outbfd, + bfd_get_section (sym)) + + sym->value); + rel->sym_ptr_ptr = datasec->symbol_ptr_ptr; + sym = *rel->sym_ptr_ptr; + } + } + + /* We must be able to resolve all PC relative relocs at this + point. If we get a branch to an undefined symbol we build a + stub, since NetWare will resolve undefined symbols into a + pointer to a function descriptor. */ + if (rel->howto->pc_relative) + { + /* This check for whether a symbol is in the same section as + the reloc will be wrong if there is a PC relative reloc + between two sections both of which were placed in the + same output section. This should not happen. */ + if (bfd_get_section (sym) != insec->output_section) + non_fatal (_("unresolved PC relative reloc against %s"), + bfd_asymbol_name (sym)); + else + { + bfd_vma val; + + assert (rel->howto->size == 2 && rel->howto->pcrel_offset); + val = bfd_get_32 (outbfd, (bfd_byte *) contents + rel->address); + val = ((val &~ rel->howto->dst_mask) + | (((val & rel->howto->src_mask) + + (sym->value - rel->address) + + rel->addend) + & rel->howto->dst_mask)); + bfd_put_32 (outbfd, val, (bfd_byte *) contents + rel->address); + + /* If this reloc is against an stubbed symbol and the + next instruction is + cror 31,31,31 + then we replace the next instruction with + lwz r2,20(r1) + This reloads the TOC pointer after a stub call. */ + if (bfd_asymbol_name (sym)[0] == '.' + && (sym->flags & BSF_DYNAMIC) != 0 + && (bfd_get_32 (outbfd, + (bfd_byte *) contents + rel->address + 4) + == 0x4ffffb82)) /* cror 31,31,31 */ + bfd_put_32 (outbfd, (bfd_vma) 0x80410014, /* lwz r2,20(r1) */ + (bfd_byte *) contents + rel->address + 4); + + --*reloc_count_ptr; + --relocs; + memmove (relocs, relocs + 1, + (size_t) ((reloc_count - 1) * sizeof (arelent *))); + continue; + } + } + + /* When considering a TOC reloc, we do not want to include the + symbol value. The symbol will be start of the TOC section + (which is named .got). We do want to include the addend. */ + if (rel->howto == toc_howto) + sym_value = 0; + else + sym_value = sym->value; + + /* If this is a relocation against a symbol with a value, or + there is a reloc addend, we need to update the addend in the + object file. */ + if (sym_value + rel->addend != 0) + { + bfd_vma val; + + switch (rel->howto->size) + { + case 1: + val = bfd_get_16 (outbfd, + (bfd_byte *) contents + rel->address); + val = ((val &~ rel->howto->dst_mask) + | (((val & rel->howto->src_mask) + + sym_value + + rel->addend) + & rel->howto->dst_mask)); + if ((bfd_signed_vma) val < - 0x8000 + || (bfd_signed_vma) val >= 0x8000) + non_fatal (_("overflow when adjusting relocation against %s"), + bfd_asymbol_name (sym)); + bfd_put_16 (outbfd, val, (bfd_byte *) contents + rel->address); + break; + + case 2: + val = bfd_get_32 (outbfd, + (bfd_byte *) contents + rel->address); + val = ((val &~ rel->howto->dst_mask) + | (((val & rel->howto->src_mask) + + sym_value + + rel->addend) + & rel->howto->dst_mask)); + bfd_put_32 (outbfd, val, (bfd_byte *) contents + rel->address); + break; + + default: + abort (); + } + + if (! bfd_is_und_section (bfd_get_section (sym))) + rel->sym_ptr_ptr = bfd_get_section (sym)->symbol_ptr_ptr; + rel->addend = 0; + } + + /* Now that we have incorporated the addend, remove any TOC + relocs. */ + if (rel->howto == toc_howto) + { + --*reloc_count_ptr; + --relocs; + memmove (relocs, relocs + 1, + (size_t) ((reloc_count - i) * sizeof (arelent *))); + continue; + } + + rel->address += insec->output_offset; + } +} + +#endif /* NLMCONV_POWERPC */ /* Name of linker. */ #ifndef LD_NAME #define LD_NAME "ld" #endif -/* Temporary file name base. */ -static char *temp_filename; - /* The user has specified several input files. Invoke the linker to link them all together, and convert and delete the resulting output file. */ @@ -1521,12 +2103,14 @@ link_inputs (inputs, ld) size_t i; int pid; int status; + char *errfmt; + char *errarg; c = 0; for (q = inputs; q != NULL; q = q->next) ++c; - argv = (char **) alloca (c + 5); + argv = (char **) alloca ((c + 5) * sizeof(char *)); #ifndef __MSDOS__ if (ld == NULL) @@ -1552,13 +2136,10 @@ link_inputs (inputs, ld) if (ld == NULL) ld = (char *) LD_NAME; - choose_temp_base (); - - unlink_on_exit = xmalloc (strlen (temp_filename) + 3); - sprintf (unlink_on_exit, "%s.O", temp_filename); + unlink_on_exit = make_temp_file (".O"); argv[0] = ld; - argv[1] = (char *) "-r"; + argv[1] = (char *) "-Ur"; argv[2] = (char *) "-o"; argv[3] = unlink_on_exit; i = 4; @@ -1573,180 +2154,29 @@ link_inputs (inputs, ld) fprintf (stderr, "\n"); } - pid = pexecute (ld, argv); - - if (waitpid (pid, &status, 0) < 0) + pid = pexecute (ld, argv, program_name, (char *) NULL, &errfmt, &errarg, + PEXECUTE_SEARCH | PEXECUTE_ONE); + if (pid == -1) { - perror ("waitpid"); + fprintf (stderr, _("%s: execution of %s failed: "), program_name, ld); + fprintf (stderr, errfmt, errarg); unlink (unlink_on_exit); exit (1); } - if (status != 0) + if (pwait (pid, &status, 0) < 0) { - fprintf (stderr, "%s: Execution of %s failed\n", program_name, ld); + perror ("pwait"); unlink (unlink_on_exit); exit (1); } - return unlink_on_exit; -} - -/* Choose a temporary file name. Stolen from gcc.c. */ - -static const char * -choose_temp_base_try (try, base) - const char *try; - const char *base; -{ - const char *rv; - - if (base) - rv = base; - else if (try == NULL) - rv = NULL; - else if (access (try, R_OK | W_OK) != 0) - rv = NULL; - else - rv = try; - return rv; -} - -static void -choose_temp_base () -{ - const char *base = NULL; - int len; - - base = choose_temp_base_try (getenv ("TMPDIR"), base); - base = choose_temp_base_try (getenv ("TMP"), base); - base = choose_temp_base_try (getenv ("TEMP"), base); - -#ifdef P_tmpdir - base = choose_temp_base_try (P_tmpdir, base); -#endif - - base = choose_temp_base_try ("/usr/tmp", base); - base = choose_temp_base_try ("/tmp", base); - - /* If all else fails, use the current directory! */ - if (base == NULL) - base = "./"; - - len = strlen (base); - temp_filename = xmalloc (len + sizeof("/ccXXXXXX") + 1); - strcpy (temp_filename, base); - if (len > 0 && temp_filename[len-1] != '/') - temp_filename[len++] = '/'; - strcpy (temp_filename + len, "ccXXXXXX"); - - mktemp (temp_filename); - if (*temp_filename == '\0') - abort (); -} - -/* Execute a job. Stolen from gcc.c. */ - -#ifndef OS2 -#ifdef __MSDOS__ - -static int -pexecute (program, argv) - char *program; - char *argv[]; -{ - char *scmd, *rf; - FILE *argfile; - int i; - - scmd = (char *)malloc (strlen (program) + strlen (temp_filename) + 10); - rf = scmd + strlen(program) + 2 + el; - sprintf (scmd, "%s.exe @%s.gp", program, temp_filename); - argfile = fopen (rf, "w"); - if (argfile == 0) - pfatal_with_name (rf); - - for (i=1; argv[i]; i++) - { - char *cp; - for (cp = argv[i]; *cp; cp++) - { - if (*cp == '"' || *cp == '\'' || *cp == '\\' || isspace (*cp)) - fputc ('\\', argfile); - fputc (*cp, argfile); - } - fputc ('\n', argfile); - } - fclose (argfile); - - i = system (scmd); - - remove (rf); - - if (i == -1) - { - perror (program); - return MIN_FATAL_STATUS << 8; - } - - return i << 8; -} - -#else /* not __MSDOS__ */ - -static int -pexecute (program, argv) - char *program; - char *argv[]; -{ - int pid; - int retries, sleep_interval; - - /* Fork a subprocess; wait and retry if it fails. */ - sleep_interval = 1; - for (retries = 0; retries < 4; retries++) - { - pid = vfork (); - if (pid >= 0) - break; - sleep (sleep_interval); - sleep_interval *= 2; - } - - switch (pid) + if (status != 0) { - case -1: -#ifdef vfork - perror ("fork"); -#else - perror ("vfork"); -#endif - exit (1); - /* NOTREACHED */ - return 0; - - case 0: /* child */ - /* Exec the program. */ - execvp (program, argv); - perror (program); + non_fatal (_("Execution of %s failed"), ld); + unlink (unlink_on_exit); exit (1); - /* NOTREACHED */ - return 0; - - default: - /* Return child's process number. */ - return pid; } -} - -#endif /* not __MSDOS__ */ -#else /* not OS2 */ -static int -pexecute (program, argv) - char *program; - char *argv[]; -{ - return spawnvp (1, program, argv); + return unlink_on_exit; } -#endif /* not OS2 */