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