Subversion Repositories Kolibri OS

Rev

Rev 5197 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
5197 serge 1
/* Generic BFD support for file formats.
6324 serge 2
   Copyright (C) 1990-2015 Free Software Foundation, Inc.
5197 serge 3
   Written by Cygnus Support.
4
 
5
   This file is part of BFD, the Binary File Descriptor library.
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
 
23
/*
24
SECTION
25
	File formats
26
 
27
	A format is a BFD concept of high level file contents type. The
28
	formats supported by BFD are:
29
 
30
	o <>
31
 
32
	The BFD may contain data, symbols, relocations and debug info.
33
 
34
	o <>
35
 
36
	The BFD contains other BFDs and an optional index.
37
 
38
	o <>
39
 
40
	The BFD contains the result of an executable core dump.
41
 
42
SUBSECTION
43
	File format functions
44
*/
45
 
46
#include "sysdep.h"
47
#include "bfd.h"
48
#include "libbfd.h"
49
 
50
/* IMPORT from targets.c.  */
51
extern const size_t _bfd_target_vector_entries;
52
 
53
/*
54
FUNCTION
55
	bfd_check_format
56
 
57
SYNOPSIS
58
	bfd_boolean bfd_check_format (bfd *abfd, bfd_format format);
59
 
60
DESCRIPTION
61
	Verify if the file attached to the BFD @var{abfd} is compatible
62
	with the format @var{format} (i.e., one of <>,
63
	<> or <>).
64
 
65
	If the BFD has been set to a specific target before the
66
	call, only the named target and format combination is
67
	checked. If the target has not been set, or has been set to
68
	<>, then all the known target backends is
69
	interrogated to determine a match.  If the default target
70
	matches, it is used.  If not, exactly one target must recognize
71
	the file, or an error results.
72
 
73
	The function returns <> on success, otherwise <>
74
	with one of the following error codes:
75
 
76
	o <> -
77
	if <> is not one of <>, <> or
78
	<>.
79
 
80
	o <> -
81
	if an error occured during a read - even some file mismatches
82
	can cause bfd_error_system_calls.
83
 
84
	o <> -
85
	none of the backends recognised the file format.
86
 
87
	o <> -
88
	more than one backend recognised the file format.
89
*/
90
 
91
bfd_boolean
92
bfd_check_format (bfd *abfd, bfd_format format)
93
{
94
  return bfd_check_format_matches (abfd, format, NULL);
95
}
96
 
97
struct bfd_preserve
98
{
99
  void *marker;
100
  void *tdata;
101
  flagword flags;
102
  const struct bfd_arch_info *arch_info;
103
  struct bfd_section *sections;
104
  struct bfd_section *section_last;
105
  unsigned int section_count;
106
  struct bfd_hash_table section_htab;
107
};
108
 
109
/* When testing an object for compatibility with a particular target
110
   back-end, the back-end object_p function needs to set up certain
111
   fields in the bfd on successfully recognizing the object.  This
112
   typically happens in a piecemeal fashion, with failures possible at
113
   many points.  On failure, the bfd is supposed to be restored to its
114
   initial state, which is virtually impossible.  However, restoring a
115
   subset of the bfd state works in practice.  This function stores
116
   the subset.  */
117
 
118
static bfd_boolean
119
bfd_preserve_save (bfd *abfd, struct bfd_preserve *preserve)
120
{
121
  preserve->tdata = abfd->tdata.any;
122
  preserve->arch_info = abfd->arch_info;
123
  preserve->flags = abfd->flags;
124
  preserve->sections = abfd->sections;
125
  preserve->section_last = abfd->section_last;
126
  preserve->section_count = abfd->section_count;
127
  preserve->section_htab = abfd->section_htab;
128
  preserve->marker = bfd_alloc (abfd, 1);
129
  if (preserve->marker == NULL)
130
    return FALSE;
131
 
132
  return bfd_hash_table_init (&abfd->section_htab, bfd_section_hash_newfunc,
133
			      sizeof (struct section_hash_entry));
134
}
135
 
136
/* Clear out a subset of BFD state.  */
137
 
138
static void
139
bfd_reinit (bfd *abfd)
140
{
141
  abfd->tdata.any = NULL;
142
  abfd->arch_info = &bfd_default_arch_struct;
143
  abfd->flags &= BFD_FLAGS_SAVED;
144
  bfd_section_list_clear (abfd);
145
}
146
 
147
/* Restores bfd state saved by bfd_preserve_save.  */
148
 
