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