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 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, 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 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 bool discard_last; 325 bool 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 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 } 694