ld/ldmisc.c

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