/* Main program of GNU linker.
- Copyright (C) 1991-2016 Free Software Foundation, Inc.
+ Copyright (C) 1991-2017 Free Software Foundation, Inc.
Written by Steve Chamberlain steve@cygnus.com
This file is part of the GNU Binutils.
const char *ld_sysroot;
/* The canonical representation of ld_sysroot. */
-char * ld_canon_sysroot;
+char *ld_canon_sysroot;
int ld_canon_sysroot_len;
/* Set by -G argument, for targets like MIPS ELF. */
(int, char **);
static bfd_boolean add_archive_element
(struct bfd_link_info *, bfd *, const char *, bfd **);
-static bfd_boolean multiple_definition
+static void multiple_definition
(struct bfd_link_info *, struct bfd_link_hash_entry *,
bfd *, asection *, bfd_vma);
-static bfd_boolean multiple_common
+static void multiple_common
(struct bfd_link_info *, struct bfd_link_hash_entry *,
bfd *, enum bfd_link_hash_type, bfd_vma);
-static bfd_boolean add_to_set
+static void add_to_set
(struct bfd_link_info *, struct bfd_link_hash_entry *,
bfd_reloc_code_real_type, bfd *, asection *, bfd_vma);
-static bfd_boolean constructor_callback
+static void constructor_callback
(struct bfd_link_info *, bfd_boolean, const char *, bfd *,
asection *, bfd_vma);
-static bfd_boolean warning_callback
+static void warning_callback
(struct bfd_link_info *, const char *, const char *, bfd *,
asection *, bfd_vma);
static void warning_find_reloc
(bfd *, asection *, void *);
-static bfd_boolean undefined_symbol
+static void undefined_symbol
(struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma,
bfd_boolean);
-static bfd_boolean reloc_overflow
+static void reloc_overflow
(struct bfd_link_info *, struct bfd_link_hash_entry *, const char *,
const char *, bfd_vma, bfd *, asection *, bfd_vma);
-static bfd_boolean reloc_dangerous
+static void reloc_dangerous
(struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma);
-static bfd_boolean unattached_reloc
+static void unattached_reloc
(struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma);
static bfd_boolean notice
(struct bfd_link_info *, struct bfd_link_hash_entry *,
};
static bfd_assert_handler_type default_bfd_assert_handler;
+static bfd_error_handler_type default_bfd_error_handler;
struct bfd_link_info link_info;
\f
unlink_if_ordinary (output_filename);
}
-/* If there's a BFD assertion, we'll notice and exit with an error
- unless otherwise instructed. */
+/* Hook to notice BFD assertions. */
static void
ld_bfd_assert_handler (const char *fmt, const char *bfdver,
const char *file, int line)
{
- (*default_bfd_assert_handler) (fmt, bfdver, file, line);
config.make_executable = FALSE;
+ (*default_bfd_assert_handler) (fmt, bfdver, file, line);
+}
+
+/* Hook the bfd error/warning handler for --fatal-warnings. */
+
+static void
+ld_bfd_error_handler (const char *fmt, va_list ap)
+{
+ if (config.fatal_warnings)
+ config.make_executable = FALSE;
+ (*default_bfd_error_handler) (fmt, ap);
}
int
leave no trace. */
default_bfd_assert_handler = bfd_set_assert_handler (ld_bfd_assert_handler);
+ /* Also hook the bfd error/warning handler for --fatal-warnings. */
+ default_bfd_error_handler = bfd_set_error_handler (ld_bfd_error_handler);
+
xatexit (ld_cleanup);
/* Set up the sysroot directory. */
this permits the linker to be configured for a particular target,
and linked against a shared BFD library which was configured for
a different target. The macro TARGET is defined by Makefile. */
- if (! bfd_set_default_target (TARGET))
+ if (!bfd_set_default_target (TARGET))
{
einfo (_("%X%P: can't set BFD default target to `%s': %E\n"), TARGET);
xexit (1);
#ifdef DEFAULT_FLAG_COMPRESS_DEBUG
link_info.compress_debug = COMPRESS_DEBUG_GABI_ZLIB;
#endif
+#ifdef DEFAULT_NEW_DTAGS
+ link_info.new_dtags = TRUE;
+#endif
ldfile_add_arch ("");
emulation = get_emulation (argc, argv);
while ((n = fread (buf, 1, ld_bufsz - 1, saved_script_handle)) > 0)
{
buf[n] = 0;
- info_msg (buf);
+ info_msg ("%s", buf);
}
rewind (saved_script_handle);
free (buf);
lang_print_memory_usage ();
#if 0
{
- struct bfd_link_hash_entry * h;
+ struct bfd_link_hash_entry *h;
h = bfd_link_hash_lookup (link_info.hash, "__image_base__", 0,0,1);
fprintf (stderr, "lookup = %p val %lx\n", h, h ? h->u.def.value : 1);
}
else
{
- if (! bfd_close (link_info.output_bfd))
+ if (!bfd_close (link_info.output_bfd))
einfo (_("%F%B: final close failed: %E\n"), link_info.output_bfd);
/* If the --force-exe-suffix is enabled, and we're making an
{
if (link_info.notice_hash == NULL)
{
- link_info.notice_hash =
- (struct bfd_hash_table *) xmalloc (sizeof (struct bfd_hash_table));
+ link_info.notice_hash
+ = (struct bfd_hash_table *) xmalloc (sizeof (struct bfd_hash_table));
if (!bfd_hash_table_init_n (link_info.notice_hash,
bfd_hash_newfunc,
sizeof (struct bfd_hash_entry),
if (info->ignore_hash == NULL)
{
info->ignore_hash = xmalloc (sizeof (struct bfd_hash_table));
- if (! bfd_hash_table_init_n (info->ignore_hash,
- bfd_hash_newfunc,
- sizeof (struct bfd_hash_entry),
- 61))
+ if (!bfd_hash_table_init_n (info->ignore_hash,
+ bfd_hash_newfunc,
+ sizeof (struct bfd_hash_entry),
+ 61))
einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
}
{
if (link_info.wrap_hash == NULL)
{
- link_info.wrap_hash =
- (struct bfd_hash_table *) xmalloc (sizeof (struct bfd_hash_table));
+ link_info.wrap_hash
+ = (struct bfd_hash_table *) xmalloc (sizeof (struct bfd_hash_table));
if (!bfd_hash_table_init_n (link_info.wrap_hash,
bfd_hash_newfunc,
sizeof (struct bfd_hash_entry),
{
size_t len = 0;
- while (! ISSPACE (c) && c != EOF)
+ while (!ISSPACE (c) && c != EOF)
{
buf[len] = c;
++len;
input = (lang_input_statement_type *)
xcalloc (1, sizeof (lang_input_statement_type));
+ input->header.type = lang_input_statement_enum;
input->filename = abfd->filename;
input->local_sym_name = abfd->filename;
input->the_bfd = abfd;
}
}
- if (! header_printed)
+ if (!header_printed)
{
- char buf[100];
-
- sprintf (buf, _("Archive member included "
- "to satisfy reference by file (symbol)\n\n"));
- minfo ("%s", buf);
+ minfo (_("Archive member included to satisfy reference by file (symbol)\n\n"));
header_printed = TRUE;
}
- if (bfd_my_archive (abfd) == NULL)
+ if (abfd->my_archive == NULL
+ || bfd_is_thin_archive (abfd->my_archive))
{
minfo ("%s", bfd_get_filename (abfd));
len = strlen (bfd_get_filename (abfd));
}
else
{
- minfo ("%s(%s)", bfd_get_filename (bfd_my_archive (abfd)),
+ minfo ("%s(%s)", bfd_get_filename (abfd->my_archive),
bfd_get_filename (abfd));
- len = (strlen (bfd_get_filename (bfd_my_archive (abfd)))
+ len = (strlen (bfd_get_filename (abfd->my_archive))
+ strlen (bfd_get_filename (abfd))
+ 2);
}
/* This is called when BFD has discovered a symbol which is defined
multiple times. */
-static bfd_boolean
+static void
multiple_definition (struct bfd_link_info *info,
struct bfd_link_hash_entry *h,
bfd *nbfd,
bfd_vma oval;
if (info->allow_multiple_definition)
- return TRUE;
+ return;
switch (h->type)
{
&& bfd_is_abs_section (osec)
&& bfd_is_abs_section (nsec)
&& nval == oval)
- return TRUE;
+ return;
/* If either section has the output_section field set to
bfd_abs_section_ptr, it means that the section is being
FIXME: It would be cleaner to somehow ignore symbols defined in
sections which are being discarded. */
if ((osec->output_section != NULL
- && ! bfd_is_abs_section (osec)
+ && !bfd_is_abs_section (osec)
&& bfd_is_abs_section (osec->output_section))
|| (nsec->output_section != NULL
- && ! bfd_is_abs_section (nsec)
+ && !bfd_is_abs_section (nsec)
&& bfd_is_abs_section (nsec->output_section)))
- return TRUE;
+ return;
name = h->root.string;
if (nbfd == NULL)
einfo (_("%P: Disabling relaxation: it will not work with multiple definitions\n"));
DISABLE_RELAXATION;
}
-
- return TRUE;
}
/* This is called when there is a definition of a common symbol, or
or when two common symbols are found. We only do something if
-warn-common was used. */
-static bfd_boolean
+static void
multiple_common (struct bfd_link_info *info ATTRIBUTE_UNUSED,
struct bfd_link_hash_entry *h,
bfd *nbfd,
bfd_vma osize;
if (!config.warn_common)
- return TRUE;
+ return;
name = h->root.string;
otype = h->type;
einfo (_("%B: warning: previous common is here\n"), obfd);
}
}
-
- return TRUE;
}
/* This is called when BFD has discovered a set element. H is the
entry in the linker hash table for the set. SECTION and VALUE
represent a value which should be added to the set. */
-static bfd_boolean
+static void
add_to_set (struct bfd_link_info *info ATTRIBUTE_UNUSED,
struct bfd_link_hash_entry *h,
bfd_reloc_code_real_type reloc,
einfo (_("%P: warning: global constructor %s used\n"),
h->root.string);
- if (! config.build_constructors)
- return TRUE;
+ if (!config.build_constructors)
+ return;
ldctor_add_set_entry (h, reloc, NULL, section, value);
undefined symbols because we are going to define it
ourselves. */
}
-
- return TRUE;
}
/* This is called when BFD has discovered a constructor. This is only
constructors in some more clever fashion. This is similar to
adding an element to a set, but less general. */
-static bfd_boolean
+static void
constructor_callback (struct bfd_link_info *info,
bfd_boolean constructor,
const char *name,
if (config.warn_constructors)
einfo (_("%P: warning: global constructor %s used\n"), name);
- if (! config.build_constructors)
- return TRUE;
+ if (!config.build_constructors)
+ return;
/* Ensure that BFD_RELOC_CTOR exists now, so that we can give a
useful error message. */
}
ldctor_add_set_entry (h, BFD_RELOC_CTOR, name, section, value);
- return TRUE;
}
/* A structure used by warning_callback to pass information through
/* This is called when there is a reference to a warning symbol. */
-static bfd_boolean
+static void
warning_callback (struct bfd_link_info *info ATTRIBUTE_UNUSED,
const char *warning,
const char *symbol,
{
/* This is a hack to support warn_multiple_gp. FIXME: This should
have a cleaner interface, but what? */
- if (! config.warn_multiple_gp
+ if (!config.warn_multiple_gp
&& strcmp (warning, "using multiple gp values") == 0)
- return TRUE;
+ return;
if (section != NULL)
einfo ("%C: %s%s\n", abfd, section, address, _("warning: "), warning);
einfo ("%P: %s%s\n", _("warning: "), warning);
else if (symbol == NULL)
einfo ("%B: %s%s\n", abfd, _("warning: "), warning);
- else if (! symbol_warning (warning, symbol, abfd))
+ else if (!symbol_warning (warning, symbol, abfd))
{
bfd *b;
/* Search all input files for a reference to SYMBOL. */
for (b = info->input_bfds; b; b = b->link.next)
if (b != abfd && symbol_warning (warning, symbol, b))
- return TRUE;
+ return;
einfo ("%B: %s%s\n", abfd, _("warning: "), warning);
}
-
- return TRUE;
}
/* This is called by warning_callback for each section. It checks the
/* This is called when an undefined symbol is found. */
-static bfd_boolean
+static void
undefined_symbol (struct bfd_link_info *info,
const char *name,
bfd *abfd,
if (info->ignore_hash != NULL
&& bfd_hash_lookup (info->ignore_hash, name, FALSE, FALSE) != NULL)
- return TRUE;
+ return;
if (config.warn_once)
{
else if (error)
einfo ("%X");
}
-
- return TRUE;
}
/* Counter to limit the number of relocation overflow error messages
/* This is called when a reloc overflows. */
-static bfd_boolean
+static void
reloc_overflow (struct bfd_link_info *info,
struct bfd_link_hash_entry *entry,
const char *name,
bfd_vma address)
{
if (overflow_cutoff_limit == -1)
- return TRUE;
+ return;
einfo ("%X%H:", abfd, section, address);
&& overflow_cutoff_limit-- == 0)
{
einfo (_(" additional relocation overflows omitted from the output\n"));
- return TRUE;
+ return;
}
if (entry)
{
case bfd_link_hash_undefined:
case bfd_link_hash_undefweak:
- einfo (_(" relocation truncated to fit: %s against undefined symbol `%T'"),
+ einfo (_(" relocation truncated to fit: "
+ "%s against undefined symbol `%T'"),
reloc_name, entry->root.string);
break;
case bfd_link_hash_defined:
case bfd_link_hash_defweak:
- einfo (_(" relocation truncated to fit: %s against symbol `%T' defined in %A section in %B"),
+ einfo (_(" relocation truncated to fit: "
+ "%s against symbol `%T' defined in %A section in %B"),
reloc_name, entry->root.string,
entry->u.def.section,
entry->u.def.section == bfd_abs_section_ptr
if (addend != 0)
einfo ("+%v", addend);
einfo ("\n");
- return TRUE;
}
/* This is called when a dangerous relocation is made. */
-static bfd_boolean
+static void
reloc_dangerous (struct bfd_link_info *info ATTRIBUTE_UNUSED,
const char *message,
bfd *abfd,
{
einfo (_("%X%H: dangerous relocation: %s\n"),
abfd, section, address, message);
- return TRUE;
}
/* This is called when a reloc is being generated attached to a symbol
that is not being output. */
-static bfd_boolean
+static void
unattached_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED,
const char *name,
bfd *abfd,
{
einfo (_("%X%H: reloc refers to symbol `%T' which is not being output\n"),
abfd, section, address, name);
- return TRUE;
}
/* This is called if link_info.notice_all is set, or when a symbol in