WebSVN – Kolibri OS – Diff – /contrib/toolchain/binutils/ld/ldfile.c


/* Linker file opening and searching.
 
 
   Copyright (C) 1991-2015 Free Software Foundation, Inc.
 
   This file is part of the 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 3 of the License, or
   (at your option) any later version.
 
   This program 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 this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
   MA 02110-1301, USA.  */
 
#include "sysdep.h"
#include "bfd.h"
#include "bfdlink.h"
#include "safe-ctype.h"
#include "ld.h"
#include "ldmisc.h"
#include "ldexp.h"
#include "ldlang.h"
#include "ldfile.h"
#include "ldmain.h"
#include 
#include "ldlex.h"
#include "ldemul.h"
#include "libiberty.h"
#include "filenames.h"
#ifdef ENABLE_PLUGINS
#include "plugin-api.h"
#include "plugin.h"
#endif /* ENABLE_PLUGINS */
 
bfd_boolean  ldfile_assumed_script = FALSE;
const char * ldfile_output_machine_name = "";
unsigned long ldfile_output_machine;
enum bfd_architecture ldfile_output_architecture;
search_dirs_type * search_head;
 
#ifdef VMS
static char * slash = "";
#else
#if defined (_WIN32) && ! defined (__CYGWIN32__)
static char * slash = "\\";
#else
static char * slash = "/";
#endif
#endif
 
typedef struct search_arch
{
  char *name;
  struct search_arch *next;
} search_arch_type;
 
static search_dirs_type **search_tail_ptr = &search_head;
static search_arch_type *search_arch_head;
static search_arch_type **search_arch_tail_ptr = &search_arch_head;
 
/* Test whether a pathname, after canonicalization, is the same or a
   sub-directory of the sysroot directory.  */
 
static bfd_boolean
is_sysrooted_pathname (const char *name)
{
  char *realname;
  int len;
  bfd_boolean result;
 
  if (ld_canon_sysroot == NULL)
    return FALSE;
 
  realname = lrealpath (name);
  len = strlen (realname);
  result = FALSE;
  if (len > ld_canon_sysroot_len
      && IS_DIR_SEPARATOR (realname[ld_canon_sysroot_len]))
    {
      realname[ld_canon_sysroot_len] = '\0';
      result = FILENAME_CMP (ld_canon_sysroot, realname) == 0;
    }
 
  free (realname);
  return result;
}
 
/* Adds NAME to the library search path.
   Makes a copy of NAME using xmalloc().  */
 
void
ldfile_add_library_path (const char *name, bfd_boolean cmdline)
{
  search_dirs_type *new_dirs;
 
  if (!cmdline && config.only_cmd_line_lib_dirs)
    return;
 
  new_dirs = (search_dirs_type *) xmalloc (sizeof (search_dirs_type));
  new_dirs->next = NULL;
  new_dirs->cmdline = cmdline;
  *search_tail_ptr = new_dirs;
  search_tail_ptr = &new_dirs->next;
 
  /* If a directory is marked as honoring sysroot, prepend the sysroot path
     now.  */
  if (name[0] == '=')
    new_dirs->name = concat (ld_sysroot, name + 1, (const char *) NULL);
  else
    new_dirs->name = xstrdup (name);
}
 
/* Try to open a BFD for a lang_input_statement.  */
 
