ld/ldmisc.c

   1 /* ldmisc.c
   2    Copyright (C) 1991-2021 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  %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, 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                 bfd_error_type last_bfd_error = bfd_get_error ();
 327
 328                 abfd = args[arg_no].reladdr.abfd;
 329                 section = args[arg_no].reladdr.sec;
 330                 offset = args[arg_no].reladdr.off;
 331                 ++arg_count;
 332
 333                 if (abfd != NULL)
 334                   {
 335                     if (!bfd_generic_link_read_symbols (abfd))
 336                       einfo (_("%F%P: %pB: could not read symbols: %E\n"), abfd);
 337
 338                     asymbols = bfd_get_outsymbols (abfd);
 339                   }
 340
 341                 /* The GNU Coding Standard requires that error messages
 342                    be of the form:
 343
 344                      source-file-name:lineno: message
 345
 346                    We do not always have a line number available so if
 347                    we cannot find them we print out the section name and
 348                    offset instead.  */
 349                 discard_last = TRUE;
 350                 if (abfd != NULL
 351                     && bfd_find_nearest_line (abfd, section, asymbols, offset,
 352                                               &filename, &functionname,
 353                                               &linenumber))
 354                   {
 355                     if (functionname != NULL
 356                         && (fmt[-1] == 'C' || fmt[-1] == 'H'))
 357                       {
 358                         /* Detect the case where we are printing out a
 359                            message for the same function as the last
 360                            call to vinfo ("%C").  In this situation do
 361                            not print out the ABFD filename or the
 362                            function name again.  Note - we do still
 363                            print out the source filename, as this will
 364                            allow programs that parse the linker's output
 365                            (eg emacs) to correctly locate multiple
 366                            errors in the same source file.  */
 367                         if (last_bfd == NULL
 368                             || last_function == NULL
 369                             || last_bfd != abfd
 370                             || (last_file == NULL) != (filename == NULL)
 371                             || (filename != NULL
 372                                 && filename_cmp (last_file, filename) != 0)
 373                             || strcmp (last_function, functionname) != 0)
 374                           {
 375                             lfinfo (fp, _("%pB: in function `%pT':\n"),
 376                                     abfd, functionname);
 377
 378                             last_bfd = abfd;
 379                             free (last_file);
 380                             last_file = NULL;
 381                             if (filename)
 382                               last_file = xstrdup (filename);
 383                             free (last_function);
 384                             last_function = xstrdup (functionname);
 385                           }
 386                         discard_last = FALSE;
 387                       }
 388                     else
 389                       lfinfo (fp, "%pB:", abfd);
 390
 391                     if (filename != NULL)
 392                       fprintf (fp, "%s:", filename);
 393
 394                     done = fmt[-1] != 'H';
 395                     if (functionname != NULL && fmt[-1] == 'G')
 396                       lfinfo (fp, "%pT", functionname);
 397                     else if (filename != NULL && linenumber != 0)
 398                       fprintf (fp, "%u%s", linenumber, done ? "" : ":");
 399                     else
 400                       done = FALSE;
 401                   }
 402                 else
 403                   {
 404                     lfinfo (fp, "%pB:", abfd);
 405                     done = FALSE;
 406                   }
 407                 if (!done)
 408                   lfinfo (fp, "(%pA+0x%v)", section, offset);
 409                 bfd_set_error (last_bfd_error);
 410
 411                 if (discard_last)
 412                   {
 413                     last_bfd = NULL;
 414                     free (last_file);
 415                     last_file = NULL;
 416                     free (last_function);
 417                     last_function = NULL;
 418                   }
 419               }
 420               break;
 421
 422             case 'p':
 423               if (*fmt == 'A')
 424                 {
 425                   /* section name from a section */
 426                   asection *sec;
 427                   bfd *abfd;
 428
 429                   fmt++;
 430                   sec = (asection *) args[arg_no].p;
 431                   ++arg_count;
 432                   fprintf (fp, "%s", sec->name);
 433                   abfd = sec->owner;
 434                   if (abfd != NULL)
 435                     {
 436                       const char *group = bfd_group_name (abfd, sec);
 437                       if (group != NULL)
 438                         fprintf (fp, "[%s]", group);
 439                     }
 440                 }
 441               else if (*fmt == 'B')
 442                 {
 443                   /* filename from a bfd */
 444                   bfd *abfd = (bfd *) args[arg_no].p;
 445
 446                   fmt++;
 447                   ++arg_count;
 448                   if (abfd == NULL)
 449                     fprintf (fp, "%s generated", program_name);
 450                   else if (abfd->my_archive != NULL
 451                            && !bfd_is_thin_archive (abfd->my_archive))
 452                     fprintf (fp, "%s(%s)",
 453                              bfd_get_filename (abfd->my_archive),
 454                              bfd_get_filename (abfd));
 455                   else
 456                     fprintf (fp, "%s", bfd_get_filename (abfd));
 457                 }
 458               else if (*fmt == 'I')
 459                 {
 460                   /* filename from a lang_input_statement_type */
 461                   lang_input_statement_type *i;
 462
 463                   fmt++;
 464                   i = (lang_input_statement_type *) args[arg_no].p;
 465                   ++arg_count;
 466                   if (i->the_bfd != NULL
 467                       && i->the_bfd->my_archive != NULL
 468                       && !bfd_is_thin_archive (i->the_bfd->my_archive))
 469                     fprintf (fp, "(%s)%s",
 470                              bfd_get_filename (i->the_bfd->my_archive),
 471                              i->local_sym_name);
 472                   else
 473                     fprintf (fp, "%s", i->filename);
 474                 }
 475               else if (*fmt == 'R')
 476                 {
 477                   /* Print all that's interesting about a relent.  */
 478                   arelent *relent = (arelent *) args[arg_no].p;
 479
 480                   fmt++;
 481                   ++arg_count;
 482                   lfinfo (fp, "%s+0x%v (type %s)",
 483                           (*(relent->sym_ptr_ptr))->name,
 484                           relent->addend,
 485                           relent->howto->name);
 486                 }
 487               else if (*fmt == 'S' || *fmt == 'U')
 488                 {
 489                   /* Print script file and perhaps the associated linenumber.  */
 490                   etree_type node;
 491                   etree_type *tp = (etree_type *) args[arg_no].p;
 492
 493                   fmt++;
 494                   ++arg_count;
 495                   if (tp == NULL)
 496                     {
 497                       tp = &node;
 498                       tp->type.filename = ldlex_filename ();
 499                       tp->type.lineno = lineno;
 500                     }
 501                   if (tp->type.filename != NULL && fmt[-1] == 'S')
 502                     fprintf (fp, "%s:%u", tp->type.filename, tp->type.lineno);
 503                   else if (tp->type.filename != NULL && fmt[-1] == 'U')
 504                     fprintf (fp, "%s", tp->type.filename);
 505                 }
 506               else if (*fmt == 'T')
 507                 {
 508                   /* Symbol name.  */
 509                   const char *name = (const char *) args[arg_no].p;
 510
 511                   fmt++;
 512                   ++arg_count;
 513                   if (name == NULL || *name == 0)
 514                     {
 515                       fprintf (fp, _("no symbol"));
 516                       break;
 517                     }
 518                   else if (demangling)
 519                     {
 520                       char *demangled;
 521
 522                       demangled = bfd_demangle (link_info.output_bfd, name,
 523                                                 DMGL_ANSI | DMGL_PARAMS);
 524                       if (demangled != NULL)
 525                         {
 526                           fprintf (fp, "%s", demangled);
 527                           free (demangled);
 528                           break;
 529                         }
 530                     }
 531                   fprintf (fp, "%s", name);
 532                 }
 533               else
 534                 {
 535                   /* native (host) void* pointer, like printf */
 536                   fprintf (fp, "%p", args[arg_no].p);
 537                   ++arg_count;
 538                 }
 539               break;
 540
 541             case 's':
 542               /* arbitrary string, like printf */
 543               fprintf (fp, "%s", (char *) args[arg_no].p);
 544               ++arg_count;
 545               break;
 546
 547             case 'd':
 548               /* integer, like printf */
 549               fprintf (fp, "%d", args[arg_no].i);
 550               ++arg_count;
 551               break;
 552
 553             case 'u':
 554               /* unsigned integer, like printf */
 555               fprintf (fp, "%u", args[arg_no].i);
 556               ++arg_count;
 557               break;
 558
 559             case 'l':
 560               if (*fmt == 'd')
 561                 {
 562                   fprintf (fp, "%ld", args[arg_no].l);
 563                   ++arg_count;
 564                   ++fmt;
 565                   break;
 566                 }
 567               else if (*fmt == 'u')
 568                 {
 569                   fprintf (fp, "%lu", args[arg_no].l);
 570                   ++arg_count;
 571                   ++fmt;
 572                   break;
 573                 }
 574               /* Fallthru */
 575
 576             default:
 577               fprintf (fp, "%%%c", fmt[-1]);
 578               break;
 579             }
 580         }
 581     }
 582
 583   if (is_warning && config.fatal_warnings)
 584     config.make_executable = FALSE;
 585
 586   if (fatal)
 587     xexit (1);
 588 }
 589
 590 /* Format info message and print on stdout.  */
 591
 592 /* (You would think this should be called just "info", but then you
 593    would be hosed by LynxOS, which defines that name in its libc.)  */
 594
 595 void
 596 info_msg (const char *fmt, ...)
 597 {
 598   va_list arg;
 599
 600   va_start (arg, fmt);
 601   vfinfo (stdout, fmt, arg, FALSE);
 602   va_end (arg);
 603 }
 604
 605 /* ('e' for error.) Format info message and print on stderr.  */
 606
 607 void
 608 einfo (const char *fmt, ...)
 609 {
 610   va_list arg;
 611
 612   fflush (stdout);
 613   va_start (arg, fmt);
 614   vfinfo (stderr, fmt, arg, TRUE);
 615   va_end (arg);
 616   fflush (stderr);
 617 }
 618
 619 void
 620 info_assert (const char *file, unsigned int line)
 621 {
 622   einfo (_("%F%P: internal error %s %d\n"), file, line);
 623 }
 624
 625 /* ('m' for map) Format info message and print on map.  */
 626
 627 void
 628 minfo (const char *fmt, ...)
 629 {
 630   if (config.map_file != NULL)
 631     {
 632       va_list arg;
 633
 634       va_start (arg, fmt);
 635       if (fmt[0] == '%' && fmt[1] == '!' && fmt[2] == 0)
 636         {
 637           /* Stash info about --as-needed shared libraries.  Print
 638              later so they don't appear intermingled with archive
 639              library info.  */
 640           struct asneeded_minfo *m = xmalloc (sizeof *m);
 641
 642           m->next = NULL;
 643           m->soname = va_arg (arg, const char *);
 644           m->ref = va_arg (arg, bfd *);
 645           m->name = va_arg (arg, const char *);
 646           *asneeded_list_tail = m;
 647           asneeded_list_tail = &m->next;
 648         }
 649       else
 650         vfinfo (config.map_file, fmt, arg, FALSE);
 651       va_end (arg);
 652     }
 653 }
 654
 655 void
 656 lfinfo (FILE *file, const char *fmt, ...)
 657 {
 658   va_list arg;
 659
 660   va_start (arg, fmt);
 661   vfinfo (file, fmt, arg, FALSE);
 662   va_end (arg);
 663 }
 664 \f
 665 /* Functions to print the link map.  */
 666
 667 void
 668 print_space (void)
 669 {
 670   fprintf (config.map_file, " ");
 671 }
 672
 673 void
 674 print_nl (void)
 675 {
 676   fprintf (config.map_file, "\n");
 677 }
 678
 679 /* A more or less friendly abort message.  In ld.h abort is defined to
 680    call this function.  */
 681
 682 void
 683 ld_abort (const char *file, int line, const char *fn)
 684 {
 685   if (fn != NULL)
 686     einfo (_("%P: internal error: aborting at %s:%d in %s\n"),
 687            file, line, fn);
 688   else
 689     einfo (_("%P: internal error: aborting at %s:%d\n"),
 690            file, line);
 691   einfo (_("%F%P: please report this bug\n"));
 692   xexit (1);
 693 }