ld/ldmisc.c

   1 /* ldmisc.c
   2    Copyright (C) 1991-2020 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 "ctf-api.h"
  27 #include "safe-ctype.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
  40 /*
  41  %% literal %
  42  %C clever filename:linenumber with function
  43  %D like %C, but no function name
  44  %E current bfd error or errno
  45  %F error is fatal
  46  %G like %D, but only function name
  47  %H like %C but in addition emit section+offset
  48  %P print program name
  49  %V hex bfd_vma
  50  %W hex bfd_vma with 0x with no leading zeros taking up 8 spaces
  51  %X no object output, fail return
  52  %d integer, like printf
  53  %ld long, like printf
  54  %lu unsigned long, like printf
  55  %p native (host) void* pointer, like printf
  56  %pA section name from a section
  57  %pB filename from a bfd
  58  %pI filename from a lang_input_statement_type
  59  %pR info about a relent
  60  %pS print script file and linenumber from etree_type.
  61  %pT symbol name
  62  %s arbitrary string, like printf
  63  %u integer, like printf
  64  %v hex bfd_vma, no leading zeros
  65 */
  66
  67 void
  68 vfinfo (FILE *fp, const char *fmt, va_list ap, bfd_boolean is_warning)
  69 {
  70   bfd_boolean fatal = FALSE;
  71   const char *scan;
  72   int arg_type;
  73   unsigned int arg_count = 0;
  74   unsigned int arg_no;
  75   union vfinfo_args
  76   {
  77     int i;
  78     long l;
  79     void *p;
  80     bfd_vma v;
  81     struct {
  82       bfd *abfd;
  83       asection *sec;
  84       bfd_vma off;
  85     } reladdr;
  86     enum
  87       {
  88         Bad,
  89         Int,
  90         Long,
  91         Ptr,
  92         Vma,
  93         RelAddr
  94       } type;
  95   } args[9];
  96
  97   for (arg_no = 0; arg_no < sizeof (args) / sizeof (args[0]); arg_no++)
  98     args[arg_no].type = Bad;
  99
 100   arg_count = 0;
 101   scan = fmt;
 102   while (*scan != '\0')
 103     {
 104       while (*scan != '%' && *scan != '\0')
 105         scan++;
 106
 107       if (*scan == '%')
 108         {
 109           scan++;
 110
 111           arg_no = arg_count;
 112           if (*scan != '0' && ISDIGIT (*scan) && scan[1] == '$')
 113             {
 114               arg_no = *scan - '1';
 115               scan += 2;
 116             }
 117
 118           arg_type = Bad;
 119           switch (*scan++)
 120             {
 121             case '\0':
 122               --scan;
 123               break;
 124
 125             case 'V':
 126             case 'v':
 127             case 'W':
 128               arg_type = Vma;
 129               break;
 130
 131             case 's':
 132               arg_type = Ptr;
 133               break;
 134
 135             case 'p':
 136               if (*scan == 'A' || *scan == 'B' || *scan == 'I'
 137                   || *scan == 'R' || *scan == 'S' || *scan ==  'T')
 138                 scan++;
 139               arg_type = Ptr;
 140               break;
 141
 142             case 'C':
 143             case 'D':
 144             case 'G':
 145             case 'H':
 146               arg_type = RelAddr;
 147               break;
 148
 149             case 'd':
 150             case 'u':
 151               arg_type = Int;
 152               break;
 153
 154             case 'l':
 155               if (*scan == 'd' || *scan == 'u')
 156                 {
 157                   ++scan;
 158                   arg_type = Long;
 159                 }
 160               break;
 161
 162             default:
 163               break;
 164             }
 165           if (arg_type != Bad)
 166             {
 167               if (arg_no >= sizeof (args) / sizeof (args[0]))
 168                 abort ();
 169               args[arg_no].type = arg_type;
 170               ++arg_count;
 171             }
 172         }
 173     }
 174
 175   for (arg_no = 0; arg_no < arg_count; arg_no++)
 176     {
 177       switch (args[arg_no].type)
 178         {
 179         case Int:
 180           args[arg_no].i = va_arg (ap, int);
 181           break;
 182         case Long:
 183           args[arg_no].l = va_arg (ap, long);
 184           break;
 185         case Ptr:
 186           args[arg_no].p = va_arg (ap, void *);
 187           break;
 188         case Vma:
 189           args[arg_no].v = va_arg (ap, bfd_vma);
 190           break;
 191         case RelAddr:
 192           args[arg_no].reladdr.abfd = va_arg (ap, bfd *);
 193           args[arg_no].reladdr.sec = va_arg (ap, asection *);
 194           args[arg_no].reladdr.off = va_arg (ap, bfd_vma);
 195           break;
 196         default:
 197           abort ();
 198         }
 199     }
 200
 201   arg_count = 0;
 202   while (*fmt != '\0')
 203     {
 204       const char *str = fmt;
 205       while (*fmt != '%' && *fmt != '\0')
 206         fmt++;
 207       if (fmt != str)
 208         if (fwrite (str, 1, fmt - str, fp))
 209           {
 210             /* Ignore.  */
 211           }
 212
 213       if (*fmt == '%')
 214         {
 215           fmt++;
 216
 217           arg_no = arg_count;
 218           if (*fmt != '0' && ISDIGIT (*fmt) && fmt[1] == '$')
 219             {
 220               arg_no = *fmt - '1';
 221               fmt += 2;
 222             }
 223
 224           switch (*fmt++)
 225             {
 226             case '\0':
 227               --fmt;
 228               /* Fall through.  */
 229
 230             case '%':
 231               /* literal % */
 232               putc ('%', fp);
 233               break;
 234
 235             case 'X':
 236               /* no object output, fail return */
 237               config.make_executable = FALSE;
 238               break;
 239
 240             case 'V':
 241               /* hex bfd_vma */
 242               {
 243                 bfd_vma value = args[arg_no].v;
 244                 ++arg_count;
 245                 fprintf_vma (fp, value);
 246               }
 247               break;
 248
 249             case 'v':
 250               /* hex bfd_vma, no leading zeros */
 251               {
 252                 char buf[100];
 253                 char *p = buf;
 254                 bfd_vma value = args[arg_no].v;
 255                 ++arg_count;
 256                 sprintf_vma (p, value);
 257                 while (*p == '0')
 258                   p++;
 259                 if (!*p)
 260                   p--;
 261                 fputs (p, fp);
 262               }
 263               break;
 264
 265             case 'W':
 266               /* hex bfd_vma with 0x with no leading zeroes taking up
 267                  8 spaces.  */
 268               {
 269                 char buf[100];
 270                 bfd_vma value;
 271                 char *p;
 272                 int len;
 273
 274                 value = args[arg_no].v;
 275                 ++arg_count;
 276                 sprintf_vma (buf, value);
 277                 for (p = buf; *p == '0'; ++p)
 278                   ;
 279                 if (*p == '\0')
 280                   --p;
 281                 len = strlen (p);
 282                 while (len < 8)
 283                   {
 284                     putc (' ', fp);
 285                     ++len;
 286                   }
 287                 fprintf (fp, "0x%s", p);
 288               }
 289               break;
 290
 291             case 'F':
 292               /* Error is fatal.  */
 293               fatal = TRUE;
 294               break;
 295
 296             case 'P':
 297               /* Print program name.  */
 298               fprintf (fp, "%s", program_name);
 299               break;
 300
 301             case 'E':
 302               /* current bfd error or errno */
 303               fprintf (fp, "%s", bfd_errmsg (bfd_get_error ()));
 304               break;
 305
 306             case 'C':
 307             case 'D':
 308             case 'G':
 309             case 'H':
 310               /* Clever filename:linenumber with function name if possible.
 311                  The arguments are a BFD, a section, and an offset.  */
 312               {
 313                 static bfd *last_bfd;
 314                 static char *last_file;
 315                 static char *last_function;
 316                 bfd *abfd;
 317                 asection *section;
 318                 bfd_vma offset;
 319                 asymbol **asymbols = NULL;
 320                 const char *filename;
 321                 const char *functionname;
 322                 unsigned int linenumber;
 323                 bfd_boolean discard_last;
 324                 bfd_boolean done;
 325                 bfd_error_type last_bfd_error = bfd_get_error ();
 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                 bfd_set_error (last_bfd_error);
 411
 412                 if (discard_last)
 413                   {
 414                     last_bfd = NULL;
 415                     if (last_file != NULL)
 416                       {
 417                         free (last_file);
 418                         last_file = NULL;
 419                       }
 420                     if (last_function != NULL)
 421                       {
 422                         free (last_function);
 423                         last_function = NULL;
 424                       }
 425                   }
 426               }
 427               break;
 428
 429             case 'p':
 430               if (*fmt == 'A')
 431                 {
 432                   /* section name from a section */
 433                   asection *sec;
 434                   bfd *abfd;
 435
 436                   fmt++;
 437                   sec = (asection *) args[arg_no].p;
 438                   ++arg_count;
 439                   fprintf (fp, "%s", sec->name);
 440                   abfd = sec->owner;
 441                   if (abfd != NULL)
 442                     {
 443                       const char *group = bfd_group_name (abfd, sec);
 444                       if (group != NULL)
 445                         fprintf (fp, "[%s]", group);
 446                     }
 447                 }
 448               else if (*fmt == 'B')
 449                 {
 450                   /* filename from a bfd */
 451                   bfd *abfd = (bfd *) args[arg_no].p;
 452
 453                   fmt++;
 454                   ++arg_count;
 455                   if (abfd == NULL)
 456                     fprintf (fp, "%s generated", program_name);
 457                   else if (abfd->my_archive != NULL
 458                            && !bfd_is_thin_archive (abfd->my_archive))
 459                     fprintf (fp, "%s(%s)",
 460                              bfd_get_filename (abfd->my_archive),
 461                              bfd_get_filename (abfd));
 462                   else
 463                     fprintf (fp, "%s", bfd_get_filename (abfd));
 464                 }
 465               else if (*fmt == 'I')
 466                 {
 467                   /* filename from a lang_input_statement_type */
 468                   lang_input_statement_type *i;
 469
 470                   fmt++;
 471                   i = (lang_input_statement_type *) args[arg_no].p;
 472                   ++arg_count;
 473                   if (i->the_bfd != NULL
 474                       && i->the_bfd->my_archive != NULL
 475                       && !bfd_is_thin_archive (i->the_bfd->my_archive))
 476                     fprintf (fp, "(%s)%s",
 477                              bfd_get_filename (i->the_bfd->my_archive),
 478                              i->local_sym_name);
 479                   else
 480                     fprintf (fp, "%s", i->filename);
 481                 }
 482               else if (*fmt == 'R')
 483                 {
 484                   /* Print all that's interesting about a relent.  */
 485                   arelent *relent = (arelent *) args[arg_no].p;
 486
 487                   fmt++;
 488                   ++arg_count;
 489                   lfinfo (fp, "%s+0x%v (type %s)",
 490                           (*(relent->sym_ptr_ptr))->name,
 491                           relent->addend,
 492                           relent->howto->name);
 493                 }
 494               else if (*fmt == 'S')
 495                 {
 496                   /* Print script file and linenumber.  */
 497                   etree_type node;
 498                   etree_type *tp = (etree_type *) args[arg_no].p;
 499
 500                   fmt++;
 501                   ++arg_count;
 502                   if (tp == NULL)
 503                     {
 504                       tp = &node;
 505                       tp->type.filename = ldlex_filename ();
 506                       tp->type.lineno = lineno;
 507                     }
 508                   if (tp->type.filename != NULL)
 509                     fprintf (fp, "%s:%u", tp->type.filename, tp->type.lineno);
 510                 }
 511               else if (*fmt == 'T')
 512                 {
 513                   /* Symbol name.  */
 514                   const char *name = (const char *) args[arg_no].p;
 515
 516                   fmt++;
 517                   ++arg_count;
 518                   if (name == NULL || *name == 0)
 519                     {
 520                       fprintf (fp, _("no symbol"));
 521                       break;
 522                     }
 523                   else if (demangling)
 524                     {
 525                       char *demangled;
 526
 527                       demangled = bfd_demangle (link_info.output_bfd, name,
 528                                                 DMGL_ANSI | DMGL_PARAMS);
 529                       if (demangled != NULL)
 530                         {
 531                           fprintf (fp, "%s", demangled);
 532                           free (demangled);
 533                           break;
 534                         }
 535                     }
 536                   fprintf (fp, "%s", name);
 537                 }
 538               else
 539                 {
 540                   /* native (host) void* pointer, like printf */
 541                   fprintf (fp, "%p", args[arg_no].p);
 542                   ++arg_count;
 543                 }
 544               break;
 545
 546             case 's':
 547               /* arbitrary string, like printf */
 548               fprintf (fp, "%s", (char *) args[arg_no].p);
 549               ++arg_count;
 550               break;
 551
 552             case 'd':
 553               /* integer, like printf */
 554               fprintf (fp, "%d", args[arg_no].i);
 555               ++arg_count;
 556               break;
 557
 558             case 'u':
 559               /* unsigned integer, like printf */
 560               fprintf (fp, "%u", args[arg_no].i);
 561               ++arg_count;
 562               break;
 563
 564             case 'l':
 565               if (*fmt == 'd')
 566                 {
 567                   fprintf (fp, "%ld", args[arg_no].l);
 568                   ++arg_count;
 569                   ++fmt;
 570                   break;
 571                 }
 572               else if (*fmt == 'u')
 573                 {
 574                   fprintf (fp, "%lu", args[arg_no].l);
 575                   ++arg_count;
 576                   ++fmt;
 577                   break;
 578                 }
 579               /* Fallthru */
 580
 581             default:
 582               fprintf (fp, "%%%c", fmt[-1]);
 583               break;
 584             }
 585         }
 586     }
 587
 588   if (is_warning && config.fatal_warnings)
 589     config.make_executable = FALSE;
 590
 591   if (fatal)
 592     xexit (1);
 593 }
 594
 595 /* Format info message and print on stdout.  */
 596
 597 /* (You would think this should be called just "info", but then you
 598    would be hosed by LynxOS, which defines that name in its libc.)  */
 599
 600 void
 601 info_msg (const char *fmt, ...)
 602 {
 603   va_list arg;
 604
 605   va_start (arg, fmt);
 606   vfinfo (stdout, fmt, arg, FALSE);
 607   va_end (arg);
 608 }
 609
 610 /* ('e' for error.) Format info message and print on stderr.  */
 611
 612 void
 613 einfo (const char *fmt, ...)
 614 {
 615   va_list arg;
 616
 617   fflush (stdout);
 618   va_start (arg, fmt);
 619   vfinfo (stderr, fmt, arg, TRUE);
 620   va_end (arg);
 621   fflush (stderr);
 622 }
 623
 624 void
 625 info_assert (const char *file, unsigned int line)
 626 {
 627   einfo (_("%F%P: internal error %s %d\n"), file, line);
 628 }
 629
 630 /* ('m' for map) Format info message and print on map.  */
 631
 632 void
 633 minfo (const char *fmt, ...)
 634 {
 635   if (config.map_file != NULL)
 636     {
 637       va_list arg;
 638
 639       va_start (arg, fmt);
 640       if (fmt[0] == '%' && fmt[1] == '!' && fmt[2] == 0)
 641         {
 642           /* Stash info about --as-needed shared libraries.  Print
 643              later so they don't appear intermingled with archive
 644              library info.  */
 645           struct asneeded_minfo *m = xmalloc (sizeof *m);
 646
 647           m->next = NULL;
 648           m->soname = va_arg (arg, const char *);
 649           m->ref = va_arg (arg, bfd *);
 650           m->name = va_arg (arg, const char *);
 651           *asneeded_list_tail = m;
 652           asneeded_list_tail = &m->next;
 653         }
 654       else
 655         vfinfo (config.map_file, fmt, arg, FALSE);
 656       va_end (arg);
 657     }
 658 }
 659
 660 void
 661 lfinfo (FILE *file, const char *fmt, ...)
 662 {
 663   va_list arg;
 664
 665   va_start (arg, fmt);
 666   vfinfo (file, fmt, arg, FALSE);
 667   va_end (arg);
 668 }
 669 \f
 670 /* Functions to print the link map.  */
 671
 672 void
 673 print_space (void)
 674 {
 675   fprintf (config.map_file, " ");
 676 }
 677
 678 void
 679 print_nl (void)
 680 {
 681   fprintf (config.map_file, "\n");
 682 }
 683
 684 /* A more or less friendly abort message.  In ld.h abort is defined to
 685    call this function.  */
 686
 687 void
 688 ld_abort (const char *file, int line, const char *fn)
 689 {
 690   if (fn != NULL)
 691     einfo (_("%P: internal error: aborting at %s:%d in %s\n"),
 692            file, line, fn);
 693   else
 694     einfo (_("%P: internal error: aborting at %s:%d\n"),
 695            file, line);
 696   einfo (_("%F%P: please report this bug\n"));
 697   xexit (1);
 698 }