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