Context Navigation

source: trunk/src/binutils/bfd/bfd-in2.h@ 106

Visit:

Last change on this file since 106 was 100, checked in by bird, 22 years ago
review. Added some comments and #ifs.
Property cvs2svn:cvs-rev set to `1.3` Property svn:eol-style set to `native` Property svn:executable set to ``*
File size: 119.6 KB

Line
1	/* Main header file for the bfd library -- portable access to object files.
2	Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3	2000, 2001
4	Free Software Foundation, Inc.
5	Contributed by Cygnus Support.
6
7	** NOTE: bfd.h and bfd-in2.h are GENERATED files. Don't change them;
8	** instead, change bfd-in.h or the other BFD source files processed to
9	** generate these files.
10
11	This file is part of BFD, the Binary File Descriptor library.
12
13	This program is free software; you can redistribute it and/or modify
14	it under the terms of the GNU General Public License as published by
15	the Free Software Foundation; either version 2 of the License, or
16	(at your option) any later version.
17
18	This program is distributed in the hope that it will be useful,
19	but WITHOUT ANY WARRANTY; without even the implied warranty of
20	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21	GNU General Public License for more details.
22
23	You should have received a copy of the GNU General Public License
24	along with this program; if not, write to the Free Software
25	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
26
27	/* bfd.h -- The only header file required by users of the bfd library
28
29	The bfd.h file is generated from bfd-in.h and various .c files; if you
30	change it, your changes will probably be lost.
31
32	All the prototypes and definitions following the comment "THE FOLLOWING
33	IS EXTRACTED FROM THE SOURCE" are extracted from the source files for
34	BFD. If you change it, someone oneday will extract it from the source
35	again, and your changes will be lost. To save yourself from this bind,
36	change the definitions in the source in the bfd directory. Type "make
37	docs" and then "make headers" in that directory, and magically this file
38	will change to reflect your changes.
39
40	If you don't have the tools to perform the extraction, then you are
41	safe from someone on your system trampling over your header files.
42	You should still maintain the equivalence between the source and this
43	file though; every change you make to the .c file should be reflected
44	here. */
45
46	#ifndef __BFD_H_SEEN__
47	#define __BFD_H_SEEN__
48
49	#ifdef __cplusplus
50	extern "C" {
51	#endif
52
53	#include "ansidecl.h"
54
55	/* These two lines get substitutions done by commands in Makefile.in. */
56	#define BFD_VERSION "@VERSION@"
57	#define BFD_ARCH_SIZE @wordsize@
58	#define BFD_HOST_64BIT_LONG @BFD_HOST_64BIT_LONG@
59	#if @BFD_HOST_64_BIT_DEFINED@
60	#define BFD_HOST_64_BIT @BFD_HOST_64_BIT@
61	#define BFD_HOST_U_64_BIT @BFD_HOST_U_64_BIT@
62	#endif
63
64	#if BFD_ARCH_SIZE >= 64
65	#define BFD64
66	#endif
67
68	#ifndef INLINE
69	#if __GNUC__ >= 2
70	#define INLINE __inline__
71	#else
72	#define INLINE
73	#endif
74	#endif
75
76	/* forward declaration */
77	typedef struct _bfd bfd;
78
79	/* To squelch erroneous compiler warnings ("illegal pointer
80	combination") from the SVR3 compiler, we would like to typedef
81	boolean to int (it doesn't like functions which return boolean.
82	Making sure they are never implicitly declared to return int
83	doesn't seem to help). But this file is not configured based on
84	the host. */
85	/* General rules: functions which are boolean return true on success
86	and false on failure (unless they're a predicate). -- bfd.doc */
87	/* I'm sure this is going to break something and someone is going to
88	force me to change it. */
89	/* typedef enum boolean {false, true} boolean; */
90	/* Yup, SVR4 has a "typedef enum boolean" in <sys/types.h> -fnf */
91	/* It gets worse if the host also defines a true/false enum... -sts */
92	/* And even worse if your compiler has built-in boolean types... -law */
93	#if defined (__GNUG__) && (__GNUC__ > 2 \|\| (__GNUC__ == 2 && __GNUC_MINOR__ >= 6))
94	#define TRUE_FALSE_ALREADY_DEFINED
95	#endif
96	#ifdef MPW
97	/* Pre-emptive strike - get the file with the enum. */
98	#include <Types.h>
99	#define TRUE_FALSE_ALREADY_DEFINED
100	#endif /* MPW */
101	#ifndef TRUE_FALSE_ALREADY_DEFINED
102	typedef enum bfd_boolean {false, true} boolean;
103	#define BFD_TRUE_FALSE
104	#else
105	/* Use enum names that will appear nowhere else. */
106	typedef enum bfd_boolean {bfd_fffalse, bfd_tttrue} boolean;
107	#endif
108
109	/* A pointer to a position in a file. */
110	/* FIXME: This should be using off_t from <sys/types.h>.
111	For now, try to avoid breaking stuff by not including <sys/types.h> here.
112	This will break on systems with 64-bit file offsets (e.g. 4.4BSD).
113	Probably the best long-term answer is to avoid using file_ptr AND off_t
114	in this header file, and to handle this in the BFD implementation
115	rather than in its interface. */
116	/* typedef off_t file_ptr; */
117	typedef long int file_ptr;
118
119	/* Support for different sizes of target format ints and addresses.
120	If the type `long' is at least 64 bits, BFD_HOST_64BIT_LONG will be
121	set to 1 above. Otherwise, if gcc is being used, this code will
122	use gcc's "long long" type. Otherwise, BFD_HOST_64_BIT must be
123	defined above. */
124
125	#ifndef BFD_HOST_64_BIT
126	# if BFD_HOST_64BIT_LONG
127	# define BFD_HOST_64_BIT long
128	# define BFD_HOST_U_64_BIT unsigned long
129	# else
130	# ifdef __GNUC__
131	# if __GNUC__ >= 2
132	# define BFD_HOST_64_BIT long long
133	# define BFD_HOST_U_64_BIT unsigned long long
134	# endif /* __GNUC__ >= 2 */
135	# endif /* ! defined (__GNUC__) */
136	# endif /* ! BFD_HOST_64BIT_LONG */
137	#endif /* ! defined (BFD_HOST_64_BIT) */
138
139	#ifdef BFD64
140
141	#ifndef BFD_HOST_64_BIT
142	#error No 64 bit integer type available
143	#endif /* ! defined (BFD_HOST_64_BIT) */
144
145	typedef BFD_HOST_U_64_BIT bfd_vma;
146	typedef BFD_HOST_64_BIT bfd_signed_vma;
147	typedef BFD_HOST_U_64_BIT bfd_size_type;
148	typedef BFD_HOST_U_64_BIT symvalue;
149
150	#ifndef fprintf_vma
151	#if BFD_HOST_64BIT_LONG
152	#define sprintf_vma(s,x) sprintf (s, "%016lx", x)
153	#define fprintf_vma(f,x) fprintf (f, "%016lx", x)
154	#else
155	#define _bfd_int64_low(x) ((unsigned long) (((x) & 0xffffffff)))
156	#define _bfd_int64_high(x) ((unsigned long) (((x) >> 32) & 0xffffffff))
157	#define fprintf_vma(s,x) \
158	fprintf ((s), "%08lx%08lx", _bfd_int64_high (x), _bfd_int64_low (x))
159	#define sprintf_vma(s,x) \
160	sprintf ((s), "%08lx%08lx", _bfd_int64_high (x), _bfd_int64_low (x))
161	#endif
162	#endif
163
164	#else /* not BFD64 */
165
166	/* Represent a target address. Also used as a generic unsigned type
167	which is guaranteed to be big enough to hold any arithmetic types
168	we need to deal with. */
169	typedef unsigned long bfd_vma;
170
171	/* A generic signed type which is guaranteed to be big enough to hold any
172	arithmetic types we need to deal with. Can be assumed to be compatible
173	with bfd_vma in the same way that signed and unsigned ints are compatible
174	(as parameters, in assignment, etc). */
175	typedef long bfd_signed_vma;
176
177	typedef unsigned long symvalue;
178	typedef unsigned long bfd_size_type;
179
180	/* Print a bfd_vma x on stream s. */
181	#define fprintf_vma(s,x) fprintf (s, "%08lx", x)
182	#define sprintf_vma(s,x) sprintf (s, "%08lx", x)
183
184	#endif /* not BFD64 */
185
186	#define printf_vma(x) fprintf_vma(stdout,x)
187
188	typedef unsigned int flagword; /* 32 bits of flags */
189	typedef unsigned char bfd_byte;
190
191
192	/** File formats */
193
194	typedef enum bfd_format {
195	bfd_unknown = 0, /* file format is unknown */
196	bfd_object, /* linker/assember/compiler output */
197	bfd_archive, /* object archive file */
198	bfd_core, /* core dump */
199	bfd_type_end} /* marks the end; don't use it! */
200	bfd_format;
201
202	/* Values that may appear in the flags field of a BFD. These also
203	appear in the object_flags field of the bfd_target structure, where
204	they indicate the set of flags used by that backend (not all flags
205	are meaningful for all object file formats) (FIXME: at the moment,
206	the object_flags values have mostly just been copied from backend
207	to another, and are not necessarily correct). */
208
209	/* No flags. */
210	#define BFD_NO_FLAGS 0x00
211
212	/* BFD contains relocation entries. */
213	#define HAS_RELOC 0x01
214
215	/* BFD is directly executable. */
216	#define EXEC_P 0x02
217
218	/* BFD has line number information (basically used for F_LNNO in a
219	COFF header). */
220	#define HAS_LINENO 0x04
221
222	/* BFD has debugging information. */
223	#define HAS_DEBUG 0x08
224
225	/* BFD has symbols. */
226	#define HAS_SYMS 0x10
227
228	/* BFD has local symbols (basically used for F_LSYMS in a COFF
229	header). */
230	#define HAS_LOCALS 0x20
231
232	/* BFD is a dynamic object. */
233	#define DYNAMIC 0x40
234
235	/* Text section is write protected (if D_PAGED is not set, this is
236	like an a.out NMAGIC file) (the linker sets this by default, but
237	clears it for -r or -N). */
238	#define WP_TEXT 0x80
239
240	/* BFD is dynamically paged (this is like an a.out ZMAGIC file) (the
241	linker sets this by default, but clears it for -r or -n or -N). */
242	#define D_PAGED 0x100
243
244	/* BFD is relaxable (this means that bfd_relax_section may be able to
245	do something) (sometimes bfd_relax_section can do something even if
246	this is not set). */
247	#define BFD_IS_RELAXABLE 0x200
248
249	/* This may be set before writing out a BFD to request using a
250	traditional format. For example, this is used to request that when
251	writing out an a.out object the symbols not be hashed to eliminate
252	duplicates. */
253	#define BFD_TRADITIONAL_FORMAT 0x400
254
255	/* This flag indicates that the BFD contents are actually cached in
256	memory. If this is set, iostream points to a bfd_in_memory struct. */
257	#define BFD_IN_MEMORY 0x800
258
259
260	/* symbols and relocation */
261
262	/* A count of carsyms (canonical archive symbols). */
263	typedef unsigned long symindex;
264
265	/* How to perform a relocation. */
266	typedef const struct reloc_howto_struct reloc_howto_type;
267
268	#define BFD_NO_MORE_SYMBOLS ((symindex) ~0)
269
270	/* General purpose part of a symbol X;
271	target specific parts are in libcoff.h, libaout.h, etc. */
272
273	#define bfd_get_section(x) ((x)->section)
274	#define bfd_get_output_section(x) ((x)->section->output_section)
275	#define bfd_set_section(x,y) ((x)->section) = (y)
276	#define bfd_asymbol_base(x) ((x)->section->vma)
277	#define bfd_asymbol_value(x) (bfd_asymbol_base(x) + (x)->value)
278	#define bfd_asymbol_name(x) ((x)->name)
279	/Perhaps future: #define bfd_asymbol_bfd(x) ((x)->section->owner)/
280	#define bfd_asymbol_bfd(x) ((x)->the_bfd)
281	#define bfd_asymbol_flavour(x) (bfd_asymbol_bfd(x)->xvec->flavour)
282
283	/* A canonical archive symbol. */
284	/* This is a type pun with struct ranlib on purpose! */
285	typedef struct carsym {
286	char *name;
287	file_ptr file_offset; /* look here to find the file */
288	} carsym; /* to make these you call a carsymogen */
289
290	/* Used in generating armaps (archive tables of contents).
291	Perhaps just a forward definition would do? */
292	struct orl { /* output ranlib */
293	char *name; / symbol name */
294	file_ptr pos; /* bfd* or file position */
295	int namidx; /* index into string table */
296	};
297
298
299	/* Linenumber stuff */
300	typedef struct lineno_cache_entry {
301	unsigned int line_number; /* Linenumber from start of function*/
302	union {
303	struct symbol_cache_entry sym; / Function name */
304	unsigned long offset; /* Offset into section */
305	} u;
306	} alent;
307
308
309	/* object and core file sections */
310
311	#define align_power(addr, align) \
312	( ((addr) + ((1<<(align))-1)) & (-1 << (align)))
313
314	typedef struct sec *sec_ptr;
315
316	#define bfd_get_section_name(bfd, ptr) ((ptr)->name + 0)
317	#define bfd_get_section_vma(bfd, ptr) ((ptr)->vma + 0)
318	#define bfd_get_section_alignment(bfd, ptr) ((ptr)->alignment_power + 0)
319	#define bfd_section_name(bfd, ptr) ((ptr)->name)
320	#define bfd_section_size(bfd, ptr) (bfd_get_section_size_before_reloc(ptr))
321	#define bfd_section_vma(bfd, ptr) ((ptr)->vma)
322	#define bfd_section_lma(bfd, ptr) ((ptr)->lma)
323	#define bfd_section_alignment(bfd, ptr) ((ptr)->alignment_power)
324	#define bfd_get_section_flags(bfd, ptr) ((ptr)->flags + 0)
325	#define bfd_get_section_userdata(bfd, ptr) ((ptr)->userdata)
326
327	#define bfd_is_com_section(ptr) (((ptr)->flags & SEC_IS_COMMON) != 0)
328
329	#define bfd_set_section_vma(bfd, ptr, val) (((ptr)->vma = (ptr)->lma= (val)), ((ptr)->user_set_vma = (boolean)true), true)
330	#define bfd_set_section_alignment(bfd, ptr, val) (((ptr)->alignment_power = (val)),true)
331	#define bfd_set_section_userdata(bfd, ptr, val) (((ptr)->userdata = (val)),true)
332
333	typedef struct stat stat_type;
334
335
336	typedef enum bfd_print_symbol
337	{
338	bfd_print_symbol_name,
339	bfd_print_symbol_more,
340	bfd_print_symbol_all
341	} bfd_print_symbol_type;
342
343	/* Information about a symbol that nm needs. */
344
345	typedef struct _symbol_info
346	{
347	symvalue value;
348	char type;
349	CONST char name; / Symbol name. */
350	unsigned char stab_type; /* Stab type. */
351	char stab_other; /* Stab other. */
352	short stab_desc; /* Stab desc. */
353	CONST char stab_name; / String for stab type. */
354	} symbol_info;
355
356	/* Get the name of a stabs type code. */
357
358	extern const char *bfd_get_stab_name PARAMS ((int));
359
360
361	/* Hash table routines. There is no way to free up a hash table. */
362
363	/* An element in the hash table. Most uses will actually use a larger
364	structure, and an instance of this will be the first field. */
365
366	struct bfd_hash_entry
367	{
368	/* Next entry for this hash code. */
369	struct bfd_hash_entry *next;
370	/* String being hashed. */
371	const char *string;
372	/* Hash code. This is the full hash code, not the index into the
373	table. */
374	unsigned long hash;
375	};
376
377	/* A hash table. */
378
379	struct bfd_hash_table
380	{
381	/* The hash array. */
382	struct bfd_hash_entry **table;
383	/* The number of slots in the hash table. */
384	unsigned int size;
385	/* A function used to create new elements in the hash table. The
386	first entry is itself a pointer to an element. When this
387	function is first invoked, this pointer will be NULL. However,
388	having the pointer permits a hierarchy of method functions to be
389	built each of which calls the function in the superclass. Thus
390	each function should be written to allocate a new block of memory
391	only if the argument is NULL. */
392	struct bfd_hash_entry (newfunc) PARAMS ((struct bfd_hash_entry *,
393	struct bfd_hash_table *,
394	const char *));
395	/* An objalloc for this hash table. This is a struct objalloc *,
396	but we use PTR to avoid requiring the inclusion of objalloc.h. */
397	PTR memory;
398	};
399
400	/* Initialize a hash table. */
401	extern boolean bfd_hash_table_init
402	PARAMS ((struct bfd_hash_table *,
403	struct bfd_hash_entry () (struct bfd_hash_entry *,
404	struct bfd_hash_table *,
405	const char *)));
406
407	/* Initialize a hash table specifying a size. */
408	extern boolean bfd_hash_table_init_n
409	PARAMS ((struct bfd_hash_table *,
410	struct bfd_hash_entry () (struct bfd_hash_entry *,
411	struct bfd_hash_table *,
412	const char *),
413	unsigned int size));
414
415	/* Free up a hash table. */
416	extern void bfd_hash_table_free PARAMS ((struct bfd_hash_table *));
417
418	/* Look up a string in a hash table. If CREATE is true, a new entry
419	will be created for this string if one does not already exist. The
420	COPY argument must be true if this routine should copy the string
421	into newly allocated memory when adding an entry. */
422	extern struct bfd_hash_entry *bfd_hash_lookup
423	PARAMS ((struct bfd_hash_table , const char , boolean create,
424	boolean copy));
425
426	/* Replace an entry in a hash table. */
427	extern void bfd_hash_replace
428	PARAMS ((struct bfd_hash_table , struct bfd_hash_entry old,
429	struct bfd_hash_entry *nw));
430
431	/* Base method for creating a hash table entry. */
432	extern struct bfd_hash_entry *bfd_hash_newfunc
433	PARAMS ((struct bfd_hash_entry , struct bfd_hash_table ,
434	const char *));
435
436	/* Grab some space for a hash table entry. */
437	extern PTR bfd_hash_allocate PARAMS ((struct bfd_hash_table *,
438	unsigned int));
439
440	/* Traverse a hash table in a random order, calling a function on each
441	element. If the function returns false, the traversal stops. The
442	INFO argument is passed to the function. */
443	extern void bfd_hash_traverse PARAMS ((struct bfd_hash_table *,
444	boolean () (struct bfd_hash_entry ,
445	PTR),
446	PTR info));
447
448
449	/* Semi-portable string concatenation in cpp.
450	The CAT4 hack is to avoid a problem with some strict ANSI C preprocessors.
451	The problem is, "32_" is not a valid preprocessing token, and we don't
452	want extra underscores (e.g., "nlm_32_"). The XCAT2 macro will cause the
453	inner CAT macros to be evaluated first, producing still-valid pp-tokens.
454	Then the final concatenation can be done. (Sigh.) */
455	#ifndef CAT
456	#ifdef SABER
457	#define CAT(a,b) a##b
458	#define CAT3(a,b,c) a##b##c
459	#define CAT4(a,b,c,d) a##b##c##d
460	#else
461	#if defined(__STDC__) \|\| defined(ALMOST_STDC)
462	#define CAT(a,b) a##b
463	#define CAT3(a,b,c) a##b##c
464	#define XCAT2(a,b) CAT(a,b)
465	#define CAT4(a,b,c,d) XCAT2(CAT(a,b),CAT(c,d))
466	#else
467	#define CAT(a,b) a/**/b
468	#define CAT3(a,b,c) a//b//c
469	#define CAT4(a,b,c,d) a//b//c/**/d
470	#endif
471	#endif
472	#endif
473
474	#define COFF_SWAP_TABLE (PTR) &bfd_coff_std_swap_table
475
476
477	/* User program access to BFD facilities */
478
479	/* Direct I/O routines, for programs which know more about the object
480	file than BFD does. Use higher level routines if possible. */
481
482	extern bfd_size_type bfd_read
483	PARAMS ((PTR, bfd_size_type size, bfd_size_type nitems, bfd *abfd));
484	extern bfd_size_type bfd_write
485	PARAMS ((const PTR, bfd_size_type size, bfd_size_type nitems, bfd *abfd));
486	extern int bfd_seek PARAMS ((bfd *abfd, file_ptr fp, int direction));
487	extern long bfd_tell PARAMS ((bfd *abfd));
488	extern int bfd_flush PARAMS ((bfd *abfd));
489	extern int bfd_stat PARAMS ((bfd abfd, struct stat ));
490
491	/* Cast from const char * to char * so that caller can assign to
492	a char * without a warning. */
493	#define bfd_get_filename(abfd) ((char *) (abfd)->filename)
494	#define bfd_get_cacheable(abfd) ((abfd)->cacheable)
495	#define bfd_get_format(abfd) ((abfd)->format)
496	#define bfd_get_target(abfd) ((abfd)->xvec->name)
497	#define bfd_get_flavour(abfd) ((abfd)->xvec->flavour)
498	#define bfd_family_coff(abfd) \
499	(bfd_get_flavour (abfd) == bfd_target_coff_flavour \|\| \
500	bfd_get_flavour (abfd) == bfd_target_xcoff_flavour)
501	#define bfd_big_endian(abfd) ((abfd)->xvec->byteorder == BFD_ENDIAN_BIG)
502	#define bfd_little_endian(abfd) ((abfd)->xvec->byteorder == BFD_ENDIAN_LITTLE)
503	#define bfd_header_big_endian(abfd) \
504	((abfd)->xvec->header_byteorder == BFD_ENDIAN_BIG)
505	#define bfd_header_little_endian(abfd) \
506	((abfd)->xvec->header_byteorder == BFD_ENDIAN_LITTLE)
507	#define bfd_get_file_flags(abfd) ((abfd)->flags)
508	#define bfd_applicable_file_flags(abfd) ((abfd)->xvec->object_flags)
509	#define bfd_applicable_section_flags(abfd) ((abfd)->xvec->section_flags)
510	#define bfd_my_archive(abfd) ((abfd)->my_archive)
511	#define bfd_has_map(abfd) ((abfd)->has_armap)
512
513	#define bfd_valid_reloc_types(abfd) ((abfd)->xvec->valid_reloc_types)
514	#define bfd_usrdata(abfd) ((abfd)->usrdata)
515
516	#define bfd_get_start_address(abfd) ((abfd)->start_address)
517	#define bfd_get_symcount(abfd) ((abfd)->symcount)
518	#define bfd_get_outsymbols(abfd) ((abfd)->outsymbols)
519	#define bfd_count_sections(abfd) ((abfd)->section_count)
520
521	#define bfd_get_symbol_leading_char(abfd) ((abfd)->xvec->symbol_leading_char)
522
523	#define bfd_set_cacheable(abfd,bool) (((abfd)->cacheable = (boolean) (bool)), true)
524
525	extern boolean bfd_record_phdr
526	PARAMS ((bfd *, unsigned long, boolean, flagword, boolean, bfd_vma,
527	boolean, boolean, unsigned int, struct sec **));
528
529	/* Byte swapping routines. */
530
531	bfd_vma bfd_getb64 PARAMS ((const unsigned char *));
532	bfd_vma bfd_getl64 PARAMS ((const unsigned char *));
533	bfd_signed_vma bfd_getb_signed_64 PARAMS ((const unsigned char *));
534	bfd_signed_vma bfd_getl_signed_64 PARAMS ((const unsigned char *));
535	bfd_vma bfd_getb32 PARAMS ((const unsigned char *));
536	bfd_vma bfd_getl32 PARAMS ((const unsigned char *));
537	bfd_signed_vma bfd_getb_signed_32 PARAMS ((const unsigned char *));
538	bfd_signed_vma bfd_getl_signed_32 PARAMS ((const unsigned char *));
539	bfd_vma bfd_getb16 PARAMS ((const unsigned char *));
540	bfd_vma bfd_getl16 PARAMS ((const unsigned char *));
541	bfd_signed_vma bfd_getb_signed_16 PARAMS ((const unsigned char *));
542	bfd_signed_vma bfd_getl_signed_16 PARAMS ((const unsigned char *));
543	void bfd_putb64 PARAMS ((bfd_vma, unsigned char *));
544	void bfd_putl64 PARAMS ((bfd_vma, unsigned char *));
545	void bfd_putb32 PARAMS ((bfd_vma, unsigned char *));
546	void bfd_putl32 PARAMS ((bfd_vma, unsigned char *));
547	void bfd_putb16 PARAMS ((bfd_vma, unsigned char *));
548	void bfd_putl16 PARAMS ((bfd_vma, unsigned char *));
549
550	/* Byte swapping routines which take size and endiannes as arguments. */
551
552	bfd_vma bfd_get_bits PARAMS ((bfd_byte *, int, boolean));
553	void bfd_put_bits PARAMS ((bfd_vma, bfd_byte *, int, boolean));
554
555
556	/* Externally visible ECOFF routines. */
557
558	#if defined(__STDC__) \|\| defined(ALMOST_STDC)
559	struct ecoff_debug_info;
560	struct ecoff_debug_swap;
561	struct ecoff_extr;
562	struct symbol_cache_entry;
563	struct bfd_link_info;
564	struct bfd_link_hash_entry;
565	struct bfd_elf_version_tree;
566	#endif
567	extern bfd_vma bfd_ecoff_get_gp_value PARAMS ((bfd * abfd));
568	extern boolean bfd_ecoff_set_gp_value PARAMS ((bfd *abfd, bfd_vma gp_value));
569	extern boolean bfd_ecoff_set_regmasks
570	PARAMS ((bfd *abfd, unsigned long gprmask, unsigned long fprmask,
571	unsigned long *cprmask));
572	extern PTR bfd_ecoff_debug_init
573	PARAMS ((bfd output_bfd, struct ecoff_debug_info output_debug,
574	const struct ecoff_debug_swap *output_swap,
575	struct bfd_link_info *));
576	extern void bfd_ecoff_debug_free
577	PARAMS ((PTR handle, bfd output_bfd, struct ecoff_debug_info output_debug,
578	const struct ecoff_debug_swap *output_swap,
579	struct bfd_link_info *));
580	extern boolean bfd_ecoff_debug_accumulate
581	PARAMS ((PTR handle, bfd output_bfd, struct ecoff_debug_info output_debug,
582	const struct ecoff_debug_swap *output_swap,
583	bfd input_bfd, struct ecoff_debug_info input_debug,
584	const struct ecoff_debug_swap *input_swap,
585	struct bfd_link_info *));
586	extern boolean bfd_ecoff_debug_accumulate_other
587	PARAMS ((PTR handle, bfd output_bfd, struct ecoff_debug_info output_debug,
588	const struct ecoff_debug_swap output_swap, bfd input_bfd,
589	struct bfd_link_info *));
590	extern boolean bfd_ecoff_debug_externals
591	PARAMS ((bfd abfd, struct ecoff_debug_info debug,
592	const struct ecoff_debug_swap *swap,
593	boolean relocateable,
594	boolean (get_extr) (struct symbol_cache_entry ,
595	struct ecoff_extr *),
596	void (set_index) (struct symbol_cache_entry ,
597	bfd_size_type)));
598	extern boolean bfd_ecoff_debug_one_external
599	PARAMS ((bfd abfd, struct ecoff_debug_info debug,
600	const struct ecoff_debug_swap *swap,
601	const char name, struct ecoff_extr esym));
602	extern bfd_size_type bfd_ecoff_debug_size
603	PARAMS ((bfd abfd, struct ecoff_debug_info debug,
604	const struct ecoff_debug_swap *swap));
605	extern boolean bfd_ecoff_write_debug
606	PARAMS ((bfd abfd, struct ecoff_debug_info debug,
607	const struct ecoff_debug_swap *swap, file_ptr where));
608	extern boolean bfd_ecoff_write_accumulated_debug
609	PARAMS ((PTR handle, bfd abfd, struct ecoff_debug_info debug,
610	const struct ecoff_debug_swap *swap,
611	struct bfd_link_info *info, file_ptr where));
612	extern boolean bfd_mips_ecoff_create_embedded_relocs
613	PARAMS ((bfd , struct bfd_link_info , struct sec , struct sec ,
614	char **));
615
616	/* Externally visible ELF routines. */
617
618	struct bfd_link_needed_list
619	{
620	struct bfd_link_needed_list *next;
621	bfd *by;
622	const char *name;
623	};
624
625	extern boolean bfd_elf32_record_link_assignment
626	PARAMS ((bfd , struct bfd_link_info , const char *, boolean));
627	extern boolean bfd_elf64_record_link_assignment
628	PARAMS ((bfd , struct bfd_link_info , const char *, boolean));
629	extern struct bfd_link_needed_list *bfd_elf_get_needed_list
630	PARAMS ((bfd , struct bfd_link_info ));
631	extern boolean bfd_elf_get_bfd_needed_list
632	PARAMS ((bfd , struct bfd_link_needed_list *));
633	extern boolean bfd_elf32_size_dynamic_sections
634	PARAMS ((bfd , const char , const char , boolean, const char ,
635	const char * const , struct bfd_link_info , struct sec **,
636	struct bfd_elf_version_tree *));
637	extern boolean bfd_elf64_size_dynamic_sections
638	PARAMS ((bfd , const char , const char , boolean, const char ,
639	const char * const , struct bfd_link_info , struct sec **,
640	struct bfd_elf_version_tree *));
641	extern void bfd_elf_set_dt_needed_name PARAMS ((bfd , const char ));
642	extern void bfd_elf_set_dt_needed_soname PARAMS ((bfd , const char ));
643	extern const char bfd_elf_get_dt_soname PARAMS ((bfd ));
644	extern struct bfd_link_needed_list *bfd_elf_get_runpath_list
645	PARAMS ((bfd , struct bfd_link_info ));
646
647	/* Return an upper bound on the number of bytes required to store a
648	copy of ABFD's program header table entries. Return -1 if an error
649	occurs; bfd_get_error will return an appropriate code. */
650	extern long bfd_get_elf_phdr_upper_bound PARAMS ((bfd *abfd));
651
652	/* Copy ABFD's program header table entries to *PHDRS. The entries
653	will be stored as an array of Elf_Internal_Phdr structures, as
654	defined in include/elf/internal.h. To find out how large the
655	buffer needs to be, call bfd_get_elf_phdr_upper_bound.
656
657	Return the number of program header table entries read, or -1 if an
658	error occurs; bfd_get_error will return an appropriate code. */
659	extern int bfd_get_elf_phdrs PARAMS ((bfd abfd, void phdrs));
660
661	/* Return the arch_size field of an elf bfd, or -1 if not elf. */
662	extern int bfd_get_arch_size PARAMS ((bfd *));
663
664	/* Return true if address "naturally" sign extends, or -1 if not elf. */
665	extern int bfd_get_sign_extend_vma PARAMS ((bfd *));
666
667	extern boolean bfd_m68k_elf32_create_embedded_relocs
668	PARAMS ((bfd , struct bfd_link_info , struct sec , struct sec ,
669	char **));
670
671	/* SunOS shared library support routines for the linker. */
672
673	extern struct bfd_link_needed_list *bfd_sunos_get_needed_list
674	PARAMS ((bfd , struct bfd_link_info ));
675	extern boolean bfd_sunos_record_link_assignment
676	PARAMS ((bfd , struct bfd_link_info , const char *));
677	extern boolean bfd_sunos_size_dynamic_sections
678	PARAMS ((bfd , struct bfd_link_info , struct sec , struct sec ,
679	struct sec **));
680
681	/* Linux shared library support routines for the linker. */
682
683	extern boolean bfd_i386linux_size_dynamic_sections
684	PARAMS ((bfd , struct bfd_link_info ));
685	extern boolean bfd_m68klinux_size_dynamic_sections
686	PARAMS ((bfd , struct bfd_link_info ));
687	extern boolean bfd_sparclinux_size_dynamic_sections
688	PARAMS ((bfd , struct bfd_link_info ));
689
690	/* mmap hacks */
691
692	struct _bfd_window_internal;
693	typedef struct _bfd_window_internal bfd_window_internal;
694
695	typedef struct _bfd_window {
696	/* What the user asked for. */
697	PTR data;
698	bfd_size_type size;
699	/* The actual window used by BFD. Small user-requested read-only
700	regions sharing a page may share a single window into the object
701	file. Read-write versions shouldn't until I've fixed things to
702	keep track of which portions have been claimed by the
703	application; don't want to give the same region back when the
704	application wants two writable copies! */
705	struct _bfd_window_internal *i;
706	} bfd_window;
707
708	extern void bfd_init_window PARAMS ((bfd_window *));
709	extern void bfd_free_window PARAMS ((bfd_window *));
710	extern boolean bfd_get_file_window
711	PARAMS ((bfd , file_ptr, bfd_size_type, bfd_window , boolean));
712
713	/* XCOFF support routines for the linker. */
714
715	extern boolean bfd_xcoff_link_record_set
716	PARAMS ((bfd , struct bfd_link_info , struct bfd_link_hash_entry *,
717	bfd_size_type));
718	extern boolean bfd_xcoff_import_symbol
719	PARAMS ((bfd , struct bfd_link_info , struct bfd_link_hash_entry *,
720	bfd_vma, const char , const char , const char *));
721	extern boolean bfd_xcoff_export_symbol
722	PARAMS ((bfd , struct bfd_link_info , struct bfd_link_hash_entry *,
723	boolean));
724	extern boolean bfd_xcoff_link_count_reloc
725	PARAMS ((bfd , struct bfd_link_info , const char *));
726	extern boolean bfd_xcoff_record_link_assignment
727	PARAMS ((bfd , struct bfd_link_info , const char *));
728	extern boolean bfd_xcoff_size_dynamic_sections
729	PARAMS ((bfd , struct bfd_link_info , const char , const char ,
730	unsigned long, unsigned long, unsigned long, boolean,
731	int, boolean, boolean, struct sec **));
732
733	/* Externally visible COFF routines. */
734
735	#if defined(__STDC__) \|\| defined(ALMOST_STDC)
736	struct internal_syment;
737	union internal_auxent;
738	#endif
739
740	extern boolean bfd_coff_get_syment
741	PARAMS ((bfd , struct symbol_cache_entry , struct internal_syment *));
742
743	extern boolean bfd_coff_get_auxent
744	PARAMS ((bfd , struct symbol_cache_entry , int, union internal_auxent *));
745
746	extern boolean bfd_coff_set_symbol_class
747	PARAMS ((bfd , struct symbol_cache_entry , unsigned int));
748
749	extern boolean bfd_m68k_coff_create_embedded_relocs
750	PARAMS ((bfd , struct bfd_link_info , struct sec , struct sec ,
751	char **));
752
753	/* ARM Interworking support. Called from linker. */
754	extern boolean bfd_arm_allocate_interworking_sections
755	PARAMS ((struct bfd_link_info *));
756
757	extern boolean bfd_arm_process_before_allocation
758	PARAMS ((bfd , struct bfd_link_info , int));
759
760	extern boolean bfd_arm_get_bfd_for_interworking
761	PARAMS ((bfd , struct bfd_link_info ));
762
763	/* PE ARM Interworking support. Called from linker. */
764	extern boolean bfd_arm_pe_allocate_interworking_sections
765	PARAMS ((struct bfd_link_info *));
766
767	extern boolean bfd_arm_pe_process_before_allocation
768	PARAMS ((bfd , struct bfd_link_info , int));
769
770	extern boolean bfd_arm_pe_get_bfd_for_interworking
771	PARAMS ((bfd , struct bfd_link_info ));
772
773	/* ELF ARM Interworking support. Called from linker. */
774	extern boolean bfd_elf32_arm_allocate_interworking_sections
775	PARAMS ((struct bfd_link_info *));
776
777	extern boolean bfd_elf32_arm_process_before_allocation
778	PARAMS ((bfd , struct bfd_link_info , int));
779
780	extern boolean bfd_elf32_arm_get_bfd_for_interworking
781	PARAMS ((bfd , struct bfd_link_info ));
782
783	/* TI COFF load page support. */
784	extern void bfd_ticoff_set_section_load_page
785	PARAMS ((struct sec *, int));
786
787	extern int bfd_ticoff_get_section_load_page
788	PARAMS ((struct sec *));
789
790	/* And more from the source. */
791	void
792	bfd_init PARAMS ((void));
793
794	bfd *
795	bfd_openr PARAMS ((CONST char filename, CONST char target));
796
797	bfd *
798	bfd_fdopenr PARAMS ((CONST char filename, CONST char target, int fd));
799
800	bfd *
801	bfd_openstreamr PARAMS ((const char , const char , PTR));
802
803	bfd *
804	bfd_openw PARAMS ((CONST char filename, CONST char target));
805
806	boolean
807	bfd_close PARAMS ((bfd *abfd));
808
809	boolean
810	bfd_close_all_done PARAMS ((bfd *));
811
812	bfd *
813	bfd_create PARAMS ((CONST char filename, bfd templ));
814
815	boolean
816	bfd_make_writable PARAMS ((bfd *abfd));
817
818	boolean
819	bfd_make_readable PARAMS ((bfd *abfd));
820
821
822	/* Byte swapping macros for user section data. */
823
824	#define bfd_put_8(abfd, val, ptr) \
825	((void) (((unsigned char ) (ptr)) = (unsigned char) (val)))
826	#define bfd_put_signed_8 \
827	bfd_put_8
828	#define bfd_get_8(abfd, ptr) \
829	((unsigned char ) (ptr))
830	#define bfd_get_signed_8(abfd, ptr) \
831	(((unsigned char ) (ptr) ^ 0x80) - 0x80)
832
833	#define bfd_put_16(abfd, val, ptr) \
834	BFD_SEND(abfd, bfd_putx16, ((val),(ptr)))
835	#define bfd_put_signed_16 \
836	bfd_put_16
837	#define bfd_get_16(abfd, ptr) \
838	BFD_SEND(abfd, bfd_getx16, (ptr))
839	#define bfd_get_signed_16(abfd, ptr) \
840	BFD_SEND (abfd, bfd_getx_signed_16, (ptr))
841
842	#define bfd_put_32(abfd, val, ptr) \
843	BFD_SEND(abfd, bfd_putx32, ((val),(ptr)))
844	#define bfd_put_signed_32 \
845	bfd_put_32
846	#define bfd_get_32(abfd, ptr) \
847	BFD_SEND(abfd, bfd_getx32, (ptr))
848	#define bfd_get_signed_32(abfd, ptr) \
849	BFD_SEND(abfd, bfd_getx_signed_32, (ptr))
850
851	#define bfd_put_64(abfd, val, ptr) \
852	BFD_SEND(abfd, bfd_putx64, ((val), (ptr)))
853	#define bfd_put_signed_64 \
854	bfd_put_64
855	#define bfd_get_64(abfd, ptr) \
856	BFD_SEND(abfd, bfd_getx64, (ptr))
857	#define bfd_get_signed_64(abfd, ptr) \
858	BFD_SEND(abfd, bfd_getx_signed_64, (ptr))
859
860	#define bfd_get(bits, abfd, ptr) \
861	((bits) == 8 ? bfd_get_8 (abfd, ptr) \
862	: (bits) == 16 ? bfd_get_16 (abfd, ptr) \
863	: (bits) == 32 ? bfd_get_32 (abfd, ptr) \
864	: (bits) == 64 ? bfd_get_64 (abfd, ptr) \
865	: (abort (), (bfd_vma) - 1))
866
867	#define bfd_put(bits, abfd, val, ptr) \
868	((bits) == 8 ? bfd_put_8 (abfd, val, ptr) \
869	: (bits) == 16 ? bfd_put_16 (abfd, val, ptr) \
870	: (bits) == 32 ? bfd_put_32 (abfd, val, ptr) \
871	: (bits) == 64 ? bfd_put_64 (abfd, val, ptr) \
872	: (abort (), (void) 0))
873
874
875	/* Byte swapping macros for file header data. */
876
877	#define bfd_h_put_8(abfd, val, ptr) \
878	bfd_put_8 (abfd, val, ptr)
879	#define bfd_h_put_signed_8(abfd, val, ptr) \
880	bfd_put_8 (abfd, val, ptr)
881	#define bfd_h_get_8(abfd, ptr) \
882	bfd_get_8 (abfd, ptr)
883	#define bfd_h_get_signed_8(abfd, ptr) \
884	bfd_get_signed_8 (abfd, ptr)
885
886	#define bfd_h_put_16(abfd, val, ptr) \
887	BFD_SEND(abfd, bfd_h_putx16,(val,ptr))
888	#define bfd_h_put_signed_16 \
889	bfd_h_put_16
890	#define bfd_h_get_16(abfd, ptr) \
891	BFD_SEND(abfd, bfd_h_getx16,(ptr))
892	#define bfd_h_get_signed_16(abfd, ptr) \
893	BFD_SEND(abfd, bfd_h_getx_signed_16, (ptr))
894
895	#define bfd_h_put_32(abfd, val, ptr) \
896	BFD_SEND(abfd, bfd_h_putx32,(val,ptr))
897	#define bfd_h_put_signed_32 \
898	bfd_h_put_32
899	#define bfd_h_get_32(abfd, ptr) \
900	BFD_SEND(abfd, bfd_h_getx32,(ptr))
901	#define bfd_h_get_signed_32(abfd, ptr) \
902	BFD_SEND(abfd, bfd_h_getx_signed_32, (ptr))
903
904	#define bfd_h_put_64(abfd, val, ptr) \
905	BFD_SEND(abfd, bfd_h_putx64,(val, ptr))
906	#define bfd_h_put_signed_64 \
907	bfd_h_put_64
908	#define bfd_h_get_64(abfd, ptr) \
909	BFD_SEND(abfd, bfd_h_getx64,(ptr))
910	#define bfd_h_get_signed_64(abfd, ptr) \
911	BFD_SEND(abfd, bfd_h_getx_signed_64, (ptr))
912
913	/* This structure is used for a comdat section, as in PE. A comdat
914	section is associated with a particular symbol. When the linker
915	sees a comdat section, it keeps only one of the sections with a
916	given name and associated with a given symbol. */
917
918	struct bfd_comdat_info
919	{
920	/* The name of the symbol associated with a comdat section. */
921	const char *name;
922
923	/* The local symbol table index of the symbol associated with a
924	comdat section. This is only meaningful to the object file format
925	specific code; it is not an index into the list returned by
926	bfd_canonicalize_symtab. */
927	long symbol;
928	};
929
930	typedef struct sec
931	{
932	/* The name of the section; the name isn't a copy, the pointer is
933	the same as that passed to bfd_make_section. */
934
935	const char *name;
936
937	/* A unique sequence number. */
938
939	int id;
940
941	/* Which section is it; 0..nth. */
942
943	int index;
944
945	/* The next section in the list belonging to the BFD, or NULL. */
946
947	struct sec *next;
948
949	/* The field flags contains attributes of the section. Some
950	flags are read in from the object file, and some are
951	synthesized from other information. */
952
953	flagword flags;
954
955	#define SEC_NO_FLAGS 0x000
956
957	/* Tells the OS to allocate space for this section when loading.
958	This is clear for a section containing debug information only. */
959	#define SEC_ALLOC 0x001
960
961	/* Tells the OS to load the section from the file when loading.
962	This is clear for a .bss section. */
963	#define SEC_LOAD 0x002
964
965	/* The section contains data still to be relocated, so there is
966	some relocation information too. */
967	#define SEC_RELOC 0x004
968
969	#if 0 /* Obsolete ? */
970	#define SEC_BALIGN 0x008
971	#endif
972
973	/* A signal to the OS that the section contains read only data. */
974	#define SEC_READONLY 0x010
975
976	/* The section contains code only. */
977	#define SEC_CODE 0x020
978
979	/* The section contains data only. */
980	#define SEC_DATA 0x040
981
982	/* The section will reside in ROM. */
983	#define SEC_ROM 0x080
984
985	/* The section contains constructor information. This section
986	type is used by the linker to create lists of constructors and
987	destructors used by <<g++>>. When a back end sees a symbol
988	which should be used in a constructor list, it creates a new
989	section for the type of name (e.g., <<__CTOR_LIST__>>), attaches
990	the symbol to it, and builds a relocation. To build the lists
991	of constructors, all the linker has to do is catenate all the
992	sections called <<__CTOR_LIST__>> and relocate the data
993	contained within - exactly the operations it would peform on
994	standard data. */
995	#define SEC_CONSTRUCTOR 0x100
996
997	/* The section is a constructor, and should be placed at the
998	end of the text, data, or bss section(?). */
999	#define SEC_CONSTRUCTOR_TEXT 0x1100
1000	#define SEC_CONSTRUCTOR_DATA 0x2100
1001	#define SEC_CONSTRUCTOR_BSS 0x3100
1002
1003	/* The section has contents - a data section could be
1004	<<SEC_ALLOC>> \| <<SEC_HAS_CONTENTS>>; a debug section could be
1005	<<SEC_HAS_CONTENTS>> */
1006	#define SEC_HAS_CONTENTS 0x200
1007
1008	/* An instruction to the linker to not output the section
1009	even if it has information which would normally be written. */
1010	#define SEC_NEVER_LOAD 0x400
1011
1012	/* The section is a COFF shared library section. This flag is
1013	only for the linker. If this type of section appears in
1014	the input file, the linker must copy it to the output file
1015	without changing the vma or size. FIXME: Although this
1016	was originally intended to be general, it really is COFF
1017	specific (and the flag was renamed to indicate this). It
1018	might be cleaner to have some more general mechanism to
1019	allow the back end to control what the linker does with
1020	sections. */
1021	#define SEC_COFF_SHARED_LIBRARY 0x800
1022
1023	/* The section has GOT references. This flag is only for the
1024	linker, and is currently only used by the elf32-hppa back end.
1025	It will be set if global offset table references were detected
1026	in this section, which indicate to the linker that the section
1027	contains PIC code, and must be handled specially when doing a
1028	static link. */
1029	#define SEC_HAS_GOT_REF 0x4000
1030
1031	/* The section contains common symbols (symbols may be defined
1032	multiple times, the value of a symbol is the amount of
1033	space it requires, and the largest symbol value is the one
1034	used). Most targets have exactly one of these (which we
1035	translate to bfd_com_section_ptr), but ECOFF has two. */
1036	#define SEC_IS_COMMON 0x8000
1037
1038	/* The section contains only debugging information. For
1039	example, this is set for ELF .debug and .stab sections.
1040	strip tests this flag to see if a section can be
1041	discarded. */
1042	#define SEC_DEBUGGING 0x10000
1043
1044	/* The contents of this section are held in memory pointed to
1045	by the contents field. This is checked by bfd_get_section_contents,
1046	and the data is retrieved from memory if appropriate. */
1047	#define SEC_IN_MEMORY 0x20000
1048
1049	/* The contents of this section are to be excluded by the
1050	linker for executable and shared objects unless those
1051	objects are to be further relocated. */
1052	#define SEC_EXCLUDE 0x40000
1053
1054	/* The contents of this section are to be sorted by the
1055	based on the address specified in the associated symbol
1056	table. */
1057	#define SEC_SORT_ENTRIES 0x80000
1058
1059	/* When linking, duplicate sections of the same name should be
1060	discarded, rather than being combined into a single section as
1061	is usually done. This is similar to how common symbols are
1062	handled. See SEC_LINK_DUPLICATES below. */
1063	#define SEC_LINK_ONCE 0x100000
1064
1065	/* If SEC_LINK_ONCE is set, this bitfield describes how the linker
1066	should handle duplicate sections. */
1067	#define SEC_LINK_DUPLICATES 0x600000
1068
1069	/* This value for SEC_LINK_DUPLICATES means that duplicate
1070	sections with the same name should simply be discarded. */
1071	#define SEC_LINK_DUPLICATES_DISCARD 0x0
1072
1073	/* This value for SEC_LINK_DUPLICATES means that the linker
1074	should warn if there are any duplicate sections, although
1075	it should still only link one copy. */
1076	#define SEC_LINK_DUPLICATES_ONE_ONLY 0x200000
1077
1078	/* This value for SEC_LINK_DUPLICATES means that the linker
1079	should warn if any duplicate sections are a different size. */
1080	#define SEC_LINK_DUPLICATES_SAME_SIZE 0x400000
1081
1082	/* This value for SEC_LINK_DUPLICATES means that the linker
1083	should warn if any duplicate sections contain different
1084	contents. */
1085	#define SEC_LINK_DUPLICATES_SAME_CONTENTS 0x600000
1086
1087	/* This section was created by the linker as part of dynamic
1088	relocation or other arcane processing. It is skipped when
1089	going through the first-pass output, trusting that someone
1090	else up the line will take care of it later. */
1091	#define SEC_LINKER_CREATED 0x800000
1092
1093	/* This section should not be subject to garbage collection. */
1094	#define SEC_KEEP 0x1000000
1095
1096	/* This section contains "short" data, and should be placed
1097	"near" the GP. */
1098	#define SEC_SMALL_DATA 0x2000000
1099
1100	/* This section contains data which may be shared with other
1101	executables or shared objects. */
1102	#define SEC_SHARED 0x4000000
1103
1104	/* When a section with this flag is being linked, then if the size of
1105	the input section is less than a page, it should not cross a page
1106	boundary. If the size of the input section is one page or more, it
1107	should be aligned on a page boundary. */
1108	#define SEC_BLOCK 0x8000000
1109
1110	/* Conditionally link this section; do not link if there are no
1111	references found to any symbol in the section. */
1112	#define SEC_CLINK 0x10000000
1113
1114	/* End of section flags. */
1115
1116	/* Some internal packed boolean fields. */
1117
1118	/* See the vma field. */
1119	unsigned int user_set_vma : 1;
1120
1121	/* Whether relocations have been processed. */
1122	unsigned int reloc_done : 1;
1123
1124	/* A mark flag used by some of the linker backends. */
1125	unsigned int linker_mark : 1;
1126
1127	/* Another mark flag used by some of the linker backends. Set for
1128	output sections that have a input section. */
1129	unsigned int linker_has_input : 1;
1130
1131	/* A mark flag used by some linker backends for garbage collection. */
1132	unsigned int gc_mark : 1;
1133
1134	/* Used by the ELF code to mark sections which have been allocated to segments. */
1135	unsigned int segment_mark : 1;
1136
1137	/* End of internal packed boolean fields. */
1138
1139	/* The virtual memory address of the section - where it will be
1140	at run time. The symbols are relocated against this. The
1141	user_set_vma flag is maintained by bfd; if it's not set, the
1142	backend can assign addresses (for example, in <<a.out>>, where
1143	the default address for <<.data>> is dependent on the specific
1144	target and various flags). */
1145
1146	bfd_vma vma;
1147
1148	/* The load address of the section - where it would be in a
1149	rom image; really only used for writing section header
1150	information. */
1151
1152	bfd_vma lma;
1153
1154	/* The size of the section in octets, as it will be output.
1155	Contains a value even if the section has no contents (e.g., the
1156	size of <<.bss>>). This will be filled in after relocation. */
1157
1158	bfd_size_type _cooked_size;
1159
1160	/* The original size on disk of the section, in octets. Normally this
1161	value is the same as the size, but if some relaxing has
1162	been done, then this value will be bigger. */
1163
1164	bfd_size_type _raw_size;
1165
1166	/* If this section is going to be output, then this value is the
1167	offset in bytes into the output section of the first byte in the
1168	input section (byte ==> smallest addressable unit on the
1169	target). In most cases, if this was going to start at the
1170	100th octet (8-bit quantity) in the output section, this value
1171	would be 100. However, if the target byte size is 16 bits
1172	(bfd_octets_per_byte is "2"), this value would be 50. */
1173
1174	bfd_vma output_offset;
1175
1176	/* The output section through which to map on output. */
1177
1178	struct sec *output_section;
1179
1180	/* The alignment requirement of the section, as an exponent of 2 -
1181	e.g., 3 aligns to 2^3 (or 8). */
1182
1183	unsigned int alignment_power;
1184
1185	/* If an input section, a pointer to a vector of relocation
1186	records for the data in this section. */
1187
1188	struct reloc_cache_entry *relocation;
1189
1190	/* If an output section, a pointer to a vector of pointers to
1191	relocation records for the data in this section. */
1192
1193	struct reloc_cache_entry **orelocation;
1194
1195	/* The number of relocation records in one of the above */
1196
1197	unsigned reloc_count;
1198
1199	/* Information below is back end specific - and not always used
1200	or updated. */
1201
1202	/* File position of section data. */
1203
1204	file_ptr filepos;
1205
1206	/* File position of relocation info. */
1207
1208	file_ptr rel_filepos;
1209
1210	/* File position of line data. */
1211
1212	file_ptr line_filepos;
1213
1214	/* Pointer to data for applications. */
1215
1216	PTR userdata;
1217
1218	/* If the SEC_IN_MEMORY flag is set, this points to the actual
1219	contents. */
1220	unsigned char *contents;
1221
1222	/* Attached line number information. */
1223
1224	alent *lineno;
1225
1226	/* Number of line number records. */
1227
1228	unsigned int lineno_count;
1229
1230	/* Optional information about a COMDAT entry; NULL if not COMDAT. */
1231
1232	struct bfd_comdat_info *comdat;
1233
1234	/* Points to the kept section if this section is a link-once section,
1235	and is discarded. */
1236	struct sec *kept_section;
1237
1238	/* When a section is being output, this value changes as more
1239	linenumbers are written out. */
1240
1241	file_ptr moving_line_filepos;
1242
1243	/* What the section number is in the target world. */
1244
1245	int target_index;
1246
1247	PTR used_by_bfd;
1248
1249	/* If this is a constructor section then here is a list of the
1250	relocations created to relocate items within it. */
1251
1252	struct relent_chain *constructor_chain;
1253
1254	/* The BFD which owns the section. */
1255
1256	bfd *owner;
1257
1258	/* A symbol which points at this section only */
1259	struct symbol_cache_entry *symbol;
1260	struct symbol_cache_entry **symbol_ptr_ptr;
1261
1262	struct bfd_link_order *link_order_head;
1263	struct bfd_link_order *link_order_tail;
1264	} asection ;
1265
1266	/* These sections are global, and are managed by BFD. The application
1267	and target back end are not permitted to change the values in
1268	these sections. New code should use the section_ptr macros rather
1269	than referring directly to the const sections. The const sections
1270	may eventually vanish. */
1271	#define BFD_ABS_SECTION_NAME "ABS"
1272	#define BFD_UND_SECTION_NAME "UND"
1273	#define BFD_COM_SECTION_NAME "COM"
1274	#define BFD_IND_SECTION_NAME "IND"
1275
1276	/* the absolute section */
1277	extern const asection bfd_abs_section;
1278	#define bfd_abs_section_ptr ((asection *) &bfd_abs_section)
1279	#define bfd_is_abs_section(sec) ((sec) == bfd_abs_section_ptr)
1280	/* Pointer to the undefined section */
1281	extern const asection bfd_und_section;
1282	#define bfd_und_section_ptr ((asection *) &bfd_und_section)
1283	#define bfd_is_und_section(sec) ((sec) == bfd_und_section_ptr)
1284	/* Pointer to the common section */
1285	extern const asection bfd_com_section;
1286	#define bfd_com_section_ptr ((asection *) &bfd_com_section)
1287	/* Pointer to the indirect section */
1288	extern const asection bfd_ind_section;
1289	#define bfd_ind_section_ptr ((asection *) &bfd_ind_section)
1290	#define bfd_is_ind_section(sec) ((sec) == bfd_ind_section_ptr)
1291
1292	extern const struct symbol_cache_entry * const bfd_abs_symbol;
1293	extern const struct symbol_cache_entry * const bfd_com_symbol;
1294	extern const struct symbol_cache_entry * const bfd_und_symbol;
1295	extern const struct symbol_cache_entry * const bfd_ind_symbol;
1296	#define bfd_get_section_size_before_reloc(section) \
1297	((section)->reloc_done ? (abort (), (bfd_size_type) 1) \
1298	: (section)->_raw_size)
1299	#define bfd_get_section_size_after_reloc(section) \
1300	((section)->reloc_done ? (section)->_cooked_size \
1301	: (abort (), (bfd_size_type) 1))
1302	asection *
1303	bfd_get_section_by_name PARAMS ((bfd abfd, const char name));
1304
1305	char *
1306	bfd_get_unique_section_name PARAMS ((bfd *abfd,
1307	const char *templat,
1308	int *count));
1309
1310	asection *
1311	bfd_make_section_old_way PARAMS ((bfd abfd, const char name));
1312
1313	asection *
1314	bfd_make_section_anyway PARAMS ((bfd abfd, const char name));
1315
1316	asection *
1317	bfd_make_section PARAMS ((bfd , const char name));
1318
1319	boolean
1320	bfd_set_section_flags PARAMS ((bfd abfd, asection sec, flagword flags));
1321
1322	void
1323	bfd_map_over_sections PARAMS ((bfd *abfd,
1324	void (func) (bfd abfd,
1325	asection *sect,
1326	PTR obj),
1327	PTR obj));
1328
1329	boolean
1330	bfd_set_section_size PARAMS ((bfd abfd, asection sec, bfd_size_type val));
1331
1332	boolean
1333	bfd_set_section_contents PARAMS ((bfd *abfd,
1334	asection *section,
1335	PTR data,
1336	file_ptr offset,
1337	bfd_size_type count));
1338
1339	boolean
1340	bfd_get_section_contents PARAMS ((bfd abfd, asection section, PTR location,
1341	file_ptr offset, bfd_size_type count));
1342
1343	boolean
1344	bfd_copy_private_section_data PARAMS ((bfd ibfd, asection isec, bfd obfd, asection osec));
1345
1346	#define bfd_copy_private_section_data(ibfd, isection, obfd, osection) \
1347	BFD_SEND (obfd, _bfd_copy_private_section_data, \
1348	(ibfd, isection, obfd, osection))
1349	void
1350	_bfd_strip_section_from_output PARAMS ((struct bfd_link_info info, asection section));
1351
1352	enum bfd_architecture
1353	{
1354	bfd_arch_unknown, /* File arch not known */
1355	bfd_arch_obscure, /* Arch known, not one of these */
1356	bfd_arch_m68k, /* Motorola 68xxx */
1357	#define bfd_mach_m68000 1
1358	#define bfd_mach_m68008 2
1359	#define bfd_mach_m68010 3
1360	#define bfd_mach_m68020 4
1361	#define bfd_mach_m68030 5
1362	#define bfd_mach_m68040 6
1363	#define bfd_mach_m68060 7
1364	#define bfd_mach_cpu32 8
1365	#define bfd_mach_mcf5200 9
1366	#define bfd_mach_mcf5206e 10
1367	#define bfd_mach_mcf5307 11
1368	#define bfd_mach_mcf5407 12
1369	bfd_arch_vax, /* DEC Vax */
1370	bfd_arch_i960, /* Intel 960 */
1371	/* The order of the following is important.
1372	lower number indicates a machine type that
1373	only accepts a subset of the instructions
1374	available to machines with higher numbers.
1375	The exception is the "ca", which is
1376	incompatible with all other machines except
1377	"core". */
1378
1379	#define bfd_mach_i960_core 1
1380	#define bfd_mach_i960_ka_sa 2
1381	#define bfd_mach_i960_kb_sb 3
1382	#define bfd_mach_i960_mc 4
1383	#define bfd_mach_i960_xa 5
1384	#define bfd_mach_i960_ca 6
1385	#define bfd_mach_i960_jx 7
1386	#define bfd_mach_i960_hx 8
1387
1388	bfd_arch_a29k, /* AMD 29000 */
1389	bfd_arch_sparc, /* SPARC */
1390	#define bfd_mach_sparc 1
1391	/* The difference between v8plus and v9 is that v9 is a true 64 bit env. */
1392	#define bfd_mach_sparc_sparclet 2
1393	#define bfd_mach_sparc_sparclite 3
1394	#define bfd_mach_sparc_v8plus 4
1395	#define bfd_mach_sparc_v8plusa 5 /* with ultrasparc add'ns */
1396	#define bfd_mach_sparc_sparclite_le 6
1397	#define bfd_mach_sparc_v9 7
1398	#define bfd_mach_sparc_v9a 8 /* with ultrasparc add'ns */
1399	#define bfd_mach_sparc_v8plusb 9 /* with cheetah add'ns */
1400	#define bfd_mach_sparc_v9b 10 /* with cheetah add'ns */
1401	/* Nonzero if MACH has the v9 instruction set. */
1402	#define bfd_mach_sparc_v9_p(mach) \
1403	((mach) >= bfd_mach_sparc_v8plus && (mach) <= bfd_mach_sparc_v9b \
1404	&& (mach) != bfd_mach_sparc_sparclite_le)
1405	bfd_arch_mips, /* MIPS Rxxxx */
1406	#define bfd_mach_mips3000 3000
1407	#define bfd_mach_mips3900 3900
1408	#define bfd_mach_mips4000 4000
1409	#define bfd_mach_mips4010 4010
1410	#define bfd_mach_mips4100 4100
1411	#define bfd_mach_mips4111 4111
1412	#define bfd_mach_mips4300 4300
1413	#define bfd_mach_mips4400 4400
1414	#define bfd_mach_mips4600 4600
1415	#define bfd_mach_mips4650 4650
1416	#define bfd_mach_mips5000 5000
1417	#define bfd_mach_mips6000 6000
1418	#define bfd_mach_mips8000 8000
1419	#define bfd_mach_mips10000 10000
1420	#define bfd_mach_mips12000 12000
1421	#define bfd_mach_mips16 16
1422	#define bfd_mach_mips32 32
1423	#define bfd_mach_mips32_4k 3204113 /* 32, 04, octal 'K' */
1424	#define bfd_mach_mips5 5
1425	#define bfd_mach_mips64 64
1426	#define bfd_mach_mips_sb1 12310201 /* octal 'SB', 01 */
1427	bfd_arch_i386, /* Intel 386 */
1428	#define bfd_mach_i386_i386 0
1429	#define bfd_mach_i386_i8086 1
1430	#define bfd_mach_i386_i386_intel_syntax 2
1431	#define bfd_mach_x86_64 3
1432	#define bfd_mach_x86_64_intel_syntax 4
1433	bfd_arch_we32k, /* AT&T WE32xxx */
1434	bfd_arch_tahoe, /* CCI/Harris Tahoe */
1435	bfd_arch_i860, /* Intel 860 */
1436	bfd_arch_i370, /* IBM 360/370 Mainframes */
1437	bfd_arch_romp, /* IBM ROMP PC/RT */
1438	bfd_arch_alliant, /* Alliant */
1439	bfd_arch_convex, /* Convex */
1440	bfd_arch_m88k, /* Motorola 88xxx */
1441	bfd_arch_pyramid, /* Pyramid Technology */
1442	bfd_arch_h8300, /* Hitachi H8/300 */
1443	#define bfd_mach_h8300 1
1444	#define bfd_mach_h8300h 2
1445	#define bfd_mach_h8300s 3
1446	bfd_arch_powerpc, /* PowerPC */
1447	#define bfd_mach_ppc 0
1448	#define bfd_mach_ppc_403 403
1449	#define bfd_mach_ppc_403gc 4030
1450	#define bfd_mach_ppc_505 505
1451	#define bfd_mach_ppc_601 601
1452	#define bfd_mach_ppc_602 602
1453	#define bfd_mach_ppc_603 603
1454	#define bfd_mach_ppc_ec603e 6031
1455	#define bfd_mach_ppc_604 604
1456	#define bfd_mach_ppc_620 620
1457	#define bfd_mach_ppc_630 630
1458	#define bfd_mach_ppc_750 750
1459	#define bfd_mach_ppc_860 860
1460	#define bfd_mach_ppc_a35 35
1461	#define bfd_mach_ppc_rs64ii 642
1462	#define bfd_mach_ppc_rs64iii 643
1463	#define bfd_mach_ppc_7400 7400
1464	bfd_arch_rs6000, /* IBM RS/6000 */
1465	#define bfd_mach_rs6k 0
1466	#define bfd_mach_rs6k_rs1 6001
1467	#define bfd_mach_rs6k_rsc 6003
1468	#define bfd_mach_rs6k_rs2 6002
1469	bfd_arch_hppa, /* HP PA RISC */
1470	bfd_arch_d10v, /* Mitsubishi D10V */
1471	#define bfd_mach_d10v 0
1472	#define bfd_mach_d10v_ts2 2
1473	#define bfd_mach_d10v_ts3 3
1474	bfd_arch_d30v, /* Mitsubishi D30V */
1475	bfd_arch_m68hc11, /* Motorola 68HC11 */
1476	bfd_arch_m68hc12, /* Motorola 68HC12 */
1477	bfd_arch_z8k, /* Zilog Z8000 */
1478	#define bfd_mach_z8001 1
1479	#define bfd_mach_z8002 2
1480	bfd_arch_h8500, /* Hitachi H8/500 */
1481	bfd_arch_sh, /* Hitachi SH */
1482	#define bfd_mach_sh 0
1483	#define bfd_mach_sh2 0x20
1484	#define bfd_mach_sh_dsp 0x2d
1485	#define bfd_mach_sh3 0x30
1486	#define bfd_mach_sh3_dsp 0x3d
1487	#define bfd_mach_sh3e 0x3e
1488	#define bfd_mach_sh4 0x40
1489	bfd_arch_alpha, /* Dec Alpha */
1490	#define bfd_mach_alpha_ev4 0x10
1491	#define bfd_mach_alpha_ev5 0x20
1492	#define bfd_mach_alpha_ev6 0x30
1493	bfd_arch_arm, /* Advanced Risc Machines ARM */
1494	#define bfd_mach_arm_2 1
1495	#define bfd_mach_arm_2a 2
1496	#define bfd_mach_arm_3 3
1497	#define bfd_mach_arm_3M 4
1498	#define bfd_mach_arm_4 5
1499	#define bfd_mach_arm_4T 6
1500	#define bfd_mach_arm_5 7
1501	#define bfd_mach_arm_5T 8
1502	#define bfd_mach_arm_5TE 9
1503	#define bfd_mach_arm_XScale 10
1504	bfd_arch_ns32k, /* National Semiconductors ns32000 */
1505	bfd_arch_w65, /* WDC 65816 */
1506	bfd_arch_tic30, /* Texas Instruments TMS320C30 */
1507	bfd_arch_tic54x, /* Texas Instruments TMS320C54X */
1508	bfd_arch_tic80, /* TI TMS320c80 (MVP) */
1509	bfd_arch_v850, /* NEC V850 */
1510	#define bfd_mach_v850 0
1511	#define bfd_mach_v850e 'E'
1512	#define bfd_mach_v850ea 'A'
1513	bfd_arch_arc, /* ARC Cores */
1514	#define bfd_mach_arc_5 0
1515	#define bfd_mach_arc_6 1
1516	#define bfd_mach_arc_7 2
1517	#define bfd_mach_arc_8 3
1518	bfd_arch_m32r, /* Mitsubishi M32R/D */
1519	#define bfd_mach_m32r 0 /* backwards compatibility */
1520	#define bfd_mach_m32rx 'x'
1521	bfd_arch_mn10200, /* Matsushita MN10200 */
1522	bfd_arch_mn10300, /* Matsushita MN10300 */
1523	#define bfd_mach_mn10300 300
1524	#define bfd_mach_am33 330
1525	bfd_arch_fr30,
1526	#define bfd_mach_fr30 0x46523330
1527	bfd_arch_mcore,
1528	bfd_arch_ia64, /* HP/Intel ia64 */
1529	#define bfd_mach_ia64_elf64 0
1530	#define bfd_mach_ia64_elf32 1
1531	bfd_arch_pj,
1532	bfd_arch_avr, /* Atmel AVR microcontrollers */
1533	#define bfd_mach_avr1 1
1534	#define bfd_mach_avr2 2
1535	#define bfd_mach_avr3 3
1536	#define bfd_mach_avr4 4
1537	#define bfd_mach_avr5 5
1538	bfd_arch_cris, /* Axis CRIS */
1539	bfd_arch_last
1540	};
1541
1542	typedef struct bfd_arch_info
1543	{
1544	int bits_per_word;
1545	int bits_per_address;
1546	int bits_per_byte;
1547	enum bfd_architecture arch;
1548	unsigned long mach;
1549	const char *arch_name;
1550	const char *printable_name;
1551	unsigned int section_align_power;
1552	/* True if this is the default machine for the architecture. */
1553	boolean the_default;
1554	const struct bfd_arch_info * (*compatible)
1555	PARAMS ((const struct bfd_arch_info *a,
1556	const struct bfd_arch_info *b));
1557
1558	boolean (scan) PARAMS ((const struct bfd_arch_info , const char *));
1559
1560	const struct bfd_arch_info *next;
1561	} bfd_arch_info_type;
1562	const char *
1563	bfd_printable_name PARAMS ((bfd *abfd));
1564
1565	const bfd_arch_info_type *
1566	bfd_scan_arch PARAMS ((const char *string));
1567
1568	const char **
1569	bfd_arch_list PARAMS ((void));
1570
1571	const bfd_arch_info_type *
1572	bfd_arch_get_compatible PARAMS ((
1573	const bfd *abfd,
1574	const bfd *bbfd));
1575
1576	void
1577	bfd_set_arch_info PARAMS ((bfd abfd, const bfd_arch_info_type arg));
1578
1579	enum bfd_architecture
1580	bfd_get_arch PARAMS ((bfd *abfd));
1581
1582	unsigned long
1583	bfd_get_mach PARAMS ((bfd *abfd));
1584
1585	unsigned int
1586	bfd_arch_bits_per_byte PARAMS ((bfd *abfd));
1587
1588	unsigned int
1589	bfd_arch_bits_per_address PARAMS ((bfd *abfd));
1590
1591	const bfd_arch_info_type *
1592	bfd_get_arch_info PARAMS ((bfd *abfd));
1593
1594	const bfd_arch_info_type *
1595	bfd_lookup_arch PARAMS ((enum bfd_architecture
1596	arch,
1597	unsigned long machine));
1598
1599	const char *
1600	bfd_printable_arch_mach PARAMS ((enum bfd_architecture arch, unsigned long machine));
1601
1602	unsigned int
1603	bfd_octets_per_byte PARAMS ((bfd *abfd));
1604
1605	unsigned int
1606	bfd_arch_mach_octets_per_byte PARAMS ((enum bfd_architecture arch,
1607	unsigned long machine));
1608
1609	typedef enum bfd_reloc_status
1610	{
1611	/* No errors detected */
1612	bfd_reloc_ok,
1613
1614	/* The relocation was performed, but there was an overflow. */
1615	bfd_reloc_overflow,
1616
1617	/* The address to relocate was not within the section supplied. */
1618	bfd_reloc_outofrange,
1619
1620	/* Used by special functions */
1621	bfd_reloc_continue,
1622
1623	/* Unsupported relocation size requested. */
1624	bfd_reloc_notsupported,
1625
1626	/* Unused */
1627	bfd_reloc_other,
1628
1629	/* The symbol to relocate against was undefined. */
1630	bfd_reloc_undefined,
1631
1632	/* The relocation was performed, but may not be ok - presently
1633	generated only when linking i960 coff files with i960 b.out
1634	symbols. If this type is returned, the error_message argument
1635	to bfd_perform_relocation will be set. */
1636	bfd_reloc_dangerous
1637	}
1638	bfd_reloc_status_type;
1639
1640
1641	typedef struct reloc_cache_entry
1642	{
1643	/* A pointer into the canonical table of pointers */
1644	struct symbol_cache_entry **sym_ptr_ptr;
1645
1646	/* offset in section */
1647	bfd_size_type address;
1648
1649	/* addend for relocation value */
1650	bfd_vma addend;
1651
1652	/* Pointer to how to perform the required relocation */
1653	reloc_howto_type *howto;
1654
1655	} arelent;
1656	enum complain_overflow
1657	{
1658	/* Do not complain on overflow. */
1659	complain_overflow_dont,
1660
1661	/* Complain if the bitfield overflows, whether it is considered
1662	as signed or unsigned. */
1663	complain_overflow_bitfield,
1664
1665	/* Complain if the value overflows when considered as signed
1666	number. */
1667	complain_overflow_signed,
1668
1669	/* Complain if the value overflows when considered as an
1670	unsigned number. */
1671	complain_overflow_unsigned
1672	};
1673
1674	struct reloc_howto_struct
1675	{
1676	/* The type field has mainly a documentary use - the back end can
1677	do what it wants with it, though normally the back end's
1678	external idea of what a reloc number is stored
1679	in this field. For example, a PC relative word relocation
1680	in a coff environment has the type 023 - because that's
1681	what the outside world calls a R_PCRWORD reloc. */
1682	unsigned int type;
1683
1684	/* The value the final relocation is shifted right by. This drops
1685	unwanted data from the relocation. */
1686	unsigned int rightshift;
1687
1688	/* The size of the item to be relocated. This is not a
1689	power-of-two measure. To get the number of bytes operated
1690	on by a type of relocation, use bfd_get_reloc_size. */
1691	int size;
1692
1693	/* The number of bits in the item to be relocated. This is used
1694	when doing overflow checking. */
1695	unsigned int bitsize;
1696
1697	/* Notes that the relocation is relative to the location in the
1698	data section of the addend. The relocation function will
1699	subtract from the relocation value the address of the location
1700	being relocated. */
1701	boolean pc_relative;
1702
1703	/* The bit position of the reloc value in the destination.
1704	The relocated value is left shifted by this amount. */
1705	unsigned int bitpos;
1706
1707	/* What type of overflow error should be checked for when
1708	relocating. */
1709	enum complain_overflow complain_on_overflow;
1710
1711	/* If this field is non null, then the supplied function is
1712	called rather than the normal function. This allows really
1713	strange relocation methods to be accomodated (e.g., i960 callj
1714	instructions). */
1715	bfd_reloc_status_type (*special_function)
1716	PARAMS ((bfd *abfd,
1717	arelent *reloc_entry,
1718	struct symbol_cache_entry *symbol,
1719	PTR data,
1720	asection *input_section,
1721	bfd *output_bfd,
1722	char **error_message));
1723
1724	/* The textual name of the relocation type. */
1725	char *name;
1726
1727	/* Some formats record a relocation addend in the section contents
1728	rather than with the relocation. For ELF formats this is the
1729	distinction between USE_REL and USE_RELA (though the code checks
1730	for USE_REL == 1/0). The value of this field is TRUE if the
1731	addend is recorded with the section contents; when performing a
1732	partial link (ld -r) the section contents (the data) will be
1733	modified. The value of this field is FALSE if addends are
1734	recorded with the relocation (in arelent.addend); when performing
1735	a partial link the relocation will be modified.
1736	All relocations for all ELF USE_RELA targets should set this field
1737	to FALSE (values of TRUE should be looked on with suspicion).
1738	However, the converse is not true: not all relocations of all ELF
1739	USE_REL targets set this field to TRUE. Why this is so is peculiar
1740	to each particular target. For relocs that aren't used in partial
1741	links (e.g. GOT stuff) it doesn't matter what this is set to. */
1742	boolean partial_inplace;
1743
1744	/* The src_mask selects which parts of the read in data
1745	are to be used in the relocation sum. E.g., if this was an 8 bit
1746	byte of data which we read and relocated, this would be
1747	0x000000ff. When we have relocs which have an addend, such as
1748	sun4 extended relocs, the value in the offset part of a
1749	relocating field is garbage so we never use it. In this case
1750	the mask would be 0x00000000. */
1751	bfd_vma src_mask;
1752
1753	/* The dst_mask selects which parts of the instruction are replaced
1754	into the instruction. In most cases src_mask == dst_mask,
1755	except in the above special case, where dst_mask would be
1756	0x000000ff, and src_mask would be 0x00000000. */
1757	bfd_vma dst_mask;
1758
1759	/* When some formats create PC relative instructions, they leave
1760	the value of the pc of the place being relocated in the offset
1761	slot of the instruction, so that a PC relative relocation can
1762	be made just by adding in an ordinary offset (e.g., sun3 a.out).
1763	Some formats leave the displacement part of an instruction
1764	empty (e.g., m88k bcs); this flag signals the fact.*/
1765	boolean pcrel_offset;
1766
1767	};
1768	#define HOWTO(C, R,S,B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC) \
1769	{(unsigned)C,R,S,B, P, BI, O,SF,NAME,INPLACE,MASKSRC,MASKDST,PC}
1770	#define NEWHOWTO( FUNCTION, NAME,SIZE,REL,IN) HOWTO(0,0,SIZE,0,REL,0,complain_overflow_dont,FUNCTION, NAME,false,0,0,IN)
1771
1772	#define EMPTY_HOWTO(C) \
1773	HOWTO((C),0,0,0,false,0,complain_overflow_dont,NULL,NULL,false,0,0,false)
1774
1775	#define HOWTO_PREPARE(relocation, symbol) \
1776	{ \
1777	if (symbol != (asymbol *)NULL) { \
1778	if (bfd_is_com_section (symbol->section)) { \
1779	relocation = 0; \
1780	} \
1781	else { \
1782	relocation = symbol->value; \
1783	} \
1784	} \
1785	}
1786	unsigned int
1787	bfd_get_reloc_size PARAMS ((reloc_howto_type *));
1788
1789	typedef struct relent_chain {
1790	arelent relent;
1791	struct relent_chain *next;
1792	} arelent_chain;
1793	bfd_reloc_status_type
1794	bfd_check_overflow PARAMS ((enum complain_overflow how,
1795	unsigned int bitsize,
1796	unsigned int rightshift,
1797	unsigned int addrsize,
1798	bfd_vma relocation));
1799
1800	bfd_reloc_status_type
1801	bfd_perform_relocation PARAMS ((bfd *abfd,
1802	arelent *reloc_entry,
1803	PTR data,
1804	asection *input_section,
1805	bfd *output_bfd,
1806	char **error_message));
1807
1808	bfd_reloc_status_type
1809	bfd_install_relocation PARAMS ((bfd *abfd,
1810	arelent *reloc_entry,
1811	PTR data, bfd_vma data_start,
1812	asection *input_section,
1813	char **error_message));
1814
1815	enum bfd_reloc_code_real {
1816	_dummy_first_bfd_reloc_code_real,
1817
1818
1819	/* Basic absolute relocations of N bits. */
1820	BFD_RELOC_64,
1821	BFD_RELOC_32,
1822	BFD_RELOC_26,
1823	BFD_RELOC_24,
1824	BFD_RELOC_16,
1825	BFD_RELOC_14,
1826	BFD_RELOC_8,
1827
1828	/* PC-relative relocations. Sometimes these are relative to the address
1829	of the relocation itself; sometimes they are relative to the start of
1830	the section containing the relocation. It depends on the specific target.
1831
1832	The 24-bit relocation is used in some Intel 960 configurations. */
1833	BFD_RELOC_64_PCREL,
1834	BFD_RELOC_32_PCREL,
1835	BFD_RELOC_24_PCREL,
1836	BFD_RELOC_16_PCREL,
1837	BFD_RELOC_12_PCREL,
1838	BFD_RELOC_8_PCREL,
1839
1840	/* For ELF. */
1841	BFD_RELOC_32_GOT_PCREL,
1842	BFD_RELOC_16_GOT_PCREL,
1843	BFD_RELOC_8_GOT_PCREL,
1844	BFD_RELOC_32_GOTOFF,
1845	BFD_RELOC_16_GOTOFF,
1846	BFD_RELOC_LO16_GOTOFF,
1847	BFD_RELOC_HI16_GOTOFF,
1848	BFD_RELOC_HI16_S_GOTOFF,
1849	BFD_RELOC_8_GOTOFF,
1850	BFD_RELOC_32_PLT_PCREL,
1851	BFD_RELOC_24_PLT_PCREL,
1852	BFD_RELOC_16_PLT_PCREL,
1853	BFD_RELOC_8_PLT_PCREL,
1854	BFD_RELOC_32_PLTOFF,
1855	BFD_RELOC_16_PLTOFF,
1856	BFD_RELOC_LO16_PLTOFF,
1857	BFD_RELOC_HI16_PLTOFF,
1858	BFD_RELOC_HI16_S_PLTOFF,
1859	BFD_RELOC_8_PLTOFF,
1860
1861	/* Relocations used by 68K ELF. */
1862	BFD_RELOC_68K_GLOB_DAT,
1863	BFD_RELOC_68K_JMP_SLOT,
1864	BFD_RELOC_68K_RELATIVE,
1865
1866	/* Linkage-table relative. */
1867	BFD_RELOC_32_BASEREL,
1868	BFD_RELOC_16_BASEREL,
1869	BFD_RELOC_LO16_BASEREL,
1870	BFD_RELOC_HI16_BASEREL,
1871	BFD_RELOC_HI16_S_BASEREL,
1872	BFD_RELOC_8_BASEREL,
1873	BFD_RELOC_RVA,
1874
1875	/* Absolute 8-bit relocation, but used to form an address like 0xFFnn. */
1876	BFD_RELOC_8_FFnn,
1877
1878	/* These PC-relative relocations are stored as word displacements --
1879	i.e., byte displacements shifted right two bits. The 30-bit word
1880	displacement (<<32_PCREL_S2>> -- 32 bits, shifted 2) is used on the
1881	SPARC. (SPARC tools generally refer to this as <<WDISP30>>.) The
1882	signed 16-bit displacement is used on the MIPS, and the 23-bit
1883	displacement is used on the Alpha. */
1884	BFD_RELOC_32_PCREL_S2,
1885	BFD_RELOC_16_PCREL_S2,
1886	BFD_RELOC_23_PCREL_S2,
1887
1888	/* High 22 bits and low 10 bits of 32-bit value, placed into lower bits of
1889	the target word. These are used on the SPARC. */
1890	BFD_RELOC_HI22,
1891	BFD_RELOC_LO10,
1892
1893	/* For systems that allocate a Global Pointer register, these are
1894	displacements off that register. These relocation types are
1895	handled specially, because the value the register will have is
1896	decided relatively late. */
1897	BFD_RELOC_GPREL16,
1898	BFD_RELOC_GPREL32,
1899
1900	/* Reloc types used for i960/b.out. */
1901	BFD_RELOC_I960_CALLJ,
1902
1903	/* SPARC ELF relocations. There is probably some overlap with other
1904	relocation types already defined. */
1905	BFD_RELOC_NONE,
1906	BFD_RELOC_SPARC_WDISP22,
1907	BFD_RELOC_SPARC22,
1908	BFD_RELOC_SPARC13,
1909	BFD_RELOC_SPARC_GOT10,
1910	BFD_RELOC_SPARC_GOT13,
1911	BFD_RELOC_SPARC_GOT22,
1912	BFD_RELOC_SPARC_PC10,
1913	BFD_RELOC_SPARC_PC22,
1914	BFD_RELOC_SPARC_WPLT30,
1915	BFD_RELOC_SPARC_COPY,
1916	BFD_RELOC_SPARC_GLOB_DAT,
1917	BFD_RELOC_SPARC_JMP_SLOT,
1918	BFD_RELOC_SPARC_RELATIVE,
1919	BFD_RELOC_SPARC_UA16,
1920	BFD_RELOC_SPARC_UA32,
1921	BFD_RELOC_SPARC_UA64,
1922
1923	/* I think these are specific to SPARC a.out (e.g., Sun 4). */
1924	BFD_RELOC_SPARC_BASE13,
1925	BFD_RELOC_SPARC_BASE22,
1926
1927	/* SPARC64 relocations */
1928	#define BFD_RELOC_SPARC_64 BFD_RELOC_64
1929	BFD_RELOC_SPARC_10,
1930	BFD_RELOC_SPARC_11,
1931	BFD_RELOC_SPARC_OLO10,
1932	BFD_RELOC_SPARC_HH22,
1933	BFD_RELOC_SPARC_HM10,
1934	BFD_RELOC_SPARC_LM22,
1935	BFD_RELOC_SPARC_PC_HH22,
1936	BFD_RELOC_SPARC_PC_HM10,
1937	BFD_RELOC_SPARC_PC_LM22,
1938	BFD_RELOC_SPARC_WDISP16,
1939	BFD_RELOC_SPARC_WDISP19,
1940	BFD_RELOC_SPARC_7,
1941	BFD_RELOC_SPARC_6,
1942	BFD_RELOC_SPARC_5,
1943	#define BFD_RELOC_SPARC_DISP64 BFD_RELOC_64_PCREL
1944	BFD_RELOC_SPARC_PLT64,
1945	BFD_RELOC_SPARC_HIX22,
1946	BFD_RELOC_SPARC_LOX10,
1947	BFD_RELOC_SPARC_H44,
1948	BFD_RELOC_SPARC_M44,
1949	BFD_RELOC_SPARC_L44,
1950	BFD_RELOC_SPARC_REGISTER,
1951
1952	/* SPARC little endian relocation */
1953	BFD_RELOC_SPARC_REV32,
1954
1955	/* Alpha ECOFF and ELF relocations. Some of these treat the symbol or
1956	"addend" in some special way.
1957	For GPDISP_HI16 ("gpdisp") relocations, the symbol is ignored when
1958	writing; when reading, it will be the absolute section symbol. The
1959	addend is the displacement in bytes of the "lda" instruction from
1960	the "ldah" instruction (which is at the address of this reloc). */
1961	BFD_RELOC_ALPHA_GPDISP_HI16,
1962
1963	/* For GPDISP_LO16 ("ignore") relocations, the symbol is handled as
1964	with GPDISP_HI16 relocs. The addend is ignored when writing the
1965	relocations out, and is filled in with the file's GP value on
1966	reading, for convenience. */
1967	BFD_RELOC_ALPHA_GPDISP_LO16,
1968
1969	/* The ELF GPDISP relocation is exactly the same as the GPDISP_HI16
1970	relocation except that there is no accompanying GPDISP_LO16
1971	relocation. */
1972	BFD_RELOC_ALPHA_GPDISP,
1973
1974	/* The Alpha LITERAL/LITUSE relocs are produced by a symbol reference;
1975	the assembler turns it into a LDQ instruction to load the address of
1976	the symbol, and then fills in a register in the real instruction.
1977
1978	The LITERAL reloc, at the LDQ instruction, refers to the .lita
1979	section symbol. The addend is ignored when writing, but is filled
1980	in with the file's GP value on reading, for convenience, as with the
1981	GPDISP_LO16 reloc.
1982
1983	The ELF_LITERAL reloc is somewhere between 16_GOTOFF and GPDISP_LO16.
1984	It should refer to the symbol to be referenced, as with 16_GOTOFF,
1985	but it generates output not based on the position within the .got
1986	section, but relative to the GP value chosen for the file during the
1987	final link stage.
1988
1989	The LITUSE reloc, on the instruction using the loaded address, gives
1990	information to the linker that it might be able to use to optimize
1991	away some literal section references. The symbol is ignored (read
1992	as the absolute section symbol), and the "addend" indicates the type
1993	of instruction using the register:
1994	1 - "memory" fmt insn
1995	2 - byte-manipulation (byte offset reg)
1996	3 - jsr (target of branch)
1997
1998	The GNU linker currently doesn't do any of this optimizing. */
1999	BFD_RELOC_ALPHA_LITERAL,
2000	BFD_RELOC_ALPHA_ELF_LITERAL,
2001	BFD_RELOC_ALPHA_LITUSE,
2002
2003	/* The BFD_RELOC_ALPHA_USER_* relocations are used by the assembler to
2004	process the explicit !<reloc>!sequence relocations, and are mapped
2005	into the normal relocations at the end of processing. */
2006	BFD_RELOC_ALPHA_USER_LITERAL,
2007	BFD_RELOC_ALPHA_USER_LITUSE_BASE,
2008	BFD_RELOC_ALPHA_USER_LITUSE_BYTOFF,
2009	BFD_RELOC_ALPHA_USER_LITUSE_JSR,
2010	BFD_RELOC_ALPHA_USER_GPDISP,
2011	BFD_RELOC_ALPHA_USER_GPRELHIGH,
2012	BFD_RELOC_ALPHA_USER_GPRELLOW,
2013
2014	/* The HINT relocation indicates a value that should be filled into the
2015	"hint" field of a jmp/jsr/ret instruction, for possible branch-
2016	prediction logic which may be provided on some processors. */
2017	BFD_RELOC_ALPHA_HINT,
2018
2019	/* The LINKAGE relocation outputs a linkage pair in the object file,
2020	which is filled by the linker. */
2021	BFD_RELOC_ALPHA_LINKAGE,
2022
2023	/* The CODEADDR relocation outputs a STO_CA in the object file,
2024	which is filled by the linker. */
2025	BFD_RELOC_ALPHA_CODEADDR,
2026
2027	/* Bits 27..2 of the relocation address shifted right 2 bits;
2028	simple reloc otherwise. */
2029	BFD_RELOC_MIPS_JMP,
2030
2031	/* The MIPS16 jump instruction. */
2032	BFD_RELOC_MIPS16_JMP,
2033
2034	/* MIPS16 GP relative reloc. */
2035	BFD_RELOC_MIPS16_GPREL,
2036
2037	/* High 16 bits of 32-bit value; simple reloc. */
2038	BFD_RELOC_HI16,
2039
2040	/* High 16 bits of 32-bit value but the low 16 bits will be sign
2041	extended and added to form the final result. If the low 16
2042	bits form a negative number, we need to add one to the high value
2043	to compensate for the borrow when the low bits are added. */
2044	BFD_RELOC_HI16_S,
2045
2046	/* Low 16 bits. */
2047	BFD_RELOC_LO16,
2048
2049	/* Like BFD_RELOC_HI16_S, but PC relative. */
2050	BFD_RELOC_PCREL_HI16_S,
2051
2052	/* Like BFD_RELOC_LO16, but PC relative. */
2053	BFD_RELOC_PCREL_LO16,
2054
2055	/* Relocation relative to the global pointer. */
2056	#define BFD_RELOC_MIPS_GPREL BFD_RELOC_GPREL16
2057
2058	/* Relocation against a MIPS literal section. */
2059	BFD_RELOC_MIPS_LITERAL,
2060
2061	/* MIPS ELF relocations. */
2062	BFD_RELOC_MIPS_GOT16,
2063	BFD_RELOC_MIPS_CALL16,
2064	#define BFD_RELOC_MIPS_GPREL32 BFD_RELOC_GPREL32
2065	BFD_RELOC_MIPS_GOT_HI16,
2066	BFD_RELOC_MIPS_GOT_LO16,
2067	BFD_RELOC_MIPS_CALL_HI16,
2068	BFD_RELOC_MIPS_CALL_LO16,
2069	BFD_RELOC_MIPS_SUB,
2070	BFD_RELOC_MIPS_GOT_PAGE,
2071	BFD_RELOC_MIPS_GOT_OFST,
2072	BFD_RELOC_MIPS_GOT_DISP,
2073	BFD_RELOC_MIPS_SHIFT5,
2074	BFD_RELOC_MIPS_SHIFT6,
2075	BFD_RELOC_MIPS_INSERT_A,
2076	BFD_RELOC_MIPS_INSERT_B,
2077	BFD_RELOC_MIPS_DELETE,
2078	BFD_RELOC_MIPS_HIGHEST,
2079	BFD_RELOC_MIPS_HIGHER,
2080	BFD_RELOC_MIPS_SCN_DISP,
2081	BFD_RELOC_MIPS_REL16,
2082	BFD_RELOC_MIPS_RELGOT,
2083	BFD_RELOC_MIPS_JALR,
2084
2085
2086	/* i386/elf relocations */
2087	BFD_RELOC_386_GOT32,
2088	BFD_RELOC_386_PLT32,
2089	BFD_RELOC_386_COPY,
2090	BFD_RELOC_386_GLOB_DAT,
2091	BFD_RELOC_386_JUMP_SLOT,
2092	BFD_RELOC_386_RELATIVE,
2093	BFD_RELOC_386_GOTOFF,
2094	BFD_RELOC_386_GOTPC,
2095
2096	/* x86-64/elf relocations */
2097	BFD_RELOC_X86_64_GOT32,
2098	BFD_RELOC_X86_64_PLT32,
2099	BFD_RELOC_X86_64_COPY,
2100	BFD_RELOC_X86_64_GLOB_DAT,
2101	BFD_RELOC_X86_64_JUMP_SLOT,
2102	BFD_RELOC_X86_64_RELATIVE,
2103	BFD_RELOC_X86_64_GOTPCREL,
2104	BFD_RELOC_X86_64_32S,
2105
2106	/* ns32k relocations */
2107	BFD_RELOC_NS32K_IMM_8,
2108	BFD_RELOC_NS32K_IMM_16,
2109	BFD_RELOC_NS32K_IMM_32,
2110	BFD_RELOC_NS32K_IMM_8_PCREL,
2111	BFD_RELOC_NS32K_IMM_16_PCREL,
2112	BFD_RELOC_NS32K_IMM_32_PCREL,
2113	BFD_RELOC_NS32K_DISP_8,
2114	BFD_RELOC_NS32K_DISP_16,
2115	BFD_RELOC_NS32K_DISP_32,
2116	BFD_RELOC_NS32K_DISP_8_PCREL,
2117	BFD_RELOC_NS32K_DISP_16_PCREL,
2118	BFD_RELOC_NS32K_DISP_32_PCREL,
2119
2120	/* Picojava relocs. Not all of these appear in object files. */
2121	BFD_RELOC_PJ_CODE_HI16,
2122	BFD_RELOC_PJ_CODE_LO16,
2123	BFD_RELOC_PJ_CODE_DIR16,
2124	BFD_RELOC_PJ_CODE_DIR32,
2125	BFD_RELOC_PJ_CODE_REL16,
2126	BFD_RELOC_PJ_CODE_REL32,
2127
2128	/* Power(rs6000) and PowerPC relocations. */
2129	BFD_RELOC_PPC_B26,
2130	BFD_RELOC_PPC_BA26,
2131	BFD_RELOC_PPC_TOC16,
2132	BFD_RELOC_PPC_B16,
2133	BFD_RELOC_PPC_B16_BRTAKEN,
2134	BFD_RELOC_PPC_B16_BRNTAKEN,
2135	BFD_RELOC_PPC_BA16,
2136	BFD_RELOC_PPC_BA16_BRTAKEN,
2137	BFD_RELOC_PPC_BA16_BRNTAKEN,
2138	BFD_RELOC_PPC_COPY,
2139	BFD_RELOC_PPC_GLOB_DAT,
2140	BFD_RELOC_PPC_JMP_SLOT,
2141	BFD_RELOC_PPC_RELATIVE,
2142	BFD_RELOC_PPC_LOCAL24PC,
2143	BFD_RELOC_PPC_EMB_NADDR32,
2144	BFD_RELOC_PPC_EMB_NADDR16,
2145	BFD_RELOC_PPC_EMB_NADDR16_LO,
2146	BFD_RELOC_PPC_EMB_NADDR16_HI,
2147	BFD_RELOC_PPC_EMB_NADDR16_HA,
2148	BFD_RELOC_PPC_EMB_SDAI16,
2149	BFD_RELOC_PPC_EMB_SDA2I16,
2150	BFD_RELOC_PPC_EMB_SDA2REL,
2151	BFD_RELOC_PPC_EMB_SDA21,
2152	BFD_RELOC_PPC_EMB_MRKREF,
2153	BFD_RELOC_PPC_EMB_RELSEC16,
2154	BFD_RELOC_PPC_EMB_RELST_LO,
2155	BFD_RELOC_PPC_EMB_RELST_HI,
2156	BFD_RELOC_PPC_EMB_RELST_HA,
2157	BFD_RELOC_PPC_EMB_BIT_FLD,
2158	BFD_RELOC_PPC_EMB_RELSDA,
2159
2160	/* IBM 370/390 relocations */
2161	BFD_RELOC_I370_D12,
2162
2163	/* The type of reloc used to build a contructor table - at the moment
2164	probably a 32 bit wide absolute relocation, but the target can choose.
2165	It generally does map to one of the other relocation types. */
2166	BFD_RELOC_CTOR,
2167
2168	/* ARM 26 bit pc-relative branch. The lowest two bits must be zero and are
2169	not stored in the instruction. */
2170	BFD_RELOC_ARM_PCREL_BRANCH,
2171
2172	/* ARM 26 bit pc-relative branch. The lowest bit must be zero and is
2173	not stored in the instruction. The 2nd lowest bit comes from a 1 bit
2174	field in the instruction. */
2175	BFD_RELOC_ARM_PCREL_BLX,
2176
2177	/* Thumb 22 bit pc-relative branch. The lowest bit must be zero and is
2178	not stored in the instruction. The 2nd lowest bit comes from a 1 bit
2179	field in the instruction. */
2180	BFD_RELOC_THUMB_PCREL_BLX,
2181
2182	/* These relocs are only used within the ARM assembler. They are not
2183	(at present) written to any object files. */
2184	BFD_RELOC_ARM_IMMEDIATE,
2185	BFD_RELOC_ARM_ADRL_IMMEDIATE,
2186	BFD_RELOC_ARM_OFFSET_IMM,
2187	BFD_RELOC_ARM_SHIFT_IMM,
2188	BFD_RELOC_ARM_SWI,
2189	BFD_RELOC_ARM_MULTI,
2190	BFD_RELOC_ARM_CP_OFF_IMM,
2191	BFD_RELOC_ARM_ADR_IMM,
2192	BFD_RELOC_ARM_LDR_IMM,
2193	BFD_RELOC_ARM_LITERAL,
2194	BFD_RELOC_ARM_IN_POOL,
2195	BFD_RELOC_ARM_OFFSET_IMM8,
2196	BFD_RELOC_ARM_HWLITERAL,
2197	BFD_RELOC_ARM_THUMB_ADD,
2198	BFD_RELOC_ARM_THUMB_IMM,
2199	BFD_RELOC_ARM_THUMB_SHIFT,
2200	BFD_RELOC_ARM_THUMB_OFFSET,
2201	BFD_RELOC_ARM_GOT12,
2202	BFD_RELOC_ARM_GOT32,
2203	BFD_RELOC_ARM_JUMP_SLOT,
2204	BFD_RELOC_ARM_COPY,
2205	BFD_RELOC_ARM_GLOB_DAT,
2206	BFD_RELOC_ARM_PLT32,
2207	BFD_RELOC_ARM_RELATIVE,
2208	BFD_RELOC_ARM_GOTOFF,
2209	BFD_RELOC_ARM_GOTPC,
2210
2211	/* Hitachi SH relocs. Not all of these appear in object files. */
2212	BFD_RELOC_SH_PCDISP8BY2,
2213	BFD_RELOC_SH_PCDISP12BY2,
2214	BFD_RELOC_SH_IMM4,
2215	BFD_RELOC_SH_IMM4BY2,
2216	BFD_RELOC_SH_IMM4BY4,
2217	BFD_RELOC_SH_IMM8,
2218	BFD_RELOC_SH_IMM8BY2,
2219	BFD_RELOC_SH_IMM8BY4,
2220	BFD_RELOC_SH_PCRELIMM8BY2,
2221	BFD_RELOC_SH_PCRELIMM8BY4,
2222	BFD_RELOC_SH_SWITCH16,
2223	BFD_RELOC_SH_SWITCH32,
2224	BFD_RELOC_SH_USES,
2225	BFD_RELOC_SH_COUNT,
2226	BFD_RELOC_SH_ALIGN,
2227	BFD_RELOC_SH_CODE,
2228	BFD_RELOC_SH_DATA,
2229	BFD_RELOC_SH_LABEL,
2230	BFD_RELOC_SH_LOOP_START,
2231	BFD_RELOC_SH_LOOP_END,
2232	BFD_RELOC_SH_COPY,
2233	BFD_RELOC_SH_GLOB_DAT,
2234	BFD_RELOC_SH_JMP_SLOT,
2235	BFD_RELOC_SH_RELATIVE,
2236	BFD_RELOC_SH_GOTPC,
2237
2238	/* Thumb 23-, 12- and 9-bit pc-relative branches. The lowest bit must
2239	be zero and is not stored in the instruction. */
2240	BFD_RELOC_THUMB_PCREL_BRANCH9,
2241	BFD_RELOC_THUMB_PCREL_BRANCH12,
2242	BFD_RELOC_THUMB_PCREL_BRANCH23,
2243
2244	/* ARC Cores relocs.
2245	ARC 22 bit pc-relative branch. The lowest two bits must be zero and are
2246	not stored in the instruction. The high 20 bits are installed in bits 26
2247	through 7 of the instruction. */
2248	BFD_RELOC_ARC_B22_PCREL,
2249
2250	/* ARC 26 bit absolute branch. The lowest two bits must be zero and are not
2251	stored in the instruction. The high 24 bits are installed in bits 23
2252	through 0. */
2253	BFD_RELOC_ARC_B26,
2254
2255	/* Mitsubishi D10V relocs.
2256	This is a 10-bit reloc with the right 2 bits
2257	assumed to be 0. */
2258	BFD_RELOC_D10V_10_PCREL_R,
2259
2260	/* Mitsubishi D10V relocs.
2261	This is a 10-bit reloc with the right 2 bits
2262	assumed to be 0. This is the same as the previous reloc
2263	except it is in the left container, i.e.,
2264	shifted left 15 bits. */
2265	BFD_RELOC_D10V_10_PCREL_L,
2266
2267	/* This is an 18-bit reloc with the right 2 bits
2268	assumed to be 0. */
2269	BFD_RELOC_D10V_18,
2270
2271	/* This is an 18-bit reloc with the right 2 bits
2272	assumed to be 0. */
2273	BFD_RELOC_D10V_18_PCREL,
2274
2275	/* Mitsubishi D30V relocs.
2276	This is a 6-bit absolute reloc. */
2277	BFD_RELOC_D30V_6,
2278
2279	/* This is a 6-bit pc-relative reloc with
2280	the right 3 bits assumed to be 0. */
2281	BFD_RELOC_D30V_9_PCREL,
2282
2283	/* This is a 6-bit pc-relative reloc with
2284	the right 3 bits assumed to be 0. Same
2285	as the previous reloc but on the right side
2286	of the container. */
2287	BFD_RELOC_D30V_9_PCREL_R,
2288
2289	/* This is a 12-bit absolute reloc with the
2290	right 3 bitsassumed to be 0. */
2291	BFD_RELOC_D30V_15,
2292
2293	/* This is a 12-bit pc-relative reloc with
2294	the right 3 bits assumed to be 0. */
2295	BFD_RELOC_D30V_15_PCREL,
2296
2297	/* This is a 12-bit pc-relative reloc with
2298	the right 3 bits assumed to be 0. Same
2299	as the previous reloc but on the right side
2300	of the container. */
2301	BFD_RELOC_D30V_15_PCREL_R,
2302
2303	/* This is an 18-bit absolute reloc with
2304	the right 3 bits assumed to be 0. */
2305	BFD_RELOC_D30V_21,
2306
2307	/* This is an 18-bit pc-relative reloc with
2308	the right 3 bits assumed to be 0. */
2309	BFD_RELOC_D30V_21_PCREL,
2310
2311	/* This is an 18-bit pc-relative reloc with
2312	the right 3 bits assumed to be 0. Same
2313	as the previous reloc but on the right side
2314	of the container. */
2315	BFD_RELOC_D30V_21_PCREL_R,
2316
2317	/* This is a 32-bit absolute reloc. */
2318	BFD_RELOC_D30V_32,
2319
2320	/* This is a 32-bit pc-relative reloc. */
2321	BFD_RELOC_D30V_32_PCREL,
2322
2323	/* Mitsubishi M32R relocs.
2324	This is a 24 bit absolute address. */
2325	BFD_RELOC_M32R_24,
2326
2327	/* This is a 10-bit pc-relative reloc with the right 2 bits assumed to be 0. */
2328	BFD_RELOC_M32R_10_PCREL,
2329
2330	/* This is an 18-bit reloc with the right 2 bits assumed to be 0. */
2331	BFD_RELOC_M32R_18_PCREL,
2332
2333	/* This is a 26-bit reloc with the right 2 bits assumed to be 0. */
2334	BFD_RELOC_M32R_26_PCREL,
2335
2336	/* This is a 16-bit reloc containing the high 16 bits of an address
2337	used when the lower 16 bits are treated as unsigned. */
2338	BFD_RELOC_M32R_HI16_ULO,
2339
2340	/* This is a 16-bit reloc containing the high 16 bits of an address
2341	used when the lower 16 bits are treated as signed. */
2342	BFD_RELOC_M32R_HI16_SLO,
2343
2344	/* This is a 16-bit reloc containing the lower 16 bits of an address. */
2345	BFD_RELOC_M32R_LO16,
2346
2347	/* This is a 16-bit reloc containing the small data area offset for use in
2348	add3, load, and store instructions. */
2349	BFD_RELOC_M32R_SDA16,
2350
2351	/* This is a 9-bit reloc */
2352	BFD_RELOC_V850_9_PCREL,
2353
2354	/* This is a 22-bit reloc */
2355	BFD_RELOC_V850_22_PCREL,
2356
2357	/* This is a 16 bit offset from the short data area pointer. */
2358	BFD_RELOC_V850_SDA_16_16_OFFSET,
2359
2360	/* This is a 16 bit offset (of which only 15 bits are used) from the
2361	short data area pointer. */
2362	BFD_RELOC_V850_SDA_15_16_OFFSET,
2363
2364	/* This is a 16 bit offset from the zero data area pointer. */
2365	BFD_RELOC_V850_ZDA_16_16_OFFSET,
2366
2367	/* This is a 16 bit offset (of which only 15 bits are used) from the
2368	zero data area pointer. */
2369	BFD_RELOC_V850_ZDA_15_16_OFFSET,
2370
2371	/* This is an 8 bit offset (of which only 6 bits are used) from the
2372	tiny data area pointer. */
2373	BFD_RELOC_V850_TDA_6_8_OFFSET,
2374
2375	/* This is an 8bit offset (of which only 7 bits are used) from the tiny
2376	data area pointer. */
2377	BFD_RELOC_V850_TDA_7_8_OFFSET,
2378
2379	/* This is a 7 bit offset from the tiny data area pointer. */
2380	BFD_RELOC_V850_TDA_7_7_OFFSET,
2381
2382	/* This is a 16 bit offset from the tiny data area pointer. */
2383	BFD_RELOC_V850_TDA_16_16_OFFSET,
2384
2385	/* This is a 5 bit offset (of which only 4 bits are used) from the tiny
2386	data area pointer. */
2387	BFD_RELOC_V850_TDA_4_5_OFFSET,
2388
2389	/* This is a 4 bit offset from the tiny data area pointer. */
2390	BFD_RELOC_V850_TDA_4_4_OFFSET,
2391
2392	/* This is a 16 bit offset from the short data area pointer, with the
2393	bits placed non-contigously in the instruction. */
2394	BFD_RELOC_V850_SDA_16_16_SPLIT_OFFSET,
2395
2396	/* This is a 16 bit offset from the zero data area pointer, with the
2397	bits placed non-contigously in the instruction. */
2398	BFD_RELOC_V850_ZDA_16_16_SPLIT_OFFSET,
2399
2400	/* This is a 6 bit offset from the call table base pointer. */
2401	BFD_RELOC_V850_CALLT_6_7_OFFSET,
2402
2403	/* This is a 16 bit offset from the call table base pointer. */
2404	BFD_RELOC_V850_CALLT_16_16_OFFSET,
2405
2406
2407	/* This is a 32bit pcrel reloc for the mn10300, offset by two bytes in the
2408	instruction. */
2409	BFD_RELOC_MN10300_32_PCREL,
2410
2411	/* This is a 16bit pcrel reloc for the mn10300, offset by two bytes in the
2412	instruction. */
2413	BFD_RELOC_MN10300_16_PCREL,
2414
2415	/* This is a 8bit DP reloc for the tms320c30, where the most
2416	significant 8 bits of a 24 bit word are placed into the least
2417	significant 8 bits of the opcode. */
2418	BFD_RELOC_TIC30_LDP,
2419
2420	/* This is a 7bit reloc for the tms320c54x, where the least
2421	significant 7 bits of a 16 bit word are placed into the least
2422	significant 7 bits of the opcode. */
2423	BFD_RELOC_TIC54X_PARTLS7,
2424
2425	/* This is a 9bit DP reloc for the tms320c54x, where the most
2426	significant 9 bits of a 16 bit word are placed into the least
2427	significant 9 bits of the opcode. */
2428	BFD_RELOC_TIC54X_PARTMS9,
2429
2430	/* This is an extended address 23-bit reloc for the tms320c54x. */
2431	BFD_RELOC_TIC54X_23,
2432
2433	/* This is a 16-bit reloc for the tms320c54x, where the least
2434	significant 16 bits of a 23-bit extended address are placed into
2435	the opcode. */
2436	BFD_RELOC_TIC54X_16_OF_23,
2437
2438	/* This is a reloc for the tms320c54x, where the most
2439	significant 7 bits of a 23-bit extended address are placed into
2440	the opcode. */
2441	BFD_RELOC_TIC54X_MS7_OF_23,
2442
2443	/* This is a 48 bit reloc for the FR30 that stores 32 bits. */
2444	BFD_RELOC_FR30_48,
2445
2446	/* This is a 32 bit reloc for the FR30 that stores 20 bits split up into
2447	two sections. */
2448	BFD_RELOC_FR30_20,
2449
2450	/* This is a 16 bit reloc for the FR30 that stores a 6 bit word offset in
2451	4 bits. */
2452	BFD_RELOC_FR30_6_IN_4,
2453
2454	/* This is a 16 bit reloc for the FR30 that stores an 8 bit byte offset
2455	into 8 bits. */
2456	BFD_RELOC_FR30_8_IN_8,
2457
2458	/* This is a 16 bit reloc for the FR30 that stores a 9 bit short offset
2459	into 8 bits. */
2460	BFD_RELOC_FR30_9_IN_8,
2461
2462	/* This is a 16 bit reloc for the FR30 that stores a 10 bit word offset
2463	into 8 bits. */
2464	BFD_RELOC_FR30_10_IN_8,
2465
2466	/* This is a 16 bit reloc for the FR30 that stores a 9 bit pc relative
2467	short offset into 8 bits. */
2468	BFD_RELOC_FR30_9_PCREL,
2469
2470	/* This is a 16 bit reloc for the FR30 that stores a 12 bit pc relative
2471	short offset into 11 bits. */
2472	BFD_RELOC_FR30_12_PCREL,
2473
2474	/* Motorola Mcore relocations. */
2475	BFD_RELOC_MCORE_PCREL_IMM8BY4,
2476	BFD_RELOC_MCORE_PCREL_IMM11BY2,
2477	BFD_RELOC_MCORE_PCREL_IMM4BY2,
2478	BFD_RELOC_MCORE_PCREL_32,
2479	BFD_RELOC_MCORE_PCREL_JSR_IMM11BY2,
2480	BFD_RELOC_MCORE_RVA,
2481
2482	/* This is a 16 bit reloc for the AVR that stores 8 bit pc relative
2483	short offset into 7 bits. */
2484	BFD_RELOC_AVR_7_PCREL,
2485
2486	/* This is a 16 bit reloc for the AVR that stores 13 bit pc relative
2487	short offset into 12 bits. */
2488	BFD_RELOC_AVR_13_PCREL,
2489
2490	/* This is a 16 bit reloc for the AVR that stores 17 bit value (usually
2491	program memory address) into 16 bits. */
2492	BFD_RELOC_AVR_16_PM,
2493
2494	/* This is a 16 bit reloc for the AVR that stores 8 bit value (usually
2495	data memory address) into 8 bit immediate value of LDI insn. */
2496	BFD_RELOC_AVR_LO8_LDI,
2497
2498	/* This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit
2499	of data memory address) into 8 bit immediate value of LDI insn. */
2500	BFD_RELOC_AVR_HI8_LDI,
2501
2502	/* This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit
2503	of program memory address) into 8 bit immediate value of LDI insn. */
2504	BFD_RELOC_AVR_HH8_LDI,
2505
2506	/* This is a 16 bit reloc for the AVR that stores negated 8 bit value
2507	(usually data memory address) into 8 bit immediate value of SUBI insn. */
2508	BFD_RELOC_AVR_LO8_LDI_NEG,
2509
2510	/* This is a 16 bit reloc for the AVR that stores negated 8 bit value
2511	(high 8 bit of data memory address) into 8 bit immediate value of
2512	SUBI insn. */
2513	BFD_RELOC_AVR_HI8_LDI_NEG,
2514
2515	/* This is a 16 bit reloc for the AVR that stores negated 8 bit value
2516	(most high 8 bit of program memory address) into 8 bit immediate value
2517	of LDI or SUBI insn. */
2518	BFD_RELOC_AVR_HH8_LDI_NEG,
2519
2520	/* This is a 16 bit reloc for the AVR that stores 8 bit value (usually
2521	command address) into 8 bit immediate value of LDI insn. */
2522	BFD_RELOC_AVR_LO8_LDI_PM,
2523
2524	/* This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit
2525	of command address) into 8 bit immediate value of LDI insn. */
2526	BFD_RELOC_AVR_HI8_LDI_PM,
2527
2528	/* This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit
2529	of command address) into 8 bit immediate value of LDI insn. */
2530	BFD_RELOC_AVR_HH8_LDI_PM,
2531
2532	/* This is a 16 bit reloc for the AVR that stores negated 8 bit value
2533	(usually command address) into 8 bit immediate value of SUBI insn. */
2534	BFD_RELOC_AVR_LO8_LDI_PM_NEG,
2535
2536	/* This is a 16 bit reloc for the AVR that stores negated 8 bit value
2537	(high 8 bit of 16 bit command address) into 8 bit immediate value
2538	of SUBI insn. */
2539	BFD_RELOC_AVR_HI8_LDI_PM_NEG,
2540
2541	/* This is a 16 bit reloc for the AVR that stores negated 8 bit value
2542	(high 6 bit of 22 bit command address) into 8 bit immediate
2543	value of SUBI insn. */
2544	BFD_RELOC_AVR_HH8_LDI_PM_NEG,
2545
2546	/* This is a 32 bit reloc for the AVR that stores 23 bit value
2547	into 22 bits. */
2548	BFD_RELOC_AVR_CALL,
2549
2550	/* These two relocations are used by the linker to determine which of
2551	the entries in a C++ virtual function table are actually used. When
2552	the --gc-sections option is given, the linker will zero out the entries
2553	that are not used, so that the code for those functions need not be
2554	included in the output.
2555
2556	VTABLE_INHERIT is a zero-space relocation used to describe to the
2557	linker the inheritence tree of a C++ virtual function table. The
2558	relocation's symbol should be the parent class' vtable, and the
2559	relocation should be located at the child vtable.
2560
2561	VTABLE_ENTRY is a zero-space relocation that describes the use of a
2562	virtual function table entry. The reloc's symbol should refer to the
2563	table of the class mentioned in the code. Off of that base, an offset
2564	describes the entry that is being used. For Rela hosts, this offset
2565	is stored in the reloc's addend. For Rel hosts, we are forced to put
2566	this offset in the reloc's section offset. */
2567	BFD_RELOC_VTABLE_INHERIT,
2568	BFD_RELOC_VTABLE_ENTRY,
2569
2570	/* Intel IA64 Relocations. */
2571	BFD_RELOC_IA64_IMM14,
2572	BFD_RELOC_IA64_IMM22,
2573	BFD_RELOC_IA64_IMM64,
2574	BFD_RELOC_IA64_DIR32MSB,
2575	BFD_RELOC_IA64_DIR32LSB,
2576	BFD_RELOC_IA64_DIR64MSB,
2577	BFD_RELOC_IA64_DIR64LSB,
2578	BFD_RELOC_IA64_GPREL22,
2579	BFD_RELOC_IA64_GPREL64I,
2580	BFD_RELOC_IA64_GPREL32MSB,
2581	BFD_RELOC_IA64_GPREL32LSB,
2582	BFD_RELOC_IA64_GPREL64MSB,
2583	BFD_RELOC_IA64_GPREL64LSB,
2584	BFD_RELOC_IA64_LTOFF22,
2585	BFD_RELOC_IA64_LTOFF64I,
2586	BFD_RELOC_IA64_PLTOFF22,
2587	BFD_RELOC_IA64_PLTOFF64I,
2588	BFD_RELOC_IA64_PLTOFF64MSB,
2589	BFD_RELOC_IA64_PLTOFF64LSB,
2590	BFD_RELOC_IA64_FPTR64I,
2591	BFD_RELOC_IA64_FPTR32MSB,
2592	BFD_RELOC_IA64_FPTR32LSB,
2593	BFD_RELOC_IA64_FPTR64MSB,
2594	BFD_RELOC_IA64_FPTR64LSB,
2595	BFD_RELOC_IA64_PCREL21B,
2596	BFD_RELOC_IA64_PCREL21BI,
2597	BFD_RELOC_IA64_PCREL21M,
2598	BFD_RELOC_IA64_PCREL21F,
2599	BFD_RELOC_IA64_PCREL22,
2600	BFD_RELOC_IA64_PCREL60B,
2601	BFD_RELOC_IA64_PCREL64I,
2602	BFD_RELOC_IA64_PCREL32MSB,
2603	BFD_RELOC_IA64_PCREL32LSB,
2604	BFD_RELOC_IA64_PCREL64MSB,
2605	BFD_RELOC_IA64_PCREL64LSB,
2606	BFD_RELOC_IA64_LTOFF_FPTR22,
2607	BFD_RELOC_IA64_LTOFF_FPTR64I,
2608	BFD_RELOC_IA64_LTOFF_FPTR64MSB,
2609	BFD_RELOC_IA64_LTOFF_FPTR64LSB,
2610	BFD_RELOC_IA64_SEGREL32MSB,
2611	BFD_RELOC_IA64_SEGREL32LSB,
2612	BFD_RELOC_IA64_SEGREL64MSB,
2613	BFD_RELOC_IA64_SEGREL64LSB,
2614	BFD_RELOC_IA64_SECREL32MSB,
2615	BFD_RELOC_IA64_SECREL32LSB,
2616	BFD_RELOC_IA64_SECREL64MSB,
2617	BFD_RELOC_IA64_SECREL64LSB,
2618	BFD_RELOC_IA64_REL32MSB,
2619	BFD_RELOC_IA64_REL32LSB,
2620	BFD_RELOC_IA64_REL64MSB,
2621	BFD_RELOC_IA64_REL64LSB,
2622	BFD_RELOC_IA64_LTV32MSB,
2623	BFD_RELOC_IA64_LTV32LSB,
2624	BFD_RELOC_IA64_LTV64MSB,
2625	BFD_RELOC_IA64_LTV64LSB,
2626	BFD_RELOC_IA64_IPLTMSB,
2627	BFD_RELOC_IA64_IPLTLSB,
2628	BFD_RELOC_IA64_COPY,
2629	BFD_RELOC_IA64_TPREL22,
2630	BFD_RELOC_IA64_TPREL64MSB,
2631	BFD_RELOC_IA64_TPREL64LSB,
2632	BFD_RELOC_IA64_LTOFF_TP22,
2633	BFD_RELOC_IA64_LTOFF22X,
2634	BFD_RELOC_IA64_LDXMOV,
2635
2636	/* Motorola 68HC11 reloc.
2637	This is the 8 bits high part of an absolute address. */
2638	BFD_RELOC_M68HC11_HI8,
2639
2640	/* Motorola 68HC11 reloc.
2641	This is the 8 bits low part of an absolute address. */
2642	BFD_RELOC_M68HC11_LO8,
2643
2644	/* Motorola 68HC11 reloc.
2645	This is the 3 bits of a value. */
2646	BFD_RELOC_M68HC11_3B,
2647
2648	/* These relocs are only used within the CRIS assembler. They are not
2649	(at present) written to any object files. */
2650	BFD_RELOC_CRIS_BDISP8,
2651	BFD_RELOC_CRIS_UNSIGNED_5,
2652	BFD_RELOC_CRIS_SIGNED_6,
2653	BFD_RELOC_CRIS_UNSIGNED_6,
2654	BFD_RELOC_CRIS_UNSIGNED_4,
2655
2656	/* Intel i860 Relocations. */
2657	BFD_RELOC_860_COPY,
2658	BFD_RELOC_860_GLOB_DAT,
2659	BFD_RELOC_860_JUMP_SLOT,
2660	BFD_RELOC_860_RELATIVE,
2661	BFD_RELOC_860_PC26,
2662	BFD_RELOC_860_PLT26,
2663	BFD_RELOC_860_PC16,
2664	BFD_RELOC_860_LOW0,
2665	BFD_RELOC_860_SPLIT0,
2666	BFD_RELOC_860_LOW1,
2667	BFD_RELOC_860_SPLIT1,
2668	BFD_RELOC_860_LOW2,
2669	BFD_RELOC_860_SPLIT2,
2670	BFD_RELOC_860_LOW3,
2671	BFD_RELOC_860_LOGOT0,
2672	BFD_RELOC_860_SPGOT0,
2673	BFD_RELOC_860_LOGOT1,
2674	BFD_RELOC_860_SPGOT1,
2675	BFD_RELOC_860_LOGOTOFF0,
2676	BFD_RELOC_860_SPGOTOFF0,
2677	BFD_RELOC_860_LOGOTOFF1,
2678	BFD_RELOC_860_SPGOTOFF1,
2679	BFD_RELOC_860_LOGOTOFF2,
2680	BFD_RELOC_860_LOGOTOFF3,
2681	BFD_RELOC_860_LOPC,
2682	BFD_RELOC_860_HIGHADJ,
2683	BFD_RELOC_860_HAGOT,
2684	BFD_RELOC_860_HAGOTOFF,
2685	BFD_RELOC_860_HAPC,
2686	BFD_RELOC_860_HIGH,
2687	BFD_RELOC_860_HIGOT,
2688	BFD_RELOC_860_HIGOTOFF,
2689	BFD_RELOC_UNUSED };
2690	typedef enum bfd_reloc_code_real bfd_reloc_code_real_type;
2691	reloc_howto_type *
2692	bfd_reloc_type_lookup PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
2693
2694	const char *
2695	bfd_get_reloc_code_name PARAMS ((bfd_reloc_code_real_type code));
2696
2697
2698	typedef struct symbol_cache_entry
2699	{
2700	/* A pointer to the BFD which owns the symbol. This information
2701	is necessary so that a back end can work out what additional
2702	information (invisible to the application writer) is carried
2703	with the symbol.
2704
2705	This field is almost redundant, since you can use section->owner
2706	instead, except that some symbols point to the global sections
2707	bfd_{abs,com,und}_section. This could be fixed by making
2708	these globals be per-bfd (or per-target-flavor). FIXME. */
2709
2710	struct _bfd the_bfd; / Use bfd_asymbol_bfd(sym) to access this field. */
2711
2712	/* The text of the symbol. The name is left alone, and not copied; the
2713	application may not alter it. */
2714	CONST char *name;
2715
2716	/* The value of the symbol. This really should be a union of a
2717	numeric value with a pointer, since some flags indicate that
2718	a pointer to another symbol is stored here. */
2719	symvalue value;
2720
2721	/* Attributes of a symbol: */
2722
2723	#define BSF_NO_FLAGS 0x00
2724
2725	/* The symbol has local scope; <<static>> in <<C>>. The value
2726	is the offset into the section of the data. */
2727	#define BSF_LOCAL 0x01
2728
2729	/* The symbol has global scope; initialized data in <<C>>. The
2730	value is the offset into the section of the data. */
2731	#define BSF_GLOBAL 0x02
2732
2733	/* The symbol has global scope and is exported. The value is
2734	the offset into the section of the data. */
2735	#define BSF_EXPORT BSF_GLOBAL /* no real difference */
2736
2737	/* A normal C symbol would be one of:
2738	<<BSF_LOCAL>>, <<BSF_FORT_COMM>>, <<BSF_UNDEFINED>> or
2739	<<BSF_GLOBAL>> */
2740
2741	/* The symbol is a debugging record. The value has an arbitary
2742	meaning, unless BSF_DEBUGGING_RELOC is also set. */
2743	#define BSF_DEBUGGING 0x08
2744
2745	/* The symbol denotes a function entry point. Used in ELF,
2746	perhaps others someday. */
2747	#define BSF_FUNCTION 0x10
2748
2749	/* Used by the linker. */
2750	#define BSF_KEEP 0x20
2751	#define BSF_KEEP_G 0x40
2752
2753	/* A weak global symbol, overridable without warnings by
2754	a regular global symbol of the same name. */
2755	#define BSF_WEAK 0x80
2756
2757	/* This symbol was created to point to a section, e.g. ELF's
2758	STT_SECTION symbols. */
2759	#define BSF_SECTION_SYM 0x100
2760
2761	/* The symbol used to be a common symbol, but now it is
2762	allocated. */
2763	#define BSF_OLD_COMMON 0x200
2764
2765	/* The default value for common data. */
2766	#define BFD_FORT_COMM_DEFAULT_VALUE 0
2767
2768	/* In some files the type of a symbol sometimes alters its
2769	location in an output file - ie in coff a <<ISFCN>> symbol
2770	which is also <<C_EXT>> symbol appears where it was
2771	declared and not at the end of a section. This bit is set
2772	by the target BFD part to convey this information. */
2773
2774	#define BSF_NOT_AT_END 0x400
2775
2776	/* Signal that the symbol is the label of constructor section. */
2777	#define BSF_CONSTRUCTOR 0x800
2778
2779	/* Signal that the symbol is a warning symbol. The name is a
2780	warning. The name of the next symbol is the one to warn about;
2781	if a reference is made to a symbol with the same name as the next
2782	symbol, a warning is issued by the linker. */
2783	#define BSF_WARNING 0x1000
2784
2785	/* Signal that the symbol is indirect. This symbol is an indirect
2786	pointer to the symbol with the same name as the next symbol. */
2787	#define BSF_INDIRECT 0x2000
2788
2789	/* BSF_FILE marks symbols that contain a file name. This is used
2790	for ELF STT_FILE symbols. */
2791	#define BSF_FILE 0x4000
2792
2793	/* Symbol is from dynamic linking information. */
2794	#define BSF_DYNAMIC 0x8000
2795
2796	/* The symbol denotes a data object. Used in ELF, and perhaps
2797	others someday. */
2798	#define BSF_OBJECT 0x10000
2799
2800	/* This symbol is a debugging symbol. The value is the offset
2801	into the section of the data. BSF_DEBUGGING should be set
2802	as well. */
2803	#define BSF_DEBUGGING_RELOC 0x20000
2804
2805	/* Symbol is an emx import reference. */
2806	#define BSF_EMX_IMPORT1 0x20000000
2807
2808	/* Symbol is an emx import definition. */
2809	#define BSF_EMX_IMPORT2 0x40000000
2810
2811	flagword flags;
2812
2813	/* A pointer to the section to which this symbol is
2814	relative. This will always be non NULL, there are special
2815	sections for undefined and absolute symbols. */
2816	struct sec *section;
2817
2818	/* Back end special data. */
2819	union
2820	{
2821	PTR p;
2822	bfd_vma i;
2823	} udata;
2824
2825	} asymbol;
2826	#define bfd_get_symtab_upper_bound(abfd) \
2827	BFD_SEND (abfd, _bfd_get_symtab_upper_bound, (abfd))
2828	boolean
2829	bfd_is_local_label PARAMS ((bfd abfd, asymbol sym));
2830
2831	boolean
2832	bfd_is_local_label_name PARAMS ((bfd abfd, const char name));
2833
2834	#define bfd_is_local_label_name(abfd, name) \
2835	BFD_SEND (abfd, _bfd_is_local_label_name, (abfd, name))
2836	#define bfd_canonicalize_symtab(abfd, location) \
2837	BFD_SEND (abfd, _bfd_canonicalize_symtab,\
2838	(abfd, location))
2839	boolean
2840	bfd_set_symtab PARAMS ((bfd abfd, asymbol *location, unsigned int count));
2841
2842	void
2843	bfd_print_symbol_vandf PARAMS ((PTR file, asymbol *symbol));
2844
2845	#define bfd_make_empty_symbol(abfd) \
2846	BFD_SEND (abfd, _bfd_make_empty_symbol, (abfd))
2847	#define bfd_make_debug_symbol(abfd,ptr,size) \
2848	BFD_SEND (abfd, _bfd_make_debug_symbol, (abfd, ptr, size))
2849	int
2850	bfd_decode_symclass PARAMS ((asymbol *symbol));
2851
2852	boolean
2853	bfd_is_undefined_symclass PARAMS ((int symclass));
2854
2855	void
2856	bfd_symbol_info PARAMS ((asymbol symbol, symbol_info ret));
2857
2858	boolean
2859	bfd_copy_private_symbol_data PARAMS ((bfd ibfd, asymbol isym, bfd obfd, asymbol osym));
2860
2861	#define bfd_copy_private_symbol_data(ibfd, isymbol, obfd, osymbol) \
2862	BFD_SEND (obfd, _bfd_copy_private_symbol_data, \
2863	(ibfd, isymbol, obfd, osymbol))
2864	struct _bfd
2865	{
2866	/* The filename the application opened the BFD with. */
2867	CONST char *filename;
2868
2869	/* A pointer to the target jump table. */
2870	const struct bfd_target *xvec;
2871
2872	/* To avoid dragging too many header files into every file that
2873	includes `<<bfd.h>>', IOSTREAM has been declared as a "char
2874	*", and MTIME as a "long". Their correct types, to which they
2875	are cast when used, are "FILE *" and "time_t". The iostream
2876	is the result of an fopen on the filename. However, if the
2877	BFD_IN_MEMORY flag is set, then iostream is actually a pointer
2878	to a bfd_in_memory struct. */
2879	PTR iostream;
2880
2881	/* Is the file descriptor being cached? That is, can it be closed as
2882	needed, and re-opened when accessed later? */
2883
2884	boolean cacheable;
2885
2886	/* Marks whether there was a default target specified when the
2887	BFD was opened. This is used to select which matching algorithm
2888	to use to choose the back end. */
2889
2890	boolean target_defaulted;
2891
2892	/* The caching routines use these to maintain a
2893	least-recently-used list of BFDs */
2894
2895	struct _bfd lru_prev, lru_next;
2896
2897	/* When a file is closed by the caching routines, BFD retains
2898	state information on the file here: */
2899
2900	file_ptr where;
2901
2902	/* and here: (``once'' means at least once) */
2903
2904	boolean opened_once;
2905
2906	/* Set if we have a locally maintained mtime value, rather than
2907	getting it from the file each time: */
2908
2909	boolean mtime_set;
2910
2911	/* File modified time, if mtime_set is true: */
2912
2913	long mtime;
2914
2915	/* Reserved for an unimplemented file locking extension.*/
2916
2917	int ifd;
2918
2919	/* The format which belongs to the BFD. (object, core, etc.) */
2920
2921	bfd_format format;
2922
2923	/* The direction the BFD was opened with*/
2924
2925	enum bfd_direction {no_direction = 0,
2926	read_direction = 1,
2927	write_direction = 2,
2928	both_direction = 3} direction;
2929
2930	/* Format_specific flags*/
2931
2932	flagword flags;
2933
2934	/* Currently my_archive is tested before adding origin to
2935	anything. I believe that this can become always an add of
2936	origin, with origin set to 0 for non archive files. */
2937
2938	file_ptr origin;
2939
2940	/* Remember when output has begun, to stop strange things
2941	from happening. */
2942	boolean output_has_begun;
2943
2944	/* Pointer to linked list of sections*/
2945	struct sec *sections;
2946
2947	/* The number of sections */
2948	unsigned int section_count;
2949
2950	/* Stuff only useful for object files:
2951	The start address. */
2952	bfd_vma start_address;
2953
2954	/* Used for input and output*/
2955	unsigned int symcount;
2956
2957	/* Symbol table for output BFD (with symcount entries) */
2958	struct symbol_cache_entry **outsymbols;
2959
2960	/* Pointer to structure which contains architecture information*/
2961	const struct bfd_arch_info *arch_info;
2962
2963	/* Stuff only useful for archives:*/
2964	PTR arelt_data;
2965	struct _bfd my_archive; / The containing archive BFD. */
2966	struct _bfd next; / The next BFD in the archive. */
2967	struct _bfd archive_head; / The first BFD in the archive. */
2968	boolean has_armap;
2969
2970	/* A chain of BFD structures involved in a link. */
2971	struct _bfd *link_next;
2972
2973	/* A field used by _bfd_generic_link_add_archive_symbols. This will
2974	be used only for archive elements. */
2975	int archive_pass;
2976
2977	/* Used by the back end to hold private data. */
2978
2979	union
2980	{
2981	struct aout_data_struct *aout_data;
2982	struct artdata *aout_ar_data;
2983	struct _oasys_data *oasys_obj_data;
2984	struct _oasys_ar_data *oasys_ar_data;
2985	struct coff_tdata *coff_obj_data;
2986	struct pe_tdata *pe_obj_data;
2987	struct xcoff_tdata *xcoff_obj_data;
2988	struct ecoff_tdata *ecoff_obj_data;
2989	struct ieee_data_struct *ieee_data;
2990	struct ieee_ar_data_struct *ieee_ar_data;
2991	struct srec_data_struct *srec_data;
2992	struct ihex_data_struct *ihex_data;
2993	struct tekhex_data_struct *tekhex_data;
2994	struct elf_obj_tdata *elf_obj_data;
2995	struct nlm_obj_tdata *nlm_obj_data;
2996	struct bout_data_struct *bout_data;
2997	struct sun_core_struct *sun_core_data;
2998	struct sco5_core_struct *sco5_core_data;
2999	struct trad_core_struct *trad_core_data;
3000	struct som_data_struct *som_data;
3001	struct hpux_core_struct *hpux_core_data;
3002	struct hppabsd_core_struct *hppabsd_core_data;
3003	struct sgi_core_struct *sgi_core_data;
3004	struct lynx_core_struct *lynx_core_data;
3005	struct osf_core_struct *osf_core_data;
3006	struct cisco_core_struct *cisco_core_data;
3007	struct versados_data_struct *versados_data;
3008	struct netbsd_core_struct *netbsd_core_data;
3009	PTR any;
3010	} tdata;
3011
3012	/* Used by the application to hold private data*/
3013	PTR usrdata;
3014
3015	/* Where all the allocated stuff under this BFD goes. This is a
3016	struct objalloc *, but we use PTR to avoid requiring the inclusion of
3017	objalloc.h. */
3018	PTR memory;
3019	};
3020
3021	typedef enum bfd_error
3022	{
3023	bfd_error_no_error = 0,
3024	bfd_error_system_call,
3025	bfd_error_invalid_target,
3026	bfd_error_wrong_format,
3027	bfd_error_invalid_operation,
3028	bfd_error_no_memory,
3029	bfd_error_no_symbols,
3030	bfd_error_no_armap,
3031	bfd_error_no_more_archived_files,
3032	bfd_error_malformed_archive,
3033	bfd_error_file_not_recognized,
3034	bfd_error_file_ambiguously_recognized,
3035	bfd_error_no_contents,
3036	bfd_error_nonrepresentable_section,
3037	bfd_error_no_debug_section,
3038	bfd_error_bad_value,
3039	bfd_error_file_truncated,
3040	bfd_error_file_too_big,
3041	bfd_error_invalid_error_code
3042	} bfd_error_type;
3043
3044	bfd_error_type
3045	bfd_get_error PARAMS ((void));
3046
3047	void
3048	bfd_set_error PARAMS ((bfd_error_type error_tag));
3049
3050	CONST char *
3051	bfd_errmsg PARAMS ((bfd_error_type error_tag));
3052
3053	void
3054	bfd_perror PARAMS ((CONST char *message));
3055
3056	typedef void (bfd_error_handler_type) PARAMS ((const char , ...));
3057
3058	bfd_error_handler_type
3059	bfd_set_error_handler PARAMS ((bfd_error_handler_type));
3060
3061	void
3062	bfd_set_error_program_name PARAMS ((const char *));
3063
3064	bfd_error_handler_type
3065	bfd_get_error_handler PARAMS ((void));
3066
3067	long
3068	bfd_get_reloc_upper_bound PARAMS ((bfd abfd, asection sect));
3069
3070	long
3071	bfd_canonicalize_reloc PARAMS ((bfd *abfd,
3072	asection *sec,
3073	arelent **loc,
3074	asymbol **syms));
3075
3076	void
3077	bfd_set_reloc PARAMS ((bfd abfd, asection sec, arelent **rel, unsigned int count)
3078
3079	);
3080
3081	boolean
3082	bfd_set_file_flags PARAMS ((bfd *abfd, flagword flags));
3083
3084	int
3085	bfd_get_arch_size PARAMS ((bfd *abfd));
3086
3087	int
3088	bfd_get_sign_extend_vma PARAMS ((bfd *abfd));
3089
3090	boolean
3091	bfd_set_start_address PARAMS ((bfd *abfd, bfd_vma vma));
3092
3093	long
3094	bfd_get_mtime PARAMS ((bfd *abfd));
3095
3096	long
3097	bfd_get_size PARAMS ((bfd *abfd));
3098
3099	int
3100	bfd_get_gp_size PARAMS ((bfd *abfd));
3101
3102	void
3103	bfd_set_gp_size PARAMS ((bfd *abfd, int i));
3104
3105	bfd_vma
3106	bfd_scan_vma PARAMS ((CONST char string, CONST char *end, int base));
3107
3108	boolean
3109	bfd_copy_private_bfd_data PARAMS ((bfd ibfd, bfd obfd));
3110
3111	#define bfd_copy_private_bfd_data(ibfd, obfd) \
3112	BFD_SEND (obfd, _bfd_copy_private_bfd_data, \
3113	(ibfd, obfd))
3114	boolean
3115	bfd_merge_private_bfd_data PARAMS ((bfd ibfd, bfd obfd));
3116
3117	#define bfd_merge_private_bfd_data(ibfd, obfd) \
3118	BFD_SEND (obfd, _bfd_merge_private_bfd_data, \
3119	(ibfd, obfd))
3120	boolean
3121	bfd_set_private_flags PARAMS ((bfd *abfd, flagword flags));
3122
3123	#define bfd_set_private_flags(abfd, flags) \
3124	BFD_SEND (abfd, _bfd_set_private_flags, \
3125	(abfd, flags))
3126	#define bfd_sizeof_headers(abfd, reloc) \
3127	BFD_SEND (abfd, _bfd_sizeof_headers, (abfd, reloc))
3128
3129	#define bfd_find_nearest_line(abfd, sec, syms, off, file, func, line) \
3130	BFD_SEND (abfd, _bfd_find_nearest_line, (abfd, sec, syms, off, file, func, line))
3131
3132	/* Do these three do anything useful at all, for any back end? */
3133	#define bfd_debug_info_start(abfd) \
3134	BFD_SEND (abfd, _bfd_debug_info_start, (abfd))
3135
3136	#define bfd_debug_info_end(abfd) \
3137	BFD_SEND (abfd, _bfd_debug_info_end, (abfd))
3138
3139	#define bfd_debug_info_accumulate(abfd, section) \
3140	BFD_SEND (abfd, _bfd_debug_info_accumulate, (abfd, section))
3141
3142
3143	#define bfd_stat_arch_elt(abfd, stat) \
3144	BFD_SEND (abfd, _bfd_stat_arch_elt,(abfd, stat))
3145
3146	#define bfd_update_armap_timestamp(abfd) \
3147	BFD_SEND (abfd, _bfd_update_armap_timestamp, (abfd))
3148
3149	#define bfd_set_arch_mach(abfd, arch, mach)\
3150	BFD_SEND ( abfd, _bfd_set_arch_mach, (abfd, arch, mach))
3151
3152	#define bfd_relax_section(abfd, section, link_info, again) \
3153	BFD_SEND (abfd, _bfd_relax_section, (abfd, section, link_info, again))
3154
3155	#define bfd_gc_sections(abfd, link_info) \
3156	BFD_SEND (abfd, _bfd_gc_sections, (abfd, link_info))
3157
3158	#define bfd_link_hash_table_create(abfd) \
3159	BFD_SEND (abfd, _bfd_link_hash_table_create, (abfd))
3160
3161	#define bfd_link_add_symbols(abfd, info) \
3162	BFD_SEND (abfd, _bfd_link_add_symbols, (abfd, info))
3163
3164	#define bfd_final_link(abfd, info) \
3165	BFD_SEND (abfd, _bfd_final_link, (abfd, info))
3166
3167	#define bfd_free_cached_info(abfd) \
3168	BFD_SEND (abfd, _bfd_free_cached_info, (abfd))
3169
3170	#define bfd_get_dynamic_symtab_upper_bound(abfd) \
3171	BFD_SEND (abfd, _bfd_get_dynamic_symtab_upper_bound, (abfd))
3172
3173	#define bfd_print_private_bfd_data(abfd, file)\
3174	BFD_SEND (abfd, _bfd_print_private_bfd_data, (abfd, file))
3175
3176	#define bfd_canonicalize_dynamic_symtab(abfd, asymbols) \
3177	BFD_SEND (abfd, _bfd_canonicalize_dynamic_symtab, (abfd, asymbols))
3178
3179	#define bfd_get_dynamic_reloc_upper_bound(abfd) \
3180	BFD_SEND (abfd, _bfd_get_dynamic_reloc_upper_bound, (abfd))
3181
3182	#define bfd_canonicalize_dynamic_reloc(abfd, arels, asyms) \
3183	BFD_SEND (abfd, _bfd_canonicalize_dynamic_reloc, (abfd, arels, asyms))
3184
3185	extern bfd_byte *bfd_get_relocated_section_contents
3186	PARAMS ((bfd , struct bfd_link_info ,
3187	struct bfd_link_order , bfd_byte ,
3188	boolean, asymbol **));
3189
3190	symindex
3191	bfd_get_next_mapent PARAMS ((bfd abfd, symindex previous, carsym *sym));
3192
3193	boolean
3194	bfd_set_archive_head PARAMS ((bfd output, bfd new_head));
3195
3196	bfd *
3197	bfd_openr_next_archived_file PARAMS ((bfd archive, bfd previous));
3198
3199	CONST char *
3200	bfd_core_file_failing_command PARAMS ((bfd *abfd));
3201
3202	int
3203	bfd_core_file_failing_signal PARAMS ((bfd *abfd));
3204
3205	boolean
3206	core_file_matches_executable_p PARAMS ((bfd core_bfd, bfd exec_bfd));
3207
3208	#define BFD_SEND(bfd, message, arglist) \
3209	((*((bfd)->xvec->message)) arglist)
3210
3211	#ifdef DEBUG_BFD_SEND
3212	#undef BFD_SEND
3213	#define BFD_SEND(bfd, message, arglist) \
3214	(((bfd) && (bfd)->xvec && (bfd)->xvec->message) ? \
3215	((*((bfd)->xvec->message)) arglist) : \
3216	(bfd_assert (__FILE__,__LINE__), NULL))
3217	#endif
3218	#define BFD_SEND_FMT(bfd, message, arglist) \
3219	(((bfd)->xvec->message[(int) ((bfd)->format)]) arglist)
3220
3221	#ifdef DEBUG_BFD_SEND
3222	#undef BFD_SEND_FMT
3223	#define BFD_SEND_FMT(bfd, message, arglist) \
3224	(((bfd) && (bfd)->xvec && (bfd)->xvec->message) ? \
3225	(((bfd)->xvec->message[(int) ((bfd)->format)]) arglist) : \
3226	(bfd_assert (__FILE__,__LINE__), NULL))
3227	#endif
3228	enum bfd_flavour {
3229	bfd_target_unknown_flavour,
3230	bfd_target_aout_flavour,
3231	bfd_target_coff_flavour,
3232	bfd_target_ecoff_flavour,
3233	bfd_target_xcoff_flavour,
3234	bfd_target_elf_flavour,
3235	bfd_target_ieee_flavour,
3236	bfd_target_nlm_flavour,
3237	bfd_target_oasys_flavour,
3238	bfd_target_tekhex_flavour,
3239	bfd_target_srec_flavour,
3240	bfd_target_ihex_flavour,
3241	bfd_target_som_flavour,
3242	bfd_target_os9k_flavour,
3243	bfd_target_versados_flavour,
3244	bfd_target_msdos_flavour,
3245	bfd_target_ovax_flavour,
3246	bfd_target_evax_flavour
3247	};
3248
3249	enum bfd_endian { BFD_ENDIAN_BIG, BFD_ENDIAN_LITTLE, BFD_ENDIAN_UNKNOWN };
3250
3251	/* Forward declaration. */
3252	typedef struct bfd_link_info _bfd_link_info;
3253
3254	typedef struct bfd_target
3255	{
3256	char *name;
3257	enum bfd_flavour flavour;
3258	enum bfd_endian byteorder;
3259	enum bfd_endian header_byteorder;
3260	flagword object_flags;
3261	flagword section_flags;
3262	char symbol_leading_char;
3263	char ar_pad_char;
3264	unsigned short ar_max_namelen;
3265	bfd_vma (bfd_getx64) PARAMS ((const bfd_byte ));
3266	bfd_signed_vma (bfd_getx_signed_64) PARAMS ((const bfd_byte ));
3267	void (bfd_putx64) PARAMS ((bfd_vma, bfd_byte ));
3268	bfd_vma (bfd_getx32) PARAMS ((const bfd_byte ));
3269	bfd_signed_vma (bfd_getx_signed_32) PARAMS ((const bfd_byte ));
3270	void (bfd_putx32) PARAMS ((bfd_vma, bfd_byte ));
3271	bfd_vma (bfd_getx16) PARAMS ((const bfd_byte ));
3272	bfd_signed_vma (bfd_getx_signed_16) PARAMS ((const bfd_byte ));
3273	void (bfd_putx16) PARAMS ((bfd_vma, bfd_byte ));
3274	bfd_vma (bfd_h_getx64) PARAMS ((const bfd_byte ));
3275	bfd_signed_vma (bfd_h_getx_signed_64) PARAMS ((const bfd_byte ));
3276	void (bfd_h_putx64) PARAMS ((bfd_vma, bfd_byte ));
3277	bfd_vma (bfd_h_getx32) PARAMS ((const bfd_byte ));
3278	bfd_signed_vma (bfd_h_getx_signed_32) PARAMS ((const bfd_byte ));
3279	void (bfd_h_putx32) PARAMS ((bfd_vma, bfd_byte ));
3280	bfd_vma (bfd_h_getx16) PARAMS ((const bfd_byte ));
3281	bfd_signed_vma (bfd_h_getx_signed_16) PARAMS ((const bfd_byte ));
3282	void (bfd_h_putx16) PARAMS ((bfd_vma, bfd_byte ));
3283	const struct bfd_target (_bfd_check_format[bfd_type_end]) PARAMS ((bfd *));
3284	boolean (_bfd_set_format[bfd_type_end]) PARAMS ((bfd ));
3285	boolean (_bfd_write_contents[bfd_type_end]) PARAMS ((bfd ));
3286
3287	/* Generic entry points. */
3288	#define BFD_JUMP_TABLE_GENERIC(NAME)\
3289	CAT(NAME,_close_and_cleanup),\
3290	CAT(NAME,_bfd_free_cached_info),\
3291	CAT(NAME,_new_section_hook),\
3292	CAT(NAME,_get_section_contents),\
3293	CAT(NAME,_get_section_contents_in_window)
3294
3295	/* Called when the BFD is being closed to do any necessary cleanup. */
3296	boolean (_close_and_cleanup) PARAMS ((bfd ));
3297	/* Ask the BFD to free all cached information. */
3298	boolean (_bfd_free_cached_info) PARAMS ((bfd ));
3299	/* Called when a new section is created. */
3300	boolean (_new_section_hook) PARAMS ((bfd , sec_ptr));
3301	/* Read the contents of a section. */
3302	boolean (_bfd_get_section_contents) PARAMS ((bfd , sec_ptr, PTR,
3303	file_ptr, bfd_size_type));
3304	boolean (*_bfd_get_section_contents_in_window)
3305	PARAMS ((bfd , sec_ptr, bfd_window ,
3306	file_ptr, bfd_size_type));
3307
3308	/* Entry points to copy private data. */
3309	#define BFD_JUMP_TABLE_COPY(NAME)\
3310	CAT(NAME,_bfd_copy_private_bfd_data),\
3311	CAT(NAME,_bfd_merge_private_bfd_data),\
3312	CAT(NAME,_bfd_copy_private_section_data),\
3313	CAT(NAME,_bfd_copy_private_symbol_data),\
3314	CAT(NAME,_bfd_set_private_flags),\
3315	CAT(NAME,_bfd_print_private_bfd_data)\
3316	/* Called to copy BFD general private data from one object file
3317	to another. */
3318	boolean (_bfd_copy_private_bfd_data) PARAMS ((bfd , bfd *));
3319	/* Called to merge BFD general private data from one object file
3320	to a common output file when linking. */
3321	boolean (_bfd_merge_private_bfd_data) PARAMS ((bfd , bfd *));
3322	/* Called to copy BFD private section data from one object file
3323	to another. */
3324	boolean (_bfd_copy_private_section_data) PARAMS ((bfd , sec_ptr,
3325	bfd *, sec_ptr));
3326	/* Called to copy BFD private symbol data from one symbol
3327	to another. */
3328	boolean (_bfd_copy_private_symbol_data) PARAMS ((bfd , asymbol *,
3329	bfd , asymbol ));
3330	/* Called to set private backend flags */
3331	boolean (_bfd_set_private_flags) PARAMS ((bfd , flagword));
3332
3333	/* Called to print private BFD data */
3334	boolean (_bfd_print_private_bfd_data) PARAMS ((bfd , PTR));
3335
3336	/* Core file entry points. */
3337	#define BFD_JUMP_TABLE_CORE(NAME)\
3338	CAT(NAME,_core_file_failing_command),\
3339	CAT(NAME,_core_file_failing_signal),\
3340	CAT(NAME,_core_file_matches_executable_p)
3341	char * (_core_file_failing_command) PARAMS ((bfd ));
3342	int (_core_file_failing_signal) PARAMS ((bfd ));
3343	boolean (_core_file_matches_executable_p) PARAMS ((bfd , bfd *));
3344
3345	/* Archive entry points. */
3346	#define BFD_JUMP_TABLE_ARCHIVE(NAME)\
3347	CAT(NAME,_slurp_armap),\
3348	CAT(NAME,_slurp_extended_name_table),\
3349	CAT(NAME,_construct_extended_name_table),\
3350	CAT(NAME,_truncate_arname),\
3351	CAT(NAME,_write_armap),\
3352	CAT(NAME,_read_ar_hdr),\
3353	CAT(NAME,_openr_next_archived_file),\
3354	CAT(NAME,_get_elt_at_index),\
3355	CAT(NAME,_generic_stat_arch_elt),\
3356	CAT(NAME,_update_armap_timestamp)
3357	boolean (_bfd_slurp_armap) PARAMS ((bfd ));
3358	boolean (_bfd_slurp_extended_name_table) PARAMS ((bfd ));
3359	boolean (*_bfd_construct_extended_name_table)
3360	PARAMS ((bfd , char , bfd_size_type , const char **));
3361	void (_bfd_truncate_arname) PARAMS ((bfd , CONST char , char ));
3362	boolean (write_armap) PARAMS ((bfd arch,
3363	unsigned int elength,
3364	struct orl *map,
3365	unsigned int orl_count,
3366	int stridx));
3367	PTR (_bfd_read_ar_hdr_fn) PARAMS ((bfd ));
3368	bfd * (openr_next_archived_file) PARAMS ((bfd arch, bfd *prev));
3369	#define bfd_get_elt_at_index(b,i) BFD_SEND(b, _bfd_get_elt_at_index, (b,i))
3370	bfd * (_bfd_get_elt_at_index) PARAMS ((bfd , symindex));
3371	int (_bfd_stat_arch_elt) PARAMS ((bfd , struct stat *));
3372	boolean (_bfd_update_armap_timestamp) PARAMS ((bfd ));
3373
3374	/* Entry points used for symbols. */
3375	#define BFD_JUMP_TABLE_SYMBOLS(NAME)\
3376	CAT(NAME,_get_symtab_upper_bound),\
3377	CAT(NAME,_get_symtab),\
3378	CAT(NAME,_make_empty_symbol),\
3379	CAT(NAME,_print_symbol),\
3380	CAT(NAME,_get_symbol_info),\
3381	CAT(NAME,_bfd_is_local_label_name),\
3382	CAT(NAME,_get_lineno),\
3383	CAT(NAME,_find_nearest_line),\
3384	CAT(NAME,_bfd_make_debug_symbol),\
3385	CAT(NAME,_read_minisymbols),\
3386	CAT(NAME,_minisymbol_to_symbol)
3387	long (_bfd_get_symtab_upper_bound) PARAMS ((bfd ));
3388	long (_bfd_canonicalize_symtab) PARAMS ((bfd ,
3389	struct symbol_cache_entry **));
3390	struct symbol_cache_entry *
3391	(_bfd_make_empty_symbol) PARAMS ((bfd ));
3392	void (_bfd_print_symbol) PARAMS ((bfd , PTR,
3393	struct symbol_cache_entry *,
3394	bfd_print_symbol_type));
3395	#define bfd_print_symbol(b,p,s,e) BFD_SEND(b, _bfd_print_symbol, (b,p,s,e))
3396	void (_bfd_get_symbol_info) PARAMS ((bfd ,
3397	struct symbol_cache_entry *,
3398	symbol_info *));
3399	#define bfd_get_symbol_info(b,p,e) BFD_SEND(b, _bfd_get_symbol_info, (b,p,e))
3400	boolean (_bfd_is_local_label_name) PARAMS ((bfd , const char *));
3401
3402	alent * (_get_lineno) PARAMS ((bfd , struct symbol_cache_entry *));
3403	boolean (_bfd_find_nearest_line) PARAMS ((bfd abfd,
3404	struct sec section, struct symbol_cache_entry *symbols,
3405	bfd_vma offset, CONST char file, CONST char func,
3406	unsigned int *line));
3407	/* Back-door to allow format-aware applications to create debug symbols
3408	while using BFD for everything else. Currently used by the assembler
3409	when creating COFF files. */
3410	asymbol * (*_bfd_make_debug_symbol) PARAMS ((
3411	bfd *abfd,
3412	void *ptr,
3413	unsigned long size));
3414	#define bfd_read_minisymbols(b, d, m, s) \
3415	BFD_SEND (b, _read_minisymbols, (b, d, m, s))
3416	long (_read_minisymbols) PARAMS ((bfd , boolean, PTR *,
3417	unsigned int *));
3418	#define bfd_minisymbol_to_symbol(b, d, m, f) \
3419	BFD_SEND (b, _minisymbol_to_symbol, (b, d, m, f))
3420	asymbol (_minisymbol_to_symbol) PARAMS ((bfd *, boolean, const PTR,
3421	asymbol *));
3422
3423	/* Routines for relocs. */
3424	#define BFD_JUMP_TABLE_RELOCS(NAME)\
3425	CAT(NAME,_get_reloc_upper_bound),\
3426	CAT(NAME,_canonicalize_reloc),\
3427	CAT(NAME,_bfd_reloc_type_lookup)
3428	long (_get_reloc_upper_bound) PARAMS ((bfd , sec_ptr));
3429	long (_bfd_canonicalize_reloc) PARAMS ((bfd , sec_ptr, arelent **,
3430	struct symbol_cache_entry **));
3431	/* See documentation on reloc types. */
3432	reloc_howto_type *
3433	(reloc_type_lookup) PARAMS ((bfd abfd,
3434	bfd_reloc_code_real_type code));
3435
3436	/* Routines used when writing an object file. */
3437	#define BFD_JUMP_TABLE_WRITE(NAME)\
3438	CAT(NAME,_set_arch_mach),\
3439	CAT(NAME,_set_section_contents)
3440	boolean (_bfd_set_arch_mach) PARAMS ((bfd , enum bfd_architecture,
3441	unsigned long));
3442	boolean (_bfd_set_section_contents) PARAMS ((bfd , sec_ptr, PTR,
3443	file_ptr, bfd_size_type));
3444
3445	/* Routines used by the linker. */
3446	#define BFD_JUMP_TABLE_LINK(NAME)\
3447	CAT(NAME,_sizeof_headers),\
3448	CAT(NAME,_bfd_get_relocated_section_contents),\
3449	CAT(NAME,_bfd_relax_section),\
3450	CAT(NAME,_bfd_link_hash_table_create),\
3451	CAT(NAME,_bfd_link_add_symbols),\
3452	CAT(NAME,_bfd_final_link),\
3453	CAT(NAME,_bfd_link_split_section),\
3454	CAT(NAME,_bfd_gc_sections)
3455	int (_bfd_sizeof_headers) PARAMS ((bfd , boolean));
3456	bfd_byte * (_bfd_get_relocated_section_contents) PARAMS ((bfd ,
3457	struct bfd_link_info , struct bfd_link_order ,
3458	bfd_byte *data, boolean relocateable,
3459	struct symbol_cache_entry **));
3460
3461	boolean (_bfd_relax_section) PARAMS ((bfd , struct sec *,
3462	struct bfd_link_info , boolean again));
3463
3464	/* Create a hash table for the linker. Different backends store
3465	different information in this table. */
3466	struct bfd_link_hash_table (_bfd_link_hash_table_create) PARAMS ((bfd *));
3467
3468	/* Add symbols from this object file into the hash table. */
3469	boolean (_bfd_link_add_symbols) PARAMS ((bfd , struct bfd_link_info *));
3470
3471	/* Do a link based on the link_order structures attached to each
3472	section of the BFD. */
3473	boolean (_bfd_final_link) PARAMS ((bfd , struct bfd_link_info *));
3474
3475	/* Should this section be split up into smaller pieces during linking. */
3476	boolean (_bfd_link_split_section) PARAMS ((bfd , struct sec *));
3477
3478	/* Remove sections that are not referenced from the output. */
3479	boolean (_bfd_gc_sections) PARAMS ((bfd , struct bfd_link_info *));
3480
3481	/* Routines to handle dynamic symbols and relocs. */
3482	#define BFD_JUMP_TABLE_DYNAMIC(NAME)\
3483	CAT(NAME,_get_dynamic_symtab_upper_bound),\
3484	CAT(NAME,_canonicalize_dynamic_symtab),\
3485	CAT(NAME,_get_dynamic_reloc_upper_bound),\
3486	CAT(NAME,_canonicalize_dynamic_reloc)
3487	/* Get the amount of memory required to hold the dynamic symbols. */
3488	long (_bfd_get_dynamic_symtab_upper_bound) PARAMS ((bfd ));
3489	/* Read in the dynamic symbols. */
3490	long (*_bfd_canonicalize_dynamic_symtab)
3491	PARAMS ((bfd , struct symbol_cache_entry *));
3492	/* Get the amount of memory required to hold the dynamic relocs. */
3493	long (_bfd_get_dynamic_reloc_upper_bound) PARAMS ((bfd ));
3494	/* Read in the dynamic relocs. */
3495	long (*_bfd_canonicalize_dynamic_reloc)
3496	PARAMS ((bfd , arelent , struct symbol_cache_entry *));
3497
3498	/* Opposite endian version of this target. */
3499	const struct bfd_target * alternative_target;
3500
3501	PTR backend_data;
3502
3503	} bfd_target;
3504	boolean
3505	bfd_set_default_target PARAMS ((const char *name));
3506
3507	const bfd_target *
3508	bfd_find_target PARAMS ((CONST char target_name, bfd abfd));
3509
3510	const char **
3511	bfd_target_list PARAMS ((void));
3512
3513	const bfd_target *
3514	bfd_search_for_target PARAMS ((int (* search_func) (const bfd_target , void ), void *));
3515
3516	boolean
3517	bfd_check_format PARAMS ((bfd *abfd, bfd_format format));
3518
3519	boolean
3520	bfd_check_format_matches PARAMS ((bfd abfd, bfd_format format, char **matching));
3521
3522	boolean
3523	bfd_set_format PARAMS ((bfd *abfd, bfd_format format));
3524
3525	CONST char *
3526	bfd_format_string PARAMS ((bfd_format format));
3527
3528	#ifdef __cplusplus
3529	}
3530	#endif
3531	#endif

Note: See TracBrowser for help on using the repository browser.

Download in other formats: