1 /* A -*- C -*- header file for the bfd library
2 Copyright 1990, 1991 Free Software Foundation, Inc.
3 Contributed by Cygnus Support.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
21 /* bfd.h -- The only header file required by users of the bfd library
23 This file is generated from various .c files, if you change it, your
26 All the prototypes and definitions following the comment "THE FOLLOWING
27 IS EXTRACTED FROM THE SOURCE" are extracted from the source files for
28 BFD. If you change it, someone oneday will extract it from the source
29 again, and your changes will be lost. To save yourself from this bind,
30 change the definitions in the source in the bfd directory. Type "make
31 docs" and then "make headers" in that directory, and magically this file
32 will change to reflect your changes.
34 If you don't have the tools to perform the extraction, then you are
35 safe from someone on your system trampling over your header files.
36 You should still maintain the equivalence between the source and this
37 file though; every change you make to the .c file should be reflected
40 #ifndef __BFD_H_SEEN__
41 #define __BFD_H_SEEN__
46 /* Make it easier to declare prototypes (puts conditional here) */
49 # define PROTO(type, name, arglist) type name arglist
51 # define PROTO(type, name, arglist) type name ()
55 #define BFD_VERSION "2.0"
57 /* forward declaration */
58 typedef struct _bfd bfd;
60 /* General rules: functions which are boolean return true on success
61 and false on failure (unless they're a predicate). -- bfd.doc */
62 /* I'm sure this is going to break something and someone is going to
63 force me to change it. */
64 /* typedef enum boolean {false, true} boolean; */
65 /* Yup, SVR4 has a "typedef enum boolean" in <sys/types.h> -fnf */
66 typedef enum bfd_boolean {false, true} boolean;
68 /* Try to avoid breaking stuff */
69 typedef long int file_ptr;
71 /* Support for different sizes of target format ints and addresses */
74 typedef HOST_64_BIT rawdata_offset;
75 typedef HOST_64_BIT bfd_vma;
76 typedef HOST_64_BIT bfd_word;
77 typedef HOST_64_BIT bfd_offset;
78 typedef HOST_64_BIT bfd_size_type;
79 typedef HOST_64_BIT symvalue;
80 typedef HOST_64_BIT bfd_64_type;
81 #define fprintf_vma(s,x) \
82 fprintf(s,"%08x%08x", uint64_typeHIGH(x), uint64_typeLOW(x))
84 typedef struct {int a,b;} bfd_64_type;
85 typedef unsigned long rawdata_offset;
86 typedef unsigned long bfd_vma;
87 typedef unsigned long bfd_offset;
88 typedef unsigned long bfd_word;
89 typedef unsigned long bfd_size;
90 typedef unsigned long symvalue;
91 typedef unsigned long bfd_size_type;
92 #define fprintf_vma(s,x) fprintf(s, "%08lx", x)
94 #define printf_vma(x) fprintf_vma(stdout,x)
96 typedef unsigned int flagword; /* 32 bits of flags */
100 typedef enum bfd_format {
101 bfd_unknown = 0, /* file format is unknown */
102 bfd_object, /* linker/assember/compiler output */
103 bfd_archive, /* object archive file */
104 bfd_core, /* core dump */
105 bfd_type_end} /* marks the end; don't use it! */
108 /* Object file flag values */
109 #define NO_FLAGS 0x00
110 #define HAS_RELOC 0x01
112 #define HAS_LINENO 0x04
113 #define HAS_DEBUG 0x08
114 #define HAS_SYMS 0x10
115 #define HAS_LOCALS 0x20
118 #define D_PAGED 0x100
119 #define BFD_IS_RELAXABLE 0x200
121 /* symbols and relocation */
123 typedef unsigned long symindex;
125 #define BFD_NO_MORE_SYMBOLS ((symindex) ~0)
127 typedef enum bfd_symclass {
128 bfd_symclass_unknown = 0,
129 bfd_symclass_fcommon, /* fortran common symbols */
130 bfd_symclass_global, /* global symbol, what a surprise */
131 bfd_symclass_debugger, /* some debugger symbol */
132 bfd_symclass_undefined /* none known */
136 typedef int symtype; /* Who knows, yet? */
139 /* general purpose part of a symbol;
140 target specific parts will be found in libcoff.h, liba.out.h etc */
143 #define bfd_get_section(x) ((x)->section)
144 #define bfd_get_output_section(x) ((x)->section->output_section)
145 #define bfd_set_section(x,y) ((x)->section) = (y)
146 #define bfd_asymbol_base(x) ((x)->section?((x)->section->vma):0)
147 #define bfd_asymbol_value(x) (bfd_asymbol_base(x) + x->value)
148 #define bfd_asymbol_name(x) ((x)->name)
150 /* This is a type pun with struct ranlib on purpose! */
151 typedef struct carsym {
153 file_ptr file_offset; /* look here to find the file */
154 } carsym; /* to make these you call a carsymogen */
157 /* Used in generating armaps. Perhaps just a forward definition would do? */
158 struct orl { /* output ranlib */
159 char **name; /* symbol name */
160 file_ptr pos; /* bfd* or file position */
161 int namidx; /* index into string table */
166 /* Linenumber stuff */
167 typedef struct lineno_cache_entry {
168 unsigned int line_number; /* Linenumber from start of function*/
170 struct symbol_cache_entry *sym; /* Function name */
171 unsigned long offset; /* Offset into section */
175 /* object and core file sections */
178 #define align_power(addr, align) \
179 ( ((addr) + ((1<<(align))-1)) & (-1 << (align)))
181 typedef struct sec *sec_ptr;
183 #define bfd_get_section_name(bfd, ptr) ((ptr)->name + 0)
184 #define bfd_get_section_vma(bfd, ptr) ((ptr)->vma + 0)
185 #define bfd_get_section_alignment(bfd, ptr) ((ptr)->alignment_power + 0)
186 #define bfd_section_name(bfd, ptr) ((ptr)->name)
187 #define bfd_section_size(bfd, ptr) (bfd_get_section_size_before_reloc(ptr))
188 #define bfd_section_vma(bfd, ptr) ((ptr)->vma)
189 #define bfd_section_alignment(bfd, ptr) ((ptr)->alignment_power)
190 #define bfd_get_section_flags(bfd, ptr) ((ptr)->flags + 0)
191 #define bfd_get_section_userdata(bfd, ptr) ((ptr)->userdata)
193 #define bfd_set_section_vma(bfd, ptr, val) (((ptr)->vma = (val)), ((ptr)->user_set_vma = true), true)
194 #define bfd_set_section_alignment(bfd, ptr, val) (((ptr)->alignment_power = (val)),true)
195 #define bfd_set_section_userdata(bfd, ptr, val) (((ptr)->userdata = (val)),true)
197 typedef struct stat stat_type;
199 /** Error handling */
201 typedef enum bfd_error {
202 no_error = 0, system_call_error, invalid_target,
203 wrong_format, invalid_operation, no_memory,
204 no_symbols, no_relocation_info,
205 no_more_archived_files, malformed_archive,
206 symbol_not_found, file_not_recognized,
207 file_ambiguously_recognized, no_contents,
208 bfd_error_nonrepresentable_section,
209 no_debug_section, bad_value,
210 invalid_error_code} bfd_ec;
212 extern bfd_ec bfd_error;
213 struct reloc_cache_entry;
214 struct bfd_seclet_struct ;
217 typedef struct bfd_error_vector {
218 PROTO(void,(* nonrepresentable_section ),(CONST bfd *CONST abfd,
219 CONST char *CONST name));
220 PROTO(void,(* undefined_symbol),(CONST struct reloc_cache_entry *rel,
221 CONST struct bfd_seclet_struct *sec
223 PROTO(void, (* reloc_value_truncated),(CONST struct
224 reloc_cache_entry *rel,
225 struct bfd_seclet_struct *sec));
227 PROTO(void, (* reloc_dangerous),(CONST struct reloc_cache_entry *rel,
228 CONST struct bfd_seclet_struct *sec));
230 } bfd_error_vector_type;
232 PROTO (CONST char *, bfd_errmsg, (bfd_ec error_tag));
233 PROTO (void, bfd_perror, (CONST char *message));
236 typedef enum bfd_print_symbol
238 bfd_print_symbol_name,
239 bfd_print_symbol_more,
240 bfd_print_symbol_all,
241 bfd_print_symbol_nm /* Pretty format suitable for nm program. */
242 } bfd_print_symbol_type;
246 /* The code that implements targets can initialize a jump table with this
247 macro. It must name all its routines the same way (a prefix plus
248 the standard routine suffix), or it must #define the routines that
249 are not so named, before calling JUMP_TABLE in the initializer. */
251 /* Semi-portable string concatenation in cpp */
254 #define CAT(a,b) a##b
256 #define CAT(a,b) a/**/b
260 #define JUMP_TABLE(NAME)\
261 CAT(NAME,_core_file_failing_command),\
262 CAT(NAME,_core_file_failing_signal),\
263 CAT(NAME,_core_file_matches_executable_p),\
264 CAT(NAME,_slurp_armap),\
265 CAT(NAME,_slurp_extended_name_table),\
266 CAT(NAME,_truncate_arname),\
267 CAT(NAME,_write_armap),\
268 CAT(NAME,_close_and_cleanup), \
269 CAT(NAME,_set_section_contents),\
270 CAT(NAME,_get_section_contents),\
271 CAT(NAME,_new_section_hook),\
272 CAT(NAME,_get_symtab_upper_bound),\
273 CAT(NAME,_get_symtab),\
274 CAT(NAME,_get_reloc_upper_bound),\
275 CAT(NAME,_canonicalize_reloc),\
276 CAT(NAME,_make_empty_symbol),\
277 CAT(NAME,_print_symbol),\
278 CAT(NAME,_get_lineno),\
279 CAT(NAME,_set_arch_mach),\
280 CAT(NAME,_openr_next_archived_file),\
281 CAT(NAME,_find_nearest_line),\
282 CAT(NAME,_generic_stat_arch_elt),\
283 CAT(NAME,_sizeof_headers),\
284 CAT(NAME,_bfd_debug_info_start),\
285 CAT(NAME,_bfd_debug_info_end),\
286 CAT(NAME,_bfd_debug_info_accumulate),\
287 CAT(NAME,_bfd_get_relocated_section_contents),\
288 CAT(NAME,_bfd_relax_section)
290 #define COFF_SWAP_TABLE \
291 coff_swap_aux_in, coff_swap_sym_in, coff_swap_lineno_in, \
292 coff_swap_aux_out, coff_swap_sym_out, \
293 coff_swap_lineno_out, coff_swap_reloc_out, \
294 coff_swap_filehdr_out, coff_swap_aouthdr_out, \
299 /* User program access to BFD facilities */
301 extern CONST short _bfd_host_big_endian;
302 #define HOST_BYTE_ORDER_BIG_P (*(char *)&_bfd_host_big_endian)
306 /* Cast from const char * to char * so that caller can assign to
307 a char * without a warning. */
308 #define bfd_get_filename(abfd) ((char *) (abfd)->filename)
309 #define bfd_get_format(abfd) ((abfd)->format)
310 #define bfd_get_target(abfd) ((abfd)->xvec->name)
311 #define bfd_get_file_flags(abfd) ((abfd)->flags)
312 #define bfd_applicable_file_flags(abfd) ((abfd)->xvec->object_flags)
313 #define bfd_applicable_section_flags(abfd) ((abfd)->xvec->section_flags)
314 #define bfd_my_archive(abfd) ((abfd)->my_archive)
315 #define bfd_has_map(abfd) ((abfd)->has_armap)
316 #define bfd_header_twiddle_required(abfd) \
317 ((((abfd)->xvec->header_byteorder_big_p) \
318 != (boolean)HOST_BYTE_ORDER_BIG_P) ? true:false)
320 #define bfd_valid_reloc_types(abfd) ((abfd)->xvec->valid_reloc_types)
321 #define bfd_usrdata(abfd) ((abfd)->usrdata)
323 #define bfd_get_start_address(abfd) ((abfd)->start_address)
324 #define bfd_get_symcount(abfd) ((abfd)->symcount)
325 #define bfd_get_outsymbols(abfd) ((abfd)->outsymbols)
326 #define bfd_count_sections(abfd) ((abfd)->section_count)
327 #define bfd_get_architecture(abfd) ((abfd)->obj_arch)
328 #define bfd_get_machine(abfd) ((abfd)->obj_machine)
336 /* And more from the source. */
337 void EXFUN(bfd_init, (void));
338 bfd *EXFUN(bfd_openr, (CONST char *filename, CONST char*target));
339 bfd *EXFUN(bfd_fdopenr, (CONST char *filename, CONST char *target, int fd));
340 bfd *EXFUN(bfd_openw, (CONST char *filename, CONST char *target));
341 boolean EXFUN(bfd_close, (bfd *));
342 boolean EXFUN(bfd_close_all_done, (bfd *));
343 bfd_size_type EXFUN(bfd_alloc_size, (bfd *abfd));
344 bfd *EXFUN(bfd_create, (CONST char *filename, bfd *template));
345 #define bfd_put_8(abfd, val, ptr) \
346 (*((char *)ptr) = (char)val)
347 #define bfd_get_8(abfd, ptr) \
349 #define bfd_put_16(abfd, val, ptr) \
350 BFD_SEND(abfd, bfd_putx16, (val,ptr))
351 #define bfd_get_16(abfd, ptr) \
352 BFD_SEND(abfd, bfd_getx16, (ptr))
353 #define bfd_put_32(abfd, val, ptr) \
354 BFD_SEND(abfd, bfd_putx32, (val,ptr))
355 #define bfd_get_32(abfd, ptr) \
356 BFD_SEND(abfd, bfd_getx32, (ptr))
357 #define bfd_put_64(abfd, val, ptr) \
358 BFD_SEND(abfd, bfd_putx64, (val, ptr))
359 #define bfd_get_64(abfd, ptr) \
360 BFD_SEND(abfd, bfd_getx64, (ptr))
361 #define bfd_h_put_8(abfd, val, ptr) \
362 (*((char *)ptr) = (char)val)
363 #define bfd_h_get_8(abfd, ptr) \
365 #define bfd_h_put_16(abfd, val, ptr) \
366 BFD_SEND(abfd, bfd_h_putx16,(val,ptr))
367 #define bfd_h_get_16(abfd, ptr) \
368 BFD_SEND(abfd, bfd_h_getx16,(ptr))
369 #define bfd_h_put_32(abfd, val, ptr) \
370 BFD_SEND(abfd, bfd_h_putx32,(val,ptr))
371 #define bfd_h_get_32(abfd, ptr) \
372 BFD_SEND(abfd, bfd_h_getx32,(ptr))
373 #define bfd_h_put_64(abfd, val, ptr) \
374 BFD_SEND(abfd, bfd_h_putx64,(val, ptr))
375 #define bfd_h_get_64(abfd, ptr) \
376 BFD_SEND(abfd, bfd_h_getx64,(ptr))
379 /* The name of the section, the name isn't a copy, the pointer is
380 the same as that passed to bfd_make_section. */
385 /* Which section is it 0.nth */
389 /* The next section in the list belonging to the BFD, or NULL. */
393 /* The field flags contains attributes of the section. Some of
394 flags are read in from the object file, and some are
395 synthesized from other information. */
399 #define SEC_NO_FLAGS 0x000
401 /* Tells the OS to allocate space for this section when loaded.
402 This would clear for a section containing debug information
406 #define SEC_ALLOC 0x001
407 /* Tells the OS to load the section from the file when loading.
408 This would be clear for a .bss section */
410 #define SEC_LOAD 0x002
411 /* The section contains data still to be relocated, so there will
412 be some relocation information too. */
414 #define SEC_RELOC 0x004
418 #define SEC_BALIGN 0x008
420 /* A signal to the OS that the section contains read only
422 #define SEC_READONLY 0x010
424 /* The section contains code only. */
426 #define SEC_CODE 0x020
428 /* The section contains data only. */
430 #define SEC_DATA 0x040
432 /* The section will reside in ROM. */
434 #define SEC_ROM 0x080
436 /* The section contains constructor information. This section
437 type is used by the linker to create lists of constructors and
438 destructors used by <<g++>>. When a back end sees a symbol
439 which should be used in a constructor list, it creates a new
440 section for the type of name (eg <<__CTOR_LIST__>>), attaches
441 the symbol to it and builds a relocation. To build the lists
442 of constructors, all the linker has to to is catenate all the
443 sections called <<__CTOR_LIST__>> and relocte the data
444 contained within - exactly the operations it would peform on
447 #define SEC_CONSTRUCTOR 0x100
449 /* The section is a constuctor, and should be placed at the
453 #define SEC_CONSTRUCTOR_TEXT 0x1100
455 #define SEC_CONSTRUCTOR_DATA 0x2100
457 #define SEC_CONSTRUCTOR_BSS 0x3100
460 /* The section has contents - a bss section could be
461 <<SEC_ALLOC>> | <<SEC_HAS_CONTENTS>>, a debug section could be
462 <<SEC_HAS_CONTENTS>> */
464 #define SEC_HAS_CONTENTS 0x200
466 /* An instruction to the linker not to output sections
467 containing this flag even if they have information which
468 would normally be written. */
470 #define SEC_NEVER_LOAD 0x400
475 boolean user_set_vma;
477 /* The size of the section in bytes, as it will be output.
478 contains a value even if the section has no contents (eg, the
479 size of <<.bss>>). This will be filled in after relocation */
481 bfd_size_type _cooked_size;
483 /* The size on disk of the section in bytes originally. Normally this
484 value is the same as the size, but if some relaxing has
485 been done, then this value will be bigger. */
487 bfd_size_type _raw_size;
489 /* If this section is going to be output, then this value is the
490 offset into the output section of the first byte in the input
491 section. Eg, if this was going to start at the 100th byte in
492 the output section, this value would be 100. */
494 bfd_vma output_offset;
496 /* The output section through which to map on output. */
498 struct sec *output_section;
500 /* The alignment requirement of the section, as an exponent - eg
501 3 aligns to 2^3 (or 8) */
503 unsigned int alignment_power;
505 /* If an input section, a pointer to a vector of relocation
506 records for the data in this section. */
508 struct reloc_cache_entry *relocation;
510 /* If an output section, a pointer to a vector of pointers to
511 relocation records for the data in this section. */
513 struct reloc_cache_entry **orelocation;
515 /* The number of relocation records in one of the above */
517 unsigned reloc_count;
519 /* Information below is back end specific - and not always used
522 File position of section data */
526 /* File position of relocation info */
528 file_ptr rel_filepos;
530 /* File position of line data */
532 file_ptr line_filepos;
534 /* Pointer to data for applications */
538 struct lang_output_section *otheruserdata;
540 /* Attached line number information */
544 /* Number of line number records */
546 unsigned int lineno_count;
548 /* When a section is being output, this value changes as more
549 linenumbers are written out */
551 file_ptr moving_line_filepos;
553 /* what the section number is in the target world */
559 /* If this is a constructor section then here is a list of the
560 relocations created to relocate items within it. */
562 struct relent_chain *constructor_chain;
564 /* The BFD which owns the section. */
569 /* A symbol which points at this section only */
570 struct symbol_cache_entry *symbol;
571 struct symbol_cache_entry **symbol_ptr_ptr;
572 struct bfd_seclet_struct *seclets_head;
573 struct bfd_seclet_struct *seclets_tail;
577 #define BFD_ABS_SECTION_NAME "*ABS*"
578 #define BFD_UND_SECTION_NAME "*UND*"
579 #define BFD_COM_SECTION_NAME "*COM*"
581 /* the absolute section */
582 extern asection bfd_abs_section;
583 /* Pointer to the undefined section */
584 extern asection bfd_und_section;
585 /* Pointer to the common section */
586 extern asection bfd_com_section;
588 extern struct symbol_cache_entry *bfd_abs_symbol;
589 extern struct symbol_cache_entry *bfd_com_symbol;
590 extern struct symbol_cache_entry *bfd_und_symbol;
591 #define bfd_get_section_size_before_reloc(section) \
592 (section->reloc_done ? (abort(),1): (section)->_raw_size)
593 #define bfd_get_section_size_after_reloc(section) \
594 ((section->reloc_done) ? (section)->_cooked_size: (abort(),1))
595 asection *EXFUN(bfd_get_section_by_name, (bfd *abfd, CONST char *name));
596 asection *EXFUN(bfd_make_section_old_way, (bfd *, CONST char *name));
597 asection * EXFUN(bfd_make_section, (bfd *, CONST char *name));
598 boolean EXFUN(bfd_set_section_flags, (bfd *, asection *, flagword));
599 void EXFUN(bfd_map_over_sections, (bfd *abfd,
600 void (*func)(bfd *abfd,
604 boolean EXFUN(bfd_set_section_size, (bfd *, asection *, bfd_size_type val));
605 boolean EXFUN(bfd_set_section_contents
610 bfd_size_type count));
611 boolean EXFUN(bfd_get_section_contents
612 , (bfd *abfd, asection *section, PTR location,
613 file_ptr offset, bfd_size_type count));
614 enum bfd_architecture
616 bfd_arch_unknown, /* File arch not known */
617 bfd_arch_obscure, /* Arch known, not one of these */
618 bfd_arch_m68k, /* Motorola 68xxx */
619 bfd_arch_vax, /* DEC Vax */
620 bfd_arch_i960, /* Intel 960 */
621 /* The order of the following is important.
622 lower number indicates a machine type that
623 only accepts a subset of the instructions
624 available to machines with higher numbers.
625 The exception is the "ca", which is
626 incompatible with all other machines except
629 #define bfd_mach_i960_core 1
630 #define bfd_mach_i960_ka_sa 2
631 #define bfd_mach_i960_kb_sb 3
632 #define bfd_mach_i960_mc 4
633 #define bfd_mach_i960_xa 5
634 #define bfd_mach_i960_ca 6
636 bfd_arch_a29k, /* AMD 29000 */
637 bfd_arch_sparc, /* SPARC */
638 bfd_arch_mips, /* MIPS Rxxxx */
639 bfd_arch_i386, /* Intel 386 */
640 bfd_arch_we32k, /* AT&T WE32xxx */
641 bfd_arch_tahoe, /* CCI/Harris Tahoe */
642 bfd_arch_i860, /* Intel 860 */
643 bfd_arch_romp, /* IBM ROMP PC/RT */
644 bfd_arch_alliant, /* Alliant */
645 bfd_arch_convex, /* Convex */
646 bfd_arch_m88k, /* Motorola 88xxx */
647 bfd_arch_pyramid, /* Pyramid Technology */
648 bfd_arch_h8300, /* Hitachi H8/300 */
649 bfd_arch_rs6000, /* IBM RS/6000 */
650 bfd_arch_hppa, /* HP PA RISC */
651 bfd_arch_z8k, /* Zilog Z8000 */
652 #define bfd_mach_z8001 1
653 #define bfd_mach_z8002 2
657 typedef struct bfd_arch_info
660 int bits_per_address;
662 enum bfd_architecture arch;
665 CONST char *printable_name;
666 unsigned int section_align_power;
667 /* true if this is the default machine for the architecture */
669 CONST struct bfd_arch_info * EXFUN((*compatible),
670 (CONST struct bfd_arch_info *a,
671 CONST struct bfd_arch_info *b));
673 boolean EXFUN((*scan),(CONST struct bfd_arch_info *,CONST char *));
674 unsigned int EXFUN((*disassemble),(bfd_vma addr, CONST char *data,
677 struct bfd_arch_info *next;
678 } bfd_arch_info_type;
679 CONST char *EXFUN(bfd_printable_name, (bfd *abfd));
680 bfd_arch_info_type *EXFUN(bfd_scan_arch, (CONST char *));
681 CONST bfd_arch_info_type *EXFUN(bfd_arch_get_compatible, (
684 void EXFUN(bfd_set_arch_info, (bfd *, bfd_arch_info_type *));
685 enum bfd_architecture EXFUN(bfd_get_arch, (bfd *abfd));
686 unsigned long EXFUN(bfd_get_mach, (bfd *abfd));
687 unsigned int EXFUN(bfd_arch_bits_per_byte, (bfd *abfd));
688 unsigned int EXFUN(bfd_arch_bits_per_address, (bfd *abfd));
689 bfd_arch_info_type * EXFUN(bfd_get_arch_info, (bfd *));
690 bfd_arch_info_type *EXFUN(bfd_lookup_arch
691 , (enum bfd_architecture
694 CONST char * EXFUN(bfd_printable_arch_mach
695 , (enum bfd_architecture arch, unsigned long machine));
696 typedef enum bfd_reloc_status
698 /* No errors detected */
701 /* The relocation was performed, but there was an overflow. */
704 /* The address to relocate was not within the section supplied*/
705 bfd_reloc_outofrange,
707 /* Used by special functions */
711 bfd_reloc_notsupported,
713 /* Unsupported relocation size requested. */
716 /* The symbol to relocate against was undefined.*/
719 /* The relocation was performed, but may not be ok - presently
720 generated only when linking i960 coff files with i960 b.out
724 bfd_reloc_status_type;
727 typedef struct reloc_cache_entry
729 /* A pointer into the canonical table of pointers */
730 struct symbol_cache_entry **sym_ptr_ptr;
732 /* offset in section */
733 rawdata_offset address;
735 /* addend for relocation value */
738 /* Pointer to how to perform the required relocation */
739 CONST struct reloc_howto_struct *howto;
743 typedef CONST struct reloc_howto_struct
745 /* The type field has mainly a documetary use - the back end can
746 to what it wants with it, though the normally the back end's
747 external idea of what a reloc number would be would be stored
748 in this field. For example, the a PC relative word relocation
749 in a coff environment would have the type 023 - because that's
750 what the outside world calls a R_PCRWORD reloc. */
753 /* The value the final relocation is shifted right by. This drops
754 unwanted data from the relocation. */
755 unsigned int rightshift;
757 /* The size of the item to be relocated - 0, is one byte, 1 is 2
758 bytes, 3 is four bytes. A -ve value indicates that the
759 result is to be subtracted from the data*/
763 unsigned int bitsize;
765 /* Notes that the relocation is relative to the location in the
766 data section of the addend. The relocation function will
767 subtract from the relocation value the address of the location
777 /* Causes the relocation routine to return an error if overflow
778 is detected when relocating. */
779 boolean complain_on_overflow;
781 /* If this field is non null, then the supplied function is
782 called rather than the normal function. This allows really
783 strange relocation methods to be accomodated (eg, i960 callj
785 bfd_reloc_status_type EXFUN ((*special_function),
787 arelent *reloc_entry,
788 struct symbol_cache_entry *symbol,
790 asection *input_section,
793 /* The textual name of the relocation type. */
796 /* When performing a partial link, some formats must modify the
797 relocations rather than the data - this flag signals this.*/
798 boolean partial_inplace;
800 /* The src_mask is used to select what parts of the read in data
801 are to be used in the relocation sum. Eg, if this was an 8 bit
802 bit of data which we read and relocated, this would be
803 0x000000ff. When we have relocs which have an addend, such as
804 sun4 extended relocs, the value in the offset part of a
805 relocating field is garbage so we never use it. In this case
806 the mask would be 0x00000000. */
809 /* The dst_mask is what parts of the instruction are replaced
810 into the instruction. In most cases src_mask == dst_mask,
811 except in the above special case, where dst_mask would be
812 0x000000ff, and src_mask would be 0x00000000. */
815 /* When some formats create PC relative instructions, they leave
816 the value of the pc of the place being relocated in the offset
817 slot of the instruction, so that a PC relative relocation can
818 be made just by adding in an ordinary offset (eg sun3 a.out).
819 Some formats leave the displacement part of an instruction
820 empty (eg m88k bcs), this flag signals the fact.*/
821 boolean pcrel_offset;
824 #define HOWTO(C, R,S,B, P, BI, ABS, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC) \
825 {(unsigned)C,R,S,B, P, BI, ABS,O,SF,NAME,INPLACE,MASKSRC,MASKDST,PC}
826 #define NEWHOWTO( FUNCTION, NAME,SIZE,REL,IN) HOWTO(0,0,SIZE,0,REL,0,false,false,FUNCTION, NAME,false,0,0,IN)
828 #define HOWTO_PREPARE(relocation, symbol) \
830 if (symbol != (asymbol *)NULL) { \
831 if (symbol->section == &bfd_com_section) { \
835 relocation = symbol->value; \
839 typedef unsigned char bfd_byte;
841 typedef struct relent_chain {
843 struct relent_chain *next;
845 bfd_reloc_status_type
846 EXFUN(bfd_perform_relocation
848 arelent *reloc_entry,
850 asection *input_section,
852 typedef enum bfd_reloc_code_real
855 /* 16 bits wide, simple reloc */
858 /* 8 bits wide, but used to form an address like 0xffnn */
861 /* 8 bits wide, simple */
864 /* 8 bits wide, pc relative */
867 /* The type of reloc used to build a contructor table - at the
868 moment probably a 32 bit wide abs address, but the cpu can
873 /* 32 bits wide, simple reloc */
875 /* 32 bits, PC-relative */
878 /* High 22 bits of 32-bit value; simple reloc. */
883 /* Reloc types used for i960/b.out. */
885 BFD_RELOC_I960_CALLJ,
888 /* 32-bit pc-relative, shifted right 2 bits (i.e., 30-bit
889 word displacement, e.g. for SPARC) */
890 BFD_RELOC_32_PCREL_S2,
892 /* now for the sparc/elf codes */
893 BFD_RELOC_NONE, /* actually used */
894 BFD_RELOC_SPARC_WDISP22,
897 BFD_RELOC_SPARC_BASE13,
898 BFD_RELOC_SPARC_GOT10,
899 BFD_RELOC_SPARC_GOT13,
900 BFD_RELOC_SPARC_GOT22,
901 BFD_RELOC_SPARC_PC10,
902 BFD_RELOC_SPARC_PC22,
903 BFD_RELOC_SPARC_WPLT30,
904 BFD_RELOC_SPARC_COPY,
905 BFD_RELOC_SPARC_GLOB_DAT,
906 BFD_RELOC_SPARC_JMP_SLOT,
907 BFD_RELOC_SPARC_RELATIVE,
908 BFD_RELOC_SPARC_UA32,
910 /* this one is a.out specific? */
911 BFD_RELOC_SPARC_BASE22,
913 /* this must be the highest numeric value */
915 } bfd_reloc_code_real_type;
916 CONST struct reloc_howto_struct *
917 EXFUN(bfd_reloc_type_lookup , (bfd *abfd, bfd_reloc_code_real_type code));
918 typedef struct symbol_cache_entry
920 /* A pointer to the BFD which owns the symbol. This information
921 is necessary so that a back end can work out what additional
922 (invisible to the application writer) information is carried
925 struct _bfd *the_bfd;
927 /* The text of the symbol. The name is left alone, and not copied - the
928 application may not alter it. */
931 /* The value of the symbol.*/
934 /* Attributes of a symbol: */
936 #define BSF_NO_FLAGS 0x00
938 /* The symbol has local scope; <<static>> in <<C>>. The value
939 is the offset into the section of the data. */
940 #define BSF_LOCAL 0x01
942 /* The symbol has global scope; initialized data in <<C>>. The
943 value is the offset into the section of the data. */
944 #define BSF_GLOBAL 0x02
947 #define BSF_IMPORT 0x04
949 /* The symbol has global scope, and is exported. The value is
950 the offset into the section of the data. */
951 #define BSF_EXPORT 0x08
953 /* The symbol is undefined. <<extern>> in <<C>>. The value has
955 #define BSF_UNDEFINED_OBS 0x10
957 /* The symbol is common, initialized to zero; default in
958 <<C>>. The value is the size of the object in bytes. */
959 #define BSF_FORT_COMM_OBS 0x20
961 /* A normal C symbol would be one of:
962 <<BSF_LOCAL>>, <<BSF_FORT_COMM>>, <<BSF_UNDEFINED>> or
963 <<BSF_EXPORT|BSD_GLOBAL>> */
965 /* The symbol is a debugging record. The value has an arbitary
967 #define BSF_DEBUGGING 0x40
969 /* Used by the linker */
970 #define BSF_KEEP 0x10000
971 #define BSF_KEEP_G 0x80000
974 #define BSF_WEAK 0x100000
975 #define BSF_CTOR 0x200000
977 /* This symbol was created to point to a section, e.g. ELF's
978 STT_SECTION symbols. */
979 #define BSF_SECTION_SYM 0x400000
981 /* The symbol used to be a common symbol, but now it is
983 #define BSF_OLD_COMMON 0x800000
985 /* The default value for common data. */
986 #define BFD_FORT_COMM_DEFAULT_VALUE 0
988 /* In some files the type of a symbol sometimes alters its
989 location in an output file - ie in coff a <<ISFCN>> symbol
990 which is also <<C_EXT>> symbol appears where it was
991 declared and not at the end of a section. This bit is set
992 by the target BFD part to convey this information. */
994 #define BSF_NOT_AT_END 0x40000
996 /* Signal that the symbol is the label of constructor section. */
997 #define BSF_CONSTRUCTOR 0x1000000
999 /* Signal that the symbol is a warning symbol. If the symbol
1000 is a warning symbol, then the value field (I know this is
1001 tacky) will point to the asymbol which when referenced will
1002 cause the warning. */
1003 #define BSF_WARNING 0x2000000
1005 /* Signal that the symbol is indirect. The value of the symbol
1006 is a pointer to an undefined asymbol which contains the
1007 name to use instead. */
1008 #define BSF_INDIRECT 0x4000000
1010 /* BSF_FILE marks symbols that contain a file name. This is used
1011 for ELF STT_FILE symbols. */
1012 #define BSF_FILE 0x08000000
1016 /* A pointer to the section to which this symbol is
1017 relative. This will always be non NULL, there are special
1018 sections for undefined and absolute symbols */
1019 struct sec *section;
1021 /* Back end special data. This is being phased out in favour
1022 of making this a union. */
1026 #define get_symtab_upper_bound(abfd) \
1027 BFD_SEND (abfd, _get_symtab_upper_bound, (abfd))
1028 #define bfd_canonicalize_symtab(abfd, location) \
1029 BFD_SEND (abfd, _bfd_canonicalize_symtab,\
1031 boolean EXFUN(bfd_set_symtab , (bfd *, asymbol **, unsigned int ));
1032 void EXFUN(bfd_print_symbol_vandf, (PTR file, asymbol *symbol));
1033 #define bfd_make_empty_symbol(abfd) \
1034 BFD_SEND (abfd, _bfd_make_empty_symbol, (abfd))
1035 #define bfd_make_debug_symbol(abfd,ptr,size) \
1036 BFD_SEND (abfd, _bfd_make_debug_symbol, (abfd, ptr, size))
1037 int EXFUN(bfd_decode_symclass, (asymbol *symbol));
1040 /* The filename the application opened the BFD with. */
1041 CONST char *filename;
1043 /* A pointer to the target jump table. */
1044 struct bfd_target *xvec;
1046 /* To avoid dragging too many header files into every file that
1047 includes `<<bfd.h>>', IOSTREAM has been declared as a "char
1048 *", and MTIME as a "long". Their correct types, to which they
1049 are cast when used, are "FILE *" and "time_t". The iostream
1050 is the result of an fopen on the filename. */
1053 /* Is the file being cached */
1057 /* Marks whether there was a default target specified when the
1058 BFD was opened. This is used to select what matching algorithm
1059 to use to chose the back end. */
1061 boolean target_defaulted;
1063 /* The caching routines use these to maintain a
1064 least-recently-used list of BFDs */
1066 struct _bfd *lru_prev, *lru_next;
1068 /* When a file is closed by the caching routines, BFD retains
1069 state information on the file here:
1076 boolean opened_once;
1078 /* Set if we have a locally maintained mtime value, rather than
1079 getting it from the file each time: */
1083 /* File modified time, if mtime_set is true: */
1087 /* Reserved for an unimplemented file locking extension.*/
1091 /* The format which belongs to the BFD.*/
1095 /* The direction the BFD was opened with*/
1097 enum bfd_direction {no_direction = 0,
1099 write_direction = 2,
1100 both_direction = 3} direction;
1102 /* Format_specific flags*/
1106 /* Currently my_archive is tested before adding origin to
1107 anything. I believe that this can become always an add of
1108 origin, with origin set to 0 for non archive files. */
1112 /* Remember when output has begun, to stop strange things
1114 boolean output_has_begun;
1116 /* Pointer to linked list of sections*/
1117 struct sec *sections;
1119 /* The number of sections */
1120 unsigned int section_count;
1122 /* Stuff only useful for object files:
1123 The start address. */
1124 bfd_vma start_address;
1126 /* Used for input and output*/
1127 unsigned int symcount;
1129 /* Symbol table for output BFD*/
1130 struct symbol_cache_entry **outsymbols;
1132 /* Pointer to structure which contains architecture information*/
1133 struct bfd_arch_info *arch_info;
1135 /* Stuff only useful for archives:*/
1137 struct _bfd *my_archive;
1139 struct _bfd *archive_head;
1142 /* Used by the back end to hold private data. */
1146 struct aout_data_struct *aout_data;
1147 struct artdata *aout_ar_data;
1148 struct _oasys_data *oasys_obj_data;
1149 struct _oasys_ar_data *oasys_ar_data;
1150 struct coff_tdata *coff_obj_data;
1151 struct ieee_data_struct *ieee_data;
1152 struct ieee_ar_data_struct *ieee_ar_data;
1153 struct srec_data_struct *srec_data;
1154 struct srec_data_struct *tekhex_data;
1155 struct elf_obj_tdata *elf_obj_data;
1156 struct bout_data_struct *bout_data;
1157 struct sun_core_struct *sun_core_data;
1158 struct trad_core_struct *trad_core_data;
1159 struct hppa_data_struct *hppa_data;
1163 /* Used by the application to hold private data*/
1166 /* Where all the allocated stuff under this BFD goes */
1167 struct obstack memory;
1169 /* Is this really needed in addition to usrdata? */
1170 asymbol **ld_symbols;
1173 unsigned int EXFUN(bfd_get_reloc_upper_bound, (bfd *abfd, asection *sect));
1174 unsigned int EXFUN(bfd_canonicalize_reloc
1179 boolean EXFUN(bfd_set_file_flags, (bfd *abfd, flagword flags));
1180 void EXFUN(bfd_set_reloc
1181 , (bfd *abfd, asection *sec, arelent **rel, unsigned int count)
1184 boolean EXFUN(bfd_set_start_address, (bfd *, bfd_vma));
1185 long EXFUN(bfd_get_mtime, (bfd *));
1186 #define bfd_sizeof_headers(abfd, reloc) \
1187 BFD_SEND (abfd, _bfd_sizeof_headers, (abfd, reloc))
1189 #define bfd_find_nearest_line(abfd, sec, syms, off, file, func, line) \
1190 BFD_SEND (abfd, _bfd_find_nearest_line, (abfd, sec, syms, off, file, func, line))
1192 /* Do these three do anything useful at all, for any back end? */
1193 #define bfd_debug_info_start(abfd) \
1194 BFD_SEND (abfd, _bfd_debug_info_start, (abfd))
1196 #define bfd_debug_info_end(abfd) \
1197 BFD_SEND (abfd, _bfd_debug_info_end, (abfd))
1199 #define bfd_debug_info_accumulate(abfd, section) \
1200 BFD_SEND (abfd, _bfd_debug_info_accumulate, (abfd, section))
1203 #define bfd_stat_arch_elt(abfd, stat) \
1204 BFD_SEND (abfd, _bfd_stat_arch_elt,(abfd, stat))
1206 #define bfd_coff_swap_aux_in(a,e,t,c,i) \
1207 BFD_SEND (a, _bfd_coff_swap_aux_in, (a,e,t,c,i))
1209 #define bfd_coff_swap_sym_in(a,e,i) \
1210 BFD_SEND (a, _bfd_coff_swap_sym_in, (a,e,i))
1212 #define bfd_coff_swap_lineno_in(a,e,i) \
1213 BFD_SEND ( a, _bfd_coff_swap_lineno_in, (a,e,i))
1215 #define bfd_set_arch_mach(abfd, arch, mach)\
1216 BFD_SEND ( abfd, _bfd_set_arch_mach, (abfd, arch, mach))
1218 #define bfd_coff_swap_reloc_out(abfd, i, o) \
1219 BFD_SEND (abfd, _bfd_coff_swap_reloc_out, (abfd, i, o))
1221 #define bfd_coff_swap_lineno_out(abfd, i, o) \
1222 BFD_SEND (abfd, _bfd_coff_swap_lineno_out, (abfd, i, o))
1224 #define bfd_coff_swap_aux_out(abfd, i, t,c,o) \
1225 BFD_SEND (abfd, _bfd_coff_swap_aux_out, (abfd, i,t,c, o))
1227 #define bfd_coff_swap_sym_out(abfd, i,o) \
1228 BFD_SEND (abfd, _bfd_coff_swap_sym_out, (abfd, i, o))
1230 #define bfd_coff_swap_scnhdr_out(abfd, i,o) \
1231 BFD_SEND (abfd, _bfd_coff_swap_scnhdr_out, (abfd, i, o))
1233 #define bfd_coff_swap_filehdr_out(abfd, i,o) \
1234 BFD_SEND (abfd, _bfd_coff_swap_filehdr_out, (abfd, i, o))
1236 #define bfd_coff_swap_aouthdr_out(abfd, i,o) \
1237 BFD_SEND (abfd, _bfd_coff_swap_aouthdr_out, (abfd, i, o))
1239 #define bfd_get_relocated_section_contents(abfd, seclet, data) \
1240 BFD_SEND (abfd, _bfd_get_relocated_section_contents, (abfd, seclet, data))
1242 #define bfd_relax_section(abfd, section, symbols) \
1243 BFD_SEND (abfd, _bfd_relax_section, (abfd, section, symbols))
1244 symindex EXFUN(bfd_get_next_mapent, (bfd *, symindex previous, carsym ** sym));
1245 boolean EXFUN(bfd_set_archive_head, (bfd *output, bfd *new_head));
1246 bfd *EXFUN(bfd_get_elt_at_index, (bfd * archive, int index));
1247 bfd* EXFUN(bfd_openr_next_archived_file, (bfd *archive, bfd *previous));
1248 CONST char *EXFUN(bfd_core_file_failing_command, (bfd *));
1249 int EXFUN(bfd_core_file_failing_signal, (bfd *));
1250 boolean EXFUN(core_file_matches_executable_p
1251 , (bfd *core_bfd, bfd *exec_bfd));
1252 #define SDEF(ret, name, arglist) \
1253 PROTO(ret,(*name),arglist)
1254 #define SDEF_FMT(ret, name, arglist) \
1255 PROTO(ret,(*name[bfd_type_end]),arglist)
1256 #define BFD_SEND(bfd, message, arglist) \
1257 ((*((bfd)->xvec->message)) arglist)
1258 #define BFD_SEND_FMT(bfd, message, arglist) \
1259 (((bfd)->xvec->message[(int)((bfd)->format)]) arglist)
1260 typedef struct bfd_target
1263 enum target_flavour {
1264 bfd_target_unknown_flavour,
1265 bfd_target_aout_flavour,
1266 bfd_target_coff_flavour,
1267 bfd_target_elf_flavour,
1268 bfd_target_ieee_flavour,
1269 bfd_target_oasys_flavour,
1270 bfd_target_tekhex_flavour,
1271 bfd_target_srec_flavour,
1272 bfd_target_hppa_flavour} flavour;
1273 boolean byteorder_big_p;
1274 boolean header_byteorder_big_p;
1275 flagword object_flags;
1276 flagword section_flags;
1278 unsigned short ar_max_namelen;
1279 unsigned int align_power_min;
1280 SDEF (bfd_vma, bfd_getx64, (bfd_byte *));
1281 SDEF (void, bfd_putx64, (bfd_vma, bfd_byte *));
1282 SDEF (bfd_vma, bfd_getx32, (bfd_byte *));
1283 SDEF (void, bfd_putx32, (bfd_vma, bfd_byte *));
1284 SDEF (bfd_vma, bfd_getx16, (bfd_byte *));
1285 SDEF (void, bfd_putx16, (bfd_vma, bfd_byte *));
1286 SDEF (bfd_vma, bfd_h_getx64, (bfd_byte *));
1287 SDEF (void, bfd_h_putx64, (bfd_vma, bfd_byte *));
1288 SDEF (bfd_vma, bfd_h_getx32, (bfd_byte *));
1289 SDEF (void, bfd_h_putx32, (bfd_vma, bfd_byte *));
1290 SDEF (bfd_vma, bfd_h_getx16, (bfd_byte *));
1291 SDEF (void, bfd_h_putx16, (bfd_vma, bfd_byte *));
1292 SDEF_FMT (struct bfd_target *, _bfd_check_format, (bfd *));
1293 SDEF_FMT (boolean, _bfd_set_format, (bfd *));
1294 SDEF_FMT (boolean, _bfd_write_contents, (bfd *));
1295 SDEF (char *, _core_file_failing_command, (bfd *));
1296 SDEF (int, _core_file_failing_signal, (bfd *));
1297 SDEF (boolean, _core_file_matches_executable_p, (bfd *, bfd *));
1298 SDEF (boolean, _bfd_slurp_armap, (bfd *));
1299 SDEF (boolean, _bfd_slurp_extended_name_table, (bfd *));
1300 SDEF (void, _bfd_truncate_arname, (bfd *, CONST char *, char *));
1301 SDEF (boolean, write_armap, (bfd *arch,
1302 unsigned int elength,
1304 unsigned int orl_count,
1306 SDEF (boolean, _close_and_cleanup, (bfd *));
1307 SDEF (boolean, _bfd_set_section_contents, (bfd *, sec_ptr, PTR,
1308 file_ptr, bfd_size_type));
1309 SDEF (boolean, _bfd_get_section_contents, (bfd *, sec_ptr, PTR,
1310 file_ptr, bfd_size_type));
1311 SDEF (boolean, _new_section_hook, (bfd *, sec_ptr));
1312 SDEF (unsigned int, _get_symtab_upper_bound, (bfd *));
1313 SDEF (unsigned int, _bfd_canonicalize_symtab,
1314 (bfd *, struct symbol_cache_entry **));
1315 SDEF (unsigned int, _get_reloc_upper_bound, (bfd *, sec_ptr));
1316 SDEF (unsigned int, _bfd_canonicalize_reloc, (bfd *, sec_ptr, arelent **,
1317 struct symbol_cache_entry**));
1318 SDEF (struct symbol_cache_entry *, _bfd_make_empty_symbol, (bfd *));
1319 SDEF (void, _bfd_print_symbol, (bfd *, PTR, struct symbol_cache_entry *,
1320 bfd_print_symbol_type));
1321 #define bfd_print_symbol(b,p,s,e) BFD_SEND(b, _bfd_print_symbol, (b,p,s,e))
1322 SDEF (alent *, _get_lineno, (bfd *, struct symbol_cache_entry *));
1324 SDEF (boolean, _bfd_set_arch_mach, (bfd *, enum bfd_architecture,
1327 SDEF (bfd *, openr_next_archived_file, (bfd *arch, bfd *prev));
1328 SDEF (boolean, _bfd_find_nearest_line,
1329 (bfd *abfd, struct sec *section,
1330 struct symbol_cache_entry **symbols,bfd_vma offset,
1331 CONST char **file, CONST char **func, unsigned int *line));
1332 SDEF (int, _bfd_stat_arch_elt, (bfd *, struct stat *));
1334 SDEF (int, _bfd_sizeof_headers, (bfd *, boolean));
1336 SDEF (void, _bfd_debug_info_start, (bfd *));
1337 SDEF (void, _bfd_debug_info_end, (bfd *));
1338 SDEF (void, _bfd_debug_info_accumulate, (bfd *, struct sec *));
1339 SDEF (bfd_byte *, _bfd_get_relocated_section_contents, (bfd*,struct bfd_seclet_struct *, bfd_byte *data));
1340 SDEF (boolean,_bfd_relax_section,(bfd *, struct sec *, struct symbol_cache_entry **));
1341 SDEF(void, _bfd_coff_swap_aux_in,(
1348 SDEF(void, _bfd_coff_swap_sym_in,(
1353 SDEF(void, _bfd_coff_swap_lineno_in, (
1358 SDEF(unsigned int, _bfd_coff_swap_aux_out,(
1365 SDEF(unsigned int, _bfd_coff_swap_sym_out,(
1370 SDEF(unsigned int, _bfd_coff_swap_lineno_out,(
1375 SDEF(unsigned int, _bfd_coff_swap_reloc_out,(
1380 SDEF(unsigned int, _bfd_coff_swap_filehdr_out,(
1385 SDEF(unsigned int, _bfd_coff_swap_aouthdr_out,(
1390 SDEF(unsigned int, _bfd_coff_swap_scnhdr_out,(
1395 /* See documentation on reloc types. */
1396 SDEF (CONST struct reloc_howto_struct *,
1398 (bfd *abfd, bfd_reloc_code_real_type code));
1400 /* Complete and utter crock, currently used for the assembler
1401 when creating COFF files. */
1402 SDEF (asymbol *, _bfd_make_debug_symbol, (
1405 unsigned long size));
1408 bfd_target *EXFUN(bfd_find_target, (CONST char *, bfd *));
1409 CONST char **EXFUN(bfd_target_list, (void));
1410 boolean EXFUN(bfd_check_format, (bfd *abfd, bfd_format format));
1411 boolean EXFUN(bfd_set_format, (bfd *, bfd_format));
1412 CONST char *EXFUN(bfd_format_string, (bfd_format));