[thirdparty/binutils-gdb.git] / ld / ldmisc.c

/* ldmisc.c
   Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
   2000, 2002
   Free Software Foundation, Inc.
   Written by Steve Chamberlain of Cygnus Support.

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, 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA.  */

#include "bfd.h"
#include "sysdep.h"
#include "libiberty.h"
#include "demangle.h"

#ifdef ANSI_PROTOTYPES
#include <stdarg.h>
#else
#include <varargs.h>
#endif

#include "ld.h"
#include "ldmisc.h"
#include "ldexp.h"
#include "ldlang.h"
#include <ldgram.h>
#include "ldlex.h"
#include "ldmain.h"
#include "ldfile.h"

static void vfinfo PARAMS ((FILE *, const char *, va_list));

/*
 %% literal %
 %F error is fatal
 %P print program name
 %S print script file and linenumber
 %E current bfd error or errno
 %I filename from a lang_input_statement_type
 %B filename from a bfd
 %T symbol name
 %X no object output, fail return
 %V hex bfd_vma
 %v hex bfd_vma, no leading zeros
 %W hex bfd_vma with 0x with no leading zeros taking up 8 spaces
 %C clever filename:linenumber with function
 %D like %C, but no function name
 %G like %D, but only function name
 %R info about a relent
 %s arbitrary string, like printf
 %d integer, like printf
 %u integer, like printf
*/

