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)", abfd->my_archive->filename,
 460                              abfd->filename);
 461                   else
 462                     fprintf (fp, "%s", abfd->filename);
 463                 }
 464               else if (*fmt == 'I')
 465                 {
 466                   /* filename from a lang_input_statement_type */
 467                   lang_input_statement_type *i;
 468
 469                   fmt++;
 470                   i = (lang_input_statement_type *) args[arg_no].p;
 471                   ++arg_count;
 472                   if (i->the_bfd != NULL
 473                       && i->the_bfd->my_archive != NULL
 474                       && !bfd_is_thin_archive (i->the_bfd->my_archive))
 475                     fprintf (fp, "(%s)%s", i->the_bfd->my_archive->filename,
 476                              i->local_sym_name);
 477                   else
 478                     fprintf (fp, "%s", i->filename);
 479                 }
 480               else if (*fmt == 'R')
 481                 {
 482                   /* Print all that's interesting about a relent.  */
 483                   arelent *relent = (arelent *) args[arg_no].p;
 484
 485                   fmt++;
 486                   ++arg_count;
 487                   lfinfo (fp, "%s+0x%v (type %s)",
 488                           (*(relent->sym_ptr_ptr))->name,
 489                           relent->addend,
 490                           relent->howto->name);
 491                 }
 492               else if (*fmt == 'S')
 493                 {
 494                   /* Print script file and linenumber.  */
 495                   etree_type node;
 496                   etree_type *tp = (etree_type *) args[arg_no].p;
 497
 498                   fmt++;
 499                   ++arg_count;
 500                   if (tp == NULL)
 501                     {
 502                       tp = &node;
 503                       tp->type.filename = ldlex_filename ();
 504                       tp->type.lineno = lineno;
 505                     }
 506                   if (tp->type.filename != NULL)
 507                     fprintf (fp, "%s:%u", tp->type.filename, tp->type.lineno);
 508                 }
 509               else if (*fmt == 'T')
 510                 {
 511                   /* Symbol name.  */
 512                   const char *name = (const char *) args[arg_no].p;
 513
 514                   fmt++;
 515                   ++arg_count;
 516                   if (name == NULL || *name == 0)
 517                     {
 518                       fprintf (fp, _("no symbol"));
 519                       break;
 520                     }
 521                   else if (demangling)
 522                     {
 523                       char *demangled;
 524
 525                       demangled = bfd_demangle (link_info.output_bfd, name,
 526                                                 DMGL_ANSI | DMGL_PARAMS);
 527                       if (demangled != NULL)
 528                         {
 529                           fprintf (fp, "%s", demangled);
 530                           free (demangled);
 531                           break;
 532                         }
 533                     }
 534                   fprintf (fp, "%s", name);
 535                 }
 536               else
 537                 {
 538                   /* native (host) void* pointer, like printf */
 539                   fprintf (fp, "%p", args[arg_no].p);
 540                   ++arg_count;
 541                 }
 542               break;
 543
 544             case 's':
 545               /* arbitrary string, like printf */
 546               fprintf (fp, "%s", (char *) args[arg_no].p);
 547               ++arg_count;
 548               break;
 549
 550             case 'd':
 551               /* integer, like printf */
 552               fprintf (fp, "%d", args[arg_no].i);
 553               ++arg_count;
 554               break;
 555
 556             case 'u':
 557               /* unsigned integer, like printf */
 558               fprintf (fp, "%u", args[arg_no].i);
 559               ++arg_count;
 560               break;
 561
 562             case 'l':
 563               if (*fmt == 'd')
 564                 {
 565                   fprintf (fp, "%ld", args[arg_no].l);
 566                   ++arg_count;
 567                   ++fmt;
 568                   break;
 569                 }
 570               else if (*fmt == 'u')
 571                 {
 572                   fprintf (fp, "%lu", args[arg_no].l);
 573                   ++arg_count;
 574                   ++fmt;
 575                   break;
 576                 }
 577               /* Fallthru */
 578
 579             default:
 580               fprintf (fp, "%%%c", fmt[-1]);
 581               break;
 582             }
 583         }
 584     }
 585
 586   if (is_warning && config.fatal_warnings)
 587     config.make_executable = FALSE;
 588
 589   if (fatal)
 590     xexit (1);
 591 }
 592
 593 /* Format info message and print on stdout.  */
 594
 595 /* (You would think this should be called just "info", but then you
 596    would be hosed by LynxOS, which defines that name in its libc.)  */
 597
 598 void
 599 info_msg (const char *fmt, ...)
 600 {
 601   va_list arg;
 602
 603   va_start (arg, fmt);
 604   vfinfo (stdout, fmt, arg, FALSE);
 605   va_end (arg);
 606 }
 607
 608 /* ('e' for error.) Format info message and print on stderr.  */
 609
 610 void
 611 einfo (const char *fmt, ...)
 612 {
 613   va_list arg;
 614
 615   fflush (stdout);
 616   va_start (arg, fmt);
 617   vfinfo (stderr, fmt, arg, TRUE);
 618   va_end (arg);
 619   fflush (stderr);
 620 }
 621
 622 void
 623 info_assert (const char *file, unsigned int line)
 624 {
 625   einfo (_("%F%P: internal error %s %d\n"), file, line);
 626 }
 627
 628 /* ('m' for map) Format info message and print on map.  */
 629
 630 void
 631 minfo (const char *fmt, ...)
 632 {
 633   if (config.map_file != NULL)
 634     {
 635       va_list arg;
 636
 637       va_start (arg, fmt);
 638       if (fmt[0] == '%' && fmt[1] == '!' && fmt[2] == 0)
 639         {
 640           /* Stash info about --as-needed shared libraries.  Print
 641              later so they don't appear intermingled with archive
 642              library info.  */
 643           struct asneeded_minfo *m = xmalloc (sizeof *m);
 644
 645           m->next = NULL;
 646           m->soname = va_arg (arg, const char *);
 647           m->ref = va_arg (arg, bfd *);
 648           m->name = va_arg (arg, const char *);
 649           *asneeded_list_tail = m;
 650           asneeded_list_tail = &m->next;
 651         }
 652       else
 653         vfinfo (config.map_file, fmt, arg, FALSE);
 654       va_end (arg);
 655     }
 656 }
 657
 658 void
 659 lfinfo (FILE *file, const char *fmt, ...)
 660 {
 661   va_list arg;
 662
 663   va_start (arg, fmt);
 664   vfinfo (file, fmt, arg, FALSE);
 665   va_end (arg);
 666 }
 667 \f
 668 /* Functions to print the link map.  */
 669
 670 void
 671 print_space (void)
 672 {
 673   fprintf (config.map_file, " ");
 674 }
 675
 676 void
 677 print_nl (void)
 678 {
 679   fprintf (config.map_file, "\n");
 680 }
 681
 682 /* A more or less friendly abort message.  In ld.h abort is defined to
 683    call this function.  */
 684
 685 void
 686 ld_abort (const char *file, int line, const char *fn)
 687 {
 688   if (fn != NULL)
 689     einfo (_("%P: internal error: aborting at %s:%d in %s\n"),
 690            file, line, fn);
 691   else
 692     einfo (_("%P: internal error: aborting at %s:%d\n"),
 693            file, line);
 694   einfo (_("%F%P: please report this bug\n"));
 695   xexit (1);
 696 }