/usr/src/gnu/usr.bin/binutils-2.17/ld/ldmain.c

Bug Summary

File:	src/gnu/usr.bin/binutils-2.17/ld/ldmain.c
Warning:	line 492, column 23 Access to field 'flags' results in a dereference of a null pointer (loaded from variable 'output_bfd')
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name ldmain.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/binutils-2.17/obj/ld -resource-dir /usr/local/lib/clang/13.0.0 -D HAVE_CONFIG_H -I . -I /usr/src/gnu/usr.bin/binutils-2.17/ld -I . -D _GNU_SOURCE -I . -I /usr/src/gnu/usr.bin/binutils-2.17/ld -I ../bfd -I /usr/src/gnu/usr.bin/binutils-2.17/ld/../bfd -I /usr/src/gnu/usr.bin/binutils-2.17/ld/../include -I /usr/src/gnu/usr.bin/binutils-2.17/ld/../intl -I ../intl -D PIE_DEFAULT=1 -D LOCALEDIR="/usr/share/locale" -D PIE_DEFAULT=1 -D DEFAULT_EMULATION="elf_x86_64_obsd" -D SCRIPTDIR="/usr/libdata" -D BINDIR="/usr/bin" -D TOOLBINDIR="/usr/bin" -D TARGET="x86_64-unknown-openbsd7.0" -D TARGET_SYSTEM_ROOT="" -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -Wno-null-pointer-arithmetic -fdebug-compilation-dir=/usr/src/gnu/usr.bin/binutils-2.17/obj/ld -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c /usr/src/gnu/usr.bin/binutils-2.17/ld/ldmain.c
1/* Main program of GNU linker.
 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
 2002, 2003, 2004, 2005, 2006
 Free Software Foundation, Inc.
 Written by Steve Chamberlain steve@cygnus.com

 This file is part of GLD, the Gnu Linker.

 GLD 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, or (at your option)
 any later version.

 GLD is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with GLD; see the file COPYING.  If not, write to the Free
 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
 02110-1301, USA.  */

24#include "bfd.h"
25#include "sysdep.h"
26#include <stdio.h>
27#include "safe-ctype.h"
28#include "libiberty.h"
29#include "progress.h"
30#include "bfdlink.h"
31#include "filenames.h"

33#include "ld.h"
34#include "ldmain.h"
35#include "ldmisc.h"
36#include "ldwrite.h"
37#include "ldexp.h"
38#include "ldlang.h"
39#include <ldgram.h>
40#include "ldlex.h"
41#include "ldfile.h"
42#include "ldemul.h"
43#include "ldctor.h"

45/* Somewhere above, sys/stat.h got included.  */
46#if !defined(S_ISDIR) && defined(S_IFDIR0040000)
47#define	S_ISDIR(m)((m & 0170000) == 0040000) (((m) & S_IFMT0170000) == S_IFDIR0040000)
48#endif

50#include <string.h>

52#ifdef HAVE_SBRK1
53#if !HAVE_DECL_SBRK1
54extern void *sbrk ();
55#endif
56#endif

58#ifndef TARGET_SYSTEM_ROOT""
59#define TARGET_SYSTEM_ROOT"" ""
60#endif

62/* EXPORTS */

64char *default_target;
65const char *output_filename = "a.out";

67/* Name this program was invoked by.  */
68char *program_name;

70/* The prefix for system library directories.  */
71const char *ld_sysroot;

73/* The canonical representation of ld_sysroot.  */
74char * ld_canon_sysroot;
75int ld_canon_sysroot_len;

77/* The file that we're creating.  */
78bfd *output_bfd = 0;

80/* Set by -G argument, for MIPS ECOFF target.  */
81int g_switch_value = 8;

83/* Nonzero means print names of input files as processed.  */
84bfd_boolean trace_files;

86/* Nonzero means same, but note open failures, too.  */
87bfd_boolean trace_file_tries;

89/* Nonzero means version number was printed, so exit successfully
 instead of complaining if no input files are given.  */
91bfd_boolean version_printed;

93/* Nonzero means link in every member of an archive.  */
94bfd_boolean whole_archive;

96/* Nonzero means create DT_NEEDED entries only if a dynamic library
 actually satisfies some reference in a regular object.  */
98bfd_boolean as_needed;

100/* Nonzero means never create DT_NEEDED entries for dynamic libraries
 in DT_NEEDED tags.  */
102bfd_boolean add_needed = TRUE1;

104/* TRUE if we should demangle symbol names.  */
105bfd_boolean demangling;

107args_type command_line;

109ld_config_type config;

111sort_type sort_section;

113static const char *get_sysroot
(int, char **);
115static char *get_emulation
(int, char **);
117static void set_scripts_dir
(void);
119static bfd_boolean add_archive_element
(struct bfd_link_info *, bfd *, const char *);
121static bfd_boolean multiple_definition
(struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma,
 bfd *, asection *, bfd_vma);
124static bfd_boolean multiple_common
(struct bfd_link_info *, const char *, bfd *, enum bfd_link_hash_type,
 bfd_vma, bfd *, enum bfd_link_hash_type, bfd_vma);
127static bfd_boolean add_to_set
(struct bfd_link_info *, struct bfd_link_hash_entry *,
 bfd_reloc_code_real_type, bfd *, asection *, bfd_vma);
130static bfd_boolean constructor_callback
(struct bfd_link_info *, bfd_boolean, const char *, bfd *,
 asection *, bfd_vma);
133static bfd_boolean warning_callback
(struct bfd_link_info *, const char *, const char *, bfd *,
 asection *, bfd_vma);
136static void warning_find_reloc
(bfd *, asection *, void *);
138static bfd_boolean undefined_symbol
(struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma,
 bfd_boolean);
141static bfd_boolean reloc_overflow
(struct bfd_link_info *, struct bfd_link_hash_entry *, const char *,
 const char *, bfd_vma, bfd *, asection *, bfd_vma);
144static bfd_boolean reloc_dangerous
(struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma);
146static bfd_boolean unattached_reloc
(struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma);
148static bfd_boolean notice
(struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma);

151static struct bfd_link_callbacks link_callbacks =
152{
add_archive_element,
multiple_definition,
multiple_common,
add_to_set,
constructor_callback,
warning_callback,
undefined_symbol,
reloc_overflow,
reloc_dangerous,
unattached_reloc,
notice,
einfo
165};

167struct bfd_link_info link_info;
168
169static void
170remove_output (void)
171{
if (output_filename)
  {
    if (output_bfd)
bfd_cache_close (output_bfd);
    if (delete_output_file_on_failure)
unlink_if_ordinary (output_filename);
  }
179}

