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


/* ldmisc.c
 
 
   Copyright (C) 1991-2015 Free Software Foundation, Inc.
   Written by Steve Chamberlain of Cygnus Support.
 
   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 "libiberty.h"
#include "filenames.h"
#include "demangle.h"
#include 
#include "ld.h"
#include "ldmisc.h"
#include "ldexp.h"
#include "ldlang.h"
#include 
#include "ldlex.h"
#include "ldmain.h"
#include "ldfile.h"
#include "elf-bfd.h"
#include "coff-bfd.h"
 
/*
 %% literal %
 %A section name from a section
 %B filename from a bfd
 %C clever filename:linenumber with function
 %D like %C, but no function name
 %E current bfd error or errno
 %F error is fatal
 %G like %D, but only function name
 %H like %C but in addition emit section+offset
 %I filename from a lang_input_statement_type
 %P print program name
 %R info about a relent
 %S print script file and linenumber from etree_type.
 %T symbol name
 %V hex bfd_vma
 %W hex bfd_vma with 0x with no leading zeros taking up 8 spaces
 %X no object output, fail return
 %d integer, like printf
 %ld long, like printf
 %lu unsigned long, like printf
 %p native (host) void* pointer, like printf
 %s arbitrary string, like printf
 %u integer, like printf
 %v hex bfd_vma, no leading zeros
*/
 
