ld/ldmisc.c

   1 /* ldmisc.c
   2    Copyright (C) 1991-2018 Free Software Foundation, Inc.
   3    Written by Steve Chamberlain of Cygnus Support.
   4
   5    This file is part of the GNU Binutils.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  20    MA 02110-1301, USA.  */
  21
  22 #include "sysdep.h"
  23 #include "bfd.h"
  24 #include "bfdlink.h"
  25 #include "libiberty.h"
  26 #include "safe-ctype.h"
  27 #include "filenames.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 #include "coff-bfd.h"
  40
  41 /*
  42  %% literal %
  43  %C clever filename:linenumber with function
  44  %D like %C, but no function name
  45  %E current bfd error or errno
  46  %F error is fatal
  47  %G like %D, but only function name
  48  %H like %C but in addition emit section+offset
  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 from etree_type.
  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  %p native (host) void* pointer, like printf
  61  %pA section name from a section
  62  %pB filename from a bfd
  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 ap, bfd_boolean is_warning)
  70 {
  71   bfd_boolean fatal = FALSE;
  72   const char *scan;
  73   int arg_type;
  74   unsigned int arg_count = 0;
  75   unsigned int arg_no;
  76   union vfinfo_args
  77   {
  78     int i;
  79     long l;
  80     void *p;
  81     bfd_vma v;
  82     struct {
  83       bfd *abfd;
  84       asection *sec;
  85       bfd_vma off;
  86     } reladdr;
  87     enum
  88       {
  89         Bad,
  90         Int,
  91         Long,
  92         Ptr,
  93         Vma,
  94         RelAddr
  95       } type;
  96   } args[9];
  97
  98   for (arg_no = 0; arg_no < sizeof (args) / sizeof (args[0]); arg_no++)
  99     args[arg_no].type = Bad;
 100
 101   arg_count = 0;
 102   scan = fmt;
 103   while (*scan != '\0')
 104     {
 105       while (*scan != '%' && *scan != '\0')
 106         scan++;
 107
 108       if (*scan == '%')
 109         {
 110           scan++;
 111
 112           arg_no = arg_count;
 113           if (*scan != '0' && ISDIGIT (*scan) && scan[1] == '$')
 114             {
 115               arg_no = *scan - '1';
 116               scan += 2;
 117             }
 118
 119           arg_type = Bad;
 120           switch (*scan++)
 121             {
 122             case '\0':
 123               --scan;
 124               break;
 125
 126             case 'V':
 127             case 'v':
 128             case 'W':
 129               arg_type = Vma;
 130               break;
 131
 132             case 'T':
 133             case 'I':
 134             case 'S':
 135             case 'R':
 136             case 's':
 137               arg_type = Ptr;
 138               break;
 139
 140             case 'p':
 141               if (*scan == 'A' || *scan == 'B')
 142                 scan++;
 143               arg_type = Ptr;
 144               break;
 145
 146             case 'C':
 147             case 'D':
 148             case 'G':
 149             case 'H':
 150               arg_type = RelAddr;
 151               break;
 152
 153             case 'd':
 154             case 'u':
 155               arg_type = Int;
 156               break;
 157
 158             case 'l':
 159               if (*scan == 'd' || *scan == 'u')
 160                 {
 161                   ++scan;
 162                   arg_type = Long;
 163                 }
 164               break;
 165
 166             default:
 167               break;
 168             }
 169           if (arg_type != Bad)
 170             {
 171               if (arg_no >= sizeof (args) / sizeof (args[0]))
 172                 abort ();
 173               args[arg_no].type = arg_type;
 174               ++arg_count;
 175             }
 176         }
 177     }
 178
 179   for (arg_no = 0; arg_no < arg_count; arg_no++)
 180     {
 181       switch (args[arg_no].type)
 182         {
 183         case Int:
 184           args[arg_no].i = va_arg (ap, int);
 185           break;
 186         case Long:
 187           args[arg_no].l = va_arg (ap, long);
 188           break;
 189         case Ptr:
 190           args[arg_no].p = va_arg (ap, void *);
 191           break;
 192         case Vma:
 193           args[arg_no].v = va_arg (ap, bfd_vma);
 194           break;
 195         case RelAddr:
 196           args[arg_no].reladdr.abfd = va_arg (ap, bfd *);
 197           args[arg_no].reladdr.sec = va_arg (ap, asection *);
 198           args[arg_no].reladdr.off = va_arg (ap, bfd_vma);
 199           break;
 200         default:
 201           abort ();
 202         }
 203     }
 204
 205   arg_count = 0;
 206   while (*fmt != '\0')
 207     {
 208       const char *str = fmt;
 209       while (*fmt != '%' && *fmt != '\0')
 210         fmt++;
 211       if (fmt != str)
 212         if (fwrite (str, 1, fmt - str, fp))
 213           {
 214             /* Ignore.  */
 215           }
 216
 217       if (*fmt == '%')
 218         {
 219           fmt++;
 220
 221           arg_no = arg_count;
 222           if (*fmt != '0' && ISDIGIT (*fmt) && fmt[1] == '$')
 223             {
 224               arg_no = *fmt - '1';
 225               fmt += 2;
 226             }
 227
 228           switch (*fmt++)
 229             {
 230             case '\0':
 231               --fmt;
 232               /* Fall through.  */
 233
 234             case '%':
 235               /* literal % */
 236               putc ('%', fp);
 237               break;
 238
 239             case 'X':
 240               /* no object output, fail return */
 241               config.make_executable = FALSE;
 242               break;
 243
 244             case 'V':
 245               /* hex bfd_vma */
 246               {
 247                 bfd_vma value = args[arg_no].v;
 248                 ++arg_count;
 249                 fprintf_vma (fp, value);
 250               }
 251               break;
 252
 253             case 'v':
 254               /* hex bfd_vma, no leading zeros */
 255               {
 256                 char buf[100];
 257                 char *p = buf;
 258                 bfd_vma value = args[arg_no].v;
 259                 ++arg_count;
 260                 sprintf_vma (p, value);
 261                 while (*p == '0')
 262                   p++;
 263                 if (!*p)
 264                   p--;
 265                 fputs (p, fp);
 266               }
 267               break;
 268
 269             case 'W':
 270               /* hex bfd_vma with 0x with no leading zeroes taking up
 271                  8 spaces.  */
 272               {
 273                 char buf[100];
 274                 bfd_vma value;
 275                 char *p;
 276                 int len;
 277
 278                 value = args[arg_no].v;
 279                 ++arg_count;
 280                 sprintf_vma (buf, value);
 281                 for (p = buf; *p == '0'; ++p)
 282                   ;
 283                 if (*p == '\0')
 284                   --p;
 285                 len = strlen (p);
 286                 while (len < 8)
 287                   {
 288                     putc (' ', fp);
 289                     ++len;
 290                   }
 291                 fprintf (fp, "0x%s", p);
 292               }
 293               break;
 294
 295             case 'T':
 296               /* Symbol name.  */
 297               {
 298                 const char *name = (const char *) args[arg_no].p;
 299                 ++arg_count;
 300                 if (name == NULL || *name == 0)
 301                   {
 302                     fprintf (fp, _("no symbol"));
 303                     break;
 304                   }
 305                 else if (demangling)
 306                   {
 307                     char *demangled;
 308
 309                     demangled = bfd_demangle (link_info.output_bfd, name,
 310                                               DMGL_ANSI | DMGL_PARAMS);
 311                     if (demangled != NULL)
 312                       {
 313                         fprintf (fp, "%s", demangled);
 314                         free (demangled);
 315                         break;
 316                       }
 317                   }
 318                 fprintf (fp, "%s", name);
 319               }
 320               break;
 321
 322             case 'F':
 323               /* Error is fatal.  */
 324               fatal = TRUE;
 325               break;
 326
 327             case 'P':
 328               /* Print program name.  */
 329               fprintf (fp, "%s", program_name);
 330               break;
 331
 332             case 'E':
 333               /* current bfd error or errno */
 334               fprintf (fp, "%s", bfd_errmsg (bfd_get_error ()));
 335               break;
 336
 337             case 'I':
 338               /* filename from a lang_input_statement_type */
 339               {
 340                 lang_input_statement_type *i;
 341
 342                 i = (lang_input_statement_type *) args[arg_no].p;
 343                 ++arg_count;
 344                 if (i->the_bfd->my_archive != NULL
 345                     && !bfd_is_thin_archive (i->the_bfd->my_archive))
 346                   fprintf (fp, "(%s)",
 347                            bfd_get_filename (i->the_bfd->my_archive));
 348                 fprintf (fp, "%s", i->local_sym_name);
 349                 if ((i->the_bfd->my_archive == NULL
 350                      || bfd_is_thin_archive (i->the_bfd->my_archive))
 351                     && filename_cmp (i->local_sym_name, i->filename) != 0)
 352                   fprintf (fp, " (%s)", i->filename);
 353               }
 354               break;
 355
 356             case 'S':
 357               /* Print script file and linenumber.  */
 358               {
 359                 etree_type node;
 360                 etree_type *tp = (etree_type *) args[arg_no].p;
 361                 ++arg_count;
 362                 if (tp == NULL)
 363                   {
 364                     tp = &node;
 365                     tp->type.filename = ldlex_filename ();
 366                     tp->type.lineno = lineno;
 367                   }
 368                 if (tp->type.filename != NULL)
 369                   fprintf (fp, "%s:%u", tp->type.filename, tp->type.lineno);
 370               }
 371               break;
 372
 373             case 'R':
 374               /* Print all that's interesting about a relent.  */
 375               {
 376                 arelent *relent = (arelent *) args[arg_no].p;
 377                 ++arg_count;
 378                 lfinfo (fp, "%s+0x%v (type %s)",
 379                         (*(relent->sym_ptr_ptr))->name,
 380                         relent->addend,
 381                         relent->howto->name);
 382               }
 383               break;
 384
 385             case 'C':
 386             case 'D':
 387             case 'G':
 388             case 'H':
 389               /* Clever filename:linenumber with function name if possible.
 390                  The arguments are a BFD, a section, and an offset.  */
 391               {
 392                 static bfd *last_bfd;
 393                 static char *last_file;
 394                 static char *last_function;
 395                 bfd *abfd;
 396                 asection *section;
 397                 bfd_vma offset;
 398                 asymbol **asymbols = NULL;
 399                 const char *filename;
 400                 const char *functionname;
 401                 unsigned int linenumber;
 402                 bfd_boolean discard_last;
 403                 bfd_boolean done;
 404
 405                 abfd = args[arg_no].reladdr.abfd;
 406                 section = args[arg_no].reladdr.sec;
 407                 offset = args[arg_no].reladdr.off;
 408                 ++arg_count;
 409
 410                 if (abfd != NULL)
 411                   {
 412                     if (!bfd_generic_link_read_symbols (abfd))
 413                       einfo (_("%pB%F: could not read symbols: %E\n"), abfd);
 414
 415                     asymbols = bfd_get_outsymbols (abfd);
 416                   }
 417
 418                 /* The GNU Coding Standard requires that error messages
 419                    be of the form:
 420
 421                      source-file-name:lineno: message
 422
 423                    We do not always have a line number available so if
 424                    we cannot find them we print out the section name and
 425                    offset instead.  */
 426                 discard_last = TRUE;
 427                 if (abfd != NULL
 428                     && bfd_find_nearest_line (abfd, section, asymbols, offset,
 429                                               &filename, &functionname,
 430                                               &linenumber))
 431                   {
 432                     if (functionname != NULL
 433                         && (fmt[-1] == 'C' || fmt[-1] == 'H'))
 434                       {
 435                         /* Detect the case where we are printing out a
 436                            message for the same function as the last
 437                            call to vinfo ("%C").  In this situation do
 438                            not print out the ABFD filename or the
 439                            function name again.  Note - we do still
 440                            print out the source filename, as this will
 441                            allow programs that parse the linker's output
 442                            (eg emacs) to correctly locate multiple
 443                            errors in the same source file.  */
 444                         if (last_bfd == NULL
 445                             || last_function == NULL
 446                             || last_bfd != abfd
 447                             || (last_file == NULL) != (filename == NULL)
 448                             || (filename != NULL
 449                                 && filename_cmp (last_file, filename) != 0)
 450                             || strcmp (last_function, functionname) != 0)
 451                           {
 452                             lfinfo (fp, _("%pB: In function `%T':\n"),
 453                                     abfd, functionname);
 454
 455                             last_bfd = abfd;
 456                             if (last_file != NULL)
 457                               free (last_file);
 458                             last_file = NULL;
 459                             if (filename)
 460                               last_file = xstrdup (filename);
 461                             if (last_function != NULL)
 462                               free (last_function);
 463                             last_function = xstrdup (functionname);
 464                           }
 465                         discard_last = FALSE;
 466                       }
 467                     else
 468                       lfinfo (fp, "%pB:", abfd);
 469
 470                     if (filename != NULL)
 471                       fprintf (fp, "%s:", filename);
 472
 473                     done = fmt[-1] != 'H';
 474                     if (functionname != NULL && fmt[-1] == 'G')
 475                       lfinfo (fp, "%T", functionname);
 476                     else if (filename != NULL && linenumber != 0)
 477                       fprintf (fp, "%u%s", linenumber, done ? "" : ":");
 478                     else
 479                       done = FALSE;
 480                   }
 481                 else
 482                   {
 483                     lfinfo (fp, "%pB:", abfd);
 484                     done = FALSE;
 485                   }
 486                 if (!done)
 487                   lfinfo (fp, "(%pA+0x%v)", section, offset);
 488
 489                 if (discard_last)
 490                   {
 491                     last_bfd = NULL;
 492                     if (last_file != NULL)
 493                       {
 494                         free (last_file);
 495                         last_file = NULL;
 496                       }
 497                     if (last_function != NULL)
 498                       {
 499                         free (last_function);
 500                         last_function = NULL;
 501                       }
 502                   }
 503               }
 504               break;
 505
 506             case 'p':
 507               if (*fmt == 'A')
 508                 {
 509                   /* section name from a section */
 510                   asection *sec;
 511                   bfd *abfd;
 512                   const char *group = NULL;
 513                   struct coff_comdat_info *ci;
 514
 515                   fmt++;
 516                   sec = (asection *) args[arg_no].p;
 517                   ++arg_count;
 518                   abfd = sec->owner;
 519                   fprintf (fp, "%s", sec->name);
 520                   if (abfd != NULL
 521                       && bfd_get_flavour (abfd) == bfd_target_elf_flavour
 522                       && elf_next_in_group (sec) != NULL
 523                       && (sec->flags & SEC_GROUP) == 0)
 524                     group = elf_group_name (sec);
 525                   else if (abfd != NULL
 526                            && bfd_get_flavour (abfd) == bfd_target_coff_flavour
 527                            && (ci = bfd_coff_get_comdat_section (sec->owner,
 528                                                                  sec)) != NULL)
 529                     group = ci->name;
 530                   if (group != NULL)
 531                     fprintf (fp, "[%s]", group);
 532                 }
 533               else if (*fmt == 'B')
 534                 {
 535                   /* filename from a bfd */
 536                   bfd *abfd = (bfd *) args[arg_no].p;
 537
 538                   fmt++;
 539                   ++arg_count;
 540                   if (abfd == NULL)
 541                     fprintf (fp, "%s generated", program_name);
 542                   else if (abfd->my_archive != NULL
 543                            && !bfd_is_thin_archive (abfd->my_archive))
 544                     fprintf (fp, "%s(%s)", abfd->my_archive->filename,
 545                              abfd->filename);
 546                   else
 547                     fprintf (fp, "%s", abfd->filename);
 548                 }
 549               else
 550                 {
 551                   /* native (host) void* pointer, like printf */
 552                   fprintf (fp, "%p", args[arg_no].p);
 553                   ++arg_count;
 554                 }
 555               break;
 556
 557             case 's':
 558               /* arbitrary string, like printf */
 559               fprintf (fp, "%s", (char *) args[arg_no].p);
 560               ++arg_count;
 561               break;
 562
 563             case 'd':
 564               /* integer, like printf */
 565               fprintf (fp, "%d", args[arg_no].i);
 566               ++arg_count;
 567               break;
 568
 569             case 'u':
 570               /* unsigned integer, like printf */
 571               fprintf (fp, "%u", args[arg_no].i);
 572               ++arg_count;
 573               break;
 574
 575             case 'l':
 576               if (*fmt == 'd')
 577                 {
 578                   fprintf (fp, "%ld", args[arg_no].l);
 579                   ++arg_count;
 580                   ++fmt;
 581                   break;
 582                 }
 583               else if (*fmt == 'u')
 584                 {
 585                   fprintf (fp, "%lu", args[arg_no].l);
 586                   ++arg_count;
 587                   ++fmt;
 588                   break;
 589                 }
 590               /* Fallthru */
 591
 592             default:
 593               fprintf (fp, "%%%c", fmt[-1]);
 594               break;
 595             }
 596         }
 597     }
 598
 599   if (is_warning && config.fatal_warnings)
 600     config.make_executable = FALSE;
 601
 602   if (fatal)
 603     xexit (1);
 604 }
 605
 606 /* Format info message and print on stdout.  */
 607
 608 /* (You would think this should be called just "info", but then you
 609    would be hosed by LynxOS, which defines that name in its libc.)  */
 610
 611 void
 612 info_msg (const char *fmt, ...)
 613 {
 614   va_list arg;
 615
 616   va_start (arg, fmt);
 617   vfinfo (stdout, fmt, arg, FALSE);
 618   va_end (arg);
 619 }
 620
 621 /* ('e' for error.) Format info message and print on stderr.  */
 622
 623 void
 624 einfo (const char *fmt, ...)
 625 {
 626   va_list arg;
 627
 628   fflush (stdout);
 629   va_start (arg, fmt);
 630   vfinfo (stderr, fmt, arg, TRUE);
 631   va_end (arg);
 632   fflush (stderr);
 633 }
 634
 635 void
 636 info_assert (const char *file, unsigned int line)
 637 {
 638   einfo (_("%F%P: internal error %s %d\n"), file, line);
 639 }
 640
 641 /* ('m' for map) Format info message and print on map.  */
 642
 643 void
 644 minfo (const char *fmt, ...)
 645 {
 646   if (config.map_file != NULL)
 647     {
 648       va_list arg;
 649
 650       va_start (arg, fmt);
 651       if (fmt[0] == '%' && fmt[1] == '!' && fmt[2] == 0)
 652         {
 653           /* Stash info about --as-needed shared libraries.  Print
 654              later so they don't appear intermingled with archive
 655              library info.  */
 656           struct asneeded_minfo *m = xmalloc (sizeof *m);
 657
 658           m->next = NULL;
 659           m->soname = va_arg (arg, const char *);
 660           m->ref = va_arg (arg, bfd *);
 661           m->name = va_arg (arg, const char *);
 662           *asneeded_list_tail = m;
 663           asneeded_list_tail = &m->next;
 664         }
 665       else
 666         vfinfo (config.map_file, fmt, arg, FALSE);
 667       va_end (arg);
 668     }
 669 }
 670
 671 void
 672 lfinfo (FILE *file, const char *fmt, ...)
 673 {
 674   va_list arg;
 675
 676   va_start (arg, fmt);
 677   vfinfo (file, fmt, arg, FALSE);
 678   va_end (arg);
 679 }
 680 \f
 681 /* Functions to print the link map.  */
 682
 683 void
 684 print_space (void)
 685 {
 686   fprintf (config.map_file, " ");
 687 }
 688
 689 void
 690 print_nl (void)
 691 {
 692   fprintf (config.map_file, "\n");
 693 }
 694
 695 /* A more or less friendly abort message.  In ld.h abort is defined to
 696    call this function.  */
 697
 698 void
 699 ld_abort (const char *file, int line, const char *fn)
 700 {
 701   if (fn != NULL)
 702     einfo (_("%P: internal error: aborting at %s:%d in %s\n"),
 703            file, line, fn);
 704   else
 705     einfo (_("%P: internal error: aborting at %s:%d\n"),
 706            file, line);
 707   einfo (_("%P%F: please report this bug\n"));
 708   xexit (1);
 709 }