1 /* ldmisc.c 2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 3 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2010, 2011, 2012 4 Free Software Foundation, Inc. 5 Written by Steve Chamberlain of Cygnus Support. 6 7 This file is part of the GNU Binutils. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program; if not, write to the Free Software 21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 22 MA 02110-1301, USA. */ 23 24 #include "sysdep.h" 25 #include "bfd.h" 26 #include "bfdlink.h" 27 #include "libiberty.h" 28 #include "filenames.h" 29 #include "demangle.h" 30 #include <stdarg.h> 31 #include "ld.h" 32 #include "ldmisc.h" 33 #include "ldexp.h" 34 #include "ldlang.h" 35 #include <ldgram.h> 36 #include "ldlex.h" 37 #include "ldmain.h" 38 #include "ldfile.h" 39 #include "elf-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 arg, bfd_boolean is_warning) 70 { 71 bfd_boolean fatal = FALSE; 72 73 while (*fmt != '\0') 74 { 75 const char *str = fmt; 76 while (*fmt != '%' && *fmt != '\0') 77 fmt++; 78 if (fmt != str) 79 if (fwrite (str, 1, fmt - str, fp)) 80 { 81 /* Ignore. */ 82 } 83 84 if (*fmt == '%') 85 { 86 fmt++; 87 switch (*fmt++) 88 { 89 case '%': 90 /* literal % */ 91 putc ('%', fp); 92 break; 93 94 case 'X': 95 /* no object output, fail return */ 96 config.make_executable = FALSE; 97 break; 98 99 case 'V': 100 /* hex bfd_vma */ 101 { 102 bfd_vma value = va_arg (arg, bfd_vma); 103 fprintf_vma (fp, value); 104 } 105 break; 106 107 case 'v': 108 /* hex bfd_vma, no leading zeros */ 109 { 110 char buf[100]; 111 char *p = buf; 112 bfd_vma value = va_arg (arg, bfd_vma); 113 sprintf_vma (p, value); 114 while (*p == '0') 115 p++; 116 if (!*p) 117 p--; 118 fputs (p, fp); 119 } 120 break; 121 122 case 'W': 123 /* hex bfd_vma with 0x with no leading zeroes taking up 124 8 spaces. */ 125 { 126 char buf[100]; 127 bfd_vma value; 128 char *p; 129 int len; 130 131 value = va_arg (arg, bfd_vma); 132 sprintf_vma (buf, value); 133 for (p = buf; *p == '0'; ++p) 134 ; 135 if (*p == '\0') 136 --p; 137 len = strlen (p); 138 while (len < 8) 139 { 140 putc (' ', fp); 141 ++len; 142 } 143 fprintf (fp, "0x%s", p); 144 } 145 break; 146 147 case 'T': 148 /* Symbol name. */ 149 { 150 const char *name = va_arg (arg, const char *); 151 152 if (name == NULL || *name == 0) 153 { 154 fprintf (fp, _("no symbol")); 155 break; 156 } 157 else if (demangling) 158 { 159 char *demangled; 160 161 demangled = bfd_demangle (link_info.output_bfd, name, 162 DMGL_ANSI | DMGL_PARAMS); 163 if (demangled != NULL) 164 { 165 fprintf (fp, "%s", demangled); 166 free (demangled); 167 break; 168 } 169 } 170 fprintf (fp, "%s", name); 171 } 172 break; 173 174 case 'A': 175 /* section name from a section */ 176 { 177 asection *sec = va_arg (arg, asection *); 178 bfd *abfd = sec->owner; 179 const char *group = NULL; 180 struct coff_comdat_info *ci; 181 182 fprintf (fp, "%s", sec->name); 183 if (abfd != NULL 184 && bfd_get_flavour (abfd) == bfd_target_elf_flavour 185 && elf_next_in_group (sec) != NULL 186 && (sec->flags & SEC_GROUP) == 0) 187 group = elf_group_name (sec); 188 else if (abfd != NULL 189 && bfd_get_flavour (abfd) == bfd_target_coff_flavour 190 && (ci = bfd_coff_get_comdat_section (sec->owner, 191 sec)) != NULL) 192 group = ci->name; 193 if (group != NULL) 194 fprintf (fp, "[%s]", group); 195 } 196 break; 197 198 case 'B': 199 /* filename from a bfd */ 200 { 201 bfd *abfd = va_arg (arg, bfd *); 202 203 if (abfd == NULL) 204 fprintf (fp, "%s generated", program_name); 205 else if (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 (bfd_my_archive (i->the_bfd) != NULL) 235 fprintf (fp, "(%s)", 236 bfd_get_filename (bfd_my_archive (i->the_bfd))); 237 fprintf (fp, "%s", i->local_sym_name); 238 if (bfd_my_archive (i->the_bfd) == NULL 239 && filename_cmp (i->local_sym_name, i->filename) != 0) 240 fprintf (fp, " (%s)", i->filename); 241 } 242 break; 243 244 case 'S': 245 /* Print script file and linenumber. */ 246 { 247 etree_type node; 248 etree_type *tp = va_arg (arg, etree_type *); 249 250 if (tp == NULL) 251 { 252 tp = &node; 253 tp->type.filename = ldlex_filename (); 254 tp->type.lineno = lineno; 255 } 256 if (tp->type.filename != NULL) 257 fprintf (fp, "%s:%u", tp->type.filename, tp->type.lineno); 258 } 259 break; 260 261 case 'R': 262 /* Print all that's interesting about a relent. */ 263 { 264 arelent *relent = va_arg (arg, arelent *); 265 266 lfinfo (fp, "%s+0x%v (type %s)", 267 (*(relent->sym_ptr_ptr))->name, 268 relent->addend, 269 relent->howto->name); 270 } 271 break; 272 273 case 'C': 274 case 'D': 275 case 'G': 276 case 'H': 277 /* Clever filename:linenumber with function name if possible. 278 The arguments are a BFD, a section, and an offset. */ 279 { 280 static bfd *last_bfd; 281 static char *last_file = NULL; 282 static char *last_function = NULL; 283 bfd *abfd; 284 asection *section; 285 bfd_vma offset; 286 asymbol **asymbols = NULL; 287 const char *filename; 288 const char *functionname; 289 unsigned int linenumber; 290 bfd_boolean discard_last; 291 bfd_boolean done; 292 293 abfd = va_arg (arg, bfd *); 294 section = va_arg (arg, asection *); 295 offset = va_arg (arg, bfd_vma); 296 297 if (abfd != NULL) 298 { 299 if (!bfd_generic_link_read_symbols (abfd)) 300 einfo (_("%B%F: could not read symbols: %E\n"), abfd); 301 302 asymbols = bfd_get_outsymbols (abfd); 303 } 304 305 /* The GNU Coding Standard requires that error messages 306 be of the form: 307 308 source-file-name:lineno: message 309 310 We do not always have a line number available so if 311 we cannot find them we print out the section name and 312 offset instead. */ 313 discard_last = TRUE; 314 if (abfd != NULL 315 && bfd_find_nearest_line (abfd, section, asymbols, offset, 316 &filename, &functionname, 317 &linenumber)) 318 { 319 if (functionname != NULL 320 && (fmt[-1] == 'C' || fmt[-1] == 'H')) 321 { 322 /* Detect the case where we are printing out a 323 message for the same function as the last 324 call to vinfo ("%C"). In this situation do 325 not print out the ABFD filename or the 326 function name again. Note - we do still 327 print out the source filename, as this will 328 allow programs that parse the linker's output 329 (eg emacs) to correctly locate multiple 330 errors in the same source file. */ 331 if (last_bfd == NULL 332 || last_file == NULL 333 || last_function == NULL 334 || last_bfd != abfd 335 || (filename != NULL 336 && filename_cmp (last_file, filename) != 0) 337 || strcmp (last_function, functionname) != 0) 338 { 339 lfinfo (fp, _("%B: In function `%T':\n"), 340 abfd, functionname); 341 342 last_bfd = abfd; 343 if (last_file != NULL) 344 free (last_file); 345 last_file = NULL; 346 if (filename) 347 last_file = xstrdup (filename); 348 if (last_function != NULL) 349 free (last_function); 350 last_function = xstrdup (functionname); 351 } 352 discard_last = FALSE; 353 } 354 else 355 lfinfo (fp, "%B:", abfd); 356 357 if (filename != NULL) 358 fprintf (fp, "%s:", filename); 359 360 done = fmt[-1] != 'H'; 361 if (functionname != NULL && fmt[-1] == 'G') 362 lfinfo (fp, "%T", functionname); 363 else if (filename != NULL && linenumber != 0) 364 fprintf (fp, "%u%s", linenumber, ":" + done); 365 else 366 done = FALSE; 367 } 368 else 369 { 370 lfinfo (fp, "%B:", abfd); 371 done = FALSE; 372 } 373 if (!done) 374 lfinfo (fp, "(%A+0x%v)", section, offset); 375 376 if (discard_last) 377 { 378 last_bfd = NULL; 379 if (last_file != NULL) 380 { 381 free (last_file); 382 last_file = NULL; 383 } 384 if (last_function != NULL) 385 { 386 free (last_function); 387 last_function = NULL; 388 } 389 } 390 } 391 break; 392 393 case 'p': 394 /* native (host) void* pointer, like printf */ 395 fprintf (fp, "%p", va_arg (arg, void *)); 396 break; 397 398 case 's': 399 /* arbitrary string, like printf */ 400 fprintf (fp, "%s", va_arg (arg, char *)); 401 break; 402 403 case 'd': 404 /* integer, like printf */ 405 fprintf (fp, "%d", va_arg (arg, int)); 406 break; 407 408 case 'u': 409 /* unsigned integer, like printf */ 410 fprintf (fp, "%u", va_arg (arg, unsigned int)); 411 break; 412 413 case 'l': 414 if (*fmt == 'd') 415 { 416 fprintf (fp, "%ld", va_arg (arg, long)); 417 ++fmt; 418 break; 419 } 420 else if (*fmt == 'u') 421 { 422 fprintf (fp, "%lu", va_arg (arg, unsigned long)); 423 ++fmt; 424 break; 425 } 426 /* Fall thru */ 427 428 default: 429 fprintf (fp, "%%%c", fmt[-1]); 430 break; 431 } 432 } 433 } 434 435 if (is_warning && config.fatal_warnings) 436 config.make_executable = FALSE; 437 438 if (fatal) 439 xexit (1); 440 } 441 442 /* Format info message and print on stdout. */ 443 444 /* (You would think this should be called just "info", but then you 445 would be hosed by LynxOS, which defines that name in its libc.) */ 446 447 void 448 info_msg (const char *fmt, ...) 449 { 450 va_list arg; 451 452 va_start (arg, fmt); 453 vfinfo (stdout, fmt, arg, FALSE); 454 va_end (arg); 455 } 456 457 /* ('e' for error.) Format info message and print on stderr. */ 458 459 void 460 einfo (const char *fmt, ...) 461 { 462 va_list arg; 463 464 fflush (stdout); 465 va_start (arg, fmt); 466 vfinfo (stderr, fmt, arg, TRUE); 467 va_end (arg); 468 fflush (stderr); 469 } 470 471 void 472 info_assert (const char *file, unsigned int line) 473 { 474 einfo (_("%F%P: internal error %s %d\n"), file, line); 475 } 476 477 /* ('m' for map) Format info message and print on map. */ 478 479 void 480 minfo (const char *fmt, ...) 481 { 482 if (config.map_file != NULL) 483 { 484 va_list arg; 485 486 va_start (arg, fmt); 487 vfinfo (config.map_file, fmt, arg, FALSE); 488 va_end (arg); 489 } 490 } 491 492 void 493 lfinfo (FILE *file, const char *fmt, ...) 494 { 495 va_list arg; 496 497 va_start (arg, fmt); 498 vfinfo (file, fmt, arg, FALSE); 499 va_end (arg); 500 } 501 502 /* Functions to print the link map. */ 503 504 void 505 print_space (void) 506 { 507 fprintf (config.map_file, " "); 508 } 509 510 void 511 print_nl (void) 512 { 513 fprintf (config.map_file, "\n"); 514 } 515 516 /* A more or less friendly abort message. In ld.h abort is defined to 517 call this function. */ 518 519 void 520 ld_abort (const char *file, int line, const char *fn) 521 { 522 if (fn != NULL) 523 einfo (_("%P: internal error: aborting at %s line %d in %s\n"), 524 file, line, fn); 525 else 526 einfo (_("%P: internal error: aborting at %s line %d\n"), 527 file, line); 528 einfo (_("%P%F: please report this bug\n")); 529 xexit (1); 530 } 531