Subversion Repositories Kolibri OS

Rev

Rev 5199 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

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