void
vfinfo (FILE *fp, const char *fmt, va_list arg, bfd_boolean is_warning)
{
  bfd_boolean fatal = FALSE;
 
  while (*fmt != '\0')
    {
      const char *str = fmt;
      while (*fmt != '%' && *fmt != '\0')
	fmt++;
      if (fmt != str)
	if (fwrite (str, 1, fmt - str, fp))
	  {
	    /* Ignore.  */
	  }
 
      if (*fmt == '%')
	{
	  fmt++;
	  switch (*fmt++)
	    {
	    case '%':
	      /* literal % */
	      putc ('%', fp);
	      break;
 
	    case 'X':
	      /* no object output, fail return */
	      config.make_executable = FALSE;
	      break;
 
	    case 'V':
	      /* hex bfd_vma */
	      {
		bfd_vma value = va_arg (arg, bfd_vma);
		fprintf_vma (fp, value);
	      }
	      break;
 
	    case 'v':
	      /* hex bfd_vma, no leading zeros */
	      {
		char buf[100];
		char *p = buf;
		bfd_vma value = va_arg (arg, bfd_vma);
		sprintf_vma (p, value);
		while (*p == '0')
		  p++;
		if (!*p)
		  p--;
		fputs (p, fp);
	      }
	      break;
 
	    case 'W':
	      /* hex bfd_vma with 0x with no leading zeroes taking up
		 8 spaces.  */
	      {
		char buf[100];
		bfd_vma value;
		char *p;
		int len;
 
		value = va_arg (arg, bfd_vma);
		sprintf_vma (buf, value);
		for (p = buf; *p == '0'; ++p)
		  ;
		if (*p == '\0')
		  --p;
		len = strlen (p);
		while (len < 8)
		  {
		    putc (' ', fp);
		    ++len;
		  }
		fprintf (fp, "0x%s", p);
	      }
	      break;
 
	    case 'T':
	      /* Symbol name.  */
	      {
		const char *name = va_arg (arg, const char *);
 
		if (name == NULL || *name == 0)
		  {
		    fprintf (fp, _("no symbol"));
		    break;
		  }
		else if (demangling)
		  {
		    char *demangled;
 
		    demangled = bfd_demangle (link_info.output_bfd, name,
					      DMGL_ANSI | DMGL_PARAMS);
		    if (demangled != NULL)
		      {
			fprintf (fp, "%s", demangled);
			free (demangled);
			break;
		      }
		  }
		fprintf (fp, "%s", name);
	      }
	      break;
 
	    case 'A':
	      /* section name from a section */
	      {
		asection *sec = va_arg (arg, asection *);
		bfd *abfd = sec->owner;
		const char *group = NULL;
		struct coff_comdat_info *ci;
 
		fprintf (fp, "%s", sec->name);
		if (abfd != NULL
		    && bfd_get_flavour (abfd) == bfd_target_elf_flavour
		    && elf_next_in_group (sec) != NULL
		    && (sec->flags & SEC_GROUP) == 0)
		  group = elf_group_name (sec);
		else if (abfd != NULL
			 && bfd_get_flavour (abfd) == bfd_target_coff_flavour
			 && (ci = bfd_coff_get_comdat_section (sec->owner,
							       sec)) != NULL)
		  group = ci->name;
		if (group != NULL)
		  fprintf (fp, "[%s]", group);
	      }
	      break;
 
	    case 'B':
	      /* filename from a bfd */
	      {
		bfd *abfd = va_arg (arg, bfd *);
 
		if (abfd == NULL)
		  fprintf (fp, "%s generated", program_name);
		else if (abfd->my_archive)
		  fprintf (fp, "%s(%s)", abfd->my_archive->filename,
			   abfd->filename);
		else
		  fprintf (fp, "%s", abfd->filename);
	      }
	      break;
 
	    case 'F':
	      /* Error is fatal.  */
	      fatal = TRUE;
	      break;
 
	    case 'P':
	      /* Print program name.  */
	      fprintf (fp, "%s", program_name);
	      break;
 
	    case 'E':
	      /* current bfd error or errno */
	      fprintf (fp, "%s", bfd_errmsg (bfd_get_error ()));
	      break;
 
	    case 'I':
	      /* filename from a lang_input_statement_type */
	      {
		lang_input_statement_type *i;
 
		i = va_arg (arg, lang_input_statement_type *);
		if (bfd_my_archive (i->the_bfd) != NULL)
		  fprintf (fp, "(%s)",
			   bfd_get_filename (bfd_my_archive (i->the_bfd)));
		fprintf (fp, "%s", i->local_sym_name);
		if (bfd_my_archive (i->the_bfd) == NULL
		    && filename_cmp (i->local_sym_name, i->filename) != 0)
		  fprintf (fp, " (%s)", i->filename);
	      }
	      break;
 
	    case 'S':
	      /* Print script file and linenumber.  */
	      {
		etree_type node;
		etree_type *tp = va_arg (arg, etree_type *);
 
		if (tp == NULL)
		  {
		    tp = &node;
		    tp->type.filename = ldlex_filename ();
		    tp->type.lineno = lineno;
		  }
		if (tp->type.filename != NULL)
		  fprintf (fp, "%s:%u", tp->type.filename, tp->type.lineno);
	      }
	      break;
 
	    case 'R':
	      /* Print all that's interesting about a relent.  */
	      {
		arelent *relent = va_arg (arg, arelent *);
 
		lfinfo (fp, "%s+0x%v (type %s)",
			(*(relent->sym_ptr_ptr))->name,
			relent->addend,
			relent->howto->name);
	      }
	      break;
 
	    case 'C':
	    case 'D':
	    case 'G':
	    case 'H':
	      /* Clever filename:linenumber with function name if possible.
		 The arguments are a BFD, a section, and an offset.  */
	      {
		static bfd *last_bfd;
		static char *last_file = NULL;
		static char *last_function = NULL;
		bfd *abfd;
		asection *section;
		bfd_vma offset;
		asymbol **asymbols = NULL;
		const char *filename;
		const char *functionname;
		unsigned int linenumber;
		bfd_boolean discard_last;
		bfd_boolean done;
 
		abfd = va_arg (arg, bfd *);
		section = va_arg (arg, asection *);
		offset = va_arg (arg, bfd_vma);
 
		if (abfd != NULL)
		  {
		    if (!bfd_generic_link_read_symbols (abfd))
		      einfo (_("%B%F: could not read symbols: %E\n"), abfd);
 
		    asymbols = bfd_get_outsymbols (abfd);
		  }
 
		/* The GNU Coding Standard requires that error messages
		   be of the form:
 
		     source-file-name:lineno: message
 
		   We do not always have a line number available so if
		   we cannot find them we print out the section name and
		   offset instead.  */
		discard_last = TRUE;
		if (abfd != NULL
		    && bfd_find_nearest_line (abfd, section, asymbols, offset,
					      &filename, &functionname,
					      &linenumber))
		  {
		    if (functionname != NULL
			&& (fmt[-1] == 'C' || fmt[-1] == 'H'))
		      {
			/* Detect the case where we are printing out a
			   message for the same function as the last
			   call to vinfo ("%C").  In this situation do
			   not print out the ABFD filename or the
			   function name again.  Note - we do still
			   print out the source filename, as this will
			   allow programs that parse the linker's output
			   (eg emacs) to correctly locate multiple
			   errors in the same source file.  */
			if (last_bfd == NULL
			    || last_file == NULL
			    || last_function == NULL
			    || last_bfd != abfd
			    || (filename != NULL
				&& filename_cmp (last_file, filename) != 0)
			    || strcmp (last_function, functionname) != 0)
			  {
			    lfinfo (fp, _("%B: In function `%T':\n"),
				    abfd, functionname);
 
			    last_bfd = abfd;
			    if (last_file != NULL)
			      free (last_file);
			    last_file = NULL;
			    if (filename)
			      last_file = xstrdup (filename);
			    if (last_function != NULL)
			      free (last_function);
			    last_function = xstrdup (functionname);
			  }
			discard_last = FALSE;
		      }
		    else
		      lfinfo (fp, "%B:", abfd);
 
		    if (filename != NULL)
		      fprintf (fp, "%s:", filename);
 
		    done = fmt[-1] != 'H';
		    if (functionname != NULL && fmt[-1] == 'G')
		      lfinfo (fp, "%T", functionname);
		    else if (filename != NULL && linenumber != 0)
		      fprintf (fp, "%u%s", linenumber, done ? "" : ":");
		    else
		      done = FALSE;
		  }
		else
		  {
		    lfinfo (fp, "%B:", abfd);
		    done = FALSE;
		  }
		if (!done)
		  lfinfo (fp, "(%A+0x%v)", section, offset);
 
		if (discard_last)
		  {
		    last_bfd = NULL;
		    if (last_file != NULL)
		      {
			free (last_file);
			last_file = NULL;
		      }
		    if (last_function != NULL)
		      {
			free (last_function);
			last_function = NULL;
		      }
		  }
	      }
	      break;
 
	    case 'p':
	      /* native (host) void* pointer, like printf */
	      fprintf (fp, "%p", va_arg (arg, void *));
	      break;
 
	    case 's':
	      /* arbitrary string, like printf */
	      fprintf (fp, "%s", va_arg (arg, char *));
	      break;
 
	    case 'd':
	      /* integer, like printf */
	      fprintf (fp, "%d", va_arg (arg, int));
	      break;
 
	    case 'u':
	      /* unsigned integer, like printf */
	      fprintf (fp, "%u", va_arg (arg, unsigned int));
	      break;
 
	    case 'l':
	      if (*fmt == 'd')
		{
		  fprintf (fp, "%ld", va_arg (arg, long));
		  ++fmt;
		  break;
		}
	      else if (*fmt == 'u')
		{
		  fprintf (fp, "%lu", va_arg (arg, unsigned long));
		  ++fmt;
		  break;
		}
	      /* Fall thru */
 
	    default:
	      fprintf (fp, "%%%c", fmt[-1]);
	      break;
	    }
	}
    }
 
  if (is_warning && config.fatal_warnings)
    config.make_executable = FALSE;
 
  if (fatal)
    xexit (1);
}
 