181int
182main (int argc, char **argv)
183{
char *emulation;
long start_time = get_run_time ();

187#if defined (HAVE_SETLOCALE1) && defined (HAVE_LC_MESSAGES1)
setlocale (LC_MESSAGES6, "");
189#endif
190#if defined (HAVE_SETLOCALE1)
setlocale (LC_CTYPE2, "");
192#endif
bindtextdomain (PACKAGE, LOCALEDIR)while (0);
1
Loop condition is false. Execution continues on line 194→
textdomain (PACKAGE)while (0);
2
←
Loop condition is false. Execution continues on line 196→

program_name = argv[0];
xmalloc_set_program_name (program_name);

if (pledge ("stdio rpath wpath cpath fattr", NULL((void*)0)) == -1) {
3
←
Assuming the condition is false→
4
←
Taking false branch→
  einfo (_("%X%P: Failed to pledge")("%X%P: Failed to pledge"));
  xexit (1);
}

START_PROGRESS (program_name, 0);

expandargv (&argc, &argv);

bfd_init ();

bfd_set_error_program_name (program_name);

xatexit (remove_output);

/* Set up the sysroot directory.  */
ld_sysroot = get_sysroot (argc, argv);
if (*ld_sysroot)
5
←
Assuming the condition is false→
6
←
Taking false branch→
  {
    if (*TARGET_SYSTEM_ROOT"" == 0)
{
 einfo ("%P%F: this linker was not configured to use sysroots\n");
 ld_sysroot = "";
}
    else
ld_canon_sysroot = lrealpath (ld_sysroot);
  }
if (ld_canon_sysroot)
7
←
Assuming 'ld_canon_sysroot' is non-null→
8
←
Taking true branch→
  ld_canon_sysroot_len = strlen (ld_canon_sysroot);
else
  ld_canon_sysroot_len = -1;

/* Set the default BFD target based on the configured target.  Doing
   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"x86_64-unknown-openbsd7.0"))
9
←
Assuming the condition is false→
10
←
Taking false branch→
  {
    einfo (_("%X%P: can't set BFD default target to `%s': %E\n")("%X%P: can't set BFD default target to `%s': %E\n"), TARGET"x86_64-unknown-openbsd7.0");
    xexit (1);
  }

241#if YYDEBUG
{
  extern int yydebug;
  yydebug = 1;
}
246#endif

/* Initialize the data about options.  */
trace_files = trace_file_tries = version_printed = FALSE0;
whole_archive = FALSE0;
config.build_constructors = TRUE1;
config.dynamic_link = FALSE0;
config.has_shared = FALSE0;
config.split_by_reloc = (unsigned) -1;
config.split_by_file = (bfd_size_type) -1;
config.hash_table_size = 0;
command_line.force_common_definition = FALSE0;
command_line.inhibit_common_definition = FALSE0;
command_line.interpreter = NULL((void*)0);
command_line.rpath = NULL((void*)0);
command_line.warn_mismatch = TRUE1;
command_line.check_section_addresses = TRUE1;
command_line.accept_unknown_input_arch = FALSE0;

sort_section = none;

/* We initialize DEMANGLING based on the environment variable
   COLLECT_NO_DEMANGLE.  The gcc collect2 program will demangle the
   output of the linker, unless COLLECT_NO_DEMANGLE is set in the
   environment.  Acting the same way here lets us provide the same
   interface by default.  */
demangling = getenv ("COLLECT_NO_DEMANGLE") == NULL((void*)0);
11
←
Assuming the condition is false→

link_info.relocatable = FALSE0;
link_info.emitrelocations = FALSE0;
link_info.task_link = FALSE0;
link_info.shared = FALSE0;
278#ifdef PIE_DEFAULT1
link_info.pie = TRUE1;
280#else
link_info.pie = FALSE0;
282#endif
link_info.executable = FALSE0;
link_info.symbolic = FALSE0;
link_info.export_dynamic = FALSE0;
link_info.static_link = FALSE0;
link_info.traditional_format = FALSE0;
link_info.optimize = FALSE0;
link_info.unresolved_syms_in_objects = RM_NOT_YET_SET;
link_info.unresolved_syms_in_shared_libs = RM_NOT_YET_SET;
link_info.allow_multiple_definition = FALSE0;
link_info.allow_undefined_version = TRUE1;
link_info.allow_textrel = FALSE0;
link_info.create_default_symver = FALSE0;
link_info.default_imported_symver = FALSE0;
link_info.keep_memory = TRUE1;
link_info.notice_all = FALSE0;
link_info.nocopyreloc = FALSE0;
link_info.new_dtags = FALSE0;
link_info.combreloc = TRUE1;
link_info.eh_frame_hdr = FALSE0;
link_info.relro = TRUE1;
link_info.strip_discarded = TRUE1;
link_info.strip = strip_none;
link_info.discard = discard_sec_merge;
link_info.common_skip_ar_aymbols = bfd_link_common_skip_none;
link_info.callbacks = &link_callbacks;
link_info.hash = NULL((void*)0);
link_info.keep_hash = NULL((void*)0);
link_info.notice_hash = NULL((void*)0);
link_info.wrap_hash = NULL((void*)0);
link_info.input_bfds = NULL((void*)0);
link_info.create_object_symbols_section = NULL((void*)0);
link_info.gc_sym_list = NULL((void*)0);
link_info.base_file = NULL((void*)0);
link_info.emit_hash = TRUE1;
317#ifndef __mips64__
link_info.emit_gnu_hash = TRUE1;
319#else
link_info.emit_gnu_hash = FALSE0;
321#endif
/* SVR4 linkers seem to set DT_INIT and DT_FINI based on magic _init
   and _fini symbols.  We are compatible.  */
link_info.init_function = "_init";
link_info.fini_function = "_fini";
link_info.pei386_auto_import = -1;
link_info.pei386_runtime_pseudo_reloc = FALSE0;
link_info.spare_dynamic_tags = 5;
link_info.flags = 0;
link_info.flags_1 = 0;
link_info.relax_pass = 1;
link_info.warn_shared_textrel = FALSE0;
link_info.gc_sections = FALSE0;
link_info.reduce_memory_overheads = FALSE0;

ldfile_add_arch ("");

config.make_executable = TRUE1;
force_make_executable = FALSE0;
config.magic_demand_paged = TRUE1;
config.text_read_only = TRUE1;
config.data_bss_contig = FALSE0;

emulation = get_emulation (argc, argv);
ldemul_choose_mode (emulation);
default_target = ldemul_choose_target (argc, argv);
lang_init ();
ldemul_before_parse ();
lang_has_input_file = FALSE0;
parse_args (argc, argv);

if (config.hash_table_size != 0)
12
←
Assuming field 'hash_table_size' is equal to 0→
13
←
Taking false branch→
  bfd_hash_set_default_size (config.hash_table_size);

ldemul_set_symbols ();

if (! link_info.shared && link_info.pie)
14
←
Assuming field 'shared' is not equal to 0→
  {
    if (link_info.relocatable)
      link_info.pie = FALSE0;
    else
      link_info.shared = TRUE1;
  }

if (link_info.relocatable)
15
←
Assuming field 'relocatable' is 0→
16
←
Taking false branch→
  {
    if (link_info.gc_sections)
einfo ("%P%F: --gc-sections and -r may not be used together\n");
    else if (command_line.relax)
einfo (_("%P%F: --relax and -r may not be used together\n")("%P%F: --relax and -r may not be used together\n"));
    if (link_info.shared)
einfo (_("%P%F: -r and -shared may not be used together\n")("%P%F: -r and -shared may not be used together\n"));
  }

if (! link_info.shared16.1
Field 'shared' is not equal to 0
)
17
←
Taking false branch→
  {
    if (command_line.filter_shlib)
einfo (_("%P%F: -F may not be used without -shared\n")("%P%F: -F may not be used without -shared\n"));
    if (command_line.auxiliary_filters)
einfo (_("%P%F: -f may not be used without -shared\n")("%P%F: -f may not be used without -shared\n"));
  }

if (! link_info.shared17.1
Field 'shared' is not equal to 0
 || link_info.pie)
18
←
Assuming field 'pie' is 0→
19
←
Taking false branch→
  link_info.executable = TRUE1;

if (! config.dynamic_link && link_info.pie)
20
←
Assuming field 'dynamic_link' is not equal to 0→
  link_info.static_link = TRUE1;

/* Treat ld -r -s as ld -r -S -x (i.e., strip all local symbols).  I
   don't see how else this can be handled, since in this case we
   must preserve all externally visible symbols.  */
if (link_info.relocatable20.1
Field 'relocatable' is 0
 && link_info.strip == strip_all)
  {
    link_info.strip = strip_debugger;
    if (link_info.discard == discard_sec_merge)
link_info.discard = discard_all;
  }

/* This essentially adds another -L directory so this must be done after
   the -L's in argv have been processed.  */
set_scripts_dir ();

/* If we have not already opened and parsed a linker script
   read the emulation's appropriate default script.  */
if (saved_script_handle == NULL((void*)0))
21
←
Assuming 'saved_script_handle' is not equal to NULL→
22
←
Taking false branch→
  {
    int isfile;
    char *s = ldemul_get_script (&isfile);

    if (isfile)
ldfile_open_command_file (s);
    else
{
 lex_string = s;
 lex_redirect (s);
}
    parser_input = input_script;
    yyparse ();
    lex_string = NULL((void*)0);
  }

if (trace_file_tries)
23
←
Assuming 'trace_file_tries' is 0→
24
←
Taking false branch→
  {
    if (saved_script_handle)
info_msg (_("using external linker script:")("using external linker script:"));
    else
info_msg (_("using internal linker script:")("using internal linker script:"));
    info_msg ("\n==================================================\n");

    if (saved_script_handle)
{
 static const int ld_bufsz = 8193;
 size_t n;
 char *buf = xmalloc (ld_bufsz);

 rewind (saved_script_handle);
 while ((n = fread (buf, 1, ld_bufsz - 1, saved_script_handle)) > 0)
   {
     buf[n] = 0;
     info_msg (buf);
   }
 rewind (saved_script_handle);
 free (buf);
}
    else
{
 int isfile;

 info_msg (ldemul_get_script (&isfile));
}

    info_msg ("\n==================================================\n");
  }

lang_final ();

if (!lang_has_input_file)
25
←
Assuming 'lang_has_input_file' is not equal to 0→
26
←
Taking false branch→
  {
    if (version_printed)
xexit (0);
    einfo (_("%P%F: no input files\n")("%P%F: no input files\n"));
  }

if (trace_files)
27
←
Assuming 'trace_files' is 0→
28
←
Taking false branch→
  info_msg (_("%P: mode %s\n")("%P: mode %s\n"), emulation);

ldemul_after_parse ();

if (config.map_filename)
29
←
Assuming field 'map_filename' is null→
30
←
Taking false branch→
  {
    if (strcmp (config.map_filename, "-") == 0)
{
 config.map_file = stdout(&__sF[1]);
}
    else
{
 config.map_file = fopen (config.map_filename, FOPEN_WT"w");
 if (config.map_file == (FILE *) NULL((void*)0))
   {
     bfd_set_error (bfd_error_system_call);
     einfo (_("%P%F: cannot open map file %s: %E\n")("%P%F: cannot open map file %s: %E\n"),
     config.map_filename);
   }
}
  }

lang_process ();

/* Print error messages for any missing symbols, for any warning
   symbols, and possibly multiple definitions.  */
if (link_info.relocatable)
31
←
Assuming field 'relocatable' is not equal to 0→
32
←
Taking true branch→
  output_bfd->flags &= ~EXEC_P0x02;
33
←
Access to field 'flags' results in a dereference of a null pointer (loaded from variable 'output_bfd')
else
  output_bfd->flags |= EXEC_P0x02;

ldwrite ();

if (config.map_file != NULL((void*)0))
  lang_map ();
if (command_line.cref)
  output_cref (config.map_file != NULL((void*)0) ? config.map_file : stdout(&__sF[1]));
if (nocrossref_list != NULL((void*)0))
  check_nocrossrefs ();

lang_finish ();

/* Even if we're producing relocatable output, some non-fatal errors should
   be reported in the exit status.  (What non-fatal errors, if any, do we
   want to ignore for relocatable output?)  */
if (!config.make_executable && !force_make_executable)
  {
    if (trace_files)
einfo (_("%P: link errors found, deleting executable `%s'\n")("%P: link errors found, deleting executable `%s'\n"),
      output_filename);

    /* The file will be removed by remove_output.  */
    xexit (1);
  }
else
  {
    if (! bfd_close (output_bfd))
einfo (_("%F%B: final close failed: %E\n")("%F%B: final close failed: %E\n"), output_bfd);

    /* If the --force-exe-suffix is enabled, and we're making an
executable file and it doesn't end in .exe, copy it to one
which does.  */
    if (! link_info.relocatable && command_line.force_exe_suffix)
{
 int len = strlen (output_filename);

 if (len < 4
     || (strcasecmp (output_filename + len - 4, ".exe") != 0
  && strcasecmp (output_filename + len - 4, ".dll") != 0))
   {
     FILE *src;
     FILE *dst;
     const int bsize = 4096;
     char *buf = xmalloc (bsize);
     int l;
     char *dst_name = xmalloc (len + 5);

     strcpy (dst_name, output_filename);
     strcat (dst_name, ".exe");
     src = fopen (output_filename, FOPEN_RB"r");
     dst = fopen (dst_name, FOPEN_WB"w");

     if (!src)
einfo (_("%X%P: unable to open for source of copy `%s'\n")("%X%P: unable to open for source of copy `%s'\n"),
       output_filename);
     if (!dst)
einfo (_("%X%P: unable to open for destination of copy `%s'\n")("%X%P: unable to open for destination of copy `%s'\n"),
       dst_name);
     while ((l = fread (buf, 1, bsize, src)) > 0)
{
  int done = fwrite (buf, 1, l, dst);

  if (done != l)
    einfo (_("%P: Error writing file `%s'\n")("%P: Error writing file `%s'\n"), dst_name);
}

     fclose (src);
     if (fclose (dst) == EOF(-1))
einfo (_("%P: Error closing file `%s'\n")("%P: Error closing file `%s'\n"), dst_name);
     free (dst_name);
     free (buf);
   }
}
  }

END_PROGRESS (program_name);

if (config.stats)
  {
574#ifdef HAVE_SBRK1
    char *lim = sbrk (0);
576#endif
    long run_time = get_run_time () - start_time;

    fprintf (stderr(&__sF[2]), _("%s: total time in link: %ld.%06ld\n")("%s: total time in link: %ld.%06ld\n"),
      program_name, run_time / 1000000, run_time % 1000000);
581#ifdef HAVE_SBRK1
    fprintf (stderr(&__sF[2]), _("%s: data size %ld\n")("%s: data size %ld\n"), program_name,
      (long) (lim - (char *) &environ));
584#endif
  }

/* Prevent remove_output from doing anything, after a successful link.  */
output_filename = NULL((void*)0);

xexit (0);
return 0;
592}

