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