1 /* ldmisc.c 2 Copyright (C) 1991-2018 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 "safe-ctype.h" 27 #include "filenames.h" 28 #include "demangle.h" 29 #include <stdarg.h> 30 #include "ld.h" 31 #include "ldmisc.h" 32 #include "ldexp.h" 33 #include "ldlang.h" 34 #include <ldgram.h> 35 #include "ldlex.h" 36 #include "ldmain.h" 37 #include "ldfile.h" 38 #include "elf-bfd.h" 39 #include "coff-bfd.h" 40 41 /* 42 %% literal % 43 %C clever filename:linenumber with function 44 %D like %C, but no function name 45 %E current bfd error or errno 46 %F error is fatal 47 %G like %D, but only function name 48 %H like %C but in addition emit section+offset 49 %P print program name 50 %V hex bfd_vma 51 %W hex bfd_vma with 0x with no leading zeros taking up 8 spaces 52 %X no object output, fail return 53 %d integer, like printf 54 %ld long, like printf 55 %lu unsigned long, like printf 56 %p native (host) void* pointer, like printf 57 %pA section name from a section 58 %pB filename from a bfd 59 %pI filename from a lang_input_statement_type 60 %pR info about a relent 61 %pS print script file and linenumber from etree_type. 62 %pT symbol name 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 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 411 if (discard_last) 412 { 413 last_bfd = NULL; 414 if (last_file != NULL) 415 { 416 free (last_file); 417 last_file = NULL; 418 } 419 if (last_function != NULL) 420 { 421 free (last_function); 422 last_function = NULL; 423 } 424 } 425 } 426 break; 427 428 case 'p': 429 if (*fmt == 'A') 430 { 431 /* section name from a section */ 432 asection *sec; 433 bfd *abfd; 434 const char *group = NULL; 435 struct coff_comdat_info *ci; 436 437 fmt++; 438 sec = (asection *) args[arg_no].p; 439 ++arg_count; 440 abfd = sec->owner; 441 fprintf (fp, "%s", sec->name); 442 if (abfd != NULL 443 && bfd_get_flavour (abfd) == bfd_target_elf_flavour 444 && elf_next_in_group (sec) != NULL 445 && (sec->flags & SEC_GROUP) == 0) 446 group = elf_group_name (sec); 447 else if (abfd != NULL 448 && bfd_get_flavour (abfd) == bfd_target_coff_flavour 449 && (ci = bfd_coff_get_comdat_section (sec->owner, 450 sec)) != NULL) 451 group = ci->name; 452 if (group != NULL) 453 fprintf (fp, "[%s]", group); 454 } 455 else if (*fmt == 'B') 456 { 457 /* filename from a bfd */ 458 bfd *abfd = (bfd *) args[arg_no].p; 459 460 fmt++; 461 ++arg_count; 462 if (abfd == NULL) 463 fprintf (fp, "%s generated", program_name); 464 else if (abfd->my_archive != NULL 465 && !bfd_is_thin_archive (abfd->my_archive)) 466 fprintf (fp, "%s(%s)", abfd->my_archive->filename, 467 abfd->filename); 468 else 469 fprintf (fp, "%s", abfd->filename); 470 } 471 else if (*fmt == 'I') 472 { 473 /* filename from a lang_input_statement_type */ 474 lang_input_statement_type *i; 475 476 fmt++; 477 i = (lang_input_statement_type *) args[arg_no].p; 478 ++arg_count; 479 if (i->the_bfd->my_archive != NULL 480 && !bfd_is_thin_archive (i->the_bfd->my_archive)) 481 fprintf (fp, "(%s)", 482 bfd_get_filename (i->the_bfd->my_archive)); 483 fprintf (fp, "%s", i->local_sym_name); 484 if ((i->the_bfd->my_archive == NULL 485 || bfd_is_thin_archive (i->the_bfd->my_archive)) 486 && filename_cmp (i->local_sym_name, i->filename) != 0) 487 fprintf (fp, " (%s)", i->filename); 488 } 489 else if (*fmt == 'R') 490 { 491 /* Print all that's interesting about a relent. */ 492 arelent *relent = (arelent *) args[arg_no].p; 493 494 fmt++; 495 ++arg_count; 496 lfinfo (fp, "%s+0x%v (type %s)", 497 (*(relent->sym_ptr_ptr))->name, 498 relent->addend, 499 relent->howto->name); 500 } 501 else if (*fmt == 'S') 502 { 503 /* Print script file and linenumber. */ 504 etree_type node; 505 etree_type *tp = (etree_type *) args[arg_no].p; 506 507 fmt++; 508 ++arg_count; 509 if (tp == NULL) 510 { 511 tp = &node; 512 tp->type.filename = ldlex_filename (); 513 tp->type.lineno = lineno; 514 } 515 if (tp->type.filename != NULL) 516 fprintf (fp, "%s:%u", tp->type.filename, tp->type.lineno); 517 } 518 else if (*fmt == 'T') 519 { 520 /* Symbol name. */ 521 const char *name = (const char *) args[arg_no].p; 522 523 fmt++; 524 ++arg_count; 525 if (name == NULL || *name == 0) 526 { 527 fprintf (fp, _("no symbol")); 528 break; 529 } 530 else if (demangling) 531 { 532 char *demangled; 533 534 demangled = bfd_demangle (link_info.output_bfd, name, 535 DMGL_ANSI | DMGL_PARAMS); 536 if (demangled != NULL) 537 { 538 fprintf (fp, "%s", demangled); 539 free (demangled); 540 break; 541 } 542 } 543 fprintf (fp, "%s", name); 544 } 545 else 546 { 547 /* native (host) void* pointer, like printf */ 548 fprintf (fp, "%p", args[arg_no].p); 549 ++arg_count; 550 } 551 break; 552 553 case 's': 554 /* arbitrary string, like printf */ 555 fprintf (fp, "%s", (char *) args[arg_no].p); 556 ++arg_count; 557 break; 558 559 case 'd': 560 /* integer, like printf */ 561 fprintf (fp, "%d", args[arg_no].i); 562 ++arg_count; 563 break; 564 565 case 'u': 566 /* unsigned integer, like printf */ 567 fprintf (fp, "%u", args[arg_no].i); 568 ++arg_count; 569 break; 570 571 case 'l': 572 if (*fmt == 'd') 573 { 574 fprintf (fp, "%ld", args[arg_no].l); 575 ++arg_count; 576 ++fmt; 577 break; 578 } 579 else if (*fmt == 'u') 580 { 581 fprintf (fp, "%lu", args[arg_no].l); 582 ++arg_count; 583 ++fmt; 584 break; 585 } 586 /* Fallthru */ 587 588 default: 589 fprintf (fp, "%%%c", fmt[-1]); 590 break; 591 } 592 } 593 } 594 595 if (is_warning && config.fatal_warnings) 596 config.make_executable = FALSE; 597 598 if (fatal) 599 xexit (1); 600 } 601 602 /* Format info message and print on stdout. */ 603 604 /* (You would think this should be called just "info", but then you 605 would be hosed by LynxOS, which defines that name in its libc.) */ 606 607 void 608 info_msg (const char *fmt, ...) 609 { 610 va_list arg; 611 612 va_start (arg, fmt); 613 vfinfo (stdout, fmt, arg, FALSE); 614 va_end (arg); 615 } 616 617 /* ('e' for error.) Format info message and print on stderr. */ 618 619 void 620 einfo (const char *fmt, ...) 621 { 622 va_list arg; 623 624 fflush (stdout); 625 va_start (arg, fmt); 626 vfinfo (stderr, fmt, arg, TRUE); 627 va_end (arg); 628 fflush (stderr); 629 } 630 631 void 632 info_assert (const char *file, unsigned int line) 633 { 634 einfo (_("%F%P: internal error %s %d\n"), file, line); 635 } 636 637 /* ('m' for map) Format info message and print on map. */ 638 639 void 640 minfo (const char *fmt, ...) 641 { 642 if (config.map_file != NULL) 643 { 644 va_list arg; 645 646 va_start (arg, fmt); 647 if (fmt[0] == '%' && fmt[1] == '!' && fmt[2] == 0) 648 { 649 /* Stash info about --as-needed shared libraries. Print 650 later so they don't appear intermingled with archive 651 library info. */ 652 struct asneeded_minfo *m = xmalloc (sizeof *m); 653 654 m->next = NULL; 655 m->soname = va_arg (arg, const char *); 656 m->ref = va_arg (arg, bfd *); 657 m->name = va_arg (arg, const char *); 658 *asneeded_list_tail = m; 659 asneeded_list_tail = &m->next; 660 } 661 else 662 vfinfo (config.map_file, fmt, arg, FALSE); 663 va_end (arg); 664 } 665 } 666 667 void 668 lfinfo (FILE *file, const char *fmt, ...) 669 { 670 va_list arg; 671 672 va_start (arg, fmt); 673 vfinfo (file, fmt, arg, FALSE); 674 va_end (arg); 675 } 676 677 /* Functions to print the link map. */ 678 679 void 680 print_space (void) 681 { 682 fprintf (config.map_file, " "); 683 } 684 685 void 686 print_nl (void) 687 { 688 fprintf (config.map_file, "\n"); 689 } 690 691 /* A more or less friendly abort message. In ld.h abort is defined to 692 call this function. */ 693 694 void 695 ld_abort (const char *file, int line, const char *fn) 696 { 697 if (fn != NULL) 698 einfo (_("%P: internal error: aborting at %s:%d in %s\n"), 699 file, line, fn); 700 else 701 einfo (_("%P: internal error: aborting at %s:%d\n"), 702 file, line); 703 einfo (_("%F%P: please report this bug\n")); 704 xexit (1); 705 } 706