594/* If the configured sysroot is relocatable, try relocating it based on
 default prefix FROM.  Return the relocated directory if it exists,
 otherwise return null.  */

598static char *
599get_relative_sysroot (const char *from ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
600{
601#ifdef TARGET_SYSTEM_ROOT_RELOCATABLE
char *path;
struct stat s;

path = make_relative_prefix (program_name, from, TARGET_SYSTEM_ROOT"");
if (path)
  {
    if (stat (path, &s) == 0 && S_ISDIR (s.st_mode)((s.st_mode & 0170000) == 0040000))
return path;
    free (path);
  }
612#endif
return 0;
614}

616/* Return the sysroot directory.  Return "" if no sysroot is being used.  */

618static const char *
619get_sysroot (int argc, char **argv)
620{
int i;
const char *path;

for (i = 1; i < argc; i++)
  if (strncmp (argv[i], "--sysroot=", strlen ("--sysroot=")) == 0)
    return argv[i] + strlen ("--sysroot=");

path = get_relative_sysroot (BINDIR"/usr/bin");
if (path)
  return path;

path = get_relative_sysroot (TOOLBINDIR"/usr/bin");
if (path)
  return path;

return TARGET_SYSTEM_ROOT"";
637}

639/* We need to find any explicitly given emulation in order to initialize the
 state that's needed by the lex&yacc argument parser (parse_args).  */

642static char *
643get_emulation (int argc, char **argv)
644{
char *emulation;
int i;

emulation = getenv (EMULATION_ENVIRON"LDEMULATION");
if (emulation == NULL((void*)0))
  emulation = DEFAULT_EMULATION"elf_x86_64_obsd";

for (i = 1; i < argc; i++)
  {
    if (!strncmp (argv[i], "-m", 2))
{
 if (argv[i][2] == '\0')
   {
     /* -m EMUL */
     if (i < argc - 1)
{
  emulation = argv[i + 1];
  i++;
}
     else
einfo (_("%P%F: missing argument to -m\n")("%P%F: missing argument to -m\n"));
   }
 else if (strcmp (argv[i], "-mips1") == 0
   || strcmp (argv[i], "-mips2") == 0
   || strcmp (argv[i], "-mips3") == 0
   || strcmp (argv[i], "-mips4") == 0
   || strcmp (argv[i], "-mips5") == 0
   || strcmp (argv[i], "-mips32") == 0
   || strcmp (argv[i], "-mips32r2") == 0
   || strcmp (argv[i], "-mips64") == 0
   || strcmp (argv[i], "-mips64r2") == 0)
   {
     /* FIXME: The arguments -mips1, -mips2, -mips3, etc. are
 passed to the linker by some MIPS compilers.  They
 generally tell the linker to use a slightly different
 library path.  Perhaps someday these should be
 implemented as emulations; until then, we just ignore
 the arguments and hope that nobody ever creates
 emulations named ips1, ips2 or ips3.  */
   }
 else if (strcmp (argv[i], "-m486") == 0)
   {
     /* FIXME: The argument -m486 is passed to the linker on
 some Linux systems.  Hope that nobody creates an
 emulation named 486.  */
   }
 else
   {
     /* -mEMUL */
     emulation = &argv[i][2];
   }
}
  }

return emulation;
700}

702/* If directory DIR contains an "ldscripts" subdirectory,
 add DIR to the library search path and return TRUE,
 else return FALSE.  */

706static bfd_boolean
707check_for_scripts_dir (char *dir)
708{
size_t dirlen;
char *buf;
struct stat s;
bfd_boolean res;

dirlen = strlen (dir);
/* sizeof counts the terminating NUL.  */
buf = xmalloc (dirlen + sizeof ("/ldscripts"));
sprintf (buf, "%s/ldscripts", dir);

res = stat (buf, &s) == 0 && S_ISDIR (s.st_mode)((s.st_mode & 0170000) == 0040000);
free (buf);
if (res)
  ldfile_add_library_path (dir, FALSE0);
return res;
724}

726/* Set the default directory for finding script files.
 Libraries will be searched for here too, but that's ok.
 We look for the "ldscripts" directory in:

 SCRIPTDIR (passed from Makefile)
    (adjusted according to the current location of the binary)
 SCRIPTDIR (passed from Makefile)
 the dir where this program is (for using it from the build tree)
 the dir where this program is/../lib
    (for installing the tool suite elsewhere).  */

737static void
738set_scripts_dir (void)
739{
char *end, *dir;
size_t dirlen;
bfd_boolean found;

dir = make_relative_prefix (program_name, BINDIR"/usr/bin", SCRIPTDIR"/usr/libdata");
if (dir)
  {
    found = check_for_scripts_dir (dir);
    free (dir);
    if (found)
return;
  }

dir = make_relative_prefix (program_name, TOOLBINDIR"/usr/bin", SCRIPTDIR"/usr/libdata");
if (dir)
  {
    found = check_for_scripts_dir (dir);
    free (dir);
    if (found)
return;
  }

if (check_for_scripts_dir (SCRIPTDIR"/usr/libdata"))
  /* We've been installed normally.  */
  return;

/* Look for "ldscripts" in the dir where our binary is.  */
end = strrchr (program_name, '/');
768#ifdef HAVE_DOS_BASED_FILE_SYSTEM
{
  /* We could have \foo\bar, or /foo\bar.  */
  char *bslash = strrchr (program_name, '\\');

  if (end == NULL((void*)0) || (bslash != NULL((void*)0) && bslash > end))
    end = bslash;
}
776#endif

if (end == NULL((void*)0))
  /* Don't look for ldscripts in the current directory.  There is
     too much potential for confusion.  */
  return;

dirlen = end - program_name;
/* Make a copy of program_name in dir.
   Leave room for later "/../lib".  */
dir = xmalloc (dirlen + 8);
strncpy (dir, program_name, dirlen);
dir[dirlen] = '\0';

if (check_for_scripts_dir (dir))
  {
    free (dir);
    return;
  }

/* Look for "ldscripts" in <the dir where our binary is>/../lib.  */
strcpy (dir + dirlen, "/../lib");
check_for_scripts_dir (dir);
free (dir);
800}

802void
803add_ysym (const char *name)
804{
if (link_info.notice_hash == NULL((void*)0))
  {
    link_info.notice_hash = xmalloc (sizeof (struct bfd_hash_table));
    if (!bfd_hash_table_init_n (link_info.notice_hash,
		  bfd_hash_newfunc,
		  sizeof (struct bfd_hash_entry),
		  61))
einfo (_("%P%F: bfd_hash_table_init failed: %E\n")("%P%F: bfd_hash_table_init failed: %E\n"));
  }

if (bfd_hash_lookup (link_info.notice_hash, name, TRUE1, TRUE1) == NULL((void*)0))
  einfo (_("%P%F: bfd_hash_lookup failed: %E\n")("%P%F: bfd_hash_lookup failed: %E\n"));
817}

819/* Record a symbol to be wrapped, from the --wrap option.  */

821void
822add_wrap (const char *name)
823{
if (link_info.wrap_hash == NULL((void*)0))
  {
    link_info.wrap_hash = xmalloc (sizeof (struct bfd_hash_table));
    if (!bfd_hash_table_init_n (link_info.wrap_hash,
		  bfd_hash_newfunc,
		  sizeof (struct bfd_hash_entry),
		  61))
einfo (_("%P%F: bfd_hash_table_init failed: %E\n")("%P%F: bfd_hash_table_init failed: %E\n"));
  }

if (bfd_hash_lookup (link_info.wrap_hash, name, TRUE1, TRUE1) == NULL((void*)0))
  einfo (_("%P%F: bfd_hash_lookup failed: %E\n")("%P%F: bfd_hash_lookup failed: %E\n"));
836}

838/* Handle the -retain-symbols-file option.  */

840void
841add_keepsyms_file (const char *filename)
842{
FILE *file;
char *buf;
size_t bufsize;
int c;

if (link_info.strip == strip_some)
  einfo (_("%X%P: error: duplicate retain-symbols-file\n")("%X%P: error: duplicate retain-symbols-file\n"));

file = fopen (filename, "r");
if (file == NULL((void*)0))
  {
    bfd_set_error (bfd_error_system_call);
    einfo ("%X%P: %s: %E\n", filename);
    return;
  }

link_info.keep_hash = xmalloc (sizeof (struct bfd_hash_table));
if (!bfd_hash_table_init (link_info.keep_hash, bfd_hash_newfunc,
	    sizeof (struct bfd_hash_entry)))
  einfo (_("%P%F: bfd_hash_table_init failed: %E\n")("%P%F: bfd_hash_table_init failed: %E\n"));

bufsize = 100;
buf = xmalloc (bufsize);

c = getc (file)(!__isthreaded ? (--(file)->_r < 0 ? __srget(file) : (int
)(*(file)->_p++)) : (getc)(file));
while (c != EOF(-1))
  {
    while (ISSPACE (c)(_sch_istable[(c) & 0xff] & (unsigned short)(_sch_isspace
)))
c = getc (file)(!__isthreaded ? (--(file)->_r < 0 ? __srget(file) : (int
)(*(file)->_p++)) : (getc)(file));

    if (c != EOF(-1))
{
 size_t len = 0;

 while (! ISSPACE (c)(_sch_istable[(c) & 0xff] & (unsigned short)(_sch_isspace
)) && c != EOF(-1))
   {
     buf[len] = c;
     ++len;
     if (len >= bufsize)
{
  bufsize *= 2;
  buf = xrealloc (buf, bufsize);
}
     c = getc (file)(!__isthreaded ? (--(file)->_r < 0 ? __srget(file) : (int
)(*(file)->_p++)) : (getc)(file));
   }

 buf[len] = '\0';

 if (bfd_hash_lookup (link_info.keep_hash, buf, TRUE1, TRUE1) == NULL((void*)0))
   einfo (_("%P%F: bfd_hash_lookup for insertion failed: %E\n")("%P%F: bfd_hash_lookup for insertion failed: %E\n"));
}
  }

if (link_info.strip != strip_none)
  einfo (_("%P: `-retain-symbols-file' overrides `-s' and `-S'\n")("%P: `-retain-symbols-file' overrides `-s' and `-S'\n"));

free (buf);
link_info.strip = strip_some;
901}
902
903/* Callbacks from the BFD linker routines.  */

905/* This is called when BFD has decided to include an archive member in
 a link.  */

908static bfd_boolean
909add_archive_element (struct bfd_link_info *info,
     bfd *abfd,
     const char *name)
912{
lang_input_statement_type *input;

input = xmalloc (sizeof (lang_input_statement_type));
input->filename = abfd->filename;
input->local_sym_name = abfd->filename;
input->the_bfd = abfd;
input->asymbols = NULL((void*)0);
input->next = NULL((void*)0);
input->just_syms_flag = FALSE0;
input->loaded = FALSE0;
input->search_dirs_flag = FALSE0;

/* FIXME: The following fields are not set: header.next,
   header.type, closed, passive_position, symbol_count,
   next_real_file, is_archive, target, real.  This bit of code is
   from the old decode_library_subfile function.  I don't know
   whether any of those fields matters.  */

ldlang_add_file (input);

if (config.map_file != NULL((void*)0))
  {
    static bfd_boolean header_printed;
    struct bfd_link_hash_entry *h;
    bfd *from;
    int len;

    h = bfd_link_hash_lookup (info->hash, name, FALSE0, FALSE0, TRUE1);

    if (h == NULL((void*)0))
from = NULL((void*)0);
    else
{
 switch (h->type)
   {
   default:
     from = NULL((void*)0);
     break;

   case bfd_link_hash_defined:
   case bfd_link_hash_defweak:
     from = h->u.def.section->owner;
     break;

   case bfd_link_hash_undefined:
   case bfd_link_hash_undefweak:
     from = h->u.undef.abfd;
     break;

   case bfd_link_hash_common:
     from = h->u.c.p->section->owner;
     break;
   }
}

    if (! header_printed)
{
 char buf[100];

 sprintf (buf, _("Archive member included because of file (symbol)\n\n")("Archive member included because of file (symbol)\n\n"));
 minfo ("%s", buf);
 header_printed = TRUE1;
}

    if (bfd_my_archive (abfd)((abfd)->my_archive) == NULL((void*)0))
{
 minfo ("%s", bfd_get_filename (abfd)((char *) (abfd)->filename));
 len = strlen (bfd_get_filename (abfd)((char *) (abfd)->filename));
}
    else
{
 minfo ("%s(%s)", bfd_get_filename (bfd_my_archive (abfd))((char *) (((abfd)->my_archive))->filename),
 bfd_get_filename (abfd)((char *) (abfd)->filename));
 len = (strlen (bfd_get_filename (bfd_my_archive (abfd))((char *) (((abfd)->my_archive))->filename))
 + strlen (bfd_get_filename (abfd)((char *) (abfd)->filename))
 + 2);
}

    if (len >= 29)
{
 print_nl ();
 len = 0;
}
    while (len < 30)
{
 print_space ();
 ++len;
}

    if (from != NULL((void*)0))
minfo ("%B ", from);
    if (h != NULL((void*)0))
minfo ("(%T)\n", h->root.string);
    else
minfo ("(%s)\n", name);
  }

if (trace_files || trace_file_tries)
  info_msg ("%I\n", input);

return TRUE1;
1014}

1016/* This is called when BFD has discovered a symbol which is defined
 multiple times.  */

1019static bfd_boolean
1020multiple_definition (struct bfd_link_info *info ATTRIBUTE_UNUSED__attribute__ ((__unused__)),
     const char *name,
     bfd *obfd,
     asection *osec,
     bfd_vma oval,
     bfd *nbfd,
     asection *nsec,
     bfd_vma nval)
1028{
/* If either section has the output_section field set to
   bfd_abs_section_ptr, it means that the section is being
   discarded, and this is not really a multiple definition at all.
   FIXME: It would be cleaner to somehow ignore symbols defined in
   sections which are being discarded.  */
if ((osec->output_section != NULL((void*)0)
     && ! bfd_is_abs_section (osec)((osec) == ((asection *) &bfd_abs_section))
     && bfd_is_abs_section (osec->output_section)((osec->output_section) == ((asection *) &bfd_abs_section
)))
    || (nsec->output_section != NULL((void*)0)
 && ! bfd_is_abs_section (nsec)((nsec) == ((asection *) &bfd_abs_section))
 && bfd_is_abs_section (nsec->output_section)((nsec->output_section) == ((asection *) &bfd_abs_section
))))
  return TRUE1;

einfo (_("%X%C: multiple definition of `%T'\n")("%X%C: multiple definition of `%T'\n"),
nbfd, nsec, nval, name);
if (obfd != NULL((void*)0))
  einfo (_("%D: first defined here\n")("%D: first defined here\n"), obfd, osec, oval);

if (command_line.relax)
  {
    einfo (_("%P: Disabling relaxation: it will not work with multiple definitions\n")("%P: Disabling relaxation: it will not work with multiple definitions\n"
));
    command_line.relax = 0;
  }

return TRUE1;
1054}

1056/* This is called when there is a definition of a common symbol, or
 when a common symbol is found for a symbol that is already defined,
 or when two common symbols are found.  We only do something if
 -warn-common was used.  */

1061static bfd_boolean
1062multiple_common (struct bfd_link_info *info ATTRIBUTE_UNUSED__attribute__ ((__unused__)),
 const char *name,
 bfd *obfd,
 enum bfd_link_hash_type otype,
 bfd_vma osize,
 bfd *nbfd,
 enum bfd_link_hash_type ntype,
 bfd_vma nsize)
1070{
if (! config.warn_common)
  return TRUE1;

if (ntype == bfd_link_hash_defined
    || ntype == bfd_link_hash_defweak
    || ntype == bfd_link_hash_indirect)
  {
    ASSERT (otype == bfd_link_hash_common)do { if (!(otype == bfd_link_hash_common)) info_assert("/usr/src/gnu/usr.bin/binutils-2.17/ld/ldmain.c"
,1078); } while (0);
    einfo (_("%B: warning: definition of `%T' overriding common\n")("%B: warning: definition of `%T' overriding common\n"),
    nbfd, name);
    if (obfd != NULL((void*)0))
einfo (_("%B: warning: common is here\n")("%B: warning: common is here\n"), obfd);
  }
else if (otype == bfd_link_hash_defined
  || otype == bfd_link_hash_defweak
  || otype == bfd_link_hash_indirect)
  {
    ASSERT (ntype == bfd_link_hash_common)do { if (!(ntype == bfd_link_hash_common)) info_assert("/usr/src/gnu/usr.bin/binutils-2.17/ld/ldmain.c"
,1088); } while (0);
    einfo (_("%B: warning: common of `%T' overridden by definition\n")("%B: warning: common of `%T' overridden by definition\n"),
    nbfd, name);
    if (obfd != NULL((void*)0))
einfo (_("%B: warning: defined here\n")("%B: warning: defined here\n"), obfd);
  }
else
  {
    ASSERT (otype == bfd_link_hash_common && ntype == bfd_link_hash_common)do { if (!(otype == bfd_link_hash_common && ntype == bfd_link_hash_common
)) info_assert("/usr/src/gnu/usr.bin/binutils-2.17/ld/ldmain.c"
,1096); } while (0);
    if (osize > nsize)
{
 einfo (_("%B: warning: common of `%T' overridden by larger common\n")("%B: warning: common of `%T' overridden by larger common\n"),
 nbfd, name);
 if (obfd != NULL((void*)0))
   einfo (_("%B: warning: larger common is here\n")("%B: warning: larger common is here\n"), obfd);
}
    else if (nsize > osize)
{
 einfo (_("%B: warning: common of `%T' overriding smaller common\n")("%B: warning: common of `%T' overriding smaller common\n"),
 nbfd, name);
 if (obfd != NULL((void*)0))
   einfo (_("%B: warning: smaller common is here\n")("%B: warning: smaller common is here\n"), obfd);
}
    else
{
 einfo (_("%B: warning: multiple common of `%T'\n")("%B: warning: multiple common of `%T'\n"), nbfd, name);
 if (obfd != NULL((void*)0))
   einfo (_("%B: warning: previous common is here\n")("%B: warning: previous common is here\n"), obfd);
}
  }

return TRUE1;
1120}

1122/* 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.  */

1126static bfd_boolean
1127add_to_set (struct bfd_link_info *info ATTRIBUTE_UNUSED__attribute__ ((__unused__)),
   struct bfd_link_hash_entry *h,
   bfd_reloc_code_real_type reloc,
   bfd *abfd,
   asection *section,
   bfd_vma value)
1133{
if (config.warn_constructors)
  einfo (_("%P: warning: global constructor %s used\n")("%P: warning: global constructor %s used\n"),
  h->root.string);

if (! config.build_constructors)
  return TRUE1;

ldctor_add_set_entry (h, reloc, NULL((void*)0), section, value);

if (h->type == bfd_link_hash_new)
  {
    h->type = bfd_link_hash_undefined;
    h->u.undef.abfd = abfd;
    /* We don't call bfd_link_add_undef to add this to the list of
undefined symbols because we are going to define it
ourselves.  */
  }

return TRUE1;
1153}

1155/* This is called when BFD has discovered a constructor.  This is only
 called for some object file formats--those which do not handle
 constructors in some more clever fashion.  This is similar to
 adding an element to a set, but less general.  */

1160static bfd_boolean
1161constructor_callback (struct bfd_link_info *info,
      bfd_boolean constructor,
      const char *name,
      bfd *abfd,
      asection *section,
      bfd_vma value)
1167{
char *s;
struct bfd_link_hash_entry *h;
char set_name[1 + sizeof "__CTOR_LIST__"];

if (config.warn_constructors)
  einfo (_("%P: warning: global constructor %s used\n")("%P: warning: global constructor %s used\n"), name);

if (! config.build_constructors)
  return TRUE1;

/* Ensure that BFD_RELOC_CTOR exists now, so that we can give a
   useful error message.  */
if (bfd_reloc_type_lookup (output_bfd, BFD_RELOC_CTOR) == NULL((void*)0)
    && (info->relocatable
 || bfd_reloc_type_lookup (abfd, BFD_RELOC_CTOR) == NULL((void*)0)))
  einfo (_("%P%F: BFD backend error: BFD_RELOC_CTOR unsupported\n")("%P%F: BFD backend error: BFD_RELOC_CTOR unsupported\n"));

s = set_name;
if (bfd_get_symbol_leading_char (abfd)((abfd)->xvec->symbol_leading_char) != '\0')
  *s++ = bfd_get_symbol_leading_char (abfd)((abfd)->xvec->symbol_leading_char);
if (constructor)
  strcpy (s, "__CTOR_LIST__");
else
  strcpy (s, "__DTOR_LIST__");

h = bfd_link_hash_lookup (info->hash, set_name, TRUE1, TRUE1, TRUE1);
if (h == (struct bfd_link_hash_entry *) NULL((void*)0))
  einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n")("%P%F: bfd_link_hash_lookup failed: %E\n"));
if (h->type == bfd_link_hash_new)
  {
    h->type = bfd_link_hash_undefined;
    h->u.undef.abfd = abfd;
    /* We don't call bfd_link_add_undef to add this to the list of
undefined symbols because we are going to define it
ourselves.  */
  }

ldctor_add_set_entry (h, BFD_RELOC_CTOR, name, section, value);
return TRUE1;
1207}

1209/* A structure used by warning_callback to pass information through
 bfd_map_over_sections.  */

1212struct warning_callback_info
1213{
bfd_boolean found;
const char *warning;
const char *symbol;
asymbol **asymbols;
1218};

1220/* This is called when there is a reference to a warning symbol.  */

1222static bfd_boolean
1223warning_callback (struct bfd_link_info *info ATTRIBUTE_UNUSED__attribute__ ((__unused__)),
  const char *warning,
  const char *symbol,
  bfd *abfd,
  asection *section,
  bfd_vma address)
1229{
/* This is a hack to support warn_multiple_gp.  FIXME: This should
   have a cleaner interface, but what?  */
if (! config.warn_multiple_gp
    && strcmp (warning, "using multiple gp values") == 0)
  return TRUE1;

if (section != NULL((void*)0))
  einfo ("%C: %s%s\n", abfd, section, address, _("warning: ")("warning: "), warning);
else if (abfd == NULL((void*)0))
  einfo ("%P: %s%s\n", _("warning: ")("warning: "), warning);
else if (symbol == NULL((void*)0))
  einfo ("%B: %s%s\n", abfd, _("warning: ")("warning: "), warning);
else
  {
    lang_input_statement_type *entry;
    asymbol **asymbols;
    struct warning_callback_info info;

    /* Look through the relocs to see if we can find a plausible
address.  */
    entry = (lang_input_statement_type *) abfd->usrdata;
    if (entry != NULL((void*)0) && entry->asymbols != NULL((void*)0))
asymbols = entry->asymbols;
    else
{
 long symsize;
 long symbol_count;

 symsize = bfd_get_symtab_upper_bound (abfd)((*((abfd)->xvec->_bfd_get_symtab_upper_bound)) (abfd));
 if (symsize < 0)
   einfo (_("%B%F: could not read symbols: %E\n")("%B%F: could not read symbols: %E\n"), abfd);
 asymbols = xmalloc (symsize);
 symbol_count = bfd_canonicalize_symtab (abfd, asymbols)((*((abfd)->xvec->_bfd_canonicalize_symtab)) (abfd, asymbols
));
 if (symbol_count < 0)
   einfo (_("%B%F: could not read symbols: %E\n")("%B%F: could not read symbols: %E\n"), abfd);
 if (entry != NULL((void*)0))
   {
     entry->asymbols = asymbols;
     entry->symbol_count = symbol_count;
   }
}

    info.found = FALSE0;
    info.warning = warning;
    info.symbol = symbol;
    info.asymbols = asymbols;
    bfd_map_over_sections (abfd, warning_find_reloc, &info);

    if (! info.found)
einfo ("%B: %s%s\n", abfd, _("warning: ")("warning: "), warning);

    if (entry == NULL((void*)0))
free (asymbols);
  }

return TRUE1;
1286}

1288/* This is called by warning_callback for each section.  It checks the
 relocs of the section to see if it can find a reference to the
 symbol which triggered the warning.  If it can, it uses the reloc
 to give an error message with a file and line number.  */

1293static void
1294warning_find_reloc (bfd *abfd, asection *sec, void *iarg)
1295{
struct warning_callback_info *info = iarg;
long relsize;
arelent **relpp;
long relcount;
arelent **p, **pend;

if (info->found)
  return;

relsize = bfd_get_reloc_upper_bound (abfd, sec);
if (relsize < 0)
  einfo (_("%B%F: could not read relocs: %E\n")("%B%F: could not read relocs: %E\n"), abfd);
if (relsize == 0)
  return;

relpp = xmalloc (relsize);
relcount = bfd_canonicalize_reloc (abfd, sec, relpp, info->asymbols);
if (relcount < 0)
  einfo (_("%B%F: could not read relocs: %E\n")("%B%F: could not read relocs: %E\n"), abfd);

p = relpp;
pend = p + relcount;
for (; p < pend && *p != NULL((void*)0); p++)
  {
    arelent *q = *p;

    if (q->sym_ptr_ptr != NULL((void*)0)
 && *q->sym_ptr_ptr != NULL((void*)0)
 && strcmp (bfd_asymbol_name (*q->sym_ptr_ptr)((*q->sym_ptr_ptr)->name), info->symbol) == 0)
{
 /* We found a reloc for the symbol we are looking for.  */
 einfo ("%C: %s%s\n", abfd, sec, q->address, _("warning: ")("warning: "),
 info->warning);
 info->found = TRUE1;
 break;
}
  }

free (relpp);
1335}

1337/* This is called when an undefined symbol is found.  */

1339static bfd_boolean
1340undefined_symbol (struct bfd_link_info *info ATTRIBUTE_UNUSED__attribute__ ((__unused__)),
  const char *name,
  bfd *abfd,
  asection *section,
  bfd_vma address,
  bfd_boolean error)
1346{
static char *error_name;
static unsigned int error_count;

1350#define MAX_ERRORS_IN_A_ROW5 5

if (config.warn_once)
  {
    static struct bfd_hash_table *hash;

    /* Only warn once about a particular undefined symbol.  */
    if (hash == NULL((void*)0))
{
 hash = xmalloc (sizeof (struct bfd_hash_table));
 if (!bfd_hash_table_init (hash, bfd_hash_newfunc,
		    sizeof (struct bfd_hash_entry)))
   einfo (_("%F%P: bfd_hash_table_init failed: %E\n")("%F%P: bfd_hash_table_init failed: %E\n"));
}

    if (bfd_hash_lookup (hash, name, FALSE0, FALSE0) != NULL((void*)0))
return TRUE1;

    if (bfd_hash_lookup (hash, name, TRUE1, TRUE1) == NULL((void*)0))
einfo (_("%F%P: bfd_hash_lookup failed: %E\n")("%F%P: bfd_hash_lookup failed: %E\n"));
  }

/* We never print more than a reasonable number of errors in a row
   for a single symbol.  */
if (error_name != NULL((void*)0)
    && strcmp (name, error_name) == 0)
  ++error_count;
else
  {
    error_count = 0;
    if (error_name != NULL((void*)0))
free (error_name);
    error_name = xstrdup (name);
  }

if (section != NULL((void*)0))
  {
    if (error_count < MAX_ERRORS_IN_A_ROW5)
{
 if (error)
   einfo (_("%X%C: undefined reference to `%T'\n")("%X%C: undefined reference to `%T'\n"),
   abfd, section, address, name);
 else
   einfo (_("%C: warning: undefined reference to `%T'\n")("%C: warning: undefined reference to `%T'\n"),
   abfd, section, address, name);
}
    else if (error_count == MAX_ERRORS_IN_A_ROW5)
{
 if (error)
   einfo (_("%X%D: more undefined references to `%T' follow\n")("%X%D: more undefined references to `%T' follow\n"),
   abfd, section, address, name);
 else
   einfo (_("%D: warning: more undefined references to `%T' follow\n")("%D: warning: more undefined references to `%T' follow\n"),
   abfd, section, address, name);
}
    else if (error)
einfo ("%X");
  }
else
  {
    if (error_count < MAX_ERRORS_IN_A_ROW5)
{
 if (error)
   einfo (_("%X%B: undefined reference to `%T'\n")("%X%B: undefined reference to `%T'\n"),
   abfd, name);
 else
   einfo (_("%B: warning: undefined reference to `%T'\n")("%B: warning: undefined reference to `%T'\n"),
   abfd, name);
}
    else if (error_count == MAX_ERRORS_IN_A_ROW5)
{
 if (error)
   einfo (_("%X%B: more undefined references to `%T' follow\n")("%X%B: more undefined references to `%T' follow\n"),
   abfd, name);
 else
   einfo (_("%B: warning: more undefined references to `%T' follow\n")("%B: warning: more undefined references to `%T' follow\n"),
   abfd, name);
}
    else if (error)
einfo ("%X");
  }

return TRUE1;
1433}

1435/* Counter to limit the number of relocation overflow error messages
 to print.  Errors are printed as it is decremented.  When it's
 called and the counter is zero, a final message is printed
 indicating more relocations were omitted.  When it gets to -1, no
 such errors are printed.  If it's initially set to a value less
 than -1, all such errors will be printed (--verbose does this).  */

1442int overflow_cutoff_limit = 10;

1444/* This is called when a reloc overflows.  */

1446static bfd_boolean
1447reloc_overflow (struct bfd_link_info *info ATTRIBUTE_UNUSED__attribute__ ((__unused__)),
struct bfd_link_hash_entry *entry,
const char *name,
const char *reloc_name,
bfd_vma addend,
bfd *abfd,
asection *section,
bfd_vma address)
1455{
if (overflow_cutoff_limit == -1)
  return TRUE1;

einfo ("%X%C:", abfd, section, address);

if (overflow_cutoff_limit >= 0
    && overflow_cutoff_limit-- == 0)
  {
    einfo (_(" additional relocation overflows omitted from the output\n")(" additional relocation overflows omitted from the output\n"
));
    return TRUE1;
  }

if (entry)
  {
    while (entry->type == bfd_link_hash_indirect
    || entry->type == bfd_link_hash_warning)
entry = entry->u.i.link;
    switch (entry->type)
{
case bfd_link_hash_undefined:
case bfd_link_hash_undefweak:
 einfo (_(" relocation truncated to fit: %s against undefined symbol `%T'")(" 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")(" 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((asection *) &bfd_abs_section)
 ? output_bfd : entry->u.def.section->owner);
 break;
default:
 abort ()ld_abort ("/usr/src/gnu/usr.bin/binutils-2.17/ld/ldmain.c", 1489
, __PRETTY_FUNCTION__);
 break;
}
  }
else
  einfo (_(" relocation truncated to fit: %s against `%T'")(" relocation truncated to fit: %s against `%T'"),
  reloc_name, name);
if (addend != 0)
  einfo ("+%v", addend);
einfo ("\n");
return TRUE1;
1500}

1502/* This is called when a dangerous relocation is made.  */

1504static bfd_boolean
1505reloc_dangerous (struct bfd_link_info *info ATTRIBUTE_UNUSED__attribute__ ((__unused__)),
 const char *message,
 bfd *abfd,
 asection *section,
 bfd_vma address)
1510{
einfo (_("%X%C: dangerous relocation: %s\n")("%X%C: dangerous relocation: %s\n"),
abfd, section, address, message);
return TRUE1;
1514}

1516/* This is called when a reloc is being generated attached to a symbol
 that is not being output.  */

1519static bfd_boolean
1520unattached_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED__attribute__ ((__unused__)),
  const char *name,
  bfd *abfd,
  asection *section,
  bfd_vma address)
1525{
einfo (_("%X%C: reloc refers to symbol `%T' which is not being output\n")("%X%C: reloc refers to symbol `%T' which is not being output\n"
),
abfd, section, address, name);
return TRUE1;
1529}

1531/* This is called if link_info.notice_all is set, or when a symbol in
 link_info.notice_hash is found.  Symbols are put in notice_hash
 using the -y option.  */

1535static bfd_boolean
1536notice (struct bfd_link_info *info,
const char *name,
bfd *abfd,
asection *section,
bfd_vma value)
1541{
if (! info->notice_all
    || (info->notice_hash != NULL((void*)0)
 && bfd_hash_lookup (info->notice_hash, name, FALSE0, FALSE0) != NULL((void*)0)))
  {
    if (bfd_is_und_section (section)((section) == ((asection *) &bfd_und_section)))
einfo ("%B: reference to %s\n", abfd, name);
    else
einfo ("%B: definition of %s\n", abfd, name);
  }

if (command_line.cref || nocrossref_list != NULL((void*)0))
  add_cref (name, abfd, section, value);

return TRUE1;
1556}