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
   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 "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 (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                 lang_input_statement_type *entry;
 273                 asymbol **asymbols;
 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                     entry = NULL;
 286                     asymbols = NULL;
 287                   }
 288                 else
 289                   {
 290                     entry = (lang_input_statement_type *) abfd->usrdata;
 291                     if (entry != (lang_input_statement_type *) NULL
 292                         && entry->asymbols != (asymbol **) NULL)
 293                       asymbols = entry->asymbols;
 294                     else
 295                       {
 296                         long symsize;
 297                         long sym_count;
 298
 299                         symsize = bfd_get_symtab_upper_bound (abfd);
 300                         if (symsize < 0)
 301                           einfo (_("%B%F: could not read symbols\n"), abfd);
 302                         asymbols = xmalloc (symsize);
 303                         sym_count = bfd_canonicalize_symtab (abfd, asymbols);
 304                         if (sym_count < 0)
 305                           einfo (_("%B%F: could not read symbols\n"), abfd);
 306                         if (entry != (lang_input_statement_type *) NULL)
 307                           {
 308                             entry->asymbols = asymbols;
 309                             entry->symbol_count = sym_count;
 310                           }
 311                       }
 312                   }
 313
 314                 /* The GNU Coding Standard requires that error messages
 315                    be of the form:
 316
 317                      source-file-name:lineno: message
 318
 319                    We do not always have a line number available so if
 320                    we cannot find them we print out the section name and
 321                    offset instread.  */
 322                 discard_last = TRUE;
 323                 if (abfd != NULL
 324                     && bfd_find_nearest_line (abfd, section, asymbols, offset,
 325                                               &filename, &functionname,
 326                                               &linenumber))
 327                   {
 328                     if (functionname != NULL && fmt[-1] == 'C')
 329                       {
 330                         /* Detect the case where we are printing out a
 331                            message for the same function as the last
 332                            call to vinfo ("%C").  In this situation do
 333                            not print out the ABFD filename or the
 334                            function name again.  Note - we do still
 335                            print out the source filename, as this will
 336                            allow programs that parse the linker's output
 337                            (eg emacs) to correctly locate multiple
 338                            errors in the same source file.  */
 339                         if (last_bfd == NULL
 340                             || last_file == NULL
 341                             || last_function == NULL
 342                             || last_bfd != abfd
 343                             || (filename != NULL
 344                                 && strcmp (last_file, filename) != 0)
 345                             || strcmp (last_function, functionname) != 0)
 346                           {
 347                             lfinfo (fp, _("%B: In function `%T':\n"),
 348                                     abfd, functionname);
 349
 350                             last_bfd = abfd;
 351                             if (last_file != NULL)
 352                               free (last_file);
 353                             last_file = NULL;
 354                             if (filename)
 355                               last_file = xstrdup (filename);
 356                             if (last_function != NULL)
 357                               free (last_function);
 358                             last_function = xstrdup (functionname);
 359                           }
 360                         discard_last = FALSE;
 361                       }
 362                     else
 363                       lfinfo (fp, "%B:", abfd);
 364
 365                     if (filename != NULL)
 366                       fprintf (fp, "%s:", filename);
 367
 368                     if (functionname != NULL && fmt[-1] == 'G')
 369                       lfinfo (fp, "%T", functionname);
 370                     else if (filename != NULL && linenumber != 0)
 371                       fprintf (fp, "%u", linenumber);
 372                     else
 373                       lfinfo (fp, "(%A+0x%v)", section, offset);
 374                   }
 375                 else
 376                   lfinfo (fp, "%B:(%A+0x%v)", abfd, section, offset);
 377
 378                 if (asymbols != NULL && entry == NULL)
 379                   free (asymbols);
 380
 381                 if (discard_last)
 382                   {
 383                     last_bfd = NULL;
 384                     if (last_file != NULL)
 385                       {
 386                         free (last_file);
 387                         last_file = NULL;
 388                       }
 389                     if (last_function != NULL)
 390                       {
 391                         free (last_function);
 392                         last_function = NULL;
 393                       }
 394                   }
 395               }
 396               break;
 397
 398             case 's':
 399               /* arbitrary string, like printf */
 400               fprintf (fp, "%s", va_arg (arg, char *));
 401               break;
 402
 403             case 'd':
 404               /* integer, like printf */
 405               fprintf (fp, "%d", va_arg (arg, int));
 406               break;
 407
 408             case 'u':
 409               /* unsigned integer, like printf */
 410               fprintf (fp, "%u", va_arg (arg, unsigned int));
 411               break;
 412
 413             case 'l':
 414               if (*fmt == 'd')
 415                 {
 416                   fprintf (fp, "%ld", va_arg (arg, long));
 417                   ++fmt;
 418                   break;
 419                 }
 420               else if (*fmt == 'u')
 421                 {
 422                   fprintf (fp, "%lu", va_arg (arg, unsigned long));
 423                   ++fmt;
 424                   break;
 425                 }
 426               /* Fall thru */
 427
 428             default:
 429               fprintf (fp, "%%%c", fmt[-1]);
 430               break;
 431             }
 432         }
 433     }
 434
 435   if (is_warning && config.fatal_warnings)
 436     config.make_executable = FALSE;
 437
 438   if (fatal)
 439     xexit (1);
 440 }
 441
 442 /* Format info message and print on stdout.  */
 443
 444 /* (You would think this should be called just "info", but then you
 445    would be hosed by LynxOS, which defines that name in its libc.)  */
 446
 447 void
 448 info_msg (const char *fmt, ...)
 449 {
 450   va_list arg;
 451
 452   va_start (arg, fmt);
 453   vfinfo (stdout, fmt, arg, FALSE);
 454   va_end (arg);
 455 }
 456
 457 /* ('e' for error.) Format info message and print on stderr.  */
 458
 459 void
 460 einfo (const char *fmt, ...)
 461 {
 462   va_list arg;
 463
 464   va_start (arg, fmt);
 465   vfinfo (stderr, fmt, arg, TRUE);
 466   va_end (arg);
 467 }
 468
 469 void
 470 info_assert (const char *file, unsigned int line)
 471 {
 472   einfo (_("%F%P: internal error %s %d\n"), file, line);
 473 }
 474
 475 /* ('m' for map) Format info message and print on map.  */
 476
 477 void
 478 minfo (const char *fmt, ...)
 479 {
 480   va_list arg;
 481
 482   va_start (arg, fmt);
 483   vfinfo (config.map_file, fmt, arg, FALSE);
 484   va_end (arg);
 485 }
 486
 487 void
 488 lfinfo (FILE *file, const char *fmt, ...)
 489 {
 490   va_list arg;
 491
 492   va_start (arg, fmt);
 493   vfinfo (file, fmt, arg, FALSE);
 494   va_end (arg);
 495 }
 496 \f
 497 /* Functions to print the link map.  */
 498
 499 void
 500 print_space (void)
 501 {
 502   fprintf (config.map_file, " ");
 503 }
 504
 505 void
 506 print_nl (void)
 507 {
 508   fprintf (config.map_file, "\n");
 509 }
 510
 511 /* A more or less friendly abort message.  In ld.h abort is defined to
 512    call this function.  */
 513
 514 void
 515 ld_abort (const char *file, int line, const char *fn)
 516 {
 517   if (fn != NULL)
 518     einfo (_("%P: internal error: aborting at %s line %d in %s\n"),
 519            file, line, fn);
 520   else
 521     einfo (_("%P: internal error: aborting at %s line %d\n"),
 522            file, line);
 523   einfo (_("%P%F: please report this bug\n"));
 524   xexit (1);
 525 }