ld/ldmisc.c

   1 /* ldmisc.c
   2    Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
   3    2002, 2003, 2004
   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)
  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                 lfinfo (fp, "%B(%A+0x%v)", abfd, section, offset);
 302
 303                 discard_last = TRUE;
 304                 if (bfd_find_nearest_line (abfd, section, asymbols, offset,
 305                                            &filename, &functionname,
 306                                            &linenumber))
 307                   {
 308                     bfd_boolean need_colon = TRUE;
 309
 310                     if (functionname != NULL && fmt[-1] == 'C')
 311                       {
 312                         if (last_bfd == NULL
 313                             || last_file == NULL
 314                             || last_function == NULL
 315                             || last_bfd != abfd
 316                             || (filename != NULL
 317                                 && strcmp (last_file, filename) != 0)
 318                             || strcmp (last_function, functionname) != 0)
 319                           {
 320                             lfinfo (fp, _(": In function `%T':\n"),
 321                                     functionname);
 322                             need_colon = FALSE;
 323
 324                             last_bfd = abfd;
 325                             if (last_file != NULL)
 326                               free (last_file);
 327                             last_file = NULL;
 328                             if (filename)
 329                               last_file = xstrdup (filename);
 330                             if (last_function != NULL)
 331                               free (last_function);
 332                             last_function = xstrdup (functionname);
 333                           }
 334                         discard_last = FALSE;
 335                       }
 336
 337                     if (filename != NULL)
 338                       {
 339                         if (need_colon)
 340                           putc (':', fp);
 341                         fputs (filename, fp);
 342                       }
 343
 344                     if (functionname != NULL && fmt[-1] == 'G')
 345                       lfinfo (fp, ":%T", functionname);
 346                     else if (filename != NULL && linenumber != 0)
 347                       fprintf (fp, ":%u", linenumber);
 348                   }
 349
 350                 if (asymbols != NULL && entry == NULL)
 351                   free (asymbols);
 352
 353                 if (discard_last)
 354                   {
 355                     last_bfd = NULL;
 356                     if (last_file != NULL)
 357                       {
 358                         free (last_file);
 359                         last_file = NULL;
 360                       }
 361                     if (last_function != NULL)
 362                       {
 363                         free (last_function);
 364                         last_function = NULL;
 365                       }
 366                   }
 367               }
 368               break;
 369
 370             case 's':
 371               /* arbitrary string, like printf */
 372               fprintf (fp, "%s", va_arg (arg, char *));
 373               break;
 374
 375             case 'd':
 376               /* integer, like printf */
 377               fprintf (fp, "%d", va_arg (arg, int));
 378               break;
 379
 380             case 'u':
 381               /* unsigned integer, like printf */
 382               fprintf (fp, "%u", va_arg (arg, unsigned int));
 383               break;
 384             }
 385         }
 386     }
 387
 388   if (config.fatal_warnings)
 389     config.make_executable = FALSE;
 390
 391   if (fatal)
 392     xexit (1);
 393 }
 394
 395 /* Wrapper around cplus_demangle.  Strips leading underscores and
 396    other such chars that would otherwise confuse the demangler.  */
 397
 398 char *
 399 demangle (const char *name)
 400 {
 401   char *res;
 402   const char *p;
 403
 404   if (output_bfd != NULL
 405       && bfd_get_symbol_leading_char (output_bfd) == name[0])
 406     ++name;
 407
 408   /* This is a hack for better error reporting on XCOFF, PowerPC64-ELF
 409      or the MS PE format.  These formats have a number of leading '.'s
 410      on at least some symbols, so we remove all dots to avoid
 411      confusing the demangler.  */
 412   p = name;
 413   while (*p == '.')
 414     ++p;
 415
 416   res = cplus_demangle (p, DMGL_ANSI | DMGL_PARAMS);
 417   if (res)
 418     {
 419       size_t dots = p - name;
 420
 421       /* Now put back any stripped dots.  */
 422       if (dots != 0)
 423         {
 424           size_t len = strlen (res) + 1;
 425           char *add_dots = xmalloc (len + dots);
 426
 427           memcpy (add_dots, name, dots);
 428           memcpy (add_dots + dots, res, len);
 429           free (res);
 430           res = add_dots;
 431         }
 432       return res;
 433     }
 434   return xstrdup (name);
 435 }
 436
 437 /* Format info message and print on stdout.  */
 438
 439 /* (You would think this should be called just "info", but then you
 440    would be hosed by LynxOS, which defines that name in its libc.)  */
 441
 442 void
 443 info_msg (const char *fmt, ...)
 444 {
 445   va_list arg;
 446
 447   va_start (arg, fmt);
 448   vfinfo (stdout, fmt, arg);
 449   va_end (arg);
 450 }
 451
 452 /* ('e' for error.) Format info message and print on stderr.  */
 453
 454 void
 455 einfo (const char *fmt, ...)
 456 {
 457   va_list arg;
 458
 459   va_start (arg, fmt);
 460   vfinfo (stderr, fmt, arg);
 461   va_end (arg);
 462 }
 463
 464 void
 465 info_assert (const char *file, unsigned int line)
 466 {
 467   einfo (_("%F%P: internal error %s %d\n"), file, line);
 468 }
 469
 470 /* ('m' for map) Format info message and print on map.  */
 471
 472 void
 473 minfo (const char *fmt, ...)
 474 {
 475   va_list arg;
 476
 477   va_start (arg, fmt);
 478   vfinfo (config.map_file, fmt, arg);
 479   va_end (arg);
 480 }
 481
 482 void
 483 lfinfo (FILE *file, const char *fmt, ...)
 484 {
 485   va_list arg;
 486
 487   va_start (arg, fmt);
 488   vfinfo (file, fmt, arg);
 489   va_end (arg);
 490 }
 491 \f
 492 /* Functions to print the link map.  */
 493
 494 void
 495 print_space (void)
 496 {
 497   fprintf (config.map_file, " ");
 498 }
 499
 500 void
 501 print_nl (void)
 502 {
 503   fprintf (config.map_file, "\n");
 504 }
 505
 506 /* A more or less friendly abort message.  In ld.h abort is defined to
 507    call this function.  */
 508
 509 void
 510 ld_abort (const char *file, int line, const char *fn)
 511 {
 512   if (fn != NULL)
 513     einfo (_("%P: internal error: aborting at %s line %d in %s\n"),
 514            file, line, fn);
 515   else
 516     einfo (_("%P: internal error: aborting at %s line %d\n"),
 517            file, line);
 518   einfo (_("%P%F: please report this bug\n"));
 519   xexit (1);
 520 }