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