/* Format info message and print on stdout.  */
 
/* (You would think this should be called just "info", but then you
   would be hosed by LynxOS, which defines that name in its libc.)  */
 
void
info_msg (const char *fmt, ...)
{
  va_list arg;
 
  va_start (arg, fmt);
  vfinfo (stdout, fmt, arg, FALSE);
  va_end (arg);
}
 
/* ('e' for error.) Format info message and print on stderr.  */
 
void
einfo (const char *fmt, ...)
{
  va_list arg;
 
  fflush (stdout);
  va_start (arg, fmt);
  vfinfo (stderr, fmt, arg, TRUE);
  va_end (arg);
  fflush (stderr);
}
 
void
info_assert (const char *file, unsigned int line)
{
  einfo (_("%F%P: internal error %s %d\n"), file, line);
}
 
/* ('m' for map) Format info message and print on map.  */
 
void
minfo (const char *fmt, ...)
{
  if (config.map_file != NULL)
    {
      va_list arg;
 
      va_start (arg, fmt);
      if (fmt[0] == '%' && fmt[1] == '!' && fmt[2] == 0)
	{
	  /* Stash info about --as-needed shared libraries.  Print
	     later so they don't appear intermingled with archive
	     library info.  */
	  struct asneeded_minfo *m = xmalloc (sizeof *m);
 
	  m->next = NULL;
	  m->soname = va_arg (arg, const char *);
	  m->ref = va_arg (arg, bfd *);
	  m->name = va_arg (arg, const char *);
	  *asneeded_list_tail = m;
	  asneeded_list_tail = &m->next;
	}
      else
      vfinfo (config.map_file, fmt, arg, FALSE);
      va_end (arg);
    }
}
 
void
lfinfo (FILE *file, const char *fmt, ...)
{
  va_list arg;
 
  va_start (arg, fmt);
  vfinfo (file, fmt, arg, FALSE);
  va_end (arg);
}

/* Functions to print the link map.  */
 
void
print_space (void)
{
  fprintf (config.map_file, " ");
}
 
void
print_nl (void)
{
  fprintf (config.map_file, "\n");
}
 
/* A more or less friendly abort message.  In ld.h abort is defined to
   call this function.  */
 
void
ld_abort (const char *file, int line, const char *fn)
{
  if (fn != NULL)
    einfo (_("%P: internal error: aborting at %s:%d in %s\n"),
	   file, line, fn);
  else
    einfo (_("%P: internal error: aborting at %s:%d\n"),
	   file, line);
  einfo (_("%P%F: please report this bug\n"));
  xexit (1);
}

