ld/ldmisc.c

   1 /* ldmisc.c
   2    Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
   3    2001, 2002, 2003, 2004, 2005
   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'"),
 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)
 364                       {
 365                         if (linenumber != 0)
 366                           fprintf (fp, ":%u", linenumber);
 367                         else
 368                           lfinfo (fp, ":(%A+0x%v)", section, offset);
 369                       }
 370                   }
 371                 else
 372                   lfinfo (fp, "%B:(%A+0x%v)", abfd, section, offset);
 373
 374                 if (asymbols != NULL && entry == NULL)
 375                   free (asymbols);
 376
 377                 if (discard_last)
 378                   {
 379                     last_bfd = NULL;
 380                     if (last_file != NULL)
 381                       {
 382                         free (last_file);
 383                         last_file = NULL;
 384                       }
 385                     if (last_function != NULL)
 386                       {
 387                         free (last_function);
 388                         last_function = NULL;
 389                       }
 390                   }
 391               }
 392               break;
 393
 394             case 's':
 395               /* arbitrary string, like printf */
 396               fprintf (fp, "%s", va_arg (arg, char *));
 397               break;
 398
 399             case 'd':
 400               /* integer, like printf */
 401               fprintf (fp, "%d", va_arg (arg, int));
 402               break;
 403
 404             case 'u':
 405               /* unsigned integer, like printf */
 406               fprintf (fp, "%u", va_arg (arg, unsigned int));
 407               break;
 408
 409             case 'l':
 410               if (*fmt == 'd')
 411                 {
 412                   fprintf (fp, "%ld", va_arg (arg, long));
 413                   ++fmt;
 414                   break;
 415                 }
 416               else if (*fmt == 'u')
 417                 {
 418                   fprintf (fp, "%lu", va_arg (arg, unsigned long));
 419                   ++fmt;
 420                   break;
 421                 }
 422               /* Fall thru */
 423
 424             default:
 425               fprintf (fp, "%%%c", fmt[-1]);
 426               break;
 427             }
 428         }
 429     }
 430
 431   if (is_warning && config.fatal_warnings)
 432     config.make_executable = FALSE;
 433
 434   if (fatal)
 435     xexit (1);
 436 }
 437
 438 /* Wrapper around cplus_demangle.  Strips leading underscores and
 439    other such chars that would otherwise confuse the demangler.  */
 440
 441 char *
 442 demangle (const char *name)
 443 {
 444   char *res;
 445   const char *p;
 446
 447   if (output_bfd != NULL
 448       && bfd_get_symbol_leading_char (output_bfd) == name[0])
 449     ++name;
 450
 451   /* This is a hack for better error reporting on XCOFF, PowerPC64-ELF
 452      or the MS PE format.  These formats have a number of leading '.'s
 453      on at least some symbols, so we remove all dots to avoid
 454      confusing the demangler.  */
 455   p = name;
 456   while (*p == '.')
 457     ++p;
 458
 459   res = cplus_demangle (p, DMGL_ANSI | DMGL_PARAMS);
 460   if (res)
 461     {
 462       size_t dots = p - name;
 463
 464       /* Now put back any stripped dots.  */
 465       if (dots != 0)
 466         {
 467           size_t len = strlen (res) + 1;
 468           char *add_dots = xmalloc (len + dots);
 469
 470           memcpy (add_dots, name, dots);
 471           memcpy (add_dots + dots, res, len);
 472           free (res);
 473           res = add_dots;
 474         }
 475       return res;
 476     }
 477   return xstrdup (name);
 478 }
 479
 480 /* Format info message and print on stdout.  */
 481
 482 /* (You would think this should be called just "info", but then you
 483    would be hosed by LynxOS, which defines that name in its libc.)  */
 484
 485 void
 486 info_msg (const char *fmt, ...)
 487 {
 488   va_list arg;
 489
 490   va_start (arg, fmt);
 491   vfinfo (stdout, fmt, arg, FALSE);
 492   va_end (arg);
 493 }
 494
 495 /* ('e' for error.) Format info message and print on stderr.  */
 496
 497 void
 498 einfo (const char *fmt, ...)
 499 {
 500   va_list arg;
 501
 502   va_start (arg, fmt);
 503   vfinfo (stderr, fmt, arg, TRUE);
 504   va_end (arg);
 505 }
 506
 507 void
 508 info_assert (const char *file, unsigned int line)
 509 {
 510   einfo (_("%F%P: internal error %s %d\n"), file, line);
 511 }
 512
 513 /* ('m' for map) Format info message and print on map.  */
 514
 515 void
 516 minfo (const char *fmt, ...)
 517 {
 518   va_list arg;
 519
 520   va_start (arg, fmt);
 521   vfinfo (config.map_file, fmt, arg, FALSE);
 522   va_end (arg);
 523 }
 524
 525 void
 526 lfinfo (FILE *file, const char *fmt, ...)
 527 {
 528   va_list arg;
 529
 530   va_start (arg, fmt);
 531   vfinfo (file, fmt, arg, FALSE);
 532   va_end (arg);
 533 }
 534 \f
 535 /* Functions to print the link map.  */
 536
 537 void
 538 print_space (void)
 539 {
 540   fprintf (config.map_file, " ");
 541 }
 542
 543 void
 544 print_nl (void)
 545 {
 546   fprintf (config.map_file, "\n");
 547 }
 548
 549 /* A more or less friendly abort message.  In ld.h abort is defined to
 550    call this function.  */
 551
 552 void
 553 ld_abort (const char *file, int line, const char *fn)
 554 {
 555   if (fn != NULL)
 556     einfo (_("%P: internal error: aborting at %s line %d in %s\n"),
 557            file, line, fn);
 558   else
 559     einfo (_("%P: internal error: aborting at %s line %d\n"),
 560            file, line);
 561   einfo (_("%P%F: please report this bug\n"));
 562   xexit (1);
 563 }