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, 2008, 2010, 2011, 2012
   4    Free Software Foundation, Inc.
   5    Written by Steve Chamberlain of Cygnus Support.
   6
   7    This file is part of the GNU Binutils.
   8
   9    This program 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 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program 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 this program; if not, write to the Free Software
  21    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  22    MA 02110-1301, USA.  */
  23
  24 #include "sysdep.h"
  25 #include "bfd.h"
  26 #include "bfdlink.h"
  27 #include "libiberty.h"
  28 #include "filenames.h"
  29 #include "demangle.h"
  30 #include <stdarg.h>
  31 #include "ld.h"
  32 #include "ldmisc.h"
  33 #include "ldexp.h"
  34 #include "ldlang.h"
  35 #include <ldgram.h>
  36 #include "ldlex.h"
  37 #include "ldmain.h"
  38 #include "ldfile.h"
  39 #include "elf-bfd.h"
  40
  41 /*
  42  %% literal %
  43  %A section name from a section
  44  %B filename from a bfd
  45  %C clever filename:linenumber with function
  46  %D like %C, but no function name
  47  %E current bfd error or errno
  48  %F error is fatal
  49  %G like %D, but only function name
  50  %H like %C but in addition emit section+offset
  51  %I filename from a lang_input_statement_type
  52  %P print program name
  53  %R info about a relent
  54  %S print script file and linenumber from etree_type.
  55  %T symbol name
  56  %V hex bfd_vma
  57  %W hex bfd_vma with 0x with no leading zeros taking up 8 spaces
  58  %X no object output, fail return
  59  %d integer, like printf
  60  %ld long, like printf
  61  %lu unsigned long, like printf
  62  %p native (host) void* pointer, like printf
  63  %s arbitrary string, like printf
  64  %u integer, like printf
  65  %v hex bfd_vma, no leading zeros
  66 */
  67
  68 void
  69 vfinfo (FILE *fp, const char *fmt, va_list arg, bfd_boolean is_warning)
  70 {
  71   bfd_boolean fatal = FALSE;
  72
  73   while (*fmt != '\0')
  74     {
  75       while (*fmt != '%' && *fmt != '\0')
  76         {
  77           putc (*fmt, fp);
  78           fmt++;
  79         }
  80
  81       if (*fmt == '%')
  82         {
  83           fmt++;
  84           switch (*fmt++)
  85             {
  86             case '%':
  87               /* literal % */
  88               putc ('%', fp);
  89               break;
  90
  91             case 'X':
  92               /* no object output, fail return */
  93               config.make_executable = FALSE;
  94               break;
  95
  96             case 'V':
  97               /* hex bfd_vma */
  98               {
  99                 bfd_vma value = va_arg (arg, bfd_vma);
 100                 fprintf_vma (fp, value);
 101               }
 102               break;
 103
 104             case 'v':
 105               /* hex bfd_vma, no leading zeros */
 106               {
 107                 char buf[100];
 108                 char *p = buf;
 109                 bfd_vma value = va_arg (arg, bfd_vma);
 110                 sprintf_vma (p, value);
 111                 while (*p == '0')
 112                   p++;
 113                 if (!*p)
 114                   p--;
 115                 fputs (p, fp);
 116               }
 117               break;
 118
 119             case 'W':
 120               /* hex bfd_vma with 0x with no leading zeroes taking up
 121                  8 spaces.  */
 122               {
 123                 char buf[100];
 124                 bfd_vma value;
 125                 char *p;
 126                 int len;
 127
 128                 value = va_arg (arg, bfd_vma);
 129                 sprintf_vma (buf, value);
 130                 for (p = buf; *p == '0'; ++p)
 131                   ;
 132                 if (*p == '\0')
 133                   --p;
 134                 len = strlen (p);
 135                 while (len < 8)
 136                   {
 137                     putc (' ', fp);
 138                     ++len;
 139                   }
 140                 fprintf (fp, "0x%s", p);
 141               }
 142               break;
 143
 144             case 'T':
 145               /* Symbol name.  */
 146               {
 147                 const char *name = va_arg (arg, const char *);
 148
 149                 if (name == NULL || *name == 0)
 150                   {
 151                     fprintf (fp, _("no symbol"));
 152                     break;
 153                   }
 154                 else if (demangling)
 155                   {
 156                     char *demangled;
 157
 158                     demangled = bfd_demangle (link_info.output_bfd, name,
 159                                               DMGL_ANSI | DMGL_PARAMS);
 160                     if (demangled != NULL)
 161                       {
 162                         fprintf (fp, "%s", demangled);
 163                         free (demangled);
 164                         break;
 165                       }
 166                   }
 167                 fprintf (fp, "%s", name);
 168               }
 169               break;
 170
 171             case 'A':
 172               /* section name from a section */
 173               {
 174                 asection *sec = va_arg (arg, asection *);
 175                 bfd *abfd = sec->owner;
 176                 const char *group = NULL;
 177                 struct coff_comdat_info *ci;
 178
 179                 fprintf (fp, "%s", sec->name);
 180                 if (abfd != NULL
 181                     && bfd_get_flavour (abfd) == bfd_target_elf_flavour
 182                     && elf_next_in_group (sec) != NULL
 183                     && (sec->flags & SEC_GROUP) == 0)
 184                   group = elf_group_name (sec);
 185                 else if (abfd != NULL
 186                          && bfd_get_flavour (abfd) == bfd_target_coff_flavour
 187                          && (ci = bfd_coff_get_comdat_section (sec->owner,
 188                                                                sec)) != NULL)
 189                   group = ci->name;
 190                 if (group != NULL)
 191                   fprintf (fp, "[%s]", group);
 192               }
 193               break;
 194
 195             case 'B':
 196               /* filename from a bfd */
 197               {
 198                 bfd *abfd = va_arg (arg, bfd *);
 199
 200                 if (abfd == NULL)
 201                   fprintf (fp, "%s generated", program_name);
 202                 else if (abfd->my_archive)
 203                   fprintf (fp, "%s(%s)", abfd->my_archive->filename,
 204                            abfd->filename);
 205                 else
 206                   fprintf (fp, "%s", abfd->filename);
 207               }
 208               break;
 209
 210             case 'F':
 211               /* Error is fatal.  */
 212               fatal = TRUE;
 213               break;
 214
 215             case 'P':
 216               /* Print program name.  */
 217               fprintf (fp, "%s", program_name);
 218               break;
 219
 220             case 'E':
 221               /* current bfd error or errno */
 222               fprintf (fp, "%s", bfd_errmsg (bfd_get_error ()));
 223               break;
 224
 225             case 'I':
 226               /* filename from a lang_input_statement_type */
 227               {
 228                 lang_input_statement_type *i;
 229
 230                 i = va_arg (arg, lang_input_statement_type *);
 231                 if (bfd_my_archive (i->the_bfd) != NULL)
 232                   fprintf (fp, "(%s)",
 233                            bfd_get_filename (bfd_my_archive (i->the_bfd)));
 234                 fprintf (fp, "%s", i->local_sym_name);
 235                 if (bfd_my_archive (i->the_bfd) == NULL
 236                     && filename_cmp (i->local_sym_name, i->filename) != 0)
 237                   fprintf (fp, " (%s)", i->filename);
 238               }
 239               break;
 240
 241             case 'S':
 242               /* Print script file and linenumber.  */
 243               {
 244                 etree_type node;
 245                 etree_type *tp = va_arg (arg, etree_type *);
 246
 247                 if (tp == NULL)
 248                   {
 249                     tp = &node;
 250                     tp->type.filename = ldlex_filename ();
 251                     tp->type.lineno = lineno;
 252                   }
 253                 if (tp->type.filename != NULL)
 254                   fprintf (fp, "%s:%u", tp->type.filename, tp->type.lineno);
 255               }
 256               break;
 257
 258             case 'R':
 259               /* Print all that's interesting about a relent.  */
 260               {
 261                 arelent *relent = va_arg (arg, arelent *);
 262
 263                 lfinfo (fp, "%s+0x%v (type %s)",
 264                         (*(relent->sym_ptr_ptr))->name,
 265                         relent->addend,
 266                         relent->howto->name);
 267               }
 268               break;
 269
 270             case 'C':
 271             case 'D':
 272             case 'G':
 273             case 'H':
 274               /* Clever filename:linenumber with function name if possible.
 275                  The arguments are a BFD, a section, and an offset.  */
 276               {
 277                 static bfd *last_bfd;
 278                 static char *last_file = NULL;
 279                 static char *last_function = NULL;
 280                 bfd *abfd;
 281                 asection *section;
 282                 bfd_vma offset;
 283                 asymbol **asymbols = NULL;
 284                 const char *filename;
 285                 const char *functionname;
 286                 unsigned int linenumber;
 287                 bfd_boolean discard_last;
 288                 bfd_boolean done;
 289
 290                 abfd = va_arg (arg, bfd *);
 291                 section = va_arg (arg, asection *);
 292                 offset = va_arg (arg, bfd_vma);
 293
 294                 if (abfd != NULL)
 295                   {
 296                     if (!bfd_generic_link_read_symbols (abfd))
 297                       einfo (_("%B%F: could not read symbols: %E\n"), abfd);
 298
 299                     asymbols = bfd_get_outsymbols (abfd);
 300                   }
 301
 302                 /* The GNU Coding Standard requires that error messages
 303                    be of the form:
 304
 305                      source-file-name:lineno: message
 306
 307                    We do not always have a line number available so if
 308                    we cannot find them we print out the section name and
 309                    offset instead.  */
 310                 discard_last = TRUE;
 311                 if (abfd != NULL
 312                     && bfd_find_nearest_line (abfd, section, asymbols, offset,
 313                                               &filename, &functionname,
 314                                               &linenumber))
 315                   {
 316                     if (functionname != NULL
 317                         && (fmt[-1] == 'C' || fmt[-1] == 'H'))
 318                       {
 319                         /* Detect the case where we are printing out a
 320                            message for the same function as the last
 321                            call to vinfo ("%C").  In this situation do
 322                            not print out the ABFD filename or the
 323                            function name again.  Note - we do still
 324                            print out the source filename, as this will
 325                            allow programs that parse the linker's output
 326                            (eg emacs) to correctly locate multiple
 327                            errors in the same source file.  */
 328                         if (last_bfd == NULL
 329                             || last_file == NULL
 330                             || last_function == NULL
 331                             || last_bfd != abfd
 332                             || (filename != NULL
 333                                 && filename_cmp (last_file, filename) != 0)
 334                             || strcmp (last_function, functionname) != 0)
 335                           {
 336                             lfinfo (fp, _("%B: In function `%T':\n"),
 337                                     abfd, functionname);
 338
 339                             last_bfd = abfd;
 340                             if (last_file != NULL)
 341                               free (last_file);
 342                             last_file = NULL;
 343                             if (filename)
 344                               last_file = xstrdup (filename);
 345                             if (last_function != NULL)
 346                               free (last_function);
 347                             last_function = xstrdup (functionname);
 348                           }
 349                         discard_last = FALSE;
 350                       }
 351                     else
 352                       lfinfo (fp, "%B:", abfd);
 353
 354                     if (filename != NULL)
 355                       fprintf (fp, "%s:", filename);
 356
 357                     done = fmt[-1] != 'H';
 358                     if (functionname != NULL && fmt[-1] == 'G')
 359                       lfinfo (fp, "%T", functionname);
 360                     else if (filename != NULL && linenumber != 0)
 361                       fprintf (fp, "%u%s", linenumber, ":" + done);
 362                     else
 363                       done = FALSE;
 364                   }
 365                 else
 366                   {
 367                     lfinfo (fp, "%B:", abfd);
 368                     done = FALSE;
 369                   }
 370                 if (!done)
 371                   lfinfo (fp, "(%A+0x%v)", section, offset);
 372
 373                 if (discard_last)
 374                   {
 375                     last_bfd = NULL;
 376                     if (last_file != NULL)
 377                       {
 378                         free (last_file);
 379                         last_file = NULL;
 380                       }
 381                     if (last_function != NULL)
 382                       {
 383                         free (last_function);
 384                         last_function = NULL;
 385                       }
 386                   }
 387               }
 388               break;
 389
 390             case 'p':
 391               /* native (host) void* pointer, like printf */
 392               fprintf (fp, "%p", va_arg (arg, void *));
 393               break;
 394
 395             case 's':
 396               /* arbitrary string, like printf */
 397               fprintf (fp, "%s", va_arg (arg, char *));
 398               break;
 399
 400             case 'd':
 401               /* integer, like printf */
 402               fprintf (fp, "%d", va_arg (arg, int));
 403               break;
 404
 405             case 'u':
 406               /* unsigned integer, like printf */
 407               fprintf (fp, "%u", va_arg (arg, unsigned int));
 408               break;
 409
 410             case 'l':
 411               if (*fmt == 'd')
 412                 {
 413                   fprintf (fp, "%ld", va_arg (arg, long));
 414                   ++fmt;
 415                   break;
 416                 }
 417               else if (*fmt == 'u')
 418                 {
 419                   fprintf (fp, "%lu", va_arg (arg, unsigned long));
 420                   ++fmt;
 421                   break;
 422                 }
 423               /* Fall thru */
 424
 425             default:
 426               fprintf (fp, "%%%c", fmt[-1]);
 427               break;
 428             }
 429         }
 430     }
 431
 432   if (is_warning && config.fatal_warnings)
 433     config.make_executable = FALSE;
 434
 435   if (fatal)
 436     xexit (1);
 437 }
 438
 439 /* Format info message and print on stdout.  */
 440
 441 /* (You would think this should be called just "info", but then you
 442    would be hosed by LynxOS, which defines that name in its libc.)  */
 443
 444 void
 445 info_msg (const char *fmt, ...)
 446 {
 447   va_list arg;
 448
 449   va_start (arg, fmt);
 450   vfinfo (stdout, fmt, arg, FALSE);
 451   va_end (arg);
 452 }
 453
 454 /* ('e' for error.) Format info message and print on stderr.  */
 455
 456 void
 457 einfo (const char *fmt, ...)
 458 {
 459   va_list arg;
 460
 461   fflush (stdout);
 462   va_start (arg, fmt);
 463   vfinfo (stderr, fmt, arg, TRUE);
 464   va_end (arg);
 465   fflush (stderr);
 466 }
 467
 468 void
 469 info_assert (const char *file, unsigned int line)
 470 {
 471   einfo (_("%F%P: internal error %s %d\n"), file, line);
 472 }
 473
 474 /* ('m' for map) Format info message and print on map.  */
 475
 476 void
 477 minfo (const char *fmt, ...)
 478 {
 479   if (config.map_file != NULL)
 480     {
 481       va_list arg;
 482
 483       va_start (arg, fmt);
 484       vfinfo (config.map_file, fmt, arg, FALSE);
 485       va_end (arg);
 486     }
 487 }
 488
 489 void
 490 lfinfo (FILE *file, const char *fmt, ...)
 491 {
 492   va_list arg;
 493
 494   va_start (arg, fmt);
 495   vfinfo (file, fmt, arg, FALSE);
 496   va_end (arg);
 497 }
 498 \f
 499 /* Functions to print the link map.  */
 500
 501 void
 502 print_space (void)
 503 {
 504   fprintf (config.map_file, " ");
 505 }
 506
 507 void
 508 print_nl (void)
 509 {
 510   fprintf (config.map_file, "\n");
 511 }
 512
 513 /* A more or less friendly abort message.  In ld.h abort is defined to
 514    call this function.  */
 515
 516 void
 517 ld_abort (const char *file, int line, const char *fn)
 518 {
 519   if (fn != NULL)
 520     einfo (_("%P: internal error: aborting at %s line %d in %s\n"),
 521            file, line, fn);
 522   else
 523     einfo (_("%P: internal error: aborting at %s line %d\n"),
 524            file, line);
 525   einfo (_("%P%F: please report this bug\n"));
 526   xexit (1);
 527 }