bfd_boolean
ldfile_try_open_bfd (const char *attempt,
		     lang_input_statement_type *entry)
{
  entry->the_bfd = bfd_openr (attempt, entry->target);
 
  if (verbose)
    {
      if (entry->the_bfd == NULL)
	info_msg (_("attempt to open %s failed\n"), attempt);
      else
	info_msg (_("attempt to open %s succeeded\n"), attempt);
    }
 
  if (entry->the_bfd == NULL)
    {
      if (bfd_get_error () == bfd_error_invalid_target)
	einfo (_("%F%P: invalid BFD target `%s'\n"), entry->target);
      return FALSE;
    }
 
  /* Linker needs to decompress sections.  */
  entry->the_bfd->flags |= BFD_DECOMPRESS;
 
  /* This is a linker input BFD.  */
  entry->the_bfd->is_linker_input = 1;
 
#ifdef ENABLE_PLUGINS
  if (entry->flags.lto_output)
    entry->the_bfd->lto_output = 1;
#endif
 
  /* If we are searching for this file, see if the architecture is
     compatible with the output file.  If it isn't, keep searching.
     If we can't open the file as an object file, stop the search
     here.  If we are statically linking, ensure that we don't link
     a dynamic object.
 
     In the code below, it's OK to exit early if the check fails,
     closing the checked BFD and returning FALSE, but if the BFD
     checks out compatible, do not exit early returning TRUE, or
     the plugins will not get a chance to claim the file.  */
 
  if (entry->flags.search_dirs || !entry->flags.dynamic)
    {
      bfd *check;
 
      if (bfd_check_format (entry->the_bfd, bfd_archive))
	check = bfd_openr_next_archived_file (entry->the_bfd, NULL);
      else
	check = entry->the_bfd;
 
      if (check != NULL)
	{
	  if (! bfd_check_format (check, bfd_object))
	    {
	      if (check == entry->the_bfd
		  && entry->flags.search_dirs
		  && bfd_get_error () == bfd_error_file_not_recognized
		  && ! ldemul_unrecognized_file (entry))
		{
		  int token, skip = 0;
		  char *arg, *arg1, *arg2, *arg3;
		  extern FILE *yyin;
 
		  /* Try to interpret the file as a linker script.  */
		  ldfile_open_command_file (attempt);
 
		  ldfile_assumed_script = TRUE;
		  parser_input = input_selected;
		  ldlex_both ();
		  token = INPUT_SCRIPT;
		  while (token != 0)
		    {
		      switch (token)
			{
			case OUTPUT_FORMAT:
			  if ((token = yylex ()) != '(')
			    continue;
			  if ((token = yylex ()) != NAME)
			    continue;
			  arg1 = yylval.name;
			  arg2 = NULL;
			  arg3 = NULL;
			  token = yylex ();
			  if (token == ',')
			    {
			      if ((token = yylex ()) != NAME)
				{
				  free (arg1);
				  continue;
				}
			      arg2 = yylval.name;
			      if ((token = yylex ()) != ','
				  || (token = yylex ()) != NAME)
				{
				  free (arg1);
				  free (arg2);
				  continue;
				}
			      arg3 = yylval.name;
			      token = yylex ();
			    }
			  if (token == ')')
			    {
			      switch (command_line.endian)
				{
				default:
				case ENDIAN_UNSET:
				  arg = arg1; break;
				case ENDIAN_BIG:
				  arg = arg2 ? arg2 : arg1; break;
				case ENDIAN_LITTLE:
				  arg = arg3 ? arg3 : arg1; break;
				}
			      if (strcmp (arg, lang_get_output_target ()) != 0)
				skip = 1;
			    }
			  free (arg1);
			  if (arg2) free (arg2);
			  if (arg3) free (arg3);
			  break;
			case NAME:
			case LNAME:
			case VERS_IDENTIFIER:
			case VERS_TAG:
			  free (yylval.name);
			  break;
			case INT:
			  if (yylval.bigint.str)
			    free (yylval.bigint.str);
			  break;
			}
		      token = yylex ();
		    }
		  ldlex_popstate ();
		  ldfile_assumed_script = FALSE;
		  fclose (yyin);
		  yyin = NULL;
		  if (skip)
		    {
		      if (command_line.warn_search_mismatch)
			einfo (_("%P: skipping incompatible %s "
				 "when searching for %s\n"),
			       attempt, entry->local_sym_name);
		      bfd_close (entry->the_bfd);
		      entry->the_bfd = NULL;
		      return FALSE;
		    }
		}
	      goto success;
	    }
 
	  if (!entry->flags.dynamic && (entry->the_bfd->flags & DYNAMIC) != 0)
	    {
	      einfo (_("%F%P: attempted static link of dynamic object `%s'\n"),
		     attempt);
	      bfd_close (entry->the_bfd);
	      entry->the_bfd = NULL;
	      return FALSE;
	    }
 
	  if (entry->flags.search_dirs
	      && !bfd_arch_get_compatible (check, link_info.output_bfd,
					   command_line.accept_unknown_input_arch)
	      /* XCOFF archives can have 32 and 64 bit objects.  */
	      && ! (bfd_get_flavour (check) == bfd_target_xcoff_flavour
		    && bfd_get_flavour (link_info.output_bfd) == bfd_target_xcoff_flavour
		    && bfd_check_format (entry->the_bfd, bfd_archive)))
	    {
	      if (command_line.warn_search_mismatch)
		einfo (_("%P: skipping incompatible %s "
			 "when searching for %s\n"),
		       attempt, entry->local_sym_name);
	      bfd_close (entry->the_bfd);
	      entry->the_bfd = NULL;
	      return FALSE;
	    }
	}
    }
success:
#ifdef ENABLE_PLUGINS
  /* If plugins are active, they get first chance to claim
     any successfully-opened input file.  We skip archives
     here; the plugin wants us to offer it the individual
     members when we enumerate them, not the whole file.  We
     also ignore corefiles, because that's just weird.  It is
     a needed side-effect of calling  bfd_check_format with
     bfd_object that it sets the bfd's arch and mach, which
     will be needed when and if we want to bfd_create a new
     one using this one as a template.  */
 
  if (link_info.lto_plugin_active
      && !no_more_claiming
 
      && bfd_check_format (entry->the_bfd, bfd_object))
 
 
 
 
 
 
 
 
    plugin_maybe_claim (entry);
 
 
#endif /* ENABLE_PLUGINS */
 
  /* It opened OK, the format checked out, and the plugins have had
     their chance to claim it, so this is success.  */
  return TRUE;
}
 
/* Search for and open the file specified by ENTRY.  If it is an
   archive, use ARCH, LIB and SUFFIX to modify the file name.  */
 
bfd_boolean
ldfile_open_file_search (const char *arch,
			 lang_input_statement_type *entry,
			 const char *lib,
			 const char *suffix)
{
  search_dirs_type *search;
 
  /* If this is not an archive, try to open it in the current
     directory first.  */
  if (! entry->flags.maybe_archive)
    {
      if (entry->flags.sysrooted && IS_ABSOLUTE_PATH (entry->filename))
	{
	  char *name = concat (ld_sysroot, entry->filename,
			       (const char *) NULL);
	  if (ldfile_try_open_bfd (name, entry))
	    {
	      entry->filename = name;
	      return TRUE;
	    }
	  free (name);
	}
      else if (ldfile_try_open_bfd (entry->filename, entry))
	return TRUE;
 
      if (IS_ABSOLUTE_PATH (entry->filename))
	return FALSE;
    }
 
  for (search = search_head; search != NULL; search = search->next)
    {
      char *string;
 
      if (entry->flags.dynamic && !bfd_link_relocatable (&link_info))
	{
	  if (ldemul_open_dynamic_archive (arch, search, entry))
	    return TRUE;
	}
 
      if (entry->flags.maybe_archive && !entry->flags.full_name_provided)
	string = concat (search->name, slash, lib, entry->filename,
			 arch, suffix, (const char *) NULL);
      else
	string = concat (search->name, slash, entry->filename,
			 (const char *) 0);
 
      if (ldfile_try_open_bfd (string, entry))
	{
	  entry->filename = string;
	  return TRUE;
	}
 
      free (string);
    }
 
  return FALSE;
}
 
/* Open the input file specified by ENTRY.
   PR 4437: Do not stop on the first missing file, but
   continue processing other input files in case there
   are more errors to report.  */
 
