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