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