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