1 /* ldmisc.c 2 Copyright (C) 1991-2016 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 "filenames.h" 27 #include "demangle.h" 28 #include <stdarg.h> 29 #include "ld.h" 30 #include "ldmisc.h" 31 #include "ldexp.h" 32 #include "ldlang.h" 33 #include <ldgram.h> 34 #include "ldlex.h" 35 #include "ldmain.h" 36 #include "ldfile.h" 37 #include "elf-bfd.h" 38 #include "coff-bfd.h" 39 40 /* 41 %% literal % 42 %A section name from a section 43 %B filename from a bfd 44 %C clever filename:linenumber with function 45 %D like %C, but no function name 46 %E current bfd error or errno 47 %F error is fatal 48 %G like %D, but only function name 49 %H like %C but in addition emit section+offset 50 %I filename from a lang_input_statement_type 51 %P print program name 52 %R info about a relent 53 %S print script file and linenumber from etree_type. 54 %T symbol name 55 %V hex bfd_vma 56 %W hex bfd_vma with 0x with no leading zeros taking up 8 spaces 57 %X no object output, fail return 58 %d integer, like printf 59 %ld long, like printf 60 %lu unsigned long, like printf 61 %p native (host) void* pointer, like printf 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 arg, bfd_boolean is_warning) 69 { 70 bfd_boolean fatal = FALSE; 71 72 while (*fmt != '\0') 73 { 74 const char *str = fmt; 75 while (*fmt != '%' && *fmt != '\0') 76 fmt++; 77 if (fmt != str) 78 if (fwrite (str, 1, fmt - str, fp)) 79 { 80 /* Ignore. */ 81 } 82 83 if (*fmt == '%') 84 { 85 fmt++; 86 switch (*fmt++) 87 { 88 case '%': 89 /* literal % */ 90 putc ('%', fp); 91 break; 92 93 case 'X': 94 /* no object output, fail return */ 95 config.make_executable = FALSE; 96 break; 97 98 case 'V': 99 /* hex bfd_vma */ 100 { 101 bfd_vma value = va_arg (arg, bfd_vma); 102 fprintf_vma (fp, value); 103 } 104 break; 105 106 case 'v': 107 /* hex bfd_vma, no leading zeros */ 108 { 109 char buf[100]; 110 char *p = buf; 111 bfd_vma value = va_arg (arg, bfd_vma); 112 sprintf_vma (p, value); 113 while (*p == '0') 114 p++; 115 if (!*p) 116 p--; 117 fputs (p, fp); 118 } 119 break; 120 121 case 'W': 122 /* hex bfd_vma with 0x with no leading zeroes taking up 123 8 spaces. */ 124 { 125 char buf[100]; 126 bfd_vma value; 127 char *p; 128 int len; 129 130 value = va_arg (arg, bfd_vma); 131 sprintf_vma (buf, value); 132 for (p = buf; *p == '0'; ++p) 133 ; 134 if (*p == '\0') 135 --p; 136 len = strlen (p); 137 while (len < 8) 138 { 139 putc (' ', fp); 140 ++len; 141 } 142 fprintf (fp, "0x%s", p); 143 } 144 break; 145 146 case 'T': 147 /* Symbol name. */ 148 { 149 const char *name = va_arg (arg, const char *); 150 151 if (name == NULL || *name == 0) 152 { 153 fprintf (fp, _("no symbol")); 154 break; 155 } 156 else if (demangling) 157 { 158 char *demangled; 159 160 demangled = bfd_demangle (link_info.output_bfd, name, 161 DMGL_ANSI | DMGL_PARAMS); 162 if (demangled != NULL) 163 { 164 fprintf (fp, "%s", demangled); 165 free (demangled); 166 break; 167 } 168 } 169 fprintf (fp, "%s", name); 170 } 171 break; 172 173 case 'A': 174 /* section name from a section */ 175 { 176 asection *sec = va_arg (arg, asection *); 177 bfd *abfd = sec->owner; 178 const char *group = NULL; 179 struct coff_comdat_info *ci; 180 181 fprintf (fp, "%s", sec->name); 182 if (abfd != NULL 183 && bfd_get_flavour (abfd) == bfd_target_elf_flavour 184 && elf_next_in_group (sec) != NULL 185 && (sec->flags & SEC_GROUP) == 0) 186 group = elf_group_name (sec); 187 else if (abfd != NULL 188 && bfd_get_flavour (abfd) == bfd_target_coff_flavour 189 && (ci = bfd_coff_get_comdat_section (sec->owner, 190 sec)) != NULL) 191 group = ci->name; 192 if (group != NULL) 193 fprintf (fp, "[%s]", group); 194 } 195 break; 196 197 case 'B': 198 /* filename from a bfd */ 199 { 200 bfd *abfd = va_arg (arg, bfd *); 201 202 if (abfd == NULL) 203 fprintf (fp, "%s generated", program_name); 204 else if (abfd->my_archive != NULL 205 && !bfd_is_thin_archive (abfd->my_archive)) 206 fprintf (fp, "%s(%s)", abfd->my_archive->filename, 207 abfd->filename); 208 else 209 fprintf (fp, "%s", abfd->filename); 210 } 211 break; 212 213 case 'F': 214 /* Error is fatal. */ 215 fatal = TRUE; 216 break; 217 218 case 'P': 219 /* Print program name. */ 220 fprintf (fp, "%s", program_name); 221 break; 222 223 case 'E': 224 /* current bfd error or errno */ 225 fprintf (fp, "%s", bfd_errmsg (bfd_get_error ())); 226 break; 227 228 case 'I': 229 /* filename from a lang_input_statement_type */ 230 { 231 lang_input_statement_type *i; 232 233 i = va_arg (arg, lang_input_statement_type *); 234 if (i->the_bfd->my_archive != NULL 235 && !bfd_is_thin_archive (i->the_bfd->my_archive)) 236 fprintf (fp, "(%s)", 237 bfd_get_filename (i->the_bfd->my_archive)); 238 fprintf (fp, "%s", i->local_sym_name); 239 if ((i->the_bfd->my_archive == NULL 240 || bfd_is_thin_archive (i->the_bfd->my_archive)) 241 && filename_cmp (i->local_sym_name, i->filename) != 0) 242 fprintf (fp, " (%s)", i->filename); 243 } 244 break; 245 246 case 'S': 247 /* Print script file and linenumber. */ 248 { 249 etree_type node; 250 etree_type *tp = va_arg (arg, etree_type *); 251 252 if (tp == NULL) 253 { 254 tp = &node; 255 tp->type.filename = ldlex_filename (); 256 tp->type.lineno = lineno; 257 } 258 if (tp->type.filename != NULL) 259 fprintf (fp, "%s:%u", tp->type.filename, tp->type.lineno); 260 } 261 break; 262 263 case 'R': 264 /* Print all that's interesting about a relent. */ 265 { 266 arelent *relent = va_arg (arg, arelent *); 267 268 lfinfo (fp, "%s+0x%v (type %s)", 269 (*(relent->sym_ptr_ptr))->name, 270 relent->addend, 271 relent->howto->name); 272 } 273 break; 274 275 case 'C': 276 case 'D': 277 case 'G': 278 case 'H': 279 /* Clever filename:linenumber with function name if possible. 280 The arguments are a BFD, a section, and an offset. */ 281 { 282 static bfd *last_bfd; 283 static char *last_file = NULL; 284 static char *last_function = NULL; 285 bfd *abfd; 286 asection *section; 287 bfd_vma offset; 288 asymbol **asymbols = NULL; 289 const char *filename; 290 const char *functionname; 291 unsigned int linenumber; 292 bfd_boolean discard_last; 293 bfd_boolean done; 294 295 abfd = va_arg (arg, bfd *); 296 section = va_arg (arg, asection *); 297 offset = va_arg (arg, bfd_vma); 298 299 if (abfd != NULL) 300 { 301 if (!bfd_generic_link_read_symbols (abfd)) 302 einfo (_("%B%F: could not read symbols: %E\n"), abfd); 303 304 asymbols = bfd_get_outsymbols (abfd); 305 } 306 307 /* The GNU Coding Standard requires that error messages 308 be of the form: 309 310 source-file-name:lineno: message 311 312 We do not always have a line number available so if 313 we cannot find them we print out the section name and 314 offset instead. */ 315 discard_last = TRUE; 316 if (abfd != NULL 317 && bfd_find_nearest_line (abfd, section, asymbols, offset, 318 &filename, &functionname, 319 &linenumber)) 320 { 321 if (functionname != NULL 322 && (fmt[-1] == 'C' || fmt[-1] == 'H')) 323 { 324 /* Detect the case where we are printing out a 325 message for the same function as the last 326 call to vinfo ("%C"). In this situation do 327 not print out the ABFD filename or the 328 function name again. Note - we do still 329 print out the source filename, as this will 330 allow programs that parse the linker's output 331 (eg emacs) to correctly locate multiple 332 errors in the same source file. */ 333 if (last_bfd == NULL 334 || last_file == NULL 335 || last_function == NULL 336 || last_bfd != abfd 337 || (filename != NULL 338 && filename_cmp (last_file, filename) != 0) 339 || strcmp (last_function, functionname) != 0) 340 { 341 lfinfo (fp, _("%B: In function `%T':\n"), 342 abfd, functionname); 343 344 last_bfd = abfd; 345 if (last_file != NULL) 346 free (last_file); 347 last_file = NULL; 348 if (filename) 349 last_file = xstrdup (filename); 350 if (last_function != NULL) 351 free (last_function); 352 last_function = xstrdup (functionname); 353 } 354 discard_last = FALSE; 355 } 356 else 357 lfinfo (fp, "%B:", abfd); 358 359 if (filename != NULL) 360 fprintf (fp, "%s:", filename); 361 362 done = fmt[-1] != 'H'; 363 if (functionname != NULL && fmt[-1] == 'G') 364 lfinfo (fp, "%T", functionname); 365 else if (filename != NULL && linenumber != 0) 366 fprintf (fp, "%u%s", linenumber, done ? "" : ":"); 367 else 368 done = FALSE; 369 } 370 else 371 { 372 lfinfo (fp, "%B:", abfd); 373 done = FALSE; 374 } 375 if (!done) 376 lfinfo (fp, "(%A+0x%v)", section, offset); 377 378 if (discard_last) 379 { 380 last_bfd = NULL; 381 if (last_file != NULL) 382 { 383 free (last_file); 384 last_file = NULL; 385 } 386 if (last_function != NULL) 387 { 388 free (last_function); 389 last_function = NULL; 390 } 391 } 392 } 393 break; 394 395 case 'p': 396 /* native (host) void* pointer, like printf */ 397 fprintf (fp, "%p", va_arg (arg, void *)); 398 break; 399 400 case 's': 401 /* arbitrary string, like printf */ 402 fprintf (fp, "%s", va_arg (arg, char *)); 403 break; 404 405 case 'd': 406 /* integer, like printf */ 407 fprintf (fp, "%d", va_arg (arg, int)); 408 break; 409 410 case 'u': 411 /* unsigned integer, like printf */ 412 fprintf (fp, "%u", va_arg (arg, unsigned int)); 413 break; 414 415 case 'l': 416 if (*fmt == 'd') 417 { 418 fprintf (fp, "%ld", va_arg (arg, long)); 419 ++fmt; 420 break; 421 } 422 else if (*fmt == 'u') 423 { 424 fprintf (fp, "%lu", va_arg (arg, unsigned long)); 425 ++fmt; 426 break; 427 } 428 /* Fall thru */ 429 430 default: 431 fprintf (fp, "%%%c", fmt[-1]); 432 break; 433 } 434 } 435 } 436 437 if (is_warning && config.fatal_warnings) 438 config.make_executable = FALSE; 439 440 if (fatal) 441 xexit (1); 442 } 443 444 /* Format info message and print on stdout. */ 445 446 /* (You would think this should be called just "info", but then you 447 would be hosed by LynxOS, which defines that name in its libc.) */ 448 449 void 450 info_msg (const char *fmt, ...) 451 { 452 va_list arg; 453 454 va_start (arg, fmt); 455 vfinfo (stdout, fmt, arg, FALSE); 456 va_end (arg); 457 } 458 459 /* ('e' for error.) Format info message and print on stderr. */ 460 461 void 462 einfo (const char *fmt, ...) 463 { 464 va_list arg; 465 466 fflush (stdout); 467 va_start (arg, fmt); 468 vfinfo (stderr, fmt, arg, TRUE); 469 va_end (arg); 470 fflush (stderr); 471 } 472 473 void 474 info_assert (const char *file, unsigned int line) 475 { 476 einfo (_("%F%P: internal error %s %d\n"), file, line); 477 } 478 479 /* ('m' for map) Format info message and print on map. */ 480 481 void 482 minfo (const char *fmt, ...) 483 { 484 if (config.map_file != NULL) 485 { 486 va_list arg; 487 488 va_start (arg, fmt); 489 if (fmt[0] == '%' && fmt[1] == '!' && fmt[2] == 0) 490 { 491 /* Stash info about --as-needed shared libraries. Print 492 later so they don't appear intermingled with archive 493 library info. */ 494 struct asneeded_minfo *m = xmalloc (sizeof *m); 495 496 m->next = NULL; 497 m->soname = va_arg (arg, const char *); 498 m->ref = va_arg (arg, bfd *); 499 m->name = va_arg (arg, const char *); 500 *asneeded_list_tail = m; 501 asneeded_list_tail = &m->next; 502 } 503 else 504 vfinfo (config.map_file, fmt, arg, FALSE); 505 va_end (arg); 506 } 507 } 508 509 void 510 lfinfo (FILE *file, const char *fmt, ...) 511 { 512 va_list arg; 513 514 va_start (arg, fmt); 515 vfinfo (file, fmt, arg, FALSE); 516 va_end (arg); 517 } 518 519 /* Functions to print the link map. */ 521 522 void 523 print_space (void) 524 { 525 fprintf (config.map_file, " "); 526 } 527 528 void 529 print_nl (void) 530 { 531 fprintf (config.map_file, "\n"); 532 } 533 534 /* A more or less friendly abort message. In ld.h abort is defined to 535 call this function. */ 536 537 void 538 ld_abort (const char *file, int line, const char *fn) 539 { 540 if (fn != NULL) 541 einfo (_("%P: internal error: aborting at %s:%d in %s\n"), 542 file, line, fn); 543 else 544 einfo (_("%P: internal error: aborting at %s:%d\n"), 545 file, line); 546 einfo (_("%P%F: please report this bug\n")); 547 xexit (1); 548 } 549