Rev 5199	Rev 6324
1	/* ldmisc.c	1	/* ldmisc.c
2	Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,	-
3	2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2010, 2011, 2012, 2013	-
4	Free Software Foundation, Inc.	2	Copyright (C) 1991-2015 Free Software Foundation, Inc.
5	Written by Steve Chamberlain of Cygnus Support.	3	Written by Steve Chamberlain of Cygnus Support.
6		4
7	This file is part of the GNU Binutils.	5	This file is part of the GNU Binutils.
8		6
9	This program is free software; you can redistribute it and/or modify	7	This program is free software; you can redistribute it and/or modify
10	it under the terms of the GNU General Public License as published by	8	it under the terms of the GNU General Public License as published by
11	the Free Software Foundation; either version 3 of the License, or	9	the Free Software Foundation; either version 3 of the License, or
12	(at your option) any later version.	10	(at your option) any later version.
13		11
14	This program is distributed in the hope that it will be useful,	12	This program is distributed in the hope that it will be useful,
15	but WITHOUT ANY WARRANTY; without even the implied warranty of	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
16	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17	GNU General Public License for more details.	15	GNU General Public License for more details.
18		16
19	You should have received a copy of the GNU General Public License	17	You should have received a copy of the GNU General Public License
20	along with this program; if not, write to the Free Software	18	along with this program; if not, write to the Free Software
21	Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,	19	Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22	MA 02110-1301, USA. */	20	MA 02110-1301, USA. */
23		21
24	#include "sysdep.h"	22	#include "sysdep.h"
25	#include "bfd.h"	23	#include "bfd.h"
26	#include "bfdlink.h"	24	#include "bfdlink.h"
27	#include "libiberty.h"	25	#include "libiberty.h"
28	#include "filenames.h"	26	#include "filenames.h"
29	#include "demangle.h"	27	#include "demangle.h"
30	#include	28	#include
31	#include "ld.h"	29	#include "ld.h"
32	#include "ldmisc.h"	30	#include "ldmisc.h"
33	#include "ldexp.h"	31	#include "ldexp.h"
34	#include "ldlang.h"	32	#include "ldlang.h"
35	#include	33	#include
36	#include "ldlex.h"	34	#include "ldlex.h"
37	#include "ldmain.h"	35	#include "ldmain.h"
38	#include "ldfile.h"	36	#include "ldfile.h"
39	#include "elf-bfd.h"	37	#include "elf-bfd.h"
-		38	#include "coff-bfd.h"
40		39
41	/*	40	/*
42	%% literal %	41	%% literal %
43	%A section name from a section	42	%A section name from a section
44	%B filename from a bfd	43	%B filename from a bfd
45	%C clever filename:linenumber with function	44	%C clever filename:linenumber with function
46	%D like %C, but no function name	45	%D like %C, but no function name
47	%E current bfd error or errno	46	%E current bfd error or errno
48	%F error is fatal	47	%F error is fatal
49	%G like %D, but only function name	48	%G like %D, but only function name
50	%H like %C but in addition emit section+offset	49	%H like %C but in addition emit section+offset
51	%I filename from a lang_input_statement_type	50	%I filename from a lang_input_statement_type
52	%P print program name	51	%P print program name
53	%R info about a relent	52	%R info about a relent
54	%S print script file and linenumber from etree_type.	53	%S print script file and linenumber from etree_type.
55	%T symbol name	54	%T symbol name
56	%V hex bfd_vma	55	%V hex bfd_vma
57	%W hex bfd_vma with 0x with no leading zeros taking up 8 spaces	56	%W hex bfd_vma with 0x with no leading zeros taking up 8 spaces
58	%X no object output, fail return	57	%X no object output, fail return
59	%d integer, like printf	58	%d integer, like printf
60	%ld long, like printf	59	%ld long, like printf
61	%lu unsigned long, like printf	60	%lu unsigned long, like printf
62	%p native (host) void* pointer, like printf	61	%p native (host) void* pointer, like printf
63	%s arbitrary string, like printf	62	%s arbitrary string, like printf
64	%u integer, like printf	63	%u integer, like printf
65	%v hex bfd_vma, no leading zeros	64	%v hex bfd_vma, no leading zeros
66	*/	65	*/
67		66
68	void	67	void
69	vfinfo (FILE fp, const char fmt, va_list arg, bfd_boolean is_warning)	68	vfinfo (FILE fp, const char fmt, va_list arg, bfd_boolean is_warning)
70	{	69	{
71	bfd_boolean fatal = FALSE;	70	bfd_boolean fatal = FALSE;
72		71
73	while (*fmt != '\0')	72	while (*fmt != '\0')
74	{	73	{
75	const char *str = fmt;	74	const char *str = fmt;
76	while (fmt != '%' && fmt != '\0')	75	while (fmt != '%' && fmt != '\0')
77	fmt++;	76	fmt++;
78	if (fmt != str)	77	if (fmt != str)
79	if (fwrite (str, 1, fmt - str, fp))	78	if (fwrite (str, 1, fmt - str, fp))
80	{	79	{
81	/* Ignore. */	80	/* Ignore. */
82	}	81	}
83		82
84	if (*fmt == '%')	83	if (*fmt == '%')
85	{	84	{
86	fmt++;	85	fmt++;
87	switch (*fmt++)	86	switch (*fmt++)
88	{	87	{
89	case '%':	88	case '%':
90	/* literal % */	89	/* literal % */
91	putc ('%', fp);	90	putc ('%', fp);
92	break;	91	break;
93		92
94	case 'X':	93	case 'X':
95	/* no object output, fail return */	94	/* no object output, fail return */
96	config.make_executable = FALSE;	95	config.make_executable = FALSE;
97	break;	96	break;
98		97
99	case 'V':	98	case 'V':
100	/* hex bfd_vma */	99	/* hex bfd_vma */
101	{	100	{
102	bfd_vma value = va_arg (arg, bfd_vma);	101	bfd_vma value = va_arg (arg, bfd_vma);
103	fprintf_vma (fp, value);	102	fprintf_vma (fp, value);
104	}	103	}
105	break;	104	break;
106		105
107	case 'v':	106	case 'v':
108	/* hex bfd_vma, no leading zeros */	107	/* hex bfd_vma, no leading zeros */
109	{	108	{
110	char buf[100];	109	char buf[100];
111	char *p = buf;	110	char *p = buf;
112	bfd_vma value = va_arg (arg, bfd_vma);	111	bfd_vma value = va_arg (arg, bfd_vma);
113	sprintf_vma (p, value);	112	sprintf_vma (p, value);
114	while (*p == '0')	113	while (*p == '0')
115	p++;	114	p++;
116	if (!*p)	115	if (!*p)
117	p--;	116	p--;
118	fputs (p, fp);	117	fputs (p, fp);
119	}	118	}
120	break;	119	break;
121		120
122	case 'W':	121	case 'W':
123	/* hex bfd_vma with 0x with no leading zeroes taking up	122	/* hex bfd_vma with 0x with no leading zeroes taking up
124	8 spaces. */	123	8 spaces. */
125	{	124	{
126	char buf[100];	125	char buf[100];
127	bfd_vma value;	126	bfd_vma value;
128	char *p;	127	char *p;
129	int len;	128	int len;
130		129
131	value = va_arg (arg, bfd_vma);	130	value = va_arg (arg, bfd_vma);
132	sprintf_vma (buf, value);	131	sprintf_vma (buf, value);
133	for (p = buf; *p == '0'; ++p)	132	for (p = buf; *p == '0'; ++p)
134	;	133	;
135	if (*p == '\0')	134	if (*p == '\0')
136	--p;	135	--p;
137	len = strlen (p);	136	len = strlen (p);
138	while (len < 8)	137	while (len < 8)
139	{	138	{
140	putc (' ', fp);	139	putc (' ', fp);
141	++len;	140	++len;
142	}	141	}
143	fprintf (fp, "0x%s", p);	142	fprintf (fp, "0x%s", p);
144	}	143	}
145	break;	144	break;
146		145
147	case 'T':	146	case 'T':
148	/* Symbol name. */	147	/* Symbol name. */
149	{	148	{
150	const char name = va_arg (arg, const char );	149	const char name = va_arg (arg, const char );
151		150
152	if (name == NULL \|\| *name == 0)	151	if (name == NULL \|\| *name == 0)
153	{	152	{
154	fprintf (fp, _("no symbol"));	153	fprintf (fp, _("no symbol"));
155	break;	154	break;
156	}	155	}
157	else if (demangling)	156	else if (demangling)
158	{	157	{
159	char *demangled;	158	char *demangled;
160		159
161	demangled = bfd_demangle (link_info.output_bfd, name,	160	demangled = bfd_demangle (link_info.output_bfd, name,
162	DMGL_ANSI \| DMGL_PARAMS);	161	DMGL_ANSI \| DMGL_PARAMS);
163	if (demangled != NULL)	162	if (demangled != NULL)
164	{	163	{
165	fprintf (fp, "%s", demangled);	164	fprintf (fp, "%s", demangled);
166	free (demangled);	165	free (demangled);
167	break;	166	break;
168	}	167	}
169	}	168	}
170	fprintf (fp, "%s", name);	169	fprintf (fp, "%s", name);
171	}	170	}
172	break;	171	break;
173		172
174	case 'A':	173	case 'A':
175	/* section name from a section */	174	/* section name from a section */
176	{	175	{
177	asection sec = va_arg (arg, asection );	176	asection sec = va_arg (arg, asection );
178	bfd *abfd = sec->owner;	177	bfd *abfd = sec->owner;
179	const char *group = NULL;	178	const char *group = NULL;
180	struct coff_comdat_info *ci;	179	struct coff_comdat_info *ci;
181		180
182	fprintf (fp, "%s", sec->name);	181	fprintf (fp, "%s", sec->name);
183	if (abfd != NULL	182	if (abfd != NULL
184	&& bfd_get_flavour (abfd) == bfd_target_elf_flavour	183	&& bfd_get_flavour (abfd) == bfd_target_elf_flavour
185	&& elf_next_in_group (sec) != NULL	184	&& elf_next_in_group (sec) != NULL
186	&& (sec->flags & SEC_GROUP) == 0)	185	&& (sec->flags & SEC_GROUP) == 0)
187	group = elf_group_name (sec);	186	group = elf_group_name (sec);
188	else if (abfd != NULL	187	else if (abfd != NULL
189	&& bfd_get_flavour (abfd) == bfd_target_coff_flavour	188	&& bfd_get_flavour (abfd) == bfd_target_coff_flavour
190	&& (ci = bfd_coff_get_comdat_section (sec->owner,	189	&& (ci = bfd_coff_get_comdat_section (sec->owner,
191	sec)) != NULL)	190	sec)) != NULL)
192	group = ci->name;	191	group = ci->name;
193	if (group != NULL)	192	if (group != NULL)
194	fprintf (fp, "[%s]", group);	193	fprintf (fp, "[%s]", group);
195	}	194	}
196	break;	195	break;
197		196
198	case 'B':	197	case 'B':
199	/* filename from a bfd */	198	/* filename from a bfd */
200	{	199	{
201	bfd abfd = va_arg (arg, bfd );	200	bfd abfd = va_arg (arg, bfd );
202		201
203	if (abfd == NULL)	202	if (abfd == NULL)
204	fprintf (fp, "%s generated", program_name);	203	fprintf (fp, "%s generated", program_name);
205	else if (abfd->my_archive)	204	else if (abfd->my_archive)
206	fprintf (fp, "%s(%s)", abfd->my_archive->filename,	205	fprintf (fp, "%s(%s)", abfd->my_archive->filename,
207	abfd->filename);	206	abfd->filename);
208	else	207	else
209	fprintf (fp, "%s", abfd->filename);	208	fprintf (fp, "%s", abfd->filename);
210	}	209	}
211	break;	210	break;
212		211
213	case 'F':	212	case 'F':
214	/* Error is fatal. */	213	/* Error is fatal. */
215	fatal = TRUE;	214	fatal = TRUE;
216	break;	215	break;
217		216
218	case 'P':	217	case 'P':
219	/* Print program name. */	218	/* Print program name. */
220	fprintf (fp, "%s", program_name);	219	fprintf (fp, "%s", program_name);
221	break;	220	break;
222		221
223	case 'E':	222	case 'E':
224	/* current bfd error or errno */	223	/* current bfd error or errno */
225	fprintf (fp, "%s", bfd_errmsg (bfd_get_error ()));	224	fprintf (fp, "%s", bfd_errmsg (bfd_get_error ()));
226	break;	225	break;
227		226
228	case 'I':	227	case 'I':
229	/* filename from a lang_input_statement_type */	228	/* filename from a lang_input_statement_type */
230	{	229	{
231	lang_input_statement_type *i;	230	lang_input_statement_type *i;
232		231
233	i = va_arg (arg, lang_input_statement_type *);	232	i = va_arg (arg, lang_input_statement_type *);
234	if (bfd_my_archive (i->the_bfd) != NULL)	233	if (bfd_my_archive (i->the_bfd) != NULL)
235	fprintf (fp, "(%s)",	234	fprintf (fp, "(%s)",
236	bfd_get_filename (bfd_my_archive (i->the_bfd)));	235	bfd_get_filename (bfd_my_archive (i->the_bfd)));
237	fprintf (fp, "%s", i->local_sym_name);	236	fprintf (fp, "%s", i->local_sym_name);
238	if (bfd_my_archive (i->the_bfd) == NULL	237	if (bfd_my_archive (i->the_bfd) == NULL
239	&& filename_cmp (i->local_sym_name, i->filename) != 0)	238	&& filename_cmp (i->local_sym_name, i->filename) != 0)
240	fprintf (fp, " (%s)", i->filename);	239	fprintf (fp, " (%s)", i->filename);
241	}	240	}
242	break;	241	break;
243		242
244	case 'S':	243	case 'S':
245	/* Print script file and linenumber. */	244	/* Print script file and linenumber. */
246	{	245	{
247	etree_type node;	246	etree_type node;
248	etree_type tp = va_arg (arg, etree_type );	247	etree_type tp = va_arg (arg, etree_type );
249		248
250	if (tp == NULL)	249	if (tp == NULL)
251	{	250	{
252	tp = &node;	251	tp = &node;
253	tp->type.filename = ldlex_filename ();	252	tp->type.filename = ldlex_filename ();
254	tp->type.lineno = lineno;	253	tp->type.lineno = lineno;
255	}	254	}
256	if (tp->type.filename != NULL)	255	if (tp->type.filename != NULL)
257	fprintf (fp, "%s:%u", tp->type.filename, tp->type.lineno);	256	fprintf (fp, "%s:%u", tp->type.filename, tp->type.lineno);
258	}	257	}
259	break;	258	break;
260		259
261	case 'R':	260	case 'R':
262	/* Print all that's interesting about a relent. */	261	/* Print all that's interesting about a relent. */
263	{	262	{
264	arelent relent = va_arg (arg, arelent );	263	arelent relent = va_arg (arg, arelent );
265		264
266	lfinfo (fp, "%s+0x%v (type %s)",	265	lfinfo (fp, "%s+0x%v (type %s)",
267	(*(relent->sym_ptr_ptr))->name,	266	(*(relent->sym_ptr_ptr))->name,
268	relent->addend,	267	relent->addend,
269	relent->howto->name);	268	relent->howto->name);
270	}	269	}
271	break;	270	break;
272		271
273	case 'C':	272	case 'C':
274	case 'D':	273	case 'D':
275	case 'G':	274	case 'G':
276	case 'H':	275	case 'H':
277	/* Clever filename:linenumber with function name if possible.	276	/* Clever filename:linenumber with function name if possible.
278	The arguments are a BFD, a section, and an offset. */	277	The arguments are a BFD, a section, and an offset. */
279	{	278	{
280	static bfd *last_bfd;	279	static bfd *last_bfd;
281	static char *last_file = NULL;	280	static char *last_file = NULL;
282	static char *last_function = NULL;	281	static char *last_function = NULL;
283	bfd *abfd;	282	bfd *abfd;
284	asection *section;	283	asection *section;
285	bfd_vma offset;	284	bfd_vma offset;
286	asymbol **asymbols = NULL;	285	asymbol **asymbols = NULL;
287	const char *filename;	286	const char *filename;
288	const char *functionname;	287	const char *functionname;
289	unsigned int linenumber;	288	unsigned int linenumber;
290	bfd_boolean discard_last;	289	bfd_boolean discard_last;
291	bfd_boolean done;	290	bfd_boolean done;
292		291
293	abfd = va_arg (arg, bfd *);	292	abfd = va_arg (arg, bfd *);
294	section = va_arg (arg, asection *);	293	section = va_arg (arg, asection *);
295	offset = va_arg (arg, bfd_vma);	294	offset = va_arg (arg, bfd_vma);
296		295
297	if (abfd != NULL)	296	if (abfd != NULL)
298	{	297	{
299	if (!bfd_generic_link_read_symbols (abfd))	298	if (!bfd_generic_link_read_symbols (abfd))
300	einfo (_("%B%F: could not read symbols: %E\n"), abfd);	299	einfo (_("%B%F: could not read symbols: %E\n"), abfd);
301		300
302	asymbols = bfd_get_outsymbols (abfd);	301	asymbols = bfd_get_outsymbols (abfd);
303	}	302	}
304		303
305	/* The GNU Coding Standard requires that error messages	304	/* The GNU Coding Standard requires that error messages
306	be of the form:	305	be of the form:
307		306
308	source-file-name:lineno: message	307	source-file-name:lineno: message
309		308
310	We do not always have a line number available so if	309	We do not always have a line number available so if
311	we cannot find them we print out the section name and	310	we cannot find them we print out the section name and
312	offset instead. */	311	offset instead. */
313	discard_last = TRUE;	312	discard_last = TRUE;
314	if (abfd != NULL	313	if (abfd != NULL
315	&& bfd_find_nearest_line (abfd, section, asymbols, offset,	314	&& bfd_find_nearest_line (abfd, section, asymbols, offset,
316	&filename, &functionname,	315	&filename, &functionname,
317	&linenumber))	316	&linenumber))
318	{	317	{
319	if (functionname != NULL	318	if (functionname != NULL
320	&& (fmt[-1] == 'C' \|\| fmt[-1] == 'H'))	319	&& (fmt[-1] == 'C' \|\| fmt[-1] == 'H'))
321	{	320	{
322	/* Detect the case where we are printing out a	321	/* Detect the case where we are printing out a
323	message for the same function as the last	322	message for the same function as the last
324	call to vinfo ("%C"). In this situation do	323	call to vinfo ("%C"). In this situation do
325	not print out the ABFD filename or the	324	not print out the ABFD filename or the
326	function name again. Note - we do still	325	function name again. Note - we do still
327	print out the source filename, as this will	326	print out the source filename, as this will
328	allow programs that parse the linker's output	327	allow programs that parse the linker's output
329	(eg emacs) to correctly locate multiple	328	(eg emacs) to correctly locate multiple
330	errors in the same source file. */	329	errors in the same source file. */
331	if (last_bfd == NULL	330	if (last_bfd == NULL
332	\|\| last_file == NULL	331	\|\| last_file == NULL
333	\|\| last_function == NULL	332	\|\| last_function == NULL
334	\|\| last_bfd != abfd	333	\|\| last_bfd != abfd
335	\|\| (filename != NULL	334	\|\| (filename != NULL
336	&& filename_cmp (last_file, filename) != 0)	335	&& filename_cmp (last_file, filename) != 0)
337	\|\| strcmp (last_function, functionname) != 0)	336	\|\| strcmp (last_function, functionname) != 0)
338	{	337	{
339	lfinfo (fp, _("%B: In function `%T':\n"),	338	lfinfo (fp, _("%B: In function `%T':\n"),
340	abfd, functionname);	339	abfd, functionname);
341		340
342	last_bfd = abfd;	341	last_bfd = abfd;
343	if (last_file != NULL)	342	if (last_file != NULL)
344	free (last_file);	343	free (last_file);
345	last_file = NULL;	344	last_file = NULL;
346	if (filename)	345	if (filename)
347	last_file = xstrdup (filename);	346	last_file = xstrdup (filename);
348	if (last_function != NULL)	347	if (last_function != NULL)
349	free (last_function);	348	free (last_function);
350	last_function = xstrdup (functionname);	349	last_function = xstrdup (functionname);
351	}	350	}
352	discard_last = FALSE;	351	discard_last = FALSE;
353	}	352	}
354	else	353	else
355	lfinfo (fp, "%B:", abfd);	354	lfinfo (fp, "%B:", abfd);
356		355
357	if (filename != NULL)	356	if (filename != NULL)
358	fprintf (fp, "%s:", filename);	357	fprintf (fp, "%s:", filename);
359		358
360	done = fmt[-1] != 'H';	359	done = fmt[-1] != 'H';
361	if (functionname != NULL && fmt[-1] == 'G')	360	if (functionname != NULL && fmt[-1] == 'G')
362	lfinfo (fp, "%T", functionname);	361	lfinfo (fp, "%T", functionname);
363	else if (filename != NULL && linenumber != 0)	362	else if (filename != NULL && linenumber != 0)
364	fprintf (fp, "%u%s", linenumber, done ? "" : ":");	363	fprintf (fp, "%u%s", linenumber, done ? "" : ":");
365	else	364	else
366	done = FALSE;	365	done = FALSE;
367	}	366	}
368	else	367	else
369	{	368	{
370	lfinfo (fp, "%B:", abfd);	369	lfinfo (fp, "%B:", abfd);
371	done = FALSE;	370	done = FALSE;
372	}	371	}
373	if (!done)	372	if (!done)
374	lfinfo (fp, "(%A+0x%v)", section, offset);	373	lfinfo (fp, "(%A+0x%v)", section, offset);
375		374
376	if (discard_last)	375	if (discard_last)
377	{	376	{
378	last_bfd = NULL;	377	last_bfd = NULL;
379	if (last_file != NULL)	378	if (last_file != NULL)
380	{	379	{
381	free (last_file);	380	free (last_file);
382	last_file = NULL;	381	last_file = NULL;
383	}	382	}
384	if (last_function != NULL)	383	if (last_function != NULL)
385	{	384	{
386	free (last_function);	385	free (last_function);
387	last_function = NULL;	386	last_function = NULL;
388	}	387	}
389	}	388	}
390	}	389	}
391	break;	390	break;
392		391
393	case 'p':	392	case 'p':
394	/* native (host) void* pointer, like printf */	393	/* native (host) void* pointer, like printf */
395	fprintf (fp, "%p", va_arg (arg, void *));	394	fprintf (fp, "%p", va_arg (arg, void *));
396	break;	395	break;
397		396
398	case 's':	397	case 's':
399	/* arbitrary string, like printf */	398	/* arbitrary string, like printf */
400	fprintf (fp, "%s", va_arg (arg, char *));	399	fprintf (fp, "%s", va_arg (arg, char *));
401	break;	400	break;
402		401
403	case 'd':	402	case 'd':
404	/* integer, like printf */	403	/* integer, like printf */
405	fprintf (fp, "%d", va_arg (arg, int));	404	fprintf (fp, "%d", va_arg (arg, int));
406	break;	405	break;
407		406
408	case 'u':	407	case 'u':
409	/* unsigned integer, like printf */	408	/* unsigned integer, like printf */
410	fprintf (fp, "%u", va_arg (arg, unsigned int));	409	fprintf (fp, "%u", va_arg (arg, unsigned int));
411	break;	410	break;
412		411
413	case 'l':	412	case 'l':
414	if (*fmt == 'd')	413	if (*fmt == 'd')
415	{	414	{
416	fprintf (fp, "%ld", va_arg (arg, long));	415	fprintf (fp, "%ld", va_arg (arg, long));
417	++fmt;	416	++fmt;
418	break;	417	break;
419	}	418	}
420	else if (*fmt == 'u')	419	else if (*fmt == 'u')
421	{	420	{
422	fprintf (fp, "%lu", va_arg (arg, unsigned long));	421	fprintf (fp, "%lu", va_arg (arg, unsigned long));
423	++fmt;	422	++fmt;
424	break;	423	break;
425	}	424	}
426	/* Fall thru */	425	/* Fall thru */
427		426
428	default:	427	default:
429	fprintf (fp, "%%%c", fmt[-1]);	428	fprintf (fp, "%%%c", fmt[-1]);
430	break;	429	break;
431	}	430	}
432	}	431	}
433	}	432	}
434		433
435	if (is_warning && config.fatal_warnings)	434	if (is_warning && config.fatal_warnings)
436	config.make_executable = FALSE;	435	config.make_executable = FALSE;
437		436
438	if (fatal)	437	if (fatal)
439	xexit (1);	438	xexit (1);
440	}	439	}
441		440
442	/* Format info message and print on stdout. */	441	/* Format info message and print on stdout. */
443		442
444	/* (You would think this should be called just "info", but then you	443	/* (You would think this should be called just "info", but then you
445	would be hosed by LynxOS, which defines that name in its libc.) */	444	would be hosed by LynxOS, which defines that name in its libc.) */
446		445
447	void	446	void
448	info_msg (const char *fmt, ...)	447	info_msg (const char *fmt, ...)
449	{	448	{
450	va_list arg;	449	va_list arg;
451		450
452	va_start (arg, fmt);	451	va_start (arg, fmt);
453	vfinfo (stdout, fmt, arg, FALSE);	452	vfinfo (stdout, fmt, arg, FALSE);
454	va_end (arg);	453	va_end (arg);
455	}	454	}
456		455
457	/* ('e' for error.) Format info message and print on stderr. */	456	/* ('e' for error.) Format info message and print on stderr. */
458		457
459	void	458	void
460	einfo (const char *fmt, ...)	459	einfo (const char *fmt, ...)
461	{	460	{
462	va_list arg;	461	va_list arg;
463		462
464	fflush (stdout);	463	fflush (stdout);
465	va_start (arg, fmt);	464	va_start (arg, fmt);
466	vfinfo (stderr, fmt, arg, TRUE);	465	vfinfo (stderr, fmt, arg, TRUE);
467	va_end (arg);	466	va_end (arg);
468	fflush (stderr);	467	fflush (stderr);
469	}	468	}
470		469
471	void	470	void
472	info_assert (const char *file, unsigned int line)	471	info_assert (const char *file, unsigned int line)
473	{	472	{
474	einfo (_("%F%P: internal error %s %d\n"), file, line);	473	einfo (_("%F%P: internal error %s %d\n"), file, line);
475	}	474	}
476		475
477	/* ('m' for map) Format info message and print on map. */	476	/* ('m' for map) Format info message and print on map. */
478		477
479	void	478	void
480	minfo (const char *fmt, ...)	479	minfo (const char *fmt, ...)
481	{	480	{
482	if (config.map_file != NULL)	481	if (config.map_file != NULL)
483	{	482	{
484	va_list arg;	483	va_list arg;
485		484
486	va_start (arg, fmt);	485	va_start (arg, fmt);
-		486	if (fmt[0] == '%' && fmt[1] == '!' && fmt[2] == 0)
-		487	{
-		488	/* Stash info about --as-needed shared libraries. Print
-		489	later so they don't appear intermingled with archive
-		490	library info. */
-		491	struct asneeded_minfo m = xmalloc (sizeof m);
-		492
-		493	m->next = NULL;
-		494	m->soname = va_arg (arg, const char *);
-		495	m->ref = va_arg (arg, bfd *);
-		496	m->name = va_arg (arg, const char *);
-		497	*asneeded_list_tail = m;
-		498	asneeded_list_tail = &m->next;

Subversion Repositories Kolibri OS

(root)/contrib/toolchain/binutils/ld/ldmisc.c – Rev 5199 → 6324