void
ldfile_open_file (lang_input_statement_type *entry)
{
  if (entry->the_bfd != NULL)
    return;
 
  if (! entry->flags.search_dirs)
    {
      if (ldfile_try_open_bfd (entry->filename, entry))
	return;
 
      if (filename_cmp (entry->filename, entry->local_sym_name) != 0)
	einfo (_("%P: cannot find %s (%s): %E\n"),
	       entry->filename, entry->local_sym_name);
      else
	einfo (_("%P: cannot find %s: %E\n"), entry->local_sym_name);
 
      entry->flags.missing_file = TRUE;
      input_flags.missing_file = TRUE;
    }
  else
    {
      search_arch_type *arch;
      bfd_boolean found = FALSE;
 
      /* Try to open  or lib.a */
      for (arch = search_arch_head; arch != NULL; arch = arch->next)
	{
	  found = ldfile_open_file_search (arch->name, entry, "lib", ".a");
	  if (found)
	    break;
#ifdef VMS
	  found = ldfile_open_file_search (arch->name, entry, ":lib", ".a");
	  if (found)
	    break;
#endif
	  found = ldemul_find_potential_libraries (arch->name, entry);
	  if (found)
	    break;
	}
 
      /* If we have found the file, we don't need to search directories
	 again.  */
      if (found)
	entry->flags.search_dirs = FALSE;
      else
	{
	  if (entry->flags.sysrooted
	       && ld_sysroot
	       && IS_ABSOLUTE_PATH (entry->local_sym_name))
	    einfo (_("%P: cannot find %s inside %s\n"),
		   entry->local_sym_name, ld_sysroot);
	  else
	    einfo (_("%P: cannot find %s\n"), entry->local_sym_name);
	  entry->flags.missing_file = TRUE;
	  input_flags.missing_file = TRUE;
	}
    }
}
 
/* Try to open NAME.  */
 
static FILE *
try_open (const char *name, bfd_boolean *sysrooted)
{
  FILE *result;
 
  result = fopen (name, "r");
 
  if (result != NULL)
    *sysrooted = is_sysrooted_pathname (name);
 
  if (verbose)
    {
      if (result == NULL)
	info_msg (_("cannot find script file %s\n"), name);
      else
	info_msg (_("opened script file %s\n"), name);
    }
 
  return result;
}
 
/* Return TRUE iff directory DIR contains an "ldscripts" subdirectory.  */
 
static bfd_boolean
check_for_scripts_dir (char *dir)
{
  char *buf;
  struct stat s;
  bfd_boolean res;
 
  buf = concat (dir, "/ldscripts", (const char *) NULL);
  res = stat (buf, &s) == 0 && S_ISDIR (s.st_mode);
  free (buf);
  return res;
}
 
/* Return the default directory for finding script files.
   We look for the "ldscripts" directory in:
 
   SCRIPTDIR (passed from Makefile)
	     (adjusted according to the current location of the binary)
   the dir where this program is (for using it from the build tree).  */
 
static char *
find_scripts_dir (void)
{
  char *dir;
 
  dir = make_relative_prefix (program_name, BINDIR, SCRIPTDIR);
  if (dir)
    {
      if (check_for_scripts_dir (dir))
	return dir;
      free (dir);
    }
 
  dir = make_relative_prefix (program_name, TOOLBINDIR, SCRIPTDIR);
  if (dir)
    {
      if (check_for_scripts_dir (dir))
	return dir;
      free (dir);
    }
 
  /* Look for "ldscripts" in the dir where our binary is.  */
  dir = make_relative_prefix (program_name, ".", ".");
  if (dir)
    {
      if (check_for_scripts_dir (dir))
	return dir;
      free (dir);
    }
 
  return NULL;
}
 
/* If DEFAULT_ONLY is false, try to open NAME; if that fails, look for
   it in directories specified with -L, then in the default script
   directory.  If DEFAULT_ONLY is true, the search is restricted to
   the default script location.  */
 
static FILE *
ldfile_find_command_file (const char *name,
			  bfd_boolean default_only,
			  bfd_boolean *sysrooted)
{
  search_dirs_type *search;
  FILE *result = NULL;
  char *path;
  static search_dirs_type *script_search;
 
  if (!default_only)
    {
      /* First try raw name.  */
      result = try_open (name, sysrooted);
      if (result != NULL)
	return result;
    }
 
  if (!script_search)
    {
      char *script_dir = find_scripts_dir ();
      if (script_dir)
	{
	  search_dirs_type **save_tail_ptr = search_tail_ptr;
	  search_tail_ptr = &script_search;
	  ldfile_add_library_path (script_dir, TRUE);
	  search_tail_ptr = save_tail_ptr;
	}
    }
 
  /* Temporarily append script_search to the path list so that the
     paths specified with -L will be searched first.  */
  *search_tail_ptr = script_search;
 
  /* Try now prefixes.  */
  for (search = default_only ? script_search : search_head;
       search != NULL;
       search = search->next)
    {
      path = concat (search->name, slash, name, (const char *) NULL);
      result = try_open (path, sysrooted);
      free (path);
      if (result)
	break;
    }
 
  /* Restore the original path list.  */
  *search_tail_ptr = NULL;
 
  return result;
}
 
/* Open command file NAME.  */
 
static void
ldfile_open_command_file_1 (const char *name, bfd_boolean default_only)
{
  FILE *ldlex_input_stack;
  bfd_boolean sysrooted;
 
  ldlex_input_stack = ldfile_find_command_file (name, default_only, &sysrooted);
 
  if (ldlex_input_stack == NULL)
    {
      bfd_set_error (bfd_error_system_call);
      einfo (_("%P%F: cannot open linker script file %s: %E\n"), name);
      return;
    }
 
  lex_push_file (ldlex_input_stack, name, sysrooted);
 
  lineno = 1;
 
  saved_script_handle = ldlex_input_stack;
}
 
/* Open command file NAME in the current directory, -L directories,
   the default script location, in that order.  */
 
void
ldfile_open_command_file (const char *name)
{
  ldfile_open_command_file_1 (name, FALSE);
}
 
/* Open command file NAME at the default script location.  */
 
void
ldfile_open_default_command_file (const char *name)
{
  ldfile_open_command_file_1 (name, TRUE);
}
 
void
ldfile_add_arch (const char *in_name)
{
  char *name = xstrdup (in_name);
  search_arch_type *new_arch = (search_arch_type *)
      xmalloc (sizeof (search_arch_type));
 
  ldfile_output_machine_name = in_name;
 
  new_arch->name = name;
  new_arch->next = NULL;
  while (*name)
    {
      *name = TOLOWER (*name);
      name++;
    }
  *search_arch_tail_ptr = new_arch;
  search_arch_tail_ptr = &new_arch->next;
 
}
 
/* Set the output architecture.  */
 
void
ldfile_set_output_arch (const char *string, enum bfd_architecture defarch)
{
  const bfd_arch_info_type *arch = bfd_scan_arch (string);
 
  if (arch)
    {
      ldfile_output_architecture = arch->arch;
      ldfile_output_machine = arch->mach;
      ldfile_output_machine_name = arch->printable_name;
    }
  else if (defarch != bfd_arch_unknown)
    ldfile_output_architecture = defarch;
  else
    einfo (_("%P%F: cannot represent machine `%s'\n"), string);
}

