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                 if (abfd->my_archive)
 192                   fprintf (fp, "%s(%s)", abfd->my_archive->filename,
 193                            abfd->filename);
 194                 else
 195                   fprintf (fp, "%s", abfd->filename);
 196               }
 197               break;
 198
 199             case 'F':
 200               /* Error is fatal.  */
 201               fatal = TRUE;
 202               break;
 203
 204             case 'P':
 205               /* Print program name.  */
 206               fprintf (fp, "%s", program_name);
 207               break;
 208
 209             case 'E':
 210               /* current bfd error or errno */
 211               fprintf (fp, "%s", bfd_errmsg (bfd_get_error ()));
 212               break;
 213
 214             case 'I':
 215               /* filename from a lang_input_statement_type */
 216               {
 217                 lang_input_statement_type *i;
 218
 219                 i = va_arg (arg, lang_input_statement_type *);
 220                 if (bfd_my_archive (i->the_bfd) != NULL)
 221                   fprintf (fp, "(%s)",
 222                            bfd_get_filename (bfd_my_archive (i->the_bfd)));
 223                 fprintf (fp, "%s", i->local_sym_name);
 224                 if (bfd_my_archive (i->the_bfd) == NULL
 225                     && strcmp (i->local_sym_name, i->filename) != 0)
 226                   fprintf (fp, " (%s)", i->filename);
 227               }
 228               break;
 229
 230             case 'S':
 231               /* Print script file and linenumber.  */
 232               if (parsing_defsym)
 233                 fprintf (fp, "--defsym %s", lex_string);
 234               else if (ldfile_input_filename != NULL)
 235                 fprintf (fp, "%s:%u", ldfile_input_filename, lineno);
 236               else
 237                 fprintf (fp, _("built in linker script:%u"), lineno);
 238               break;
 239
 240             case 'R':
 241               /* Print all that's interesting about a relent.  */
 242               {
 243                 arelent *relent = va_arg (arg, arelent *);
 244
 245                 lfinfo (fp, "%s+0x%v (type %s)",
 246                         (*(relent->sym_ptr_ptr))->name,
 247                         relent->addend,
 248                         relent->howto->name);
 249               }
 250               break;
 251
 252             case 'C':
 253             case 'D':
 254             case 'G':
 255               /* Clever filename:linenumber with function name if possible.
 256                  The arguments are a BFD, a section, and an offset.  */
 257               {
 258                 static bfd *last_bfd;
 259                 static char *last_file = NULL;
 260                 static char *last_function = NULL;
 261                 bfd *abfd;
 262                 asection *section;
 263                 bfd_vma offset;
 264                 lang_input_statement_type *entry;
 265                 asymbol **asymbols;
 266                 const char *filename;
 267                 const char *functionname;
 268                 unsigned int linenumber;
 269                 bfd_boolean discard_last;
 270
 271                 abfd = va_arg (arg, bfd *);
 272                 section = va_arg (arg, asection *);
 273                 offset = va_arg (arg, bfd_vma);
 274
 275                 entry = (lang_input_statement_type *) abfd->usrdata;
 276                 if (entry != (lang_input_statement_type *) NULL
 277                     && entry->asymbols != (asymbol **) NULL)
 278                   asymbols = entry->asymbols;
 279                 else
 280                   {
 281                     long symsize;
 282                     long symbol_count;
 283
 284                     symsize = bfd_get_symtab_upper_bound (abfd);
 285                     if (symsize < 0)
 286                       einfo (_("%B%F: could not read symbols\n"), abfd);
 287                     asymbols = xmalloc (symsize);
 288                     symbol_count = bfd_canonicalize_symtab (abfd, asymbols);
 289                     if (symbol_count < 0)
 290                       einfo (_("%B%F: could not read symbols\n"), abfd);
 291                     if (entry != (lang_input_statement_type *) NULL)
 292                       {
 293                         entry->asymbols = asymbols;
 294                         entry->symbol_count = symbol_count;
 295                       }
 296                   }
 297
 298                 lfinfo (fp, "%B(%A+0x%v)", abfd, section, offset);
 299
 300                 discard_last = TRUE;
 301                 if (bfd_find_nearest_line (abfd, section, asymbols, offset,
 302                                            &filename, &functionname,
 303                                            &linenumber))
 304                   {
 305                     bfd_boolean need_colon = TRUE;
 306
 307                     if (functionname != NULL && fmt[-1] == 'C')
 308                       {
 309                         if (last_bfd == NULL
 310                             || last_file == NULL
 311                             || last_function == NULL
 312                             || last_bfd != abfd
 313                             || (filename != NULL
 314                                 && strcmp (last_file, filename) != 0)
 315                             || strcmp (last_function, functionname) != 0)
 316                           {
 317                             lfinfo (fp, _(": In function `%T':\n"),
 318                                     functionname);
 319                             need_colon = FALSE;
 320
 321                             last_bfd = abfd;
 322                             if (last_file != NULL)
 323                               free (last_file);
 324                             last_file = NULL;
 325                             if (filename)
 326                               last_file = xstrdup (filename);
 327                             if (last_function != NULL)
 328                               free (last_function);
 329                             last_function = xstrdup (functionname);
 330                           }
 331                         discard_last = FALSE;
 332                       }
 333
 334                     if (filename != NULL)
 335                       {
 336                         if (need_colon)
 337                           putc (':', fp);
 338                         fputs (filename, fp);
 339                       }
 340
 341                     if (functionname != NULL && fmt[-1] == 'G')
 342                       lfinfo (fp, ":%T", functionname);
 343                     else if (filename != NULL && linenumber != 0)
 344                       fprintf (fp, ":%u", linenumber);
 345                   }
 346
 347                 if (asymbols != NULL && entry == NULL)
 348                   free (asymbols);
 349
 350                 if (discard_last)
 351                   {
 352                     last_bfd = NULL;
 353                     if (last_file != NULL)
 354                       {
 355                         free (last_file);
 356                         last_file = NULL;
 357                       }
 358                     if (last_function != NULL)
 359                       {
 360                         free (last_function);
 361                         last_function = NULL;
 362                       }
 363                   }
 364               }
 365               break;
 366
 367             case 's':
 368               /* arbitrary string, like printf */
 369               fprintf (fp, "%s", va_arg (arg, char *));
 370               break;
 371
 372             case 'd':
 373               /* integer, like printf */
 374               fprintf (fp, "%d", va_arg (arg, int));
 375               break;
 376
 377             case 'u':
 378               /* unsigned integer, like printf */
 379               fprintf (fp, "%u", va_arg (arg, unsigned int));
 380               break;
 381             }
 382         }
 383     }
 384
 385   if (config.fatal_warnings)
 386     config.make_executable = FALSE;
 387
 388   if (fatal)
 389     xexit (1);
 390 }
 391
 392 /* Wrapper around cplus_demangle.  Strips leading underscores and
 393    other such chars that would otherwise confuse the demangler.  */
 394
 395 char *
 396 demangle (const char *name)
 397 {
 398   char *res;
 399   const char *p;
 400
 401   if (output_bfd != NULL
 402       && bfd_get_symbol_leading_char (output_bfd) == name[0])
 403     ++name;
 404
 405   /* This is a hack for better error reporting on XCOFF, PowerPC64-ELF
 406      or the MS PE format.  These formats have a number of leading '.'s
 407      on at least some symbols, so we remove all dots to avoid
 408      confusing the demangler.  */
 409   p = name;
 410   while (*p == '.')
 411     ++p;
 412
 413   res = cplus_demangle (p, DMGL_ANSI | DMGL_PARAMS);
 414   if (res)
 415     {
 416       size_t dots = p - name;
 417
 418       /* Now put back any stripped dots.  */
 419       if (dots != 0)
 420         {
 421           size_t len = strlen (res) + 1;
 422           char *add_dots = xmalloc (len + dots);
 423
 424           memcpy (add_dots, name, dots);
 425           memcpy (add_dots + dots, res, len);
 426           free (res);
 427           res = add_dots;
 428         }
 429       return res;
 430     }
 431   return xstrdup (name);
 432 }
 433
 434 /* Format info message and print on stdout.  */
 435
 436 /* (You would think this should be called just "info", but then you
 437    would be hosed by LynxOS, which defines that name in its libc.)  */
 438
 439 void
 440 info_msg (const char *fmt, ...)
 441 {
 442   va_list arg;
 443
 444   va_start (arg, fmt);
 445   vfinfo (stdout, fmt, arg);
 446   va_end (arg);
 447 }
 448
 449 /* ('e' for error.) Format info message and print on stderr.  */
 450
 451 void
 452 einfo (const char *fmt, ...)
 453 {
 454   va_list arg;
 455
 456   va_start (arg, fmt);
 457   vfinfo (stderr, fmt, arg);
 458   va_end (arg);
 459 }
 460
 461 void
 462 info_assert (const char *file, unsigned int line)
 463 {
 464   einfo (_("%F%P: internal error %s %d\n"), file, line);
 465 }
 466
 467 /* ('m' for map) Format info message and print on map.  */
 468
 469 void
 470 minfo (const char *fmt, ...)
 471 {
 472   va_list arg;
 473
 474   va_start (arg, fmt);
 475   vfinfo (config.map_file, fmt, arg);
 476   va_end (arg);
 477 }
 478
 479 void
 480 lfinfo (FILE *file, const char *fmt, ...)
 481 {
 482   va_list arg;
 483
 484   va_start (arg, fmt);
 485   vfinfo (file, fmt, arg);
 486   va_end (arg);
 487 }
 488 \f
 489 /* Functions to print the link map.  */
 490
 491 void
 492 print_space (void)
 493 {
 494   fprintf (config.map_file, " ");
 495 }
 496
 497 void
 498 print_nl (void)
 499 {
 500   fprintf (config.map_file, "\n");
 501 }
 502
 503 /* A more or less friendly abort message.  In ld.h abort is defined to
 504    call this function.  */
 505
 506 void
 507 ld_abort (const char *file, int line, const char *fn)
 508 {
 509   if (fn != NULL)
 510     einfo (_("%P: internal error: aborting at %s line %d in %s\n"),
 511            file, line, fn);
 512   else
 513     einfo (_("%P: internal error: aborting at %s line %d\n"),
 514            file, line);
 515   einfo (_("%P%F: please report this bug\n"));
 516   xexit (1);
 517 }