149
static void
150
bfd_preserve_restore (bfd *abfd, struct bfd_preserve *preserve)
151
{
152
  bfd_hash_table_free (&abfd->section_htab);
153
 
154
  abfd->tdata.any = preserve->tdata;
155
  abfd->arch_info = preserve->arch_info;
156
  abfd->flags = preserve->flags;
157
  abfd->section_htab = preserve->section_htab;
158
  abfd->sections = preserve->sections;
159
  abfd->section_last = preserve->section_last;
160
  abfd->section_count = preserve->section_count;
161
 
162
  /* bfd_release frees all memory more recently bfd_alloc'd than
163
     its arg, as well as its arg.  */
164
  bfd_release (abfd, preserve->marker);
165
  preserve->marker = NULL;
166
}
167
 
168
/* Called when the bfd state saved by bfd_preserve_save is no longer
169
   needed.  */
170
 
171
static void
172
bfd_preserve_finish (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_preserve *preserve)
173
{
174
  /* It would be nice to be able to free more memory here, eg. old
175
     tdata, but that's not possible since these blocks are sitting
176
     inside bfd_alloc'd memory.  The section hash is on a separate
177
     objalloc.  */
178
  bfd_hash_table_free (&preserve->section_htab);
179
  preserve->marker = NULL;
180
}
181
 
182
/*
183
FUNCTION
184
	bfd_check_format_matches
185
 
186
SYNOPSIS
187
	bfd_boolean bfd_check_format_matches
188
	  (bfd *abfd, bfd_format format, char ***matching);
189
 
190
DESCRIPTION
191
	Like <>, except when it returns FALSE with
192
	<> set to <>.  In that
193
	case, if @var{matching} is not NULL, it will be filled in with
194
	a NULL-terminated list of the names of the formats that matched,
195
	allocated with <>.
196
	Then the user may choose a format and try again.
197
 
198
	When done with the list that @var{matching} points to, the caller
199
	should free it.
200
*/
201
 
202
bfd_boolean
203
bfd_check_format_matches (bfd *abfd, bfd_format format, char ***matching)
204
{
205
  extern const bfd_target binary_vec;
206
  const bfd_target * const *target;
207
  const bfd_target **matching_vector = NULL;
208
  const bfd_target *save_targ, *right_targ, *ar_right_targ, *match_targ;
209
  int match_count, best_count, best_match;
210
  int ar_match_index;
211
  struct bfd_preserve preserve;
212
 
213
  if (matching != NULL)
214
    *matching = NULL;
215
 
216
  if (!bfd_read_p (abfd)
217
      || (unsigned int) abfd->format >= (unsigned int) bfd_type_end)
218
    {
219
      bfd_set_error (bfd_error_invalid_operation);
220
      return FALSE;
221
    }
222
 
223
  if (abfd->format != bfd_unknown)
224
    return abfd->format == format;
225
 
226
  if (matching != NULL || *bfd_associated_vector != NULL)
227
    {
228
      bfd_size_type amt;
229
 
230
      amt = sizeof (*matching_vector) * 2 * _bfd_target_vector_entries;
231
      matching_vector = (const bfd_target **) bfd_malloc (amt);
232
      if (!matching_vector)
233
	return FALSE;
234
    }
235
 
236
  /* Presume the answer is yes.  */
237
  abfd->format = format;
238
  save_targ = abfd->xvec;
239
  preserve.marker = NULL;
240
 
241
  /* If the target type was explicitly specified, just check that target.  */
242
  if (!abfd->target_defaulted)
243
    {
244
      if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)	/* rewind! */
245
	goto err_ret;
246
 
247
      right_targ = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd));
248
 
249
      if (right_targ)
250
	goto ok_ret;
251
 
252
      /* For a long time the code has dropped through to check all
253
	 targets if the specified target was wrong.  I don't know why,
254
	 and I'm reluctant to change it.  However, in the case of an
255
	 archive, it can cause problems.  If the specified target does
256
	 not permit archives (e.g., the binary target), then we should
257
	 not allow some other target to recognize it as an archive, but
258
	 should instead allow the specified target to recognize it as an
259
	 object.  When I first made this change, it broke the PE target,
260
	 because the specified pei-i386 target did not recognize the
261
	 actual pe-i386 archive.  Since there may be other problems of
262
	 this sort, I changed this test to check only for the binary
263
	 target.  */
264
      if (format == bfd_archive && save_targ == &binary_vec)
265
	goto err_unrecog;
266
    }
267
 
268
  /* Since the target type was defaulted, check them all in the hope
269
     that one will be uniquely recognized.  */
270
  right_targ = NULL;
271
  ar_right_targ = NULL;
272
  match_targ = NULL;
273
  best_match = 256;
274
  best_count = 0;
275
  match_count = 0;
276
  ar_match_index = _bfd_target_vector_entries;
277
 
