1 /* ldmisc.c 2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 3 2001, 2002, 2003, 2004, 2005, 2006 4 Free Software Foundation, Inc. 5 Written by Steve Chamberlain of Cygnus Support. 6 7 This file is part of GLD, the Gnu Linker. 8 9 GLD 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 2, or (at your option) 12 any later version. 13 14 GLD 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 GLD; see the file COPYING. If not, write to the Free 21 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA 22 02110-1301, USA. */ 23 24 #include "bfd.h" 25 #include "bfdlink.h" 26 #include "sysdep.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 %s arbitrary string, like printf 61 %u integer, like printf 62 %v hex bfd_vma, no leading zeros 63 */ 64 65 static void 66 vfinfo (FILE *fp, const char *fmt, va_list arg, bfd_boolean is_warning) 67 { 68 bfd_boolean fatal = FALSE; 69 70 while (*fmt != '\0') 71 { 72 while (*fmt != '%' && *fmt != '\0') 73 { 74 putc (*fmt, fp); 75 fmt++; 76 } 77 78 if (*fmt == '%') 79 { 80 fmt++; 81 switch (*fmt++) 82 { 83 case '%': 84 /* literal % */ 85 putc ('%', fp); 86 break; 87 88 case 'X': 89 /* no object output, fail return */ 90 config.make_executable = FALSE; 91 break; 92 93 case 'V': 94 /* hex bfd_vma */ 95 { 96 bfd_vma value = va_arg (arg, bfd_vma); 97 fprintf_vma (fp, value); 98 } 99 break; 100 101 case 'v': 102 /* hex bfd_vma, no leading zeros */ 103 { 104 char buf[100]; 105 char *p = buf; 106 bfd_vma value = va_arg (arg, bfd_vma); 107 sprintf_vma (p, value); 108 while (*p == '0') 109 p++; 110 if (!*p) 111 p--; 112 fputs (p, fp); 113 } 114 break; 115 116 case 'W': 117 /* hex bfd_vma with 0x with no leading zeroes taking up 118 8 spaces. */ 119 { 120 char buf[100]; 121 bfd_vma value; 122 char *p; 123 int len; 124 125 value = va_arg (arg, bfd_vma); 126 sprintf_vma (buf, value); 127 for (p = buf; *p == '0'; ++p) 128 ; 129 if (*p == '\0') 130 --p; 131 len = strlen (p); 132 while (len < 8) 133 { 134 putc (' ', fp); 135 ++len; 136 } 137 fprintf (fp, "0x%s", p); 138 } 139 break; 140 141 case 'T': 142 /* Symbol name. */ 143 { 144 const char *name = va_arg (arg, const char *); 145 146 if (name == NULL || *name == 0) 147 fprintf (fp, _("no symbol")); 148 else if (! demangling) 149 fprintf (fp, "%s", name); 150 else 151 { 152 char *demangled; 153 154 demangled = demangle (name); 155 fprintf (fp, "%s", demangled); 156 free (demangled); 157 } 158 } 159 break; 160 161 case 'A': 162 /* section name from a section */ 163 { 164 asection *sec = va_arg (arg, asection *); 165 bfd *abfd = sec->owner; 166 const char *group = NULL; 167 struct coff_comdat_info *ci; 168 169 fprintf (fp, "%s", sec->name); 170 if (abfd != NULL 171 && bfd_get_flavour (abfd) == bfd_target_elf_flavour 172 && elf_next_in_group (sec) != NULL 173 && (sec->flags & SEC_GROUP) == 0) 174 group = elf_group_name (sec); 175 else if (abfd != NULL 176 && bfd_get_flavour (abfd) == bfd_target_coff_flavour 177 && (ci = bfd_coff_get_comdat_section (sec->owner, 178 sec)) != NULL) 179 group = ci->name; 180 if (group != NULL) 181 fprintf (fp, "[%s]", group); 182 } 183 break; 184 185 case 'B': 186 /* filename from a bfd */ 187 { 188 bfd *abfd = va_arg (arg, bfd *); 189 190 if (abfd == NULL) 191 fprintf (fp, "%s generated", program_name); 192 else if (abfd->my_archive) 193 fprintf (fp, "%s(%s)", abfd->my_archive->filename, 194 abfd->filename); 195 else 196 fprintf (fp, "%s", abfd->filename); 197 } 198 break; 199 200 case 'F': 201 /* Error is fatal. */ 202 fatal = TRUE; 203 break; 204 205 case 'P': 206 /* Print program name. */ 207 fprintf (fp, "%s", program_name); 208 break; 209 210 case 'E': 211 /* current bfd error or errno */ 212 fprintf (fp, "%s", bfd_errmsg (bfd_get_error ())); 213 break; 214 215 case 'I': 216 /* filename from a lang_input_statement_type */ 217 { 218 lang_input_statement_type *i; 219 220 i = va_arg (arg, lang_input_statement_type *); 221 if (bfd_my_archive (i->the_bfd) != NULL) 222 fprintf (fp, "(%s)", 223 bfd_get_filename (bfd_my_archive (i->the_bfd))); 224 fprintf (fp, "%s", i->local_sym_name); 225 if (bfd_my_archive (i->the_bfd) == NULL 226 && strcmp (i->local_sym_name, i->filename) != 0) 227 fprintf (fp, " (%s)", i->filename); 228 } 229 break; 230 231 case 'S': 232 /* Print script file and linenumber. */ 233 if (parsing_defsym) 234 fprintf (fp, "--defsym %s", lex_string); 235 else if (ldfile_input_filename != NULL) 236 fprintf (fp, "%s:%u", ldfile_input_filename, lineno); 237 else 238 fprintf (fp, _("built in linker script:%u"), lineno); 239 break; 240 241 case 'R': 242 /* Print all that's interesting about a relent. */ 243 { 244 arelent *relent = va_arg (arg, arelent *); 245 246 lfinfo (fp, "%s+0x%v (type %s)", 247 (*(relent->sym_ptr_ptr))->name, 248 relent->addend, 249 relent->howto->name); 250 } 251 break; 252 253 case 'C': 254 case 'D': 255 case 'G': 256 /* Clever filename:linenumber with function name if possible. 257 The arguments are a BFD, a section, and an offset. */ 258 { 259 static bfd *last_bfd; 260 static char *last_file = NULL; 261 static char *last_function = NULL; 262 bfd *abfd; 263 asection *section; 264 bfd_vma offset; 265 lang_input_statement_type *entry; 266 asymbol **asymbols; 267 const char *filename; 268 const char *functionname; 269 unsigned int linenumber; 270 bfd_boolean discard_last; 271 272 abfd = va_arg (arg, bfd *); 273 section = va_arg (arg, asection *); 274 offset = va_arg (arg, bfd_vma); 275 276 if (abfd == NULL) 277 { 278 entry = NULL; 279 asymbols = NULL; 280 } 281 else 282 { 283 entry = (lang_input_statement_type *) abfd->usrdata; 284 if (entry != (lang_input_statement_type *) NULL 285 && entry->asymbols != (asymbol **) NULL) 286 asymbols = entry->asymbols; 287 else 288 { 289 long symsize; 290 long sym_count; 291 292 symsize = bfd_get_symtab_upper_bound (abfd); 293 if (symsize < 0) 294 einfo (_("%B%F: could not read symbols\n"), abfd); 295 asymbols = xmalloc (symsize); 296 sym_count = bfd_canonicalize_symtab (abfd, asymbols); 297 if (sym_count < 0) 298 einfo (_("%B%F: could not read symbols\n"), abfd); 299 if (entry != (lang_input_statement_type *) NULL) 300 { 301 entry->asymbols = asymbols; 302 entry->symbol_count = sym_count; 303 } 304 } 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 instread. */ 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 && fmt[-1] == 'C') 322 { 323 /* Detect the case where we are printing out a 324 message for the same function as the last 325 call to vinfo ("%C"). In this situation do 326 not print out the ABFD filename or the 327 function name again. Note - we do still 328 print out the source filename, as this will 329 allow programs that parse the linker's output 330 (eg emacs) to correctly locate multiple 331 errors in the same source file. */ 332 if (last_bfd == NULL 333 || last_file == NULL 334 || last_function == NULL 335 || last_bfd != abfd 336 || (filename != NULL 337 && strcmp (last_file, filename) != 0) 338 || strcmp (last_function, functionname) != 0) 339 { 340 lfinfo (fp, _("%B: In function `%T':\n"), 341 abfd, functionname); 342 343 last_bfd = abfd; 344 if (last_file != NULL) 345 free (last_file); 346 last_file = NULL; 347 if (filename) 348 last_file = xstrdup (filename); 349 if (last_function != NULL) 350 free (last_function); 351 last_function = xstrdup (functionname); 352 } 353 discard_last = FALSE; 354 } 355 else 356 lfinfo (fp, "%B:", abfd); 357 358 if (filename != NULL) 359 fprintf (fp, "%s:", filename); 360 361 if (functionname != NULL && fmt[-1] == 'G') 362 lfinfo (fp, "%T", functionname); 363 else if (filename != NULL && linenumber != 0) 364 fprintf (fp, "%u", linenumber); 365 else 366 lfinfo (fp, "(%A+0x%v)", section, offset); 367 } 368 else 369 lfinfo (fp, "%B:(%A+0x%v)", abfd, section, offset); 370 371 if (asymbols != NULL && entry == NULL) 372 free (asymbols); 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 's': 392 /* arbitrary string, like printf */ 393 fprintf (fp, "%s", va_arg (arg, char *)); 394 break; 395 396 case 'd': 397 /* integer, like printf */ 398 fprintf (fp, "%d", va_arg (arg, int)); 399 break; 400 401 case 'u': 402 /* unsigned integer, like printf */ 403 fprintf (fp, "%u", va_arg (arg, unsigned int)); 404 break; 405 406 case 'l': 407 if (*fmt == 'd') 408 { 409 fprintf (fp, "%ld", va_arg (arg, long)); 410 ++fmt; 411 break; 412 } 413 else if (*fmt == 'u') 414 { 415 fprintf (fp, "%lu", va_arg (arg, unsigned long)); 416 ++fmt; 417 break; 418 } 419 /* Fall thru */ 420 421 default: 422 fprintf (fp, "%%%c", fmt[-1]); 423 break; 424 } 425 } 426 } 427 428 if (is_warning && config.fatal_warnings) 429 config.make_executable = FALSE; 430 431 if (fatal) 432 xexit (1); 433 } 434 435 /* Wrapper around cplus_demangle. Strips leading underscores and 436 other such chars that would otherwise confuse the demangler. */ 437 438 char * 439 demangle (const char *name) 440 { 441 char *res; 442 const char *p; 443 444 if (output_bfd != NULL 445 && bfd_get_symbol_leading_char (output_bfd) == name[0]) 446 ++name; 447 448 /* This is a hack for better error reporting on XCOFF, PowerPC64-ELF 449 or the MS PE format. These formats have a number of leading '.'s 450 on at least some symbols, so we remove all dots to avoid 451 confusing the demangler. */ 452 p = name; 453 while (*p == '.') 454 ++p; 455 456 res = cplus_demangle (p, DMGL_ANSI | DMGL_PARAMS); 457 if (res) 458 { 459 size_t dots = p - name; 460 461 /* Now put back any stripped dots. */ 462 if (dots != 0) 463 { 464 size_t len = strlen (res) + 1; 465 char *add_dots = xmalloc (len + dots); 466 467 memcpy (add_dots, name, dots); 468 memcpy (add_dots + dots, res, len); 469 free (res); 470 res = add_dots; 471 } 472 return res; 473 } 474 return xstrdup (name); 475 } 476 477 /* Format info message and print on stdout. */ 478 479 /* (You would think this should be called just "info", but then you 480 would be hosed by LynxOS, which defines that name in its libc.) */ 481 482 void 483 info_msg (const char *fmt, ...) 484 { 485 va_list arg; 486 487 va_start (arg, fmt); 488 vfinfo (stdout, fmt, arg, FALSE); 489 va_end (arg); 490 } 491 492 /* ('e' for error.) Format info message and print on stderr. */ 493 494 void 495 einfo (const char *fmt, ...) 496 { 497 va_list arg; 498 char buf[BUFSIZ]; 499 500 setvbuf(stderr, buf, _IOFBF, sizeof(buf)); 501 va_start (arg, fmt); 502 vfinfo (stderr, fmt, arg, TRUE); 503 va_end (arg); 504 fflush(stderr); 505 setvbuf(stderr, NULL, _IONBF, 0); 506 } 507 508 void 509 info_assert (const char *file, unsigned int line) 510 { 511 einfo (_("%F%P: internal error %s %d\n"), file, line); 512 } 513 514 /* ('m' for map) Format info message and print on map. */ 515 516 void 517 minfo (const char *fmt, ...) 518 { 519 va_list arg; 520 521 va_start (arg, fmt); 522 vfinfo (config.map_file, fmt, arg, FALSE); 523 va_end (arg); 524 } 525 526 void 527 lfinfo (FILE *file, const char *fmt, ...) 528 { 529 va_list arg; 530 531 va_start (arg, fmt); 532 vfinfo (file, fmt, arg, FALSE); 533 va_end (arg); 534 } 535 536 /* Functions to print the link map. */ 537 538 void 539 print_space (void) 540 { 541 fprintf (config.map_file, " "); 542 } 543 544 void 545 print_nl (void) 546 { 547 fprintf (config.map_file, "\n"); 548 } 549 550 /* A more or less friendly abort message. In ld.h abort is defined to 551 call this function. */ 552 553 void 554 ld_abort (const char *file, int line, const char *fn) 555 { 556 if (fn != NULL) 557 einfo (_("%P: internal error: aborting at %s line %d in %s\n"), 558 file, line, fn); 559 else 560 einfo (_("%P: internal error: aborting at %s line %d\n"), 561 file, line); 562 einfo (_("%P%F: please report this bug\n")); 563 xexit (1); 564 } 565