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