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 f
= bfd_get_section_flags (inbfd
, insec
);
1174 outname
= NLM_CODE_NAME
;
1175 else if ((f
& SEC_LOAD
) && (f
& SEC_HAS_CONTENTS
))
1176 outname
= NLM_INITIALIZED_DATA_NAME
;
1177 else if (f
& SEC_ALLOC
)
1178 outname
= NLM_UNINITIALIZED_DATA_NAME
;
1180 outname
= bfd_section_name (inbfd
, insec
);
1182 outsec
= bfd_get_section_by_name (outbfd
, outname
);
1185 outsec
= bfd_make_section (outbfd
, outname
);
1187 bfd_fatal ("make section");
1190 insec
->output_section
= outsec
;
1192 offset
= bfd_section_size (outbfd
, outsec
);
1193 align
= 1 << bfd_section_alignment (inbfd
, insec
);
1194 add
= ((offset
+ align
- 1) &~ (align
- 1)) - offset
;
1195 insec
->output_offset
= offset
+ add
;
1197 if (! bfd_set_section_size (outbfd
, outsec
,
1198 (bfd_section_size (outbfd
, outsec
)
1199 + bfd_section_size (inbfd
, insec
)
1201 bfd_fatal ("set section size");
1203 if ((bfd_section_alignment (inbfd
, insec
)
1204 > bfd_section_alignment (outbfd
, outsec
))
1205 && ! bfd_set_section_alignment (outbfd
, outsec
,
1206 bfd_section_alignment (inbfd
, insec
)))
1207 bfd_fatal ("set section alignment");
1209 if (! bfd_set_section_flags (outbfd
, outsec
, f
))
1210 bfd_fatal ("set section flags");
1212 bfd_set_reloc (outbfd
, outsec
, (arelent
**) NULL
, 0);
1214 /* For each input section we allocate space for an entry in
1216 secsecsize
= bfd_section_size (outbfd
, secsec
);
1217 secsecsize
+= strlen (bfd_section_name (inbfd
, insec
)) + 1;
1218 secsecsize
= (secsecsize
+ 3) &~ 3;
1220 if (! bfd_set_section_size (outbfd
, secsec
, secsecsize
))
1221 bfd_fatal ("set .nlmsections size");
1224 /* Copy the section contents. */
1227 copy_sections (inbfd
, insec
, data_ptr
)
1232 static bfd_size_type secsecoff
= 0;
1233 bfd
*outbfd
= (bfd
*) data_ptr
;
1242 inname
= bfd_section_name (inbfd
, insec
);
1244 outsec
= insec
->output_section
;
1245 assert (outsec
!= NULL
);
1247 size
= bfd_get_section_size_before_reloc (insec
);
1249 /* FIXME: Why are these necessary? */
1250 insec
->_cooked_size
= insec
->_raw_size
;
1251 insec
->reloc_done
= true;
1253 if ((bfd_get_section_flags (inbfd
, insec
) & SEC_HAS_CONTENTS
) == 0)
1257 contents
= xmalloc (size
);
1258 if (! bfd_get_section_contents (inbfd
, insec
, contents
,
1259 (file_ptr
) 0, size
))
1260 bfd_fatal (bfd_get_filename (inbfd
));
1263 reloc_size
= bfd_get_reloc_upper_bound (inbfd
, insec
);
1265 bfd_fatal (bfd_get_filename (inbfd
));
1266 if (reloc_size
!= 0)
1271 relocs
= (arelent
**) xmalloc (reloc_size
);
1272 reloc_count
= bfd_canonicalize_reloc (inbfd
, insec
, relocs
, symbols
);
1273 if (reloc_count
< 0)
1274 bfd_fatal (bfd_get_filename (inbfd
));
1275 mangle_relocs (outbfd
, insec
, &relocs
, &reloc_count
, (char *) contents
,
1278 /* FIXME: refers to internal BFD fields. */
1279 if (outsec
->orelocation
!= (arelent
**) NULL
)
1281 bfd_size_type total_count
;
1284 total_count
= reloc_count
+ outsec
->reloc_count
;
1285 combined
= (arelent
**) xmalloc (total_count
* sizeof (arelent
));
1286 memcpy (combined
, outsec
->orelocation
,
1287 outsec
->reloc_count
* sizeof (arelent
));
1288 memcpy (combined
+ outsec
->reloc_count
, relocs
,
1289 (size_t) (reloc_count
* sizeof (arelent
)));
1290 free (outsec
->orelocation
);
1291 reloc_count
= total_count
;
1295 bfd_set_reloc (outbfd
, outsec
, relocs
, reloc_count
);
1298 if (contents
!= NULL
)
1300 if (! bfd_set_section_contents (outbfd
, outsec
, contents
,
1301 insec
->output_offset
, size
))
1302 bfd_fatal (bfd_get_filename (outbfd
));
1306 /* Add this section to .nlmsections. */
1307 if (! bfd_set_section_contents (outbfd
, secsec
, (PTR
) inname
, secsecoff
,
1308 strlen (inname
) + 1))
1309 bfd_fatal ("set .nlmsection contents");
1310 secsecoff
+= strlen (inname
) + 1;
1312 add
= ((secsecoff
+ 3) &~ 3) - secsecoff
;
1315 bfd_h_put_32 (outbfd
, (bfd_vma
) 0, buf
);
1316 if (! bfd_set_section_contents (outbfd
, secsec
, buf
, secsecoff
, add
))
1317 bfd_fatal ("set .nlmsection contents");
1321 if (contents
!= NULL
)
1322 bfd_h_put_32 (outbfd
, (bfd_vma
) outsec
->filepos
, buf
);
1324 bfd_h_put_32 (outbfd
, (bfd_vma
) 0, buf
);
1325 if (! bfd_set_section_contents (outbfd
, secsec
, buf
, secsecoff
, 4))
1326 bfd_fatal ("set .nlmsection contents");
1329 bfd_h_put_32 (outbfd
, (bfd_vma
) size
, buf
);
1330 if (! bfd_set_section_contents (outbfd
, secsec
, buf
, secsecoff
, 4))
1331 bfd_fatal ("set .nlmsection contents");
1335 /* Some, perhaps all, NetWare targets require changing the relocs used
1336 by the input formats. */
1339 mangle_relocs (outbfd
, insec
, relocs_ptr
, reloc_count_ptr
, contents
,
1343 arelent
***relocs_ptr
;
1344 long *reloc_count_ptr
;
1346 bfd_size_type contents_size
;
1348 switch (bfd_get_arch (outbfd
))
1351 i386_mangle_relocs (outbfd
, insec
, relocs_ptr
, reloc_count_ptr
,
1352 contents
, contents_size
);
1354 case bfd_arch_alpha
:
1355 alpha_mangle_relocs (outbfd
, insec
, relocs_ptr
, reloc_count_ptr
,
1356 contents
, contents_size
);
1358 /* start-sanitize-powerpc-netware */
1359 case bfd_arch_powerpc
:
1360 powerpc_mangle_relocs (outbfd
, insec
, relocs_ptr
, reloc_count_ptr
,
1361 contents
, contents_size
);
1363 /* end-sanitize-powerpc-netware */
1365 default_mangle_relocs (outbfd
, insec
, relocs_ptr
, reloc_count_ptr
,
1366 contents
, contents_size
);
1371 /* By default all we need to do for relocs is change the address by
1372 the output_offset. */
1376 default_mangle_relocs (outbfd
, insec
, relocs_ptr
, reloc_count_ptr
, contents
,
1380 arelent
***relocs_ptr
;
1381 long *reloc_count_ptr
;
1383 bfd_size_type contents_size
;
1385 if (insec
->output_offset
!= 0)
1388 register arelent
**relocs
;
1391 reloc_count
= *reloc_count_ptr
;
1392 relocs
= *relocs_ptr
;
1393 for (i
= 0; i
< reloc_count
; i
++, relocs
++)
1394 (*relocs
)->address
+= insec
->output_offset
;
1398 /* NetWare on the i386 supports a restricted set of relocs, which are
1399 different from those used on other i386 targets. This routine
1400 converts the relocs. It is, obviously, very target dependent. At
1401 the moment, the nlm32-i386 backend performs similar translations;
1402 however, it is more reliable and efficient to do them here. */
1404 static reloc_howto_type nlm_i386_pcrel_howto
=
1405 HOWTO (1, /* type */
1407 2, /* size (0 = byte, 1 = short, 2 = long) */
1409 true, /* pc_relative */
1411 complain_overflow_signed
, /* complain_on_overflow */
1412 0, /* special_function */
1413 "DISP32", /* name */
1414 true, /* partial_inplace */
1415 0xffffffff, /* src_mask */
1416 0xffffffff, /* dst_mask */
1417 true); /* pcrel_offset */
1420 i386_mangle_relocs (outbfd
, insec
, relocs_ptr
, reloc_count_ptr
, contents
,
1424 arelent
***relocs_ptr
;
1425 long *reloc_count_ptr
;
1427 bfd_size_type contents_size
;
1429 long reloc_count
, i
;
1432 reloc_count
= *reloc_count_ptr
;
1433 relocs
= *relocs_ptr
;
1434 for (i
= 0; i
< reloc_count
; i
++)
1438 bfd_size_type address
;
1442 sym
= *rel
->sym_ptr_ptr
;
1444 /* We're moving the relocs from the input section to the output
1445 section, so we must adjust the address accordingly. */
1446 address
= rel
->address
;
1447 rel
->address
+= insec
->output_offset
;
1449 /* Note that no serious harm will ensue if we fail to change a
1450 reloc. The backend will fail when writing out the reloc. */
1452 /* Make sure this reloc is within the data we have. We use only
1453 4 byte relocs here, so we insist on having 4 bytes. */
1454 if (address
+ 4 > contents_size
)
1457 /* A PC relative reloc entirely within a single section is
1458 completely unnecessary. This can be generated by ld -r. */
1459 if (sym
== insec
->symbol
1460 && rel
->howto
!= NULL
1461 && rel
->howto
->pc_relative
1462 && ! rel
->howto
->pcrel_offset
)
1466 memmove (relocs
, relocs
+ 1,
1467 (size_t) ((reloc_count
- i
) * sizeof (arelent
*)));
1471 /* Get the amount the relocation will add in. */
1472 addend
= rel
->addend
+ sym
->value
;
1474 /* NetWare doesn't support PC relative relocs against defined
1475 symbols, so we have to eliminate them by doing the relocation
1476 now. We can only do this if the reloc is within a single
1478 if (rel
->howto
!= NULL
1479 && rel
->howto
->pc_relative
1480 && bfd_get_section (sym
) == insec
->output_section
)
1484 if (rel
->howto
->pcrel_offset
)
1487 val
= bfd_get_32 (outbfd
, (bfd_byte
*) contents
+ address
);
1489 bfd_put_32 (outbfd
, val
, (bfd_byte
*) contents
+ address
);
1493 memmove (relocs
, relocs
+ 1,
1494 (size_t) ((reloc_count
- i
) * sizeof (arelent
*)));
1498 /* NetWare doesn't support reloc addends, so we get rid of them
1499 here by simply adding them into the object data. We handle
1500 the symbol value, if any, the same way. */
1502 && rel
->howto
!= NULL
1503 && rel
->howto
->rightshift
== 0
1504 && rel
->howto
->size
== 2
1505 && rel
->howto
->bitsize
== 32
1506 && rel
->howto
->bitpos
== 0
1507 && rel
->howto
->src_mask
== 0xffffffff
1508 && rel
->howto
->dst_mask
== 0xffffffff)
1512 val
= bfd_get_32 (outbfd
, (bfd_byte
*) contents
+ address
);
1514 bfd_put_32 (outbfd
, val
, (bfd_byte
*) contents
+ address
);
1516 /* Adjust the reloc for the changes we just made. */
1518 if (bfd_get_section (sym
) != &bfd_und_section
)
1519 rel
->sym_ptr_ptr
= bfd_get_section (sym
)->symbol_ptr_ptr
;
1522 /* NetWare uses a reloc with pcrel_offset set. We adjust
1523 pc_relative relocs accordingly. We are going to change the
1524 howto field, so we can only do this if the current one is
1525 compatible. We should check that special_function is NULL
1526 here, but at the moment coff-i386 uses a special_function
1527 which does not affect what we are doing here. */
1528 if (rel
->howto
!= NULL
1529 && rel
->howto
->pc_relative
1530 && ! rel
->howto
->pcrel_offset
1531 && rel
->howto
->rightshift
== 0
1532 && rel
->howto
->size
== 2
1533 && rel
->howto
->bitsize
== 32
1534 && rel
->howto
->bitpos
== 0
1535 && rel
->howto
->src_mask
== 0xffffffff
1536 && rel
->howto
->dst_mask
== 0xffffffff)
1540 /* When pcrel_offset is not set, it means that the negative
1541 of the address of the memory location is stored in the
1542 memory location. We must add it back in. */
1543 val
= bfd_get_32 (outbfd
, (bfd_byte
*) contents
+ address
);
1545 bfd_put_32 (outbfd
, val
, (bfd_byte
*) contents
+ address
);
1547 /* We must change to a new howto. */
1548 rel
->howto
= &nlm_i386_pcrel_howto
;
1553 /* On the Alpha the first reloc for every section must be a special
1554 relocs which hold the GP address. Also, the first reloc in the
1555 file must be a special reloc which holds the address of the .lita
1558 static reloc_howto_type nlm32_alpha_nw_howto
=
1559 HOWTO (ALPHA_R_NW_RELOC
, /* type */
1561 0, /* size (0 = byte, 1 = short, 2 = long) */
1563 false, /* pc_relative */
1565 complain_overflow_dont
, /* complain_on_overflow */
1566 0, /* special_function */
1567 "NW_RELOC", /* name */
1568 false, /* partial_inplace */
1571 false); /* pcrel_offset */
1575 alpha_mangle_relocs (outbfd
, insec
, relocs_ptr
, reloc_count_ptr
, contents
,
1579 register arelent
***relocs_ptr
;
1580 long *reloc_count_ptr
;
1582 bfd_size_type contents_size
;
1584 long old_reloc_count
;
1585 arelent
**old_relocs
;
1586 register arelent
**relocs
;
1588 old_reloc_count
= *reloc_count_ptr
;
1589 old_relocs
= *relocs_ptr
;
1590 relocs
= (arelent
**) xmalloc ((old_reloc_count
+ 3) * sizeof (arelent
*));
1591 *relocs_ptr
= relocs
;
1593 if (nlm_alpha_backend_data (outbfd
)->lita_address
== 0)
1596 asection
*lita_section
;
1598 inbfd
= insec
->owner
;
1599 lita_section
= bfd_get_section_by_name (inbfd
, _LITA
);
1600 if (lita_section
!= (asection
*) NULL
)
1602 nlm_alpha_backend_data (outbfd
)->lita_address
=
1603 bfd_get_section_vma (inbfd
, lita_section
);
1604 nlm_alpha_backend_data (outbfd
)->lita_size
=
1605 bfd_section_size (inbfd
, lita_section
);
1609 /* Avoid outputting this reloc again. */
1610 nlm_alpha_backend_data (outbfd
)->lita_address
= 4;
1613 *relocs
= (arelent
*) xmalloc (sizeof (arelent
));
1614 (*relocs
)->sym_ptr_ptr
= bfd_abs_section
.symbol_ptr_ptr
;
1615 (*relocs
)->address
= nlm_alpha_backend_data (outbfd
)->lita_address
;
1616 (*relocs
)->addend
= nlm_alpha_backend_data (outbfd
)->lita_size
+ 1;
1617 (*relocs
)->howto
= &nlm32_alpha_nw_howto
;
1619 ++(*reloc_count_ptr
);
1622 /* Get the GP value from bfd. */
1623 if (nlm_alpha_backend_data (outbfd
)->gp
== 0)
1624 nlm_alpha_backend_data (outbfd
)->gp
=
1625 bfd_ecoff_get_gp_value (insec
->owner
);
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
)->gp
;
1630 (*relocs
)->addend
= 0;
1631 (*relocs
)->howto
= &nlm32_alpha_nw_howto
;
1633 ++(*reloc_count_ptr
);
1635 memcpy ((PTR
) relocs
, (PTR
) old_relocs
,
1636 (size_t) old_reloc_count
* sizeof (arelent
*));
1637 relocs
[old_reloc_count
] = (arelent
*) NULL
;
1641 if (insec
->output_offset
!= 0)
1643 register bfd_size_type i
;
1645 for (i
= 0; i
< old_reloc_count
; i
++, relocs
++)
1646 (*relocs
)->address
+= insec
->output_offset
;
1649 /* start-sanitize-powerpc-netware */
1651 /* We keep a linked list of stubs which we must build. Because BFD
1652 requires us to know the sizes of all sections before we can set the
1653 contents of any, we must figure out which stubs we want to build
1654 before we can actually build any of them. */
1658 /* Next stub in linked list. */
1659 struct powerpc_stub
*next
;
1661 /* Symbol whose value is the start of the stub. This is a symbol
1662 whose name begins with `.'. */
1665 /* Symbol we are going to create a reloc against. This is a symbol
1666 with the same name as START but without the leading `.'. */
1669 /* The TOC index for this stub. This is the index into the TOC
1670 section at which the reloc is created. */
1671 unsigned int toc_index
;
1674 /* The linked list of stubs. */
1676 static struct powerpc_stub
*powerpc_stubs
;
1678 /* This is what a stub looks like. The first instruction will get
1679 adjusted with the correct TOC index. */
1681 static unsigned long powerpc_stub_insns
[] =
1683 0x81820000, /* lwz r12,0(r2) */
1684 0x90410014, /* stw r2,20(r1) */
1685 0x800c0000, /* lwz r0,0(r12) */
1686 0x804c0004, /* lwz r2,r(r12) */
1687 0x7c0903a6, /* mtctr r0 */
1688 0x4e800420, /* bctr */
1689 0, /* Traceback table. */
1694 #define POWERPC_STUB_INSN_COUNT \
1695 (sizeof powerpc_stub_insns / sizeof powerpc_stub_insns[0])
1697 #define POWERPC_STUB_SIZE (4 * POWERPC_STUB_INSN_COUNT)
1699 /* Each stub uses a four byte TOC entry. */
1700 #define POWERPC_STUB_TOC_ENTRY_SIZE (4)
1702 /* The original size of the .got section. */
1703 static bfd_size_type powerpc_initial_got_size
;
1705 /* Look for all undefined symbols beginning with `.', and prepare to
1706 build a stub for each one. */
1709 powerpc_build_stubs (inbfd
, outbfd
, symbols_ptr
, symcount_ptr
)
1712 asymbol
***symbols_ptr
;
1717 unsigned int got_base
;
1722 /* Make a section to hold stubs. We don't set SEC_HAS_CONTENTS for
1723 the section to prevent copy_sections from reading from it. */
1724 stub_sec
= bfd_make_section (inbfd
, ".stubs");
1725 if (stub_sec
== (asection
*) NULL
1726 || ! bfd_set_section_flags (inbfd
, stub_sec
,
1731 || ! bfd_set_section_alignment (inbfd
, stub_sec
, 2))
1732 bfd_fatal (".stubs");
1734 /* Get the TOC section, which is named .got. */
1735 got_sec
= bfd_get_section_by_name (inbfd
, ".got");
1736 if (got_sec
== (asection
*) NULL
)
1738 got_sec
= bfd_make_section (inbfd
, ".got");
1739 if (got_sec
== (asection
*) NULL
1740 || ! bfd_set_section_flags (inbfd
, got_sec
,
1745 | SEC_HAS_CONTENTS
))
1746 || ! bfd_set_section_alignment (inbfd
, got_sec
, 2))
1750 powerpc_initial_got_size
= bfd_section_size (inbfd
, got_sec
);
1751 got_base
= powerpc_initial_got_size
;
1752 got_base
= (got_base
+ 3) &~ 3;
1756 symcount
= *symcount_ptr
;
1757 for (i
= 0; i
< symcount
; i
++)
1762 struct powerpc_stub
*item
;
1764 sym
= (*symbols_ptr
)[i
];
1766 /* We must make a stub for every undefined symbol whose name
1768 if (bfd_asymbol_name (sym
)[0] != '.'
1769 || bfd_get_section (sym
) != &bfd_und_section
)
1772 /* Make a new undefined symbol with the same name but without
1774 newsym
= (asymbol
*) xmalloc (sizeof (asymbol
));
1776 newname
= (char *) xmalloc (strlen (bfd_asymbol_name (sym
)));
1777 strcpy (newname
, bfd_asymbol_name (sym
) + 1);
1778 newsym
->name
= newname
;
1780 /* Define the `.' symbol to be in the stub section. */
1781 sym
->section
= stub_sec
;
1782 sym
->value
= stubcount
* POWERPC_STUB_SIZE
;
1783 /* We set the BSF_DYNAMIC flag here so that we can check it when
1784 we are mangling relocs. FIXME: This is a hack. */
1785 sym
->flags
= BSF_LOCAL
| BSF_DYNAMIC
;
1787 /* Add this stub to the linked list. */
1788 item
= (struct powerpc_stub
*) xmalloc (sizeof (struct powerpc_stub
));
1790 item
->reloc
= newsym
;
1791 item
->toc_index
= got_base
+ stubcount
* POWERPC_STUB_TOC_ENTRY_SIZE
;
1793 item
->next
= powerpc_stubs
;
1794 powerpc_stubs
= item
;
1802 struct powerpc_stub
*l
;
1804 /* Add the new symbols we just created to the symbol table. */
1805 *symbols_ptr
= (asymbol
**) xrealloc ((char *) *symbols_ptr
,
1806 ((symcount
+ stubcount
)
1807 * sizeof (asymbol
)));
1808 *symcount_ptr
+= stubcount
;
1809 s
= &(*symbols_ptr
)[symcount
];
1810 for (l
= powerpc_stubs
; l
!= (struct powerpc_stub
*) NULL
; l
= l
->next
)
1813 /* Set the size of the .stubs section and increase the size of
1814 the .got section. */
1815 if (! bfd_set_section_size (inbfd
, stub_sec
,
1816 stubcount
* POWERPC_STUB_SIZE
)
1817 || ! bfd_set_section_size (inbfd
, got_sec
,
1820 * POWERPC_STUB_TOC_ENTRY_SIZE
))))
1821 bfd_fatal ("stub section sizes");
1824 /* PowerPC NetWare requires a custom header. We create it here.
1825 The first word is the header version number, currently 1. The
1826 second word is the timestamp of the input file. */
1827 memcpy (nlm_custom_header (outbfd
)->stamp
, "CuStHeAd", 8);
1828 nlm_custom_header (outbfd
)->dataLength
= 8;
1829 nlm_custom_header (outbfd
)->data
= xmalloc (8);
1830 bfd_h_put_32 (outbfd
, (bfd_vma
) 1,
1831 (bfd_byte
*) nlm_custom_header (outbfd
)->data
);
1835 if (stat (bfd_get_filename (inbfd
), &s
) < 0)
1837 bfd_h_put_32 (outbfd
, (bfd_vma
) s
.st_mtime
,
1838 (bfd_byte
*) nlm_custom_header (outbfd
)->data
+ 4);
1842 /* Resolve all the stubs for PowerPC NetWare. We fill in the contents
1843 of the output section, and create new relocs in the TOC. */
1846 powerpc_resolve_stubs (inbfd
, outbfd
)
1850 bfd_byte buf
[POWERPC_STUB_SIZE
];
1852 unsigned int stubcount
;
1856 struct powerpc_stub
*l
;
1858 if (powerpc_stubs
== (struct powerpc_stub
*) NULL
)
1861 for (i
= 0; i
< POWERPC_STUB_INSN_COUNT
; i
++)
1862 bfd_put_32 (outbfd
, (bfd_vma
) powerpc_stub_insns
[i
], buf
+ i
* 4);
1864 got_sec
= bfd_get_section_by_name (inbfd
, ".got");
1865 assert (got_sec
!= (asection
*) NULL
);
1866 assert (got_sec
->output_section
->orelocation
== (arelent
**) NULL
);
1869 for (l
= powerpc_stubs
; l
!= (struct powerpc_stub
*) NULL
; l
= l
->next
)
1871 relocs
= (arelent
**) xmalloc (stubcount
* sizeof (arelent
*));
1874 for (l
= powerpc_stubs
; l
!= (struct powerpc_stub
*) NULL
; l
= l
->next
)
1878 /* Adjust the first instruction to use the right TOC index. */
1879 bfd_put_32 (outbfd
, (bfd_vma
) powerpc_stub_insns
[0] + l
->toc_index
, buf
);
1881 /* Write this stub out. */
1882 if (! bfd_set_section_contents (outbfd
,
1883 bfd_get_section (l
->start
),
1887 bfd_fatal ("writing stub");
1889 /* Create a new reloc for the TOC entry. */
1890 reloc
= (arelent
*) xmalloc (sizeof (arelent
));
1891 reloc
->sym_ptr_ptr
= &l
->reloc
;
1892 reloc
->address
= l
->toc_index
+ got_sec
->output_offset
;
1894 reloc
->howto
= bfd_reloc_type_lookup (inbfd
, BFD_RELOC_32
);
1899 bfd_set_reloc (outbfd
, got_sec
->output_section
, relocs
, stubcount
);
1902 /* Adjust relocation entries for PowerPC NetWare. We do not output
1903 TOC relocations. The object code already contains the offset from
1904 the TOC pointer. When the function is called, the TOC register,
1905 r2, will be set to the correct TOC value, so there is no need for
1906 any further reloc. */
1910 powerpc_mangle_relocs (outbfd
, insec
, relocs_ptr
, reloc_count_ptr
, contents
,
1914 register arelent
***relocs_ptr
;
1915 long *reloc_count_ptr
;
1917 bfd_size_type contents_size
;
1919 const reloc_howto_type
*toc_howto
;
1921 register arelent
**relocs
;
1924 toc_howto
= bfd_reloc_type_lookup (insec
->owner
, BFD_RELOC_PPC_TOC16
);
1925 if (toc_howto
== (reloc_howto_type
*) NULL
)
1928 /* If this is the .got section, clear out all the contents beyond
1929 the initial size. We must do this here because copy_sections is
1930 going to write out whatever we return in the contents field. */
1931 if (strcmp (bfd_get_section_name (insec
->owner
, insec
), ".got") == 0)
1932 memset (contents
+ powerpc_initial_got_size
, 0,
1933 (bfd_get_section_size_after_reloc (insec
)
1934 - powerpc_initial_got_size
));
1936 reloc_count
= *reloc_count_ptr
;
1937 relocs
= *relocs_ptr
;
1938 for (i
= 0; i
< reloc_count
; i
++)
1945 sym
= *rel
->sym_ptr_ptr
;
1947 /* We must be able to resolve all PC relative relocs at this
1948 point. If we get a branch to an undefined symbol we build a
1949 stub, since NetWare will resolve undefined symbols into a
1950 pointer to a function descriptor. */
1951 if (rel
->howto
->pc_relative
)
1953 /* This check for whether a symbol is in the same section as
1954 the reloc will be wrong if there is a PC relative reloc
1955 between two sections both of which were placed in the
1956 same output section. This should not happen. */
1957 if (bfd_get_section (sym
) != insec
->output_section
)
1958 fprintf (stderr
, "%s: unresolved PC relative reloc against %s\n",
1959 program_name
, bfd_asymbol_name (sym
));
1964 assert (rel
->howto
->size
== 2 && rel
->howto
->pcrel_offset
);
1965 val
= bfd_get_32 (outbfd
, (bfd_byte
*) contents
+ rel
->address
);
1966 val
= ((val
&~ rel
->howto
->dst_mask
)
1967 | (((val
& rel
->howto
->src_mask
)
1968 + (sym
->value
- rel
->address
)
1970 & rel
->howto
->dst_mask
));
1971 bfd_put_32 (outbfd
, val
, (bfd_byte
*) contents
+ rel
->address
);
1973 /* If this reloc is against an stubbed symbol and the
1976 then we replace the next instruction with
1978 This reloads the TOC pointer after a stub call. */
1979 if (bfd_asymbol_name (sym
)[0] == '.'
1980 && (sym
->flags
& BSF_DYNAMIC
) != 0
1981 && (bfd_get_32 (outbfd
,
1982 (bfd_byte
*) contents
+ rel
->address
+ 4)
1983 == 0x4ffffb82)) /* cror 31,31,31 */
1984 bfd_put_32 (outbfd
, (bfd_vma
) 0x80410014, /* lwz r2,20(r1) */
1985 (bfd_byte
*) contents
+ rel
->address
+ 4);
1989 memmove (relocs
, relocs
+ 1,
1990 (size_t) ((reloc_count
- 1) * sizeof (arelent
*)));
1995 /* When considering a TOC reloc, we do not want to include the
1996 symbol value. The symbol will be start of the TOC section
1997 (which is named .got). We do want to include the addend. */
1998 if (rel
->howto
== toc_howto
)
2001 symvalue
= sym
->value
;
2003 /* If this is a relocation against a symbol with a value, or
2004 there is a reloc addend, we need to update the addend in the
2006 if (symvalue
+ rel
->addend
!= 0)
2010 switch (rel
->howto
->size
)
2013 val
= bfd_get_16 (outbfd
,
2014 (bfd_byte
*) contents
+ rel
->address
);
2015 val
= ((val
&~ rel
->howto
->dst_mask
)
2016 | (((val
& rel
->howto
->src_mask
)
2019 & rel
->howto
->dst_mask
));
2020 if ((bfd_signed_vma
) val
< - 0x8000
2021 || (bfd_signed_vma
) val
>= 0x8000)
2023 "%s: overflow when adjusting relocation against %s\n",
2024 program_name
, bfd_asymbol_name (sym
));
2025 bfd_put_16 (outbfd
, val
, (bfd_byte
*) contents
+ rel
->address
);
2029 val
= bfd_get_32 (outbfd
,
2030 (bfd_byte
*) contents
+ rel
->address
);
2031 val
= ((val
&~ rel
->howto
->dst_mask
)
2032 | (((val
& rel
->howto
->src_mask
)
2035 & rel
->howto
->dst_mask
));
2036 bfd_put_32 (outbfd
, val
, (bfd_byte
*) contents
+ rel
->address
);
2043 rel
->sym_ptr_ptr
= bfd_get_section (sym
)->symbol_ptr_ptr
;
2047 /* Now that we have incorporated the addend, remove any TOC
2049 if (rel
->howto
== toc_howto
)
2053 memmove (relocs
, relocs
+ 1,
2054 (size_t) ((reloc_count
- i
) * sizeof (arelent
*)));
2058 rel
->address
+= insec
->output_offset
;
2061 /* end-sanitize-powerpc-netware */
2063 /* Name of linker. */
2065 #define LD_NAME "ld"
2068 /* Temporary file name base. */
2069 static char *temp_filename
;
2071 /* The user has specified several input files. Invoke the linker to
2072 link them all together, and convert and delete the resulting output
2076 link_inputs (inputs
, ld
)
2077 struct string_list
*inputs
;
2081 struct string_list
*q
;
2088 for (q
= inputs
; q
!= NULL
; q
= q
->next
)
2091 argv
= (char **) alloca (c
+ 5);
2098 /* Find the linker to invoke based on how nlmconv was run. */
2099 p
= program_name
+ strlen (program_name
);
2100 while (p
!= program_name
)
2104 ld
= (char *) xmalloc (p
- program_name
+ strlen (LD_NAME
) + 1);
2105 memcpy (ld
, program_name
, p
- program_name
);
2106 strcpy (ld
+ (p
- program_name
), LD_NAME
);
2115 ld
= (char *) LD_NAME
;
2117 choose_temp_base ();
2119 unlink_on_exit
= xmalloc (strlen (temp_filename
) + 3);
2120 sprintf (unlink_on_exit
, "%s.O", temp_filename
);
2123 argv
[1] = (char *) "-r";
2124 argv
[2] = (char *) "-o";
2125 argv
[3] = unlink_on_exit
;
2127 for (q
= inputs
; q
!= NULL
; q
= q
->next
, i
++)
2128 argv
[i
] = q
->string
;
2133 for (i
= 0; argv
[i
] != NULL
; i
++)
2134 fprintf (stderr
, " %s", argv
[i
]);
2135 fprintf (stderr
, "\n");
2138 pid
= pexecute (ld
, argv
);
2140 if (waitpid (pid
, &status
, 0) < 0)
2143 unlink (unlink_on_exit
);
2149 fprintf (stderr
, "%s: Execution of %s failed\n", program_name
, ld
);
2150 unlink (unlink_on_exit
);
2154 return unlink_on_exit
;
2157 /* Choose a temporary file name. Stolen from gcc.c. */
2160 choose_temp_base_try (try, base
)
2168 else if (try == NULL
)
2170 else if (access (try, R_OK
| W_OK
) != 0)
2180 const char *base
= NULL
;
2183 base
= choose_temp_base_try (getenv ("TMPDIR"), base
);
2184 base
= choose_temp_base_try (getenv ("TMP"), base
);
2185 base
= choose_temp_base_try (getenv ("TEMP"), base
);
2188 base
= choose_temp_base_try (P_tmpdir
, base
);
2191 base
= choose_temp_base_try ("/usr/tmp", base
);
2192 base
= choose_temp_base_try ("/tmp", base
);
2194 /* If all else fails, use the current directory! */
2198 len
= strlen (base
);
2199 temp_filename
= xmalloc (len
+ sizeof("/ccXXXXXX") + 1);
2200 strcpy (temp_filename
, base
);
2201 if (len
> 0 && temp_filename
[len
-1] != '/')
2202 temp_filename
[len
++] = '/';
2203 strcpy (temp_filename
+ len
, "ccXXXXXX");
2205 mktemp (temp_filename
);
2206 if (*temp_filename
== '\0')
2210 /* Execute a job. Stolen from gcc.c. */
2216 pexecute (program
, argv
)
2224 scmd
= (char *)malloc (strlen (program
) + strlen (temp_filename
) + 10);
2225 rf
= scmd
+ strlen(program
) + 2 + el
;
2226 sprintf (scmd
, "%s.exe @%s.gp", program
, temp_filename
);
2227 argfile
= fopen (rf
, "w");
2229 pfatal_with_name (rf
);
2231 for (i
=1; argv
[i
]; i
++)
2234 for (cp
= argv
[i
]; *cp
; cp
++)
2236 if (*cp
== '"' || *cp
== '\'' || *cp
== '\\' || isspace (*cp
))
2237 fputc ('\\', argfile
);
2238 fputc (*cp
, argfile
);
2240 fputc ('\n', argfile
);
2251 return MIN_FATAL_STATUS
<< 8;
2257 #else /* not __MSDOS__ */
2260 pexecute (program
, argv
)
2265 int retries
, sleep_interval
;
2267 /* Fork a subprocess; wait and retry if it fails. */
2269 for (retries
= 0; retries
< 4; retries
++)
2274 sleep (sleep_interval
);
2275 sleep_interval
*= 2;
2291 /* Exec the program. */
2292 execvp (program
, argv
);
2299 /* Return child's process number. */
2304 #endif /* not __MSDOS__ */
2308 pexecute (program
, argv
)
2312 return spawnvp (1, program
, argv
);
2314 #endif /* not OS2 */