278
  for (target = bfd_target_vector; *target != NULL; target++)
279
    {
280
      const bfd_target *temp;
281
 
282
      /* Don't check the default target twice.  */
283
      if (*target == &binary_vec
284
	  || (!abfd->target_defaulted && *target == save_targ)
285
	  || (*target)->match_priority > best_match)
286
	continue;
287
 
288
      /* If we already tried a match, the bfd is modified and may
289
	 have sections attached, which will confuse the next
290
	 _bfd_check_format call.  */
291
      bfd_reinit (abfd);
292
 
293
      /* Change BFD's target temporarily.  */
294
      abfd->xvec = *target;
295
 
296
      if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
297
	goto err_ret;
298
 
299
      /* If _bfd_check_format neglects to set bfd_error, assume
300
	 bfd_error_wrong_format.  We didn't used to even pay any
301
	 attention to bfd_error, so I suspect that some
302
	 _bfd_check_format might have this problem.  */
303
      bfd_set_error (bfd_error_wrong_format);
304
 
305
      temp = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd));
306
      if (temp)
307
	{
308
	  match_targ = temp;
309
	  if (preserve.marker != NULL)
310
	    bfd_preserve_finish (abfd, &preserve);
311
 
312
	  if (abfd->format != bfd_archive
313
	      || (bfd_has_map (abfd)
314
		  && bfd_get_error () != bfd_error_wrong_object_format))
315
	    {
316
	      /* This format checks out as ok!  */
317
	      right_targ = temp;
318
 
319
	      /* If this is the default target, accept it, even if
320
		 other targets might match.  People who want those
321
		 other targets have to set the GNUTARGET variable.  */
322
	      if (temp == bfd_default_vector[0])
323
		goto ok_ret;
324
 
325
	      if (matching_vector)
326
		matching_vector[match_count] = temp;
327
	      match_count++;
328
 
329
	      if (temp->match_priority < best_match)
330
		{
331
		  best_match = temp->match_priority;
332
		  best_count = 0;
333
		}
334
	      best_count++;
335
	    }
336
	  else
337
	    {
338
	      /* An archive with no armap or objects of the wrong
339
		 type.  We want this target to match if we get no
340
		 better matches.  */
341
	      if (ar_right_targ != bfd_default_vector[0])
342
		ar_right_targ = *target;
343
	      if (matching_vector)
344
		matching_vector[ar_match_index] = *target;
345
	      ar_match_index++;
346
	    }
347
 
348
	  if (!bfd_preserve_save (abfd, &preserve))
349
	    goto err_ret;
350
	}
351
      else if (bfd_get_error () != bfd_error_wrong_format)
352
	goto err_ret;
353
    }
354
 
355
  if (best_count == 1)
356
    match_count = 1;
357
 
358
  if (match_count == 0)
359
    {
360
      /* Try partial matches.  */
361
      right_targ = ar_right_targ;
362
 
363
      if (right_targ == bfd_default_vector[0])
364
	{
365
	  match_count = 1;
366
	}
367
      else
368
	{
369
	  match_count = ar_match_index - _bfd_target_vector_entries;
370
 
371
	  if (matching_vector && match_count > 1)
372
	    memcpy (matching_vector,
373
		    matching_vector + _bfd_target_vector_entries,
374
		    sizeof (*matching_vector) * match_count);
375
	}
376
    }
377
 
378
  /* We have more than one equally good match.  If any of the best
379
     matches is a target in config.bfd targ_defvec or targ_selvecs,
380
     choose it.  */
381
  if (match_count > 1)
382
    {
383
      const bfd_target * const *assoc = bfd_associated_vector;
384
 
385
      while ((right_targ = *assoc++) != NULL)
386
	{
387
	  int i = match_count;
388
 
389
	  while (--i >= 0)
390
	    if (matching_vector[i] == right_targ
391
		&& right_targ->match_priority <= best_match)
392
	      break;
393
 
394
	  if (i >= 0)
395
	    {
396
	      match_count = 1;
397
	      break;
398
	    }
399
	}
400
    }
401
 
402
  /* We still have more than one equally good match, and at least some
403
     of the targets support match priority.  Choose the first of the
404
     best matches.  */
6324 serge 405
  if (matching_vector && match_count > 1 && best_count != match_count)
5197 serge 406
    {
407
      int i;
408
 
409
      for (i = 0; i < match_count; i++)
410
	{
411
	  right_targ = matching_vector[i];
412
	  if (right_targ->match_priority <= best_match)
413
	    break;
414
	}
415
      match_count = 1;
416
    }
417
 
