Fix memory leaks
[deliverable/binutils-gdb.git] / bfd / format.c
1 /* Generic BFD support for file formats.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1999, 2000, 2001, 2002, 2003
3 Free Software Foundation, Inc.
4 Written by Cygnus Support.
5
6 This file is part of BFD, the Binary File Descriptor library.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
21
22 /*
23 SECTION
24 File formats
25
26 A format is a BFD concept of high level file contents type. The
27 formats supported by BFD are:
28
29 o <<bfd_object>>
30
31 The BFD may contain data, symbols, relocations and debug info.
32
33 o <<bfd_archive>>
34
35 The BFD contains other BFDs and an optional index.
36
37 o <<bfd_core>>
38
39 The BFD contains the result of an executable core dump.
40
41 */
42
43 #include "bfd.h"
44 #include "sysdep.h"
45 #include "libbfd.h"
46
47 /* IMPORT from targets.c. */
48 extern const size_t _bfd_target_vector_entries;
49
50 /*
51 FUNCTION
52 bfd_check_format
53
54 SYNOPSIS
55 bfd_boolean bfd_check_format (bfd *abfd, bfd_format format);
56
57 DESCRIPTION
58 Verify if the file attached to the BFD @var{abfd} is compatible
59 with the format @var{format} (i.e., one of <<bfd_object>>,
60 <<bfd_archive>> or <<bfd_core>>).
61
62 If the BFD has been set to a specific target before the
63 call, only the named target and format combination is
64 checked. If the target has not been set, or has been set to
65 <<default>>, then all the known target backends is
66 interrogated to determine a match. If the default target
67 matches, it is used. If not, exactly one target must recognize
68 the file, or an error results.
69
70 The function returns <<TRUE>> on success, otherwise <<FALSE>>
71 with one of the following error codes:
72
73 o <<bfd_error_invalid_operation>> -
74 if <<format>> is not one of <<bfd_object>>, <<bfd_archive>> or
75 <<bfd_core>>.
76
77 o <<bfd_error_system_call>> -
78 if an error occured during a read - even some file mismatches
79 can cause bfd_error_system_calls.
80
81 o <<file_not_recognised>> -
82 none of the backends recognised the file format.
83
84 o <<bfd_error_file_ambiguously_recognized>> -
85 more than one backend recognised the file format.
86 */
87
88 bfd_boolean
89 bfd_check_format (abfd, format)
90 bfd *abfd;
91 bfd_format format;
92 {
93 return bfd_check_format_matches (abfd, format, NULL);
94 }
95
96 /*
97 FUNCTION
98 bfd_check_format_matches
99
100 SYNOPSIS
101 bfd_boolean bfd_check_format_matches (bfd *abfd, bfd_format format,
102 char ***matching);
103
104 DESCRIPTION
105 Like <<bfd_check_format>>, except when it returns FALSE with
106 <<bfd_errno>> set to <<bfd_error_file_ambiguously_recognized>>. In that
107 case, if @var{matching} is not NULL, it will be filled in with
108 a NULL-terminated list of the names of the formats that matched,
109 allocated with <<malloc>>.
110 Then the user may choose a format and try again.
111
112 When done with the list that @var{matching} points to, the caller
113 should free it.
114 */
115
116 bfd_boolean
117 bfd_check_format_matches (abfd, format, matching)
118 bfd *abfd;
119 bfd_format format;
120 char ***matching;
121 {
122 extern const bfd_target binary_vec;
123 const bfd_target * const *target;
124 const bfd_target **matching_vector = NULL;
125 const bfd_target *save_targ, *right_targ, *ar_right_targ;
126 int match_count;
127 int ar_match_index;
128
129 if (!bfd_read_p (abfd)
130 || (unsigned int) abfd->format >= (unsigned int) bfd_type_end)
131 {
132 bfd_set_error (bfd_error_invalid_operation);
133 return FALSE;
134 }
135
136 if (abfd->format != bfd_unknown)
137 return abfd->format == format;
138
139 /* Since the target type was defaulted, check them
140 all in the hope that one will be uniquely recognized. */
141 save_targ = abfd->xvec;
142 match_count = 0;
143 ar_match_index = _bfd_target_vector_entries;
144
145 if (matching)
146 {
147 bfd_size_type amt;
148
149 *matching = NULL;
150 amt = sizeof (*matching_vector) * 2 * _bfd_target_vector_entries;
151 matching_vector = (const bfd_target **) bfd_malloc (amt);
152 if (!matching_vector)
153 return FALSE;
154 }
155
156 right_targ = 0;
157 ar_right_targ = 0;
158
159 /* Presume the answer is yes. */
160 abfd->format = format;
161
162 /* If the target type was explicitly specified, just check that target. */
163 if (!abfd->target_defaulted)
164 {
165 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) /* rewind! */
166 {
167 if (matching)
168 free ((PTR) matching_vector);
169 return FALSE;
170 }
171
172 right_targ = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd));
173
174 if (right_targ)
175 {
176 abfd->xvec = right_targ; /* Set the target as returned. */
177
178 if (matching)
179 free ((PTR) matching_vector);
180
181 return TRUE; /* File position has moved, BTW. */
182 }
183
184 /* For a long time the code has dropped through to check all
185 targets if the specified target was wrong. I don't know why,
186 and I'm reluctant to change it. However, in the case of an
187 archive, it can cause problems. If the specified target does
188 not permit archives (e.g., the binary target), then we should
189 not allow some other target to recognize it as an archive, but
190 should instead allow the specified target to recognize it as an
191 object. When I first made this change, it broke the PE target,
192 because the specified pei-i386 target did not recognize the
193 actual pe-i386 archive. Since there may be other problems of
194 this sort, I changed this test to check only for the binary
195 target. */
196 if (format == bfd_archive && save_targ == &binary_vec)
197 {
198 abfd->xvec = save_targ;
199 abfd->format = bfd_unknown;
200
201 if (matching)
202 free ((PTR) matching_vector);
203
204 bfd_set_error (bfd_error_file_not_recognized);
205
206 return FALSE;
207 }
208 }
209
210 for (target = bfd_target_vector; *target != NULL; target++)
211 {
212 const bfd_target *temp;
213 bfd_error_type err;
214
215 if (*target == &binary_vec)
216 continue;
217
218 abfd->xvec = *target; /* Change BFD's target temporarily. */
219
220 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
221 {
222 if (matching)
223 free ((PTR) matching_vector);
224 return FALSE;
225 }
226
227 /* If _bfd_check_format neglects to set bfd_error, assume
228 bfd_error_wrong_format. We didn't used to even pay any
229 attention to bfd_error, so I suspect that some
230 _bfd_check_format might have this problem. */
231 bfd_set_error (bfd_error_wrong_format);
232
233 temp = BFD_SEND_FMT (abfd, _bfd_check_format, (abfd));
234
235 if (temp)
236 {
237 /* This format checks out as ok! */
238 right_targ = temp;
239
240 /* If this is the default target, accept it, even if other
241 targets might match. People who want those other targets
242 have to set the GNUTARGET variable. */
243 if (temp == bfd_default_vector[0])
244 {
245 match_count = 1;
246 break;
247 }
248
249 if (matching)
250 matching_vector[match_count] = temp;
251
252 match_count++;
253
254 #ifdef GNU960
255 /* Big- and little-endian b.out archives look the same, but it
256 doesn't matter: there is no difference in their headers, and
257 member file byte orders will (I hope) be handled appropriately
258 by bfd. Ditto for big and little coff archives. And the 4
259 coff/b.out object formats are unambiguous. So accept the
260 first match we find. */
261 break;
262 #endif
263 }
264 else if ((err = bfd_get_error ()) == bfd_error_wrong_object_format
265 || err == bfd_error_file_ambiguously_recognized)
266 {
267 /* An archive with objects of the wrong type, or an
268 ambiguous match. We want this target to match if we get
269 no better matches. */
270 if (ar_right_targ != bfd_default_vector[0])
271 ar_right_targ = *target;
272 if (matching)
273 matching_vector[ar_match_index] = *target;
274 ar_match_index++;
275 }
276 else if (err != bfd_error_wrong_format)
277 {
278 abfd->xvec = save_targ;
279 abfd->format = bfd_unknown;
280
281 if (matching)
282 free ((PTR) matching_vector);
283
284 return FALSE;
285 }
286 }
287
288 if (match_count == 0)
289 {
290 /* Try partial matches. */
291 right_targ = ar_right_targ;
292
293 if (right_targ == bfd_default_vector[0])
294 {
295 match_count = 1;
296 }
297 else
298 {
299 match_count = ar_match_index - _bfd_target_vector_entries;
300
301 if (matching && match_count > 1)
302 memcpy (matching_vector,
303 matching_vector + _bfd_target_vector_entries,
304 sizeof (*matching_vector) * match_count);
305 }
306 }
307
308 if (match_count > 1 && bfd_associated_vector != NULL)
309 {
310 const bfd_target * const *assoc = bfd_associated_vector;
311
312 while ((right_targ = *assoc++) != NULL)
313 {
314 int i = match_count;
315
316 while (--i >= 0)
317 if (matching_vector[i] == right_targ)
318 break;
319
320 if (i >= 0)
321 {
322 match_count = 1;
323 break;
324 }
325 }
326 }
327
328 if (match_count == 1)
329 {
330 abfd->xvec = right_targ; /* Change BFD's target permanently. */
331
332 if (matching)
333 free ((PTR) matching_vector);
334
335 return TRUE; /* File position has moved, BTW. */
336 }
337
338 abfd->xvec = save_targ; /* Restore original target type. */
339 abfd->format = bfd_unknown; /* Restore original format. */
340
341 if (match_count == 0)
342 {
343 bfd_set_error (bfd_error_file_not_recognized);
344
345 if (matching)
346 free ((PTR) matching_vector);
347 }
348 else
349 {
350 bfd_set_error (bfd_error_file_ambiguously_recognized);
351
352 if (matching)
353 {
354 *matching = (char **) matching_vector;
355 matching_vector[match_count] = NULL;
356 /* Return target names. This is a little nasty. Maybe we
357 should do another bfd_malloc? */
358 while (--match_count >= 0)
359 {
360 const char *name = matching_vector[match_count]->name;
361 *(const char **) &matching_vector[match_count] = name;
362 }
363 }
364 }
365
366 return FALSE;
367 }
368
369 /*
370 FUNCTION
371 bfd_set_format
372
373 SYNOPSIS
374 bfd_boolean bfd_set_format (bfd *abfd, bfd_format format);
375
376 DESCRIPTION
377 This function sets the file format of the BFD @var{abfd} to the
378 format @var{format}. If the target set in the BFD does not
379 support the format requested, the format is invalid, or the BFD
380 is not open for writing, then an error occurs.
381 */
382
383 bfd_boolean
384 bfd_set_format (abfd, format)
385 bfd *abfd;
386 bfd_format format;
387 {
388 if (bfd_read_p (abfd)
389 || (unsigned int) abfd->format >= (unsigned int) bfd_type_end)
390 {
391 bfd_set_error (bfd_error_invalid_operation);
392 return FALSE;
393 }
394
395 if (abfd->format != bfd_unknown)
396 return abfd->format == format;
397
398 /* Presume the answer is yes. */
399 abfd->format = format;
400
401 if (!BFD_SEND_FMT (abfd, _bfd_set_format, (abfd)))
402 {
403 abfd->format = bfd_unknown;
404 return FALSE;
405 }
406
407 return TRUE;
408 }
409
410 /*
411 FUNCTION
412 bfd_format_string
413
414 SYNOPSIS
415 const char *bfd_format_string (bfd_format format);
416
417 DESCRIPTION
418 Return a pointer to a const string
419 <<invalid>>, <<object>>, <<archive>>, <<core>>, or <<unknown>>,
420 depending upon the value of @var{format}.
421 */
422
423 const char *
424 bfd_format_string (format)
425 bfd_format format;
426 {
427 if (((int)format <(int) bfd_unknown)
428 || ((int)format >=(int) bfd_type_end))
429 return "invalid";
430
431 switch (format)
432 {
433 case bfd_object:
434 return "object"; /* Linker/assember/compiler output. */
435 case bfd_archive:
436 return "archive"; /* Object archive file. */
437 case bfd_core:
438 return "core"; /* Core dump. */
439 default:
440 return "unknown";
441 }
442 }
This page took 0.072992 seconds and 4 git commands to generate.