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
   4    Free Software Foundation, Inc.
   5    Written by Steve Chamberlain of Cygnus Support.
   6
   7    This file is part of GLD, the Gnu Linker.
   8
   9    GLD 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 2, or (at your option)
  12    any later version.
  13
  14    GLD 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 GLD; see the file COPYING.  If not, write to the Free
  21    Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
  22    02110-1301, USA.  */
  23
  24 #include "bfd.h"
  25 #include "bfdlink.h"
  26 #include "sysdep.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                   fprintf (fp, _("no symbol"));
 148                 else if (! demangling)
 149                   fprintf (fp, "%s", name);
 150                 else
 151                   {
 152                     char *demangled;
 153
 154                     demangled = demangle (name);
 155                     fprintf (fp, "%s", demangled);
 156                     free (demangled);
 157                   }
 158               }
 159               break;
 160
 161             case 'A':
 162               /* section name from a section */
 163               {
 164                 asection *sec = va_arg (arg, asection *);
 165                 bfd *abfd = sec->owner;
 166                 const char *group = NULL;
 167                 struct coff_comdat_info *ci;
 168
 169                 fprintf (fp, "%s", sec->name);
 170                 if (abfd != NULL
 171                     && bfd_get_flavour (abfd) == bfd_target_elf_flavour
 172                     && elf_next_in_group (sec) != NULL
 173                     && (sec->flags & SEC_GROUP) == 0)
 174                   group = elf_group_name (sec);
 175                 else if (abfd != NULL
 176                          && bfd_get_flavour (abfd) == bfd_target_coff_flavour
 177                          && (ci = bfd_coff_get_comdat_section (sec->owner,
 178                                                                sec)) != NULL)
 179                   group = ci->name;
 180                 if (group != NULL)
 181                   fprintf (fp, "[%s]", group);
 182               }
 183               break;
 184
 185             case 'B':
 186               /* filename from a bfd */
 187               {
 188                 bfd *abfd = va_arg (arg, bfd *);
 189
 190                 if (abfd == NULL)
 191                   fprintf (fp, "%s generated", program_name);
 192                 else if (abfd->my_archive)
 193                   fprintf (fp, "%s(%s)", abfd->my_archive->filename,
 194                            abfd->filename);
 195                 else
 196                   fprintf (fp, "%s", abfd->filename);
 197               }
 198               break;
 199
 200             case 'F':
 201               /* Error is fatal.  */
 202               fatal = TRUE;
 203               break;
 204
 205             case 'P':
 206               /* Print program name.  */
 207               fprintf (fp, "%s", program_name);
 208               break;
 209
 210             case 'E':
 211               /* current bfd error or errno */
 212               fprintf (fp, "%s", bfd_errmsg (bfd_get_error ()));
 213               break;
 214
 215             case 'I':
 216               /* filename from a lang_input_statement_type */
 217               {
 218                 lang_input_statement_type *i;
 219
 220                 i = va_arg (arg, lang_input_statement_type *);
 221                 if (bfd_my_archive (i->the_bfd) != NULL)
 222                   fprintf (fp, "(%s)",
 223                            bfd_get_filename (bfd_my_archive (i->the_bfd)));
 224                 fprintf (fp, "%s", i->local_sym_name);
 225                 if (bfd_my_archive (i->the_bfd) == NULL
 226                     && strcmp (i->local_sym_name, i->filename) != 0)
 227                   fprintf (fp, " (%s)", i->filename);
 228               }
 229               break;
 230
 231             case 'S':
 232               /* Print script file and linenumber.  */
 233               if (parsing_defsym)
 234                 fprintf (fp, "--defsym %s", lex_string);
 235               else if (ldfile_input_filename != NULL)
 236                 fprintf (fp, "%s:%u", ldfile_input_filename, lineno);
 237               else
 238                 fprintf (fp, _("built in linker script:%u"), lineno);
 239               break;
 240
 241             case 'R':
 242               /* Print all that's interesting about a relent.  */
 243               {
 244                 arelent *relent = va_arg (arg, arelent *);
 245
 246                 lfinfo (fp, "%s+0x%v (type %s)",
 247                         (*(relent->sym_ptr_ptr))->name,
 248                         relent->addend,
 249                         relent->howto->name);
 250               }
 251               break;
 252
 253             case 'C':
 254             case 'D':
 255             case 'G':
 256               /* Clever filename:linenumber with function name if possible.
 257                  The arguments are a BFD, a section, and an offset.  */
 258               {
 259                 static bfd *last_bfd;
 260                 static char *last_file = NULL;
 261                 static char *last_function = NULL;
 262                 bfd *abfd;
 263                 asection *section;
 264                 bfd_vma offset;
 265                 lang_input_statement_type *entry;
 266                 asymbol **asymbols;
 267                 const char *filename;
 268                 const char *functionname;
 269                 unsigned int linenumber;
 270                 bfd_boolean discard_last;
 271
 272                 abfd = va_arg (arg, bfd *);
 273                 section = va_arg (arg, asection *);
 274                 offset = va_arg (arg, bfd_vma);
 275
 276                 if (abfd == NULL)
 277                   {
 278                     entry = NULL;
 279                     asymbols = NULL;
 280                   }
 281                 else
 282                   {
 283                     entry = (lang_input_statement_type *) abfd->usrdata;
 284                     if (entry != (lang_input_statement_type *) NULL
 285                         && entry->asymbols != (asymbol **) NULL)
 286                       asymbols = entry->asymbols;
 287                     else
 288                       {
 289                         long symsize;
 290                         long sym_count;
 291
 292                         symsize = bfd_get_symtab_upper_bound (abfd);
 293                         if (symsize < 0)
 294                           einfo (_("%B%F: could not read symbols\n"), abfd);
 295                         asymbols = xmalloc (symsize);
 296                         sym_count = bfd_canonicalize_symtab (abfd, asymbols);
 297                         if (sym_count < 0)
 298                           einfo (_("%B%F: could not read symbols\n"), abfd);
 299                         if (entry != (lang_input_statement_type *) NULL)
 300                           {
 301                             entry->asymbols = asymbols;
 302                             entry->symbol_count = sym_count;
 303                           }
 304                       }
 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 instread.  */
 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 && fmt[-1] == 'C')
 322                       {
 323                         /* Detect the case where we are printing out a
 324                            message for the same function as the last
 325                            call to vinfo ("%C").  In this situation do
 326                            not print out the ABFD filename or the
 327                            function name again.  Note - we do still
 328                            print out the source filename, as this will
 329                            allow programs that parse the linker's output
 330                            (eg emacs) to correctly locate multiple
 331                            errors in the same source file.  */
 332                         if (last_bfd == NULL
 333                             || last_file == NULL
 334                             || last_function == NULL
 335                             || last_bfd != abfd
 336                             || (filename != NULL
 337                                 && strcmp (last_file, filename) != 0)
 338                             || strcmp (last_function, functionname) != 0)
 339                           {
 340                             lfinfo (fp, _("%B: In function `%T':\n"),
 341                                     abfd, functionname);
 342
 343                             last_bfd = abfd;
 344                             if (last_file != NULL)
 345                               free (last_file);
 346                             last_file = NULL;
 347                             if (filename)
 348                               last_file = xstrdup (filename);
 349                             if (last_function != NULL)
 350                               free (last_function);
 351                             last_function = xstrdup (functionname);
 352                           }
 353                         discard_last = FALSE;
 354                       }
 355                     else
 356                       lfinfo (fp, "%B:", abfd);
 357
 358                     if (filename != NULL)
 359                       fprintf (fp, "%s:", filename);
 360
 361                     if (functionname != NULL && fmt[-1] == 'G')
 362                       lfinfo (fp, "%T", functionname);
 363                     else if (filename != NULL && linenumber != 0)
 364                       fprintf (fp, "%u", linenumber);
 365                     else
 366                       lfinfo (fp, "(%A+0x%v)", section, offset);
 367                   }
 368                 else
 369                   lfinfo (fp, "%B:(%A+0x%v)", abfd, section, offset);
 370
 371                 if (asymbols != NULL && entry == NULL)
 372                   free (asymbols);
 373
 374                 if (discard_last)
 375                   {
 376                     last_bfd = NULL;
 377                     if (last_file != NULL)
 378                       {
 379                         free (last_file);
 380                         last_file = NULL;
 381                       }
 382                     if (last_function != NULL)
 383                       {
 384                         free (last_function);
 385                         last_function = NULL;
 386                       }
 387                   }
 388               }
 389               break;
 390
 391             case 's':
 392               /* arbitrary string, like printf */
 393               fprintf (fp, "%s", va_arg (arg, char *));
 394               break;
 395
 396             case 'd':
 397               /* integer, like printf */
 398               fprintf (fp, "%d", va_arg (arg, int));
 399               break;
 400
 401             case 'u':
 402               /* unsigned integer, like printf */
 403               fprintf (fp, "%u", va_arg (arg, unsigned int));
 404               break;
 405
 406             case 'l':
 407               if (*fmt == 'd')
 408                 {
 409                   fprintf (fp, "%ld", va_arg (arg, long));
 410                   ++fmt;
 411                   break;
 412                 }
 413               else if (*fmt == 'u')
 414                 {
 415                   fprintf (fp, "%lu", va_arg (arg, unsigned long));
 416                   ++fmt;
 417                   break;
 418                 }
 419               /* Fall thru */
 420
 421             default:
 422               fprintf (fp, "%%%c", fmt[-1]);
 423               break;
 424             }
 425         }
 426     }
 427
 428   if (is_warning && config.fatal_warnings)
 429     config.make_executable = FALSE;
 430
 431   if (fatal)
 432     xexit (1);
 433 }
 434
 435 /* Wrapper around cplus_demangle.  Strips leading underscores and
 436    other such chars that would otherwise confuse the demangler.  */
 437
 438 char *
 439 demangle (const char *name)
 440 {
 441   char *res;
 442   const char *p;
 443
 444   if (output_bfd != NULL
 445       && bfd_get_symbol_leading_char (output_bfd) == name[0])
 446     ++name;
 447
 448   /* This is a hack for better error reporting on XCOFF, PowerPC64-ELF
 449      or the MS PE format.  These formats have a number of leading '.'s
 450      on at least some symbols, so we remove all dots to avoid
 451      confusing the demangler.  */
 452   p = name;
 453   while (*p == '.')
 454     ++p;
 455
 456   res = cplus_demangle (p, DMGL_ANSI | DMGL_PARAMS);
 457   if (res)
 458     {
 459       size_t dots = p - name;
 460
 461       /* Now put back any stripped dots.  */
 462       if (dots != 0)
 463         {
 464           size_t len = strlen (res) + 1;
 465           char *add_dots = xmalloc (len + dots);
 466
 467           memcpy (add_dots, name, dots);
 468           memcpy (add_dots + dots, res, len);
 469           free (res);
 470           res = add_dots;
 471         }
 472       return res;
 473     }
 474   return xstrdup (name);
 475 }
 476
 477 /* Format info message and print on stdout.  */
 478
 479 /* (You would think this should be called just "info", but then you
 480    would be hosed by LynxOS, which defines that name in its libc.)  */
 481
 482 void
 483 info_msg (const char *fmt, ...)
 484 {
 485   va_list arg;
 486
 487   va_start (arg, fmt);
 488   vfinfo (stdout, fmt, arg, FALSE);
 489   va_end (arg);
 490 }
 491
 492 /* ('e' for error.) Format info message and print on stderr.  */
 493
 494 void
 495 einfo (const char *fmt, ...)
 496 {
 497   va_list arg;
 498
 499   va_start (arg, fmt);
 500   vfinfo (stderr, fmt, arg, TRUE);
 501   va_end (arg);
 502 }
 503
 504 void
 505 info_assert (const char *file, unsigned int line)
 506 {
 507   einfo (_("%F%P: internal error %s %d\n"), file, line);
 508 }
 509
 510 /* ('m' for map) Format info message and print on map.  */
 511
 512 void
 513 minfo (const char *fmt, ...)
 514 {
 515   va_list arg;
 516
 517   va_start (arg, fmt);
 518   vfinfo (config.map_file, fmt, arg, FALSE);
 519   va_end (arg);
 520 }
 521
 522 void
 523 lfinfo (FILE *file, const char *fmt, ...)
 524 {
 525   va_list arg;
 526
 527   va_start (arg, fmt);
 528   vfinfo (file, fmt, arg, FALSE);
 529   va_end (arg);
 530 }
 531 \f
 532 /* Functions to print the link map.  */
 533
 534 void
 535 print_space (void)
 536 {
 537   fprintf (config.map_file, " ");
 538 }
 539
 540 void
 541 print_nl (void)
 542 {
 543   fprintf (config.map_file, "\n");
 544 }
 545
 546 /* A more or less friendly abort message.  In ld.h abort is defined to
 547    call this function.  */
 548
 549 void
 550 ld_abort (const char *file, int line, const char *fn)
 551 {
 552   if (fn != NULL)
 553     einfo (_("%P: internal error: aborting at %s line %d in %s\n"),
 554            file, line, fn);
 555   else
 556     einfo (_("%P: internal error: aborting at %s line %d\n"),
 557            file, line);
 558   einfo (_("%P%F: please report this bug\n"));
 559   xexit (1);
 560 }