1/* ldmisc.c 2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 3 2001, 2002, 2003, 2004, 2005, 2006, 2007 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 "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 %s arbitrary string, like printf 61 %u integer, like printf 62 %v hex bfd_vma, no leading zeros 63*/ 64 65static void 66vfinfo (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 { 148 fprintf (fp, _("no symbol")); 149 break; 150 } 151 else if (demangling) 152 { 153 char *demangled; 154 155 demangled = bfd_demangle (output_bfd, name, 156 DMGL_ANSI | DMGL_PARAMS); 157 if (demangled != NULL) 158 { 159 fprintf (fp, "%s", demangled); 160 free (demangled); 161 break; 162 } 163 } 164 fprintf (fp, "%s", name); 165 } 166 break; 167 168 case 'A': 169 /* section name from a section */ 170 { 171 asection *sec = va_arg (arg, asection *); 172 bfd *abfd = sec->owner; 173 const char *group = NULL; 174 struct coff_comdat_info *ci; 175 176 fprintf (fp, "%s", sec->name); 177 if (abfd != NULL 178 && bfd_get_flavour (abfd) == bfd_target_elf_flavour 179 && elf_next_in_group (sec) != NULL 180 && (sec->flags & SEC_GROUP) == 0) 181 group = elf_group_name (sec); 182 else if (abfd != NULL 183 && bfd_get_flavour (abfd) == bfd_target_coff_flavour 184 && (ci = bfd_coff_get_comdat_section (sec->owner, 185 sec)) != NULL) 186 group = ci->name; 187 if (group != NULL) 188 fprintf (fp, "[%s]", group); 189 } 190 break; 191 192 case 'B': 193 /* filename from a bfd */ 194 { 195 bfd *abfd = va_arg (arg, bfd *); 196 197 if (abfd == NULL) 198 fprintf (fp, "%s generated", program_name); 199 else if (abfd->my_archive) 200 fprintf (fp, "%s(%s)", abfd->my_archive->filename, 201 abfd->filename); 202 else 203 fprintf (fp, "%s", abfd->filename); 204 } 205 break; 206 207 case 'F': 208 /* Error is fatal. */ 209 fatal = TRUE; 210 break; 211 212 case 'P': 213 /* Print program name. */ 214 fprintf (fp, "%s", program_name); 215 break; 216 217 case 'E': 218 /* current bfd error or errno */ 219 fprintf (fp, "%s", bfd_errmsg (bfd_get_error ())); 220 break; 221 222 case 'I': 223 /* filename from a lang_input_statement_type */ 224 { 225 lang_input_statement_type *i; 226 227 i = va_arg (arg, lang_input_statement_type *); 228 if (bfd_my_archive (i->the_bfd) != NULL) 229 fprintf (fp, "(%s)", 230 bfd_get_filename (bfd_my_archive (i->the_bfd))); 231 fprintf (fp, "%s", i->local_sym_name); 232 if (bfd_my_archive (i->the_bfd) == NULL 233 && strcmp (i->local_sym_name, i->filename) != 0) 234 fprintf (fp, " (%s)", i->filename); 235 } 236 break; 237 238 case 'S': 239 /* Print script file and linenumber. */ 240 if (parsing_defsym) 241 fprintf (fp, "--defsym %s", lex_string); 242 else if (ldfile_input_filename != NULL) 243 fprintf (fp, "%s:%u", ldfile_input_filename, lineno); 244 else 245 fprintf (fp, _("built in linker script:%u"), lineno); 246 break; 247 248 case 'R': 249 /* Print all that's interesting about a relent. */ 250 { 251 arelent *relent = va_arg (arg, arelent *); 252 253 lfinfo (fp, "%s+0x%v (type %s)", 254 (*(relent->sym_ptr_ptr))->name, 255 relent->addend, 256 relent->howto->name); 257 } 258 break; 259 260 case 'C': 261 case 'D': 262 case 'G': 263 /* Clever filename:linenumber with function name if possible. 264 The arguments are a BFD, a section, and an offset. */ 265 { 266 static bfd *last_bfd; 267 static char *last_file = NULL; 268 static char *last_function = NULL; 269 bfd *abfd; 270 asection *section; 271 bfd_vma offset; 272 lang_input_statement_type *entry; 273 asymbol **asymbols; 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 entry = NULL; 286 asymbols = NULL; 287 } 288 else 289 { 290 entry = (lang_input_statement_type *) abfd->usrdata; 291 if (entry != (lang_input_statement_type *) NULL 292 && entry->asymbols != (asymbol **) NULL) 293 asymbols = entry->asymbols; 294 else 295 { 296 long symsize; 297 long sym_count; 298 299 symsize = bfd_get_symtab_upper_bound (abfd); 300 if (symsize < 0) 301 einfo (_("%B%F: could not read symbols\n"), abfd); 302 asymbols = xmalloc (symsize); 303 sym_count = bfd_canonicalize_symtab (abfd, asymbols); 304 if (sym_count < 0) 305 einfo (_("%B%F: could not read symbols\n"), abfd); 306 if (entry != (lang_input_statement_type *) NULL) 307 { 308 entry->asymbols = asymbols; 309 entry->symbol_count = sym_count; 310 } 311 } 312 } 313 314 /* The GNU Coding Standard requires that error messages 315 be of the form: 316 317 source-file-name:lineno: message 318 319 We do not always have a line number available so if 320 we cannot find them we print out the section name and 321 offset instread. */ 322 discard_last = TRUE; 323 if (abfd != NULL 324 && bfd_find_nearest_line (abfd, section, asymbols, offset, 325 &filename, &functionname, 326 &linenumber)) 327 { 328 if (functionname != NULL && fmt[-1] == 'C') 329 { 330 /* Detect the case where we are printing out a 331 message for the same function as the last 332 call to vinfo ("%C"). In this situation do 333 not print out the ABFD filename or the 334 function name again. Note - we do still 335 print out the source filename, as this will 336 allow programs that parse the linker's output 337 (eg emacs) to correctly locate multiple 338 errors in the same source file. */ 339 if (last_bfd == NULL 340 || last_file == NULL 341 || last_function == NULL 342 || last_bfd != abfd 343 || (filename != NULL 344 && strcmp (last_file, filename) != 0) 345 || strcmp (last_function, functionname) != 0) 346 { 347 lfinfo (fp, _("%B: In function `%T':\n"), 348 abfd, functionname); 349 350 last_bfd = abfd; 351 if (last_file != NULL) 352 free (last_file); 353 last_file = NULL; 354 if (filename) 355 last_file = xstrdup (filename); 356 if (last_function != NULL) 357 free (last_function); 358 last_function = xstrdup (functionname); 359 } 360 discard_last = FALSE; 361 } 362 else 363 lfinfo (fp, "%B:", abfd); 364 365 if (filename != NULL) 366 fprintf (fp, "%s:", filename); 367 368 if (functionname != NULL && fmt[-1] == 'G') 369 lfinfo (fp, "%T", functionname); 370 else if (filename != NULL && linenumber != 0) 371 fprintf (fp, "%u", linenumber); 372 else 373 lfinfo (fp, "(%A+0x%v)", section, offset); 374 } 375 else 376 lfinfo (fp, "%B:(%A+0x%v)", abfd, section, offset); 377 378 if (asymbols != NULL && entry == NULL) 379 free (asymbols); 380 381 if (discard_last) 382 { 383 last_bfd = NULL; 384 if (last_file != NULL) 385 { 386 free (last_file); 387 last_file = NULL; 388 } 389 if (last_function != NULL) 390 { 391 free (last_function); 392 last_function = NULL; 393 } 394 } 395 } 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 447void 448info_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 459void 460einfo (const char *fmt, ...) 461{ 462 va_list arg; 463 464 va_start (arg, fmt); 465 vfinfo (stderr, fmt, arg, TRUE); 466 va_end (arg); 467} 468 469void 470info_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 477void 478minfo (const char *fmt, ...) 479{ 480 if (config.map_file != NULL) 481 { 482 va_list arg; 483 484 va_start (arg, fmt); 485 vfinfo (config.map_file, fmt, arg, FALSE); 486 va_end (arg); 487 } 488} 489 490void 491lfinfo (FILE *file, const char *fmt, ...) 492{ 493 va_list arg; 494 495 va_start (arg, fmt); 496 vfinfo (file, fmt, arg, FALSE); 497 va_end (arg); 498} 499 500/* Functions to print the link map. */ 501 502void 503print_space (void) 504{ 505 fprintf (config.map_file, " "); 506} 507 508void 509print_nl (void) 510{ 511 fprintf (config.map_file, "\n"); 512} 513 514/* A more or less friendly abort message. In ld.h abort is defined to 515 call this function. */ 516 517void 518ld_abort (const char *file, int line, const char *fn) 519{ 520 if (fn != NULL) 521 einfo (_("%P: internal error: aborting at %s line %d in %s\n"), 522 file, line, fn); 523 else 524 einfo (_("%P: internal error: aborting at %s line %d\n"), 525 file, line); 526 einfo (_("%P%F: please report this bug\n")); 527 xexit (1); 528} 529