static void
vfinfo (fp, fmt, arg)
     FILE *fp;
     const char *fmt;
     va_list arg;
{
  bfd_boolean fatal = FALSE;

  while (*fmt != '\0')
    {
      while (*fmt != '%' && *fmt != '\0')
	{
	  putc (*fmt, fp);
	  fmt++;
	}

      if (*fmt == '%')
	{
	  fmt++;
	  switch (*fmt++)
	    {
	    default:
	      fprintf (fp, "%%%c", fmt[-1]);
	      break;

	    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 == (const char *) NULL || *name == 0)
		  fprintf (fp, _("no symbol"));
		else if (! demangling)
		  fprintf (fp, "%s", name);
		else
		  {
		    char *demangled;

		    demangled = demangle (name);
		    fprintf (fp, "%s", demangled);
		    free (demangled);
		  }
	      }
	      break;

	    case 'B':
	      /* filename from a bfd */
	      {
		bfd *abfd = va_arg (arg, bfd *);
		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
		    && strcmp (i->local_sym_name, i->filename) != 0)
		  fprintf (fp, " (%s)", i->filename);
	      }
	      break;

	    case 'S':
	      /* Print script file and linenumber.  */
	      if (parsing_defsym)
		fprintf (fp, "--defsym %s", lex_string);
	      else if (ldfile_input_filename != NULL)
		fprintf (fp, "%s:%u", ldfile_input_filename, lineno);
	      else
		fprintf (fp, _("built in linker script:%u"), 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':
	      /* 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;
		lang_input_statement_type *entry;
		asymbol **asymbols;
		const char *filename;
		const char *functionname;
		unsigned int linenumber;
		bfd_boolean discard_last;

		abfd = va_arg (arg, bfd *);
		section = va_arg (arg, asection *);
		offset = va_arg (arg, bfd_vma);

		entry = (lang_input_statement_type *) abfd->usrdata;
		if (entry != (lang_input_statement_type *) NULL
		    && entry->asymbols != (asymbol **) NULL)
		  asymbols = entry->asymbols;
		else
		  {
		    long symsize;
		    long symbol_count;

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

		lfinfo (fp, "%B(%s+0x%v)", abfd, section->name, offset);

		discard_last = TRUE;
		if (bfd_find_nearest_line (abfd, section, asymbols, offset,
					   &filename, &functionname,
					   &linenumber))
		  {
		    bfd_boolean need_colon = TRUE;

		    if (functionname != NULL && fmt[-1] == 'C')
		      {
			if (last_bfd == NULL
			    || last_file == NULL
			    || last_function == NULL
			    || last_bfd != abfd
			    || (filename != NULL
				&& strcmp (last_file, filename) != 0)
			    || strcmp (last_function, functionname) != 0)
			  {
			    lfinfo (fp, _(": In function `%T':\n"),
				    functionname);
			    need_colon = FALSE;

			    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;
		      }

		    if (filename != NULL)
		      {
			if (need_colon)
			  putc (':', fp);
			fputs (filename, fp);
		      }

		    if (functionname != NULL && fmt[-1] == 'G')
		      lfinfo (fp, ":%T", functionname);
		    else if (filename != NULL && linenumber != 0)
		      fprintf (fp, ":%u", linenumber);
		  }

		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 '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;
	    }
	}
    }

  if (config.fatal_warnings)
    config.make_executable = FALSE;

  if (fatal)
    xexit (1);
}

/* Wrapper around cplus_demangle.  Strips leading underscores and
   other such chars that would otherwise confuse the demangler.  */

char *
demangle (name)
     const char *name;
{
  char *res;
  const char *p;

  if (output_bfd != NULL
      && bfd_get_symbol_leading_char (output_bfd) == name[0])
    ++name;

  /* This is a hack for better error reporting on XCOFF, PowerPC64-ELF
     or the MS PE format.  These formats have a number of leading '.'s
     on at least some symbols, so we remove all dots to avoid
     confusing the demangler.  */
  p = name;
  while (*p == '.')
    ++p;

  res = cplus_demangle (p, DMGL_ANSI | DMGL_PARAMS);
  if (res)
    {
      size_t dots = p - name;

      /* Now put back any stripped dots.  */
      if (dots != 0)
	{
	  size_t len = strlen (res) + 1;
	  char *add_dots = xmalloc (len + dots);

	  memcpy (add_dots, name, dots);
	  memcpy (add_dots + dots, res, len);
	  free (res);
	  res = add_dots;
	}
      return res;
    }
  return xstrdup (name);
}

/* Format info message and print on stdout.  */

/* (You would think this should be called just "info", but then you
   would hosed by LynxOS, which defines that name in its libc.)  */

void
info_msg VPARAMS ((const char *fmt, ...))
{
  VA_OPEN (arg, fmt);
  VA_FIXEDARG (arg, const char *, fmt);

  vfinfo (stdout, fmt, arg);
  VA_CLOSE (arg);
}

/* ('e' for error.) Format info message and print on stderr.  */

void
einfo VPARAMS ((const char *fmt, ...))
{
  VA_OPEN (arg, fmt);
  VA_FIXEDARG (arg, const char *, fmt);

  vfinfo (stderr, fmt, arg);
  VA_CLOSE (arg);
}

void
info_assert (file, line)
     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 VPARAMS ((const char *fmt, ...))
{
  VA_OPEN (arg, fmt);
  VA_FIXEDARG (arg, const char *, fmt);

  vfinfo (config.map_file, fmt, arg);
  VA_CLOSE (arg);
}

void
lfinfo VPARAMS ((FILE *file, const char *fmt, ...))
{
  VA_OPEN (arg, fmt);
  VA_FIXEDARG (arg, FILE *, file);
  VA_FIXEDARG (arg, const char *, fmt);

  vfinfo (file, fmt, arg);
  VA_CLOSE (arg);
}
\f
/* Functions to print the link map.  */

void
print_space ()
{
  fprintf (config.map_file, " ");
}

void
print_nl ()
{
  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 (file, line, fn)
     const char *file;
     int line;
     const char *fn;
{
  if (fn != NULL)
    einfo (_("%P: internal error: aborting at %s line %d in %s\n"),
	   file, line, fn);
  else
    einfo (_("%P: internal error: aborting at %s line %d\n"),
	   file, line);
  einfo (_("%P%F: please report this bug\n"));
  xexit (1);
}
Commit	Line	Data
252b5132	1	/* ldmisc.c
6d39955e AM	2	Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
6d39955e AM	3	2000, 2002
252b5132 RH	4	Free Software Foundation, Inc.
	5	Written by Steve Chamberlain of Cygnus Support.
	6
	7	This file is part of GLD, the Gnu Linker.
	8
	9	GLD is free software; you can redistribute it and/or modify
	10	it under the terms of the GNU General Public License as published by
	11	the Free Software Foundation; either version 2, or (at your option)
	12	any later version.
	13
	14	GLD is distributed in the hope that it will be useful,
	15	but WITHOUT ANY WARRANTY; without even the implied warranty of
	16	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	17	GNU General Public License for more details.
	18
	19	You should have received a copy of the GNU General Public License
	20	along with GLD; see the file COPYING. If not, write to the Free
	21	Software Foundation, 59 Temple Place - Suite 330, Boston, MA
	22	02111-1307, USA. */
	23
	24	#include "bfd.h"
	25	#include "sysdep.h"
	26	#include "libiberty.h"
	27	#include "demangle.h"
	28
	29	#ifdef ANSI_PROTOTYPES
	30	#include <stdarg.h>
252b5132 RH	31	#else
252b5132 RH	32	#include <varargs.h>
252b5132 RH	33	#endif
	34
	35	#include "ld.h"
	36	#include "ldmisc.h"
	37	#include "ldexp.h"
	38	#include "ldlang.h"
df2a7313	39	#include <ldgram.h>
252b5132 RH	40	#include "ldlex.h"
	41	#include "ldmain.h"
	42	#include "ldfile.h"
	43
	44	static void vfinfo PARAMS ((FILE , const char , va_list));
	45
	46	/*
	47	%% literal %
	48	%F error is fatal
	49	%P print program name
	50	%S print script file and linenumber
	51	%E current bfd error or errno
	52	%I filename from a lang_input_statement_type
	53	%B filename from a bfd
	54	%T symbol name
	55	%X no object output, fail return
	56	%V hex bfd_vma
	57	%v hex bfd_vma, no leading zeros
	58	%W hex bfd_vma with 0x with no leading zeros taking up 8 spaces
	59	%C clever filename:linenumber with function
	60	%D like %C, but no function name
	61	%G like %D, but only function name
	62	%R info about a relent
	63	%s arbitrary string, like printf
	64	%d integer, like printf
	65	%u integer, like printf
	66	*/
	67
252b5132 RH	68	static void
	69	vfinfo (fp, fmt, arg)
	70	FILE *fp;
	71	const char *fmt;
	72	va_list arg;
	73	{
b34976b6	74	bfd_boolean fatal = FALSE;
252b5132 RH	75
	76	while (*fmt != '\0')
	77	{
6d5e62f8	78	while (fmt != '%' && fmt != '\0')
252b5132 RH	79	{
	80	putc (*fmt, fp);
	81	fmt++;
	82	}
	83
6d5e62f8	84	if (*fmt == '%')
252b5132	85	{
6d5e62f8 KH	86	fmt++;
6d5e62f8 KH	87	switch (*fmt++)
252b5132 RH	88	{
252b5132 RH	89	default:
6d5e62f8	90	fprintf (fp, "%%%c", fmt[-1]);
252b5132 RH	91	break;
	92
	93	case '%':
	94	/* literal % */
	95	putc ('%', fp);
	96	break;
	97
	98	case 'X':
	99	/* no object output, fail return */
b34976b6	100	config.make_executable = FALSE;
252b5132 RH	101	break;
	102
	103	case 'V':
	104	/* hex bfd_vma */
	105	{
	106	bfd_vma value = va_arg (arg, bfd_vma);
	107	fprintf_vma (fp, value);
	108	}
	109	break;
	110
	111	case 'v':
	112	/* hex bfd_vma, no leading zeros */
	113	{
	114	char buf[100];
	115	char *p = buf;
	116	bfd_vma value = va_arg (arg, bfd_vma);
	117	sprintf_vma (p, value);
	118	while (*p == '0')
	119	p++;
	120	if (!*p)
	121	p--;
	122	fputs (p, fp);
	123	}
	124	break;
	125
	126	case 'W':
	127	/* hex bfd_vma with 0x with no leading zeroes taking up
	128	8 spaces. */
	129	{
	130	char buf[100];
	131	bfd_vma value;
	132	char *p;
	133	int len;
	134
	135	value = va_arg (arg, bfd_vma);
	136	sprintf_vma (buf, value);
	137	for (p = buf; *p == '0'; ++p)
	138	;
	139	if (*p == '\0')
	140	--p;
	141	len = strlen (p);
	142	while (len < 8)
	143	{
	144	putc (' ', fp);
	145	++len;
	146	}
	147	fprintf (fp, "0x%s", p);
	148	}
	149	break;
	150
	151	case 'T':
	152	/* Symbol name. */
	153	{
	154	const char name = va_arg (arg, const char );
	155
	156	if (name == (const char ) NULL \|\| name == 0)
	157	fprintf (fp, _("no symbol"));
	158	else if (! demangling)
	159	fprintf (fp, "%s", name);
	160	else
	161	{
	162	char *demangled;
	163
	164	demangled = demangle (name);
165	fprintf (fp, "%s", demangled);
166	free (demangled);
167	}
168	}
169	break;
170
171	case 'B':
172	/* filename from a bfd */
6d5e62f8	173	{
252b5132 RH	174	bfd abfd = va_arg (arg, bfd );
	175	if (abfd->my_archive)
	176	fprintf (fp, "%s(%s)", abfd->my_archive->filename,
	177	abfd->filename);
	178	else
	179	fprintf (fp, "%s", abfd->filename);
	180	}
	181	break;
	182
	183	case 'F':
6d5e62f8	184	/* Error is fatal. */
b34976b6	185	fatal = TRUE;
252b5132 RH	186	break;
	187
	188	case 'P':
6d5e62f8	189	/* Print program name. */
252b5132 RH	190	fprintf (fp, "%s", program_name);
	191	break;
	192
	193	case 'E':
	194	/* current bfd error or errno */
305c7206	195	fprintf (fp, "%s", bfd_errmsg (bfd_get_error ()));
252b5132 RH	196	break;
	197
	198	case 'I':
	199	/* filename from a lang_input_statement_type */
	200	{
	201	lang_input_statement_type *i;
	202
	203	i = va_arg (arg, lang_input_statement_type *);
	204	if (bfd_my_archive (i->the_bfd) != NULL)
	205	fprintf (fp, "(%s)",
	206	bfd_get_filename (bfd_my_archive (i->the_bfd)));
	207	fprintf (fp, "%s", i->local_sym_name);
	208	if (bfd_my_archive (i->the_bfd) == NULL
	209	&& strcmp (i->local_sym_name, i->filename) != 0)
	210	fprintf (fp, " (%s)", i->filename);
	211	}
	212	break;
	213
	214	case 'S':
6d5e62f8	215	/* Print script file and linenumber. */
252b5132 RH	216	if (parsing_defsym)
	217	fprintf (fp, "--defsym %s", lex_string);
	218	else if (ldfile_input_filename != NULL)
	219	fprintf (fp, "%s:%u", ldfile_input_filename, lineno);
	220	else
	221	fprintf (fp, _("built in linker script:%u"), lineno);
	222	break;
	223
	224	case 'R':
6d5e62f8	225	/* Print all that's interesting about a relent. */
252b5132 RH	226	{
252b5132 RH	227	arelent relent = va_arg (arg, arelent );
6d5e62f8	228
252b5132 RH	229	lfinfo (fp, "%s+0x%v (type %s)",
	230	(*(relent->sym_ptr_ptr))->name,
	231	relent->addend,
	232	relent->howto->name);
	233	}
	234	break;
6d5e62f8	235
252b5132 RH	236	case 'C':
	237	case 'D':
	238	case 'G':
5cfb2bb2 AM	239	/* Clever filename:linenumber with function name if possible.
5cfb2bb2 AM	240	The arguments are a BFD, a section, and an offset. */
252b5132 RH	241	{
	242	static bfd *last_bfd;
	243	static char *last_file = NULL;
	244	static char *last_function = NULL;
	245	bfd *abfd;
	246	asection *section;
	247	bfd_vma offset;
	248	lang_input_statement_type *entry;
	249	asymbol **asymbols;
	250	const char *filename;
	251	const char *functionname;
	252	unsigned int linenumber;
b34976b6	253	bfd_boolean discard_last;
252b5132 RH	254
	255	abfd = va_arg (arg, bfd *);
	256	section = va_arg (arg, asection *);
	257	offset = va_arg (arg, bfd_vma);
	258
	259	entry = (lang_input_statement_type *) abfd->usrdata;
	260	if (entry != (lang_input_statement_type *) NULL
	261	&& entry->asymbols != (asymbol **) NULL)
	262	asymbols = entry->asymbols;
	263	else
	264	{
	265	long symsize;
	266	long symbol_count;
	267
	268	symsize = bfd_get_symtab_upper_bound (abfd);
	269	if (symsize < 0)
	270	einfo (_("%B%F: could not read symbols\n"), abfd);
	271	asymbols = (asymbol **) xmalloc (symsize);
	272	symbol_count = bfd_canonicalize_symtab (abfd, asymbols);
	273	if (symbol_count < 0)
	274	einfo (_("%B%F: could not read symbols\n"), abfd);
	275	if (entry != (lang_input_statement_type *) NULL)
	276	{
	277	entry->asymbols = asymbols;
	278	entry->symbol_count = symbol_count;
	279	}
	280	}
	281
5cfb2bb2 AM	282	lfinfo (fp, "%B(%s+0x%v)", abfd, section->name, offset);
5cfb2bb2 AM	283
b34976b6	284	discard_last = TRUE;
252b5132 RH	285	if (bfd_find_nearest_line (abfd, section, asymbols, offset,
	286	&filename, &functionname,
	287	&linenumber))
	288	{
b34976b6	289	bfd_boolean need_colon = TRUE;
252b5132	290
5cfb2bb2 AM	291	if (functionname != NULL && fmt[-1] == 'C')
5cfb2bb2 AM	292	{
252b5132 RH	293	if (last_bfd == NULL
	294	\|\| last_file == NULL
	295	\|\| last_function == NULL
	296	\|\| last_bfd != abfd
5cfb2bb2 AM	297	\|\| (filename != NULL
5cfb2bb2 AM	298	&& strcmp (last_file, filename) != 0)
252b5132 RH	299	\|\| strcmp (last_function, functionname) != 0)
252b5132 RH	300	{
5cfb2bb2 AM	301	lfinfo (fp, _(": In function `%T':\n"),
5cfb2bb2 AM	302	functionname);
b34976b6	303	need_colon = FALSE;
252b5132 RH	304
	305	last_bfd = abfd;
	306	if (last_file != NULL)
	307	free (last_file);
5cfb2bb2 AM	308	last_file = NULL;
	309	if (filename)
	310	last_file = xstrdup (filename);
252b5132 RH	311	if (last_function != NULL)
252b5132 RH	312	free (last_function);
d1b2b2dc	313	last_function = xstrdup (functionname);
252b5132	314	}
b34976b6	315	discard_last = FALSE;
252b5132	316	}
5cfb2bb2 AM	317
5cfb2bb2 AM	318	if (filename != NULL)
252b5132	319	{
5cfb2bb2 AM	320	if (need_colon)
	321	putc (':', fp);
	322	fputs (filename, fp);
252b5132	323	}
5cfb2bb2 AM	324
	325	if (functionname != NULL && fmt[-1] == 'G')
	326	lfinfo (fp, ":%T", functionname);
	327	else if (filename != NULL && linenumber != 0)
	328	fprintf (fp, ":%u", linenumber);
252b5132	329	}
252b5132 RH	330
	331	if (discard_last)
	332	{
	333	last_bfd = NULL;
	334	if (last_file != NULL)
	335	{
	336	free (last_file);
	337	last_file = NULL;
	338	}
	339	if (last_function != NULL)
	340	{
	341	free (last_function);
	342	last_function = NULL;
	343	}
	344	}
	345	}
	346	break;
6d5e62f8	347
252b5132 RH	348	case 's':
	349	/* arbitrary string, like printf */
	350	fprintf (fp, "%s", va_arg (arg, char *));
	351	break;
	352
	353	case 'd':
	354	/* integer, like printf */
	355	fprintf (fp, "%d", va_arg (arg, int));
	356	break;
	357
	358	case 'u':
	359	/* unsigned integer, like printf */
	360	fprintf (fp, "%u", va_arg (arg, unsigned int));
	361	break;
	362	}
	363	}
	364	}
	365
7ce691ae	366	if (config.fatal_warnings)
b34976b6	367	config.make_executable = FALSE;
7ce691ae	368
b34976b6	369	if (fatal)
6d5e62f8	370	xexit (1);
252b5132 RH	371	}
252b5132 RH	372
b7b482a3 AM	373	/* Wrapper around cplus_demangle. Strips leading underscores and
	374	other such chars that would otherwise confuse the demangler. */
	375
	376	char *
	377	demangle (name)
	378	const char *name;
	379	{
	380	char *res;
	381	const char *p;
	382
	383	if (output_bfd != NULL
	384	&& bfd_get_symbol_leading_char (output_bfd) == name[0])
	385	++name;
	386
	387	/* This is a hack for better error reporting on XCOFF, PowerPC64-ELF
	388	or the MS PE format. These formats have a number of leading '.'s
	389	on at least some symbols, so we remove all dots to avoid
	390	confusing the demangler. */
	391	p = name;
	392	while (*p == '.')
	393	++p;
	394
	395	res = cplus_demangle (p, DMGL_ANSI \| DMGL_PARAMS);
	396	if (res)
	397	{
	398	size_t dots = p - name;
	399
	400	/* Now put back any stripped dots. */
	401	if (dots != 0)
	402	{
	403	size_t len = strlen (res) + 1;
	404	char *add_dots = xmalloc (len + dots);
	405
	406	memcpy (add_dots, name, dots);
	407	memcpy (add_dots + dots, res, len);
	408	free (res);
	409	res = add_dots;
	410	}
	411	return res;
	412	}
	413	return xstrdup (name);
	414	}
	415
6d5e62f8	416	/* Format info message and print on stdout. */
252b5132 RH	417
	418	/* (You would think this should be called just "info", but then you
	419	would hosed by LynxOS, which defines that name in its libc.) */
	420
	421	void
d5e0ebeb	422	info_msg VPARAMS ((const char *fmt, ...))
252b5132	423	{
d5e0ebeb AM	424	VA_OPEN (arg, fmt);
d5e0ebeb AM	425	VA_FIXEDARG (arg, const char *, fmt);
252b5132 RH	426
252b5132 RH	427	vfinfo (stdout, fmt, arg);
d5e0ebeb	428	VA_CLOSE (arg);
252b5132 RH	429	}
252b5132 RH	430
6d5e62f8	431	/* ('e' for error.) Format info message and print on stderr. */
252b5132 RH	432
252b5132 RH	433	void
d5e0ebeb	434	einfo VPARAMS ((const char *fmt, ...))
252b5132	435	{
d5e0ebeb AM	436	VA_OPEN (arg, fmt);
d5e0ebeb AM	437	VA_FIXEDARG (arg, const char *, fmt);
252b5132 RH	438
252b5132 RH	439	vfinfo (stderr, fmt, arg);
d5e0ebeb	440	VA_CLOSE (arg);
252b5132 RH	441	}
252b5132 RH	442
6d5e62f8	443	void
252b5132 RH	444	info_assert (file, line)
	445	const char *file;
	446	unsigned int line;
	447	{
	448	einfo (_("%F%P: internal error %s %d\n"), file, line);
	449	}
	450
6d5e62f8	451	/* ('m' for map) Format info message and print on map. */
252b5132 RH	452
252b5132 RH	453	void
d5e0ebeb	454	minfo VPARAMS ((const char *fmt, ...))
252b5132	455	{
d5e0ebeb AM	456	VA_OPEN (arg, fmt);
d5e0ebeb AM	457	VA_FIXEDARG (arg, const char *, fmt);
252b5132 RH	458
252b5132 RH	459	vfinfo (config.map_file, fmt, arg);
d5e0ebeb	460	VA_CLOSE (arg);
252b5132 RH	461	}
	462
	463	void
d5e0ebeb	464	lfinfo VPARAMS ((FILE file, const char fmt, ...))
252b5132	465	{
d5e0ebeb AM	466	VA_OPEN (arg, fmt);
	467	VA_FIXEDARG (arg, FILE *, file);
	468	VA_FIXEDARG (arg, const char *, fmt);
252b5132 RH	469
252b5132 RH	470	vfinfo (file, fmt, arg);
d5e0ebeb	471	VA_CLOSE (arg);
252b5132 RH	472	}
	473	\f
	474	/* Functions to print the link map. */
	475
6d5e62f8	476	void
252b5132 RH	477	print_space ()
	478	{
	479	fprintf (config.map_file, " ");
	480	}
	481
6d5e62f8	482	void
252b5132 RH	483	print_nl ()
	484	{
	485	fprintf (config.map_file, "\n");
	486	}
45455cdd ILT	487
	488	/* A more or less friendly abort message. In ld.h abort is defined to
	489	call this function. */
	490
	491	void
	492	ld_abort (file, line, fn)
	493	const char *file;
	494	int line;
	495	const char *fn;
	496	{
	497	if (fn != NULL)
	498	einfo (_("%P: internal error: aborting at %s line %d in %s\n"),
	499	file, line, fn);
	500	else
	501	einfo (_("%P: internal error: aborting at %s line %d\n"),
	502	file, line);
	503	einfo (_("%P%F: please report this bug\n"));
	504	xexit (1);
	505	}