ld/ldmisc.c

   1 /* ldmisc.c
   2    Copyright (C) 1991-2022 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 10 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  %pU print script file without linenumber from etree_type.
  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, bool is_warning)
  70 {
  71   bool 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   if (is_warning && config.no_warnings)
  99     return;
 100
 101   for (arg_no = 0; arg_no < sizeof (args) / sizeof (args[0]); arg_no++)
 102     args[arg_no].type = Bad;
 103
 104   arg_count = 0;
 105   scan = fmt;
 106   while (*scan != '\0')
 107     {
 108       while (*scan != '%' && *scan != '\0')
 109         scan++;
 110
 111       if (*scan == '%')
 112         {
 113           scan++;
 114
 115           arg_no = arg_count;
 116           if (*scan != '0' && ISDIGIT (*scan) && scan[1] == '$')
 117             {
 118               arg_no = *scan - '1';
 119               scan += 2;
 120             }
 121
 122           arg_type = Bad;
 123           switch (*scan++)
 124             {
 125             case '\0':
 126               --scan;
 127               break;
 128
 129             case 'V':
 130             case 'v':
 131             case 'W':
 132               arg_type = Vma;
 133               break;
 134
 135             case 's':
 136               arg_type = Ptr;
 137               break;
 138
 139             case 'p':
 140               if (*scan == 'A' || *scan == 'B' || *scan == 'I'
 141                   || *scan == 'R' || *scan == 'S' || *scan ==  'T')
 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                 char buf[32];
 248                 bfd_vma value;
 249
 250                 value = args[arg_no].v;
 251                 ++arg_count;
 252                 bfd_sprintf_vma (link_info.output_bfd, buf, value);
 253                 fprintf (fp, "%s", buf);
 254               }
 255               break;
 256
 257             case 'v':
 258               /* hex bfd_vma, no leading zeros */
 259               {
 260                 uint64_t value = args[arg_no].v;
 261                 ++arg_count;
 262                 fprintf (fp, "%" PRIx64, value);
 263               }
 264               break;
 265
 266             case 'W':
 267               /* hex bfd_vma with 0x with no leading zeroes taking up
 268                  10 spaces (including the 0x).  */
 269               {
 270                 char buf[32];
 271                 uint64_t value;
 272
 273                 value = args[arg_no].v;
 274                 ++arg_count;
 275                 sprintf (buf, "0x%" PRIx64, value);
 276                 fprintf (fp, "%10s", buf);
 277               }
 278               break;
 279
 280             case 'F':
 281               /* Error is fatal.  */
 282               fatal = true;
 283               break;
 284
 285             case 'P':
 286               /* Print program name.  */
 287               fprintf (fp, "%s", program_name);
 288               break;
 289
 290             case 'E':
 291               /* current bfd error or errno */
 292               fprintf (fp, "%s", bfd_errmsg (bfd_get_error ()));
 293               break;
 294
 295             case 'C':
 296             case 'D':
 297             case 'G':
 298             case 'H':
 299               /* Clever filename:linenumber with function name if possible.
 300                  The arguments are a BFD, a section, and an offset.  */
 301               {
 302                 static bfd *last_bfd;
 303                 static char *last_file;
 304                 static char *last_function;
 305                 bfd *abfd;
 306                 asection *section;
 307                 bfd_vma offset;
 308                 asymbol **asymbols = NULL;
 309                 const char *filename;
 310                 const char *functionname;
 311                 unsigned int linenumber;
 312                 bool discard_last;
 313                 bool done;
 314                 bfd_error_type last_bfd_error = bfd_get_error ();
 315
 316                 abfd = args[arg_no].reladdr.abfd;
 317                 section = args[arg_no].reladdr.sec;
 318                 offset = args[arg_no].reladdr.off;
 319                 ++arg_count;
 320
 321                 if (abfd != NULL)
 322                   {
 323                     if (!bfd_generic_link_read_symbols (abfd))
 324                       einfo (_("%F%P: %pB: could not read symbols: %E\n"), abfd);
 325
 326                     asymbols = bfd_get_outsymbols (abfd);
 327                   }
 328
 329                 /* The GNU Coding Standard requires that error messages
 330                    be of the form:
 331
 332                      source-file-name:lineno: message
 333
 334                    We do not always have a line number available so if
 335                    we cannot find them we print out the section name and
 336                    offset instead.  */
 337                 discard_last = true;
 338                 if (abfd != NULL
 339                     && bfd_find_nearest_line (abfd, section, asymbols, offset,
 340                                               &filename, &functionname,
 341                                               &linenumber))
 342                   {
 343                     if (functionname != NULL
 344                         && (fmt[-1] == 'C' || fmt[-1] == 'H'))
 345                       {
 346                         /* Detect the case where we are printing out a
 347                            message for the same function as the last
 348                            call to vinfo ("%C").  In this situation do
 349                            not print out the ABFD filename or the
 350                            function name again.  Note - we do still
 351                            print out the source filename, as this will
 352                            allow programs that parse the linker's output
 353                            (eg emacs) to correctly locate multiple
 354                            errors in the same source file.  */
 355                         if (last_bfd == NULL
 356                             || last_function == NULL
 357                             || last_bfd != abfd
 358                             || (last_file == NULL) != (filename == NULL)
 359                             || (filename != NULL
 360                                 && filename_cmp (last_file, filename) != 0)
 361                             || strcmp (last_function, functionname) != 0)
 362                           {
 363                             lfinfo (fp, _("%pB: in function `%pT':\n"),
 364                                     abfd, functionname);
 365
 366                             last_bfd = abfd;
 367                             free (last_file);
 368                             last_file = NULL;
 369                             if (filename)
 370                               last_file = xstrdup (filename);
 371                             free (last_function);
 372                             last_function = xstrdup (functionname);
 373                           }
 374                         discard_last = false;
 375                       }
 376                     else
 377                       lfinfo (fp, "%pB:", abfd);
 378
 379                     if (filename != NULL)
 380                       fprintf (fp, "%s:", filename);
 381
 382                     done = fmt[-1] != 'H';
 383                     if (functionname != NULL && fmt[-1] == 'G')
 384                       lfinfo (fp, "%pT", functionname);
 385                     else if (filename != NULL && linenumber != 0)
 386                       fprintf (fp, "%u%s", linenumber, done ? "" : ":");
 387                     else
 388                       done = false;
 389                   }
 390                 else
 391                   {
 392                     lfinfo (fp, "%pB:", abfd);
 393                     done = false;
 394                   }
 395                 if (!done)
 396                   lfinfo (fp, "(%pA+0x%v)", section, offset);
 397                 bfd_set_error (last_bfd_error);
 398
 399                 if (discard_last)
 400                   {
 401                     last_bfd = NULL;
 402                     free (last_file);
 403                     last_file = NULL;
 404                     free (last_function);
 405                     last_function = NULL;
 406                   }
 407               }
 408               break;
 409
 410             case 'p':
 411               if (*fmt == 'A')
 412                 {
 413                   /* section name from a section */
 414                   asection *sec;
 415                   bfd *abfd;
 416
 417                   fmt++;
 418                   sec = (asection *) args[arg_no].p;
 419                   ++arg_count;
 420                   fprintf (fp, "%s", sec->name);
 421                   abfd = sec->owner;
 422                   if (abfd != NULL)
 423                     {
 424                       const char *group = bfd_group_name (abfd, sec);
 425                       if (group != NULL)
 426                         fprintf (fp, "[%s]", group);
 427                     }
 428                 }
 429               else if (*fmt == 'B')
 430                 {
 431                   /* filename from a bfd */
 432                   bfd *abfd = (bfd *) args[arg_no].p;
 433
 434                   fmt++;
 435                   ++arg_count;
 436                   if (abfd == NULL)
 437                     fprintf (fp, "%s generated", program_name);
 438                   else if (abfd->my_archive != NULL
 439                            && !bfd_is_thin_archive (abfd->my_archive))
 440                     fprintf (fp, "%s(%s)",
 441                              bfd_get_filename (abfd->my_archive),
 442                              bfd_get_filename (abfd));
 443                   else
 444                     fprintf (fp, "%s", bfd_get_filename (abfd));
 445                 }
 446               else if (*fmt == 'I')
 447                 {
 448                   /* filename from a lang_input_statement_type */
 449                   lang_input_statement_type *i;
 450
 451                   fmt++;
 452                   i = (lang_input_statement_type *) args[arg_no].p;
 453                   ++arg_count;
 454                   if (i->the_bfd != NULL
 455                       && i->the_bfd->my_archive != NULL
 456                       && !bfd_is_thin_archive (i->the_bfd->my_archive))
 457                     fprintf (fp, "(%s)%s",
 458                              bfd_get_filename (i->the_bfd->my_archive),
 459                              i->local_sym_name);
 460                   else
 461                     fprintf (fp, "%s", i->filename);
 462                 }
 463               else if (*fmt == 'R')
 464                 {
 465                   /* Print all that's interesting about a relent.  */
 466                   arelent *relent = (arelent *) args[arg_no].p;
 467
 468                   fmt++;
 469                   ++arg_count;
 470                   lfinfo (fp, "%s+0x%v (type %s)",
 471                           (*(relent->sym_ptr_ptr))->name,
 472                           relent->addend,
 473                           relent->howto->name);
 474                 }
 475               else if (*fmt == 'S' || *fmt == 'U')
 476                 {
 477                   /* Print script file and perhaps the associated linenumber.  */
 478                   etree_type node;
 479                   etree_type *tp = (etree_type *) args[arg_no].p;
 480
 481                   fmt++;
 482                   ++arg_count;
 483                   if (tp == NULL)
 484                     {
 485                       tp = &node;
 486                       tp->type.filename = ldlex_filename ();
 487                       tp->type.lineno = lineno;
 488                     }
 489                   if (tp->type.filename != NULL && fmt[-1] == 'S')
 490                     fprintf (fp, "%s:%u", tp->type.filename, tp->type.lineno);
 491                   else if (tp->type.filename != NULL && fmt[-1] == 'U')
 492                     fprintf (fp, "%s", tp->type.filename);
 493                 }
 494               else if (*fmt == 'T')
 495                 {
 496                   /* Symbol name.  */
 497                   const char *name = (const char *) args[arg_no].p;
 498
 499                   fmt++;
 500                   ++arg_count;
 501                   if (name == NULL || *name == 0)
 502                     {
 503                       fprintf (fp, _("no symbol"));
 504                       break;
 505                     }
 506                   else if (demangling)
 507                     {
 508                       char *demangled;
 509
 510                       demangled = bfd_demangle (link_info.output_bfd, name,
 511                                                 DMGL_ANSI | DMGL_PARAMS);
 512                       if (demangled != NULL)
 513                         {
 514                           fprintf (fp, "%s", demangled);
 515                           free (demangled);
 516                           break;
 517                         }
 518                     }
 519                   fprintf (fp, "%s", name);
 520                 }
 521               else
 522                 {
 523                   /* native (host) void* pointer, like printf */
 524                   fprintf (fp, "%p", args[arg_no].p);
 525                   ++arg_count;
 526                 }
 527               break;
 528
 529             case 's':
 530               /* arbitrary string, like printf */
 531               fprintf (fp, "%s", (char *) args[arg_no].p);
 532               ++arg_count;
 533               break;
 534
 535             case 'd':
 536               /* integer, like printf */
 537               fprintf (fp, "%d", args[arg_no].i);
 538               ++arg_count;
 539               break;
 540
 541             case 'u':
 542               /* unsigned integer, like printf */
 543               fprintf (fp, "%u", args[arg_no].i);
 544               ++arg_count;
 545               break;
 546
 547             case 'l':
 548               if (*fmt == 'd')
 549                 {
 550                   fprintf (fp, "%ld", args[arg_no].l);
 551                   ++arg_count;
 552                   ++fmt;
 553                   break;
 554                 }
 555               else if (*fmt == 'u')
 556                 {
 557                   fprintf (fp, "%lu", args[arg_no].l);
 558                   ++arg_count;
 559                   ++fmt;
 560                   break;
 561                 }
 562               /* Fallthru */
 563
 564             default:
 565               fprintf (fp, "%%%c", fmt[-1]);
 566               break;
 567             }
 568         }
 569     }
 570
 571   if (is_warning && config.fatal_warnings)
 572     config.make_executable = false;
 573
 574   if (fatal)
 575     xexit (1);
 576 }
 577
 578 /* Format info message and print on stdout.  */
 579
 580 /* (You would think this should be called just "info", but then you
 581    would be hosed by LynxOS, which defines that name in its libc.)  */
 582
 583 void
 584 info_msg (const char *fmt, ...)
 585 {
 586   va_list arg;
 587
 588   va_start (arg, fmt);
 589   vfinfo (stdout, fmt, arg, false);
 590   va_end (arg);
 591 }
 592
 593 /* ('e' for error.) Format info message and print on stderr.  */
 594
 595 void
 596 einfo (const char *fmt, ...)
 597 {
 598   va_list arg;
 599
 600   fflush (stdout);
 601   va_start (arg, fmt);
 602   vfinfo (stderr, fmt, arg, true);
 603   va_end (arg);
 604   fflush (stderr);
 605 }
 606
 607 void
 608 info_assert (const char *file, unsigned int line)
 609 {
 610   einfo (_("%F%P: internal error %s %d\n"), file, line);
 611 }
 612
 613 /* ('m' for map) Format info message and print on map.  */
 614
 615 void
 616 minfo (const char *fmt, ...)
 617 {
 618   if (config.map_file != NULL)
 619     {
 620       va_list arg;
 621
 622       va_start (arg, fmt);
 623       if (fmt[0] == '%' && fmt[1] == '!' && fmt[2] == 0)
 624         {
 625           /* Stash info about --as-needed shared libraries.  Print
 626              later so they don't appear intermingled with archive
 627              library info.  */
 628           struct asneeded_minfo *m = xmalloc (sizeof *m);
 629
 630           m->next = NULL;
 631           m->soname = va_arg (arg, const char *);
 632           m->ref = va_arg (arg, bfd *);
 633           m->name = va_arg (arg, const char *);
 634           *asneeded_list_tail = m;
 635           asneeded_list_tail = &m->next;
 636         }
 637       else
 638         vfinfo (config.map_file, fmt, arg, false);
 639       va_end (arg);
 640     }
 641 }
 642
 643 void
 644 lfinfo (FILE *file, const char *fmt, ...)
 645 {
 646   va_list arg;
 647
 648   va_start (arg, fmt);
 649   vfinfo (file, fmt, arg, false);
 650   va_end (arg);
 651 }
 652 \f
 653 /* Functions to print the link map.  */
 654
 655 void
 656 print_spaces (int count)
 657 {
 658   fprintf (config.map_file, "%*s", count, "");
 659 }
 660
 661 void
 662 print_nl (void)
 663 {
 664   fprintf (config.map_file, "\n");
 665 }
 666
 667 /* A more or less friendly abort message.  In ld.h abort is defined to
 668    call this function.  */
 669
 670 void
 671 ld_abort (const char *file, int line, const char *fn)
 672 {
 673   if (fn != NULL)
 674     einfo (_("%P: internal error: aborting at %s:%d in %s\n"),
 675            file, line, fn);
 676   else
 677     einfo (_("%P: internal error: aborting at %s:%d\n"),
 678            file, line);
 679   einfo (_("%F%P: please report this bug\n"));
 680   xexit (1);
 681 }