1 /* ldmisc.c 2 Copyright (C) 1991-2015 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) 205 fprintf (fp, "%s(%s)", abfd->my_archive->filename, 206 abfd->filename); 207 else 208 fprintf (fp, "%s", abfd->filename); 209 } 210 break; 211 212 case 'F': 213 /* Error is fatal. */ 214 fatal = TRUE; 215 break; 216 217 case 'P': 218 /* Print program name. */ 219 fprintf (fp, "%s", program_name); 220 break; 221 222 case 'E': 223 /* current bfd error or errno */ 224 fprintf (fp, "%s", bfd_errmsg (bfd_get_error ())); 225 break; 226 227 case 'I': 228 /* filename from a lang_input_statement_type */ 229 { 230 lang_input_statement_type *i; 231 232 i = va_arg (arg, lang_input_statement_type *); 233 if (bfd_my_archive (i->the_bfd) != NULL) 234 fprintf (fp, "(%s)", 235 bfd_get_filename (bfd_my_archive (i->the_bfd))); 236 fprintf (fp, "%s", i->local_sym_name); 237 if (bfd_my_archive (i->the_bfd) == NULL 238 && filename_cmp (i->local_sym_name, i->filename) != 0) 239 fprintf (fp, " (%s)", i->filename); 240 } 241 break; 242 243 case 'S': 244 /* Print script file and linenumber. */ 245 { 246 etree_type node; 247 etree_type *tp = va_arg (arg, etree_type *); 248 249 if (tp == NULL) 250 { 251 tp = &node; 252 tp->type.filename = ldlex_filename (); 253 tp->type.lineno = lineno; 254 } 255 if (tp->type.filename != NULL) 256 fprintf (fp, "%s:%u", tp->type.filename, tp->type.lineno); 257 } 258 break; 259 260 case 'R': 261 /* Print all that's interesting about a relent. */ 262 { 263 arelent *relent = va_arg (arg, arelent *); 264 265 lfinfo (fp, "%s+0x%v (type %s)", 266 (*(relent->sym_ptr_ptr))->name, 267 relent->addend, 268 relent->howto->name); 269 } 270 break; 271 272 case 'C': 273 case 'D': 274 case 'G': 275 case 'H': 276 /* Clever filename:linenumber with function name if possible. 277 The arguments are a BFD, a section, and an offset. */ 278 { 279 static bfd *last_bfd; 280 static char *last_file = NULL; 281 static char *last_function = NULL; 282 bfd *abfd; 283 asection *section; 284 bfd_vma offset; 285 asymbol **asymbols = NULL; 286 const char *filename; 287 const char *functionname; 288 unsigned int linenumber; 289 bfd_boolean discard_last; 290 bfd_boolean done; 291 292 abfd = va_arg (arg, bfd *); 293 section = va_arg (arg, asection *); 294 offset = va_arg (arg, bfd_vma); 295 296 if (abfd != NULL) 297 { 298 if (!bfd_generic_link_read_symbols (abfd)) 299 einfo (_("%B%F: could not read symbols: %E\n"), abfd); 300 301 asymbols = bfd_get_outsymbols (abfd); 302 } 303 304 /* The GNU Coding Standard requires that error messages 305 be of the form: 306 307 source-file-name:lineno: message 308 309 We do not always have a line number available so if 310 we cannot find them we print out the section name and 311 offset instead. */ 312 discard_last = TRUE; 313 if (abfd != NULL 314 && bfd_find_nearest_line (abfd, section, asymbols, offset, 315 &filename, &functionname, 316 &linenumber)) 317 { 318 if (functionname != NULL 319 && (fmt[-1] == 'C' || fmt[-1] == 'H')) 320 { 321 /* Detect the case where we are printing out a 322 message for the same function as the last 323 call to vinfo ("%C"). In this situation do 324 not print out the ABFD filename or the 325 function name again. Note - we do still 326 print out the source filename, as this will 327 allow programs that parse the linker's output 328 (eg emacs) to correctly locate multiple 329 errors in the same source file. */ 330 if (last_bfd == NULL 331 || last_file == NULL 332 || last_function == NULL 333 || last_bfd != abfd 334 || (filename != NULL 335 && filename_cmp (last_file, filename) != 0) 336 || strcmp (last_function, functionname) != 0) 337 { 338 lfinfo (fp, _("%B: In function `%T':\n"), 339 abfd, functionname); 340 341 last_bfd = abfd; 342 if (last_file != NULL) 343 free (last_file); 344 last_file = NULL; 345 if (filename) 346 last_file = xstrdup (filename); 347 if (last_function != NULL) 348 free (last_function); 349 last_function = xstrdup (functionname); 350 } 351 discard_last = FALSE; 352 } 353 else 354 lfinfo (fp, "%B:", abfd); 355 356 if (filename != NULL) 357 fprintf (fp, "%s:", filename); 358 359 done = fmt[-1] != 'H'; 360 if (functionname != NULL && fmt[-1] == 'G') 361 lfinfo (fp, "%T", functionname); 362 else if (filename != NULL && linenumber != 0) 363 fprintf (fp, "%u%s", linenumber, done ? "" : ":"); 364 else 365 done = FALSE; 366 } 367 else 368 { 369 lfinfo (fp, "%B:", abfd); 370 done = FALSE; 371 } 372 if (!done) 373 lfinfo (fp, "(%A+0x%v)", section, offset); 374 375 if (discard_last) 376 { 377 last_bfd = NULL; 378 if (last_file != NULL) 379 { 380 free (last_file); 381 last_file = NULL; 382 } 383 if (last_function != NULL) 384 { 385 free (last_function); 386 last_function = NULL; 387 } 388 } 389 } 390 break; 391 392 case 'p': 393 /* native (host) void* pointer, like printf */ 394 fprintf (fp, "%p", va_arg (arg, void *)); 395 break; 396 397 case 's': 398 /* arbitrary string, like printf */ 399 fprintf (fp, "%s", va_arg (arg, char *)); 400 break; 401 402 case 'd': 403 /* integer, like printf */ 404 fprintf (fp, "%d", va_arg (arg, int)); 405 break; 406 407 case 'u': 408 /* unsigned integer, like printf */ 409 fprintf (fp, "%u", va_arg (arg, unsigned int)); 410 break; 411 412 case 'l': 413 if (*fmt == 'd') 414 { 415 fprintf (fp, "%ld", va_arg (arg, long)); 416 ++fmt; 417 break; 418 } 419 else if (*fmt == 'u') 420 { 421 fprintf (fp, "%lu", va_arg (arg, unsigned long)); 422 ++fmt; 423 break; 424 } 425 /* Fall thru */ 426 427 default: 428 fprintf (fp, "%%%c", fmt[-1]); 429 break; 430 } 431 } 432 } 433 434 if (is_warning && config.fatal_warnings) 435 config.make_executable = FALSE; 436 437 if (fatal) 438 xexit (1); 439 } 440 441 /* Format info message and print on stdout. */ 442 443 /* (You would think this should be called just "info", but then you 444 would be hosed by LynxOS, which defines that name in its libc.) */ 445 446 void 447 info_msg (const char *fmt, ...) 448 { 449 va_list arg; 450 451 va_start (arg, fmt); 452 vfinfo (stdout, fmt, arg, FALSE); 453 va_end (arg); 454 } 455 456 /* ('e' for error.) Format info message and print on stderr. */ 457 458 void 459 einfo (const char *fmt, ...) 460 { 461 va_list arg; 462 463 fflush (stdout); 464 va_start (arg, fmt); 465 vfinfo (stderr, fmt, arg, TRUE); 466 va_end (arg); 467 fflush (stderr); 468 } 469 470 void 471 info_assert (const char *file, unsigned int line) 472 { 473 einfo (_("%F%P: internal error %s %d\n"), file, line); 474 } 475 476 /* ('m' for map) Format info message and print on map. */ 477 478 void 479 minfo (const char *fmt, ...) 480 { 481 if (config.map_file != NULL) 482 { 483 va_list arg; 484 485 va_start (arg, fmt); 486 if (fmt[0] == '%' && fmt[1] == '!' && fmt[2] == 0) 487 { 488 /* Stash info about --as-needed shared libraries. Print 489 later so they don't appear intermingled with archive 490 library info. */ 491 struct asneeded_minfo *m = xmalloc (sizeof *m); 492 493 m->next = NULL; 494 m->soname = va_arg (arg, const char *); 495 m->ref = va_arg (arg, bfd *); 496 m->name = va_arg (arg, const char *); 497 *asneeded_list_tail = m; 498 asneeded_list_tail = &m->next; 499 } 500 else 501 vfinfo (config.map_file, fmt, arg, FALSE); 502 va_end (arg); 503 } 504 } 505 506 void 507 lfinfo (FILE *file, const char *fmt, ...) 508 { 509 va_list arg; 510 511 va_start (arg, fmt); 512 vfinfo (file, fmt, arg, FALSE); 513 va_end (arg); 514 } 515 516 /* Functions to print the link map. */ 517 518 void 519 print_space (void) 520 { 521 fprintf (config.map_file, " "); 522 } 523 524 void 525 print_nl (void) 526 { 527 fprintf (config.map_file, "\n"); 528 } 529 530 /* A more or less friendly abort message. In ld.h abort is defined to 531 call this function. */ 532 533 void 534 ld_abort (const char *file, int line, const char *fn) 535 { 536 if (fn != NULL) 537 einfo (_("%P: internal error: aborting at %s:%d in %s\n"), 538 file, line, fn); 539 else 540 einfo (_("%P: internal error: aborting at %s:%d\n"), 541 file, line); 542 einfo (_("%P%F: please report this bug\n")); 543 xexit (1); 544 } 545