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 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 "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:   if (config.map_file != NULL)
  481:     {
  482:       va_list arg;
  483: 
  484:       va_start (arg, fmt);
  485:       vfinfo (config.map_file, fmt, arg, FALSE);
  486:       va_end (arg);
  487:     }
  488: }
  489: 
  490: void
  491: lfinfo (FILE *file, const char *fmt, ...)
  492: {
  493:   va_list arg;
  494: 
  495:   va_start (arg, fmt);
  496:   vfinfo (file, fmt, arg, FALSE);
  497:   va_end (arg);
  498: }
  499: ^L
  500: /* Functions to print the link map.  */
  501: 
  502: void
  503: print_space (void)
  504: {
  505:   fprintf (config.map_file, " ");
  506: }
  507: 
  508: void
  509: print_nl (void)
  510: {
  511:   fprintf (config.map_file, "\n");
  512: }
  513: 
  514: /* A more or less friendly abort message.  In ld.h abort is defined to
  515:    call this function.  */
  516: 
  517: void
  518: ld_abort (const char *file, int line, const char *fn)
  519: {
  520:   if (fn != NULL)
  521:     einfo (_("%P: internal error: aborting at %s line %d in %s\n"),
  522:            file, line, fn);
  523:   else
  524:     einfo (_("%P: internal error: aborting at %s line %d\n"),
  525:            file, line);
  526:   einfo (_("%P%F: please report this bug\n"));
  527:   xexit (1);
  528: }