/* nlmconv.c -- NLM conversion program
- Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002
- Free Software Foundation, Inc.
+ Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
+ 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
This file is part of GNU Binutils.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
+ Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
+ MA 02110-1301, USA. */
+
/* Written by Ian Lance Taylor <ian@cygnus.com>.
#endif
#endif
+#include "sysdep.h"
#include "bfd.h"
#include "libiberty.h"
-#include "bucomm.h"
#include "safe-ctype.h"
#include "ansidecl.h"
#include "coff/ecoff.h"
#endif
+#include "bucomm.h"
+
/* If strerror is just a macro, we want to use the one from libiberty
since it will handle undefined values. */
#undef strerror
-extern char *strerror PARAMS ((int));
-
-#ifndef localtime
-extern struct tm *localtime ();
-#endif
+extern char *strerror (int);
#ifndef SEEK_SET
#define SEEK_SET 0
/* Local routines. */
-int main PARAMS ((int, char **));
+int main (int, char **);
-static void show_usage
- PARAMS ((FILE *, int));
+static void show_usage (FILE *, int);
static const char *select_output_format
- PARAMS ((enum bfd_architecture, unsigned long, bfd_boolean));
-static void setup_sections
- PARAMS ((bfd *, asection *, PTR));
-static void copy_sections
- PARAMS ((bfd *, asection *, PTR));
+ (enum bfd_architecture, unsigned long, bfd_boolean);
+static void setup_sections (bfd *, asection *, void *);
+static void copy_sections (bfd *, asection *, void *);
static void mangle_relocs
- PARAMS ((bfd *, asection *, arelent ***, long *, char *, bfd_size_type));
+ (bfd *, asection *, arelent ***, long *, char *, bfd_size_type);
static void default_mangle_relocs
- PARAMS ((bfd *, asection *, arelent ***, long *, char *, bfd_size_type));
-static char *link_inputs
- PARAMS ((struct string_list *, char *));
+ (bfd *, asection *, arelent ***, long *, char *, bfd_size_type);
+static char *link_inputs (struct string_list *, char *, char *);
#ifdef NLMCONV_I386
-static void i386_mangle_relocs
- PARAMS ((bfd *, asection *, arelent ***, long *, char *, bfd_size_type));
+static void i386_mangle_relocs (bfd *, asection *, arelent ***, long *, char *, bfd_size_type);
#endif
#ifdef NLMCONV_ALPHA
-static void alpha_mangle_relocs
- PARAMS ((bfd *, asection *, arelent ***, long *, char *, bfd_size_type));
+static void alpha_mangle_relocs (bfd *, asection *, arelent ***, long *, char *, bfd_size_type);
#endif
#ifdef NLMCONV_POWERPC
-static void powerpc_build_stubs
- PARAMS ((bfd *, bfd *, asymbol ***, long *));
-static void powerpc_resolve_stubs
- PARAMS ((bfd *, bfd *));
-static void powerpc_mangle_relocs
- PARAMS ((bfd *, asection *, arelent ***, long *, char *, bfd_size_type));
+static void powerpc_build_stubs (bfd *, bfd *, asymbol ***, long *);
+static void powerpc_resolve_stubs (bfd *, bfd *);
+static void powerpc_mangle_relocs (bfd *, asection *, arelent ***, long *, char *, bfd_size_type);
#endif
\f
/* The main routine. */
int
-main (argc, argv)
- int argc;
- char **argv;
+main (int argc, char **argv)
{
int opt;
char *input_file = NULL;
bfd *sharedbfd;
size_t shared_offset = 0;
size_t shared_size = 0;
- Nlm_Internal_Fixed_Header sharedhdr;
+ static Nlm_Internal_Fixed_Header sharedhdr;
int len;
char *modname;
char **matching;
program_name = argv[0];
xmalloc_set_program_name (program_name);
+ expandargv (&argc, &argv);
+
bfd_init ();
set_default_bfd_target ();
/* Initialize the header information to default values. */
fixed_hdr = &fixed_hdr_struct;
- memset ((PTR) &fixed_hdr_struct, 0, sizeof fixed_hdr_struct);
+ memset ((void *) &fixed_hdr_struct, 0, sizeof fixed_hdr_struct);
var_hdr = &var_hdr_struct;
- memset ((PTR) &var_hdr_struct, 0, sizeof var_hdr_struct);
+ memset ((void *) &var_hdr_struct, 0, sizeof var_hdr_struct);
version_hdr = &version_hdr_struct;
- memset ((PTR) &version_hdr_struct, 0, sizeof version_hdr_struct);
+ memset ((void *) &version_hdr_struct, 0, sizeof version_hdr_struct);
copyright_hdr = ©right_hdr_struct;
- memset ((PTR) ©right_hdr_struct, 0, sizeof copyright_hdr_struct);
+ memset ((void *) ©right_hdr_struct, 0, sizeof copyright_hdr_struct);
extended_hdr = &extended_hdr_struct;
- memset ((PTR) &extended_hdr_struct, 0, sizeof extended_hdr_struct);
+ memset ((void *) &extended_hdr_struct, 0, sizeof extended_hdr_struct);
check_procedure = NULL;
custom_file = NULL;
debug_info = FALSE;
if (input_files->next == NULL)
input_file = input_files->string;
else
- input_file = link_inputs (input_files, ld_arg);
+ input_file = link_inputs (input_files, ld_arg, map_file);
}
else if (input_file == NULL)
{
assert (bfd_get_flavour (outbfd) == bfd_target_nlm_flavour);
- if (bfd_arch_get_compatible (inbfd, outbfd) == NULL)
+ /* XXX: Should we accept the unknown bfd format here ? */
+ if (bfd_arch_get_compatible (inbfd, outbfd, TRUE) == NULL)
non_fatal (_("warning: input and output formats are not compatible"));
/* Move the values read from the command file into outbfd. */
bss_sec = bfd_get_section_by_name (outbfd, NLM_UNINITIALIZED_DATA_NAME);
if (bss_sec == NULL)
{
- bss_sec = bfd_make_section (outbfd, NLM_UNINITIALIZED_DATA_NAME);
+ bss_sec = bfd_make_section_with_flags (outbfd,
+ NLM_UNINITIALIZED_DATA_NAME,
+ SEC_ALLOC);
if (bss_sec == NULL
- || ! bfd_set_section_flags (outbfd, bss_sec, SEC_ALLOC)
|| ! bfd_set_section_alignment (outbfd, bss_sec, 1))
bfd_fatal (_("make .bss section"));
}
so that programs which understand it can resurrect the original
sections from the NLM. We will put a pointer to .nlmsections in
the NLM header area. */
- secsec = bfd_make_section (outbfd, ".nlmsections");
+ secsec = bfd_make_section_with_flags (outbfd, ".nlmsections",
+ SEC_HAS_CONTENTS);
if (secsec == NULL)
bfd_fatal (_("make .nlmsections section"));
- if (! bfd_set_section_flags (outbfd, secsec, SEC_HAS_CONTENTS))
- bfd_fatal (_("set .nlmsections flags"));
#ifdef NLMCONV_POWERPC
/* For PowerPC NetWare we need to build stubs for calls to undefined
#endif
/* Set up the sections. */
- bfd_map_over_sections (inbfd, setup_sections, (PTR) outbfd);
+ bfd_map_over_sections (inbfd, setup_sections, (void *) outbfd);
text_sec = bfd_get_section_by_name (outbfd, NLM_CODE_NAME);
{
bfd_size_type add;
- vma = bfd_get_section_size_before_reloc (data_sec);
+ vma = bfd_get_section_size (data_sec);
align = 1 << bss_sec->alignment_power;
add = ((vma + align - 1) &~ (align - 1)) - vma;
vma += add;
{
bfd_size_type data_size;
- data_size = bfd_get_section_size_before_reloc (data_sec);
+ data_size = bfd_get_section_size (data_sec);
if (! bfd_set_section_size (outbfd, data_sec, data_size + add))
bfd_fatal (_("set .data size"));
}
endsym = NULL;
for (i = 0; i < symcount; i++)
{
- register asymbol *sym;
+ asymbol *sym;
sym = symbols[i];
symbols into the .bss section, and mark them as exported. */
if (bfd_is_com_section (bfd_get_section (sym)))
{
- bfd_vma size;
+ bfd_vma size = sym->value;
sym->section = bss_sec;
- size = sym->value;
- sym->value = bss_sec->_raw_size;
- bss_sec->_raw_size += size;
+ sym->value = bfd_get_section_size (bss_sec);
+ size += sym->value;
align = 1 << bss_sec->alignment_power;
- bss_sec->_raw_size = (bss_sec->_raw_size + align - 1) &~ (align - 1);
+ size = (size + align - 1) & ~(align - 1);
+ bfd_set_section_size (outbfd, bss_sec, size);
sym->flags |= BSF_EXPORT | BSF_GLOBAL;
}
else if (bfd_get_section (sym)->output_section != NULL)
/* If this is a global symbol, check the export list. */
if ((sym->flags & (BSF_EXPORT | BSF_GLOBAL)) != 0)
{
- register struct string_list *l;
+ struct string_list *l;
int found_simple;
/* Unfortunately, a symbol can appear multiple times on the
{
newsymalloc += 10;
newsyms = ((asymbol **)
- xrealloc ((PTR) newsyms,
+ xrealloc ((void *) newsyms,
(newsymalloc
* sizeof (asymbol *))));
}
Change the prefix if necessary. */
if (bfd_is_und_section (bfd_get_section (sym)))
{
- register struct string_list *l;
+ struct string_list *l;
for (l = import_symbols; l != NULL; l = l->next)
{
if (endsym != NULL)
{
- endsym->value = bfd_get_section_size_before_reloc (bss_sec);
+ endsym->value = bfd_get_section_size (bss_sec);
/* FIXME: If any relocs referring to _end use inplace addends,
then I think they need to be updated. This is handled by
else
{
custom_size = st.st_size;
- custom_section = bfd_make_section (outbfd, ".nlmcustom");
+ custom_section = bfd_make_section_with_flags (outbfd, ".nlmcustom",
+ SEC_HAS_CONTENTS);
if (custom_section == NULL
- || ! bfd_set_section_size (outbfd, custom_section, custom_size)
- || ! bfd_set_section_flags (outbfd, custom_section,
- SEC_HAS_CONTENTS))
+ || ! bfd_set_section_size (outbfd, custom_section, custom_size))
bfd_fatal (_("custom section"));
}
}
else
{
help_size = st.st_size;
- help_section = bfd_make_section (outbfd, ".nlmhelp");
+ help_section = bfd_make_section_with_flags (outbfd, ".nlmhelp",
+ SEC_HAS_CONTENTS);
if (help_section == NULL
- || ! bfd_set_section_size (outbfd, help_section, help_size)
- || ! bfd_set_section_flags (outbfd, help_section,
- SEC_HAS_CONTENTS))
+ || ! bfd_set_section_size (outbfd, help_section, help_size))
bfd_fatal (_("help section"));
- strncpy (nlm_extended_header (outbfd)->stamp, "MeSsAgEs", 8);
+ LITMEMCPY (nlm_extended_header (outbfd)->stamp, "MeSsAgEs");
}
}
if (message_file != NULL)
else
{
message_size = st.st_size;
- message_section = bfd_make_section (outbfd, ".nlmmessages");
+ message_section = bfd_make_section_with_flags (outbfd,
+ ".nlmmessages",
+ SEC_HAS_CONTENTS);
if (message_section == NULL
- || ! bfd_set_section_size (outbfd, message_section, message_size)
- || ! bfd_set_section_flags (outbfd, message_section,
- SEC_HAS_CONTENTS))
+ || ! bfd_set_section_size (outbfd, message_section, message_size))
bfd_fatal (_("message section"));
- strncpy (nlm_extended_header (outbfd)->stamp, "MeSsAgEs", 8);
+ LITMEMCPY (nlm_extended_header (outbfd)->stamp, "MeSsAgEs");
}
}
if (modules != NULL)
module_size = 0;
for (l = modules; l != NULL; l = l->next)
module_size += strlen (l->string) + 1;
- module_section = bfd_make_section (outbfd, ".nlmmodules");
+ module_section = bfd_make_section_with_flags (outbfd, ".nlmmodules",
+ SEC_HAS_CONTENTS);
if (module_section == NULL
- || ! bfd_set_section_size (outbfd, module_section, module_size)
- || ! bfd_set_section_flags (outbfd, module_section,
- SEC_HAS_CONTENTS))
+ || ! bfd_set_section_size (outbfd, module_section, module_size))
bfd_fatal (_("module section"));
}
if (rpc_file != NULL)
else
{
rpc_size = st.st_size;
- rpc_section = bfd_make_section (outbfd, ".nlmrpc");
+ rpc_section = bfd_make_section_with_flags (outbfd, ".nlmrpc",
+ SEC_HAS_CONTENTS);
if (rpc_section == NULL
- || ! bfd_set_section_size (outbfd, rpc_section, rpc_size)
- || ! bfd_set_section_flags (outbfd, rpc_section,
- SEC_HAS_CONTENTS))
+ || ! bfd_set_section_size (outbfd, rpc_section, rpc_size))
bfd_fatal (_("rpc section"));
- strncpy (nlm_extended_header (outbfd)->stamp, "MeSsAgEs", 8);
+ LITMEMCPY (nlm_extended_header (outbfd)->stamp, "MeSsAgEs");
}
}
if (sharelib_file != NULL)
if (shared_offset > (size_t) sharedhdr.publicsOffset)
shared_offset = sharedhdr.publicsOffset;
shared_size = st.st_size - shared_offset;
- shared_section = bfd_make_section (outbfd, ".nlmshared");
+ shared_section = bfd_make_section_with_flags (outbfd,
+ ".nlmshared",
+ SEC_HAS_CONTENTS);
if (shared_section == NULL
|| ! bfd_set_section_size (outbfd, shared_section,
- shared_size)
- || ! bfd_set_section_flags (outbfd, shared_section,
- SEC_HAS_CONTENTS))
+ shared_size))
bfd_fatal (_("shared section"));
- strncpy (nlm_extended_header (outbfd)->stamp, "MeSsAgEs", 8);
+ LITMEMCPY (nlm_extended_header (outbfd)->stamp, "MeSsAgEs");
}
}
}
/* Check whether a version was given. */
- if (strncmp (version_hdr->stamp, "VeRsIoN#", 8) != 0)
+ if (!CONST_STRNEQ (version_hdr->stamp, "VeRsIoN#"))
non_fatal (_("warning: No version number given"));
/* At least for now, always create an extended header, because that
is what NLMLINK does. */
- strncpy (nlm_extended_header (outbfd)->stamp, "MeSsAgEs", 8);
+ LITMEMCPY (nlm_extended_header (outbfd)->stamp, "MeSsAgEs");
- strncpy (nlm_cygnus_ext_header (outbfd)->stamp, "CyGnUsEx", 8);
+ LITMEMCPY (nlm_cygnus_ext_header (outbfd)->stamp, "CyGnUsEx");
/* If the date was not given, force it in. */
if (nlm_version_header (outbfd)->month == 0
nlm_version_header (outbfd)->month = ptm->tm_mon + 1;
nlm_version_header (outbfd)->day = ptm->tm_mday;
nlm_version_header (outbfd)->year = ptm->tm_year + 1900;
- strncpy (version_hdr->stamp, "VeRsIoN#", 8);
+ LITMEMCPY (version_hdr->stamp, "VeRsIoN#");
}
#ifdef NLMCONV_POWERPC
#endif
/* Copy over the sections. */
- bfd_map_over_sections (inbfd, copy_sections, (PTR) outbfd);
+ bfd_map_over_sections (inbfd, copy_sections, (void *) outbfd);
/* Finish up the header information. */
if (custom_file != NULL)
{
- PTR data;
+ void *data;
data = xmalloc (custom_size);
if (fread (data, 1, custom_size, custom_data) != custom_size)
export information and the debugging information. */
nlm_fixed_header (outbfd)->debugInfoOffset = (file_ptr) -1;
}
- if (map_file != NULL)
- non_fatal (_("warning: MAP and FULLMAP are not supported; try ld -M"));
+ if (full_map)
+ non_fatal (_("warning: FULLMAP is not supported; try ld -M"));
if (help_file != NULL)
{
- PTR data;
+ void *data;
data = xmalloc (help_size);
if (fread (data, 1, help_size, help_data) != help_size)
}
if (message_file != NULL)
{
- PTR data;
+ void *data;
data = xmalloc (message_size);
if (fread (data, 1, message_size, message_data) != message_size)
}
if (modules != NULL)
{
- PTR data;
+ void *data;
unsigned char *set;
struct string_list *l;
bfd_size_type c;
for (l = modules; l != NULL; l = l->next)
{
*set = strlen (l->string);
- strncpy (set + 1, l->string, *set);
+ strncpy ((char *) set + 1, l->string, *set);
set += *set + 1;
++c;
}
}
if (rpc_file != NULL)
{
- PTR data;
+ void *data;
data = xmalloc (rpc_size);
if (fread (data, 1, rpc_size, rpc_data) != rpc_size)
}
if (sharelib_file != NULL)
{
- PTR data;
+ void *data;
data = xmalloc (shared_size);
if (fseek (shared_data, shared_offset, SEEK_SET) != 0
sharedhdr.exitProcedureOffset;
free (data);
}
- len = strlen (output_file);
- if (len > NLM_MODULE_NAME_SIZE - 2)
- len = NLM_MODULE_NAME_SIZE - 2;
- nlm_fixed_header (outbfd)->moduleName[0] = len;
-
- strncpy (nlm_fixed_header (outbfd)->moduleName + 1, output_file,
- NLM_MODULE_NAME_SIZE - 2);
- nlm_fixed_header (outbfd)->moduleName[NLM_MODULE_NAME_SIZE - 1] = '\0';
- for (modname = nlm_fixed_header (outbfd)->moduleName;
- *modname != '\0';
- modname++)
- *modname = TOUPPER (*modname);
+
+ {
+ const int max_len = NLM_MODULE_NAME_SIZE - 2;
+ const char * filename = lbasename (output_file);
+
+ len = strlen (filename);
+ if (len > max_len)
+ len = max_len;
+ nlm_fixed_header (outbfd)->moduleName[0] = len;
+
+ strncpy (nlm_fixed_header (outbfd)->moduleName + 1, filename, max_len);
+ nlm_fixed_header (outbfd)->moduleName[max_len + 1] = '\0';
+
+ for (modname = nlm_fixed_header (outbfd)->moduleName;
+ *modname != '\0';
+ modname++)
+ *modname = TOUPPER (*modname);
+ }
strncpy (nlm_variable_header (outbfd)->oldThreadName, " LONG",
NLM_OLD_THREAD_NAME_LENGTH);
/* Show a usage message and exit. */
static void
-show_usage (file, status)
- FILE *file;
- int status;
+show_usage (FILE *file, int status)
{
fprintf (file, _("Usage: %s [option(s)] [in-file [out-file]]\n"), program_name);
fprintf (file, _(" Convert an object file into a NetWare Loadable Module\n"));
-T --header-file=<file> Read <file> for NLM header information\n\
-l --linker=<linker> Use <linker> for any linking\n\
-d --debug Display on stderr the linker command line\n\
+ @<file> Read options from <file>.\n\
-h --help Display this information\n\
-v --version Display the program's version\n\
"));
- if (status == 0)
+ if (REPORT_BUGS_TO[0] && status == 0)
fprintf (file, _("Report bugs to %s\n"), REPORT_BUGS_TO);
exit (status);
}
and endianness. This chooses the appropriate NLM target. */
static const char *
-select_output_format (arch, mach, bigendian)
- enum bfd_architecture arch;
- unsigned long mach;
- bfd_boolean bigendian ATTRIBUTE_UNUSED;
+select_output_format (enum bfd_architecture arch, unsigned long mach,
+ bfd_boolean bigendian ATTRIBUTE_UNUSED)
{
switch (arch)
{
name, size, etc. */
static void
-setup_sections (inbfd, insec, data_ptr)
- bfd *inbfd ATTRIBUTE_UNUSED;
- asection *insec;
- PTR data_ptr;
+setup_sections (bfd *inbfd ATTRIBUTE_UNUSED, asection *insec, void *data_ptr)
{
bfd *outbfd = (bfd *) data_ptr;
flagword f;
/* Copy the section contents. */
static void
-copy_sections (inbfd, insec, data_ptr)
- bfd *inbfd;
- asection *insec;
- PTR data_ptr;
+copy_sections (bfd *inbfd, asection *insec, void *data_ptr)
{
static bfd_size_type secsecoff = 0;
bfd *outbfd = (bfd *) data_ptr;
const char *inname;
asection *outsec;
bfd_size_type size;
- PTR contents;
+ void *contents;
long reloc_size;
bfd_byte buf[4];
bfd_size_type add;
outsec = insec->output_section;
assert (outsec != NULL);
- size = bfd_get_section_size_before_reloc (insec);
-
- /* FIXME: Why are these necessary? */
- insec->_cooked_size = insec->_raw_size;
- insec->reloc_done = TRUE;
+ size = bfd_get_section_size (insec);
if ((bfd_get_section_flags (inbfd, insec) & SEC_HAS_CONTENTS) == 0)
contents = NULL;
}
/* Add this section to .nlmsections. */
- if (! bfd_set_section_contents (outbfd, secsec, (PTR) inname, secsecoff,
+ if (! bfd_set_section_contents (outbfd, secsec, (void *) inname, secsecoff,
strlen (inname) + 1))
bfd_fatal (_("set .nlmsection contents"));
secsecoff += strlen (inname) + 1;
by the input formats. */
static void
-mangle_relocs (outbfd, insec, relocs_ptr, reloc_count_ptr, contents,
- contents_size)
- bfd *outbfd;
- asection *insec;
- arelent ***relocs_ptr;
- long *reloc_count_ptr;
- char *contents;
- bfd_size_type contents_size;
+mangle_relocs (bfd *outbfd, asection *insec, arelent ***relocs_ptr,
+ long *reloc_count_ptr, char *contents,
+ bfd_size_type contents_size)
{
switch (bfd_get_arch (outbfd))
{
the output_offset. */
static void
-default_mangle_relocs (outbfd, insec, relocs_ptr, reloc_count_ptr, contents,
- contents_size)
- bfd *outbfd ATTRIBUTE_UNUSED;
- asection *insec;
- arelent ***relocs_ptr;
- long *reloc_count_ptr;
- char *contents ATTRIBUTE_UNUSED;
- bfd_size_type contents_size ATTRIBUTE_UNUSED;
+default_mangle_relocs (bfd *outbfd ATTRIBUTE_UNUSED, asection *insec,
+ arelent ***relocs_ptr, long *reloc_count_ptr,
+ char *contents ATTRIBUTE_UNUSED,
+ bfd_size_type contents_size ATTRIBUTE_UNUSED)
{
if (insec->output_offset != 0)
{
long reloc_count;
- register arelent **relocs;
- register long i;
+ arelent **relocs;
+ long i;
reloc_count = *reloc_count_ptr;
relocs = *relocs_ptr;
TRUE); /* pcrel_offset */
static void
-i386_mangle_relocs (outbfd, insec, relocs_ptr, reloc_count_ptr, contents,
- contents_size)
- bfd *outbfd;
- asection *insec;
- arelent ***relocs_ptr;
- long *reloc_count_ptr;
- char *contents;
- bfd_size_type contents_size;
+i386_mangle_relocs (bfd *outbfd, asection *insec, arelent ***relocs_ptr,
+ long *reloc_count_ptr, char *contents,
+ bfd_size_type contents_size)
{
long reloc_count, i;
arelent **relocs;
FALSE); /* pcrel_offset */
static void
-alpha_mangle_relocs (outbfd, insec, relocs_ptr, reloc_count_ptr, contents,
- contents_size)
- bfd *outbfd;
- asection *insec;
- register arelent ***relocs_ptr;
- long *reloc_count_ptr;
- char *contents ATTRIBUTE_UNUSED;
- bfd_size_type contents_size ATTRIBUTE_UNUSED;
+alpha_mangle_relocs (bfd *outbfd, asection *insec,
+ arelent ***relocs_ptr, long *reloc_count_ptr,
+ char *contents ATTRIBUTE_UNUSED,
+ bfd_size_type contents_size ATTRIBUTE_UNUSED)
{
long old_reloc_count;
arelent **old_relocs;
- register arelent **relocs;
+ arelent **relocs;
old_reloc_count = *reloc_count_ptr;
old_relocs = *relocs_ptr;
++relocs;
++(*reloc_count_ptr);
- memcpy ((PTR) relocs, (PTR) old_relocs,
- (size_t) old_reloc_count * sizeof (arelent *));
+ memcpy (relocs, old_relocs, (size_t) old_reloc_count * sizeof (arelent *));
relocs[old_reloc_count] = (arelent *) NULL;
free (old_relocs);
if (insec->output_offset != 0)
{
- register bfd_size_type i;
+ bfd_size_type i;
for (i = 0; i < (bfd_size_type) old_reloc_count; i++, relocs++)
(*relocs)->address += insec->output_offset;
build a stub for each one. */
static void
-powerpc_build_stubs (inbfd, outbfd, symbols_ptr, symcount_ptr)
- bfd *inbfd;
- bfd *outbfd ATTRIBUTE_UNUSED;
- asymbol ***symbols_ptr;
- long *symcount_ptr;
+powerpc_build_stubs (bfd *inbfd, bfd *outbfd ATTRIBUTE_UNUSED,
+ asymbol ***symbols_ptr, long *symcount_ptr)
{
asection *stub_sec;
asection *got_sec;
/* Make a section to hold stubs. We don't set SEC_HAS_CONTENTS for
the section to prevent copy_sections from reading from it. */
- stub_sec = bfd_make_section (inbfd, ".stubs");
+ stub_sec = bfd_make_section_with_flags (inbfd, ".stubs",
+ (SEC_CODE
+ | SEC_RELOC
+ | SEC_ALLOC
+ | SEC_LOAD));
if (stub_sec == (asection *) NULL
- || ! bfd_set_section_flags (inbfd, stub_sec,
- (SEC_CODE
- | SEC_RELOC
- | SEC_ALLOC
- | SEC_LOAD))
|| ! bfd_set_section_alignment (inbfd, stub_sec, 2))
bfd_fatal (".stubs");
got_sec = bfd_get_section_by_name (inbfd, ".got");
if (got_sec == (asection *) NULL)
{
- got_sec = bfd_make_section (inbfd, ".got");
+ got_sec = bfd_make_section_with_flags (inbfd, ".got",
+ (SEC_DATA
+ | SEC_RELOC
+ | SEC_ALLOC
+ | SEC_LOAD
+ | SEC_HAS_CONTENTS));
if (got_sec == (asection *) NULL
- || ! bfd_set_section_flags (inbfd, got_sec,
- (SEC_DATA
- | SEC_RELOC
- | SEC_ALLOC
- | SEC_LOAD
- | SEC_HAS_CONTENTS))
|| ! bfd_set_section_alignment (inbfd, got_sec, 2))
bfd_fatal (".got");
}
/* Make a new undefined symbol with the same name but without
the leading `.'. */
- newsym = (asymbol *) xmalloc (sizeof (asymbol));
+ newsym = xmalloc (sizeof (asymbol));
*newsym = *sym;
- newname = (char *) xmalloc (strlen (bfd_asymbol_name (sym)));
+ newname = xmalloc (strlen (bfd_asymbol_name (sym)));
strcpy (newname, bfd_asymbol_name (sym) + 1);
newsym->name = newname;
of the output section, and create new relocs in the TOC. */
static void
-powerpc_resolve_stubs (inbfd, outbfd)
- bfd *inbfd;
- bfd *outbfd;
+powerpc_resolve_stubs (bfd *inbfd, bfd *outbfd)
{
bfd_byte buf[POWERPC_STUB_SIZE];
unsigned int i;
any further reloc. */
static void
-powerpc_mangle_relocs (outbfd, insec, relocs_ptr, reloc_count_ptr, contents,
- contents_size)
- bfd *outbfd;
- asection *insec;
- register arelent ***relocs_ptr;
- long *reloc_count_ptr;
- char *contents;
- bfd_size_type contents_size ATTRIBUTE_UNUSED;
+powerpc_mangle_relocs (bfd *outbfd, asection *insec,
+ arelent ***relocs_ptr,
+ long *reloc_count_ptr, char *contents,
+ bfd_size_type contents_size ATTRIBUTE_UNUSED)
{
reloc_howto_type *toc_howto;
long reloc_count;
- register arelent **relocs;
- register long i;
+ arelent **relocs;
+ long i;
toc_howto = bfd_reloc_type_lookup (insec->owner, BFD_RELOC_PPC_TOC16);
if (toc_howto == (reloc_howto_type *) NULL)
going to write out whatever we return in the contents field. */
if (strcmp (bfd_get_section_name (insec->owner, insec), ".got") == 0)
memset (contents + powerpc_initial_got_size, 0,
- (size_t) (bfd_get_section_size_after_reloc (insec)
- - powerpc_initial_got_size));
+ (size_t) (bfd_get_section_size (insec) - powerpc_initial_got_size));
reloc_count = *reloc_count_ptr;
relocs = *relocs_ptr;
file. */
static char *
-link_inputs (inputs, ld)
- struct string_list *inputs;
- char *ld;
+link_inputs (struct string_list *inputs, char *ld, char * map_file)
{
size_t c;
struct string_list *q;
for (q = inputs; q != NULL; q = q->next)
++c;
- argv = (char **) alloca ((c + 5) * sizeof(char *));
+ argv = (char **) alloca ((c + 7) * sizeof (char *));
#ifndef __MSDOS__
if (ld == NULL)
argv[1] = (char *) "-Ur";
argv[2] = (char *) "-o";
argv[3] = unlink_on_exit;
- i = 4;
+ /* If we have been given the name of a mapfile and that
+ name is not 'stderr' then pass it on to the linker. */
+ if (map_file
+ && * map_file
+ && strcmp (map_file, "stderr") == 0)
+ {
+ argv[4] = (char *) "-Map";
+ argv[5] = map_file;
+ i = 6;
+ }
+ else
+ i = 4;
+
for (q = inputs; q != NULL; q = q->next, i++)
argv[i] = q->string;
argv[i] = NULL;