merge from gcc
[deliverable/binutils-gdb.git] / bfd / bfd.c
CommitLineData
252b5132 1/* Generic BFD library interface and support routines.
7898deda 2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
c067354b 3 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
252b5132
RH
4 Free Software Foundation, Inc.
5 Written by Cygnus Support.
6
3af9a47b 7 This file is part of BFD, the Binary File Descriptor library.
252b5132 8
3af9a47b
NC
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
cd123cb7 11 the Free Software Foundation; either version 3 of the License, or
3af9a47b 12 (at your option) any later version.
252b5132 13
3af9a47b
NC
14 This program 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.
252b5132 18
3af9a47b
NC
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
cd123cb7
NC
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22 MA 02110-1301, USA. */
252b5132
RH
23
24/*
25SECTION
26 <<typedef bfd>>
27
28 A BFD has type <<bfd>>; objects of this type are the
29 cornerstone of any application using BFD. Using BFD
30 consists of making references though the BFD and to data in the BFD.
31
32 Here is the structure that defines the type <<bfd>>. It
33 contains the major data about the file and pointers
34 to the rest of the data.
35
36CODE_FRAGMENT
37.
c2852e88 38.struct bfd
252b5132 39.{
52b69c9e
AO
40. {* A unique identifier of the BFD *}
41. unsigned int id;
42.
b5f79c76
NC
43. {* The filename the application opened the BFD with. *}
44. const char *filename;
252b5132 45.
b5f79c76
NC
46. {* A pointer to the target jump table. *}
47. const struct bfd_target *xvec;
252b5132 48.
40838a72
AC
49. {* The IOSTREAM, and corresponding IO vector that provide access
50. to the file backing the BFD. *}
c58b9523 51. void *iostream;
40838a72 52. const struct bfd_iovec *iovec;
b5f79c76 53.
b5f79c76
NC
54. {* The caching routines use these to maintain a
55. least-recently-used list of BFDs. *}
2ce40c65 56. struct bfd *lru_prev, *lru_next;
b5f79c76
NC
57.
58. {* When a file is closed by the caching routines, BFD retains
59. state information on the file here... *}
60. ufile_ptr where;
61.
b34976b6 62. {* File modified time, if mtime_set is TRUE. *}
b5f79c76
NC
63. long mtime;
64.
65. {* Reserved for an unimplemented file locking extension. *}
66. int ifd;
67.
68. {* The format which belongs to the BFD. (object, core, etc.) *}
69. bfd_format format;
70.
71. {* The direction with which the BFD was opened. *}
72. enum bfd_direction
73. {
74. no_direction = 0,
75. read_direction = 1,
76. write_direction = 2,
77. both_direction = 3
78. }
79. direction;
80.
81. {* Format_specific flags. *}
82. flagword flags;
83.
6ad2759d
L
84. {* Values that may appear in the flags field of a BFD. These also
85. appear in the object_flags field of the bfd_target structure, where
86. they indicate the set of flags used by that backend (not all flags
87. are meaningful for all object file formats) (FIXME: at the moment,
88. the object_flags values have mostly just been copied from backend
89. to another, and are not necessarily correct). *}
90.
91.#define BFD_NO_FLAGS 0x00
92.
93. {* BFD contains relocation entries. *}
94.#define HAS_RELOC 0x01
95.
96. {* BFD is directly executable. *}
97.#define EXEC_P 0x02
98.
99. {* BFD has line number information (basically used for F_LNNO in a
100. COFF header). *}
101.#define HAS_LINENO 0x04
102.
103. {* BFD has debugging information. *}
104.#define HAS_DEBUG 0x08
105.
106. {* BFD has symbols. *}
107.#define HAS_SYMS 0x10
108.
109. {* BFD has local symbols (basically used for F_LSYMS in a COFF
110. header). *}
111.#define HAS_LOCALS 0x20
112.
113. {* BFD is a dynamic object. *}
114.#define DYNAMIC 0x40
115.
116. {* Text section is write protected (if D_PAGED is not set, this is
117. like an a.out NMAGIC file) (the linker sets this by default, but
118. clears it for -r or -N). *}
119.#define WP_TEXT 0x80
120.
121. {* BFD is dynamically paged (this is like an a.out ZMAGIC file) (the
122. linker sets this by default, but clears it for -r or -n or -N). *}
123.#define D_PAGED 0x100
124.
125. {* BFD is relaxable (this means that bfd_relax_section may be able to
126. do something) (sometimes bfd_relax_section can do something even if
127. this is not set). *}
128.#define BFD_IS_RELAXABLE 0x200
129.
130. {* This may be set before writing out a BFD to request using a
131. traditional format. For example, this is used to request that when
132. writing out an a.out object the symbols not be hashed to eliminate
133. duplicates. *}
134.#define BFD_TRADITIONAL_FORMAT 0x400
135.
136. {* This flag indicates that the BFD contents are actually cached
137. in memory. If this is set, iostream points to a bfd_in_memory
138. struct. *}
139.#define BFD_IN_MEMORY 0x800
140.
141. {* The sections in this BFD specify a memory page. *}
142.#define HAS_LOAD_PAGE 0x1000
143.
144. {* This BFD has been created by the linker and doesn't correspond
145. to any input file. *}
146.#define BFD_LINKER_CREATED 0x2000
147.
36e4dce6
CD
148. {* This may be set before writing out a BFD to request that it
149. be written using values for UIDs, GIDs, timestamps, etc. that
150. will be consistent from run to run. *}
151.#define BFD_DETERMINISTIC_OUTPUT 0x4000
152.
b5f79c76
NC
153. {* Currently my_archive is tested before adding origin to
154. anything. I believe that this can become always an add of
155. origin, with origin set to 0 for non archive files. *}
156. ufile_ptr origin;
157.
a8da6403
NC
158. {* The origin in the archive of the proxy entry. This will
159. normally be the same as origin, except for thin archives,
160. when it will contain the current offset of the proxy in the
161. thin archive rather than the offset of the bfd in its actual
162. container. *}
163. ufile_ptr proxy_origin;
164.
b5f79c76
NC
165. {* A hash table for section names. *}
166. struct bfd_hash_table section_htab;
167.
168. {* Pointer to linked list of sections. *}
198beae2 169. struct bfd_section *sections;
b5f79c76 170.
5daa8fe7
L
171. {* The last section on the section list. *}
172. struct bfd_section *section_last;
b5f79c76
NC
173.
174. {* The number of sections. *}
175. unsigned int section_count;
176.
177. {* Stuff only useful for object files:
178. The start address. *}
179. bfd_vma start_address;
180.
181. {* Used for input and output. *}
182. unsigned int symcount;
183.
5c1d2f5f
AM
184. {* Symbol table for output BFD (with symcount entries).
185. Also used by the linker to cache input BFD symbols. *}
fc0a2244 186. struct bfd_symbol **outsymbols;
b5f79c76 187.
1f70368c
DJ
188. {* Used for slurped dynamic symbol tables. *}
189. unsigned int dynsymcount;
190.
b5f79c76
NC
191. {* Pointer to structure which contains architecture information. *}
192. const struct bfd_arch_info *arch_info;
193.
194. {* Stuff only useful for archives. *}
c58b9523 195. void *arelt_data;
2ce40c65 196. struct bfd *my_archive; {* The containing archive BFD. *}
cc481421 197. struct bfd *archive_next; {* The next BFD in the archive. *}
2ce40c65 198. struct bfd *archive_head; {* The first BFD in the archive. *}
a8da6403
NC
199. struct bfd *nested_archives; {* List of nested archive in a flattened
200. thin archive. *}
252b5132 201.
b5f79c76 202. {* A chain of BFD structures involved in a link. *}
2ce40c65 203. struct bfd *link_next;
b5f79c76
NC
204.
205. {* A field used by _bfd_generic_link_add_archive_symbols. This will
206. be used only for archive elements. *}
207. int archive_pass;
208.
209. {* Used by the back end to hold private data. *}
210. union
211. {
252b5132
RH
212. struct aout_data_struct *aout_data;
213. struct artdata *aout_ar_data;
214. struct _oasys_data *oasys_obj_data;
215. struct _oasys_ar_data *oasys_ar_data;
216. struct coff_tdata *coff_obj_data;
217. struct pe_tdata *pe_obj_data;
218. struct xcoff_tdata *xcoff_obj_data;
219. struct ecoff_tdata *ecoff_obj_data;
220. struct ieee_data_struct *ieee_data;
221. struct ieee_ar_data_struct *ieee_ar_data;
222. struct srec_data_struct *srec_data;
c067354b 223. struct verilog_data_struct *verilog_data;
252b5132
RH
224. struct ihex_data_struct *ihex_data;
225. struct tekhex_data_struct *tekhex_data;
226. struct elf_obj_tdata *elf_obj_data;
227. struct nlm_obj_tdata *nlm_obj_data;
228. struct bout_data_struct *bout_data;
3c3bdf30 229. struct mmo_data_struct *mmo_data;
252b5132
RH
230. struct sun_core_struct *sun_core_data;
231. struct sco5_core_struct *sco5_core_data;
232. struct trad_core_struct *trad_core_data;
233. struct som_data_struct *som_data;
234. struct hpux_core_struct *hpux_core_data;
235. struct hppabsd_core_struct *hppabsd_core_data;
236. struct sgi_core_struct *sgi_core_data;
237. struct lynx_core_struct *lynx_core_data;
238. struct osf_core_struct *osf_core_data;
239. struct cisco_core_struct *cisco_core_data;
240. struct versados_data_struct *versados_data;
241. struct netbsd_core_struct *netbsd_core_data;
3af9a47b
NC
242. struct mach_o_data_struct *mach_o_data;
243. struct mach_o_fat_data_struct *mach_o_fat_data;
ce3c775b 244. struct plugin_data_struct *plugin_data;
3af9a47b
NC
245. struct bfd_pef_data_struct *pef_data;
246. struct bfd_pef_xlib_data_struct *pef_xlib_data;
247. struct bfd_sym_data_struct *sym_data;
c58b9523 248. void *any;
b5f79c76
NC
249. }
250. tdata;
aebad5fe 251.
b5f79c76 252. {* Used by the application to hold private data. *}
c58b9523 253. void *usrdata;
252b5132
RH
254.
255. {* Where all the allocated stuff under this BFD goes. This is a
c58b9523
AM
256. struct objalloc *, but we use void * to avoid requiring the inclusion
257. of objalloc.h. *}
258. void *memory;
6ad2759d
L
259.
260. {* Is the file descriptor being cached? That is, can it be closed as
261. needed, and re-opened when accessed later? *}
262. unsigned int cacheable : 1;
263.
264. {* Marks whether there was a default target specified when the
265. BFD was opened. This is used to select which matching algorithm
266. to use to choose the back end. *}
267. unsigned int target_defaulted : 1;
268.
269. {* ... and here: (``once'' means at least once). *}
270. unsigned int opened_once : 1;
271.
272. {* Set if we have a locally maintained mtime value, rather than
273. getting it from the file each time. *}
274. unsigned int mtime_set : 1;
275.
276. {* Flag set if symbols from this BFD should not be exported. *}
277. unsigned int no_export : 1;
278.
279. {* Remember when output has begun, to stop strange things
280. from happening. *}
281. unsigned int output_has_begun : 1;
282.
283. {* Have archive map. *}
284. unsigned int has_armap : 1;
a8da6403
NC
285.
286. {* Set if this is a thin archive. *}
287. unsigned int is_thin_archive : 1;
252b5132
RH
288.};
289.
290*/
291
252b5132 292#include "sysdep.h"
252b5132 293#include <stdarg.h>
3db64b00
AM
294#include "bfd.h"
295#include "bfdver.h"
252b5132 296#include "libiberty.h"
3fad56a3 297#include "demangle.h"
3882b010 298#include "safe-ctype.h"
252b5132
RH
299#include "bfdlink.h"
300#include "libbfd.h"
301#include "coff/internal.h"
302#include "coff/sym.h"
303#include "libcoff.h"
304#include "libecoff.h"
305#undef obj_symbols
306#include "elf-bfd.h"
3168356f
AM
307
308#ifndef EXIT_FAILURE
309#define EXIT_FAILURE 1
310#endif
311
252b5132
RH
312\f
313/* provide storage for subsystem, stack and heap data which may have been
314 passed in on the command line. Ld puts this data into a bfd_link_info
315 struct which ultimately gets passed in to the bfd. When it arrives, copy
316 it to the following struct so that the data will be available in coffcode.h
317 where it is needed. The typedef's used are defined in bfd.h */
252b5132
RH
318\f
319/*
320SECTION
321 Error reporting
322
323 Most BFD functions return nonzero on success (check their
324 individual documentation for precise semantics). On an error,
325 they call <<bfd_set_error>> to set an error condition that callers
326 can check by calling <<bfd_get_error>>.
327 If that returns <<bfd_error_system_call>>, then check
328 <<errno>>.
329
330 The easiest way to report a BFD error to the user is to
331 use <<bfd_perror>>.
332
333SUBSECTION
334 Type <<bfd_error_type>>
335
336 The values returned by <<bfd_get_error>> are defined by the
337 enumerated type <<bfd_error_type>>.
338
339CODE_FRAGMENT
340.
341.typedef enum bfd_error
342.{
343. bfd_error_no_error = 0,
344. bfd_error_system_call,
345. bfd_error_invalid_target,
346. bfd_error_wrong_format,
3619ad04 347. bfd_error_wrong_object_format,
252b5132
RH
348. bfd_error_invalid_operation,
349. bfd_error_no_memory,
350. bfd_error_no_symbols,
351. bfd_error_no_armap,
352. bfd_error_no_more_archived_files,
353. bfd_error_malformed_archive,
354. bfd_error_file_not_recognized,
355. bfd_error_file_ambiguously_recognized,
356. bfd_error_no_contents,
357. bfd_error_nonrepresentable_section,
358. bfd_error_no_debug_section,
359. bfd_error_bad_value,
360. bfd_error_file_truncated,
361. bfd_error_file_too_big,
ffda70fc 362. bfd_error_on_input,
252b5132 363. bfd_error_invalid_error_code
b5f79c76
NC
364.}
365.bfd_error_type;
252b5132
RH
366.
367*/
368
369static bfd_error_type bfd_error = bfd_error_no_error;
ffda70fc
AM
370static bfd *input_bfd = NULL;
371static bfd_error_type input_error = bfd_error_no_error;
252b5132 372
55ab10f0
NC
373const char *const bfd_errmsgs[] =
374{
375 N_("No error"),
376 N_("System call error"),
377 N_("Invalid bfd target"),
378 N_("File in wrong format"),
3619ad04 379 N_("Archive object file in wrong format"),
55ab10f0
NC
380 N_("Invalid operation"),
381 N_("Memory exhausted"),
382 N_("No symbols"),
383 N_("Archive has no index; run ranlib to add one"),
384 N_("No more archived files"),
385 N_("Malformed archive"),
386 N_("File format not recognized"),
387 N_("File format is ambiguous"),
388 N_("Section has no contents"),
389 N_("Nonrepresentable section on output"),
390 N_("Symbol needs debug section which does not exist"),
391 N_("Bad value"),
392 N_("File truncated"),
393 N_("File too big"),
ffda70fc 394 N_("Error reading %s: %s"),
55ab10f0
NC
395 N_("#<Invalid error code>")
396};
252b5132
RH
397
398/*
399FUNCTION
400 bfd_get_error
401
402SYNOPSIS
403 bfd_error_type bfd_get_error (void);
404
405DESCRIPTION
406 Return the current BFD error condition.
407*/
408
409bfd_error_type
c58b9523 410bfd_get_error (void)
252b5132
RH
411{
412 return bfd_error;
413}
414
415/*
416FUNCTION
417 bfd_set_error
418
419SYNOPSIS
ffda70fc 420 void bfd_set_error (bfd_error_type error_tag, ...);
252b5132
RH
421
422DESCRIPTION
423 Set the BFD error condition to be @var{error_tag}.
ffda70fc
AM
424 If @var{error_tag} is bfd_error_on_input, then this function
425 takes two more parameters, the input bfd where the error
426 occurred, and the bfd_error_type error.
252b5132
RH
427*/
428
429void
ffda70fc 430bfd_set_error (bfd_error_type error_tag, ...)
252b5132
RH
431{
432 bfd_error = error_tag;
ffda70fc
AM
433 if (error_tag == bfd_error_on_input)
434 {
435 /* This is an error that occurred during bfd_close when
436 writing an archive, but on one of the input files. */
437 va_list ap;
438
439 va_start (ap, error_tag);
440 input_bfd = va_arg (ap, bfd *);
441 input_error = va_arg (ap, int);
442 if (input_error >= bfd_error_on_input)
443 abort ();
444 va_end (ap);
445 }
252b5132
RH
446}
447
448/*
449FUNCTION
450 bfd_errmsg
451
452SYNOPSIS
55ab10f0 453 const char *bfd_errmsg (bfd_error_type error_tag);
252b5132
RH
454
455DESCRIPTION
456 Return a string describing the error @var{error_tag}, or
457 the system error if @var{error_tag} is <<bfd_error_system_call>>.
458*/
459
55ab10f0 460const char *
c58b9523 461bfd_errmsg (bfd_error_type error_tag)
252b5132
RH
462{
463#ifndef errno
464 extern int errno;
465#endif
ffda70fc
AM
466 if (error_tag == bfd_error_on_input)
467 {
468 char *buf;
469 const char *msg = bfd_errmsg (input_error);
470
471 if (asprintf (&buf, _(bfd_errmsgs [error_tag]), input_bfd->filename, msg)
472 != -1)
473 return buf;
474
475 /* Ick, what to do on out of memory? */
476 return msg;
477 }
478
252b5132
RH
479 if (error_tag == bfd_error_system_call)
480 return xstrerror (errno);
481
c58b9523
AM
482 if (error_tag > bfd_error_invalid_error_code)
483 error_tag = bfd_error_invalid_error_code; /* sanity check */
252b5132 484
c58b9523 485 return _(bfd_errmsgs [error_tag]);
252b5132
RH
486}
487
488/*
489FUNCTION
490 bfd_perror
491
492SYNOPSIS
55ab10f0 493 void bfd_perror (const char *message);
252b5132
RH
494
495DESCRIPTION
496 Print to the standard error stream a string describing the
497 last BFD error that occurred, or the last system error if
498 the last BFD error was a system call failure. If @var{message}
499 is non-NULL and non-empty, the error string printed is preceded
500 by @var{message}, a colon, and a space. It is followed by a newline.
501*/
502
503void
c58b9523 504bfd_perror (const char *message)
252b5132 505{
ffda70fc
AM
506 if (message == NULL || *message == '\0')
507 fprintf (stderr, "%s\n", bfd_errmsg (bfd_get_error ()));
55ab10f0 508 else
ffda70fc 509 fprintf (stderr, "%s: %s\n", message, bfd_errmsg (bfd_get_error ()));
252b5132
RH
510}
511
512/*
513SUBSECTION
514 BFD error handler
515
516 Some BFD functions want to print messages describing the
517 problem. They call a BFD error handler function. This
5c4491d3 518 function may be overridden by the program.
252b5132
RH
519
520 The BFD error handler acts like printf.
521
522CODE_FRAGMENT
523.
c58b9523 524.typedef void (*bfd_error_handler_type) (const char *, ...);
252b5132
RH
525.
526*/
527
528/* The program name used when printing BFD error messages. */
529
530static const char *_bfd_error_program_name;
531
d003868e
AM
532/* This is the default routine to handle BFD error messages.
533 Like fprintf (stderr, ...), but also handles some extra format specifiers.
534
535 %A section name from section. For group components, print group name too.
536 %B file name from bfd. For archive components, prints archive too.
d07676f8
NC
537
538 Note - because these two extra format specifiers require special handling
539 they are scanned for and processed in this function, before calling
540 vfprintf. This means that the *arguments* for these format specifiers
541 must be the first ones in the variable argument list, regardless of where
542 the specifiers appear in the format string. Thus for example calling
543 this function with a format string of:
544
545 "blah %s blah %A blah %d blah %B"
546
547 would involve passing the arguments as:
548
549 "blah %s blah %A blah %d blah %B",
550 asection_for_the_%A,
551 bfd_for_the_%B,
552 string_for_the_%s,
553 integer_for_the_%d);
d003868e 554 */
252b5132 555
185d09ad 556void
d003868e 557_bfd_default_error_handler (const char *fmt, ...)
252b5132 558{
d003868e
AM
559 va_list ap;
560 char *bufp;
561 const char *new_fmt, *p;
562 size_t avail = 1000;
563 char buf[1000];
c58b9523 564
0bc43230
AM
565 /* PR 4992: Don't interrupt output being sent to stdout. */
566 fflush (stdout);
567
252b5132
RH
568 if (_bfd_error_program_name != NULL)
569 fprintf (stderr, "%s: ", _bfd_error_program_name);
570 else
571 fprintf (stderr, "BFD: ");
572
d003868e
AM
573 va_start (ap, fmt);
574 new_fmt = fmt;
575 bufp = buf;
576
577 /* Reserve enough space for the existing format string. */
578 avail -= strlen (fmt) + 1;
579 if (avail > 1000)
3168356f 580 _exit (EXIT_FAILURE);
d003868e
AM
581
582 p = fmt;
3e540f25 583 while (1)
d003868e
AM
584 {
585 char *q;
586 size_t len, extra, trim;
587
588 p = strchr (p, '%');
589 if (p == NULL || p[1] == '\0')
590 {
591 if (new_fmt == buf)
592 {
593 len = strlen (fmt);
594 memcpy (bufp, fmt, len + 1);
595 }
596 break;
597 }
598
599 if (p[1] == 'A' || p[1] == 'B')
600 {
601 len = p - fmt;
602 memcpy (bufp, fmt, len);
603 bufp += len;
604 fmt = p + 2;
605 new_fmt = buf;
606
607 /* If we run out of space, tough, you lose your ridiculously
608 long file or section name. It's not safe to try to alloc
609 memory here; We might be printing an out of memory message. */
610 if (avail == 0)
611 {
612 *bufp++ = '*';
613 *bufp++ = '*';
614 *bufp = '\0';
615 }
616 else
617 {
618 if (p[1] == 'B')
619 {
620 bfd *abfd = va_arg (ap, bfd *);
d07676f8
NC
621
622 if (abfd == NULL)
623 /* Invoking %B with a null bfd pointer is an internal error. */
624 abort ();
625 else if (abfd->my_archive)
d003868e
AM
626 snprintf (bufp, avail, "%s(%s)",
627 abfd->my_archive->filename, abfd->filename);
628 else
629 snprintf (bufp, avail, "%s", abfd->filename);
630 }
631 else
632 {
633 asection *sec = va_arg (ap, asection *);
d07676f8 634 bfd *abfd;
d003868e
AM
635 const char *group = NULL;
636 struct coff_comdat_info *ci;
637
d07676f8
NC
638 if (sec == NULL)
639 /* Invoking %A with a null section pointer is an internal error. */
640 abort ();
641 abfd = sec->owner;
d003868e
AM
642 if (abfd != NULL
643 && bfd_get_flavour (abfd) == bfd_target_elf_flavour
644 && elf_next_in_group (sec) != NULL
645 && (sec->flags & SEC_GROUP) == 0)
646 group = elf_group_name (sec);
647 else if (abfd != NULL
648 && bfd_get_flavour (abfd) == bfd_target_coff_flavour
649 && (ci = bfd_coff_get_comdat_section (sec->owner,
650 sec)) != NULL)
651 group = ci->name;
652 if (group != NULL)
653 snprintf (bufp, avail, "%s[%s]", sec->name, group);
654 else
655 snprintf (bufp, avail, "%s", sec->name);
656 }
657 len = strlen (bufp);
658 avail = avail - len + 2;
659
660 /* We need to replace any '%' we printed by "%%".
661 First count how many. */
662 q = bufp;
663 bufp += len;
664 extra = 0;
665 while ((q = strchr (q, '%')) != NULL)
666 {
667 ++q;
668 ++extra;
669 }
670
671 /* If there isn't room, trim off the end of the string. */
672 q = bufp;
673 bufp += extra;
674 if (extra > avail)
675 {
676 trim = extra - avail;
677 bufp -= trim;
678 do
679 {
680 if (*--q == '%')
681 --extra;
682 }
683 while (--trim != 0);
684 *q = '\0';
45fc9e4a 685 avail = extra;
d003868e 686 }
45fc9e4a 687 avail -= extra;
d003868e
AM
688
689 /* Now double all '%' chars, shuffling the string as we go. */
690 while (extra != 0)
691 {
692 while ((q[extra] = *q) != '%')
693 --q;
694 q[--extra] = '%';
695 --q;
696 }
697 }
698 }
699 p = p + 2;
700 }
701
702 vfprintf (stderr, new_fmt, ap);
703 va_end (ap);
252b5132 704
d003868e 705 putc ('\n', stderr);
252b5132
RH
706}
707
252b5132
RH
708/* This is a function pointer to the routine which should handle BFD
709 error messages. It is called when a BFD routine encounters an
710 error for which it wants to print a message. Going through a
711 function pointer permits a program linked against BFD to intercept
712 the messages and deal with them itself. */
713
714bfd_error_handler_type _bfd_error_handler = _bfd_default_error_handler;
715
716/*
717FUNCTION
718 bfd_set_error_handler
719
720SYNOPSIS
721 bfd_error_handler_type bfd_set_error_handler (bfd_error_handler_type);
722
723DESCRIPTION
724 Set the BFD error handler function. Returns the previous
725 function.
726*/
727
728bfd_error_handler_type
c58b9523 729bfd_set_error_handler (bfd_error_handler_type pnew)
252b5132
RH
730{
731 bfd_error_handler_type pold;
732
733 pold = _bfd_error_handler;
734 _bfd_error_handler = pnew;
735 return pold;
736}
737
738/*
739FUNCTION
740 bfd_set_error_program_name
741
742SYNOPSIS
743 void bfd_set_error_program_name (const char *);
744
745DESCRIPTION
746 Set the program name to use when printing a BFD error. This
747 is printed before the error message followed by a colon and
748 space. The string must not be changed after it is passed to
749 this function.
750*/
751
752void
c58b9523 753bfd_set_error_program_name (const char *name)
252b5132
RH
754{
755 _bfd_error_program_name = name;
756}
757
252b5132
RH
758/*
759FUNCTION
760 bfd_get_error_handler
761
762SYNOPSIS
763 bfd_error_handler_type bfd_get_error_handler (void);
764
765DESCRIPTION
766 Return the BFD error handler function.
767*/
768
769bfd_error_handler_type
c58b9523 770bfd_get_error_handler (void)
252b5132
RH
771{
772 return _bfd_error_handler;
773}
774\f
775/*
776SECTION
1b74d094
BW
777 Miscellaneous
778
779SUBSECTION
780 Miscellaneous functions
252b5132
RH
781*/
782
783/*
784FUNCTION
785 bfd_get_reloc_upper_bound
786
787SYNOPSIS
ed781d5d 788 long bfd_get_reloc_upper_bound (bfd *abfd, asection *sect);
252b5132
RH
789
790DESCRIPTION
791 Return the number of bytes required to store the
792 relocation information associated with section @var{sect}
793 attached to bfd @var{abfd}. If an error occurs, return -1.
794
795*/
796
252b5132 797long
c58b9523 798bfd_get_reloc_upper_bound (bfd *abfd, sec_ptr asect)
252b5132 799{
55ab10f0
NC
800 if (abfd->format != bfd_object)
801 {
802 bfd_set_error (bfd_error_invalid_operation);
803 return -1;
804 }
252b5132
RH
805
806 return BFD_SEND (abfd, _get_reloc_upper_bound, (abfd, asect));
807}
808
809/*
810FUNCTION
811 bfd_canonicalize_reloc
812
813SYNOPSIS
814 long bfd_canonicalize_reloc
c58b9523 815 (bfd *abfd, asection *sec, arelent **loc, asymbol **syms);
252b5132
RH
816
817DESCRIPTION
818 Call the back end associated with the open BFD
819 @var{abfd} and translate the external form of the relocation
820 information attached to @var{sec} into the internal canonical
821 form. Place the table into memory at @var{loc}, which has
822 been preallocated, usually by a call to
823 <<bfd_get_reloc_upper_bound>>. Returns the number of relocs, or
824 -1 on error.
825
826 The @var{syms} table is also needed for horrible internal magic
827 reasons.
828
252b5132
RH
829*/
830long
c58b9523
AM
831bfd_canonicalize_reloc (bfd *abfd,
832 sec_ptr asect,
833 arelent **location,
834 asymbol **symbols)
252b5132 835{
55ab10f0
NC
836 if (abfd->format != bfd_object)
837 {
838 bfd_set_error (bfd_error_invalid_operation);
839 return -1;
840 }
841
252b5132
RH
842 return BFD_SEND (abfd, _bfd_canonicalize_reloc,
843 (abfd, asect, location, symbols));
844}
845
846/*
847FUNCTION
848 bfd_set_reloc
849
850SYNOPSIS
851 void bfd_set_reloc
b5f79c76 852 (bfd *abfd, asection *sec, arelent **rel, unsigned int count);
252b5132
RH
853
854DESCRIPTION
855 Set the relocation pointer and count within
856 section @var{sec} to the values @var{rel} and @var{count}.
857 The argument @var{abfd} is ignored.
858
859*/
aebad5fe 860
252b5132 861void
c58b9523
AM
862bfd_set_reloc (bfd *ignore_abfd ATTRIBUTE_UNUSED,
863 sec_ptr asect,
864 arelent **location,
865 unsigned int count)
252b5132
RH
866{
867 asect->orelocation = location;
868 asect->reloc_count = count;
869}
870
871/*
872FUNCTION
873 bfd_set_file_flags
874
875SYNOPSIS
ed781d5d 876 bfd_boolean bfd_set_file_flags (bfd *abfd, flagword flags);
252b5132
RH
877
878DESCRIPTION
879 Set the flag word in the BFD @var{abfd} to the value @var{flags}.
880
881 Possible errors are:
882 o <<bfd_error_wrong_format>> - The target bfd was not of object format.
883 o <<bfd_error_invalid_operation>> - The target bfd was open for reading.
884 o <<bfd_error_invalid_operation>> -
885 The flag word contained a bit which was not applicable to the
886 type of file. E.g., an attempt was made to set the <<D_PAGED>> bit
887 on a BFD format which does not support demand paging.
888
889*/
890
b34976b6 891bfd_boolean
c58b9523 892bfd_set_file_flags (bfd *abfd, flagword flags)
252b5132 893{
55ab10f0
NC
894 if (abfd->format != bfd_object)
895 {
896 bfd_set_error (bfd_error_wrong_format);
b34976b6 897 return FALSE;
55ab10f0 898 }
252b5132 899
55ab10f0
NC
900 if (bfd_read_p (abfd))
901 {
902 bfd_set_error (bfd_error_invalid_operation);
b34976b6 903 return FALSE;
55ab10f0 904 }
252b5132
RH
905
906 bfd_get_file_flags (abfd) = flags;
55ab10f0
NC
907 if ((flags & bfd_applicable_file_flags (abfd)) != flags)
908 {
909 bfd_set_error (bfd_error_invalid_operation);
b34976b6 910 return FALSE;
55ab10f0 911 }
252b5132 912
b34976b6 913 return TRUE;
252b5132
RH
914}
915
916void
c58b9523 917bfd_assert (const char *file, int line)
252b5132 918{
aec2f561
AM
919 (*_bfd_error_handler) (_("BFD %s assertion fail %s:%d"),
920 BFD_VERSION_STRING, file, line);
252b5132
RH
921}
922
c0bed66d
ILT
923/* A more or less friendly abort message. In libbfd.h abort is
924 defined to call this function. */
925
c0bed66d 926void
c58b9523 927_bfd_abort (const char *file, int line, const char *fn)
c0bed66d
ILT
928{
929 if (fn != NULL)
930 (*_bfd_error_handler)
aec2f561
AM
931 (_("BFD %s internal error, aborting at %s line %d in %s\n"),
932 BFD_VERSION_STRING, file, line, fn);
c0bed66d
ILT
933 else
934 (*_bfd_error_handler)
391154e9 935 (_("BFD %s internal error, aborting at %s line %d\n"),
aec2f561 936 BFD_VERSION_STRING, file, line);
c0bed66d 937 (*_bfd_error_handler) (_("Please report this bug.\n"));
3168356f 938 _exit (EXIT_FAILURE);
c0bed66d 939}
252b5132 940
125c4a69
NC
941/*
942FUNCTION
943 bfd_get_arch_size
944
945SYNOPSIS
946 int bfd_get_arch_size (bfd *abfd);
947
948DESCRIPTION
949 Returns the architecture address size, in bits, as determined
950 by the object file's format. For ELF, this information is
951 included in the header.
952
953RETURNS
954 Returns the arch size in bits if known, <<-1>> otherwise.
955*/
956
957int
c58b9523 958bfd_get_arch_size (bfd *abfd)
125c4a69
NC
959{
960 if (abfd->xvec->flavour == bfd_target_elf_flavour)
c58b9523 961 return get_elf_backend_data (abfd)->s->arch_size;
125c4a69 962
125c4a69
NC
963 return -1;
964}
965
966/*
967FUNCTION
968 bfd_get_sign_extend_vma
969
970SYNOPSIS
971 int bfd_get_sign_extend_vma (bfd *abfd);
972
973DESCRIPTION
974 Indicates if the target architecture "naturally" sign extends
975 an address. Some architectures implicitly sign extend address
976 values when they are converted to types larger than the size
977 of an address. For instance, bfd_get_start_address() will
978 return an address sign extended to fill a bfd_vma when this is
979 the case.
980
981RETURNS
982 Returns <<1>> if the target architecture is known to sign
983 extend addresses, <<0>> if the target architecture is known to
984 not sign extend addresses, and <<-1>> otherwise.
985*/
986
987int
c58b9523 988bfd_get_sign_extend_vma (bfd *abfd)
125c4a69 989{
f47e5071
NC
990 char *name;
991
125c4a69 992 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
c58b9523 993 return get_elf_backend_data (abfd)->sign_extend_vma;
125c4a69 994
f47e5071
NC
995 name = bfd_get_target (abfd);
996
7148cc28 997 /* Return a proper value for DJGPP & PE COFF.
f47e5071
NC
998 This function is required for DWARF2 support, but there is
999 no place to store this information in the COFF back end.
1000 Should enough other COFF targets add support for DWARF2,
1001 a place will have to be found. Until then, this hack will do. */
0112cd26 1002 if (CONST_STRNEQ (name, "coff-go32")
8a7140c3 1003 || strcmp (name, "pe-i386") == 0
f0927246 1004 || strcmp (name, "pei-i386") == 0
6e3d6dc1
NC
1005 || strcmp (name, "pe-x86-64") == 0
1006 || strcmp (name, "pei-x86-64") == 0
7148cc28
NC
1007 || strcmp (name, "pe-arm-wince-little") == 0
1008 || strcmp (name, "pei-arm-wince-little") == 0)
f47e5071
NC
1009 return 1;
1010
09c6f846
TG
1011 if (CONST_STRNEQ (name, "mach-o"))
1012 return 0;
1013
a022216b 1014 bfd_set_error (bfd_error_wrong_format);
125c4a69
NC
1015 return -1;
1016}
1017
252b5132
RH
1018/*
1019FUNCTION
1020 bfd_set_start_address
1021
1022SYNOPSIS
ed781d5d 1023 bfd_boolean bfd_set_start_address (bfd *abfd, bfd_vma vma);
252b5132
RH
1024
1025DESCRIPTION
1026 Make @var{vma} the entry point of output BFD @var{abfd}.
1027
1028RETURNS
b34976b6 1029 Returns <<TRUE>> on success, <<FALSE>> otherwise.
252b5132
RH
1030*/
1031
b34976b6 1032bfd_boolean
c58b9523 1033bfd_set_start_address (bfd *abfd, bfd_vma vma)
252b5132
RH
1034{
1035 abfd->start_address = vma;
b34976b6 1036 return TRUE;
252b5132
RH
1037}
1038
252b5132
RH
1039/*
1040FUNCTION
1041 bfd_get_gp_size
1042
1043SYNOPSIS
ed781d5d 1044 unsigned int bfd_get_gp_size (bfd *abfd);
252b5132
RH
1045
1046DESCRIPTION
1047 Return the maximum size of objects to be optimized using the GP
1048 register under MIPS ECOFF. This is typically set by the <<-G>>
1049 argument to the compiler, assembler or linker.
1050*/
1051
c0846b23 1052unsigned int
c58b9523 1053bfd_get_gp_size (bfd *abfd)
252b5132
RH
1054{
1055 if (abfd->format == bfd_object)
1056 {
1057 if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
1058 return ecoff_data (abfd)->gp_size;
1059 else if (abfd->xvec->flavour == bfd_target_elf_flavour)
1060 return elf_gp_size (abfd);
1061 }
1062 return 0;
1063}
1064
1065/*
1066FUNCTION
1067 bfd_set_gp_size
1068
1069SYNOPSIS
ed781d5d 1070 void bfd_set_gp_size (bfd *abfd, unsigned int i);
252b5132
RH
1071
1072DESCRIPTION
1073 Set the maximum size of objects to be optimized using the GP
1074 register under ECOFF or MIPS ELF. This is typically set by
1075 the <<-G>> argument to the compiler, assembler or linker.
1076*/
1077
1078void
c58b9523 1079bfd_set_gp_size (bfd *abfd, unsigned int i)
252b5132 1080{
55ab10f0 1081 /* Don't try to set GP size on an archive or core file! */
252b5132
RH
1082 if (abfd->format != bfd_object)
1083 return;
55ab10f0 1084
252b5132
RH
1085 if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
1086 ecoff_data (abfd)->gp_size = i;
1087 else if (abfd->xvec->flavour == bfd_target_elf_flavour)
1088 elf_gp_size (abfd) = i;
1089}
1090
1091/* Get the GP value. This is an internal function used by some of the
1092 relocation special_function routines on targets which support a GP
1093 register. */
1094
1095bfd_vma
c58b9523 1096_bfd_get_gp_value (bfd *abfd)
252b5132 1097{
9bcf4de0
TS
1098 if (! abfd)
1099 return 0;
55ab10f0
NC
1100 if (abfd->format != bfd_object)
1101 return 0;
1102
1103 if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
1104 return ecoff_data (abfd)->gp;
1105 else if (abfd->xvec->flavour == bfd_target_elf_flavour)
1106 return elf_gp (abfd);
1107
252b5132
RH
1108 return 0;
1109}
1110
1111/* Set the GP value. */
1112
1113void
c58b9523 1114_bfd_set_gp_value (bfd *abfd, bfd_vma v)
252b5132 1115{
9bcf4de0 1116 if (! abfd)
c2c96631 1117 abort ();
252b5132
RH
1118 if (abfd->format != bfd_object)
1119 return;
55ab10f0 1120
252b5132
RH
1121 if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
1122 ecoff_data (abfd)->gp = v;
1123 else if (abfd->xvec->flavour == bfd_target_elf_flavour)
1124 elf_gp (abfd) = v;
1125}
1126
1127/*
1128FUNCTION
1129 bfd_scan_vma
1130
1131SYNOPSIS
ed781d5d 1132 bfd_vma bfd_scan_vma (const char *string, const char **end, int base);
252b5132
RH
1133
1134DESCRIPTION
1135 Convert, like <<strtoul>>, a numerical expression
1136 @var{string} into a <<bfd_vma>> integer, and return that integer.
1137 (Though without as many bells and whistles as <<strtoul>>.)
1138 The expression is assumed to be unsigned (i.e., positive).
1139 If given a @var{base}, it is used as the base for conversion.
1140 A base of 0 causes the function to interpret the string
1141 in hex if a leading "0x" or "0X" is found, otherwise
1142 in octal if a leading zero is found, otherwise in decimal.
1143
88eaccc2
AM
1144 If the value would overflow, the maximum <<bfd_vma>> value is
1145 returned.
252b5132
RH
1146*/
1147
1148bfd_vma
c58b9523 1149bfd_scan_vma (const char *string, const char **end, int base)
252b5132
RH
1150{
1151 bfd_vma value;
88eaccc2
AM
1152 bfd_vma cutoff;
1153 unsigned int cutlim;
1154 int overflow;
252b5132
RH
1155
1156 /* Let the host do it if possible. */
eb6e10cb 1157 if (sizeof (bfd_vma) <= sizeof (unsigned long))
c58b9523 1158 return strtoul (string, (char **) end, base);
252b5132 1159
49c97a80
ILT
1160#ifdef HAVE_STRTOULL
1161 if (sizeof (bfd_vma) <= sizeof (unsigned long long))
1162 return strtoull (string, (char **) end, base);
1163#endif
1164
252b5132
RH
1165 if (base == 0)
1166 {
1167 if (string[0] == '0')
1168 {
1169 if ((string[1] == 'x') || (string[1] == 'X'))
1170 base = 16;
252b5132
RH
1171 else
1172 base = 8;
1173 }
252b5132 1174 }
55ab10f0 1175
88eaccc2
AM
1176 if ((base < 2) || (base > 36))
1177 base = 10;
1178
1179 if (base == 16
1180 && string[0] == '0'
1181 && (string[1] == 'x' || string[1] == 'X')
1182 && ISXDIGIT (string[2]))
1183 {
1184 string += 2;
1185 }
aebad5fe 1186
88eaccc2
AM
1187 cutoff = (~ (bfd_vma) 0) / (bfd_vma) base;
1188 cutlim = (~ (bfd_vma) 0) % (bfd_vma) base;
1189 value = 0;
1190 overflow = 0;
1191 while (1)
1192 {
1193 unsigned int digit;
1194
1195 digit = *string;
1196 if (ISDIGIT (digit))
1197 digit = digit - '0';
1198 else if (ISALPHA (digit))
1199 digit = TOUPPER (digit) - 'A' + 10;
1200 else
1201 break;
1202 if (digit >= (unsigned int) base)
1203 break;
1204 if (value > cutoff || (value == cutoff && digit > cutlim))
1205 overflow = 1;
1206 value = value * base + digit;
1207 ++string;
1208 }
252b5132 1209
88eaccc2
AM
1210 if (overflow)
1211 value = ~ (bfd_vma) 0;
252b5132 1212
88eaccc2
AM
1213 if (end != NULL)
1214 *end = string;
252b5132
RH
1215
1216 return value;
1217}
1218
80fccad2
BW
1219/*
1220FUNCTION
1221 bfd_copy_private_header_data
1222
1223SYNOPSIS
1224 bfd_boolean bfd_copy_private_header_data (bfd *ibfd, bfd *obfd);
1225
1226DESCRIPTION
1227 Copy private BFD header information from the BFD @var{ibfd} to the
1228 the BFD @var{obfd}. This copies information that may require
1229 sections to exist, but does not require symbol tables. Return
1230 <<true>> on success, <<false>> on error.
1231 Possible error returns are:
1232
1233 o <<bfd_error_no_memory>> -
1234 Not enough memory exists to create private data for @var{obfd}.
1235
1236.#define bfd_copy_private_header_data(ibfd, obfd) \
1237. BFD_SEND (obfd, _bfd_copy_private_header_data, \
1238. (ibfd, obfd))
1239
1240*/
1241
252b5132
RH
1242/*
1243FUNCTION
1244 bfd_copy_private_bfd_data
1245
1246SYNOPSIS
ed781d5d 1247 bfd_boolean bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd);
252b5132
RH
1248
1249DESCRIPTION
aebad5fe 1250 Copy private BFD information from the BFD @var{ibfd} to the
b34976b6 1251 the BFD @var{obfd}. Return <<TRUE>> on success, <<FALSE>> on error.
252b5132
RH
1252 Possible error returns are:
1253
1254 o <<bfd_error_no_memory>> -
1255 Not enough memory exists to create private data for @var{obfd}.
1256
1257.#define bfd_copy_private_bfd_data(ibfd, obfd) \
1258. BFD_SEND (obfd, _bfd_copy_private_bfd_data, \
1259. (ibfd, obfd))
1260
1261*/
1262
1263/*
1264FUNCTION
1265 bfd_merge_private_bfd_data
1266
1267SYNOPSIS
ed781d5d 1268 bfd_boolean bfd_merge_private_bfd_data (bfd *ibfd, bfd *obfd);
252b5132
RH
1269
1270DESCRIPTION
aebad5fe 1271 Merge private BFD information from the BFD @var{ibfd} to the
b34976b6
AM
1272 the output file BFD @var{obfd} when linking. Return <<TRUE>>
1273 on success, <<FALSE>> on error. Possible error returns are:
252b5132
RH
1274
1275 o <<bfd_error_no_memory>> -
1276 Not enough memory exists to create private data for @var{obfd}.
1277
1278.#define bfd_merge_private_bfd_data(ibfd, obfd) \
1279. BFD_SEND (obfd, _bfd_merge_private_bfd_data, \
1280. (ibfd, obfd))
1281
1282*/
1283
1284/*
1285FUNCTION
1286 bfd_set_private_flags
1287
1288SYNOPSIS
ed781d5d 1289 bfd_boolean bfd_set_private_flags (bfd *abfd, flagword flags);
252b5132
RH
1290
1291DESCRIPTION
1292 Set private BFD flag information in the BFD @var{abfd}.
b34976b6 1293 Return <<TRUE>> on success, <<FALSE>> on error. Possible error
252b5132
RH
1294 returns are:
1295
1296 o <<bfd_error_no_memory>> -
1297 Not enough memory exists to create private data for @var{obfd}.
1298
1299.#define bfd_set_private_flags(abfd, flags) \
ed781d5d 1300. BFD_SEND (abfd, _bfd_set_private_flags, (abfd, flags))
252b5132
RH
1301
1302*/
1303
1304/*
1305FUNCTION
ed781d5d 1306 Other functions
252b5132
RH
1307
1308DESCRIPTION
ed781d5d 1309 The following functions exist but have not yet been documented.
252b5132 1310
a6b96beb
AM
1311.#define bfd_sizeof_headers(abfd, info) \
1312. BFD_SEND (abfd, _bfd_sizeof_headers, (abfd, info))
252b5132
RH
1313.
1314.#define bfd_find_nearest_line(abfd, sec, syms, off, file, func, line) \
ed781d5d
NC
1315. BFD_SEND (abfd, _bfd_find_nearest_line, \
1316. (abfd, sec, syms, off, file, func, line))
252b5132 1317.
5420f73d
L
1318.#define bfd_find_line(abfd, syms, sym, file, line) \
1319. BFD_SEND (abfd, _bfd_find_line, \
1320. (abfd, syms, sym, file, line))
1321.
4ab527b0
FF
1322.#define bfd_find_inliner_info(abfd, file, func, line) \
1323. BFD_SEND (abfd, _bfd_find_inliner_info, \
1324. (abfd, file, func, line))
1325.
252b5132 1326.#define bfd_debug_info_start(abfd) \
ed781d5d 1327. BFD_SEND (abfd, _bfd_debug_info_start, (abfd))
252b5132
RH
1328.
1329.#define bfd_debug_info_end(abfd) \
ed781d5d 1330. BFD_SEND (abfd, _bfd_debug_info_end, (abfd))
252b5132
RH
1331.
1332.#define bfd_debug_info_accumulate(abfd, section) \
ed781d5d 1333. BFD_SEND (abfd, _bfd_debug_info_accumulate, (abfd, section))
252b5132
RH
1334.
1335.#define bfd_stat_arch_elt(abfd, stat) \
ed781d5d 1336. BFD_SEND (abfd, _bfd_stat_arch_elt,(abfd, stat))
252b5132
RH
1337.
1338.#define bfd_update_armap_timestamp(abfd) \
ed781d5d 1339. BFD_SEND (abfd, _bfd_update_armap_timestamp, (abfd))
252b5132
RH
1340.
1341.#define bfd_set_arch_mach(abfd, arch, mach)\
ed781d5d 1342. BFD_SEND ( abfd, _bfd_set_arch_mach, (abfd, arch, mach))
252b5132
RH
1343.
1344.#define bfd_relax_section(abfd, section, link_info, again) \
1345. BFD_SEND (abfd, _bfd_relax_section, (abfd, section, link_info, again))
1346.
1347.#define bfd_gc_sections(abfd, link_info) \
1348. BFD_SEND (abfd, _bfd_gc_sections, (abfd, link_info))
8550eb6e
JJ
1349.
1350.#define bfd_merge_sections(abfd, link_info) \
1351. BFD_SEND (abfd, _bfd_merge_sections, (abfd, link_info))
252b5132 1352.
72adc230
AM
1353.#define bfd_is_group_section(abfd, sec) \
1354. BFD_SEND (abfd, _bfd_is_group_section, (abfd, sec))
1355.
e61463e1
AM
1356.#define bfd_discard_group(abfd, sec) \
1357. BFD_SEND (abfd, _bfd_discard_group, (abfd, sec))
1358.
252b5132
RH
1359.#define bfd_link_hash_table_create(abfd) \
1360. BFD_SEND (abfd, _bfd_link_hash_table_create, (abfd))
1361.
e2d34d7d
DJ
1362.#define bfd_link_hash_table_free(abfd, hash) \
1363. BFD_SEND (abfd, _bfd_link_hash_table_free, (hash))
1364.
252b5132
RH
1365.#define bfd_link_add_symbols(abfd, info) \
1366. BFD_SEND (abfd, _bfd_link_add_symbols, (abfd, info))
1367.
1449d79b 1368.#define bfd_link_just_syms(abfd, sec, info) \
2d653fc7
AM
1369. BFD_SEND (abfd, _bfd_link_just_syms, (sec, info))
1370.
252b5132
RH
1371.#define bfd_final_link(abfd, info) \
1372. BFD_SEND (abfd, _bfd_final_link, (abfd, info))
1373.
1374.#define bfd_free_cached_info(abfd) \
1375. BFD_SEND (abfd, _bfd_free_cached_info, (abfd))
1376.
1377.#define bfd_get_dynamic_symtab_upper_bound(abfd) \
1378. BFD_SEND (abfd, _bfd_get_dynamic_symtab_upper_bound, (abfd))
1379.
1380.#define bfd_print_private_bfd_data(abfd, file)\
1381. BFD_SEND (abfd, _bfd_print_private_bfd_data, (abfd, file))
1382.
1383.#define bfd_canonicalize_dynamic_symtab(abfd, asymbols) \
1384. BFD_SEND (abfd, _bfd_canonicalize_dynamic_symtab, (abfd, asymbols))
1385.
c9727e01
AM
1386.#define bfd_get_synthetic_symtab(abfd, count, syms, dyncount, dynsyms, ret) \
1387. BFD_SEND (abfd, _bfd_get_synthetic_symtab, (abfd, count, syms, \
1388. dyncount, dynsyms, ret))
4c45e5c9 1389.
252b5132
RH
1390.#define bfd_get_dynamic_reloc_upper_bound(abfd) \
1391. BFD_SEND (abfd, _bfd_get_dynamic_reloc_upper_bound, (abfd))
1392.
1393.#define bfd_canonicalize_dynamic_reloc(abfd, arels, asyms) \
1394. BFD_SEND (abfd, _bfd_canonicalize_dynamic_reloc, (abfd, arels, asyms))
1395.
1396.extern bfd_byte *bfd_get_relocated_section_contents
c58b9523
AM
1397. (bfd *, struct bfd_link_info *, struct bfd_link_order *, bfd_byte *,
1398. bfd_boolean, asymbol **);
252b5132
RH
1399.
1400
1401*/
1402
1403bfd_byte *
c58b9523
AM
1404bfd_get_relocated_section_contents (bfd *abfd,
1405 struct bfd_link_info *link_info,
1406 struct bfd_link_order *link_order,
1407 bfd_byte *data,
1408 bfd_boolean relocatable,
1409 asymbol **symbols)
252b5132
RH
1410{
1411 bfd *abfd2;
c58b9523
AM
1412 bfd_byte *(*fn) (bfd *, struct bfd_link_info *, struct bfd_link_order *,
1413 bfd_byte *, bfd_boolean, asymbol **);
252b5132
RH
1414
1415 if (link_order->type == bfd_indirect_link_order)
1416 {
1417 abfd2 = link_order->u.indirect.section->owner;
55ab10f0 1418 if (abfd2 == NULL)
252b5132
RH
1419 abfd2 = abfd;
1420 }
1421 else
1422 abfd2 = abfd;
55ab10f0 1423
252b5132
RH
1424 fn = abfd2->xvec->_bfd_get_relocated_section_contents;
1425
1049f94e 1426 return (*fn) (abfd, link_info, link_order, data, relocatable, symbols);
252b5132
RH
1427}
1428
1429/* Record information about an ELF program header. */
1430
b34976b6 1431bfd_boolean
c58b9523
AM
1432bfd_record_phdr (bfd *abfd,
1433 unsigned long type,
1434 bfd_boolean flags_valid,
1435 flagword flags,
1436 bfd_boolean at_valid,
1437 bfd_vma at,
1438 bfd_boolean includes_filehdr,
1439 bfd_boolean includes_phdrs,
1440 unsigned int count,
1441 asection **secs)
252b5132
RH
1442{
1443 struct elf_segment_map *m, **pm;
dc810e39 1444 bfd_size_type amt;
252b5132
RH
1445
1446 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
b34976b6 1447 return TRUE;
252b5132 1448
dc810e39
AM
1449 amt = sizeof (struct elf_segment_map);
1450 amt += ((bfd_size_type) count - 1) * sizeof (asection *);
fb70130a 1451 m = bfd_zalloc (abfd, amt);
252b5132 1452 if (m == NULL)
b34976b6 1453 return FALSE;
252b5132 1454
252b5132
RH
1455 m->p_type = type;
1456 m->p_flags = flags;
1457 m->p_paddr = at;
c58b9523
AM
1458 m->p_flags_valid = flags_valid;
1459 m->p_paddr_valid = at_valid;
1460 m->includes_filehdr = includes_filehdr;
1461 m->includes_phdrs = includes_phdrs;
252b5132
RH
1462 m->count = count;
1463 if (count > 0)
1464 memcpy (m->sections, secs, count * sizeof (asection *));
1465
1466 for (pm = &elf_tdata (abfd)->segment_map; *pm != NULL; pm = &(*pm)->next)
1467 ;
1468 *pm = m;
1469
b34976b6 1470 return TRUE;
252b5132 1471}
ae4221d7 1472
01a3c213
AM
1473#ifdef BFD64
1474/* Return true iff this target is 32-bit. */
1475
1476static bfd_boolean
1477is32bit (bfd *abfd)
ae4221d7
L
1478{
1479 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
01a3c213
AM
1480 {
1481 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
1482 return bed->s->elfclass == ELFCLASS32;
1483 }
1484
6aa341c7
TG
1485 /* For non-ELF targets, use architecture information. */
1486 return bfd_arch_bits_per_address (abfd) <= 32;
ae4221d7 1487}
01a3c213
AM
1488#endif
1489
1490/* bfd_sprintf_vma and bfd_fprintf_vma display an address in the
1491 target's address size. */
ae4221d7
L
1492
1493void
01a3c213 1494bfd_sprintf_vma (bfd *abfd ATTRIBUTE_UNUSED, char *buf, bfd_vma value)
ae4221d7 1495{
970ccc77 1496#ifdef BFD64
01a3c213
AM
1497 if (is32bit (abfd))
1498 {
1499 sprintf (buf, "%08lx", (unsigned long) value & 0xffffffff);
1500 return;
1501 }
970ccc77 1502#endif
01a3c213
AM
1503 sprintf_vma (buf, value);
1504}
1505
1506void
1507bfd_fprintf_vma (bfd *abfd ATTRIBUTE_UNUSED, void *stream, bfd_vma value)
1508{
1509#ifdef BFD64
1510 if (is32bit (abfd))
1511 {
1512 fprintf ((FILE *) stream, "%08lx", (unsigned long) value & 0xffffffff);
1513 return;
1514 }
1515#endif
1516 fprintf_vma ((FILE *) stream, value);
ae4221d7 1517}
8c98ec7d
AO
1518
1519/*
1520FUNCTION
1521 bfd_alt_mach_code
1522
1523SYNOPSIS
ed781d5d 1524 bfd_boolean bfd_alt_mach_code (bfd *abfd, int alternative);
8c98ec7d
AO
1525
1526DESCRIPTION
1527
1528 When more than one machine code number is available for the
1529 same machine type, this function can be used to switch between
47badb7b 1530 the preferred one (alternative == 0) and any others. Currently,
8c98ec7d
AO
1531 only ELF supports this feature, with up to two alternate
1532 machine codes.
1533*/
1534
b34976b6 1535bfd_boolean
c58b9523 1536bfd_alt_mach_code (bfd *abfd, int alternative)
8c98ec7d
AO
1537{
1538 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
1539 {
1540 int code;
1541
47badb7b 1542 switch (alternative)
8c98ec7d
AO
1543 {
1544 case 0:
1545 code = get_elf_backend_data (abfd)->elf_machine_code;
1546 break;
1547
1548 case 1:
1549 code = get_elf_backend_data (abfd)->elf_machine_alt1;
1550 if (code == 0)
b34976b6 1551 return FALSE;
8c98ec7d
AO
1552 break;
1553
1554 case 2:
1555 code = get_elf_backend_data (abfd)->elf_machine_alt2;
1556 if (code == 0)
b34976b6 1557 return FALSE;
8c98ec7d
AO
1558 break;
1559
1560 default:
b34976b6 1561 return FALSE;
8c98ec7d
AO
1562 }
1563
1564 elf_elfheader (abfd)->e_machine = code;
1565
b34976b6 1566 return TRUE;
8c98ec7d
AO
1567 }
1568
b34976b6 1569 return FALSE;
8c98ec7d 1570}
e84d6fca
AM
1571
1572/*
1573CODE_FRAGMENT
1574
1575.struct bfd_preserve
1576.{
c58b9523
AM
1577. void *marker;
1578. void *tdata;
e84d6fca
AM
1579. flagword flags;
1580. const struct bfd_arch_info *arch_info;
198beae2 1581. struct bfd_section *sections;
5daa8fe7 1582. struct bfd_section *section_last;
e84d6fca
AM
1583. unsigned int section_count;
1584. struct bfd_hash_table section_htab;
1585.};
1586.
1587*/
1588
1589/*
1590FUNCTION
1591 bfd_preserve_save
1592
1593SYNOPSIS
b34976b6 1594 bfd_boolean bfd_preserve_save (bfd *, struct bfd_preserve *);
e84d6fca
AM
1595
1596DESCRIPTION
1597 When testing an object for compatibility with a particular
1598 target back-end, the back-end object_p function needs to set
1599 up certain fields in the bfd on successfully recognizing the
1600 object. This typically happens in a piecemeal fashion, with
1601 failures possible at many points. On failure, the bfd is
1602 supposed to be restored to its initial state, which is
1603 virtually impossible. However, restoring a subset of the bfd
1604 state works in practice. This function stores the subset and
1605 reinitializes the bfd.
1606
1607*/
1608
b34976b6 1609bfd_boolean
c58b9523 1610bfd_preserve_save (bfd *abfd, struct bfd_preserve *preserve)
e84d6fca
AM
1611{
1612 preserve->tdata = abfd->tdata.any;
1613 preserve->arch_info = abfd->arch_info;
1614 preserve->flags = abfd->flags;
e84d6fca 1615 preserve->sections = abfd->sections;
5daa8fe7 1616 preserve->section_last = abfd->section_last;
e84d6fca
AM
1617 preserve->section_count = abfd->section_count;
1618 preserve->section_htab = abfd->section_htab;
1619
66eb6687
AM
1620 if (! bfd_hash_table_init (&abfd->section_htab, bfd_section_hash_newfunc,
1621 sizeof (struct section_hash_entry)))
b34976b6 1622 return FALSE;
e84d6fca
AM
1623
1624 abfd->tdata.any = NULL;
1625 abfd->arch_info = &bfd_default_arch_struct;
3ae41454 1626 abfd->flags &= BFD_IN_MEMORY;
e84d6fca 1627 abfd->sections = NULL;
5daa8fe7 1628 abfd->section_last = NULL;
e84d6fca
AM
1629 abfd->section_count = 0;
1630
b34976b6 1631 return TRUE;
e84d6fca
AM
1632}
1633
1634/*
1635FUNCTION
1636 bfd_preserve_restore
1637
1638SYNOPSIS
1639 void bfd_preserve_restore (bfd *, struct bfd_preserve *);
1640
1641DESCRIPTION
1642 This function restores bfd state saved by bfd_preserve_save.
1643 If MARKER is non-NULL in struct bfd_preserve then that block
1644 and all subsequently bfd_alloc'd memory is freed.
1645
1646*/
1647
1648void
c58b9523 1649bfd_preserve_restore (bfd *abfd, struct bfd_preserve *preserve)
e84d6fca
AM
1650{
1651 bfd_hash_table_free (&abfd->section_htab);
1652
1653 abfd->tdata.any = preserve->tdata;
1654 abfd->arch_info = preserve->arch_info;
1655 abfd->flags = preserve->flags;
e84d6fca
AM
1656 abfd->section_htab = preserve->section_htab;
1657 abfd->sections = preserve->sections;
5daa8fe7 1658 abfd->section_last = preserve->section_last;
e84d6fca
AM
1659 abfd->section_count = preserve->section_count;
1660
1661 /* bfd_release frees all memory more recently bfd_alloc'd than
1662 its arg, as well as its arg. */
1663 if (preserve->marker != NULL)
1664 {
1665 bfd_release (abfd, preserve->marker);
1666 preserve->marker = NULL;
1667 }
1668}
1669
1670/*
1671FUNCTION
1672 bfd_preserve_finish
1673
1674SYNOPSIS
1675 void bfd_preserve_finish (bfd *, struct bfd_preserve *);
1676
1677DESCRIPTION
1678 This function should be called when the bfd state saved by
1679 bfd_preserve_save is no longer needed. ie. when the back-end
1680 object_p function returns with success.
1681
1682*/
1683
1684void
c58b9523 1685bfd_preserve_finish (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_preserve *preserve)
e84d6fca
AM
1686{
1687 /* It would be nice to be able to free more memory here, eg. old
1688 tdata, but that's not possible since these blocks are sitting
1689 inside bfd_alloc'd memory. The section hash is on a separate
1690 objalloc. */
1691 bfd_hash_table_free (&preserve->section_htab);
1692}
24718e3b
L
1693
1694/*
1695FUNCTION
1696 bfd_emul_get_maxpagesize
1697
1698SYNOPSIS
1699 bfd_vma bfd_emul_get_maxpagesize (const char *);
1700
1701DESCRIPTION
1702 Returns the maximum page size, in bytes, as determined by
1703 emulation.
1704
1705RETURNS
095106a2 1706 Returns the maximum page size in bytes for ELF, 0 otherwise.
24718e3b
L
1707*/
1708
1709bfd_vma
1710bfd_emul_get_maxpagesize (const char *emul)
1711{
1712 const bfd_target *target;
1713
1714 target = bfd_find_target (emul, NULL);
1715 if (target != NULL
1716 && target->flavour == bfd_target_elf_flavour)
1717 return xvec_get_elf_backend_data (target)->maxpagesize;
1718
24718e3b
L
1719 return 0;
1720}
1721
1722static void
1723bfd_elf_set_pagesize (const bfd_target *target, bfd_vma size,
1724 int offset, const bfd_target *orig_target)
1725{
1726 if (target->flavour == bfd_target_elf_flavour)
1727 {
1728 const struct elf_backend_data *bed;
1729
1730 bed = xvec_get_elf_backend_data (target);
1731 *((bfd_vma *) ((char *) bed + offset)) = size;
1732 }
1733
1734 if (target->alternative_target
1735 && target->alternative_target != orig_target)
1736 bfd_elf_set_pagesize (target->alternative_target, size, offset,
1737 orig_target);
1738}
1739
1740/*
1741FUNCTION
1742 bfd_emul_set_maxpagesize
1743
1744SYNOPSIS
1745 void bfd_emul_set_maxpagesize (const char *, bfd_vma);
1746
1747DESCRIPTION
1748 For ELF, set the maximum page size for the emulation. It is
1749 a no-op for other formats.
1750
1751*/
1752
1753void
1754bfd_emul_set_maxpagesize (const char *emul, bfd_vma size)
1755{
1756 const bfd_target *target;
1757
1758 target = bfd_find_target (emul, NULL);
1759 if (target)
1760 bfd_elf_set_pagesize (target, size,
1761 offsetof (struct elf_backend_data,
1762 maxpagesize), target);
1763}
1764
1765/*
1766FUNCTION
1767 bfd_emul_get_commonpagesize
1768
1769SYNOPSIS
1770 bfd_vma bfd_emul_get_commonpagesize (const char *);
1771
1772DESCRIPTION
1773 Returns the common page size, in bytes, as determined by
1774 emulation.
1775
1776RETURNS
095106a2 1777 Returns the common page size in bytes for ELF, 0 otherwise.
24718e3b
L
1778*/
1779
1780bfd_vma
1781bfd_emul_get_commonpagesize (const char *emul)
1782{
1783 const bfd_target *target;
1784
1785 target = bfd_find_target (emul, NULL);
1786 if (target != NULL
1787 && target->flavour == bfd_target_elf_flavour)
1788 return xvec_get_elf_backend_data (target)->commonpagesize;
1789
24718e3b
L
1790 return 0;
1791}
1792
1793/*
1794FUNCTION
1795 bfd_emul_set_commonpagesize
1796
1797SYNOPSIS
1798 void bfd_emul_set_commonpagesize (const char *, bfd_vma);
1799
1800DESCRIPTION
1801 For ELF, set the common page size for the emulation. It is
1802 a no-op for other formats.
1803
1804*/
1805
1806void
1807bfd_emul_set_commonpagesize (const char *emul, bfd_vma size)
1808{
1809 const bfd_target *target;
1810
1811 target = bfd_find_target (emul, NULL);
1812 if (target)
1813 bfd_elf_set_pagesize (target, size,
1814 offsetof (struct elf_backend_data,
1815 commonpagesize), target);
1816}
3fad56a3
AM
1817
1818/*
1819FUNCTION
1820 bfd_demangle
1821
1822SYNOPSIS
1823 char *bfd_demangle (bfd *, const char *, int);
1824
1825DESCRIPTION
1826 Wrapper around cplus_demangle. Strips leading underscores and
1827 other such chars that would otherwise confuse the demangler.
1828 If passed a g++ v3 ABI mangled name, returns a buffer allocated
1829 with malloc holding the demangled name. Returns NULL otherwise
1830 and on memory alloc failure.
1831*/
1832
1833char *
1834bfd_demangle (bfd *abfd, const char *name, int options)
1835{
1836 char *res, *alloc;
1837 const char *pre, *suf;
1838 size_t pre_len;
c29aae59 1839 bfd_boolean skip_lead;
3fad56a3 1840
c29aae59
AM
1841 skip_lead = (abfd != NULL
1842 && *name != '\0'
1843 && bfd_get_symbol_leading_char (abfd) == *name);
1844 if (skip_lead)
3fad56a3
AM
1845 ++name;
1846
1847 /* This is a hack for better error reporting on XCOFF, PowerPC64-ELF
1848 or the MS PE format. These formats have a number of leading '.'s
1849 on at least some symbols, so we remove all dots to avoid
1850 confusing the demangler. */
1851 pre = name;
1852 while (*name == '.' || *name == '$')
1853 ++name;
1854 pre_len = name - pre;
1855
1856 /* Strip off @plt and suchlike too. */
1857 alloc = NULL;
1858 suf = strchr (name, '@');
1859 if (suf != NULL)
1860 {
1861 alloc = bfd_malloc (suf - name + 1);
1862 if (alloc == NULL)
1863 return NULL;
1864 memcpy (alloc, name, suf - name);
1865 alloc[suf - name] = '\0';
1866 name = alloc;
1867 }
1868
1869 res = cplus_demangle (name, options);
1870
1871 if (alloc != NULL)
1872 free (alloc);
1873
1874 if (res == NULL)
c29aae59
AM
1875 {
1876 if (skip_lead)
1877 {
1878 size_t len = strlen (pre) + 1;
1879 alloc = bfd_malloc (len);
1880 if (alloc == NULL)
1881 return NULL;
1882 memcpy (alloc, pre, len);
1883 return alloc;
1884 }
1885 return NULL;
1886 }
3fad56a3
AM
1887
1888 /* Put back any prefix or suffix. */
1889 if (pre_len != 0 || suf != NULL)
1890 {
1891 size_t len;
1892 size_t suf_len;
1893 char *final;
1894
1895 len = strlen (res);
1896 if (suf == NULL)
1897 suf = res + len;
1898 suf_len = strlen (suf) + 1;
1899 final = bfd_malloc (pre_len + len + suf_len);
32e8a950
NC
1900 if (final != NULL)
1901 {
1902 memcpy (final, pre, pre_len);
1903 memcpy (final + pre_len, res, len);
1904 memcpy (final + pre_len + len, suf, suf_len);
1905 }
3fad56a3
AM
1906 free (res);
1907 res = final;
1908 }
1909
1910 return res;
1911}
This page took 0.631455 seconds and 4 git commands to generate.