1 /* ldmisc.c 2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 3 2000, 2002, 2003 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, 59 Temple Place - Suite 330, Boston, MA 22 02111-1307, 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 39 /* 40 %% literal % 41 %F error is fatal 42 %P print program name 43 %S print script file and linenumber 44 %E current bfd error or errno 45 %I filename from a lang_input_statement_type 46 %B filename from a bfd 47 %T symbol name 48 %X no object output, fail return 49 %V hex bfd_vma 50 %v hex bfd_vma, no leading zeros 51 %W hex bfd_vma with 0x with no leading zeros taking up 8 spaces 52 %C clever filename:linenumber with function 53 %D like %C, but no function name 54 %G like %D, but only function name 55 %R info about a relent 56 %s arbitrary string, like printf 57 %d integer, like printf 58 %u integer, like printf 59 */ 60 61 static void 62 vfinfo (FILE *fp, const char *fmt, va_list arg) 63 { 64 bfd_boolean fatal = FALSE; 65 66 while (*fmt != '\0') 67 { 68 while (*fmt != '%' && *fmt != '\0') 69 { 70 putc (*fmt, fp); 71 fmt++; 72 } 73 74 if (*fmt == '%') 75 { 76 fmt++; 77 switch (*fmt++) 78 { 79 default: 80 fprintf (fp, "%%%c", fmt[-1]); 81 break; 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 'B': 162 /* filename from a bfd */ 163 { 164 bfd *abfd = va_arg (arg, bfd *); 165 if (abfd->my_archive) 166 fprintf (fp, "%s(%s)", abfd->my_archive->filename, 167 abfd->filename); 168 else 169 fprintf (fp, "%s", abfd->filename); 170 } 171 break; 172 173 case 'F': 174 /* Error is fatal. */ 175 fatal = TRUE; 176 break; 177 178 case 'P': 179 /* Print program name. */ 180 fprintf (fp, "%s", program_name); 181 break; 182 183 case 'E': 184 /* current bfd error or errno */ 185 fprintf (fp, "%s", bfd_errmsg (bfd_get_error ())); 186 break; 187 188 case 'I': 189 /* filename from a lang_input_statement_type */ 190 { 191 lang_input_statement_type *i; 192 193 i = va_arg (arg, lang_input_statement_type *); 194 if (bfd_my_archive (i->the_bfd) != NULL) 195 fprintf (fp, "(%s)", 196 bfd_get_filename (bfd_my_archive (i->the_bfd))); 197 fprintf (fp, "%s", i->local_sym_name); 198 if (bfd_my_archive (i->the_bfd) == NULL 199 && strcmp (i->local_sym_name, i->filename) != 0) 200 fprintf (fp, " (%s)", i->filename); 201 } 202 break; 203 204 case 'S': 205 /* Print script file and linenumber. */ 206 if (parsing_defsym) 207 fprintf (fp, "--defsym %s", lex_string); 208 else if (ldfile_input_filename != NULL) 209 fprintf (fp, "%s:%u", ldfile_input_filename, lineno); 210 else 211 fprintf (fp, _("built in linker script:%u"), lineno); 212 break; 213 214 case 'R': 215 /* Print all that's interesting about a relent. */ 216 { 217 arelent *relent = va_arg (arg, arelent *); 218 219 lfinfo (fp, "%s+0x%v (type %s)", 220 (*(relent->sym_ptr_ptr))->name, 221 relent->addend, 222 relent->howto->name); 223 } 224 break; 225 226 case 'C': 227 case 'D': 228 case 'G': 229 /* Clever filename:linenumber with function name if possible. 230 The arguments are a BFD, a section, and an offset. */ 231 { 232 static bfd *last_bfd; 233 static char *last_file = NULL; 234 static char *last_function = NULL; 235 bfd *abfd; 236 asection *section; 237 bfd_vma offset; 238 lang_input_statement_type *entry; 239 asymbol **asymbols; 240 const char *filename; 241 const char *functionname; 242 unsigned int linenumber; 243 bfd_boolean discard_last; 244 245 abfd = va_arg (arg, bfd *); 246 section = va_arg (arg, asection *); 247 offset = va_arg (arg, bfd_vma); 248 249 entry = (lang_input_statement_type *) abfd->usrdata; 250 if (entry != (lang_input_statement_type *) NULL 251 && entry->asymbols != (asymbol **) NULL) 252 asymbols = entry->asymbols; 253 else 254 { 255 long symsize; 256 long symbol_count; 257 258 symsize = bfd_get_symtab_upper_bound (abfd); 259 if (symsize < 0) 260 einfo (_("%B%F: could not read symbols\n"), abfd); 261 asymbols = xmalloc (symsize); 262 symbol_count = bfd_canonicalize_symtab (abfd, asymbols); 263 if (symbol_count < 0) 264 einfo (_("%B%F: could not read symbols\n"), abfd); 265 if (entry != (lang_input_statement_type *) NULL) 266 { 267 entry->asymbols = asymbols; 268 entry->symbol_count = symbol_count; 269 } 270 } 271 272 lfinfo (fp, "%B(%s+0x%v)", abfd, section->name, offset); 273 274 discard_last = TRUE; 275 if (bfd_find_nearest_line (abfd, section, asymbols, offset, 276 &filename, &functionname, 277 &linenumber)) 278 { 279 bfd_boolean need_colon = TRUE; 280 281 if (functionname != NULL && fmt[-1] == 'C') 282 { 283 if (last_bfd == NULL 284 || last_file == NULL 285 || last_function == NULL 286 || last_bfd != abfd 287 || (filename != NULL 288 && strcmp (last_file, filename) != 0) 289 || strcmp (last_function, functionname) != 0) 290 { 291 lfinfo (fp, _(": In function `%T':\n"), 292 functionname); 293 need_colon = FALSE; 294 295 last_bfd = abfd; 296 if (last_file != NULL) 297 free (last_file); 298 last_file = NULL; 299 if (filename) 300 last_file = xstrdup (filename); 301 if (last_function != NULL) 302 free (last_function); 303 last_function = xstrdup (functionname); 304 } 305 discard_last = FALSE; 306 } 307 308 if (filename != NULL) 309 { 310 if (need_colon) 311 putc (':', fp); 312 fputs (filename, fp); 313 } 314 315 if (functionname != NULL && fmt[-1] == 'G') 316 lfinfo (fp, ":%T", functionname); 317 else if (filename != NULL && linenumber != 0) 318 fprintf (fp, ":%u", linenumber); 319 } 320 321 if (asymbols != NULL && entry == NULL) 322 free (asymbols); 323 324 if (discard_last) 325 { 326 last_bfd = NULL; 327 if (last_file != NULL) 328 { 329 free (last_file); 330 last_file = NULL; 331 } 332 if (last_function != NULL) 333 { 334 free (last_function); 335 last_function = NULL; 336 } 337 } 338 } 339 break; 340 341 case 's': 342 /* arbitrary string, like printf */ 343 fprintf (fp, "%s", va_arg (arg, char *)); 344 break; 345 346 case 'd': 347 /* integer, like printf */ 348 fprintf (fp, "%d", va_arg (arg, int)); 349 break; 350 351 case 'u': 352 /* unsigned integer, like printf */ 353 fprintf (fp, "%u", va_arg (arg, unsigned int)); 354 break; 355 } 356 } 357 } 358 359 if (config.fatal_warnings) 360 config.make_executable = FALSE; 361 362 if (fatal) 363 xexit (1); 364 } 365 366 /* Wrapper around cplus_demangle. Strips leading underscores and 367 other such chars that would otherwise confuse the demangler. */ 368 369 char * 370 demangle (const char *name) 371 { 372 char *res; 373 const char *p; 374 375 if (output_bfd != NULL 376 && bfd_get_symbol_leading_char (output_bfd) == name[0]) 377 ++name; 378 379 /* This is a hack for better error reporting on XCOFF, PowerPC64-ELF 380 or the MS PE format. These formats have a number of leading '.'s 381 on at least some symbols, so we remove all dots to avoid 382 confusing the demangler. */ 383 p = name; 384 while (*p == '.') 385 ++p; 386 387 res = cplus_demangle (p, DMGL_ANSI | DMGL_PARAMS); 388 if (res) 389 { 390 size_t dots = p - name; 391 392 /* Now put back any stripped dots. */ 393 if (dots != 0) 394 { 395 size_t len = strlen (res) + 1; 396 char *add_dots = xmalloc (len + dots); 397 398 memcpy (add_dots, name, dots); 399 memcpy (add_dots + dots, res, len); 400 free (res); 401 res = add_dots; 402 } 403 return res; 404 } 405 return xstrdup (name); 406 } 407 408 /* Format info message and print on stdout. */ 409 410 /* (You would think this should be called just "info", but then you 411 would be hosed by LynxOS, which defines that name in its libc.) */ 412 413 void 414 info_msg (const char *fmt, ...) 415 { 416 va_list arg; 417 418 va_start (arg, fmt); 419 vfinfo (stdout, fmt, arg); 420 va_end (arg); 421 } 422 423 /* ('e' for error.) Format info message and print on stderr. */ 424 425 void 426 einfo (const char *fmt, ...) 427 { 428 va_list arg; 429 char buf[BUFSIZ]; 430 431 setvbuf(stderr, buf, _IOFBF, sizeof(buf)); 432 va_start (arg, fmt); 433 vfinfo (stderr, fmt, arg); 434 va_end (arg); 435 fflush(stderr); 436 setvbuf(stderr, NULL, _IONBF, 0); 437 } 438 439 void 440 info_assert (const char *file, unsigned int line) 441 { 442 einfo (_("%F%P: internal error %s %d\n"), file, line); 443 } 444 445 /* ('m' for map) Format info message and print on map. */ 446 447 void 448 minfo (const char *fmt, ...) 449 { 450 va_list arg; 451 452 va_start (arg, fmt); 453 vfinfo (config.map_file, fmt, arg); 454 va_end (arg); 455 } 456 457 void 458 lfinfo (FILE *file, const char *fmt, ...) 459 { 460 va_list arg; 461 462 va_start (arg, fmt); 463 vfinfo (file, fmt, arg); 464 va_end (arg); 465 } 466 467 /* Functions to print the link map. */ 468 469 void 470 print_space (void) 471 { 472 fprintf (config.map_file, " "); 473 } 474 475 void 476 print_nl (void) 477 { 478 fprintf (config.map_file, "\n"); 479 } 480 481 /* A more or less friendly abort message. In ld.h abort is defined to 482 call this function. */ 483 484 void 485 ld_abort (const char *file, int line, const char *fn) 486 { 487 if (fn != NULL) 488 einfo (_("%P: internal error: aborting at %s line %d in %s\n"), 489 file, line, fn); 490 else 491 einfo (_("%P: internal error: aborting at %s line %d\n"), 492 file, line); 493 einfo (_("%P%F: please report this bug\n")); 494 xexit (1); 495 } 496 497 bfd_boolean 498 error_handler (int id, const char *fmt, ...) 499 { 500 va_list arg; 501 502 va_start (arg, fmt); 503 504 switch (id) 505 { 506 default: 507 break; 508 509 /* We can be called with 510 511 error_handler (-LD_DEFINITION_IN_DISCARDED_SECTION, "", 0); 512 513 to make this error non-fatal and 514 515 error_handler (-LD_DEFINITION_IN_DISCARDED_SECTION, "", 1); 516 517 to make this error fatal. */ 518 case -LD_DEFINITION_IN_DISCARDED_SECTION: 519 case LD_DEFINITION_IN_DISCARDED_SECTION: 520 { 521 static struct bfd_hash_table *hash; 522 static int fatal = 1; 523 const char *name; 524 525 if (id == -LD_DEFINITION_IN_DISCARDED_SECTION) 526 { 527 fatal = va_arg (arg, int); 528 goto out; 529 } 530 531 name = va_arg (arg, const char *); 532 /* Only warn once about a particular undefined symbol. */ 533 if (hash == NULL) 534 { 535 hash = xmalloc (sizeof (struct bfd_hash_table)); 536 if (! bfd_hash_table_init (hash, bfd_hash_newfunc)) 537 einfo (_("%F%P: bfd_hash_table_init failed: %E\n")); 538 } 539 540 if (bfd_hash_lookup (hash, name, FALSE, FALSE) != NULL) 541 goto out; 542 543 if (bfd_hash_lookup (hash, name, TRUE, TRUE) == NULL) 544 einfo (_("%F%P: bfd_hash_lookup failed: %E\n")); 545 546 if (fatal) 547 config.make_executable = FALSE; 548 } 549 break; 550 } 551 vfinfo (stderr, fmt, arg); 552 553 out: 554 va_end (arg); 555 return TRUE; 556 } 557