1 /* Main header file for the bfd library -- portable access to object files. 2 Copyright 1990, 1991, 1992, 1993, 1994 Free Software Foundation, Inc. 3 Contributed by Cygnus Support. 4 5 ** NOTE: bfd.h and bfd-in2.h are GENERATED files. Don't change them; 6 ** instead, change bfd-in.h or the other BFD source files processed to 7 ** generate these files. 8 9 This file is part of BFD, the Binary File Descriptor library. 10 11 This program is free software; you can redistribute it and/or modify 12 it under the terms of the GNU General Public License as published by 13 the Free Software Foundation; either version 2 of the License, or 14 (at your option) any later version. 15 16 This program is distributed in the hope that it will be useful, 17 but WITHOUT ANY WARRANTY; without even the implied warranty of 18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 19 GNU General Public License for more details. 20 21 You should have received a copy of the GNU General Public License 22 along with this program; if not, write to the Free Software 23 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ 24 25 /* bfd.h -- The only header file required by users of the bfd library 26 27 The bfd.h file is generated from bfd-in.h and various .c files; if you 28 change it, your changes will probably be lost. 29 30 All the prototypes and definitions following the comment "THE FOLLOWING 31 IS EXTRACTED FROM THE SOURCE" are extracted from the source files for 32 BFD. If you change it, someone oneday will extract it from the source 33 again, and your changes will be lost. To save yourself from this bind, 34 change the definitions in the source in the bfd directory. Type "make 35 docs" and then "make headers" in that directory, and magically this file 36 will change to reflect your changes. 37 38 If you don't have the tools to perform the extraction, then you are 39 safe from someone on your system trampling over your header files. 40 You should still maintain the equivalence between the source and this 41 file though; every change you make to the .c file should be reflected 42 here. */ 43 44 #ifndef __BFD_H_SEEN__ 45 #define __BFD_H_SEEN__ 46 47 #include "ansidecl.h" 48 #include "obstack.h" 49 50 /* These two lines get substitutions done by commands in Makefile.in. */ 51 #define BFD_VERSION "2.4" 52 #define BFD_ARCH_SIZE 32 53 54 #if BFD_ARCH_SIZE >= 64 55 #define BFD64 56 #endif 57 58 #ifndef INLINE 59 #if __GNUC__ >= 2 60 #define INLINE __inline__ 61 #else 62 #define INLINE 63 #endif 64 #endif 65 66 /* 64-bit type definition (if any) from bfd's sysdep.h goes here */ 67 68 69 /* forward declaration */ 70 typedef struct _bfd bfd; 71 72 /* To squelch erroneous compiler warnings ("illegal pointer 73 combination") from the SVR3 compiler, we would like to typedef 74 boolean to int (it doesn't like functions which return boolean. 75 Making sure they are never implicitly declared to return int 76 doesn't seem to help). But this file is not configured based on 77 the host. */ 78 /* General rules: functions which are boolean return true on success 79 and false on failure (unless they're a predicate). -- bfd.doc */ 80 /* I'm sure this is going to break something and someone is going to 81 force me to change it. */ 82 /* typedef enum boolean {false, true} boolean; */ 83 /* Yup, SVR4 has a "typedef enum boolean" in <sys/types.h> -fnf */ 84 /* It gets worse if the host also defines a true/false enum... -sts */ 85 #ifndef TRUE_FALSE_ALREADY_DEFINED 86 typedef enum bfd_boolean {false, true} boolean; 87 #define BFD_TRUE_FALSE 88 #else 89 typedef enum bfd_boolean {bfd_false, bfd_true} boolean; 90 #endif 91 92 /* A pointer to a position in a file. */ 93 /* FIXME: This should be using off_t from <sys/types.h>. 94 For now, try to avoid breaking stuff by not including <sys/types.h> here. 95 This will break on systems with 64-bit file offsets (e.g. 4.4BSD). 96 Probably the best long-term answer is to avoid using file_ptr AND off_t 97 in this header file, and to handle this in the BFD implementation 98 rather than in its interface. */ 99 /* typedef off_t file_ptr; */ 100 typedef long int file_ptr; 101 102 /* Support for different sizes of target format ints and addresses. If the 103 host implements 64-bit values, it defines BFD_HOST_64_BIT to be the appropriate 104 type. Otherwise, this code will fall back on gcc's "long long" type if gcc 105 is being used. BFD_HOST_64_BIT must be defined in such a way as to be a valid 106 type name by itself or with "unsigned" prefixed. It should be a signed 107 type by itself. 108 109 If neither is the case, then compilation will fail if 64-bit targets are 110 requested. If you don't request any 64-bit targets, you should be safe. */ 111 112 #ifdef BFD64 113 114 #if defined (__GNUC__) && !defined (BFD_HOST_64_BIT) 115 #define BFD_HOST_64_BIT long long 116 typedef BFD_HOST_64_BIT int64_type; 117 typedef unsigned BFD_HOST_64_BIT uint64_type; 118 #endif 119 120 #if !defined (uint64_type) && defined (__GNUC__) 121 #define uint64_type unsigned long long 122 #define int64_type long long 123 #endif 124 #ifndef uint64_typeLOW 125 #define uint64_typeLOW(x) ((unsigned long)(((x) & 0xffffffff))) 126 #define uint64_typeHIGH(x) ((unsigned long)(((x) >> 32) & 0xffffffff)) 127 #endif 128 129 typedef unsigned BFD_HOST_64_BIT bfd_vma; 130 typedef BFD_HOST_64_BIT bfd_signed_vma; 131 typedef unsigned BFD_HOST_64_BIT bfd_size_type; 132 typedef unsigned BFD_HOST_64_BIT symvalue; 133 #ifndef fprintf_vma 134 #define fprintf_vma(s,x) \ 135 fprintf(s,"%08lx%08lx", uint64_typeHIGH(x), uint64_typeLOW(x)) 136 #define sprintf_vma(s,x) \ 137 sprintf(s,"%08lx%08lx", uint64_typeHIGH(x), uint64_typeLOW(x)) 138 #endif 139 #else /* not BFD64 */ 140 141 /* Represent a target address. Also used as a generic unsigned type 142 which is guaranteed to be big enough to hold any arithmetic types 143 we need to deal with. */ 144 typedef unsigned long bfd_vma; 145 146 /* A generic signed type which is guaranteed to be big enough to hold any 147 arithmetic types we need to deal with. Can be assumed to be compatible 148 with bfd_vma in the same way that signed and unsigned ints are compatible 149 (as parameters, in assignment, etc). */ 150 typedef long bfd_signed_vma; 151 152 typedef unsigned long symvalue; 153 typedef unsigned long bfd_size_type; 154 155 /* Print a bfd_vma x on stream s. */ 156 #define fprintf_vma(s,x) fprintf(s, "%08lx", x) 157 #define sprintf_vma(s,x) sprintf(s, "%08lx", x) 158 #endif /* not BFD64 */ 159 #define printf_vma(x) fprintf_vma(stdout,x) 160 161 typedef unsigned int flagword; /* 32 bits of flags */ 162 163 /** File formats */ 164 165 typedef enum bfd_format { 166 bfd_unknown = 0, /* file format is unknown */ 167 bfd_object, /* linker/assember/compiler output */ 168 bfd_archive, /* object archive file */ 169 bfd_core, /* core dump */ 170 bfd_type_end} /* marks the end; don't use it! */ 171 bfd_format; 172 173 /* Values that may appear in the flags field of a BFD. These also 174 appear in the object_flags field of the bfd_target structure, where 175 they indicate the set of flags used by that backend (not all flags 176 are meaningful for all object file formats) (FIXME: at the moment, 177 the object_flags values have mostly just been copied from backend 178 to another, and are not necessarily correct). */ 179 180 /* No flags. */ 181 #define NO_FLAGS 0x00 182 183 /* BFD contains relocation entries. */ 184 #define HAS_RELOC 0x01 185 186 /* BFD is directly executable. */ 187 #define EXEC_P 0x02 188 189 /* BFD has line number information (basically used for F_LNNO in a 190 COFF header). */ 191 #define HAS_LINENO 0x04 192 193 /* BFD has debugging information. */ 194 #define HAS_DEBUG 0x08 195 196 /* BFD has symbols. */ 197 #define HAS_SYMS 0x10 198 199 /* BFD has local symbols (basically used for F_LSYMS in a COFF 200 header). */ 201 #define HAS_LOCALS 0x20 202 203 /* BFD is a dynamic object. */ 204 #define DYNAMIC 0x40 205 206 /* Text section is write protected (if D_PAGED is not set, this is 207 like an a.out NMAGIC file) (the linker sets this by default, but 208 clears it for -r or -N). */ 209 #define WP_TEXT 0x80 210 211 /* BFD is dynamically paged (this is like an a.out ZMAGIC file) (the 212 linker sets this by default, but clears it for -r or -n or -N). */ 213 #define D_PAGED 0x100 214 215 /* BFD is relaxable (this means that bfd_relax_section may be able to 216 do something). */ 217 #define BFD_IS_RELAXABLE 0x200 218 219 /* symbols and relocation */ 220 221 /* A count of carsyms (canonical archive symbols). */ 222 typedef unsigned long symindex; 223 224 #define BFD_NO_MORE_SYMBOLS ((symindex) ~0) 225 226 /* General purpose part of a symbol X; 227 target specific parts are in libcoff.h, libaout.h, etc. */ 228 229 #define bfd_get_section(x) ((x)->section) 230 #define bfd_get_output_section(x) ((x)->section->output_section) 231 #define bfd_set_section(x,y) ((x)->section) = (y) 232 #define bfd_asymbol_base(x) ((x)->section->vma) 233 #define bfd_asymbol_value(x) (bfd_asymbol_base(x) + (x)->value) 234 #define bfd_asymbol_name(x) ((x)->name) 235 /*Perhaps future: #define bfd_asymbol_bfd(x) ((x)->section->owner)*/ 236 #define bfd_asymbol_bfd(x) ((x)->the_bfd) 237 #define bfd_asymbol_flavour(x) (bfd_asymbol_bfd(x)->xvec->flavour) 238 239 /* A canonical archive symbol. */ 240 /* This is a type pun with struct ranlib on purpose! */ 241 typedef struct carsym { 242 char *name; 243 file_ptr file_offset; /* look here to find the file */ 244 } carsym; /* to make these you call a carsymogen */ 245 246 247 /* Used in generating armaps (archive tables of contents). 248 Perhaps just a forward definition would do? */ 249 struct orl { /* output ranlib */ 250 char **name; /* symbol name */ 251 file_ptr pos; /* bfd* or file position */ 252 int namidx; /* index into string table */ 253 }; 254 255 256 257 /* Linenumber stuff */ 258 typedef struct lineno_cache_entry { 259 unsigned int line_number; /* Linenumber from start of function*/ 260 union { 261 struct symbol_cache_entry *sym; /* Function name */ 262 unsigned long offset; /* Offset into section */ 263 } u; 264 } alent; 265 266 /* object and core file sections */ 267 268 269 #define align_power(addr, align) \ 270 ( ((addr) + ((1<<(align))-1)) & (-1 << (align))) 271 272 typedef struct sec *sec_ptr; 273 274 #define bfd_get_section_name(bfd, ptr) ((ptr)->name + 0) 275 #define bfd_get_section_vma(bfd, ptr) ((ptr)->vma + 0) 276 #define bfd_get_section_alignment(bfd, ptr) ((ptr)->alignment_power + 0) 277 #define bfd_section_name(bfd, ptr) ((ptr)->name) 278 #define bfd_section_size(bfd, ptr) (bfd_get_section_size_before_reloc(ptr)) 279 #define bfd_section_vma(bfd, ptr) ((ptr)->vma) 280 #define bfd_section_alignment(bfd, ptr) ((ptr)->alignment_power) 281 #define bfd_get_section_flags(bfd, ptr) ((ptr)->flags + 0) 282 #define bfd_get_section_userdata(bfd, ptr) ((ptr)->userdata) 283 284 #define bfd_is_com_section(ptr) (((ptr)->flags & SEC_IS_COMMON) != 0) 285 286 #define bfd_set_section_vma(bfd, ptr, val) (((ptr)->vma = (ptr)->lma= (val)), ((ptr)->user_set_vma = true), true) 287 #define bfd_set_section_alignment(bfd, ptr, val) (((ptr)->alignment_power = (val)),true) 288 #define bfd_set_section_userdata(bfd, ptr, val) (((ptr)->userdata = (val)),true) 289 290 typedef struct stat stat_type; 291 292 typedef enum bfd_print_symbol 293 { 294 bfd_print_symbol_name, 295 bfd_print_symbol_more, 296 bfd_print_symbol_all 297 } bfd_print_symbol_type; 298 299 /* Information about a symbol that nm needs. */ 300 301 typedef struct _symbol_info 302 { 303 symvalue value; 304 char type; 305 CONST char *name; /* Symbol name. */ 306 char stab_other; /* Unused. */ 307 short stab_desc; /* Info for N_TYPE. */ 308 CONST char *stab_name; 309 } symbol_info; 310 311 /* Hash table routines. There is no way to free up a hash table. */ 312 313 /* An element in the hash table. Most uses will actually use a larger 314 structure, and an instance of this will be the first field. */ 315 316 struct bfd_hash_entry 317 { 318 /* Next entry for this hash code. */ 319 struct bfd_hash_entry *next; 320 /* String being hashed. */ 321 const char *string; 322 /* Hash code. This is the full hash code, not the index into the 323 table. */ 324 unsigned long hash; 325 }; 326 327 /* A hash table. */ 328 329 struct bfd_hash_table 330 { 331 /* The hash array. */ 332 struct bfd_hash_entry **table; 333 /* The number of slots in the hash table. */ 334 unsigned int size; 335 /* A function used to create new elements in the hash table. The 336 first entry is itself a pointer to an element. When this 337 function is first invoked, this pointer will be NULL. However, 338 having the pointer permits a hierarchy of method functions to be 339 built each of which calls the function in the superclass. Thus 340 each function should be written to allocate a new block of memory 341 only if the argument is NULL. */ 342 struct bfd_hash_entry *(*newfunc) PARAMS ((struct bfd_hash_entry *, 343 struct bfd_hash_table *, 344 const char *)); 345 /* An obstack for this hash table. */ 346 struct obstack memory; 347 }; 348 349 /* Initialize a hash table. */ 350 extern boolean bfd_hash_table_init 351 PARAMS ((struct bfd_hash_table *, 352 struct bfd_hash_entry *(*) (struct bfd_hash_entry *, 353 struct bfd_hash_table *, 354 const char *))); 355 356 /* Initialize a hash table specifying a size. */ 357 extern boolean bfd_hash_table_init_n 358 PARAMS ((struct bfd_hash_table *, 359 struct bfd_hash_entry *(*) (struct bfd_hash_entry *, 360 struct bfd_hash_table *, 361 const char *), 362 unsigned int size)); 363 364 /* Free up a hash table. */ 365 extern void bfd_hash_table_free PARAMS ((struct bfd_hash_table *)); 366 367 /* Look up a string in a hash table. If CREATE is true, a new entry 368 will be created for this string if one does not already exist. The 369 COPY argument must be true if this routine should copy the string 370 into newly allocated memory when adding an entry. */ 371 extern struct bfd_hash_entry *bfd_hash_lookup 372 PARAMS ((struct bfd_hash_table *, const char *, boolean create, 373 boolean copy)); 374 375 /* Base method for creating a hash table entry. */ 376 extern struct bfd_hash_entry *bfd_hash_newfunc 377 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, 378 const char *)); 379 380 /* Grab some space for a hash table entry. */ 381 extern PTR bfd_hash_allocate PARAMS ((struct bfd_hash_table *, 382 unsigned int)); 383 384 /* Traverse a hash table in a random order, calling a function on each 385 element. If the function returns false, the traversal stops. The 386 INFO argument is passed to the function. */ 387 extern void bfd_hash_traverse PARAMS ((struct bfd_hash_table *, 388 boolean (*) (struct bfd_hash_entry *, 389 PTR), 390 PTR info)); 391 392 /* Semi-portable string concatenation in cpp. 393 The CAT4 hack is to avoid a problem with some strict ANSI C preprocessors. 394 The problem is, "32_" is not a valid preprocessing token, and we don't 395 want extra underscores (e.g., "nlm_32_"). The XCAT2 macro will cause the 396 inner CAT macros to be evaluated first, producing still-valid pp-tokens. 397 Then the final concatenation can be done. (Sigh.) */ 398 #ifndef CAT 399 #ifdef SABER 400 #define CAT(a,b) a##b 401 #define CAT3(a,b,c) a##b##c 402 #define CAT4(a,b,c,d) a##b##c##d 403 #else 404 #if defined(__STDC__) || defined(ALMOST_STDC) 405 #define CAT(a,b) a##b 406 #define CAT3(a,b,c) a##b##c 407 #define XCAT2(a,b) CAT(a,b) 408 #define CAT4(a,b,c,d) XCAT2(CAT(a,b),CAT(c,d)) 409 #else 410 #define CAT(a,b) a/**/b 411 #define CAT3(a,b,c) a/**/b/**/c 412 #define CAT4(a,b,c,d) a/**/b/**/c/**/d 413 #endif 414 #endif 415 #endif 416 417 #define COFF_SWAP_TABLE (PTR) &bfd_coff_std_swap_table 418 419 /* User program access to BFD facilities */ 420 421 /* Cast from const char * to char * so that caller can assign to 422 a char * without a warning. */ 423 #define bfd_get_filename(abfd) ((char *) (abfd)->filename) 424 #define bfd_get_cacheable(abfd) ((abfd)->cacheable) 425 #define bfd_get_format(abfd) ((abfd)->format) 426 #define bfd_get_target(abfd) ((abfd)->xvec->name) 427 #define bfd_get_flavour(abfd) ((abfd)->xvec->flavour) 428 #define bfd_get_file_flags(abfd) ((abfd)->flags) 429 #define bfd_applicable_file_flags(abfd) ((abfd)->xvec->object_flags) 430 #define bfd_applicable_section_flags(abfd) ((abfd)->xvec->section_flags) 431 #define bfd_my_archive(abfd) ((abfd)->my_archive) 432 #define bfd_has_map(abfd) ((abfd)->has_armap) 433 434 #define bfd_valid_reloc_types(abfd) ((abfd)->xvec->valid_reloc_types) 435 #define bfd_usrdata(abfd) ((abfd)->usrdata) 436 437 #define bfd_get_start_address(abfd) ((abfd)->start_address) 438 #define bfd_get_symcount(abfd) ((abfd)->symcount) 439 #define bfd_get_outsymbols(abfd) ((abfd)->outsymbols) 440 #define bfd_count_sections(abfd) ((abfd)->section_count) 441 442 #define bfd_get_symbol_leading_char(abfd) ((abfd)->xvec->symbol_leading_char) 443 444 #define bfd_set_cacheable(abfd,bool) (((abfd)->cacheable = (bool)), true) 445 446 /* Byte swapping routines. */ 447 448 bfd_vma bfd_getb64 PARAMS ((const unsigned char *)); 449 bfd_vma bfd_getl64 PARAMS ((const unsigned char *)); 450 bfd_signed_vma bfd_getb_signed_64 PARAMS ((const unsigned char *)); 451 bfd_signed_vma bfd_getl_signed_64 PARAMS ((const unsigned char *)); 452 bfd_vma bfd_getb32 PARAMS ((const unsigned char *)); 453 bfd_vma bfd_getl32 PARAMS ((const unsigned char *)); 454 bfd_signed_vma bfd_getb_signed_32 PARAMS ((const unsigned char *)); 455 bfd_signed_vma bfd_getl_signed_32 PARAMS ((const unsigned char *)); 456 bfd_vma bfd_getb16 PARAMS ((const unsigned char *)); 457 bfd_vma bfd_getl16 PARAMS ((const unsigned char *)); 458 bfd_signed_vma bfd_getb_signed_16 PARAMS ((const unsigned char *)); 459 bfd_signed_vma bfd_getl_signed_16 PARAMS ((const unsigned char *)); 460 void bfd_putb64 PARAMS ((bfd_vma, unsigned char *)); 461 void bfd_putl64 PARAMS ((bfd_vma, unsigned char *)); 462 void bfd_putb32 PARAMS ((bfd_vma, unsigned char *)); 463 void bfd_putl32 PARAMS ((bfd_vma, unsigned char *)); 464 void bfd_putb16 PARAMS ((bfd_vma, unsigned char *)); 465 void bfd_putl16 PARAMS ((bfd_vma, unsigned char *)); 466 467 /* Externally visible ECOFF routines. */ 468 469 #if defined(__STDC__) || defined(ALMOST_STDC) 470 struct ecoff_debug_info; 471 struct ecoff_debug_swap; 472 struct ecoff_extr; 473 struct symbol_cache_entry; 474 struct bfd_link_info; 475 #endif 476 extern bfd_vma bfd_ecoff_get_gp_value PARAMS ((bfd * abfd)); 477 extern boolean bfd_ecoff_set_gp_value PARAMS ((bfd *abfd, bfd_vma gp_value)); 478 extern boolean bfd_ecoff_set_regmasks 479 PARAMS ((bfd *abfd, unsigned long gprmask, unsigned long fprmask, 480 unsigned long *cprmask)); 481 extern PTR bfd_ecoff_debug_init 482 PARAMS ((bfd *output_bfd, struct ecoff_debug_info *output_debug, 483 const struct ecoff_debug_swap *output_swap, 484 struct bfd_link_info *)); 485 extern void bfd_ecoff_debug_free 486 PARAMS ((PTR handle, bfd *output_bfd, struct ecoff_debug_info *output_debug, 487 const struct ecoff_debug_swap *output_swap, 488 struct bfd_link_info *)); 489 extern boolean bfd_ecoff_debug_accumulate 490 PARAMS ((PTR handle, bfd *output_bfd, struct ecoff_debug_info *output_debug, 491 const struct ecoff_debug_swap *output_swap, 492 bfd *input_bfd, struct ecoff_debug_info *input_debug, 493 const struct ecoff_debug_swap *input_swap, 494 struct bfd_link_info *)); 495 extern boolean bfd_ecoff_debug_accumulate_other 496 PARAMS ((PTR handle, bfd *output_bfd, struct ecoff_debug_info *output_debug, 497 const struct ecoff_debug_swap *output_swap, bfd *input_bfd, 498 struct bfd_link_info *)); 499 extern boolean bfd_ecoff_debug_externals 500 PARAMS ((bfd *abfd, struct ecoff_debug_info *debug, 501 const struct ecoff_debug_swap *swap, 502 boolean relocateable, 503 boolean (*get_extr) (struct symbol_cache_entry *, 504 struct ecoff_extr *), 505 void (*set_index) (struct symbol_cache_entry *, 506 bfd_size_type))); 507 extern boolean bfd_ecoff_debug_one_external 508 PARAMS ((bfd *abfd, struct ecoff_debug_info *debug, 509 const struct ecoff_debug_swap *swap, 510 const char *name, struct ecoff_extr *esym)); 511 extern bfd_size_type bfd_ecoff_debug_size 512 PARAMS ((bfd *abfd, struct ecoff_debug_info *debug, 513 const struct ecoff_debug_swap *swap)); 514 extern boolean bfd_ecoff_write_debug 515 PARAMS ((bfd *abfd, struct ecoff_debug_info *debug, 516 const struct ecoff_debug_swap *swap, file_ptr where)); 517 extern boolean bfd_ecoff_write_accumulated_debug 518 PARAMS ((PTR handle, bfd *abfd, struct ecoff_debug_info *debug, 519 const struct ecoff_debug_swap *swap, 520 struct bfd_link_info *info, file_ptr where)); 521 522 /* And more from the source. */ 523 void 524 bfd_init PARAMS ((void)); 525 526 bfd * 527 bfd_openr PARAMS ((CONST char *filename, CONST char *target)); 528 529 bfd * 530 bfd_fdopenr PARAMS ((CONST char *filename, CONST char *target, int fd)); 531 532 bfd * 533 bfd_openw PARAMS ((CONST char *filename, CONST char *target)); 534 535 boolean 536 bfd_close PARAMS ((bfd *abfd)); 537 538 boolean 539 bfd_close_all_done PARAMS ((bfd *)); 540 541 bfd_size_type 542 bfd_alloc_size PARAMS ((bfd *abfd)); 543 544 bfd * 545 bfd_create PARAMS ((CONST char *filename, bfd *templ)); 546 547 548 /* Byte swapping macros for user section data. */ 549 550 #define bfd_put_8(abfd, val, ptr) \ 551 (*((unsigned char *)(ptr)) = (unsigned char)(val)) 552 #define bfd_put_signed_8 \ 553 bfd_put_8 554 #define bfd_get_8(abfd, ptr) \ 555 (*(unsigned char *)(ptr)) 556 #define bfd_get_signed_8(abfd, ptr) \ 557 ((*(unsigned char *)(ptr) ^ 0x80) - 0x80) 558 559 #define bfd_put_16(abfd, val, ptr) \ 560 BFD_SEND(abfd, bfd_putx16, ((val),(ptr))) 561 #define bfd_put_signed_16 \ 562 bfd_put_16 563 #define bfd_get_16(abfd, ptr) \ 564 BFD_SEND(abfd, bfd_getx16, (ptr)) 565 #define bfd_get_signed_16(abfd, ptr) \ 566 BFD_SEND (abfd, bfd_getx_signed_16, (ptr)) 567 568 #define bfd_put_32(abfd, val, ptr) \ 569 BFD_SEND(abfd, bfd_putx32, ((val),(ptr))) 570 #define bfd_put_signed_32 \ 571 bfd_put_32 572 #define bfd_get_32(abfd, ptr) \ 573 BFD_SEND(abfd, bfd_getx32, (ptr)) 574 #define bfd_get_signed_32(abfd, ptr) \ 575 BFD_SEND(abfd, bfd_getx_signed_32, (ptr)) 576 577 #define bfd_put_64(abfd, val, ptr) \ 578 BFD_SEND(abfd, bfd_putx64, ((val), (ptr))) 579 #define bfd_put_signed_64 \ 580 bfd_put_64 581 #define bfd_get_64(abfd, ptr) \ 582 BFD_SEND(abfd, bfd_getx64, (ptr)) 583 #define bfd_get_signed_64(abfd, ptr) \ 584 BFD_SEND(abfd, bfd_getx_signed_64, (ptr)) 585 586 587 /* Byte swapping macros for file header data. */ 588 589 #define bfd_h_put_8(abfd, val, ptr) \ 590 bfd_put_8 (abfd, val, ptr) 591 #define bfd_h_put_signed_8(abfd, val, ptr) \ 592 bfd_put_8 (abfd, val, ptr) 593 #define bfd_h_get_8(abfd, ptr) \ 594 bfd_get_8 (abfd, ptr) 595 #define bfd_h_get_signed_8(abfd, ptr) \ 596 bfd_get_signed_8 (abfd, ptr) 597 598 #define bfd_h_put_16(abfd, val, ptr) \ 599 BFD_SEND(abfd, bfd_h_putx16,(val,ptr)) 600 #define bfd_h_put_signed_16 \ 601 bfd_h_put_16 602 #define bfd_h_get_16(abfd, ptr) \ 603 BFD_SEND(abfd, bfd_h_getx16,(ptr)) 604 #define bfd_h_get_signed_16(abfd, ptr) \ 605 BFD_SEND(abfd, bfd_h_getx_signed_16, (ptr)) 606 607 #define bfd_h_put_32(abfd, val, ptr) \ 608 BFD_SEND(abfd, bfd_h_putx32,(val,ptr)) 609 #define bfd_h_put_signed_32 \ 610 bfd_h_put_32 611 #define bfd_h_get_32(abfd, ptr) \ 612 BFD_SEND(abfd, bfd_h_getx32,(ptr)) 613 #define bfd_h_get_signed_32(abfd, ptr) \ 614 BFD_SEND(abfd, bfd_h_getx_signed_32, (ptr)) 615 616 #define bfd_h_put_64(abfd, val, ptr) \ 617 BFD_SEND(abfd, bfd_h_putx64,(val, ptr)) 618 #define bfd_h_put_signed_64 \ 619 bfd_h_put_64 620 #define bfd_h_get_64(abfd, ptr) \ 621 BFD_SEND(abfd, bfd_h_getx64,(ptr)) 622 #define bfd_h_get_signed_64(abfd, ptr) \ 623 BFD_SEND(abfd, bfd_h_getx_signed_64, (ptr)) 624 625 typedef struct sec 626 { 627 /* The name of the section; the name isn't a copy, the pointer is 628 the same as that passed to bfd_make_section. */ 629 630 CONST char *name; 631 632 /* Which section is it; 0..nth. */ 633 634 int index; 635 636 /* The next section in the list belonging to the BFD, or NULL. */ 637 638 struct sec *next; 639 640 /* The field flags contains attributes of the section. Some 641 flags are read in from the object file, and some are 642 synthesized from other information. */ 643 644 flagword flags; 645 646 #define SEC_NO_FLAGS 0x000 647 648 /* Tells the OS to allocate space for this section when loading. 649 This is clear for a section containing debug information 650 only. */ 651 #define SEC_ALLOC 0x001 652 653 /* Tells the OS to load the section from the file when loading. 654 This is clear for a .bss section. */ 655 #define SEC_LOAD 0x002 656 657 /* The section contains data still to be relocated, so there is 658 some relocation information too. */ 659 #define SEC_RELOC 0x004 660 661 #if 0 /* Obsolete ? */ 662 #define SEC_BALIGN 0x008 663 #endif 664 665 /* A signal to the OS that the section contains read only 666 data. */ 667 #define SEC_READONLY 0x010 668 669 /* The section contains code only. */ 670 #define SEC_CODE 0x020 671 672 /* The section contains data only. */ 673 #define SEC_DATA 0x040 674 675 /* The section will reside in ROM. */ 676 #define SEC_ROM 0x080 677 678 /* The section contains constructor information. This section 679 type is used by the linker to create lists of constructors and 680 destructors used by <<g++>>. When a back end sees a symbol 681 which should be used in a constructor list, it creates a new 682 section for the type of name (e.g., <<__CTOR_LIST__>>), attaches 683 the symbol to it, and builds a relocation. To build the lists 684 of constructors, all the linker has to do is catenate all the 685 sections called <<__CTOR_LIST__>> and relocate the data 686 contained within - exactly the operations it would peform on 687 standard data. */ 688 #define SEC_CONSTRUCTOR 0x100 689 690 /* The section is a constuctor, and should be placed at the 691 end of the text, data, or bss section(?). */ 692 #define SEC_CONSTRUCTOR_TEXT 0x1100 693 #define SEC_CONSTRUCTOR_DATA 0x2100 694 #define SEC_CONSTRUCTOR_BSS 0x3100 695 696 /* The section has contents - a data section could be 697 <<SEC_ALLOC>> | <<SEC_HAS_CONTENTS>>; a debug section could be 698 <<SEC_HAS_CONTENTS>> */ 699 #define SEC_HAS_CONTENTS 0x200 700 701 /* An instruction to the linker to not output the section 702 even if it has information which would normally be written. */ 703 #define SEC_NEVER_LOAD 0x400 704 705 /* The section is a shared library section. The linker must leave 706 these completely alone, as the vma and size are used when 707 the executable is loaded. */ 708 #define SEC_SHARED_LIBRARY 0x800 709 710 /* The section is a common section (symbols may be defined 711 multiple times, the value of a symbol is the amount of 712 space it requires, and the largest symbol value is the one 713 used). Most targets have exactly one of these (which we 714 translate to bfd_com_section), but ECOFF has two. */ 715 #define SEC_IS_COMMON 0x8000 716 717 /* The section contains only debugging information. For 718 example, this is set for ELF .debug and .stab sections. 719 strip tests this flag to see if a section can be 720 discarded. */ 721 #define SEC_DEBUGGING 0x10000 722 723 /* The contents of this section are held in memory pointed to 724 by the contents field. This is checked by 725 bfd_get_section_contents, and the data is retrieved from 726 memory if appropriate. */ 727 #define SEC_IN_MEMORY 0x20000 728 729 /* End of section flags. */ 730 731 /* The virtual memory address of the section - where it will be 732 at run time. The symbols are relocated against this. The 733 user_set_vma flag is maintained by bfd; if it's not set, the 734 backend can assign addresses (for example, in <<a.out>>, where 735 the default address for <<.data>> is dependent on the specific 736 target and various flags). */ 737 738 bfd_vma vma; 739 boolean user_set_vma; 740 741 /* The load address of the section - where it would be in a 742 rom image; really only used for writing section header 743 information. */ 744 745 bfd_vma lma; 746 747 /* The size of the section in bytes, as it will be output. 748 contains a value even if the section has no contents (e.g., the 749 size of <<.bss>>). This will be filled in after relocation */ 750 751 bfd_size_type _cooked_size; 752 753 /* The original size on disk of the section, in bytes. Normally this 754 value is the same as the size, but if some relaxing has 755 been done, then this value will be bigger. */ 756 757 bfd_size_type _raw_size; 758 759 /* If this section is going to be output, then this value is the 760 offset into the output section of the first byte in the input 761 section. E.g., if this was going to start at the 100th byte in 762 the output section, this value would be 100. */ 763 764 bfd_vma output_offset; 765 766 /* The output section through which to map on output. */ 767 768 struct sec *output_section; 769 770 /* The alignment requirement of the section, as an exponent of 2 - 771 e.g., 3 aligns to 2^3 (or 8). */ 772 773 unsigned int alignment_power; 774 775 /* If an input section, a pointer to a vector of relocation 776 records for the data in this section. */ 777 778 struct reloc_cache_entry *relocation; 779 780 /* If an output section, a pointer to a vector of pointers to 781 relocation records for the data in this section. */ 782 783 struct reloc_cache_entry **orelocation; 784 785 /* The number of relocation records in one of the above */ 786 787 unsigned reloc_count; 788 789 /* Information below is back end specific - and not always used 790 or updated. */ 791 792 /* File position of section data */ 793 794 file_ptr filepos; 795 796 /* File position of relocation info */ 797 798 file_ptr rel_filepos; 799 800 /* File position of line data */ 801 802 file_ptr line_filepos; 803 804 /* Pointer to data for applications */ 805 806 PTR userdata; 807 808 /* If the SEC_IN_MEMORY flag is set, this points to the actual 809 contents. */ 810 unsigned char *contents; 811 812 /* Attached line number information */ 813 814 alent *lineno; 815 816 /* Number of line number records */ 817 818 unsigned int lineno_count; 819 820 /* When a section is being output, this value changes as more 821 linenumbers are written out */ 822 823 file_ptr moving_line_filepos; 824 825 /* What the section number is in the target world */ 826 827 int target_index; 828 829 PTR used_by_bfd; 830 831 /* If this is a constructor section then here is a list of the 832 relocations created to relocate items within it. */ 833 834 struct relent_chain *constructor_chain; 835 836 /* The BFD which owns the section. */ 837 838 bfd *owner; 839 840 boolean reloc_done; 841 /* A symbol which points at this section only */ 842 struct symbol_cache_entry *symbol; 843 struct symbol_cache_entry **symbol_ptr_ptr; 844 845 struct bfd_link_order *link_order_head; 846 struct bfd_link_order *link_order_tail; 847 } asection ; 848 849 850 /* These sections are global, and are managed by BFD. The application 851 and target back end are not permitted to change the values in 852 these sections. */ 853 #define BFD_ABS_SECTION_NAME "*ABS*" 854 #define BFD_UND_SECTION_NAME "*UND*" 855 #define BFD_COM_SECTION_NAME "*COM*" 856 #define BFD_IND_SECTION_NAME "*IND*" 857 858 /* the absolute section */ 859 extern asection bfd_abs_section; 860 /* Pointer to the undefined section */ 861 extern asection bfd_und_section; 862 /* Pointer to the common section */ 863 extern asection bfd_com_section; 864 /* Pointer to the indirect section */ 865 extern asection bfd_ind_section; 866 867 extern struct symbol_cache_entry *bfd_abs_symbol; 868 extern struct symbol_cache_entry *bfd_com_symbol; 869 extern struct symbol_cache_entry *bfd_und_symbol; 870 extern struct symbol_cache_entry *bfd_ind_symbol; 871 #define bfd_get_section_size_before_reloc(section) \ 872 (section->reloc_done ? (abort(),1): (section)->_raw_size) 873 #define bfd_get_section_size_after_reloc(section) \ 874 ((section->reloc_done) ? (section)->_cooked_size: (abort(),1)) 875 asection * 876 bfd_get_section_by_name PARAMS ((bfd *abfd, CONST char *name)); 877 878 asection * 879 bfd_make_section_old_way PARAMS ((bfd *abfd, CONST char *name)); 880 881 asection * 882 bfd_make_section_anyway PARAMS ((bfd *abfd, CONST char *name)); 883 884 asection * 885 bfd_make_section PARAMS ((bfd *, CONST char *name)); 886 887 boolean 888 bfd_set_section_flags PARAMS ((bfd *abfd, asection *sec, flagword flags)); 889 890 void 891 bfd_map_over_sections PARAMS ((bfd *abfd, 892 void (*func)(bfd *abfd, 893 asection *sect, 894 PTR obj), 895 PTR obj)); 896 897 boolean 898 bfd_set_section_size PARAMS ((bfd *abfd, asection *sec, bfd_size_type val)); 899 900 boolean 901 bfd_set_section_contents 902 PARAMS ((bfd *abfd, 903 asection *section, 904 PTR data, 905 file_ptr offset, 906 bfd_size_type count)); 907 908 boolean 909 bfd_get_section_contents 910 PARAMS ((bfd *abfd, asection *section, PTR location, 911 file_ptr offset, bfd_size_type count)); 912 913 boolean 914 bfd_copy_private_section_data PARAMS ((bfd *ibfd, asection *isec, bfd *obfd, asection *osec)); 915 916 #define bfd_copy_private_section_data(ibfd, isection, obfd, osection) \ 917 BFD_SEND (ibfd, _bfd_copy_private_section_data, \ 918 (ibfd, isection, obfd, osection)) 919 enum bfd_architecture 920 { 921 bfd_arch_unknown, /* File arch not known */ 922 bfd_arch_obscure, /* Arch known, not one of these */ 923 bfd_arch_m68k, /* Motorola 68xxx */ 924 bfd_arch_vax, /* DEC Vax */ 925 bfd_arch_i960, /* Intel 960 */ 926 /* The order of the following is important. 927 lower number indicates a machine type that 928 only accepts a subset of the instructions 929 available to machines with higher numbers. 930 The exception is the "ca", which is 931 incompatible with all other machines except 932 "core". */ 933 934 #define bfd_mach_i960_core 1 935 #define bfd_mach_i960_ka_sa 2 936 #define bfd_mach_i960_kb_sb 3 937 #define bfd_mach_i960_mc 4 938 #define bfd_mach_i960_xa 5 939 #define bfd_mach_i960_ca 6 940 941 bfd_arch_a29k, /* AMD 29000 */ 942 bfd_arch_sparc, /* SPARC */ 943 bfd_arch_mips, /* MIPS Rxxxx */ 944 bfd_arch_i386, /* Intel 386 */ 945 bfd_arch_we32k, /* AT&T WE32xxx */ 946 bfd_arch_tahoe, /* CCI/Harris Tahoe */ 947 bfd_arch_i860, /* Intel 860 */ 948 bfd_arch_romp, /* IBM ROMP PC/RT */ 949 bfd_arch_alliant, /* Alliant */ 950 bfd_arch_convex, /* Convex */ 951 bfd_arch_m88k, /* Motorola 88xxx */ 952 bfd_arch_pyramid, /* Pyramid Technology */ 953 bfd_arch_h8300, /* Hitachi H8/300 */ 954 #define bfd_mach_h8300 1 955 #define bfd_mach_h8300h 2 956 bfd_arch_powerpc, /* PowerPC */ 957 bfd_arch_rs6000, /* IBM RS/6000 */ 958 bfd_arch_hppa, /* HP PA RISC */ 959 bfd_arch_z8k, /* Zilog Z8000 */ 960 #define bfd_mach_z8001 1 961 #define bfd_mach_z8002 2 962 bfd_arch_h8500, /* Hitachi H8/500 */ 963 bfd_arch_sh, /* Hitachi SH */ 964 bfd_arch_alpha, /* Dec Alpha */ 965 bfd_arch_last 966 }; 967 968 typedef struct bfd_arch_info 969 { 970 int bits_per_word; 971 int bits_per_address; 972 int bits_per_byte; 973 enum bfd_architecture arch; 974 long mach; 975 char *arch_name; 976 CONST char *printable_name; 977 unsigned int section_align_power; 978 /* true if this is the default machine for the architecture */ 979 boolean the_default; 980 CONST struct bfd_arch_info * (*compatible) 981 PARAMS ((CONST struct bfd_arch_info *a, 982 CONST struct bfd_arch_info *b)); 983 984 boolean (*scan) PARAMS ((CONST struct bfd_arch_info *, CONST char *)); 985 /* How to disassemble an instruction, producing a printable 986 representation on a specified stdio stream. This isn't 987 defined for most processors at present, because of the size 988 of the additional tables it would drag in, and because gdb 989 wants to use a different interface. */ 990 unsigned int (*disassemble) PARAMS ((bfd_vma addr, CONST char *data, 991 PTR stream)); 992 993 struct bfd_arch_info *next; 994 } bfd_arch_info_type; 995 CONST char * 996 bfd_printable_name PARAMS ((bfd *abfd)); 997 998 bfd_arch_info_type * 999 bfd_scan_arch PARAMS ((CONST char *string)); 1000 1001 CONST bfd_arch_info_type * 1002 bfd_arch_get_compatible PARAMS (( 1003 CONST bfd *abfd, 1004 CONST bfd *bbfd)); 1005 1006 void 1007 bfd_set_arch_info PARAMS ((bfd *abfd, bfd_arch_info_type *arg)); 1008 1009 enum bfd_architecture 1010 bfd_get_arch PARAMS ((bfd *abfd)); 1011 1012 unsigned long 1013 bfd_get_mach PARAMS ((bfd *abfd)); 1014 1015 unsigned int 1016 bfd_arch_bits_per_byte PARAMS ((bfd *abfd)); 1017 1018 unsigned int 1019 bfd_arch_bits_per_address PARAMS ((bfd *abfd)); 1020 1021 bfd_arch_info_type * 1022 bfd_get_arch_info PARAMS ((bfd *abfd)); 1023 1024 bfd_arch_info_type * 1025 bfd_lookup_arch 1026 PARAMS ((enum bfd_architecture 1027 arch, 1028 long machine)); 1029 1030 CONST char * 1031 bfd_printable_arch_mach 1032 PARAMS ((enum bfd_architecture arch, unsigned long machine)); 1033 1034 typedef enum bfd_reloc_status 1035 { 1036 /* No errors detected */ 1037 bfd_reloc_ok, 1038 1039 /* The relocation was performed, but there was an overflow. */ 1040 bfd_reloc_overflow, 1041 1042 /* The address to relocate was not within the section supplied. */ 1043 bfd_reloc_outofrange, 1044 1045 /* Used by special functions */ 1046 bfd_reloc_continue, 1047 1048 /* Unsupported relocation size requested. */ 1049 bfd_reloc_notsupported, 1050 1051 /* Unused */ 1052 bfd_reloc_other, 1053 1054 /* The symbol to relocate against was undefined. */ 1055 bfd_reloc_undefined, 1056 1057 /* The relocation was performed, but may not be ok - presently 1058 generated only when linking i960 coff files with i960 b.out 1059 symbols. If this type is returned, the error_message argument 1060 to bfd_perform_relocation will be set. */ 1061 bfd_reloc_dangerous 1062 } 1063 bfd_reloc_status_type; 1064 1065 1066 typedef struct reloc_cache_entry 1067 { 1068 /* A pointer into the canonical table of pointers */ 1069 struct symbol_cache_entry **sym_ptr_ptr; 1070 1071 /* offset in section */ 1072 bfd_size_type address; 1073 1074 /* addend for relocation value */ 1075 bfd_vma addend; 1076 1077 /* Pointer to how to perform the required relocation */ 1078 const struct reloc_howto_struct *howto; 1079 1080 } arelent; 1081 enum complain_overflow 1082 { 1083 /* Do not complain on overflow. */ 1084 complain_overflow_dont, 1085 1086 /* Complain if the bitfield overflows, whether it is considered 1087 as signed or unsigned. */ 1088 complain_overflow_bitfield, 1089 1090 /* Complain if the value overflows when considered as signed 1091 number. */ 1092 complain_overflow_signed, 1093 1094 /* Complain if the value overflows when considered as an 1095 unsigned number. */ 1096 complain_overflow_unsigned 1097 }; 1098 1099 typedef struct reloc_howto_struct 1100 { 1101 /* The type field has mainly a documetary use - the back end can 1102 do what it wants with it, though normally the back end's 1103 external idea of what a reloc number is stored 1104 in this field. For example, a PC relative word relocation 1105 in a coff environment has the type 023 - because that's 1106 what the outside world calls a R_PCRWORD reloc. */ 1107 unsigned int type; 1108 1109 /* The value the final relocation is shifted right by. This drops 1110 unwanted data from the relocation. */ 1111 unsigned int rightshift; 1112 1113 /* The size of the item to be relocated. This is *not* a 1114 power-of-two measure. To get the number of bytes operated 1115 on by a type of relocation, use bfd_get_reloc_size. */ 1116 int size; 1117 1118 /* The number of bits in the item to be relocated. This is used 1119 when doing overflow checking. */ 1120 unsigned int bitsize; 1121 1122 /* Notes that the relocation is relative to the location in the 1123 data section of the addend. The relocation function will 1124 subtract from the relocation value the address of the location 1125 being relocated. */ 1126 boolean pc_relative; 1127 1128 /* The bit position of the reloc value in the destination. 1129 The relocated value is left shifted by this amount. */ 1130 unsigned int bitpos; 1131 1132 /* What type of overflow error should be checked for when 1133 relocating. */ 1134 enum complain_overflow complain_on_overflow; 1135 1136 /* If this field is non null, then the supplied function is 1137 called rather than the normal function. This allows really 1138 strange relocation methods to be accomodated (e.g., i960 callj 1139 instructions). */ 1140 bfd_reloc_status_type (*special_function) 1141 PARAMS ((bfd *abfd, 1142 arelent *reloc_entry, 1143 struct symbol_cache_entry *symbol, 1144 PTR data, 1145 asection *input_section, 1146 bfd *output_bfd, 1147 char **error_message)); 1148 1149 /* The textual name of the relocation type. */ 1150 char *name; 1151 1152 /* When performing a partial link, some formats must modify the 1153 relocations rather than the data - this flag signals this.*/ 1154 boolean partial_inplace; 1155 1156 /* The src_mask selects which parts of the read in data 1157 are to be used in the relocation sum. E.g., if this was an 8 bit 1158 bit of data which we read and relocated, this would be 1159 0x000000ff. When we have relocs which have an addend, such as 1160 sun4 extended relocs, the value in the offset part of a 1161 relocating field is garbage so we never use it. In this case 1162 the mask would be 0x00000000. */ 1163 bfd_vma src_mask; 1164 1165 /* The dst_mask selects which parts of the instruction are replaced 1166 into the instruction. In most cases src_mask == dst_mask, 1167 except in the above special case, where dst_mask would be 1168 0x000000ff, and src_mask would be 0x00000000. */ 1169 bfd_vma dst_mask; 1170 1171 /* When some formats create PC relative instructions, they leave 1172 the value of the pc of the place being relocated in the offset 1173 slot of the instruction, so that a PC relative relocation can 1174 be made just by adding in an ordinary offset (e.g., sun3 a.out). 1175 Some formats leave the displacement part of an instruction 1176 empty (e.g., m88k bcs); this flag signals the fact.*/ 1177 boolean pcrel_offset; 1178 1179 } reloc_howto_type; 1180 #define HOWTO(C, R,S,B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC) \ 1181 {(unsigned)C,R,S,B, P, BI, O,SF,NAME,INPLACE,MASKSRC,MASKDST,PC} 1182 #define NEWHOWTO( FUNCTION, NAME,SIZE,REL,IN) HOWTO(0,0,SIZE,0,REL,0,complain_overflow_dont,FUNCTION, NAME,false,0,0,IN) 1183 1184 #define HOWTO_PREPARE(relocation, symbol) \ 1185 { \ 1186 if (symbol != (asymbol *)NULL) { \ 1187 if (bfd_is_com_section (symbol->section)) { \ 1188 relocation = 0; \ 1189 } \ 1190 else { \ 1191 relocation = symbol->value; \ 1192 } \ 1193 } \ 1194 } 1195 int 1196 bfd_get_reloc_size PARAMS ((const reloc_howto_type *)); 1197 1198 typedef unsigned char bfd_byte; 1199 1200 typedef struct relent_chain { 1201 arelent relent; 1202 struct relent_chain *next; 1203 } arelent_chain; 1204 bfd_reloc_status_type 1205 1206 bfd_perform_relocation 1207 PARAMS ((bfd *abfd, 1208 arelent *reloc_entry, 1209 PTR data, 1210 asection *input_section, 1211 bfd *output_bfd, 1212 char **error_message)); 1213 1214 typedef enum bfd_reloc_code_real 1215 { 1216 /* Basic absolute relocations */ 1217 BFD_RELOC_64, 1218 BFD_RELOC_32, 1219 BFD_RELOC_26, 1220 BFD_RELOC_16, 1221 BFD_RELOC_14, 1222 BFD_RELOC_8, 1223 1224 /* PC-relative relocations */ 1225 BFD_RELOC_64_PCREL, 1226 BFD_RELOC_32_PCREL, 1227 BFD_RELOC_24_PCREL, /* used by i960 */ 1228 BFD_RELOC_16_PCREL, 1229 BFD_RELOC_8_PCREL, 1230 1231 /* Linkage-table relative */ 1232 BFD_RELOC_32_BASEREL, 1233 BFD_RELOC_16_BASEREL, 1234 BFD_RELOC_8_BASEREL, 1235 1236 /* The type of reloc used to build a contructor table - at the moment 1237 probably a 32 bit wide abs address, but the cpu can choose. */ 1238 BFD_RELOC_CTOR, 1239 1240 /* 8 bits wide, but used to form an address like 0xffnn */ 1241 BFD_RELOC_8_FFnn, 1242 1243 /* 32-bit pc-relative, shifted right 2 bits (i.e., 30-bit 1244 word displacement, e.g. for SPARC) */ 1245 BFD_RELOC_32_PCREL_S2, 1246 /* signed 16-bit pc-relative, shifted right 2 bits (e.g. for MIPS) */ 1247 BFD_RELOC_16_PCREL_S2, 1248 /* this is used on the Alpha */ 1249 BFD_RELOC_23_PCREL_S2, 1250 1251 /* High 22 bits of 32-bit value, placed into lower 22 bits of 1252 target word; simple reloc. */ 1253 BFD_RELOC_HI22, 1254 /* Low 10 bits. */ 1255 BFD_RELOC_LO10, 1256 1257 /* For systems that allocate a Global Pointer register, these are 1258 displacements off that register. These relocation types are 1259 handled specially, because the value the register will have is 1260 decided relatively late. */ 1261 BFD_RELOC_GPREL16, 1262 BFD_RELOC_GPREL32, 1263 1264 /* Reloc types used for i960/b.out. */ 1265 BFD_RELOC_I960_CALLJ, 1266 1267 /* now for the sparc/elf codes */ 1268 BFD_RELOC_NONE, /* actually used */ 1269 BFD_RELOC_SPARC_WDISP22, 1270 BFD_RELOC_SPARC22, 1271 BFD_RELOC_SPARC13, 1272 BFD_RELOC_SPARC_GOT10, 1273 BFD_RELOC_SPARC_GOT13, 1274 BFD_RELOC_SPARC_GOT22, 1275 BFD_RELOC_SPARC_PC10, 1276 BFD_RELOC_SPARC_PC22, 1277 BFD_RELOC_SPARC_WPLT30, 1278 BFD_RELOC_SPARC_COPY, 1279 BFD_RELOC_SPARC_GLOB_DAT, 1280 BFD_RELOC_SPARC_JMP_SLOT, 1281 BFD_RELOC_SPARC_RELATIVE, 1282 BFD_RELOC_SPARC_UA32, 1283 1284 /* these are a.out specific? */ 1285 BFD_RELOC_SPARC_BASE13, 1286 BFD_RELOC_SPARC_BASE22, 1287 1288 1289 /* Alpha ECOFF relocations. Some of these treat the symbol or "addend" 1290 in some special way. */ 1291 /* For GPDISP_HI16 ("gpdisp") relocations, the symbol is ignored when 1292 writing; when reading, it will be the absolute section symbol. The 1293 addend is the displacement in bytes of the "lda" instruction from 1294 the "ldah" instruction (which is at the address of this reloc). */ 1295 BFD_RELOC_ALPHA_GPDISP_HI16, 1296 /* For GPDISP_LO16 ("ignore") relocations, the symbol is handled as 1297 with GPDISP_HI16 relocs. The addend is ignored when writing the 1298 relocations out, and is filled in with the file's GP value on 1299 reading, for convenience. */ 1300 BFD_RELOC_ALPHA_GPDISP_LO16, 1301 1302 /* The Alpha LITERAL/LITUSE relocs are produced by a symbol reference; 1303 the assembler turns it into a LDQ instruction to load the address of 1304 the symbol, and then fills in a register in the real instruction. 1305 1306 The LITERAL reloc, at the LDQ instruction, refers to the .lita 1307 section symbol. The addend is ignored when writing, but is filled 1308 in with the file's GP value on reading, for convenience, as with the 1309 GPDISP_LO16 reloc. 1310 1311 The LITUSE reloc, on the instruction using the loaded address, gives 1312 information to the linker that it might be able to use to optimize 1313 away some literal section references. The symbol is ignored (read 1314 as the absolute section symbol), and the "addend" indicates the type 1315 of instruction using the register: 1316 1 - "memory" fmt insn 1317 2 - byte-manipulation (byte offset reg) 1318 3 - jsr (target of branch) 1319 1320 The GNU linker currently doesn't do any of this optimizing. */ 1321 BFD_RELOC_ALPHA_LITERAL, 1322 BFD_RELOC_ALPHA_LITUSE, 1323 1324 /* The HINT relocation indicates a value that should be filled into the 1325 "hint" field of a jmp/jsr/ret instruction, for possible branch- 1326 prediction logic which may be provided on some processors. */ 1327 BFD_RELOC_ALPHA_HINT, 1328 1329 /* Bits 27..2 of the relocation address shifted right 2 bits; 1330 simple reloc otherwise. */ 1331 BFD_RELOC_MIPS_JMP, 1332 1333 /* High 16 bits of 32-bit value; simple reloc. */ 1334 BFD_RELOC_HI16, 1335 /* High 16 bits of 32-bit value but the low 16 bits will be sign 1336 extended and added to form the final result. If the low 16 1337 bits form a negative number, we need to add one to the high value 1338 to compensate for the borrow when the low bits are added. */ 1339 BFD_RELOC_HI16_S, 1340 /* Low 16 bits. */ 1341 BFD_RELOC_LO16, 1342 /* Like BFD_RELOC_HI16_S, but PC relative. */ 1343 BFD_RELOC_PCREL_HI16_S, 1344 /* Like BFD_RELOC_LO16, but PC relative. */ 1345 BFD_RELOC_PCREL_LO16, 1346 1347 /* relocation relative to the global pointer. */ 1348 #define BFD_RELOC_MIPS_GPREL BFD_RELOC_GPREL16 1349 1350 /* Relocation against a MIPS literal section. */ 1351 BFD_RELOC_MIPS_LITERAL, 1352 1353 /* MIPS ELF relocations. */ 1354 BFD_RELOC_MIPS_GOT16, 1355 BFD_RELOC_MIPS_CALL16, 1356 #define BFD_RELOC_MIPS_GPREL32 BFD_RELOC_GPREL32 1357 1358 /* These are, so far, specific to HPPA processors. I'm not sure that some 1359 don't duplicate other reloc types, such as BFD_RELOC_32 and _32_PCREL. 1360 Also, many more were in the list I got that don't fit in well in the 1361 model BFD uses, so I've omitted them for now. If we do make this reloc 1362 type get used for code that really does implement the funky reloc types, 1363 they'll have to be added to this list. */ 1364 BFD_RELOC_HPPA_32, 1365 BFD_RELOC_HPPA_11, 1366 BFD_RELOC_HPPA_14, 1367 BFD_RELOC_HPPA_17, 1368 1369 BFD_RELOC_HPPA_L21, 1370 BFD_RELOC_HPPA_R11, 1371 BFD_RELOC_HPPA_R14, 1372 BFD_RELOC_HPPA_R17, 1373 BFD_RELOC_HPPA_LS21, 1374 BFD_RELOC_HPPA_RS11, 1375 BFD_RELOC_HPPA_RS14, 1376 BFD_RELOC_HPPA_RS17, 1377 BFD_RELOC_HPPA_LD21, 1378 BFD_RELOC_HPPA_RD11, 1379 BFD_RELOC_HPPA_RD14, 1380 BFD_RELOC_HPPA_RD17, 1381 BFD_RELOC_HPPA_LR21, 1382 BFD_RELOC_HPPA_RR14, 1383 BFD_RELOC_HPPA_RR17, 1384 1385 BFD_RELOC_HPPA_GOTOFF_11, 1386 BFD_RELOC_HPPA_GOTOFF_14, 1387 BFD_RELOC_HPPA_GOTOFF_L21, 1388 BFD_RELOC_HPPA_GOTOFF_R11, 1389 BFD_RELOC_HPPA_GOTOFF_R14, 1390 BFD_RELOC_HPPA_GOTOFF_LS21, 1391 BFD_RELOC_HPPA_GOTOFF_RS11, 1392 BFD_RELOC_HPPA_GOTOFF_RS14, 1393 BFD_RELOC_HPPA_GOTOFF_LD21, 1394 BFD_RELOC_HPPA_GOTOFF_RD11, 1395 BFD_RELOC_HPPA_GOTOFF_RD14, 1396 BFD_RELOC_HPPA_GOTOFF_LR21, 1397 BFD_RELOC_HPPA_GOTOFF_RR14, 1398 1399 BFD_RELOC_HPPA_DLT_32, 1400 BFD_RELOC_HPPA_DLT_11, 1401 BFD_RELOC_HPPA_DLT_14, 1402 BFD_RELOC_HPPA_DLT_L21, 1403 BFD_RELOC_HPPA_DLT_R11, 1404 BFD_RELOC_HPPA_DLT_R14, 1405 1406 BFD_RELOC_HPPA_ABS_CALL_11, 1407 BFD_RELOC_HPPA_ABS_CALL_14, 1408 BFD_RELOC_HPPA_ABS_CALL_17, 1409 BFD_RELOC_HPPA_ABS_CALL_L21, 1410 BFD_RELOC_HPPA_ABS_CALL_R11, 1411 BFD_RELOC_HPPA_ABS_CALL_R14, 1412 BFD_RELOC_HPPA_ABS_CALL_R17, 1413 BFD_RELOC_HPPA_ABS_CALL_LS21, 1414 BFD_RELOC_HPPA_ABS_CALL_RS11, 1415 BFD_RELOC_HPPA_ABS_CALL_RS14, 1416 BFD_RELOC_HPPA_ABS_CALL_RS17, 1417 BFD_RELOC_HPPA_ABS_CALL_LD21, 1418 BFD_RELOC_HPPA_ABS_CALL_RD11, 1419 BFD_RELOC_HPPA_ABS_CALL_RD14, 1420 BFD_RELOC_HPPA_ABS_CALL_RD17, 1421 BFD_RELOC_HPPA_ABS_CALL_LR21, 1422 BFD_RELOC_HPPA_ABS_CALL_RR14, 1423 BFD_RELOC_HPPA_ABS_CALL_RR17, 1424 1425 BFD_RELOC_HPPA_PCREL_CALL_11, 1426 BFD_RELOC_HPPA_PCREL_CALL_12, 1427 BFD_RELOC_HPPA_PCREL_CALL_14, 1428 BFD_RELOC_HPPA_PCREL_CALL_17, 1429 BFD_RELOC_HPPA_PCREL_CALL_L21, 1430 BFD_RELOC_HPPA_PCREL_CALL_R11, 1431 BFD_RELOC_HPPA_PCREL_CALL_R14, 1432 BFD_RELOC_HPPA_PCREL_CALL_R17, 1433 BFD_RELOC_HPPA_PCREL_CALL_LS21, 1434 BFD_RELOC_HPPA_PCREL_CALL_RS11, 1435 BFD_RELOC_HPPA_PCREL_CALL_RS14, 1436 BFD_RELOC_HPPA_PCREL_CALL_RS17, 1437 BFD_RELOC_HPPA_PCREL_CALL_LD21, 1438 BFD_RELOC_HPPA_PCREL_CALL_RD11, 1439 BFD_RELOC_HPPA_PCREL_CALL_RD14, 1440 BFD_RELOC_HPPA_PCREL_CALL_RD17, 1441 BFD_RELOC_HPPA_PCREL_CALL_LR21, 1442 BFD_RELOC_HPPA_PCREL_CALL_RR14, 1443 BFD_RELOC_HPPA_PCREL_CALL_RR17, 1444 1445 BFD_RELOC_HPPA_PLABEL_32, 1446 BFD_RELOC_HPPA_PLABEL_11, 1447 BFD_RELOC_HPPA_PLABEL_14, 1448 BFD_RELOC_HPPA_PLABEL_L21, 1449 BFD_RELOC_HPPA_PLABEL_R11, 1450 BFD_RELOC_HPPA_PLABEL_R14, 1451 1452 BFD_RELOC_HPPA_UNWIND_ENTRY, 1453 BFD_RELOC_HPPA_UNWIND_ENTRIES, 1454 1455 /* i386/elf relocations */ 1456 BFD_RELOC_386_GOT32, 1457 BFD_RELOC_386_PLT32, 1458 BFD_RELOC_386_COPY, 1459 BFD_RELOC_386_GLOB_DAT, 1460 BFD_RELOC_386_JUMP_SLOT, 1461 BFD_RELOC_386_RELATIVE, 1462 BFD_RELOC_386_GOTOFF, 1463 BFD_RELOC_386_GOTPC, 1464 1465 /* PowerPC/POWER (RS/6000) relocs. */ 1466 /* 26 bit relative branch. Low two bits must be zero. High 24 1467 bits installed in bits 6 through 29 of instruction. */ 1468 BFD_RELOC_PPC_B26, 1469 /* 26 bit absolute branch, like BFD_RELOC_PPC_B26 but absolute. */ 1470 BFD_RELOC_PPC_BA26, 1471 /* 16 bit TOC relative reference. */ 1472 BFD_RELOC_PPC_TOC16, 1473 1474 /* this must be the highest numeric value */ 1475 BFD_RELOC_UNUSED 1476 } bfd_reloc_code_real_type; 1477 const struct reloc_howto_struct * 1478 1479 bfd_reloc_type_lookup PARAMS ((bfd *abfd, bfd_reloc_code_real_type code)); 1480 1481 1482 typedef struct symbol_cache_entry 1483 { 1484 /* A pointer to the BFD which owns the symbol. This information 1485 is necessary so that a back end can work out what additional 1486 information (invisible to the application writer) is carried 1487 with the symbol. 1488 1489 This field is *almost* redundant, since you can use section->owner 1490 instead, except that some symbols point to the global sections 1491 bfd_{abs,com,und}_section. This could be fixed by making 1492 these globals be per-bfd (or per-target-flavor). FIXME. */ 1493 1494 struct _bfd *the_bfd; /* Use bfd_asymbol_bfd(sym) to access this field. */ 1495 1496 /* The text of the symbol. The name is left alone, and not copied; the 1497 application may not alter it. */ 1498 CONST char *name; 1499 1500 /* The value of the symbol. This really should be a union of a 1501 numeric value with a pointer, since some flags indicate that 1502 a pointer to another symbol is stored here. */ 1503 symvalue value; 1504 1505 /* Attributes of a symbol: */ 1506 1507 #define BSF_NO_FLAGS 0x00 1508 1509 /* The symbol has local scope; <<static>> in <<C>>. The value 1510 is the offset into the section of the data. */ 1511 #define BSF_LOCAL 0x01 1512 1513 /* The symbol has global scope; initialized data in <<C>>. The 1514 value is the offset into the section of the data. */ 1515 #define BSF_GLOBAL 0x02 1516 1517 /* The symbol has global scope and is exported. The value is 1518 the offset into the section of the data. */ 1519 #define BSF_EXPORT BSF_GLOBAL /* no real difference */ 1520 1521 /* A normal C symbol would be one of: 1522 <<BSF_LOCAL>>, <<BSF_FORT_COMM>>, <<BSF_UNDEFINED>> or 1523 <<BSF_GLOBAL>> */ 1524 1525 /* The symbol is a debugging record. The value has an arbitary 1526 meaning. */ 1527 #define BSF_DEBUGGING 0x08 1528 1529 /* The symbol denotes a function entry point. Used in ELF, 1530 perhaps others someday. */ 1531 #define BSF_FUNCTION 0x10 1532 1533 /* Used by the linker. */ 1534 #define BSF_KEEP 0x20 1535 #define BSF_KEEP_G 0x40 1536 1537 /* A weak global symbol, overridable without warnings by 1538 a regular global symbol of the same name. */ 1539 #define BSF_WEAK 0x80 1540 1541 /* This symbol was created to point to a section, e.g. ELF's 1542 STT_SECTION symbols. */ 1543 #define BSF_SECTION_SYM 0x100 1544 1545 /* The symbol used to be a common symbol, but now it is 1546 allocated. */ 1547 #define BSF_OLD_COMMON 0x200 1548 1549 /* The default value for common data. */ 1550 #define BFD_FORT_COMM_DEFAULT_VALUE 0 1551 1552 /* In some files the type of a symbol sometimes alters its 1553 location in an output file - ie in coff a <<ISFCN>> symbol 1554 which is also <<C_EXT>> symbol appears where it was 1555 declared and not at the end of a section. This bit is set 1556 by the target BFD part to convey this information. */ 1557 1558 #define BSF_NOT_AT_END 0x400 1559 1560 /* Signal that the symbol is the label of constructor section. */ 1561 #define BSF_CONSTRUCTOR 0x800 1562 1563 /* Signal that the symbol is a warning symbol. If the symbol 1564 is a warning symbol, then the value field (I know this is 1565 tacky) will point to the asymbol which when referenced will 1566 cause the warning. */ 1567 #define BSF_WARNING 0x1000 1568 1569 /* Signal that the symbol is indirect. The value of the symbol 1570 is a pointer to an undefined asymbol which contains the 1571 name to use instead. */ 1572 #define BSF_INDIRECT 0x2000 1573 1574 /* BSF_FILE marks symbols that contain a file name. This is used 1575 for ELF STT_FILE symbols. */ 1576 #define BSF_FILE 0x4000 1577 1578 /* Symbol is from dynamic linking information. */ 1579 #define BSF_DYNAMIC 0x8000 1580 1581 flagword flags; 1582 1583 /* A pointer to the section to which this symbol is 1584 relative. This will always be non NULL, there are special 1585 sections for undefined and absolute symbols */ 1586 struct sec *section; 1587 1588 /* Back end special data. This is being phased out in favour 1589 of making this a union. */ 1590 PTR udata; 1591 1592 } asymbol; 1593 #define bfd_get_symtab_upper_bound(abfd) \ 1594 BFD_SEND (abfd, _bfd_get_symtab_upper_bound, (abfd)) 1595 boolean 1596 bfd_is_local_label PARAMS ((bfd *abfd, asymbol *sym)); 1597 1598 #define bfd_is_local_label(abfd, sym) \ 1599 BFD_SEND (abfd, _bfd_is_local_label,(abfd, sym)) 1600 #define bfd_canonicalize_symtab(abfd, location) \ 1601 BFD_SEND (abfd, _bfd_canonicalize_symtab,\ 1602 (abfd, location)) 1603 boolean 1604 bfd_set_symtab PARAMS ((bfd *abfd, asymbol **location, unsigned int count)); 1605 1606 void 1607 bfd_print_symbol_vandf PARAMS ((PTR file, asymbol *symbol)); 1608 1609 #define bfd_make_empty_symbol(abfd) \ 1610 BFD_SEND (abfd, _bfd_make_empty_symbol, (abfd)) 1611 #define bfd_make_debug_symbol(abfd,ptr,size) \ 1612 BFD_SEND (abfd, _bfd_make_debug_symbol, (abfd, ptr, size)) 1613 int 1614 bfd_decode_symclass PARAMS ((asymbol *symbol)); 1615 1616 void 1617 bfd_symbol_info PARAMS ((asymbol *symbol, symbol_info *ret)); 1618 1619 struct _bfd 1620 { 1621 /* The filename the application opened the BFD with. */ 1622 CONST char *filename; 1623 1624 /* A pointer to the target jump table. */ 1625 struct bfd_target *xvec; 1626 1627 /* To avoid dragging too many header files into every file that 1628 includes `<<bfd.h>>', IOSTREAM has been declared as a "char 1629 *", and MTIME as a "long". Their correct types, to which they 1630 are cast when used, are "FILE *" and "time_t". The iostream 1631 is the result of an fopen on the filename. */ 1632 char *iostream; 1633 1634 /* Is the file descriptor being cached? That is, can it be closed as 1635 needed, and re-opened when accessed later? */ 1636 1637 boolean cacheable; 1638 1639 /* Marks whether there was a default target specified when the 1640 BFD was opened. This is used to select which matching algorithm 1641 to use to choose the back end. */ 1642 1643 boolean target_defaulted; 1644 1645 /* The caching routines use these to maintain a 1646 least-recently-used list of BFDs */ 1647 1648 struct _bfd *lru_prev, *lru_next; 1649 1650 /* When a file is closed by the caching routines, BFD retains 1651 state information on the file here: */ 1652 1653 file_ptr where; 1654 1655 /* and here: (``once'' means at least once) */ 1656 1657 boolean opened_once; 1658 1659 /* Set if we have a locally maintained mtime value, rather than 1660 getting it from the file each time: */ 1661 1662 boolean mtime_set; 1663 1664 /* File modified time, if mtime_set is true: */ 1665 1666 long mtime; 1667 1668 /* Reserved for an unimplemented file locking extension.*/ 1669 1670 int ifd; 1671 1672 /* The format which belongs to the BFD. (object, core, etc.) */ 1673 1674 bfd_format format; 1675 1676 /* The direction the BFD was opened with*/ 1677 1678 enum bfd_direction {no_direction = 0, 1679 read_direction = 1, 1680 write_direction = 2, 1681 both_direction = 3} direction; 1682 1683 /* Format_specific flags*/ 1684 1685 flagword flags; 1686 1687 /* Currently my_archive is tested before adding origin to 1688 anything. I believe that this can become always an add of 1689 origin, with origin set to 0 for non archive files. */ 1690 1691 file_ptr origin; 1692 1693 /* Remember when output has begun, to stop strange things 1694 from happening. */ 1695 boolean output_has_begun; 1696 1697 /* Pointer to linked list of sections*/ 1698 struct sec *sections; 1699 1700 /* The number of sections */ 1701 unsigned int section_count; 1702 1703 /* Stuff only useful for object files: 1704 The start address. */ 1705 bfd_vma start_address; 1706 1707 /* Used for input and output*/ 1708 unsigned int symcount; 1709 1710 /* Symbol table for output BFD (with symcount entries) */ 1711 struct symbol_cache_entry **outsymbols; 1712 1713 /* Pointer to structure which contains architecture information*/ 1714 struct bfd_arch_info *arch_info; 1715 1716 /* Stuff only useful for archives:*/ 1717 PTR arelt_data; 1718 struct _bfd *my_archive; /* The containing archive BFD. */ 1719 struct _bfd *next; /* The next BFD in the archive. */ 1720 struct _bfd *archive_head; /* The first BFD in the archive. */ 1721 boolean has_armap; 1722 1723 /* A chain of BFD structures involved in a link. */ 1724 struct _bfd *link_next; 1725 1726 /* A field used by _bfd_generic_link_add_archive_symbols. This will 1727 be used only for archive elements. */ 1728 int archive_pass; 1729 1730 /* Used by the back end to hold private data. */ 1731 1732 union 1733 { 1734 struct aout_data_struct *aout_data; 1735 struct artdata *aout_ar_data; 1736 struct _oasys_data *oasys_obj_data; 1737 struct _oasys_ar_data *oasys_ar_data; 1738 struct coff_tdata *coff_obj_data; 1739 struct ecoff_tdata *ecoff_obj_data; 1740 struct ieee_data_struct *ieee_data; 1741 struct ieee_ar_data_struct *ieee_ar_data; 1742 struct srec_data_struct *srec_data; 1743 struct tekhex_data_struct *tekhex_data; 1744 struct elf_obj_tdata *elf_obj_data; 1745 struct nlm_obj_tdata *nlm_obj_data; 1746 struct bout_data_struct *bout_data; 1747 struct sun_core_struct *sun_core_data; 1748 struct trad_core_struct *trad_core_data; 1749 struct som_data_struct *som_data; 1750 struct hpux_core_struct *hpux_core_data; 1751 struct hppabsd_core_struct *hppabsd_core_data; 1752 struct sgi_core_struct *sgi_core_data; 1753 struct lynx_core_struct *lynx_core_data; 1754 struct osf_core_struct *osf_core_data; 1755 struct cisco_core_struct *cisco_core_data; 1756 PTR any; 1757 } tdata; 1758 1759 /* Used by the application to hold private data*/ 1760 PTR usrdata; 1761 1762 /* Where all the allocated stuff under this BFD goes */ 1763 struct obstack memory; 1764 }; 1765 1766 typedef enum bfd_error 1767 { 1768 bfd_error_no_error = 0, 1769 bfd_error_system_call, 1770 bfd_error_invalid_target, 1771 bfd_error_wrong_format, 1772 bfd_error_invalid_operation, 1773 bfd_error_no_memory, 1774 bfd_error_no_symbols, 1775 bfd_error_no_more_archived_files, 1776 bfd_error_malformed_archive, 1777 bfd_error_file_not_recognized, 1778 bfd_error_file_ambiguously_recognized, 1779 bfd_error_no_contents, 1780 bfd_error_nonrepresentable_section, 1781 bfd_error_no_debug_section, 1782 bfd_error_bad_value, 1783 bfd_error_file_truncated, 1784 bfd_error_invalid_error_code 1785 } bfd_error_type; 1786 1787 bfd_error_type 1788 bfd_get_error PARAMS ((void)); 1789 1790 void 1791 bfd_set_error PARAMS ((bfd_error_type error_tag)); 1792 1793 CONST char * 1794 bfd_errmsg PARAMS ((bfd_error_type error_tag)); 1795 1796 void 1797 bfd_perror PARAMS ((CONST char *message)); 1798 1799 long 1800 bfd_get_reloc_upper_bound PARAMS ((bfd *abfd, asection *sect)); 1801 1802 long 1803 bfd_canonicalize_reloc 1804 PARAMS ((bfd *abfd, 1805 asection *sec, 1806 arelent **loc, 1807 asymbol **syms)); 1808 1809 void 1810 bfd_set_reloc 1811 PARAMS ((bfd *abfd, asection *sec, arelent **rel, unsigned int count) 1812 1813 ); 1814 1815 boolean 1816 bfd_set_file_flags PARAMS ((bfd *abfd, flagword flags)); 1817 1818 boolean 1819 bfd_set_start_address PARAMS ((bfd *abfd, bfd_vma vma)); 1820 1821 long 1822 bfd_get_mtime PARAMS ((bfd *abfd)); 1823 1824 long 1825 bfd_get_size PARAMS ((bfd *abfd)); 1826 1827 int 1828 bfd_get_gp_size PARAMS ((bfd *abfd)); 1829 1830 void 1831 bfd_set_gp_size PARAMS ((bfd *abfd, int i)); 1832 1833 bfd_vma 1834 bfd_scan_vma PARAMS ((CONST char *string, CONST char **end, int base)); 1835 1836 boolean 1837 bfd_copy_private_bfd_data PARAMS ((bfd *ibfd, bfd *obfd)); 1838 1839 #define bfd_copy_private_bfd_data(ibfd, obfd) \ 1840 BFD_SEND (ibfd, _bfd_copy_private_bfd_data, \ 1841 (ibfd, obfd)) 1842 #define bfd_sizeof_headers(abfd, reloc) \ 1843 BFD_SEND (abfd, _bfd_sizeof_headers, (abfd, reloc)) 1844 1845 #define bfd_find_nearest_line(abfd, sec, syms, off, file, func, line) \ 1846 BFD_SEND (abfd, _bfd_find_nearest_line, (abfd, sec, syms, off, file, func, line)) 1847 1848 /* Do these three do anything useful at all, for any back end? */ 1849 #define bfd_debug_info_start(abfd) \ 1850 BFD_SEND (abfd, _bfd_debug_info_start, (abfd)) 1851 1852 #define bfd_debug_info_end(abfd) \ 1853 BFD_SEND (abfd, _bfd_debug_info_end, (abfd)) 1854 1855 #define bfd_debug_info_accumulate(abfd, section) \ 1856 BFD_SEND (abfd, _bfd_debug_info_accumulate, (abfd, section)) 1857 1858 1859 #define bfd_stat_arch_elt(abfd, stat) \ 1860 BFD_SEND (abfd, _bfd_stat_arch_elt,(abfd, stat)) 1861 1862 #define bfd_set_arch_mach(abfd, arch, mach)\ 1863 BFD_SEND ( abfd, _bfd_set_arch_mach, (abfd, arch, mach)) 1864 1865 #define bfd_get_relocated_section_contents(abfd, link_info, link_order, data, relocateable, symbols) \ 1866 BFD_SEND (abfd, _bfd_get_relocated_section_contents, \ 1867 (abfd, link_info, link_order, data, relocateable, symbols)) 1868 1869 #define bfd_relax_section(abfd, section, link_info, again) \ 1870 BFD_SEND (abfd, _bfd_relax_section, (abfd, section, link_info, again)) 1871 1872 #define bfd_link_hash_table_create(abfd) \ 1873 BFD_SEND (abfd, _bfd_link_hash_table_create, (abfd)) 1874 1875 #define bfd_link_add_symbols(abfd, info) \ 1876 BFD_SEND (abfd, _bfd_link_add_symbols, (abfd, info)) 1877 1878 #define bfd_final_link(abfd, info) \ 1879 BFD_SEND (abfd, _bfd_final_link, (abfd, info)) 1880 1881 #define bfd_free_cached_info(abfd) \ 1882 BFD_SEND (abfd, _bfd_free_cached_info, (abfd)) 1883 1884 #define bfd_get_dynamic_symtab_upper_bound(abfd) \ 1885 BFD_SEND (abfd, _bfd_get_dynamic_symtab_upper_bound, (abfd)) 1886 1887 #define bfd_canonicalize_dynamic_symtab(abfd, asymbols) \ 1888 BFD_SEND (abfd, _bfd_canonicalize_dynamic_symtab, (abfd, asymbols)) 1889 1890 #define bfd_get_dynamic_reloc_upper_bound(abfd) \ 1891 BFD_SEND (abfd, _bfd_get_dynamic_reloc_upper_bound, (abfd)) 1892 1893 #define bfd_canonicalize_dynamic_reloc(abfd, arels, asyms) \ 1894 BFD_SEND (abfd, _bfd_canonicalize_dynamic_reloc, (abfd, arels, asyms)) 1895 1896 symindex 1897 bfd_get_next_mapent PARAMS ((bfd *abfd, symindex previous, carsym **sym)); 1898 1899 boolean 1900 bfd_set_archive_head PARAMS ((bfd *output, bfd *new_head)); 1901 1902 bfd * 1903 bfd_get_elt_at_index PARAMS ((bfd *archive, int index)); 1904 1905 bfd * 1906 bfd_openr_next_archived_file PARAMS ((bfd *archive, bfd *previous)); 1907 1908 CONST char * 1909 bfd_core_file_failing_command PARAMS ((bfd *abfd)); 1910 1911 int 1912 bfd_core_file_failing_signal PARAMS ((bfd *abfd)); 1913 1914 boolean 1915 core_file_matches_executable_p 1916 PARAMS ((bfd *core_bfd, bfd *exec_bfd)); 1917 1918 #define BFD_SEND(bfd, message, arglist) \ 1919 ((*((bfd)->xvec->message)) arglist) 1920 1921 #ifdef DEBUG_BFD_SEND 1922 #undef BFD_SEND 1923 #define BFD_SEND(bfd, message, arglist) \ 1924 (((bfd) && (bfd)->xvec && (bfd)->xvec->message) ? \ 1925 ((*((bfd)->xvec->message)) arglist) : \ 1926 (bfd_assert (__FILE__,__LINE__), NULL)) 1927 #endif 1928 #define BFD_SEND_FMT(bfd, message, arglist) \ 1929 (((bfd)->xvec->message[(int)((bfd)->format)]) arglist) 1930 1931 #ifdef DEBUG_BFD_SEND 1932 #undef BFD_SEND_FMT 1933 #define BFD_SEND_FMT(bfd, message, arglist) \ 1934 (((bfd) && (bfd)->xvec && (bfd)->xvec->message) ? \ 1935 (((bfd)->xvec->message[(int)((bfd)->format)]) arglist) : \ 1936 (bfd_assert (__FILE__,__LINE__), NULL)) 1937 #endif 1938 enum bfd_flavour { 1939 bfd_target_unknown_flavour, 1940 bfd_target_aout_flavour, 1941 bfd_target_coff_flavour, 1942 bfd_target_ecoff_flavour, 1943 bfd_target_elf_flavour, 1944 bfd_target_ieee_flavour, 1945 bfd_target_nlm_flavour, 1946 bfd_target_oasys_flavour, 1947 bfd_target_tekhex_flavour, 1948 bfd_target_srec_flavour, 1949 bfd_target_som_flavour, 1950 bfd_target_os9k_flavour}; 1951 1952 /* Forward declaration. */ 1953 typedef struct bfd_link_info _bfd_link_info; 1954 1955 typedef struct bfd_target 1956 { 1957 char *name; 1958 enum bfd_flavour flavour; 1959 boolean byteorder_big_p; 1960 boolean header_byteorder_big_p; 1961 flagword object_flags; 1962 flagword section_flags; 1963 char symbol_leading_char; 1964 char ar_pad_char; 1965 unsigned short ar_max_namelen; 1966 unsigned int align_power_min; 1967 bfd_vma (*bfd_getx64) PARAMS ((const bfd_byte *)); 1968 bfd_signed_vma (*bfd_getx_signed_64) PARAMS ((const bfd_byte *)); 1969 void (*bfd_putx64) PARAMS ((bfd_vma, bfd_byte *)); 1970 bfd_vma (*bfd_getx32) PARAMS ((const bfd_byte *)); 1971 bfd_signed_vma (*bfd_getx_signed_32) PARAMS ((const bfd_byte *)); 1972 void (*bfd_putx32) PARAMS ((bfd_vma, bfd_byte *)); 1973 bfd_vma (*bfd_getx16) PARAMS ((const bfd_byte *)); 1974 bfd_signed_vma (*bfd_getx_signed_16) PARAMS ((const bfd_byte *)); 1975 void (*bfd_putx16) PARAMS ((bfd_vma, bfd_byte *)); 1976 bfd_vma (*bfd_h_getx64) PARAMS ((const bfd_byte *)); 1977 bfd_signed_vma (*bfd_h_getx_signed_64) PARAMS ((const bfd_byte *)); 1978 void (*bfd_h_putx64) PARAMS ((bfd_vma, bfd_byte *)); 1979 bfd_vma (*bfd_h_getx32) PARAMS ((const bfd_byte *)); 1980 bfd_signed_vma (*bfd_h_getx_signed_32) PARAMS ((const bfd_byte *)); 1981 void (*bfd_h_putx32) PARAMS ((bfd_vma, bfd_byte *)); 1982 bfd_vma (*bfd_h_getx16) PARAMS ((const bfd_byte *)); 1983 bfd_signed_vma (*bfd_h_getx_signed_16) PARAMS ((const bfd_byte *)); 1984 void (*bfd_h_putx16) PARAMS ((bfd_vma, bfd_byte *)); 1985 struct bfd_target * (*_bfd_check_format[bfd_type_end]) PARAMS ((bfd *)); 1986 boolean (*_bfd_set_format[bfd_type_end]) PARAMS ((bfd *)); 1987 boolean (*_bfd_write_contents[bfd_type_end]) PARAMS ((bfd *)); 1988 1989 /* Generic entry points. */ 1990 #define BFD_JUMP_TABLE_GENERIC(NAME)\ 1991 CAT(NAME,_close_and_cleanup),\ 1992 CAT(NAME,_bfd_free_cached_info),\ 1993 CAT(NAME,_new_section_hook),\ 1994 CAT(NAME,_get_section_contents) 1995 /* Called when the BFD is being closed to do any necessary cleanup. */ 1996 boolean (*_close_and_cleanup) PARAMS ((bfd *)); 1997 /* Ask the BFD to free all cached information. */ 1998 boolean (*_bfd_free_cached_info) PARAMS ((bfd *)); 1999 /* Called when a new section is created. */ 2000 boolean (*_new_section_hook) PARAMS ((bfd *, sec_ptr)); 2001 /* Read the contents of a section. */ 2002 boolean (*_bfd_get_section_contents) PARAMS ((bfd *, sec_ptr, PTR, 2003 file_ptr, bfd_size_type)); 2004 2005 /* Entry points to copy private data. */ 2006 #define BFD_JUMP_TABLE_COPY(NAME)\ 2007 CAT(NAME,_bfd_copy_private_bfd_data),\ 2008 CAT(NAME,_bfd_copy_private_section_data) 2009 /* Called to copy BFD general private data from one object file 2010 to another. */ 2011 boolean (*_bfd_copy_private_bfd_data) PARAMS ((bfd *, bfd *)); 2012 /* Called to copy BFD private section data from one object file 2013 to another. */ 2014 boolean (*_bfd_copy_private_section_data) PARAMS ((bfd *, sec_ptr, 2015 bfd *, sec_ptr)); 2016 2017 /* Core file entry points. */ 2018 #define BFD_JUMP_TABLE_CORE(NAME)\ 2019 CAT(NAME,_core_file_failing_command),\ 2020 CAT(NAME,_core_file_failing_signal),\ 2021 CAT(NAME,_core_file_matches_executable_p) 2022 char * (*_core_file_failing_command) PARAMS ((bfd *)); 2023 int (*_core_file_failing_signal) PARAMS ((bfd *)); 2024 boolean (*_core_file_matches_executable_p) PARAMS ((bfd *, bfd *)); 2025 2026 /* Archive entry points. */ 2027 #define BFD_JUMP_TABLE_ARCHIVE(NAME)\ 2028 CAT(NAME,_slurp_armap),\ 2029 CAT(NAME,_slurp_extended_name_table),\ 2030 CAT(NAME,_truncate_arname),\ 2031 CAT(NAME,_write_armap),\ 2032 CAT(NAME,_openr_next_archived_file),\ 2033 CAT(NAME,_generic_stat_arch_elt) 2034 boolean (*_bfd_slurp_armap) PARAMS ((bfd *)); 2035 boolean (*_bfd_slurp_extended_name_table) PARAMS ((bfd *)); 2036 void (*_bfd_truncate_arname) PARAMS ((bfd *, CONST char *, char *)); 2037 boolean (*write_armap) PARAMS ((bfd *arch, 2038 unsigned int elength, 2039 struct orl *map, 2040 unsigned int orl_count, 2041 int stridx)); 2042 bfd * (*openr_next_archived_file) PARAMS ((bfd *arch, bfd *prev)); 2043 int (*_bfd_stat_arch_elt) PARAMS ((bfd *, struct stat *)); 2044 2045 /* Entry points used for symbols. */ 2046 #define BFD_JUMP_TABLE_SYMBOLS(NAME)\ 2047 CAT(NAME,_get_symtab_upper_bound),\ 2048 CAT(NAME,_get_symtab),\ 2049 CAT(NAME,_make_empty_symbol),\ 2050 CAT(NAME,_print_symbol),\ 2051 CAT(NAME,_get_symbol_info),\ 2052 CAT(NAME,_bfd_is_local_label),\ 2053 CAT(NAME,_get_lineno),\ 2054 CAT(NAME,_find_nearest_line),\ 2055 CAT(NAME,_bfd_make_debug_symbol) 2056 long (*_bfd_get_symtab_upper_bound) PARAMS ((bfd *)); 2057 long (*_bfd_canonicalize_symtab) PARAMS ((bfd *, 2058 struct symbol_cache_entry **)); 2059 struct symbol_cache_entry * 2060 (*_bfd_make_empty_symbol) PARAMS ((bfd *)); 2061 void (*_bfd_print_symbol) PARAMS ((bfd *, PTR, 2062 struct symbol_cache_entry *, 2063 bfd_print_symbol_type)); 2064 #define bfd_print_symbol(b,p,s,e) BFD_SEND(b, _bfd_print_symbol, (b,p,s,e)) 2065 void (*_bfd_get_symbol_info) PARAMS ((bfd *, 2066 struct symbol_cache_entry *, 2067 symbol_info *)); 2068 #define bfd_get_symbol_info(b,p,e) BFD_SEND(b, _bfd_get_symbol_info, (b,p,e)) 2069 boolean (*_bfd_is_local_label) PARAMS ((bfd *, asymbol *)); 2070 2071 alent * (*_get_lineno) PARAMS ((bfd *, struct symbol_cache_entry *)); 2072 boolean (*_bfd_find_nearest_line) PARAMS ((bfd *abfd, 2073 struct sec *section, struct symbol_cache_entry **symbols, 2074 bfd_vma offset, CONST char **file, CONST char **func, 2075 unsigned int *line)); 2076 /* Back-door to allow format-aware applications to create debug symbols 2077 while using BFD for everything else. Currently used by the assembler 2078 when creating COFF files. */ 2079 asymbol * (*_bfd_make_debug_symbol) PARAMS (( 2080 bfd *abfd, 2081 void *ptr, 2082 unsigned long size)); 2083 2084 /* Routines for relocs. */ 2085 #define BFD_JUMP_TABLE_RELOCS(NAME)\ 2086 CAT(NAME,_get_reloc_upper_bound),\ 2087 CAT(NAME,_canonicalize_reloc),\ 2088 CAT(NAME,_bfd_reloc_type_lookup) 2089 long (*_get_reloc_upper_bound) PARAMS ((bfd *, sec_ptr)); 2090 long (*_bfd_canonicalize_reloc) PARAMS ((bfd *, sec_ptr, arelent **, 2091 struct symbol_cache_entry **)); 2092 /* See documentation on reloc types. */ 2093 CONST struct reloc_howto_struct * 2094 (*reloc_type_lookup) PARAMS ((bfd *abfd, 2095 bfd_reloc_code_real_type code)); 2096 2097 /* Routines used when writing an object file. */ 2098 #define BFD_JUMP_TABLE_WRITE(NAME)\ 2099 CAT(NAME,_set_arch_mach),\ 2100 CAT(NAME,_set_section_contents) 2101 boolean (*_bfd_set_arch_mach) PARAMS ((bfd *, enum bfd_architecture, 2102 unsigned long)); 2103 boolean (*_bfd_set_section_contents) PARAMS ((bfd *, sec_ptr, PTR, 2104 file_ptr, bfd_size_type)); 2105 2106 /* Routines used by the linker. */ 2107 #define BFD_JUMP_TABLE_LINK(NAME)\ 2108 CAT(NAME,_sizeof_headers),\ 2109 CAT(NAME,_bfd_get_relocated_section_contents),\ 2110 CAT(NAME,_bfd_relax_section),\ 2111 CAT(NAME,_bfd_link_hash_table_create),\ 2112 CAT(NAME,_bfd_link_add_symbols),\ 2113 CAT(NAME,_bfd_final_link) 2114 int (*_bfd_sizeof_headers) PARAMS ((bfd *, boolean)); 2115 bfd_byte * (*_bfd_get_relocated_section_contents) PARAMS ((bfd *, 2116 struct bfd_link_info *, struct bfd_link_order *, 2117 bfd_byte *data, boolean relocateable, 2118 struct symbol_cache_entry **)); 2119 2120 boolean (*_bfd_relax_section) PARAMS ((bfd *, struct sec *, 2121 struct bfd_link_info *, boolean *again)); 2122 2123 /* Create a hash table for the linker. Different backends store 2124 different information in this table. */ 2125 struct bfd_link_hash_table *(*_bfd_link_hash_table_create) PARAMS ((bfd *)); 2126 2127 /* Add symbols from this object file into the hash table. */ 2128 boolean (*_bfd_link_add_symbols) PARAMS ((bfd *, struct bfd_link_info *)); 2129 2130 /* Do a link based on the link_order structures attached to each 2131 section of the BFD. */ 2132 boolean (*_bfd_final_link) PARAMS ((bfd *, struct bfd_link_info *)); 2133 2134 /* Routines to handle dynamic symbols and relocs. */ 2135 #define BFD_JUMP_TABLE_DYNAMIC(NAME)\ 2136 CAT(NAME,_get_dynamic_symtab_upper_bound),\ 2137 CAT(NAME,_canonicalize_dynamic_symtab),\ 2138 CAT(NAME,_get_dynamic_reloc_upper_bound),\ 2139 CAT(NAME,_canonicalize_dynamic_reloc) 2140 /* Get the amount of memory required to hold the dynamic symbols. */ 2141 long (*_bfd_get_dynamic_symtab_upper_bound) PARAMS ((bfd *)); 2142 /* Read in the dynamic symbols. */ 2143 long (*_bfd_canonicalize_dynamic_symtab) 2144 PARAMS ((bfd *, struct symbol_cache_entry **)); 2145 /* Get the amount of memory required to hold the dynamic relocs. */ 2146 long (*_bfd_get_dynamic_reloc_upper_bound) PARAMS ((bfd *)); 2147 /* Read in the dynamic relocs. */ 2148 long (*_bfd_canonicalize_dynamic_reloc) 2149 PARAMS ((bfd *, arelent **, struct symbol_cache_entry **)); 2150 2151 PTR backend_data; 2152 } bfd_target; 2153 bfd_target * 2154 bfd_find_target PARAMS ((CONST char *target_name, bfd *abfd)); 2155 2156 CONST char ** 2157 bfd_target_list PARAMS ((void)); 2158 2159 boolean 2160 bfd_check_format PARAMS ((bfd *abfd, bfd_format format)); 2161 2162 boolean 2163 bfd_check_format_matches PARAMS ((bfd *abfd, bfd_format format, char ***matching)); 2164 2165 boolean 2166 bfd_set_format PARAMS ((bfd *abfd, bfd_format format)); 2167 2168 CONST char * 2169 bfd_format_string PARAMS ((bfd_format format)); 2170 2171 #endif 2172