418
  /* There is way too much undoing of half-known state here.  We
419
     really shouldn't iterate on live bfd's.  Note that saving the
420
     whole bfd and restoring it would be even worse; the first thing
421
     you notice is that the cached bfd file position gets out of sync.  */
422
  if (preserve.marker != NULL)
423
    bfd_preserve_restore (abfd, &preserve);
424
 
425
  if (match_count == 1)
426
    {
427
      abfd->xvec = right_targ;
428
      /* If we come out of the loop knowing that the last target that
429
	 matched is the one we want, then ABFD should still be in a usable
430
	 state (except possibly for XVEC).  */
431
      if (match_targ != right_targ)
432
	{
433
	  bfd_reinit (abfd);
434
	  if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
435
	    goto err_ret;
436
	  match_targ = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd));
437
	  BFD_ASSERT (match_targ != NULL);
438
	}
439
 
440
    ok_ret:
441
      /* If the file was opened for update, then `output_has_begun'
442
	 some time ago when the file was created.  Do not recompute
443
	 sections sizes or alignments in _bfd_set_section_contents.
444
	 We can not set this flag until after checking the format,
445
	 because it will interfere with creation of BFD sections.  */
446
      if (abfd->direction == both_direction)
447
	abfd->output_has_begun = TRUE;
448
 
449
      if (matching_vector)
450
	free (matching_vector);
451
 
452
      /* File position has moved, BTW.  */
453
      return TRUE;
454
    }
455
 
456
  if (match_count == 0)
457
    {
458
    err_unrecog:
459
      bfd_set_error (bfd_error_file_not_recognized);
460
    err_ret:
461
      abfd->xvec = save_targ;
462
      abfd->format = bfd_unknown;
463
      if (matching_vector)
464
	free (matching_vector);
465
      if (preserve.marker != NULL)
466
	bfd_preserve_restore (abfd, &preserve);
467
      return FALSE;
468
    }
469
 
470
  /* Restore original target type and format.  */
471
  abfd->xvec = save_targ;
472
  abfd->format = bfd_unknown;
473
  bfd_set_error (bfd_error_file_ambiguously_recognized);
474
 
475
  if (matching)
476
    {
477
      *matching = (char **) matching_vector;
478
      matching_vector[match_count] = NULL;
479
      /* Return target names.  This is a little nasty.  Maybe we
480
	 should do another bfd_malloc?  */
481
      while (--match_count >= 0)
482
	{
483
	  const char *name = matching_vector[match_count]->name;
484
	  *(const char **) &matching_vector[match_count] = name;
485
	}
486
    }
487
  return FALSE;
488
}
489
 
490
/*
491
FUNCTION
492
	bfd_set_format
493
 
494
SYNOPSIS
495
	bfd_boolean bfd_set_format (bfd *abfd, bfd_format format);
496
 
497
DESCRIPTION
498
	This function sets the file format of the BFD @var{abfd} to the
499
	format @var{format}. If the target set in the BFD does not
500
	support the format requested, the format is invalid, or the BFD
501
	is not open for writing, then an error occurs.
502
*/
503
 
504
bfd_boolean
505
bfd_set_format (bfd *abfd, bfd_format format)
506
{
507
  if (bfd_read_p (abfd)
508
      || (unsigned int) abfd->format >= (unsigned int) bfd_type_end)
509
    {
510
      bfd_set_error (bfd_error_invalid_operation);
511
      return FALSE;
512
    }
513
 
514
  if (abfd->format != bfd_unknown)
515
    return abfd->format == format;
516
 
517
  /* Presume the answer is yes.  */
518
  abfd->format = format;
519
 
520
  if (!BFD_SEND_FMT (abfd, _bfd_set_format, (abfd)))
521
    {
522
      abfd->format = bfd_unknown;
523
      return FALSE;
524
    }
525
 
526
  return TRUE;
527
}
528
 
529
/*
530
FUNCTION
531
	bfd_format_string
532
 
533
SYNOPSIS
534
	const char *bfd_format_string (bfd_format format);
535
 
536
DESCRIPTION
537
	Return a pointer to a const string
538
	<>, <>, <>, <>, or <>,
539
	depending upon the value of @var{format}.
540
*/
541
 
542
const char *
543
bfd_format_string (bfd_format format)
544
{
545
  if (((int) format < (int) bfd_unknown)
546
      || ((int) format >= (int) bfd_type_end))
547
    return "invalid";
548
 
549
  switch (format)
550
    {
551
    case bfd_object:
552
      return "object";		/* Linker/assembler/compiler output.  */
553
    case bfd_archive:
554
      return "archive";		/* Object archive file.  */
555
    case bfd_core:
556
      return "core";		/* Core dump.  */
557
    default:
558
      return "unknown";
559
    }
560
}