Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed

  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, 2013
  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.       const char *str = fmt;
  76.       while (*fmt != '%' && *fmt != '\0')
  77.         fmt++;
  78.       if (fmt != str)
  79.         if (fwrite (str, 1, fmt - str, fp))
  80.           {
  81.             /* Ignore.  */
  82.           }
  83.  
  84.       if (*fmt == '%')
  85.         {
  86.           fmt++;
  87.           switch (*fmt++)
  88.             {
  89.             case '%':
  90.               /* literal % */
  91.               putc ('%', fp);
  92.               break;
  93.  
  94.             case 'X':
  95.               /* no object output, fail return */
  96.               config.make_executable = FALSE;
  97.               break;
  98.  
  99.             case 'V':
  100.               /* hex bfd_vma */
  101.               {
  102.                 bfd_vma value = va_arg (arg, bfd_vma);
  103.                 fprintf_vma (fp, value);
  104.               }
  105.               break;
  106.  
  107.             case 'v':
  108.               /* hex bfd_vma, no leading zeros */
  109.               {
  110.                 char buf[100];
  111.                 char *p = buf;
  112.                 bfd_vma value = va_arg (arg, bfd_vma);
  113.                 sprintf_vma (p, value);
  114.                 while (*p == '0')
  115.                   p++;
  116.                 if (!*p)
  117.                   p--;
  118.                 fputs (p, fp);
  119.               }
  120.               break;
  121.  
  122.             case 'W':
  123.               /* hex bfd_vma with 0x with no leading zeroes taking up
  124.                  8 spaces.  */
  125.               {
  126.                 char buf[100];
  127.                 bfd_vma value;
  128.                 char *p;
  129.                 int len;
  130.  
  131.                 value = va_arg (arg, bfd_vma);
  132.                 sprintf_vma (buf, value);
  133.                 for (p = buf; *p == '0'; ++p)
  134.                   ;
  135.                 if (*p == '\0')
  136.                   --p;
  137.                 len = strlen (p);
  138.                 while (len < 8)
  139.                   {
  140.                     putc (' ', fp);
  141.                     ++len;
  142.                   }
  143.                 fprintf (fp, "0x%s", p);
  144.               }
  145.               break;
  146.  
  147.             case 'T':
  148.               /* Symbol name.  */
  149.               {
  150.                 const char *name = va_arg (arg, const char *);
  151.  
  152.                 if (name == NULL || *name == 0)
  153.                   {
  154.                     fprintf (fp, _("no symbol"));
  155.                     break;
  156.                   }
  157.                 else if (demangling)
  158.                   {
  159.                     char *demangled;
  160.  
  161.                     demangled = bfd_demangle (link_info.output_bfd, name,
  162.                                               DMGL_ANSI | DMGL_PARAMS);
  163.                     if (demangled != NULL)
  164.                       {
  165.                         fprintf (fp, "%s", demangled);
  166.                         free (demangled);
  167.                         break;
  168.                       }
  169.                   }
  170.                 fprintf (fp, "%s", name);
  171.               }
  172.               break;
  173.  
  174.             case 'A':
  175.               /* section name from a section */
  176.               {
  177.                 asection *sec = va_arg (arg, asection *);
  178.                 bfd *abfd = sec->owner;
  179.                 const char *group = NULL;
  180.                 struct coff_comdat_info *ci;
  181.  
  182.                 fprintf (fp, "%s", sec->name);
  183.                 if (abfd != NULL
  184.                     && bfd_get_flavour (abfd) == bfd_target_elf_flavour
  185.                     && elf_next_in_group (sec) != NULL
  186.                     && (sec->flags & SEC_GROUP) == 0)
  187.                   group = elf_group_name (sec);
  188.                 else if (abfd != NULL
  189.                          && bfd_get_flavour (abfd) == bfd_target_coff_flavour
  190.                          && (ci = bfd_coff_get_comdat_section (sec->owner,
  191.                                                                sec)) != NULL)
  192.                   group = ci->name;
  193.                 if (group != NULL)
  194.                   fprintf (fp, "[%s]", group);
  195.               }
  196.               break;
  197.  
  198.             case 'B':
  199.               /* filename from a bfd */
  200.               {
  201.                 bfd *abfd = va_arg (arg, bfd *);
  202.  
  203.                 if (abfd == NULL)
  204.                   fprintf (fp, "%s generated", program_name);
  205.                 else if (abfd->my_archive)
  206.                   fprintf (fp, "%s(%s)", abfd->my_archive->filename,
  207.                            abfd->filename);
  208.                 else
  209.                   fprintf (fp, "%s", abfd->filename);
  210.               }
  211.               break;
  212.  
  213.             case 'F':
  214.               /* Error is fatal.  */
  215.               fatal = TRUE;
  216.               break;
  217.  
  218.             case 'P':
  219.               /* Print program name.  */
  220.               fprintf (fp, "%s", program_name);
  221.               break;
  222.  
  223.             case 'E':
  224.               /* current bfd error or errno */
  225.               fprintf (fp, "%s", bfd_errmsg (bfd_get_error ()));
  226.               break;
  227.  
  228.             case 'I':
  229.               /* filename from a lang_input_statement_type */
  230.               {
  231.                 lang_input_statement_type *i;
  232.  
  233.                 i = va_arg (arg, lang_input_statement_type *);
  234.                 if (bfd_my_archive (i->the_bfd) != NULL)
  235.                   fprintf (fp, "(%s)",
  236.                            bfd_get_filename (bfd_my_archive (i->the_bfd)));
  237.                 fprintf (fp, "%s", i->local_sym_name);
  238.                 if (bfd_my_archive (i->the_bfd) == NULL
  239.                     && filename_cmp (i->local_sym_name, i->filename) != 0)
  240.                   fprintf (fp, " (%s)", i->filename);
  241.               }
  242.               break;
  243.  
  244.             case 'S':
  245.               /* Print script file and linenumber.  */
  246.               {
  247.                 etree_type node;
  248.                 etree_type *tp = va_arg (arg, etree_type *);
  249.  
  250.                 if (tp == NULL)
  251.                   {
  252.                     tp = &node;
  253.                     tp->type.filename = ldlex_filename ();
  254.                     tp->type.lineno = lineno;
  255.                   }
  256.                 if (tp->type.filename != NULL)
  257.                   fprintf (fp, "%s:%u", tp->type.filename, tp->type.lineno);
  258.               }
  259.               break;
  260.  
  261.             case 'R':
  262.               /* Print all that's interesting about a relent.  */
  263.               {
  264.                 arelent *relent = va_arg (arg, arelent *);
  265.  
  266.                 lfinfo (fp, "%s+0x%v (type %s)",
  267.                         (*(relent->sym_ptr_ptr))->name,
  268.                         relent->addend,
  269.                         relent->howto->name);
  270.               }
  271.               break;
  272.  
  273.             case 'C':
  274.             case 'D':
  275.             case 'G':
  276.             case 'H':
  277.               /* Clever filename:linenumber with function name if possible.
  278.                  The arguments are a BFD, a section, and an offset.  */
  279.               {
  280.                 static bfd *last_bfd;
  281.                 static char *last_file = NULL;
  282.                 static char *last_function = NULL;
  283.                 bfd *abfd;
  284.                 asection *section;
  285.                 bfd_vma offset;
  286.                 asymbol **asymbols = NULL;
  287.                 const char *filename;
  288.                 const char *functionname;
  289.                 unsigned int linenumber;
  290.                 bfd_boolean discard_last;
  291.                 bfd_boolean done;
  292.  
  293.                 abfd = va_arg (arg, bfd *);
  294.                 section = va_arg (arg, asection *);
  295.                 offset = va_arg (arg, bfd_vma);
  296.  
  297.                 if (abfd != NULL)
  298.                   {
  299.                     if (!bfd_generic_link_read_symbols (abfd))
  300.                       einfo (_("%B%F: could not read symbols: %E\n"), abfd);
  301.  
  302.                     asymbols = bfd_get_outsymbols (abfd);
  303.                   }
  304.  
  305.                 /* The GNU Coding Standard requires that error messages
  306.                    be of the form:
  307.  
  308.                      source-file-name:lineno: message
  309.  
  310.                    We do not always have a line number available so if
  311.                    we cannot find them we print out the section name and
  312.                    offset instead.  */
  313.                 discard_last = TRUE;
  314.                 if (abfd != NULL
  315.                     && bfd_find_nearest_line (abfd, section, asymbols, offset,
  316.                                               &filename, &functionname,
  317.                                               &linenumber))
  318.                   {
  319.                     if (functionname != NULL
  320.                         && (fmt[-1] == 'C' || fmt[-1] == 'H'))
  321.                       {
  322.                         /* Detect the case where we are printing out a
  323.                            message for the same function as the last
  324.                            call to vinfo ("%C").  In this situation do
  325.                            not print out the ABFD filename or the
  326.                            function name again.  Note - we do still
  327.                            print out the source filename, as this will
  328.                            allow programs that parse the linker's output
  329.                            (eg emacs) to correctly locate multiple
  330.                            errors in the same source file.  */
  331.                         if (last_bfd == NULL
  332.                             || last_file == NULL
  333.                             || last_function == NULL
  334.                             || last_bfd != abfd
  335.                             || (filename != NULL
  336.                                 && filename_cmp (last_file, filename) != 0)
  337.                             || strcmp (last_function, functionname) != 0)
  338.                           {
  339.                             lfinfo (fp, _("%B: In function `%T':\n"),
  340.                                     abfd, functionname);
  341.  
  342.                             last_bfd = abfd;
  343.                             if (last_file != NULL)
  344.                               free (last_file);
  345.                             last_file = NULL;
  346.                             if (filename)
  347.                               last_file = xstrdup (filename);
  348.                             if (last_function != NULL)
  349.                               free (last_function);
  350.                             last_function = xstrdup (functionname);
  351.                           }
  352.                         discard_last = FALSE;
  353.                       }
  354.                     else
  355.                       lfinfo (fp, "%B:", abfd);
  356.  
  357.                     if (filename != NULL)
  358.                       fprintf (fp, "%s:", filename);
  359.  
  360.                     done = fmt[-1] != 'H';
  361.                     if (functionname != NULL && fmt[-1] == 'G')
  362.                       lfinfo (fp, "%T", functionname);
  363.                     else if (filename != NULL && linenumber != 0)
  364.                       fprintf (fp, "%u%s", linenumber, done ? "" : ":");
  365.                     else
  366.                       done = FALSE;
  367.                   }
  368.                 else
  369.                   {
  370.                     lfinfo (fp, "%B:", abfd);
  371.                     done = FALSE;
  372.                   }
  373.                 if (!done)
  374.                   lfinfo (fp, "(%A+0x%v)", section, offset);
  375.  
  376.                 if (discard_last)
  377.                   {
  378.                     last_bfd = NULL;
  379.                     if (last_file != NULL)
  380.                       {
  381.                         free (last_file);
  382.                         last_file = NULL;
  383.                       }
  384.                     if (last_function != NULL)
  385.                       {
  386.                         free (last_function);
  387.                         last_function = NULL;
  388.                       }
  389.                   }
  390.               }
  391.               break;
  392.  
  393.             case 'p':
  394.               /* native (host) void* pointer, like printf */
  395.               fprintf (fp, "%p", va_arg (arg, void *));
  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.   fflush (stdout);
  465.   va_start (arg, fmt);
  466.   vfinfo (stderr, fmt, arg, TRUE);
  467.   va_end (arg);
  468.   fflush (stderr);
  469. }
  470.  
  471. void
  472. info_assert (const char *file, unsigned int line)
  473. {
  474.   einfo (_("%F%P: internal error %s %d\n"), file, line);
  475. }
  476.  
  477. /* ('m' for map) Format info message and print on map.  */
  478.  
  479. void
  480. minfo (const char *fmt, ...)
  481. {
  482.   if (config.map_file != NULL)
  483.     {
  484.       va_list arg;
  485.  
  486.       va_start (arg, fmt);
  487.       vfinfo (config.map_file, fmt, arg, FALSE);
  488.       va_end (arg);
  489.     }
  490. }
  491.  
  492. void
  493. lfinfo (FILE *file, const char *fmt, ...)
  494. {
  495.   va_list arg;
  496.  
  497.   va_start (arg, fmt);
  498.   vfinfo (file, fmt, arg, FALSE);
  499.   va_end (arg);
  500. }
  502. /* Functions to print the link map.  */
  503.  
  504. void
  505. print_space (void)
  506. {
  507.   fprintf (config.map_file, " ");
  508. }
  509.  
  510. void
  511. print_nl (void)
  512. {
  513.   fprintf (config.map_file, "\n");
  514. }
  515.  
  516. /* A more or less friendly abort message.  In ld.h abort is defined to
  517.    call this function.  */
  518.  
  519. void
  520. ld_abort (const char *file, int line, const char *fn)
  521. {
  522.   if (fn != NULL)
  523.     einfo (_("%P: internal error: aborting at %s line %d in %s\n"),
  524.            file, line, fn);
  525.   else
  526.     einfo (_("%P: internal error: aborting at %s line %d\n"),
  527.            file, line);
  528.   einfo (_("%P%F: please report this bug\n"));
  529.   xexit (1);
  530. }
  531.