Rev 5211	Rev 6324
1	/* Linker file opening and searching.	1	/* Linker file opening and searching.
2	Copyright 1991, 1992, 1993, 1994, 1995, 1998, 1999, 2000, 2001, 2002,	-
3	2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011, 2012	-
4	Free Software Foundation, Inc.	2	Copyright (C) 1991-2015 Free Software Foundation, Inc.
5		3
6	This file is part of the GNU Binutils.	4	This file is part of the GNU Binutils.
7		5
8	This program is free software; you can redistribute it and/or modify	6	This program is free software; you can redistribute it and/or modify
9	it under the terms of the GNU General Public License as published by	7	it under the terms of the GNU General Public License as published by
10	the Free Software Foundation; either version 3 of the License, or	8	the Free Software Foundation; either version 3 of the License, or
11	(at your option) any later version.	9	(at your option) any later version.
12		10
13	This program is distributed in the hope that it will be useful,	11	This program is distributed in the hope that it will be useful,
14	but WITHOUT ANY WARRANTY; without even the implied warranty of	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	GNU General Public License for more details.	14	GNU General Public License for more details.
17		15
18	You should have received a copy of the GNU General Public License	16	You should have received a copy of the GNU General Public License
19	along with this program; if not, write to the Free Software	17	along with this program; if not, write to the Free Software
20	Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,	18	Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21	MA 02110-1301, USA. */	19	MA 02110-1301, USA. */
22		20
23	#include "sysdep.h"	21	#include "sysdep.h"
24	#include "bfd.h"	22	#include "bfd.h"
25	#include "bfdlink.h"	23	#include "bfdlink.h"
26	#include "safe-ctype.h"	24	#include "safe-ctype.h"
27	#include "ld.h"	25	#include "ld.h"
28	#include "ldmisc.h"	26	#include "ldmisc.h"
29	#include "ldexp.h"	27	#include "ldexp.h"
30	#include "ldlang.h"	28	#include "ldlang.h"
31	#include "ldfile.h"	29	#include "ldfile.h"
32	#include "ldmain.h"	30	#include "ldmain.h"
33	#include	31	#include
34	#include "ldlex.h"	32	#include "ldlex.h"
35	#include "ldemul.h"	33	#include "ldemul.h"
36	#include "libiberty.h"	34	#include "libiberty.h"
37	#include "filenames.h"	35	#include "filenames.h"
38	#ifdef ENABLE_PLUGINS	36	#ifdef ENABLE_PLUGINS
39	#include "plugin-api.h"	37	#include "plugin-api.h"
40	#include "plugin.h"	38	#include "plugin.h"
41	#endif /* ENABLE_PLUGINS */	39	#endif /* ENABLE_PLUGINS */
42		40
43	bfd_boolean ldfile_assumed_script = FALSE;	41	bfd_boolean ldfile_assumed_script = FALSE;
44	const char * ldfile_output_machine_name = "";	42	const char * ldfile_output_machine_name = "";
45	unsigned long ldfile_output_machine;	43	unsigned long ldfile_output_machine;
46	enum bfd_architecture ldfile_output_architecture;	44	enum bfd_architecture ldfile_output_architecture;
47	search_dirs_type * search_head;	45	search_dirs_type * search_head;
48		46
49	#ifdef VMS	47	#ifdef VMS
50	static char * slash = "";	48	static char * slash = "";
51	#else	49	#else
52	#if defined (_WIN32) && ! defined (__CYGWIN32__)	50	#if defined (_WIN32) && ! defined (__CYGWIN32__)
53	static char * slash = "\\";	51	static char * slash = "\\";
54	#else	52	#else
55	static char * slash = "/";	53	static char * slash = "/";
56	#endif	54	#endif
57	#endif	55	#endif
58		56
59	typedef struct search_arch	57	typedef struct search_arch
60	{	58	{
61	char *name;	59	char *name;
62	struct search_arch *next;	60	struct search_arch *next;
63	} search_arch_type;	61	} search_arch_type;
64		62
65	static search_dirs_type **search_tail_ptr = &search_head;	63	static search_dirs_type **search_tail_ptr = &search_head;
66	static search_arch_type *search_arch_head;	64	static search_arch_type *search_arch_head;
67	static search_arch_type **search_arch_tail_ptr = &search_arch_head;	65	static search_arch_type **search_arch_tail_ptr = &search_arch_head;
68		66
69	/* Test whether a pathname, after canonicalization, is the same or a	67	/* Test whether a pathname, after canonicalization, is the same or a
70	sub-directory of the sysroot directory. */	68	sub-directory of the sysroot directory. */
71		69
72	static bfd_boolean	70	static bfd_boolean
73	is_sysrooted_pathname (const char *name)	71	is_sysrooted_pathname (const char *name)
74	{	72	{
75	char *realname;	73	char *realname;
76	int len;	74	int len;
77	bfd_boolean result;	75	bfd_boolean result;
78		76
79	if (ld_canon_sysroot == NULL)	77	if (ld_canon_sysroot == NULL)
80	return FALSE;	78	return FALSE;
81		79
82	realname = lrealpath (name);	80	realname = lrealpath (name);
83	len = strlen (realname);	81	len = strlen (realname);
84	result = FALSE;	82	result = FALSE;
85	if (len > ld_canon_sysroot_len	83	if (len > ld_canon_sysroot_len
86	&& IS_DIR_SEPARATOR (realname[ld_canon_sysroot_len]))	84	&& IS_DIR_SEPARATOR (realname[ld_canon_sysroot_len]))
87	{	85	{
88	realname[ld_canon_sysroot_len] = '\0';	86	realname[ld_canon_sysroot_len] = '\0';
89	result = FILENAME_CMP (ld_canon_sysroot, realname) == 0;	87	result = FILENAME_CMP (ld_canon_sysroot, realname) == 0;
90	}	88	}
91		89
92	free (realname);	90	free (realname);
93	return result;	91	return result;
94	}	92	}
95		93
96	/* Adds NAME to the library search path.	94	/* Adds NAME to the library search path.
97	Makes a copy of NAME using xmalloc(). */	95	Makes a copy of NAME using xmalloc(). */
98		96
99	void	97	void
100	ldfile_add_library_path (const char *name, bfd_boolean cmdline)	98	ldfile_add_library_path (const char *name, bfd_boolean cmdline)
101	{	99	{
102	search_dirs_type *new_dirs;	100	search_dirs_type *new_dirs;
103		101
104	if (!cmdline && config.only_cmd_line_lib_dirs)	102	if (!cmdline && config.only_cmd_line_lib_dirs)
105	return;	103	return;
106		104
107	new_dirs = (search_dirs_type *) xmalloc (sizeof (search_dirs_type));	105	new_dirs = (search_dirs_type *) xmalloc (sizeof (search_dirs_type));
108	new_dirs->next = NULL;	106	new_dirs->next = NULL;
109	new_dirs->cmdline = cmdline;	107	new_dirs->cmdline = cmdline;
110	*search_tail_ptr = new_dirs;	108	*search_tail_ptr = new_dirs;
111	search_tail_ptr = &new_dirs->next;	109	search_tail_ptr = &new_dirs->next;
112		110
113	/* If a directory is marked as honoring sysroot, prepend the sysroot path	111	/* If a directory is marked as honoring sysroot, prepend the sysroot path
114	now. */	112	now. */
115	if (name[0] == '=')	113	if (name[0] == '=')
116	new_dirs->name = concat (ld_sysroot, name + 1, (const char *) NULL);	114	new_dirs->name = concat (ld_sysroot, name + 1, (const char *) NULL);
117	else	115	else
118	new_dirs->name = xstrdup (name);	116	new_dirs->name = xstrdup (name);
119	}	117	}
120		118
121	/* Try to open a BFD for a lang_input_statement. */	119	/* Try to open a BFD for a lang_input_statement. */
122		120
123	bfd_boolean	121	bfd_boolean
124	ldfile_try_open_bfd (const char *attempt,	122	ldfile_try_open_bfd (const char *attempt,
125	lang_input_statement_type *entry)	123	lang_input_statement_type *entry)
126	{	124	{
127	entry->the_bfd = bfd_openr (attempt, entry->target);	125	entry->the_bfd = bfd_openr (attempt, entry->target);
128		126
129	if (verbose)	127	if (verbose)
130	{	128	{
131	if (entry->the_bfd == NULL)	129	if (entry->the_bfd == NULL)
132	info_msg (_("attempt to open %s failed\n"), attempt);	130	info_msg (_("attempt to open %s failed\n"), attempt);
133	else	131	else
134	info_msg (_("attempt to open %s succeeded\n"), attempt);	132	info_msg (_("attempt to open %s succeeded\n"), attempt);
135	}	133	}
136		134
137	if (entry->the_bfd == NULL)	135	if (entry->the_bfd == NULL)
138	{	136	{
139	if (bfd_get_error () == bfd_error_invalid_target)	137	if (bfd_get_error () == bfd_error_invalid_target)
140	einfo (_("%F%P: invalid BFD target `%s'\n"), entry->target);	138	einfo (_("%F%P: invalid BFD target `%s'\n"), entry->target);
141	return FALSE;	139	return FALSE;
142	}	140	}
143		141
144	/* Linker needs to decompress sections. */	142	/* Linker needs to decompress sections. */
145	entry->the_bfd->flags \|= BFD_DECOMPRESS;	143	entry->the_bfd->flags \|= BFD_DECOMPRESS;
-		144
-		145	/* This is a linker input BFD. */
-		146	entry->the_bfd->is_linker_input = 1;
-		147
-		148	#ifdef ENABLE_PLUGINS
-		149	if (entry->flags.lto_output)
-		150	entry->the_bfd->lto_output = 1;
-		151	#endif
146		152
147	/* If we are searching for this file, see if the architecture is	153	/* If we are searching for this file, see if the architecture is
148	compatible with the output file. If it isn't, keep searching.	154	compatible with the output file. If it isn't, keep searching.
149	If we can't open the file as an object file, stop the search	155	If we can't open the file as an object file, stop the search
150	here. If we are statically linking, ensure that we don't link	156	here. If we are statically linking, ensure that we don't link
151	a dynamic object.	157	a dynamic object.
152		158
153	In the code below, it's OK to exit early if the check fails,	159	In the code below, it's OK to exit early if the check fails,
154	closing the checked BFD and returning FALSE, but if the BFD	160	closing the checked BFD and returning FALSE, but if the BFD
155	checks out compatible, do not exit early returning TRUE, or	161	checks out compatible, do not exit early returning TRUE, or
156	the plugins will not get a chance to claim the file. */	162	the plugins will not get a chance to claim the file. */
157		163
158	if (entry->flags.search_dirs \|\| !entry->flags.dynamic)	164	if (entry->flags.search_dirs \|\| !entry->flags.dynamic)
159	{	165	{
160	bfd *check;	166	bfd *check;
161		167
162	if (bfd_check_format (entry->the_bfd, bfd_archive))	168	if (bfd_check_format (entry->the_bfd, bfd_archive))
163	check = bfd_openr_next_archived_file (entry->the_bfd, NULL);	169	check = bfd_openr_next_archived_file (entry->the_bfd, NULL);
164	else	170	else
165	check = entry->the_bfd;	171	check = entry->the_bfd;
166		172
167	if (check != NULL)	173	if (check != NULL)
168	{	174	{
169	if (! bfd_check_format (check, bfd_object))	175	if (! bfd_check_format (check, bfd_object))
170	{	176	{
171	if (check == entry->the_bfd	177	if (check == entry->the_bfd
172	&& entry->flags.search_dirs	178	&& entry->flags.search_dirs
173	&& bfd_get_error () == bfd_error_file_not_recognized	179	&& bfd_get_error () == bfd_error_file_not_recognized
174	&& ! ldemul_unrecognized_file (entry))	180	&& ! ldemul_unrecognized_file (entry))
175	{	181	{
176	int token, skip = 0;	182	int token, skip = 0;
177	char arg, arg1, arg2, arg3;	183	char arg, arg1, arg2, arg3;
178	extern FILE *yyin;	184	extern FILE *yyin;
179		185
180	/* Try to interpret the file as a linker script. */	186	/* Try to interpret the file as a linker script. */
181	ldfile_open_command_file (attempt);	187	ldfile_open_command_file (attempt);
182		188
183	ldfile_assumed_script = TRUE;	189	ldfile_assumed_script = TRUE;
184	parser_input = input_selected;	190	parser_input = input_selected;
185	ldlex_both ();	191	ldlex_both ();
186	token = INPUT_SCRIPT;	192	token = INPUT_SCRIPT;
187	while (token != 0)	193	while (token != 0)
188	{	194	{
189	switch (token)	195	switch (token)
190	{	196	{
191	case OUTPUT_FORMAT:	197	case OUTPUT_FORMAT:
192	if ((token = yylex ()) != '(')	198	if ((token = yylex ()) != '(')
193	continue;	199	continue;
194	if ((token = yylex ()) != NAME)	200	if ((token = yylex ()) != NAME)
195	continue;	201	continue;
196	arg1 = yylval.name;	202	arg1 = yylval.name;
197	arg2 = NULL;	203	arg2 = NULL;
198	arg3 = NULL;	204	arg3 = NULL;
199	token = yylex ();	205	token = yylex ();
200	if (token == ',')	206	if (token == ',')
201	{	207	{
202	if ((token = yylex ()) != NAME)	208	if ((token = yylex ()) != NAME)
203	{	209	{
204	free (arg1);	210	free (arg1);
205	continue;	211	continue;
206	}	212	}
207	arg2 = yylval.name;	213	arg2 = yylval.name;
208	if ((token = yylex ()) != ','	214	if ((token = yylex ()) != ','
209	\|\| (token = yylex ()) != NAME)	215	\|\| (token = yylex ()) != NAME)
210	{	216	{
211	free (arg1);	217	free (arg1);
212	free (arg2);	218	free (arg2);
213	continue;	219	continue;
214	}	220	}
215	arg3 = yylval.name;	221	arg3 = yylval.name;
216	token = yylex ();	222	token = yylex ();
217	}	223	}
218	if (token == ')')	224	if (token == ')')
219	{	225	{
220	switch (command_line.endian)	226	switch (command_line.endian)
221	{	227	{
222	default:	228	default:
223	case ENDIAN_UNSET:	229	case ENDIAN_UNSET:
224	arg = arg1; break;	230	arg = arg1; break;
225	case ENDIAN_BIG:	231	case ENDIAN_BIG:
226	arg = arg2 ? arg2 : arg1; break;	232	arg = arg2 ? arg2 : arg1; break;
227	case ENDIAN_LITTLE:	233	case ENDIAN_LITTLE:
228	arg = arg3 ? arg3 : arg1; break;	234	arg = arg3 ? arg3 : arg1; break;
229	}	235	}
230	if (strcmp (arg, lang_get_output_target ()) != 0)	236	if (strcmp (arg, lang_get_output_target ()) != 0)
231	skip = 1;	237	skip = 1;
232	}	238	}
233	free (arg1);	239	free (arg1);
234	if (arg2) free (arg2);	240	if (arg2) free (arg2);
235	if (arg3) free (arg3);	241	if (arg3) free (arg3);
236	break;	242	break;
237	case NAME:	243	case NAME:
238	case LNAME:	244	case LNAME:
239	case VERS_IDENTIFIER:	245	case VERS_IDENTIFIER:
240	case VERS_TAG:	246	case VERS_TAG:
241	free (yylval.name);	247	free (yylval.name);
242	break;	248	break;
243	case INT:	249	case INT:
244	if (yylval.bigint.str)	250	if (yylval.bigint.str)
245	free (yylval.bigint.str);	251	free (yylval.bigint.str);
246	break;	252	break;
247	}	253	}
248	token = yylex ();	254	token = yylex ();
249	}	255	}
250	ldlex_popstate ();	256	ldlex_popstate ();
251	ldfile_assumed_script = FALSE;	257	ldfile_assumed_script = FALSE;
252	fclose (yyin);	258	fclose (yyin);
253	yyin = NULL;	259	yyin = NULL;
254	if (skip)	260	if (skip)
255	{	261	{
256	if (command_line.warn_search_mismatch)	262	if (command_line.warn_search_mismatch)
257	einfo (_("%P: skipping incompatible %s "	263	einfo (_("%P: skipping incompatible %s "
258	"when searching for %s\n"),	264	"when searching for %s\n"),
259	attempt, entry->local_sym_name);	265	attempt, entry->local_sym_name);
260	bfd_close (entry->the_bfd);	266	bfd_close (entry->the_bfd);
261	entry->the_bfd = NULL;	267	entry->the_bfd = NULL;
262	return FALSE;	268	return FALSE;
263	}	269	}
264	}	270	}
265	goto success;	271	goto success;
266	}	272	}
267		273
268	if (!entry->flags.dynamic && (entry->the_bfd->flags & DYNAMIC) != 0)	274	if (!entry->flags.dynamic && (entry->the_bfd->flags & DYNAMIC) != 0)
269	{	275	{
270	einfo (_("%F%P: attempted static link of dynamic object `%s'\n"),	276	einfo (_("%F%P: attempted static link of dynamic object `%s'\n"),
271	attempt);	277	attempt);
272	bfd_close (entry->the_bfd);	278	bfd_close (entry->the_bfd);
273	entry->the_bfd = NULL;	279	entry->the_bfd = NULL;
274	return FALSE;	280	return FALSE;
275	}	281	}
276		282
277	if (entry->flags.search_dirs	283	if (entry->flags.search_dirs
278	&& !bfd_arch_get_compatible (check, link_info.output_bfd,	284	&& !bfd_arch_get_compatible (check, link_info.output_bfd,
279	command_line.accept_unknown_input_arch)	285	command_line.accept_unknown_input_arch)
280	/* XCOFF archives can have 32 and 64 bit objects. */	286	/* XCOFF archives can have 32 and 64 bit objects. */
281	&& ! (bfd_get_flavour (check) == bfd_target_xcoff_flavour	287	&& ! (bfd_get_flavour (check) == bfd_target_xcoff_flavour
282	&& bfd_get_flavour (link_info.output_bfd) == bfd_target_xcoff_flavour	288	&& bfd_get_flavour (link_info.output_bfd) == bfd_target_xcoff_flavour
283	&& bfd_check_format (entry->the_bfd, bfd_archive)))	289	&& bfd_check_format (entry->the_bfd, bfd_archive)))
284	{	290	{
285	if (command_line.warn_search_mismatch)	291	if (command_line.warn_search_mismatch)
286	einfo (_("%P: skipping incompatible %s "	292	einfo (_("%P: skipping incompatible %s "
287	"when searching for %s\n"),	293	"when searching for %s\n"),
288	attempt, entry->local_sym_name);	294	attempt, entry->local_sym_name);
289	bfd_close (entry->the_bfd);	295	bfd_close (entry->the_bfd);
290	entry->the_bfd = NULL;	296	entry->the_bfd = NULL;
291	return FALSE;	297	return FALSE;
292	}	298	}
293	}	299	}
294	}	300	}
295	success:	301	success:
296	#ifdef ENABLE_PLUGINS	302	#ifdef ENABLE_PLUGINS
297	/* If plugins are active, they get first chance to claim	303	/* If plugins are active, they get first chance to claim
298	any successfully-opened input file. We skip archives	304	any successfully-opened input file. We skip archives
299	here; the plugin wants us to offer it the individual	305	here; the plugin wants us to offer it the individual
300	members when we enumerate them, not the whole file. We	306	members when we enumerate them, not the whole file. We
301	also ignore corefiles, because that's just weird. It is	307	also ignore corefiles, because that's just weird. It is
302	a needed side-effect of calling bfd_check_format with	308	a needed side-effect of calling bfd_check_format with
303	bfd_object that it sets the bfd's arch and mach, which	309	bfd_object that it sets the bfd's arch and mach, which
304	will be needed when and if we want to bfd_create a new	310	will be needed when and if we want to bfd_create a new
305	one using this one as a template. */	311	one using this one as a template. */
306	if (bfd_check_format (entry->the_bfd, bfd_object)	-
307	&& plugin_active_plugins_p ()	312	if (link_info.lto_plugin_active
308	&& !no_more_claiming)	313	&& !no_more_claiming
309	{	-
310	int fd = open (attempt, O_RDONLY \| O_BINARY);	314	&& bfd_check_format (entry->the_bfd, bfd_object))
311	if (fd >= 0)	-
312	{	-
313	struct ld_plugin_input_file file;	-
314		-
315	file.name = attempt;	-
316	file.offset = 0;	-
317	file.filesize = lseek (fd, 0, SEEK_END);	-
318	file.fd = fd;	-
319	plugin_maybe_claim (&file, entry);	315	plugin_maybe_claim (entry);
320	}	-
321	}	-
322	#endif /* ENABLE_PLUGINS */	316	#endif /* ENABLE_PLUGINS */
323		317
324	/* It opened OK, the format checked out, and the plugins have had	318	/* It opened OK, the format checked out, and the plugins have had
325	their chance to claim it, so this is success. */	319	their chance to claim it, so this is success. */
326	return TRUE;	320	return TRUE;
327	}	321	}
328		322
329	/* Search for and open the file specified by ENTRY. If it is an	323	/* Search for and open the file specified by ENTRY. If it is an
330	archive, use ARCH, LIB and SUFFIX to modify the file name. */	324	archive, use ARCH, LIB and SUFFIX to modify the file name. */
331		325
332	bfd_boolean	326	bfd_boolean
333	ldfile_open_file_search (const char *arch,	327	ldfile_open_file_search (const char *arch,
334	lang_input_statement_type *entry,	328	lang_input_statement_type *entry,
335	const char *lib,	329	const char *lib,
336	const char *suffix)	330	const char *suffix)
337	{	331	{
338	search_dirs_type *search;	332	search_dirs_type *search;
339		333
340	/* If this is not an archive, try to open it in the current	334	/* If this is not an archive, try to open it in the current
341	directory first. */	335	directory first. */
342	if (! entry->flags.maybe_archive)	336	if (! entry->flags.maybe_archive)
343	{	337	{
344	if (entry->flags.sysrooted && IS_ABSOLUTE_PATH (entry->filename))	338	if (entry->flags.sysrooted && IS_ABSOLUTE_PATH (entry->filename))
345	{	339	{
346	char *name = concat (ld_sysroot, entry->filename,	340	char *name = concat (ld_sysroot, entry->filename,
347	(const char *) NULL);	341	(const char *) NULL);
348	if (ldfile_try_open_bfd (name, entry))	342	if (ldfile_try_open_bfd (name, entry))
349	{	343	{
350	entry->filename = name;	344	entry->filename = name;
351	return TRUE;	345	return TRUE;
352	}	346	}
353	free (name);	347	free (name);
354	}	348	}
355	else if (ldfile_try_open_bfd (entry->filename, entry))	349	else if (ldfile_try_open_bfd (entry->filename, entry))
356	return TRUE;	350	return TRUE;
357		351
358	if (IS_ABSOLUTE_PATH (entry->filename))	352	if (IS_ABSOLUTE_PATH (entry->filename))
359	return FALSE;	353	return FALSE;
360	}	354	}
361		355
362	for (search = search_head; search != NULL; search = search->next)	356	for (search = search_head; search != NULL; search = search->next)
363	{	357	{
364	char *string;	358	char *string;
365		359
366	if (entry->flags.dynamic && ! link_info.relocatable)	360	if (entry->flags.dynamic && !bfd_link_relocatable (&link_info))
367	{	361	{
368	if (ldemul_open_dynamic_archive (arch, search, entry))	362	if (ldemul_open_dynamic_archive (arch, search, entry))
369	return TRUE;	363	return TRUE;
370	}	364	}
371		365
372	if (entry->flags.maybe_archive)	366	if (entry->flags.maybe_archive && !entry->flags.full_name_provided)
373	string = concat (search->name, slash, lib, entry->filename,	367	string = concat (search->name, slash, lib, entry->filename,
374	arch, suffix, (const char *) NULL);	368	arch, suffix, (const char *) NULL);
375	else	369	else
376	string = concat (search->name, slash, entry->filename,	370	string = concat (search->name, slash, entry->filename,
377	(const char *) 0);	371	(const char *) 0);
378		372
379	if (ldfile_try_open_bfd (string, entry))	373	if (ldfile_try_open_bfd (string, entry))
380	{	374	{
381	entry->filename = string;	375	entry->filename = string;
382	return TRUE;	376	return TRUE;
383	}	377	}
384		378
385	free (string);	379	free (string);
386	}	380	}
387		381
388	return FALSE;	382	return FALSE;
389	}	383	}
390		384
391	/* Open the input file specified by ENTRY.	385	/* Open the input file specified by ENTRY.
392	PR 4437: Do not stop on the first missing file, but	386	PR 4437: Do not stop on the first missing file, but
393	continue processing other input files in case there	387	continue processing other input files in case there
394	are more errors to report. */	388	are more errors to report. */
395		389
396	void	390	void
397	ldfile_open_file (lang_input_statement_type *entry)	391	ldfile_open_file (lang_input_statement_type *entry)
398	{	392	{
399	if (entry->the_bfd != NULL)	393	if (entry->the_bfd != NULL)
400	return;	394	return;
401		395
402	if (! entry->flags.search_dirs)	396	if (! entry->flags.search_dirs)
403	{	397	{
404	if (ldfile_try_open_bfd (entry->filename, entry))	398	if (ldfile_try_open_bfd (entry->filename, entry))
405	return;	399	return;
406		400
407	if (filename_cmp (entry->filename, entry->local_sym_name) != 0)	401	if (filename_cmp (entry->filename, entry->local_sym_name) != 0)
408	einfo (_("%P: cannot find %s (%s): %E\n"),	402	einfo (_("%P: cannot find %s (%s): %E\n"),
409	entry->filename, entry->local_sym_name);	403	entry->filename, entry->local_sym_name);
410	else	404	else
411	einfo (_("%P: cannot find %s: %E\n"), entry->local_sym_name);	405	einfo (_("%P: cannot find %s: %E\n"), entry->local_sym_name);
412		406
413	entry->flags.missing_file = TRUE;	407	entry->flags.missing_file = TRUE;
414	input_flags.missing_file = TRUE;	408	input_flags.missing_file = TRUE;
415	}	409	}
416	else	410	else
417	{	411	{
418	search_arch_type *arch;	412	search_arch_type *arch;
419	bfd_boolean found = FALSE;	413	bfd_boolean found = FALSE;
420		414
421	/* Try to open or lib.a */	415	/* Try to open or lib.a */
422	for (arch = search_arch_head; arch != NULL; arch = arch->next)	416	for (arch = search_arch_head; arch != NULL; arch = arch->next)
423	{	417	{
424	found = ldfile_open_file_search (arch->name, entry, "lib", ".a");	418	found = ldfile_open_file_search (arch->name, entry, "lib", ".a");
425	if (found)	419	if (found)
426	break;	420	break;
427	#ifdef VMS	421	#ifdef VMS
428	found = ldfile_open_file_search (arch->name, entry, ":lib", ".a");	422	found = ldfile_open_file_search (arch->name, entry, ":lib", ".a");
429	if (found)	423	if (found)
430	break;	424	break;
431	#endif	425	#endif
432	found = ldemul_find_potential_libraries (arch->name, entry);	426	found = ldemul_find_potential_libraries (arch->name, entry);
433	if (found)	427	if (found)
434	break;	428	break;
435	}	429	}
436		430
437	/* If we have found the file, we don't need to search directories	431	/* If we have found the file, we don't need to search directories
438	again. */	432	again. */
439	if (found)	433	if (found)
440	entry->flags.search_dirs = FALSE;	434	entry->flags.search_dirs = FALSE;
441	else	435	else
442	{	436	{
443	if (entry->flags.sysrooted	437	if (entry->flags.sysrooted
444	&& ld_sysroot	438	&& ld_sysroot
445	&& IS_ABSOLUTE_PATH (entry->local_sym_name))	439	&& IS_ABSOLUTE_PATH (entry->local_sym_name))
446	einfo (_("%P: cannot find %s inside %s\n"),	440	einfo (_("%P: cannot find %s inside %s\n"),
447	entry->local_sym_name, ld_sysroot);	441	entry->local_sym_name, ld_sysroot);
448	else	442	else
449	einfo (_("%P: cannot find %s\n"), entry->local_sym_name);	443	einfo (_("%P: cannot find %s\n"), entry->local_sym_name);
450	entry->flags.missing_file = TRUE;	444	entry->flags.missing_file = TRUE;
451	input_flags.missing_file = TRUE;	445	input_flags.missing_file = TRUE;
452	}	446	}
453	}	447	}
454	}	448	}
455		449
456	/* Try to open NAME. */	450	/* Try to open NAME. */
457		451
458	static FILE *	452	static FILE *
459	try_open (const char name, bfd_boolean sysrooted)	453	try_open (const char name, bfd_boolean sysrooted)
460	{	454	{
461	FILE *result;	455	FILE *result;
462		456
463	result = fopen (name, "r");	457	result = fopen (name, "r");
464		458
465	if (result != NULL)	459	if (result != NULL)
466	*sysrooted = is_sysrooted_pathname (name);	460	*sysrooted = is_sysrooted_pathname (name);
467		461
468	if (verbose)	462	if (verbose)
469	{	463	{
470	if (result == NULL)	464	if (result == NULL)
471	info_msg (_("cannot find script file %s\n"), name);	465	info_msg (_("cannot find script file %s\n"), name);
472	else	466	else
473	info_msg (_("opened script file %s\n"), name);	467	info_msg (_("opened script file %s\n"), name);
474	}	468	}
475		469
476	return result;	470	return result;
477	}	471	}
478		472
479	/* Return TRUE iff directory DIR contains an "ldscripts" subdirectory. */	473	/* Return TRUE iff directory DIR contains an "ldscripts" subdirectory. */
480		474
481	static bfd_boolean	475	static bfd_boolean
482	check_for_scripts_dir (char *dir)	476	check_for_scripts_dir (char *dir)
483	{	477	{
484	char *buf;	478	char *buf;
485	struct stat s;	479	struct stat s;
486	bfd_boolean res;	480	bfd_boolean res;
487		481
488	buf = concat (dir, "/ldscripts", (const char *) NULL);	482	buf = concat (dir, "/ldscripts", (const char *) NULL);
489	res = stat (buf, &s) == 0 && S_ISDIR (s.st_mode);	483	res = stat (buf, &s) == 0 && S_ISDIR (s.st_mode);
490	free (buf);	484	free (buf);
491	return res;	485	return res;
492	}	486	}

Subversion Repositories Kolibri OS

(root)/contrib/toolchain/binutils/ld/ldfile.c – Rev 5211 → 6324