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