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