1 /* nlmconv.c -- NLM conversion program
2 Copyright (C) 1993 Free Software Foundation, Inc.
4 This file is part of GNU Binutils.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
20 /* Written by Ian Lance Taylor <ian@cygnus.com>.
22 This program can be used to convert any appropriate object file
23 into a NetWare Loadable Module (an NLM). It will accept a linker
24 specification file which is identical to that accepted by the
25 NetWare linker, NLMLINK, except that the INPUT command, normally
26 used to give a list of object files to link together, is not used.
27 This program will convert only a single object file. */
33 #include <sys/types.h>
39 #include "libiberty.h"
42 /* Internal BFD NLM header. */
46 /* Needed for Alpha support. */
48 #include "coff/ecoff.h"
50 /* If strerror is just a macro, we want to use the one from libiberty
51 since it will handle undefined values. */
53 extern char *strerror ();
56 extern struct tm *localtime ();
60 extern char *getenv ();
73 /* Global variables. */
75 /* The name used to invoke the program. */
78 /* The version number. */
79 extern char *program_version;
81 /* Local variables. */
83 /* Whether to print out debugging information (currently just controls
84 whether it prints the linker command if there is one). */
87 /* The symbol table. */
88 static asymbol **symbols;
90 /* A section we create in the output file to hold pointers to where
91 the sections of the input file end up. We will put a pointer to
92 this section in the NLM header. These is an entry for each input
93 section. The format is
94 null terminated section name
95 zeroes to adjust to 4 byte boundary
96 4 byte section data file pointer
98 We don't need a version number. The way we find this information
99 is by finding a stamp in the NLM header information. If we need to
100 change the format of this information, we can simply change the
102 static asection *secsec;
104 /* A temporary file name to be unlinked on exit. Actually, for most
105 errors, we leave it around. It's not clear whether that is helpful
107 static char *unlink_on_exit;
109 /* The list of long options. */
110 static struct option long_options[] =
112 { "debug", no_argument, 0, 'd' },
113 { "header-file", required_argument, 0, 'T' },
114 { "help", no_argument, 0, 'h' },
115 { "input-target", required_argument, 0, 'I' },
116 { "input-format", required_argument, 0, 'I' }, /* Obsolete */
117 { "linker", required_argument, 0, 'l' },
118 { "output-target", required_argument, 0, 'O' },
119 { "output-format", required_argument, 0, 'O' }, /* Obsolete */
120 { "version", no_argument, 0, 'V' },
121 { NULL, no_argument, 0, 0 }
124 /* Local routines. */
126 static void show_help PARAMS ((void));
127 static void show_usage PARAMS ((FILE *, int));
128 static const char *select_output_format PARAMS ((enum bfd_architecture,
129 unsigned long, boolean));
130 static void setup_sections PARAMS ((bfd *, asection *, PTR));
131 static void copy_sections PARAMS ((bfd *, asection *, PTR));
132 static void mangle_relocs PARAMS ((bfd *, asection *, arelent ***,
135 static void i386_mangle_relocs PARAMS ((bfd *, asection *, arelent ***,
138 static void alpha_mangle_relocs PARAMS ((bfd *, asection *, arelent ***,
141 /* start-sanitize-powerpc-netware */
142 static void powerpc_build_stubs PARAMS ((bfd *, bfd *, asymbol ***, long *));
143 static void powerpc_resolve_stubs PARAMS ((bfd *, bfd *));
144 static void powerpc_mangle_relocs PARAMS ((bfd *, asection *, arelent ***,
147 /* end-sanitize-powerpc-netware */
148 static void default_mangle_relocs PARAMS ((bfd *, asection *, arelent ***,
151 static char *link_inputs PARAMS ((struct string_list *, char *));
152 static const char *choose_temp_base_try PARAMS ((const char *,
154 static void choose_temp_base PARAMS ((void));
155 static int pexecute PARAMS ((char *, char *[]));
157 /* The main routine. */
165 char *input_file = NULL;
166 const char *input_format = NULL;
167 const char *output_format = NULL;
168 const char *header_file = NULL;
170 Nlm_Internal_Fixed_Header fixed_hdr_struct;
171 Nlm_Internal_Variable_Header var_hdr_struct;
172 Nlm_Internal_Version_Header version_hdr_struct;
173 Nlm_Internal_Copyright_Header copyright_hdr_struct;
174 Nlm_Internal_Extended_Header extended_hdr_struct;
177 asymbol **newsyms, **outsyms;
178 long symcount, newsymalloc, newsymcount;
180 asection *text_sec, *bss_sec, *data_sec;
185 char inlead, outlead;
186 boolean gotstart, gotexit, gotcheck;
188 FILE *custom_data, *help_data, *message_data, *rpc_data, *shared_data;
189 size_t custom_size, help_size, message_size, module_size, rpc_size;
190 asection *custom_section, *help_section, *message_section, *module_section;
191 asection *rpc_section, *shared_section;
193 size_t shared_offset, shared_size;
194 Nlm_Internal_Fixed_Header sharedhdr;
199 program_name = argv[0];
200 xmalloc_set_program_name (program_name);
204 while ((opt = getopt_long (argc, argv, "dhI:l:O:T:V", long_options,
217 input_format = optarg;
223 output_format = optarg;
226 header_file = optarg;
229 printf ("GNU %s version %s\n", program_name, program_version);
235 show_usage (stderr, 1);
240 /* The input and output files may be named on the command line. */
244 input_file = argv[optind];
248 output_file = argv[optind];
251 show_usage (stderr, 1);
252 if (strcmp (input_file, output_file) == 0)
255 "%s: input and output files must be different\n",
262 /* Initialize the header information to default values. */
263 fixed_hdr = &fixed_hdr_struct;
264 memset ((PTR) &fixed_hdr_struct, 0, sizeof fixed_hdr_struct);
265 var_hdr = &var_hdr_struct;
266 memset ((PTR) &var_hdr_struct, 0, sizeof var_hdr_struct);
267 version_hdr = &version_hdr_struct;
268 memset ((PTR) &version_hdr_struct, 0, sizeof version_hdr_struct);
269 copyright_hdr = ©right_hdr_struct;
270 memset ((PTR) ©right_hdr_struct, 0, sizeof copyright_hdr_struct);
271 extended_hdr = &extended_hdr_struct;
272 memset ((PTR) &extended_hdr_struct, 0, sizeof extended_hdr_struct);
273 check_procedure = NULL;
276 exit_procedure = "_Stop";
277 export_symbols = NULL;
281 import_symbols = NULL;
284 sharelib_file = NULL;
285 start_procedure = "_Prelude";
291 /* Parse the header file (if there is one). */
292 if (header_file != NULL)
294 if (! nlmlex_file (header_file)
296 || parse_errors != 0)
300 if (input_files != NULL)
302 if (input_file != NULL)
305 "%s: input file named both on command line and with INPUT\n",
309 if (input_files->next == NULL)
310 input_file = input_files->string;
312 input_file = link_inputs (input_files, ld_arg);
314 else if (input_file == NULL)
316 fprintf (stderr, "%s: no input file\n", program_name);
317 show_usage (stderr, 1);
320 inbfd = bfd_openr (input_file, input_format);
322 bfd_fatal (input_file);
324 if (! bfd_check_format_matches (inbfd, bfd_object, &matching))
326 bfd_nonfatal (input_file);
327 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
329 list_matching_formats (matching);
335 if (output_format == NULL)
336 output_format = select_output_format (bfd_get_arch (inbfd),
337 bfd_get_mach (inbfd),
338 inbfd->xvec->byteorder_big_p);
340 assert (output_format != NULL);
342 /* Use the output file named on the command line if it exists.
343 Otherwise use the file named in the OUTPUT statement. */
344 if (output_file == NULL)
346 fprintf (stderr, "%s: no name for output file\n",
348 show_usage (stderr, 1);
351 outbfd = bfd_openw (output_file, output_format);
353 bfd_fatal (output_file);
354 if (! bfd_set_format (outbfd, bfd_object))
355 bfd_fatal (output_file);
357 assert (bfd_get_flavour (outbfd) == bfd_target_nlm_flavour);
359 if (bfd_arch_get_compatible (inbfd, outbfd) == NULL)
361 "%s: warning:input and output formats are not compatible\n",
364 /* Move the values read from the command file into outbfd. */
365 *nlm_fixed_header (outbfd) = fixed_hdr_struct;
366 *nlm_variable_header (outbfd) = var_hdr_struct;
367 *nlm_version_header (outbfd) = version_hdr_struct;
368 *nlm_copyright_header (outbfd) = copyright_hdr_struct;
369 *nlm_extended_header (outbfd) = extended_hdr_struct;
371 /* Start copying the input BFD to the output BFD. */
372 if (! bfd_set_file_flags (outbfd, bfd_get_file_flags (inbfd)))
373 bfd_fatal (bfd_get_filename (outbfd));
375 symsize = bfd_get_symtab_upper_bound (inbfd);
377 bfd_fatal (input_file);
378 symbols = (asymbol **) xmalloc (symsize);
379 symcount = bfd_canonicalize_symtab (inbfd, symbols);
381 bfd_fatal (input_file);
383 /* Make sure we have a .bss section. */
384 bss_sec = bfd_get_section_by_name (outbfd, NLM_UNINITIALIZED_DATA_NAME);
387 bss_sec = bfd_make_section (outbfd, NLM_UNINITIALIZED_DATA_NAME);
389 || ! bfd_set_section_flags (outbfd, bss_sec, SEC_ALLOC)
390 || ! bfd_set_section_alignment (outbfd, bss_sec, 1))
391 bfd_fatal ("make .bss section");
394 /* We store the original section names in the .nlmsections section,
395 so that programs which understand it can resurrect the original
396 sections from the NLM. We will put a pointer to .nlmsections in
397 the NLM header area. */
398 secsec = bfd_make_section (outbfd, ".nlmsections");
400 bfd_fatal ("make .nlmsections section");
401 if (! bfd_set_section_flags (outbfd, secsec, SEC_HAS_CONTENTS))
402 bfd_fatal ("set .nlmsections flags");
403 /* start-sanitize-powerpc-netware */
405 /* For PowerPC NetWare we need to build stubs for calls to undefined
406 symbols. Because each stub requires an entry in the TOC section
407 which must be at the same location as other entries in the TOC
408 section, we must do this before determining where the TOC section
409 goes in setup_sections. */
410 if (bfd_get_arch (inbfd) == bfd_arch_powerpc)
411 powerpc_build_stubs (inbfd, outbfd, &symbols, &symcount);
412 /* end-sanitize-powerpc-netware */
414 /* Set up the sections. */
415 bfd_map_over_sections (inbfd, setup_sections, (PTR) outbfd);
417 text_sec = bfd_get_section_by_name (outbfd, NLM_CODE_NAME);
419 /* The .bss section immediately follows the .data section. */
420 data_sec = bfd_get_section_by_name (outbfd, NLM_INITIALIZED_DATA_NAME);
421 if (data_sec != NULL)
425 vma = bfd_get_section_size_before_reloc (data_sec);
426 align = 1 << bss_sec->alignment_power;
427 add = ((vma + align - 1) &~ (align - 1)) - vma;
429 if (! bfd_set_section_vma (outbfd, bss_sec, vma))
430 bfd_fatal ("set .bss vma");
433 bfd_size_type data_size;
435 data_size = bfd_get_section_size_before_reloc (data_sec);
436 if (! bfd_set_section_size (outbfd, data_sec, data_size + add))
437 bfd_fatal ("set .data size");
441 /* Adjust symbol information. */
442 inlead = bfd_get_symbol_leading_char (inbfd);
443 outlead = bfd_get_symbol_leading_char (outbfd);
448 newsyms = (asymbol **) xmalloc (newsymalloc * sizeof (asymbol *));
451 for (i = 0; i < symcount; i++)
453 register asymbol *sym;
457 /* Add or remove a leading underscore. */
458 if (inlead != outlead)
462 if (bfd_asymbol_name (sym)[0] == inlead)
470 new = xmalloc (strlen (bfd_asymbol_name (sym)) + 1);
472 strcpy (new + 1, bfd_asymbol_name (sym) + 1);
481 new = xmalloc (strlen (bfd_asymbol_name (sym)) + 2);
483 strcpy (new + 1, bfd_asymbol_name (sym));
488 /* NLM's have an uninitialized data section, but they do not
489 have a common section in the Unix sense. Move all common
490 symbols into the .bss section, and mark them as exported. */
491 if (bfd_is_com_section (bfd_get_section (sym)))
495 sym->section = bss_sec;
497 sym->value = bss_sec->_raw_size;
498 bss_sec->_raw_size += size;
499 align = 1 << bss_sec->alignment_power;
500 bss_sec->_raw_size = (bss_sec->_raw_size + align - 1) &~ (align - 1);
501 sym->flags |= BSF_EXPORT | BSF_GLOBAL;
503 else if (bfd_get_section (sym)->output_section != NULL)
505 /* Move the symbol into the output section. */
506 sym->value += bfd_get_section (sym)->output_offset;
507 sym->section = bfd_get_section (sym)->output_section;
508 /* This is no longer a section symbol. */
509 sym->flags &=~ BSF_SECTION_SYM;
512 /* Force _edata and _end to be defined. This would normally be
513 done by the linker, but the manipulation of the common
514 symbols will confuse it. */
515 if ((sym->flags & BSF_DEBUGGING) == 0
516 && bfd_asymbol_name (sym)[0] == '_'
517 && bfd_get_section (sym) == &bfd_und_section)
519 if (strcmp (bfd_asymbol_name (sym), "_edata") == 0)
521 sym->section = bss_sec;
524 if (strcmp (bfd_asymbol_name (sym), "_end") == 0)
526 sym->section = bss_sec;
529 /* start-sanitize-powerpc-netware */
530 /* For PowerPC NetWare, we define __GOT0. This is the start
531 of the .got section. */
532 if (bfd_get_arch (inbfd) == bfd_arch_powerpc
533 && strcmp (bfd_asymbol_name (sym), "__GOT0") == 0)
537 got_sec = bfd_get_section_by_name (inbfd, ".got");
538 assert (got_sec != (asection *) NULL);
539 sym->value = got_sec->output_offset;
540 sym->section = got_sec->output_section;
542 /* end-sanitize-powerpc-netware */
545 /* If this is a global symbol, check the export list. */
546 if ((sym->flags & (BSF_EXPORT | BSF_GLOBAL)) != 0)
548 register struct string_list *l;
551 /* Unfortunately, a symbol can appear multiple times on the
552 export list, with and without prefixes. */
554 for (l = export_symbols; l != NULL; l = l->next)
556 if (strcmp (l->string, bfd_asymbol_name (sym)) == 0)
562 zbase = strchr (l->string, '@');
564 && strcmp (zbase + 1, bfd_asymbol_name (sym)) == 0)
566 /* We must add a symbol with this prefix. */
567 if (newsymcount >= newsymalloc)
570 newsyms = ((asymbol **)
571 xrealloc ((PTR) newsyms,
573 * sizeof (asymbol *))));
575 newsyms[newsymcount] =
576 (asymbol *) xmalloc (sizeof (asymbol));
577 *newsyms[newsymcount] = *sym;
578 newsyms[newsymcount]->name = l->string;
585 /* The unmodified symbol is actually not exported at
587 sym->flags &=~ (BSF_GLOBAL | BSF_EXPORT);
588 sym->flags |= BSF_LOCAL;
592 /* If it's an undefined symbol, see if it's on the import list.
593 Change the prefix if necessary. */
594 if (bfd_get_section (sym) == &bfd_und_section)
596 register struct string_list *l;
598 for (l = import_symbols; l != NULL; l = l->next)
600 if (strcmp (l->string, bfd_asymbol_name (sym)) == 0)
606 zbase = strchr (l->string, '@');
608 && strcmp (zbase + 1, bfd_asymbol_name (sym)) == 0)
610 sym->name = l->string;
617 "%s: warning: symbol %s imported but not in import list\n",
618 program_name, bfd_asymbol_name (sym));
621 /* See if it's one of the special named symbols. */
622 if ((sym->flags & BSF_DEBUGGING) == 0)
626 /* FIXME: If these symbols are not in the .text section, we
627 add the .text section size to the value. This may not be
628 correct for all targets. I'm not sure how this should
629 really be handled. */
630 if (strcmp (bfd_asymbol_name (sym), start_procedure) == 0)
632 val = bfd_asymbol_value (sym);
633 if (bfd_get_section (sym) == data_sec
634 && text_sec != (asection *) NULL)
635 val += bfd_section_size (outbfd, text_sec);
636 if (! bfd_set_start_address (outbfd, val))
637 bfd_fatal ("set start address");
640 if (strcmp (bfd_asymbol_name (sym), exit_procedure) == 0)
642 val = bfd_asymbol_value (sym);
643 if (bfd_get_section (sym) == data_sec
644 && text_sec != (asection *) NULL)
645 val += bfd_section_size (outbfd, text_sec);
646 nlm_fixed_header (outbfd)->exitProcedureOffset = val;
649 if (check_procedure != NULL
650 && strcmp (bfd_asymbol_name (sym), check_procedure) == 0)
652 val = bfd_asymbol_value (sym);
653 if (bfd_get_section (sym) == data_sec
654 && text_sec != (asection *) NULL)
655 val += bfd_section_size (outbfd, text_sec);
656 nlm_fixed_header (outbfd)->checkUnloadProcedureOffset = val;
664 endsym->value = bfd_get_section_size_before_reloc (bss_sec);
666 /* FIXME: If any relocs referring to _end use inplace addends,
667 then I think they need to be updated. This is handled by
668 i386_mangle_relocs. Is it needed for any other object
672 if (newsymcount == 0)
676 outsyms = (asymbol **) xmalloc ((symcount + newsymcount + 1)
677 * sizeof (asymbol *));
678 memcpy (outsyms, symbols, symcount * sizeof (asymbol *));
679 memcpy (outsyms + symcount, newsyms, newsymcount * sizeof (asymbol *));
680 outsyms[symcount + newsymcount] = NULL;
683 bfd_set_symtab (outbfd, outsyms, symcount + newsymcount);
686 fprintf (stderr, "%s: warning: START procedure %s not defined\n",
687 program_name, start_procedure);
689 fprintf (stderr, "%s: warning: EXIT procedure %s not defined\n",
690 program_name, exit_procedure);
691 if (check_procedure != NULL
693 fprintf (stderr, "%s: warning: CHECK procedure %s not defined\n",
694 program_name, check_procedure);
696 /* Add additional sections required for the header information. */
697 if (custom_file != NULL)
699 custom_data = fopen (custom_file, "r");
700 if (custom_data == NULL
701 || fstat (fileno (custom_data), &st) < 0)
703 fprintf (stderr, "%s:%s: %s\n", program_name, custom_file,
709 custom_size = st.st_size;
710 custom_section = bfd_make_section (outbfd, ".nlmcustom");
711 if (custom_section == NULL
712 || ! bfd_set_section_size (outbfd, custom_section, custom_size)
713 || ! bfd_set_section_flags (outbfd, custom_section,
715 bfd_fatal ("custom section");
718 if (help_file != NULL)
720 help_data = fopen (help_file, "r");
721 if (help_data == NULL
722 || fstat (fileno (help_data), &st) < 0)
724 fprintf (stderr, "%s:%s: %s\n", program_name, help_file,
730 help_size = st.st_size;
731 help_section = bfd_make_section (outbfd, ".nlmhelp");
732 if (help_section == NULL
733 || ! bfd_set_section_size (outbfd, help_section, help_size)
734 || ! bfd_set_section_flags (outbfd, help_section,
736 bfd_fatal ("help section");
737 strncpy (nlm_extended_header (outbfd)->stamp, "MeSsAgEs", 8);
740 if (message_file != NULL)
742 message_data = fopen (message_file, "r");
743 if (message_data == NULL
744 || fstat (fileno (message_data), &st) < 0)
746 fprintf (stderr, "%s:%s: %s\n", program_name, message_file,
752 message_size = st.st_size;
753 message_section = bfd_make_section (outbfd, ".nlmmessages");
754 if (message_section == NULL
755 || ! bfd_set_section_size (outbfd, message_section, message_size)
756 || ! bfd_set_section_flags (outbfd, message_section,
758 bfd_fatal ("message section");
759 strncpy (nlm_extended_header (outbfd)->stamp, "MeSsAgEs", 8);
764 struct string_list *l;
767 for (l = modules; l != NULL; l = l->next)
768 module_size += strlen (l->string) + 1;
769 module_section = bfd_make_section (outbfd, ".nlmmodules");
770 if (module_section == NULL
771 || ! bfd_set_section_size (outbfd, module_section, module_size)
772 || ! bfd_set_section_flags (outbfd, module_section,
774 bfd_fatal ("module section");
776 if (rpc_file != NULL)
778 rpc_data = fopen (rpc_file, "r");
780 || fstat (fileno (rpc_data), &st) < 0)
782 fprintf (stderr, "%s:%s: %s\n", program_name, rpc_file,
788 rpc_size = st.st_size;
789 rpc_section = bfd_make_section (outbfd, ".nlmrpc");
790 if (rpc_section == NULL
791 || ! bfd_set_section_size (outbfd, rpc_section, rpc_size)
792 || ! bfd_set_section_flags (outbfd, rpc_section,
794 bfd_fatal ("rpc section");
795 strncpy (nlm_extended_header (outbfd)->stamp, "MeSsAgEs", 8);
798 if (sharelib_file != NULL)
800 sharedbfd = bfd_openr (sharelib_file, output_format);
801 if (sharedbfd == NULL
802 || ! bfd_check_format (sharedbfd, bfd_object))
804 fprintf (stderr, "%s:%s: %s\n", program_name, sharelib_file,
805 bfd_errmsg (bfd_get_error ()));
806 sharelib_file = NULL;
810 sharedhdr = *nlm_fixed_header (sharedbfd);
811 bfd_close (sharedbfd);
812 shared_data = fopen (sharelib_file, "r");
813 if (shared_data == NULL
814 || (fstat (fileno (shared_data), &st) < 0))
816 fprintf (stderr, "%s:%s: %s\n", program_name, sharelib_file,
818 sharelib_file = NULL;
822 /* If we were clever, we could just copy out the
823 sections of the shared library which we actually
824 need. However, we would have to figure out the sizes
825 of the external and public information, and that can
826 not be done without reading through them. */
827 if (sharedhdr.uninitializedDataSize > 0)
829 /* There is no place to record this information. */
831 "%s:%s: warning: shared libraries can not have uninitialized data\n",
832 program_name, sharelib_file);
834 shared_offset = st.st_size;
835 if (shared_offset > sharedhdr.codeImageOffset)
836 shared_offset = sharedhdr.codeImageOffset;
837 if (shared_offset > sharedhdr.dataImageOffset)
838 shared_offset = sharedhdr.dataImageOffset;
839 if (shared_offset > sharedhdr.relocationFixupOffset)
840 shared_offset = sharedhdr.relocationFixupOffset;
841 if (shared_offset > sharedhdr.externalReferencesOffset)
842 shared_offset = sharedhdr.externalReferencesOffset;
843 if (shared_offset > sharedhdr.publicsOffset)
844 shared_offset = sharedhdr.publicsOffset;
845 shared_size = st.st_size - shared_offset;
846 shared_section = bfd_make_section (outbfd, ".nlmshared");
847 if (shared_section == NULL
848 || ! bfd_set_section_size (outbfd, shared_section,
850 || ! bfd_set_section_flags (outbfd, shared_section,
852 bfd_fatal ("shared section");
853 strncpy (nlm_extended_header (outbfd)->stamp, "MeSsAgEs", 8);
858 /* Check whether a version was given. */
859 if (strncmp (version_hdr->stamp, "VeRsIoN#", 8) != 0)
860 fprintf (stderr, "%s: warning: No version number given\n",
863 /* At least for now, always create an extended header, because that
864 is what NLMLINK does. */
865 strncpy (nlm_extended_header (outbfd)->stamp, "MeSsAgEs", 8);
867 strncpy (nlm_cygnus_ext_header (outbfd)->stamp, "CyGnUsEx", 8);
869 /* If the date was not given, force it in. */
870 if (nlm_version_header (outbfd)->month == 0
871 && nlm_version_header (outbfd)->day == 0
872 && nlm_version_header (outbfd)->year == 0)
878 ptm = localtime (&now);
879 nlm_version_header (outbfd)->month = ptm->tm_mon + 1;
880 nlm_version_header (outbfd)->day = ptm->tm_mday;
881 nlm_version_header (outbfd)->year = ptm->tm_year + 1900;
882 strncpy (version_hdr->stamp, "VeRsIoN#", 8);
884 /* start-sanitize-powerpc-netware */
886 /* Resolve the stubs we build for PowerPC NetWare. */
887 if (bfd_get_arch (inbfd) == bfd_arch_powerpc)
888 powerpc_resolve_stubs (inbfd, outbfd);
889 /* end-sanitize-powerpc-netware */
891 /* Copy over the sections. */
892 bfd_map_over_sections (inbfd, copy_sections, (PTR) outbfd);
894 /* Finish up the header information. */
895 if (custom_file != NULL)
899 data = xmalloc (custom_size);
900 if (fread (data, 1, custom_size, custom_data) != custom_size)
901 fprintf (stderr, "%s:%s: read: %s\n", program_name, custom_file,
905 if (! bfd_set_section_contents (outbfd, custom_section, data,
906 (file_ptr) 0, custom_size))
907 bfd_fatal ("custom section");
908 nlm_fixed_header (outbfd)->customDataOffset =
909 custom_section->filepos;
910 nlm_fixed_header (outbfd)->customDataSize = custom_size;
916 /* As a special hack, the backend recognizes a debugInfoOffset
917 of -1 to mean that it should not output any debugging
918 information. This can not be handling by fiddling with the
919 symbol table because exported symbols appear in both the
920 export information and the debugging information. */
921 nlm_fixed_header (outbfd)->debugInfoOffset = (file_ptr) -1;
923 if (map_file != NULL)
925 "%s: warning: MAP and FULLMAP are not supported; try ld -M\n",
927 if (help_file != NULL)
931 data = xmalloc (help_size);
932 if (fread (data, 1, help_size, help_data) != help_size)
933 fprintf (stderr, "%s:%s: read: %s\n", program_name, help_file,
937 if (! bfd_set_section_contents (outbfd, help_section, data,
938 (file_ptr) 0, help_size))
939 bfd_fatal ("help section");
940 nlm_extended_header (outbfd)->helpFileOffset =
941 help_section->filepos;
942 nlm_extended_header (outbfd)->helpFileLength = help_size;
946 if (message_file != NULL)
950 data = xmalloc (message_size);
951 if (fread (data, 1, message_size, message_data) != message_size)
952 fprintf (stderr, "%s:%s: read: %s\n", program_name, message_file,
956 if (! bfd_set_section_contents (outbfd, message_section, data,
957 (file_ptr) 0, message_size))
958 bfd_fatal ("message section");
959 nlm_extended_header (outbfd)->messageFileOffset =
960 message_section->filepos;
961 nlm_extended_header (outbfd)->messageFileLength = message_size;
963 /* FIXME: Are these offsets correct on all platforms? Are
964 they 32 bits on all platforms? What endianness? */
965 nlm_extended_header (outbfd)->languageID =
966 bfd_h_get_32 (outbfd, (bfd_byte *) data + 106);
967 nlm_extended_header (outbfd)->messageCount =
968 bfd_h_get_32 (outbfd, (bfd_byte *) data + 110);
976 struct string_list *l;
979 data = xmalloc (module_size);
981 set = (unsigned char *) data;
982 for (l = modules; l != NULL; l = l->next)
984 *set = strlen (l->string);
985 strncpy (set + 1, l->string, *set);
989 if (! bfd_set_section_contents (outbfd, module_section, data,
990 (file_ptr) 0, module_size))
991 bfd_fatal ("module section");
992 nlm_fixed_header (outbfd)->moduleDependencyOffset =
993 module_section->filepos;
994 nlm_fixed_header (outbfd)->numberOfModuleDependencies = c;
996 if (rpc_file != NULL)
1000 data = xmalloc (rpc_size);
1001 if (fread (data, 1, rpc_size, rpc_data) != rpc_size)
1002 fprintf (stderr, "%s:%s: read: %s\n", program_name, rpc_file,
1006 if (! bfd_set_section_contents (outbfd, rpc_section, data,
1007 (file_ptr) 0, rpc_size))
1008 bfd_fatal ("rpc section");
1009 nlm_extended_header (outbfd)->RPCDataOffset =
1010 rpc_section->filepos;
1011 nlm_extended_header (outbfd)->RPCDataLength = rpc_size;
1015 if (sharelib_file != NULL)
1019 data = xmalloc (shared_size);
1020 if (fseek (shared_data, shared_offset, SEEK_SET) != 0
1021 || fread (data, 1, shared_size, shared_data) != shared_size)
1022 fprintf (stderr, "%s:%s: read: %s\n", program_name, sharelib_file,
1026 if (! bfd_set_section_contents (outbfd, shared_section, data,
1027 (file_ptr) 0, shared_size))
1028 bfd_fatal ("shared section");
1030 nlm_extended_header (outbfd)->sharedCodeOffset =
1031 sharedhdr.codeImageOffset - shared_offset + shared_section->filepos;
1032 nlm_extended_header (outbfd)->sharedCodeLength =
1033 sharedhdr.codeImageSize;
1034 nlm_extended_header (outbfd)->sharedDataOffset =
1035 sharedhdr.dataImageOffset - shared_offset + shared_section->filepos;
1036 nlm_extended_header (outbfd)->sharedDataLength =
1037 sharedhdr.dataImageSize;
1038 nlm_extended_header (outbfd)->sharedRelocationFixupOffset =
1039 (sharedhdr.relocationFixupOffset
1041 + shared_section->filepos);
1042 nlm_extended_header (outbfd)->sharedRelocationFixupCount =
1043 sharedhdr.numberOfRelocationFixups;
1044 nlm_extended_header (outbfd)->sharedExternalReferenceOffset =
1045 (sharedhdr.externalReferencesOffset
1047 + shared_section->filepos);
1048 nlm_extended_header (outbfd)->sharedExternalReferenceCount =
1049 sharedhdr.numberOfExternalReferences;
1050 nlm_extended_header (outbfd)->sharedPublicsOffset =
1051 sharedhdr.publicsOffset - shared_offset + shared_section->filepos;
1052 nlm_extended_header (outbfd)->sharedPublicsCount =
1053 sharedhdr.numberOfPublics;
1054 nlm_extended_header (outbfd)->sharedDebugRecordOffset =
1055 sharedhdr.debugInfoOffset - shared_offset + shared_section->filepos;
1056 nlm_extended_header (outbfd)->sharedDebugRecordCount =
1057 sharedhdr.numberOfDebugRecords;
1058 nlm_extended_header (outbfd)->SharedInitializationOffset =
1059 sharedhdr.codeStartOffset;
1060 nlm_extended_header (outbfd)->SharedExitProcedureOffset =
1061 sharedhdr.exitProcedureOffset;
1064 len = strlen (output_file);
1065 if (len > NLM_MODULE_NAME_SIZE - 2)
1066 len = NLM_MODULE_NAME_SIZE - 2;
1067 nlm_fixed_header (outbfd)->moduleName[0] = len;
1069 strncpy (nlm_fixed_header (outbfd)->moduleName + 1, output_file,
1070 NLM_MODULE_NAME_SIZE - 2);
1071 nlm_fixed_header (outbfd)->moduleName[NLM_MODULE_NAME_SIZE - 1] = '\0';
1072 for (modname = nlm_fixed_header (outbfd)->moduleName;
1075 if (islower (*modname))
1076 *modname = toupper (*modname);
1078 strncpy (nlm_variable_header (outbfd)->oldThreadName, " LONG",
1079 NLM_OLD_THREAD_NAME_LENGTH);
1081 nlm_cygnus_ext_header (outbfd)->offset = secsec->filepos;
1082 nlm_cygnus_ext_header (outbfd)->length = bfd_section_size (outbfd, secsec);
1084 if (! bfd_close (outbfd))
1085 bfd_fatal (output_file);
1086 if (! bfd_close (inbfd))
1087 bfd_fatal (input_file);
1089 if (unlink_on_exit != NULL)
1090 unlink (unlink_on_exit);
1095 /* Display a help message and exit. */
1100 printf ("%s: Convert an object file into a NetWare Loadable Module\n",
1102 show_usage (stdout, 0);
1105 /* Show a usage message and exit. */
1108 show_usage (file, status)
1113 Usage: %s [-dhV] [-I bfdname] [-O bfdname] [-T header-file] [-l linker]\n\
1114 [--input-target=bfdname] [--output-target=bfdname]\n\
1115 [--header-file=file] [--linker=linker] [--debug]\n\
1116 [--help] [--version]\n\
1117 [in-file [out-file]]\n",
1122 /* Select the output format based on the input architecture, machine,
1123 and endianness. This chooses the appropriate NLM target. */
1126 select_output_format (arch, mach, bigendian)
1127 enum bfd_architecture arch;
1134 return "nlm32-i386";
1135 case bfd_arch_sparc:
1136 return "nlm32-sparc";
1137 case bfd_arch_alpha:
1138 return "nlm32-alpha";
1139 /* start-sanitize-powerpc-netware */
1140 case bfd_arch_powerpc:
1141 return "nlm32-powerpc";
1142 /* end-sanitize-powerpc-netware */
1144 fprintf (stderr, "%s: no default NLM format for %s\n",
1145 program_name, bfd_printable_arch_mach (arch, mach));
1147 /* Avoid warning. */
1153 /* The BFD sections are copied in two passes. This function selects
1154 the output section for each input section, and sets up the section
1158 setup_sections (inbfd, insec, data_ptr)
1163 bfd *outbfd = (bfd *) data_ptr;
1165 const char *outname;
1168 bfd_size_type align;
1170 bfd_size_type secsecsize;
1172 /* FIXME: We don't want to copy the .reginfo section of an ECOFF
1173 file. However, I don't have a good way to describe this section.
1174 We do want to copy the section when using objcopy. */
1175 if (bfd_get_flavour (inbfd) == bfd_target_ecoff_flavour
1176 && strcmp (bfd_section_name (inbfd, insec), ".reginfo") == 0)
1179 f = bfd_get_section_flags (inbfd, insec);
1181 outname = NLM_CODE_NAME;
1182 else if ((f & SEC_LOAD) && (f & SEC_HAS_CONTENTS))
1183 outname = NLM_INITIALIZED_DATA_NAME;
1184 else if (f & SEC_ALLOC)
1185 outname = NLM_UNINITIALIZED_DATA_NAME;
1187 outname = bfd_section_name (inbfd, insec);
1189 outsec = bfd_get_section_by_name (outbfd, outname);
1192 outsec = bfd_make_section (outbfd, outname);
1194 bfd_fatal ("make section");
1197 insec->output_section = outsec;
1199 offset = bfd_section_size (outbfd, outsec);
1200 align = 1 << bfd_section_alignment (inbfd, insec);
1201 add = ((offset + align - 1) &~ (align - 1)) - offset;
1202 insec->output_offset = offset + add;
1204 if (! bfd_set_section_size (outbfd, outsec,
1205 (bfd_section_size (outbfd, outsec)
1206 + bfd_section_size (inbfd, insec)
1208 bfd_fatal ("set section size");
1210 if ((bfd_section_alignment (inbfd, insec)
1211 > bfd_section_alignment (outbfd, outsec))
1212 && ! bfd_set_section_alignment (outbfd, outsec,
1213 bfd_section_alignment (inbfd, insec)))
1214 bfd_fatal ("set section alignment");
1216 if (! bfd_set_section_flags (outbfd, outsec, f))
1217 bfd_fatal ("set section flags");
1219 bfd_set_reloc (outbfd, outsec, (arelent **) NULL, 0);
1221 /* For each input section we allocate space for an entry in
1223 secsecsize = bfd_section_size (outbfd, secsec);
1224 secsecsize += strlen (bfd_section_name (inbfd, insec)) + 1;
1225 secsecsize = (secsecsize + 3) &~ 3;
1227 if (! bfd_set_section_size (outbfd, secsec, secsecsize))
1228 bfd_fatal ("set .nlmsections size");
1231 /* Copy the section contents. */
1234 copy_sections (inbfd, insec, data_ptr)
1239 static bfd_size_type secsecoff = 0;
1240 bfd *outbfd = (bfd *) data_ptr;
1249 inname = bfd_section_name (inbfd, insec);
1251 /* FIXME: We don't want to copy the .reginfo section of an ECOFF
1252 file. However, I don't have a good way to describe this section.
1253 We do want to copy the section when using objcopy. */
1254 if (bfd_get_flavour (inbfd) == bfd_target_ecoff_flavour
1255 && strcmp (inname, ".reginfo") == 0)
1258 outsec = insec->output_section;
1259 assert (outsec != NULL);
1261 size = bfd_get_section_size_before_reloc (insec);
1263 /* FIXME: Why are these necessary? */
1264 insec->_cooked_size = insec->_raw_size;
1265 insec->reloc_done = true;
1267 if ((bfd_get_section_flags (inbfd, insec) & SEC_HAS_CONTENTS) == 0)
1271 contents = xmalloc (size);
1272 if (! bfd_get_section_contents (inbfd, insec, contents,
1273 (file_ptr) 0, size))
1274 bfd_fatal (bfd_get_filename (inbfd));
1277 reloc_size = bfd_get_reloc_upper_bound (inbfd, insec);
1279 bfd_fatal (bfd_get_filename (inbfd));
1280 if (reloc_size != 0)
1285 relocs = (arelent **) xmalloc (reloc_size);
1286 reloc_count = bfd_canonicalize_reloc (inbfd, insec, relocs, symbols);
1287 if (reloc_count < 0)
1288 bfd_fatal (bfd_get_filename (inbfd));
1289 mangle_relocs (outbfd, insec, &relocs, &reloc_count, (char *) contents,
1292 /* FIXME: refers to internal BFD fields. */
1293 if (outsec->orelocation != (arelent **) NULL)
1295 bfd_size_type total_count;
1298 total_count = reloc_count + outsec->reloc_count;
1299 combined = (arelent **) xmalloc (total_count * sizeof (arelent));
1300 memcpy (combined, outsec->orelocation,
1301 outsec->reloc_count * sizeof (arelent));
1302 memcpy (combined + outsec->reloc_count, relocs,
1303 (size_t) (reloc_count * sizeof (arelent)));
1304 free (outsec->orelocation);
1305 reloc_count = total_count;
1309 bfd_set_reloc (outbfd, outsec, relocs, reloc_count);
1312 if (contents != NULL)
1314 if (! bfd_set_section_contents (outbfd, outsec, contents,
1315 insec->output_offset, size))
1316 bfd_fatal (bfd_get_filename (outbfd));
1320 /* Add this section to .nlmsections. */
1321 if (! bfd_set_section_contents (outbfd, secsec, (PTR) inname, secsecoff,
1322 strlen (inname) + 1))
1323 bfd_fatal ("set .nlmsection contents");
1324 secsecoff += strlen (inname) + 1;
1326 add = ((secsecoff + 3) &~ 3) - secsecoff;
1329 bfd_h_put_32 (outbfd, (bfd_vma) 0, buf);
1330 if (! bfd_set_section_contents (outbfd, secsec, buf, secsecoff, add))
1331 bfd_fatal ("set .nlmsection contents");
1335 if (contents != NULL)
1336 bfd_h_put_32 (outbfd, (bfd_vma) outsec->filepos, buf);
1338 bfd_h_put_32 (outbfd, (bfd_vma) 0, buf);
1339 if (! bfd_set_section_contents (outbfd, secsec, buf, secsecoff, 4))
1340 bfd_fatal ("set .nlmsection contents");
1343 bfd_h_put_32 (outbfd, (bfd_vma) size, buf);
1344 if (! bfd_set_section_contents (outbfd, secsec, buf, secsecoff, 4))
1345 bfd_fatal ("set .nlmsection contents");
1349 /* Some, perhaps all, NetWare targets require changing the relocs used
1350 by the input formats. */
1353 mangle_relocs (outbfd, insec, relocs_ptr, reloc_count_ptr, contents,
1357 arelent ***relocs_ptr;
1358 long *reloc_count_ptr;
1360 bfd_size_type contents_size;
1362 switch (bfd_get_arch (outbfd))
1365 i386_mangle_relocs (outbfd, insec, relocs_ptr, reloc_count_ptr,
1366 contents, contents_size);
1368 case bfd_arch_alpha:
1369 alpha_mangle_relocs (outbfd, insec, relocs_ptr, reloc_count_ptr,
1370 contents, contents_size);
1372 /* start-sanitize-powerpc-netware */
1373 case bfd_arch_powerpc:
1374 powerpc_mangle_relocs (outbfd, insec, relocs_ptr, reloc_count_ptr,
1375 contents, contents_size);
1377 /* end-sanitize-powerpc-netware */
1379 default_mangle_relocs (outbfd, insec, relocs_ptr, reloc_count_ptr,
1380 contents, contents_size);
1385 /* By default all we need to do for relocs is change the address by
1386 the output_offset. */
1390 default_mangle_relocs (outbfd, insec, relocs_ptr, reloc_count_ptr, contents,
1394 arelent ***relocs_ptr;
1395 long *reloc_count_ptr;
1397 bfd_size_type contents_size;
1399 if (insec->output_offset != 0)
1402 register arelent **relocs;
1405 reloc_count = *reloc_count_ptr;
1406 relocs = *relocs_ptr;
1407 for (i = 0; i < reloc_count; i++, relocs++)
1408 (*relocs)->address += insec->output_offset;
1412 /* NetWare on the i386 supports a restricted set of relocs, which are
1413 different from those used on other i386 targets. This routine
1414 converts the relocs. It is, obviously, very target dependent. At
1415 the moment, the nlm32-i386 backend performs similar translations;
1416 however, it is more reliable and efficient to do them here. */
1418 static reloc_howto_type nlm_i386_pcrel_howto =
1419 HOWTO (1, /* type */
1421 2, /* size (0 = byte, 1 = short, 2 = long) */
1423 true, /* pc_relative */
1425 complain_overflow_signed, /* complain_on_overflow */
1426 0, /* special_function */
1427 "DISP32", /* name */
1428 true, /* partial_inplace */
1429 0xffffffff, /* src_mask */
1430 0xffffffff, /* dst_mask */
1431 true); /* pcrel_offset */
1434 i386_mangle_relocs (outbfd, insec, relocs_ptr, reloc_count_ptr, contents,
1438 arelent ***relocs_ptr;
1439 long *reloc_count_ptr;
1441 bfd_size_type contents_size;
1443 long reloc_count, i;
1446 reloc_count = *reloc_count_ptr;
1447 relocs = *relocs_ptr;
1448 for (i = 0; i < reloc_count; i++)
1452 bfd_size_type address;
1456 sym = *rel->sym_ptr_ptr;
1458 /* We're moving the relocs from the input section to the output
1459 section, so we must adjust the address accordingly. */
1460 address = rel->address;
1461 rel->address += insec->output_offset;
1463 /* Note that no serious harm will ensue if we fail to change a
1464 reloc. The backend will fail when writing out the reloc. */
1466 /* Make sure this reloc is within the data we have. We use only
1467 4 byte relocs here, so we insist on having 4 bytes. */
1468 if (address + 4 > contents_size)
1471 /* A PC relative reloc entirely within a single section is
1472 completely unnecessary. This can be generated by ld -r. */
1473 if (sym == insec->symbol
1474 && rel->howto != NULL
1475 && rel->howto->pc_relative
1476 && ! rel->howto->pcrel_offset)
1480 memmove (relocs, relocs + 1,
1481 (size_t) ((reloc_count - i) * sizeof (arelent *)));
1485 /* Get the amount the relocation will add in. */
1486 addend = rel->addend + sym->value;
1488 /* NetWare doesn't support PC relative relocs against defined
1489 symbols, so we have to eliminate them by doing the relocation
1490 now. We can only do this if the reloc is within a single
1492 if (rel->howto != NULL
1493 && rel->howto->pc_relative
1494 && bfd_get_section (sym) == insec->output_section)
1498 if (rel->howto->pcrel_offset)
1501 val = bfd_get_32 (outbfd, (bfd_byte *) contents + address);
1503 bfd_put_32 (outbfd, val, (bfd_byte *) contents + address);
1507 memmove (relocs, relocs + 1,
1508 (size_t) ((reloc_count - i) * sizeof (arelent *)));
1512 /* NetWare doesn't support reloc addends, so we get rid of them
1513 here by simply adding them into the object data. We handle
1514 the symbol value, if any, the same way. */
1516 && rel->howto != NULL
1517 && rel->howto->rightshift == 0
1518 && rel->howto->size == 2
1519 && rel->howto->bitsize == 32
1520 && rel->howto->bitpos == 0
1521 && rel->howto->src_mask == 0xffffffff
1522 && rel->howto->dst_mask == 0xffffffff)
1526 val = bfd_get_32 (outbfd, (bfd_byte *) contents + address);
1528 bfd_put_32 (outbfd, val, (bfd_byte *) contents + address);
1530 /* Adjust the reloc for the changes we just made. */
1532 if (bfd_get_section (sym) != &bfd_und_section)
1533 rel->sym_ptr_ptr = bfd_get_section (sym)->symbol_ptr_ptr;
1536 /* NetWare uses a reloc with pcrel_offset set. We adjust
1537 pc_relative relocs accordingly. We are going to change the
1538 howto field, so we can only do this if the current one is
1539 compatible. We should check that special_function is NULL
1540 here, but at the moment coff-i386 uses a special_function
1541 which does not affect what we are doing here. */
1542 if (rel->howto != NULL
1543 && rel->howto->pc_relative
1544 && ! rel->howto->pcrel_offset
1545 && rel->howto->rightshift == 0
1546 && rel->howto->size == 2
1547 && rel->howto->bitsize == 32
1548 && rel->howto->bitpos == 0
1549 && rel->howto->src_mask == 0xffffffff
1550 && rel->howto->dst_mask == 0xffffffff)
1554 /* When pcrel_offset is not set, it means that the negative
1555 of the address of the memory location is stored in the
1556 memory location. We must add it back in. */
1557 val = bfd_get_32 (outbfd, (bfd_byte *) contents + address);
1559 bfd_put_32 (outbfd, val, (bfd_byte *) contents + address);
1561 /* We must change to a new howto. */
1562 rel->howto = &nlm_i386_pcrel_howto;
1567 /* On the Alpha the first reloc for every section must be a special
1568 relocs which hold the GP address. Also, the first reloc in the
1569 file must be a special reloc which holds the address of the .lita
1572 static reloc_howto_type nlm32_alpha_nw_howto =
1573 HOWTO (ALPHA_R_NW_RELOC, /* type */
1575 0, /* size (0 = byte, 1 = short, 2 = long) */
1577 false, /* pc_relative */
1579 complain_overflow_dont, /* complain_on_overflow */
1580 0, /* special_function */
1581 "NW_RELOC", /* name */
1582 false, /* partial_inplace */
1585 false); /* pcrel_offset */
1589 alpha_mangle_relocs (outbfd, insec, relocs_ptr, reloc_count_ptr, contents,
1593 register arelent ***relocs_ptr;
1594 long *reloc_count_ptr;
1596 bfd_size_type contents_size;
1598 long old_reloc_count;
1599 arelent **old_relocs;
1600 register arelent **relocs;
1602 old_reloc_count = *reloc_count_ptr;
1603 old_relocs = *relocs_ptr;
1604 relocs = (arelent **) xmalloc ((old_reloc_count + 3) * sizeof (arelent *));
1605 *relocs_ptr = relocs;
1607 if (nlm_alpha_backend_data (outbfd)->lita_address == 0)
1610 asection *lita_section;
1612 inbfd = insec->owner;
1613 lita_section = bfd_get_section_by_name (inbfd, _LITA);
1614 if (lita_section != (asection *) NULL)
1616 nlm_alpha_backend_data (outbfd)->lita_address =
1617 bfd_get_section_vma (inbfd, lita_section);
1618 nlm_alpha_backend_data (outbfd)->lita_size =
1619 bfd_section_size (inbfd, lita_section);
1623 /* Avoid outputting this reloc again. */
1624 nlm_alpha_backend_data (outbfd)->lita_address = 4;
1627 *relocs = (arelent *) xmalloc (sizeof (arelent));
1628 (*relocs)->sym_ptr_ptr = bfd_abs_section.symbol_ptr_ptr;
1629 (*relocs)->address = nlm_alpha_backend_data (outbfd)->lita_address;
1630 (*relocs)->addend = nlm_alpha_backend_data (outbfd)->lita_size + 1;
1631 (*relocs)->howto = &nlm32_alpha_nw_howto;
1633 ++(*reloc_count_ptr);
1636 /* Get the GP value from bfd. It is in the .reginfo section. */
1637 if (nlm_alpha_backend_data (outbfd)->gp == 0)
1640 asection *reginfo_sec;
1641 struct ecoff_reginfo sreginfo;
1643 inbfd = insec->owner;
1644 assert (bfd_get_flavour (inbfd) == bfd_target_ecoff_flavour);
1645 reginfo_sec = bfd_get_section_by_name (inbfd, REGINFO);
1646 if (reginfo_sec != (asection *) NULL
1647 && bfd_get_section_contents (inbfd, reginfo_sec,
1648 (PTR) &sreginfo, (file_ptr) 0,
1649 sizeof sreginfo) != false)
1650 nlm_alpha_backend_data (outbfd)->gp = sreginfo.gp_value;
1653 *relocs = (arelent *) xmalloc (sizeof (arelent));
1654 (*relocs)->sym_ptr_ptr = bfd_abs_section.symbol_ptr_ptr;
1655 (*relocs)->address = nlm_alpha_backend_data (outbfd)->gp;
1656 (*relocs)->addend = 0;
1657 (*relocs)->howto = &nlm32_alpha_nw_howto;
1659 ++(*reloc_count_ptr);
1661 memcpy ((PTR) relocs, (PTR) old_relocs,
1662 (size_t) old_reloc_count * sizeof (arelent *));
1663 relocs[old_reloc_count] = (arelent *) NULL;
1667 if (insec->output_offset != 0)
1669 register bfd_size_type i;
1671 for (i = 0; i < old_reloc_count; i++, relocs++)
1672 (*relocs)->address += insec->output_offset;
1675 /* start-sanitize-powerpc-netware */
1677 /* We keep a linked list of stubs which we must build. Because BFD
1678 requires us to know the sizes of all sections before we can set the
1679 contents of any, we must figure out which stubs we want to build
1680 before we can actually build any of them. */
1684 /* Next stub in linked list. */
1685 struct powerpc_stub *next;
1687 /* Symbol whose value is the start of the stub. This is a symbol
1688 whose name begins with `.'. */
1691 /* Symbol we are going to create a reloc against. This is a symbol
1692 with the same name as START but without the leading `.'. */
1695 /* The TOC index for this stub. This is the index into the TOC
1696 section at which the reloc is created. */
1697 unsigned int toc_index;
1700 /* The linked list of stubs. */
1702 static struct powerpc_stub *powerpc_stubs;
1704 /* This is what a stub looks like. The first instruction will get
1705 adjusted with the correct TOC index. */
1707 static unsigned long powerpc_stub_insns[] =
1709 0x81820000, /* lwz r12,0(r2) */
1710 0x90410014, /* stw r2,20(r1) */
1711 0x800c0000, /* lwz r0,0(r12) */
1712 0x804c0004, /* lwz r2,r(r12) */
1713 0x7c0903a6, /* mtctr r0 */
1714 0x4e800420, /* bctr */
1715 0, /* Traceback table. */
1720 #define POWERPC_STUB_INSN_COUNT \
1721 (sizeof powerpc_stub_insns / sizeof powerpc_stub_insns[0])
1723 #define POWERPC_STUB_SIZE (4 * POWERPC_STUB_INSN_COUNT)
1725 /* Each stub uses a four byte TOC entry. */
1726 #define POWERPC_STUB_TOC_ENTRY_SIZE (4)
1728 /* The original size of the .got section. */
1729 static bfd_size_type powerpc_initial_got_size;
1731 /* Look for all undefined symbols beginning with `.', and prepare to
1732 build a stub for each one. */
1735 powerpc_build_stubs (inbfd, outbfd, symbols_ptr, symcount_ptr)
1738 asymbol ***symbols_ptr;
1743 unsigned int got_base;
1748 /* Make a section to hold stubs. We don't set SEC_HAS_CONTENTS for
1749 the section to prevent copy_sections from reading from it. */
1750 stub_sec = bfd_make_section (inbfd, ".stubs");
1751 if (stub_sec == (asection *) NULL
1752 || ! bfd_set_section_flags (inbfd, stub_sec,
1757 || ! bfd_set_section_alignment (inbfd, stub_sec, 2))
1758 bfd_fatal (".stubs");
1760 /* Get the TOC section, which is named .got. */
1761 got_sec = bfd_get_section_by_name (inbfd, ".got");
1762 if (got_sec == (asection *) NULL)
1764 got_sec = bfd_make_section (inbfd, ".got");
1765 if (got_sec == (asection *) NULL
1766 || ! bfd_set_section_flags (inbfd, got_sec,
1771 | SEC_HAS_CONTENTS))
1772 || ! bfd_set_section_alignment (inbfd, got_sec, 2))
1776 powerpc_initial_got_size = bfd_section_size (inbfd, got_sec);
1777 got_base = powerpc_initial_got_size;
1778 got_base = (got_base + 3) &~ 3;
1782 symcount = *symcount_ptr;
1783 for (i = 0; i < symcount; i++)
1788 struct powerpc_stub *item;
1790 sym = (*symbols_ptr)[i];
1792 /* We must make a stub for every undefined symbol whose name
1794 if (bfd_asymbol_name (sym)[0] != '.'
1795 || bfd_get_section (sym) != &bfd_und_section)
1798 /* Make a new undefined symbol with the same name but without
1800 newsym = (asymbol *) xmalloc (sizeof (asymbol));
1802 newname = (char *) xmalloc (strlen (bfd_asymbol_name (sym)));
1803 strcpy (newname, bfd_asymbol_name (sym) + 1);
1804 newsym->name = newname;
1806 /* Define the `.' symbol to be in the stub section. */
1807 sym->section = stub_sec;
1808 sym->value = stubcount * POWERPC_STUB_SIZE;
1809 /* We set the BSF_DYNAMIC flag here so that we can check it when
1810 we are mangling relocs. FIXME: This is a hack. */
1811 sym->flags = BSF_LOCAL | BSF_DYNAMIC;
1813 /* Add this stub to the linked list. */
1814 item = (struct powerpc_stub *) xmalloc (sizeof (struct powerpc_stub));
1816 item->reloc = newsym;
1817 item->toc_index = got_base + stubcount * POWERPC_STUB_TOC_ENTRY_SIZE;
1819 item->next = powerpc_stubs;
1820 powerpc_stubs = item;
1828 struct powerpc_stub *l;
1830 /* Add the new symbols we just created to the symbol table. */
1831 *symbols_ptr = (asymbol **) xrealloc ((char *) *symbols_ptr,
1832 ((symcount + stubcount)
1833 * sizeof (asymbol)));
1834 *symcount_ptr += stubcount;
1835 s = &(*symbols_ptr)[symcount];
1836 for (l = powerpc_stubs; l != (struct powerpc_stub *) NULL; l = l->next)
1839 /* Set the size of the .stubs section and increase the size of
1840 the .got section. */
1841 if (! bfd_set_section_size (inbfd, stub_sec,
1842 stubcount * POWERPC_STUB_SIZE)
1843 || ! bfd_set_section_size (inbfd, got_sec,
1846 * POWERPC_STUB_TOC_ENTRY_SIZE))))
1847 bfd_fatal ("stub section sizes");
1850 /* PowerPC NetWare requires a custom header. We create it here.
1851 The first word is the header version number, currently 1. The
1852 second word is the timestamp of the input file. */
1853 memcpy (nlm_custom_header (outbfd)->stamp, "CuStHeAd", 8);
1854 nlm_custom_header (outbfd)->dataLength = 8;
1855 nlm_custom_header (outbfd)->data = xmalloc (8);
1856 bfd_h_put_32 (outbfd, (bfd_vma) 1,
1857 (bfd_byte *) nlm_custom_header (outbfd)->data);
1861 if (stat (bfd_get_filename (inbfd), &s) < 0)
1863 bfd_h_put_32 (outbfd, (bfd_vma) s.st_mtime,
1864 (bfd_byte *) nlm_custom_header (outbfd)->data + 4);
1868 /* Resolve all the stubs for PowerPC NetWare. We fill in the contents
1869 of the output section, and create new relocs in the TOC. */
1872 powerpc_resolve_stubs (inbfd, outbfd)
1876 bfd_byte buf[POWERPC_STUB_SIZE];
1878 unsigned int stubcount;
1882 struct powerpc_stub *l;
1884 if (powerpc_stubs == (struct powerpc_stub *) NULL)
1887 for (i = 0; i < POWERPC_STUB_INSN_COUNT; i++)
1888 bfd_put_32 (outbfd, (bfd_vma) powerpc_stub_insns[i], buf + i * 4);
1890 got_sec = bfd_get_section_by_name (inbfd, ".got");
1891 assert (got_sec != (asection *) NULL);
1892 assert (got_sec->output_section->orelocation == (arelent **) NULL);
1895 for (l = powerpc_stubs; l != (struct powerpc_stub *) NULL; l = l->next)
1897 relocs = (arelent **) xmalloc (stubcount * sizeof (arelent *));
1900 for (l = powerpc_stubs; l != (struct powerpc_stub *) NULL; l = l->next)
1904 /* Adjust the first instruction to use the right TOC index. */
1905 bfd_put_32 (outbfd, (bfd_vma) powerpc_stub_insns[0] + l->toc_index, buf);
1907 /* Write this stub out. */
1908 if (! bfd_set_section_contents (outbfd,
1909 bfd_get_section (l->start),
1913 bfd_fatal ("writing stub");
1915 /* Create a new reloc for the TOC entry. */
1916 reloc = (arelent *) xmalloc (sizeof (arelent));
1917 reloc->sym_ptr_ptr = &l->reloc;
1918 reloc->address = l->toc_index + got_sec->output_offset;
1920 reloc->howto = bfd_reloc_type_lookup (inbfd, BFD_RELOC_32);
1925 bfd_set_reloc (outbfd, got_sec->output_section, relocs, stubcount);
1928 /* Adjust relocation entries for PowerPC NetWare. We do not output
1929 TOC relocations. The object code already contains the offset from
1930 the TOC pointer. When the function is called, the TOC register,
1931 r2, will be set to the correct TOC value, so there is no need for
1932 any further reloc. */
1936 powerpc_mangle_relocs (outbfd, insec, relocs_ptr, reloc_count_ptr, contents,
1940 register arelent ***relocs_ptr;
1941 long *reloc_count_ptr;
1943 bfd_size_type contents_size;
1945 const reloc_howto_type *toc_howto;
1947 register arelent **relocs;
1950 toc_howto = bfd_reloc_type_lookup (insec->owner, BFD_RELOC_PPC_TOC16);
1951 if (toc_howto == (reloc_howto_type *) NULL)
1954 /* If this is the .got section, clear out all the contents beyond
1955 the initial size. We must do this here because copy_sections is
1956 going to write out whatever we return in the contents field. */
1957 if (strcmp (bfd_get_section_name (insec->owner, insec), ".got") == 0)
1958 memset (contents + powerpc_initial_got_size, 0,
1959 (bfd_get_section_size_after_reloc (insec)
1960 - powerpc_initial_got_size));
1962 reloc_count = *reloc_count_ptr;
1963 relocs = *relocs_ptr;
1964 for (i = 0; i < reloc_count; i++)
1971 sym = *rel->sym_ptr_ptr;
1973 /* We must be able to resolve all PC relative relocs at this
1974 point. If we get a branch to an undefined symbol we build a
1975 stub, since NetWare will resolve undefined symbols into a
1976 pointer to a function descriptor. */
1977 if (rel->howto->pc_relative)
1979 /* This check for whether a symbol is in the same section as
1980 the reloc will be wrong if there is a PC relative reloc
1981 between two sections both of which were placed in the
1982 same output section. This should not happen. */
1983 if (bfd_get_section (sym) != insec->output_section)
1984 fprintf (stderr, "%s: unresolved PC relative reloc against %s\n",
1985 program_name, bfd_asymbol_name (sym));
1990 assert (rel->howto->size == 2 && rel->howto->pcrel_offset);
1991 val = bfd_get_32 (outbfd, (bfd_byte *) contents + rel->address);
1992 val = ((val &~ rel->howto->dst_mask)
1993 | (((val & rel->howto->src_mask)
1994 + (sym->value - rel->address)
1996 & rel->howto->dst_mask));
1997 bfd_put_32 (outbfd, val, (bfd_byte *) contents + rel->address);
1999 /* If this reloc is against an stubbed symbol and the
2002 then we replace the next instruction with
2004 This reloads the TOC pointer after a stub call. */
2005 if (bfd_asymbol_name (sym)[0] == '.'
2006 && (sym->flags & BSF_DYNAMIC) != 0
2007 && (bfd_get_32 (outbfd,
2008 (bfd_byte *) contents + rel->address + 4)
2009 == 0x4ffffb82)) /* cror 31,31,31 */
2010 bfd_put_32 (outbfd, (bfd_vma) 0x80410014, /* lwz r2,20(r1) */
2011 (bfd_byte *) contents + rel->address + 4);
2015 memmove (relocs, relocs + 1,
2016 (size_t) ((reloc_count - 1) * sizeof (arelent *)));
2021 /* When considering a TOC reloc, we do not want to include the
2022 symbol value. The symbol will be start of the TOC section
2023 (which is named .got). We do want to include the addend. */
2024 if (rel->howto == toc_howto)
2027 symvalue = sym->value;
2029 /* If this is a relocation against a symbol with a value, or
2030 there is a reloc addend, we need to update the addend in the
2032 if (symvalue + rel->addend != 0)
2036 switch (rel->howto->size)
2039 val = bfd_get_16 (outbfd,
2040 (bfd_byte *) contents + rel->address);
2041 val = ((val &~ rel->howto->dst_mask)
2042 | (((val & rel->howto->src_mask)
2045 & rel->howto->dst_mask));
2046 if ((bfd_signed_vma) val < - 0x8000
2047 || (bfd_signed_vma) val >= 0x8000)
2049 "%s: overflow when adjusting relocation against %s\n",
2050 program_name, bfd_asymbol_name (sym));
2051 bfd_put_16 (outbfd, val, (bfd_byte *) contents + rel->address);
2055 val = bfd_get_32 (outbfd,
2056 (bfd_byte *) contents + rel->address);
2057 val = ((val &~ rel->howto->dst_mask)
2058 | (((val & rel->howto->src_mask)
2061 & rel->howto->dst_mask));
2062 bfd_put_32 (outbfd, val, (bfd_byte *) contents + rel->address);
2069 rel->sym_ptr_ptr = bfd_get_section (sym)->symbol_ptr_ptr;
2073 /* Now that we have incorporated the addend, remove any TOC
2075 if (rel->howto == toc_howto)
2079 memmove (relocs, relocs + 1,
2080 (size_t) ((reloc_count - i) * sizeof (arelent *)));
2084 rel->address += insec->output_offset;
2087 /* end-sanitize-powerpc-netware */
2089 /* Name of linker. */
2091 #define LD_NAME "ld"
2094 /* Temporary file name base. */
2095 static char *temp_filename;
2097 /* The user has specified several input files. Invoke the linker to
2098 link them all together, and convert and delete the resulting output
2102 link_inputs (inputs, ld)
2103 struct string_list *inputs;
2107 struct string_list *q;
2114 for (q = inputs; q != NULL; q = q->next)
2117 argv = (char **) alloca (c + 5);
2124 /* Find the linker to invoke based on how nlmconv was run. */
2125 p = program_name + strlen (program_name);
2126 while (p != program_name)
2130 ld = (char *) xmalloc (p - program_name + strlen (LD_NAME) + 1);
2131 memcpy (ld, program_name, p - program_name);
2132 strcpy (ld + (p - program_name), LD_NAME);
2141 ld = (char *) LD_NAME;
2143 choose_temp_base ();
2145 unlink_on_exit = xmalloc (strlen (temp_filename) + 3);
2146 sprintf (unlink_on_exit, "%s.O", temp_filename);
2149 argv[1] = (char *) "-r";
2150 argv[2] = (char *) "-o";
2151 argv[3] = unlink_on_exit;
2153 for (q = inputs; q != NULL; q = q->next, i++)
2154 argv[i] = q->string;
2159 for (i = 0; argv[i] != NULL; i++)
2160 fprintf (stderr, " %s", argv[i]);
2161 fprintf (stderr, "\n");
2164 pid = pexecute (ld, argv);
2166 if (waitpid (pid, &status, 0) < 0)
2169 unlink (unlink_on_exit);
2175 fprintf (stderr, "%s: Execution of %s failed\n", program_name, ld);
2176 unlink (unlink_on_exit);
2180 return unlink_on_exit;
2183 /* Choose a temporary file name. Stolen from gcc.c. */
2186 choose_temp_base_try (try, base)
2194 else if (try == NULL)
2196 else if (access (try, R_OK | W_OK) != 0)
2206 const char *base = NULL;
2209 base = choose_temp_base_try (getenv ("TMPDIR"), base);
2210 base = choose_temp_base_try (getenv ("TMP"), base);
2211 base = choose_temp_base_try (getenv ("TEMP"), base);
2214 base = choose_temp_base_try (P_tmpdir, base);
2217 base = choose_temp_base_try ("/usr/tmp", base);
2218 base = choose_temp_base_try ("/tmp", base);
2220 /* If all else fails, use the current directory! */
2224 len = strlen (base);
2225 temp_filename = xmalloc (len + sizeof("/ccXXXXXX") + 1);
2226 strcpy (temp_filename, base);
2227 if (len > 0 && temp_filename[len-1] != '/')
2228 temp_filename[len++] = '/';
2229 strcpy (temp_filename + len, "ccXXXXXX");
2231 mktemp (temp_filename);
2232 if (*temp_filename == '\0')
2236 /* Execute a job. Stolen from gcc.c. */
2242 pexecute (program, argv)
2250 scmd = (char *)malloc (strlen (program) + strlen (temp_filename) + 10);
2251 rf = scmd + strlen(program) + 2 + el;
2252 sprintf (scmd, "%s.exe @%s.gp", program, temp_filename);
2253 argfile = fopen (rf, "w");
2255 pfatal_with_name (rf);
2257 for (i=1; argv[i]; i++)
2260 for (cp = argv[i]; *cp; cp++)
2262 if (*cp == '"' || *cp == '\'' || *cp == '\\' || isspace (*cp))
2263 fputc ('\\', argfile);
2264 fputc (*cp, argfile);
2266 fputc ('\n', argfile);
2277 return MIN_FATAL_STATUS << 8;
2283 #else /* not __MSDOS__ */
2286 pexecute (program, argv)
2291 int retries, sleep_interval;
2293 /* Fork a subprocess; wait and retry if it fails. */
2295 for (retries = 0; retries < 4; retries++)
2300 sleep (sleep_interval);
2301 sleep_interval *= 2;
2317 /* Exec the program. */
2318 execvp (program, argv);
2325 /* Return child's process number. */
2330 #endif /* not __MSDOS__ */
2334 pexecute (program, argv)
2338 return spawnvp (1, program, argv);
2340 #endif /* not OS2 */