1 This is bfd.info, produced by makeinfo version 4.8 from 2 ../../../../toolchain/android-toolchain/binutils-2.17/bfd/doc/bfd.texinfo. 3 4 START-INFO-DIR-ENTRY 5 * Bfd: (bfd). The Binary File Descriptor library. 6 END-INFO-DIR-ENTRY 7 8 This file documents the BFD library. 9 10 Copyright (C) 1991, 2000, 2001, 2003 Free Software Foundation, Inc. 11 12 Permission is granted to copy, distribute and/or modify this document 13 under the terms of the GNU Free Documentation License, Version 1.1 14 or any later version published by the Free Software Foundation; 15 with no Invariant Sections, with no Front-Cover Texts, and with no 16 Back-Cover Texts. A copy of the license is included in the 17 section entitled "GNU Free Documentation License". 18 19 20 File: bfd.info, Node: Top, Next: Overview, Prev: (dir), Up: (dir) 21 22 This file documents the binary file descriptor library libbfd. 23 24 * Menu: 25 26 * Overview:: Overview of BFD 27 * BFD front end:: BFD front end 28 * BFD back ends:: BFD back ends 29 * GNU Free Documentation License:: GNU Free Documentation License 30 * Index:: Index 31 32 33 File: bfd.info, Node: Overview, Next: BFD front end, Prev: Top, Up: Top 34 35 1 Introduction 36 ************** 37 38 BFD is a package which allows applications to use the same routines to 39 operate on object files whatever the object file format. A new object 40 file format can be supported simply by creating a new BFD back end and 41 adding it to the library. 42 43 BFD is split into two parts: the front end, and the back ends (one 44 for each object file format). 45 * The front end of BFD provides the interface to the user. It manages 46 memory and various canonical data structures. The front end also 47 decides which back end to use and when to call back end routines. 48 49 * The back ends provide BFD its view of the real world. Each back 50 end provides a set of calls which the BFD front end can use to 51 maintain its canonical form. The back ends also may keep around 52 information for their own use, for greater efficiency. 53 54 * Menu: 55 56 * History:: History 57 * How It Works:: How It Works 58 * What BFD Version 2 Can Do:: What BFD Version 2 Can Do 59 60 61 File: bfd.info, Node: History, Next: How It Works, Prev: Overview, Up: Overview 62 63 1.1 History 64 =========== 65 66 One spur behind BFD was the desire, on the part of the GNU 960 team at 67 Intel Oregon, for interoperability of applications on their COFF and 68 b.out file formats. Cygnus was providing GNU support for the team, and 69 was contracted to provide the required functionality. 70 71 The name came from a conversation David Wallace was having with 72 Richard Stallman about the library: RMS said that it would be quite 73 hard--David said "BFD". Stallman was right, but the name stuck. 74 75 At the same time, Ready Systems wanted much the same thing, but for 76 different object file formats: IEEE-695, Oasys, Srecords, a.out and 68k 77 coff. 78 79 BFD was first implemented by members of Cygnus Support; Steve 80 Chamberlain (`sac (a] cygnus.com'), John Gilmore (`gnu (a] cygnus.com'), K. 81 Richard Pixley (`rich (a] cygnus.com') and David Henkel-Wallace 82 (`gumby (a] cygnus.com'). 83 84 85 File: bfd.info, Node: How It Works, Next: What BFD Version 2 Can Do, Prev: History, Up: Overview 86 87 1.2 How To Use BFD 88 ================== 89 90 To use the library, include `bfd.h' and link with `libbfd.a'. 91 92 BFD provides a common interface to the parts of an object file for a 93 calling application. 94 95 When an application sucessfully opens a target file (object, 96 archive, or whatever), a pointer to an internal structure is returned. 97 This pointer points to a structure called `bfd', described in `bfd.h'. 98 Our convention is to call this pointer a BFD, and instances of it 99 within code `abfd'. All operations on the target object file are 100 applied as methods to the BFD. The mapping is defined within `bfd.h' 101 in a set of macros, all beginning with `bfd_' to reduce namespace 102 pollution. 103 104 For example, this sequence does what you would probably expect: 105 return the number of sections in an object file attached to a BFD 106 `abfd'. 107 108 #include "bfd.h" 109 110 unsigned int number_of_sections (abfd) 111 bfd *abfd; 112 { 113 return bfd_count_sections (abfd); 114 } 115 116 The abstraction used within BFD is that an object file has: 117 118 * a header, 119 120 * a number of sections containing raw data (*note Sections::), 121 122 * a set of relocations (*note Relocations::), and 123 124 * some symbol information (*note Symbols::). 125 Also, BFDs opened for archives have the additional attribute of an 126 index and contain subordinate BFDs. This approach is fine for a.out and 127 coff, but loses efficiency when applied to formats such as S-records and 128 IEEE-695. 129 130 131 File: bfd.info, Node: What BFD Version 2 Can Do, Prev: How It Works, Up: Overview 132 133 1.3 What BFD Version 2 Can Do 134 ============================= 135 136 When an object file is opened, BFD subroutines automatically determine 137 the format of the input object file. They then build a descriptor in 138 memory with pointers to routines that will be used to access elements of 139 the object file's data structures. 140 141 As different information from the object files is required, BFD 142 reads from different sections of the file and processes them. For 143 example, a very common operation for the linker is processing symbol 144 tables. Each BFD back end provides a routine for converting between 145 the object file's representation of symbols and an internal canonical 146 format. When the linker asks for the symbol table of an object file, it 147 calls through a memory pointer to the routine from the relevant BFD 148 back end which reads and converts the table into a canonical form. The 149 linker then operates upon the canonical form. When the link is finished 150 and the linker writes the output file's symbol table, another BFD back 151 end routine is called to take the newly created symbol table and 152 convert it into the chosen output format. 153 154 * Menu: 155 156 * BFD information loss:: Information Loss 157 * Canonical format:: The BFD canonical object-file format 158 159 160 File: bfd.info, Node: BFD information loss, Next: Canonical format, Up: What BFD Version 2 Can Do 161 162 1.3.1 Information Loss 163 ---------------------- 164 165 _Information can be lost during output._ The output formats supported 166 by BFD do not provide identical facilities, and information which can 167 be described in one form has nowhere to go in another format. One 168 example of this is alignment information in `b.out'. There is nowhere 169 in an `a.out' format file to store alignment information on the 170 contained data, so when a file is linked from `b.out' and an `a.out' 171 image is produced, alignment information will not propagate to the 172 output file. (The linker will still use the alignment information 173 internally, so the link is performed correctly). 174 175 Another example is COFF section names. COFF files may contain an 176 unlimited number of sections, each one with a textual section name. If 177 the target of the link is a format which does not have many sections 178 (e.g., `a.out') or has sections without names (e.g., the Oasys format), 179 the link cannot be done simply. You can circumvent this problem by 180 describing the desired input-to-output section mapping with the linker 181 command language. 182 183 _Information can be lost during canonicalization._ The BFD internal 184 canonical form of the external formats is not exhaustive; there are 185 structures in input formats for which there is no direct representation 186 internally. This means that the BFD back ends cannot maintain all 187 possible data richness through the transformation between external to 188 internal and back to external formats. 189 190 This limitation is only a problem when an application reads one 191 format and writes another. Each BFD back end is responsible for 192 maintaining as much data as possible, and the internal BFD canonical 193 form has structures which are opaque to the BFD core, and exported only 194 to the back ends. When a file is read in one format, the canonical form 195 is generated for BFD and the application. At the same time, the back 196 end saves away any information which may otherwise be lost. If the data 197 is then written back in the same format, the back end routine will be 198 able to use the canonical form provided by the BFD core as well as the 199 information it prepared earlier. Since there is a great deal of 200 commonality between back ends, there is no information lost when 201 linking or copying big endian COFF to little endian COFF, or `a.out' to 202 `b.out'. When a mixture of formats is linked, the information is only 203 lost from the files whose format differs from the destination. 204 205 206 File: bfd.info, Node: Canonical format, Prev: BFD information loss, Up: What BFD Version 2 Can Do 207 208 1.3.2 The BFD canonical object-file format 209 ------------------------------------------ 210 211 The greatest potential for loss of information occurs when there is the 212 least overlap between the information provided by the source format, 213 that stored by the canonical format, and that needed by the destination 214 format. A brief description of the canonical form may help you 215 understand which kinds of data you can count on preserving across 216 conversions. 217 218 _files_ 219 Information stored on a per-file basis includes target machine 220 architecture, particular implementation format type, a demand 221 pageable bit, and a write protected bit. Information like Unix 222 magic numbers is not stored here--only the magic numbers' meaning, 223 so a `ZMAGIC' file would have both the demand pageable bit and the 224 write protected text bit set. The byte order of the target is 225 stored on a per-file basis, so that big- and little-endian object 226 files may be used with one another. 227 228 _sections_ 229 Each section in the input file contains the name of the section, 230 the section's original address in the object file, size and 231 alignment information, various flags, and pointers into other BFD 232 data structures. 233 234 _symbols_ 235 Each symbol contains a pointer to the information for the object 236 file which originally defined it, its name, its value, and various 237 flag bits. When a BFD back end reads in a symbol table, it 238 relocates all symbols to make them relative to the base of the 239 section where they were defined. Doing this ensures that each 240 symbol points to its containing section. Each symbol also has a 241 varying amount of hidden private data for the BFD back end. Since 242 the symbol points to the original file, the private data format 243 for that symbol is accessible. `ld' can operate on a collection 244 of symbols of wildly different formats without problems. 245 246 Normal global and simple local symbols are maintained on output, 247 so an output file (no matter its format) will retain symbols 248 pointing to functions and to global, static, and common variables. 249 Some symbol information is not worth retaining; in `a.out', type 250 information is stored in the symbol table as long symbol names. 251 This information would be useless to most COFF debuggers; the 252 linker has command line switches to allow users to throw it away. 253 254 There is one word of type information within the symbol, so if the 255 format supports symbol type information within symbols (for 256 example, COFF, IEEE, Oasys) and the type is simple enough to fit 257 within one word (nearly everything but aggregates), the 258 information will be preserved. 259 260 _relocation level_ 261 Each canonical BFD relocation record contains a pointer to the 262 symbol to relocate to, the offset of the data to relocate, the 263 section the data is in, and a pointer to a relocation type 264 descriptor. Relocation is performed by passing messages through 265 the relocation type descriptor and the symbol pointer. Therefore, 266 relocations can be performed on output data using a relocation 267 method that is only available in one of the input formats. For 268 instance, Oasys provides a byte relocation format. A relocation 269 record requesting this relocation type would point indirectly to a 270 routine to perform this, so the relocation may be performed on a 271 byte being written to a 68k COFF file, even though 68k COFF has no 272 such relocation type. 273 274 _line numbers_ 275 Object formats can contain, for debugging purposes, some form of 276 mapping between symbols, source line numbers, and addresses in the 277 output file. These addresses have to be relocated along with the 278 symbol information. Each symbol with an associated list of line 279 number records points to the first record of the list. The head 280 of a line number list consists of a pointer to the symbol, which 281 allows finding out the address of the function whose line number 282 is being described. The rest of the list is made up of pairs: 283 offsets into the section and line numbers. Any format which can 284 simply derive this information can pass it successfully between 285 formats (COFF, IEEE and Oasys). 286 287 288 File: bfd.info, Node: BFD front end, Next: BFD back ends, Prev: Overview, Up: Top 289 290 2 BFD Front End 291 *************** 292 293 2.1 `typedef bfd' 294 ================= 295 296 A BFD has type `bfd'; objects of this type are the cornerstone of any 297 application using BFD. Using BFD consists of making references though 298 the BFD and to data in the BFD. 299 300 Here is the structure that defines the type `bfd'. It contains the 301 major data about the file and pointers to the rest of the data. 302 303 304 struct bfd 305 { 306 /* A unique identifier of the BFD */ 307 unsigned int id; 308 309 /* The filename the application opened the BFD with. */ 310 const char *filename; 311 312 /* A pointer to the target jump table. */ 313 const struct bfd_target *xvec; 314 315 /* The IOSTREAM, and corresponding IO vector that provide access 316 to the file backing the BFD. */ 317 void *iostream; 318 const struct bfd_iovec *iovec; 319 320 /* Is the file descriptor being cached? That is, can it be closed as 321 needed, and re-opened when accessed later? */ 322 bfd_boolean cacheable; 323 324 /* Marks whether there was a default target specified when the 325 BFD was opened. This is used to select which matching algorithm 326 to use to choose the back end. */ 327 bfd_boolean target_defaulted; 328 329 /* The caching routines use these to maintain a 330 least-recently-used list of BFDs. */ 331 struct bfd *lru_prev, *lru_next; 332 333 /* When a file is closed by the caching routines, BFD retains 334 state information on the file here... */ 335 ufile_ptr where; 336 337 /* ... and here: (``once'' means at least once). */ 338 bfd_boolean opened_once; 339 340 /* Set if we have a locally maintained mtime value, rather than 341 getting it from the file each time. */ 342 bfd_boolean mtime_set; 343 344 /* File modified time, if mtime_set is TRUE. */ 345 long mtime; 346 347 /* Reserved for an unimplemented file locking extension. */ 348 int ifd; 349 350 /* The format which belongs to the BFD. (object, core, etc.) */ 351 bfd_format format; 352 353 /* The direction with which the BFD was opened. */ 354 enum bfd_direction 355 { 356 no_direction = 0, 357 read_direction = 1, 358 write_direction = 2, 359 both_direction = 3 360 } 361 direction; 362 363 /* Format_specific flags. */ 364 flagword flags; 365 366 /* Currently my_archive is tested before adding origin to 367 anything. I believe that this can become always an add of 368 origin, with origin set to 0 for non archive files. */ 369 ufile_ptr origin; 370 371 /* Remember when output has begun, to stop strange things 372 from happening. */ 373 bfd_boolean output_has_begun; 374 375 /* A hash table for section names. */ 376 struct bfd_hash_table section_htab; 377 378 /* Pointer to linked list of sections. */ 379 struct bfd_section *sections; 380 381 /* The last section on the section list. */ 382 struct bfd_section *section_last; 383 384 /* The number of sections. */ 385 unsigned int section_count; 386 387 /* Stuff only useful for object files: 388 The start address. */ 389 bfd_vma start_address; 390 391 /* Used for input and output. */ 392 unsigned int symcount; 393 394 /* Symbol table for output BFD (with symcount entries). */ 395 struct bfd_symbol **outsymbols; 396 397 /* Used for slurped dynamic symbol tables. */ 398 unsigned int dynsymcount; 399 400 /* Pointer to structure which contains architecture information. */ 401 const struct bfd_arch_info *arch_info; 402 403 /* Flag set if symbols from this BFD should not be exported. */ 404 bfd_boolean no_export; 405 406 /* Stuff only useful for archives. */ 407 void *arelt_data; 408 struct bfd *my_archive; /* The containing archive BFD. */ 409 struct bfd *next; /* The next BFD in the archive. */ 410 struct bfd *archive_head; /* The first BFD in the archive. */ 411 bfd_boolean has_armap; 412 413 /* A chain of BFD structures involved in a link. */ 414 struct bfd *link_next; 415 416 /* A field used by _bfd_generic_link_add_archive_symbols. This will 417 be used only for archive elements. */ 418 int archive_pass; 419 420 /* Used by the back end to hold private data. */ 421 union 422 { 423 struct aout_data_struct *aout_data; 424 struct artdata *aout_ar_data; 425 struct _oasys_data *oasys_obj_data; 426 struct _oasys_ar_data *oasys_ar_data; 427 struct coff_tdata *coff_obj_data; 428 struct pe_tdata *pe_obj_data; 429 struct xcoff_tdata *xcoff_obj_data; 430 struct ecoff_tdata *ecoff_obj_data; 431 struct ieee_data_struct *ieee_data; 432 struct ieee_ar_data_struct *ieee_ar_data; 433 struct srec_data_struct *srec_data; 434 struct ihex_data_struct *ihex_data; 435 struct tekhex_data_struct *tekhex_data; 436 struct elf_obj_tdata *elf_obj_data; 437 struct nlm_obj_tdata *nlm_obj_data; 438 struct bout_data_struct *bout_data; 439 struct mmo_data_struct *mmo_data; 440 struct sun_core_struct *sun_core_data; 441 struct sco5_core_struct *sco5_core_data; 442 struct trad_core_struct *trad_core_data; 443 struct som_data_struct *som_data; 444 struct hpux_core_struct *hpux_core_data; 445 struct hppabsd_core_struct *hppabsd_core_data; 446 struct sgi_core_struct *sgi_core_data; 447 struct lynx_core_struct *lynx_core_data; 448 struct osf_core_struct *osf_core_data; 449 struct cisco_core_struct *cisco_core_data; 450 struct versados_data_struct *versados_data; 451 struct netbsd_core_struct *netbsd_core_data; 452 struct mach_o_data_struct *mach_o_data; 453 struct mach_o_fat_data_struct *mach_o_fat_data; 454 struct bfd_pef_data_struct *pef_data; 455 struct bfd_pef_xlib_data_struct *pef_xlib_data; 456 struct bfd_sym_data_struct *sym_data; 457 void *any; 458 } 459 tdata; 460 461 /* Used by the application to hold private data. */ 462 void *usrdata; 463 464 /* Where all the allocated stuff under this BFD goes. This is a 465 struct objalloc *, but we use void * to avoid requiring the inclusion 466 of objalloc.h. */ 467 void *memory; 468 }; 469 470 2.2 Error reporting 471 =================== 472 473 Most BFD functions return nonzero on success (check their individual 474 documentation for precise semantics). On an error, they call 475 `bfd_set_error' to set an error condition that callers can check by 476 calling `bfd_get_error'. If that returns `bfd_error_system_call', then 477 check `errno'. 478 479 The easiest way to report a BFD error to the user is to use 480 `bfd_perror'. 481 482 2.2.1 Type `bfd_error_type' 483 --------------------------- 484 485 The values returned by `bfd_get_error' are defined by the enumerated 486 type `bfd_error_type'. 487 488 489 typedef enum bfd_error 490 { 491 bfd_error_no_error = 0, 492 bfd_error_system_call, 493 bfd_error_invalid_target, 494 bfd_error_wrong_format, 495 bfd_error_wrong_object_format, 496 bfd_error_invalid_operation, 497 bfd_error_no_memory, 498 bfd_error_no_symbols, 499 bfd_error_no_armap, 500 bfd_error_no_more_archived_files, 501 bfd_error_malformed_archive, 502 bfd_error_file_not_recognized, 503 bfd_error_file_ambiguously_recognized, 504 bfd_error_no_contents, 505 bfd_error_nonrepresentable_section, 506 bfd_error_no_debug_section, 507 bfd_error_bad_value, 508 bfd_error_file_truncated, 509 bfd_error_file_too_big, 510 bfd_error_invalid_error_code 511 } 512 bfd_error_type; 513 514 2.2.1.1 `bfd_get_error' 515 ....................... 516 517 *Synopsis* 518 bfd_error_type bfd_get_error (void); 519 *Description* 520 Return the current BFD error condition. 521 522 2.2.1.2 `bfd_set_error' 523 ....................... 524 525 *Synopsis* 526 void bfd_set_error (bfd_error_type error_tag); 527 *Description* 528 Set the BFD error condition to be ERROR_TAG. 529 530 2.2.1.3 `bfd_errmsg' 531 .................... 532 533 *Synopsis* 534 const char *bfd_errmsg (bfd_error_type error_tag); 535 *Description* 536 Return a string describing the error ERROR_TAG, or the system error if 537 ERROR_TAG is `bfd_error_system_call'. 538 539 2.2.1.4 `bfd_perror' 540 .................... 541 542 *Synopsis* 543 void bfd_perror (const char *message); 544 *Description* 545 Print to the standard error stream a string describing the last BFD 546 error that occurred, or the last system error if the last BFD error was 547 a system call failure. If MESSAGE is non-NULL and non-empty, the error 548 string printed is preceded by MESSAGE, a colon, and a space. It is 549 followed by a newline. 550 551 2.2.2 BFD error handler 552 ----------------------- 553 554 Some BFD functions want to print messages describing the problem. They 555 call a BFD error handler function. This function may be overridden by 556 the program. 557 558 The BFD error handler acts like printf. 559 560 561 typedef void (*bfd_error_handler_type) (const char *, ...); 562 563 2.2.2.1 `bfd_set_error_handler' 564 ............................... 565 566 *Synopsis* 567 bfd_error_handler_type bfd_set_error_handler (bfd_error_handler_type); 568 *Description* 569 Set the BFD error handler function. Returns the previous function. 570 571 2.2.2.2 `bfd_set_error_program_name' 572 .................................... 573 574 *Synopsis* 575 void bfd_set_error_program_name (const char *); 576 *Description* 577 Set the program name to use when printing a BFD error. This is printed 578 before the error message followed by a colon and space. The string 579 must not be changed after it is passed to this function. 580 581 2.2.2.3 `bfd_get_error_handler' 582 ............................... 583 584 *Synopsis* 585 bfd_error_handler_type bfd_get_error_handler (void); 586 *Description* 587 Return the BFD error handler function. 588 589 2.3 Miscellaneous 590 ================= 591 592 2.3.1 Miscellaneous functions 593 ----------------------------- 594 595 2.3.1.1 `bfd_get_reloc_upper_bound' 596 ................................... 597 598 *Synopsis* 599 long bfd_get_reloc_upper_bound (bfd *abfd, asection *sect); 600 *Description* 601 Return the number of bytes required to store the relocation information 602 associated with section SECT attached to bfd ABFD. If an error occurs, 603 return -1. 604 605 2.3.1.2 `bfd_canonicalize_reloc' 606 ................................ 607 608 *Synopsis* 609 long bfd_canonicalize_reloc 610 (bfd *abfd, asection *sec, arelent **loc, asymbol **syms); 611 *Description* 612 Call the back end associated with the open BFD ABFD and translate the 613 external form of the relocation information attached to SEC into the 614 internal canonical form. Place the table into memory at LOC, which has 615 been preallocated, usually by a call to `bfd_get_reloc_upper_bound'. 616 Returns the number of relocs, or -1 on error. 617 618 The SYMS table is also needed for horrible internal magic reasons. 619 620 2.3.1.3 `bfd_set_reloc' 621 ....................... 622 623 *Synopsis* 624 void bfd_set_reloc 625 (bfd *abfd, asection *sec, arelent **rel, unsigned int count); 626 *Description* 627 Set the relocation pointer and count within section SEC to the values 628 REL and COUNT. The argument ABFD is ignored. 629 630 2.3.1.4 `bfd_set_file_flags' 631 ............................ 632 633 *Synopsis* 634 bfd_boolean bfd_set_file_flags (bfd *abfd, flagword flags); 635 *Description* 636 Set the flag word in the BFD ABFD to the value FLAGS. 637 638 Possible errors are: 639 * `bfd_error_wrong_format' - The target bfd was not of object format. 640 641 * `bfd_error_invalid_operation' - The target bfd was open for 642 reading. 643 644 * `bfd_error_invalid_operation' - The flag word contained a bit 645 which was not applicable to the type of file. E.g., an attempt 646 was made to set the `D_PAGED' bit on a BFD format which does not 647 support demand paging. 648 649 2.3.1.5 `bfd_get_arch_size' 650 ........................... 651 652 *Synopsis* 653 int bfd_get_arch_size (bfd *abfd); 654 *Description* 655 Returns the architecture address size, in bits, as determined by the 656 object file's format. For ELF, this information is included in the 657 header. 658 659 *Returns* 660 Returns the arch size in bits if known, `-1' otherwise. 661 662 2.3.1.6 `bfd_get_sign_extend_vma' 663 ................................. 664 665 *Synopsis* 666 int bfd_get_sign_extend_vma (bfd *abfd); 667 *Description* 668 Indicates if the target architecture "naturally" sign extends an 669 address. Some architectures implicitly sign extend address values when 670 they are converted to types larger than the size of an address. For 671 instance, bfd_get_start_address() will return an address sign extended 672 to fill a bfd_vma when this is the case. 673 674 *Returns* 675 Returns `1' if the target architecture is known to sign extend 676 addresses, `0' if the target architecture is known to not sign extend 677 addresses, and `-1' otherwise. 678 679 2.3.1.7 `bfd_set_start_address' 680 ............................... 681 682 *Synopsis* 683 bfd_boolean bfd_set_start_address (bfd *abfd, bfd_vma vma); 684 *Description* 685 Make VMA the entry point of output BFD ABFD. 686 687 *Returns* 688 Returns `TRUE' on success, `FALSE' otherwise. 689 690 2.3.1.8 `bfd_get_gp_size' 691 ......................... 692 693 *Synopsis* 694 unsigned int bfd_get_gp_size (bfd *abfd); 695 *Description* 696 Return the maximum size of objects to be optimized using the GP 697 register under MIPS ECOFF. This is typically set by the `-G' argument 698 to the compiler, assembler or linker. 699 700 2.3.1.9 `bfd_set_gp_size' 701 ......................... 702 703 *Synopsis* 704 void bfd_set_gp_size (bfd *abfd, unsigned int i); 705 *Description* 706 Set the maximum size of objects to be optimized using the GP register 707 under ECOFF or MIPS ELF. This is typically set by the `-G' argument to 708 the compiler, assembler or linker. 709 710 2.3.1.10 `bfd_scan_vma' 711 ....................... 712 713 *Synopsis* 714 bfd_vma bfd_scan_vma (const char *string, const char **end, int base); 715 *Description* 716 Convert, like `strtoul', a numerical expression STRING into a `bfd_vma' 717 integer, and return that integer. (Though without as many bells and 718 whistles as `strtoul'.) The expression is assumed to be unsigned 719 (i.e., positive). If given a BASE, it is used as the base for 720 conversion. A base of 0 causes the function to interpret the string in 721 hex if a leading "0x" or "0X" is found, otherwise in octal if a leading 722 zero is found, otherwise in decimal. 723 724 If the value would overflow, the maximum `bfd_vma' value is returned. 725 726 2.3.1.11 `bfd_copy_private_header_data' 727 ....................................... 728 729 *Synopsis* 730 bfd_boolean bfd_copy_private_header_data (bfd *ibfd, bfd *obfd); 731 *Description* 732 Copy private BFD header information from the BFD IBFD to the the BFD 733 OBFD. This copies information that may require sections to exist, but 734 does not require symbol tables. Return `true' on success, `false' on 735 error. Possible error returns are: 736 737 * `bfd_error_no_memory' - Not enough memory exists to create private 738 data for OBFD. 739 740 #define bfd_copy_private_header_data(ibfd, obfd) \ 741 BFD_SEND (obfd, _bfd_copy_private_header_data, \ 742 (ibfd, obfd)) 743 744 2.3.1.12 `bfd_copy_private_bfd_data' 745 .................................... 746 747 *Synopsis* 748 bfd_boolean bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd); 749 *Description* 750 Copy private BFD information from the BFD IBFD to the the BFD OBFD. 751 Return `TRUE' on success, `FALSE' on error. Possible error returns are: 752 753 * `bfd_error_no_memory' - Not enough memory exists to create private 754 data for OBFD. 755 756 #define bfd_copy_private_bfd_data(ibfd, obfd) \ 757 BFD_SEND (obfd, _bfd_copy_private_bfd_data, \ 758 (ibfd, obfd)) 759 760 2.3.1.13 `bfd_merge_private_bfd_data' 761 ..................................... 762 763 *Synopsis* 764 bfd_boolean bfd_merge_private_bfd_data (bfd *ibfd, bfd *obfd); 765 *Description* 766 Merge private BFD information from the BFD IBFD to the the output file 767 BFD OBFD when linking. Return `TRUE' on success, `FALSE' on error. 768 Possible error returns are: 769 770 * `bfd_error_no_memory' - Not enough memory exists to create private 771 data for OBFD. 772 773 #define bfd_merge_private_bfd_data(ibfd, obfd) \ 774 BFD_SEND (obfd, _bfd_merge_private_bfd_data, \ 775 (ibfd, obfd)) 776 777 2.3.1.14 `bfd_set_private_flags' 778 ................................ 779 780 *Synopsis* 781 bfd_boolean bfd_set_private_flags (bfd *abfd, flagword flags); 782 *Description* 783 Set private BFD flag information in the BFD ABFD. Return `TRUE' on 784 success, `FALSE' on error. Possible error returns are: 785 786 * `bfd_error_no_memory' - Not enough memory exists to create private 787 data for OBFD. 788 789 #define bfd_set_private_flags(abfd, flags) \ 790 BFD_SEND (abfd, _bfd_set_private_flags, (abfd, flags)) 791 792 2.3.1.15 `Other functions' 793 .......................... 794 795 *Description* 796 The following functions exist but have not yet been documented. 797 #define bfd_sizeof_headers(abfd, reloc) \ 798 BFD_SEND (abfd, _bfd_sizeof_headers, (abfd, reloc)) 799 800 #define bfd_find_nearest_line(abfd, sec, syms, off, file, func, line) \ 801 BFD_SEND (abfd, _bfd_find_nearest_line, \ 802 (abfd, sec, syms, off, file, func, line)) 803 804 #define bfd_find_line(abfd, syms, sym, file, line) \ 805 BFD_SEND (abfd, _bfd_find_line, \ 806 (abfd, syms, sym, file, line)) 807 808 #define bfd_find_inliner_info(abfd, file, func, line) \ 809 BFD_SEND (abfd, _bfd_find_inliner_info, \ 810 (abfd, file, func, line)) 811 812 #define bfd_debug_info_start(abfd) \ 813 BFD_SEND (abfd, _bfd_debug_info_start, (abfd)) 814 815 #define bfd_debug_info_end(abfd) \ 816 BFD_SEND (abfd, _bfd_debug_info_end, (abfd)) 817 818 #define bfd_debug_info_accumulate(abfd, section) \ 819 BFD_SEND (abfd, _bfd_debug_info_accumulate, (abfd, section)) 820 821 #define bfd_stat_arch_elt(abfd, stat) \ 822 BFD_SEND (abfd, _bfd_stat_arch_elt,(abfd, stat)) 823 824 #define bfd_update_armap_timestamp(abfd) \ 825 BFD_SEND (abfd, _bfd_update_armap_timestamp, (abfd)) 826 827 #define bfd_set_arch_mach(abfd, arch, mach)\ 828 BFD_SEND ( abfd, _bfd_set_arch_mach, (abfd, arch, mach)) 829 830 #define bfd_relax_section(abfd, section, link_info, again) \ 831 BFD_SEND (abfd, _bfd_relax_section, (abfd, section, link_info, again)) 832 833 #define bfd_gc_sections(abfd, link_info) \ 834 BFD_SEND (abfd, _bfd_gc_sections, (abfd, link_info)) 835 836 #define bfd_merge_sections(abfd, link_info) \ 837 BFD_SEND (abfd, _bfd_merge_sections, (abfd, link_info)) 838 839 #define bfd_is_group_section(abfd, sec) \ 840 BFD_SEND (abfd, _bfd_is_group_section, (abfd, sec)) 841 842 #define bfd_discard_group(abfd, sec) \ 843 BFD_SEND (abfd, _bfd_discard_group, (abfd, sec)) 844 845 #define bfd_link_hash_table_create(abfd) \ 846 BFD_SEND (abfd, _bfd_link_hash_table_create, (abfd)) 847 848 #define bfd_link_hash_table_free(abfd, hash) \ 849 BFD_SEND (abfd, _bfd_link_hash_table_free, (hash)) 850 851 #define bfd_link_add_symbols(abfd, info) \ 852 BFD_SEND (abfd, _bfd_link_add_symbols, (abfd, info)) 853 854 #define bfd_link_just_syms(abfd, sec, info) \ 855 BFD_SEND (abfd, _bfd_link_just_syms, (sec, info)) 856 857 #define bfd_final_link(abfd, info) \ 858 BFD_SEND (abfd, _bfd_final_link, (abfd, info)) 859 860 #define bfd_free_cached_info(abfd) \ 861 BFD_SEND (abfd, _bfd_free_cached_info, (abfd)) 862 863 #define bfd_get_dynamic_symtab_upper_bound(abfd) \ 864 BFD_SEND (abfd, _bfd_get_dynamic_symtab_upper_bound, (abfd)) 865 866 #define bfd_print_private_bfd_data(abfd, file)\ 867 BFD_SEND (abfd, _bfd_print_private_bfd_data, (abfd, file)) 868 869 #define bfd_canonicalize_dynamic_symtab(abfd, asymbols) \ 870 BFD_SEND (abfd, _bfd_canonicalize_dynamic_symtab, (abfd, asymbols)) 871 872 #define bfd_get_synthetic_symtab(abfd, count, syms, dyncount, dynsyms, ret) \ 873 BFD_SEND (abfd, _bfd_get_synthetic_symtab, (abfd, count, syms, \ 874 dyncount, dynsyms, ret)) 875 876 #define bfd_get_dynamic_reloc_upper_bound(abfd) \ 877 BFD_SEND (abfd, _bfd_get_dynamic_reloc_upper_bound, (abfd)) 878 879 #define bfd_canonicalize_dynamic_reloc(abfd, arels, asyms) \ 880 BFD_SEND (abfd, _bfd_canonicalize_dynamic_reloc, (abfd, arels, asyms)) 881 882 extern bfd_byte *bfd_get_relocated_section_contents 883 (bfd *, struct bfd_link_info *, struct bfd_link_order *, bfd_byte *, 884 bfd_boolean, asymbol **); 885 886 2.3.1.16 `bfd_alt_mach_code' 887 ............................ 888 889 *Synopsis* 890 bfd_boolean bfd_alt_mach_code (bfd *abfd, int alternative); 891 *Description* 892 When more than one machine code number is available for the same 893 machine type, this function can be used to switch between the preferred 894 one (alternative == 0) and any others. Currently, only ELF supports 895 this feature, with up to two alternate machine codes. 896 897 struct bfd_preserve 898 { 899 void *marker; 900 void *tdata; 901 flagword flags; 902 const struct bfd_arch_info *arch_info; 903 struct bfd_section *sections; 904 struct bfd_section *section_last; 905 unsigned int section_count; 906 struct bfd_hash_table section_htab; 907 }; 908 909 2.3.1.17 `bfd_preserve_save' 910 ............................ 911 912 *Synopsis* 913 bfd_boolean bfd_preserve_save (bfd *, struct bfd_preserve *); 914 *Description* 915 When testing an object for compatibility with a particular target 916 back-end, the back-end object_p function needs to set up certain fields 917 in the bfd on successfully recognizing the object. This typically 918 happens in a piecemeal fashion, with failures possible at many points. 919 On failure, the bfd is supposed to be restored to its initial state, 920 which is virtually impossible. However, restoring a subset of the bfd 921 state works in practice. This function stores the subset and 922 reinitializes the bfd. 923 924 2.3.1.18 `bfd_preserve_restore' 925 ............................... 926 927 *Synopsis* 928 void bfd_preserve_restore (bfd *, struct bfd_preserve *); 929 *Description* 930 This function restores bfd state saved by bfd_preserve_save. If MARKER 931 is non-NULL in struct bfd_preserve then that block and all subsequently 932 bfd_alloc'd memory is freed. 933 934 2.3.1.19 `bfd_preserve_finish' 935 .............................. 936 937 *Synopsis* 938 void bfd_preserve_finish (bfd *, struct bfd_preserve *); 939 *Description* 940 This function should be called when the bfd state saved by 941 bfd_preserve_save is no longer needed. ie. when the back-end object_p 942 function returns with success. 943 944 2.3.1.20 `struct bfd_iovec' 945 ........................... 946 947 *Description* 948 The `struct bfd_iovec' contains the internal file I/O class. Each 949 `BFD' has an instance of this class and all file I/O is routed through 950 it (it is assumed that the instance implements all methods listed 951 below). 952 struct bfd_iovec 953 { 954 /* To avoid problems with macros, a "b" rather than "f" 955 prefix is prepended to each method name. */ 956 /* Attempt to read/write NBYTES on ABFD's IOSTREAM storing/fetching 957 bytes starting at PTR. Return the number of bytes actually 958 transfered (a read past end-of-file returns less than NBYTES), 959 or -1 (setting `bfd_error') if an error occurs. */ 960 file_ptr (*bread) (struct bfd *abfd, void *ptr, file_ptr nbytes); 961 file_ptr (*bwrite) (struct bfd *abfd, const void *ptr, 962 file_ptr nbytes); 963 /* Return the current IOSTREAM file offset, or -1 (setting `bfd_error' 964 if an error occurs. */ 965 file_ptr (*btell) (struct bfd *abfd); 966 /* For the following, on successful completion a value of 0 is returned. 967 Otherwise, a value of -1 is returned (and `bfd_error' is set). */ 968 int (*bseek) (struct bfd *abfd, file_ptr offset, int whence); 969 int (*bclose) (struct bfd *abfd); 970 int (*bflush) (struct bfd *abfd); 971 int (*bstat) (struct bfd *abfd, struct stat *sb); 972 }; 973 974 2.3.1.21 `bfd_get_mtime' 975 ........................ 976 977 *Synopsis* 978 long bfd_get_mtime (bfd *abfd); 979 *Description* 980 Return the file modification time (as read from the file system, or 981 from the archive header for archive members). 982 983 2.3.1.22 `bfd_get_size' 984 ....................... 985 986 *Synopsis* 987 long bfd_get_size (bfd *abfd); 988 *Description* 989 Return the file size (as read from file system) for the file associated 990 with BFD ABFD. 991 992 The initial motivation for, and use of, this routine is not so we 993 can get the exact size of the object the BFD applies to, since that 994 might not be generally possible (archive members for example). It 995 would be ideal if someone could eventually modify it so that such 996 results were guaranteed. 997 998 Instead, we want to ask questions like "is this NNN byte sized 999 object I'm about to try read from file offset YYY reasonable?" As as 1000 example of where we might do this, some object formats use string 1001 tables for which the first `sizeof (long)' bytes of the table contain 1002 the size of the table itself, including the size bytes. If an 1003 application tries to read what it thinks is one of these string tables, 1004 without some way to validate the size, and for some reason the size is 1005 wrong (byte swapping error, wrong location for the string table, etc.), 1006 the only clue is likely to be a read error when it tries to read the 1007 table, or a "virtual memory exhausted" error when it tries to allocate 1008 15 bazillon bytes of space for the 15 bazillon byte table it is about 1009 to read. This function at least allows us to answer the question, "is 1010 the size reasonable?". 1011 1012 * Menu: 1013 1014 * Memory Usage:: 1015 * Initialization:: 1016 * Sections:: 1017 * Symbols:: 1018 * Archives:: 1019 * Formats:: 1020 * Relocations:: 1021 * Core Files:: 1022 * Targets:: 1023 * Architectures:: 1024 * Opening and Closing:: 1025 * Internal:: 1026 * File Caching:: 1027 * Linker Functions:: 1028 * Hash Tables:: 1029 1030 1031 File: bfd.info, Node: Memory Usage, Next: Initialization, Prev: BFD front end, Up: BFD front end 1032 1033 2.4 Memory Usage 1034 ================ 1035 1036 BFD keeps all of its internal structures in obstacks. There is one 1037 obstack per open BFD file, into which the current state is stored. When 1038 a BFD is closed, the obstack is deleted, and so everything which has 1039 been allocated by BFD for the closing file is thrown away. 1040 1041 BFD does not free anything created by an application, but pointers 1042 into `bfd' structures become invalid on a `bfd_close'; for example, 1043 after a `bfd_close' the vector passed to `bfd_canonicalize_symtab' is 1044 still around, since it has been allocated by the application, but the 1045 data that it pointed to are lost. 1046 1047 The general rule is to not close a BFD until all operations dependent 1048 upon data from the BFD have been completed, or all the data from within 1049 the file has been copied. To help with the management of memory, there 1050 is a function (`bfd_alloc_size') which returns the number of bytes in 1051 obstacks associated with the supplied BFD. This could be used to select 1052 the greediest open BFD, close it to reclaim the memory, perform some 1053 operation and reopen the BFD again, to get a fresh copy of the data 1054 structures. 1055 1056 1057 File: bfd.info, Node: Initialization, Next: Sections, Prev: Memory Usage, Up: BFD front end 1058 1059 2.5 Initialization 1060 ================== 1061 1062 2.5.1 Initialization functions 1063 ------------------------------ 1064 1065 These are the functions that handle initializing a BFD. 1066 1067 2.5.1.1 `bfd_init' 1068 .................. 1069 1070 *Synopsis* 1071 void bfd_init (void); 1072 *Description* 1073 This routine must be called before any other BFD function to initialize 1074 magical internal data structures. 1075 1076 1077 File: bfd.info, Node: Sections, Next: Symbols, Prev: Initialization, Up: BFD front end 1078 1079 2.6 Sections 1080 ============ 1081 1082 The raw data contained within a BFD is maintained through the section 1083 abstraction. A single BFD may have any number of sections. It keeps 1084 hold of them by pointing to the first; each one points to the next in 1085 the list. 1086 1087 Sections are supported in BFD in `section.c'. 1088 1089 * Menu: 1090 1091 * Section Input:: 1092 * Section Output:: 1093 * typedef asection:: 1094 * section prototypes:: 1095 1096 1097 File: bfd.info, Node: Section Input, Next: Section Output, Prev: Sections, Up: Sections 1098 1099 2.6.1 Section input 1100 ------------------- 1101 1102 When a BFD is opened for reading, the section structures are created 1103 and attached to the BFD. 1104 1105 Each section has a name which describes the section in the outside 1106 world--for example, `a.out' would contain at least three sections, 1107 called `.text', `.data' and `.bss'. 1108 1109 Names need not be unique; for example a COFF file may have several 1110 sections named `.data'. 1111 1112 Sometimes a BFD will contain more than the "natural" number of 1113 sections. A back end may attach other sections containing constructor 1114 data, or an application may add a section (using `bfd_make_section') to 1115 the sections attached to an already open BFD. For example, the linker 1116 creates an extra section `COMMON' for each input file's BFD to hold 1117 information about common storage. 1118 1119 The raw data is not necessarily read in when the section descriptor 1120 is created. Some targets may leave the data in place until a 1121 `bfd_get_section_contents' call is made. Other back ends may read in 1122 all the data at once. For example, an S-record file has to be read 1123 once to determine the size of the data. An IEEE-695 file doesn't 1124 contain raw data in sections, but data and relocation expressions 1125 intermixed, so the data area has to be parsed to get out the data and 1126 relocations. 1127 1128 1129 File: bfd.info, Node: Section Output, Next: typedef asection, Prev: Section Input, Up: Sections 1130 1131 2.6.2 Section output 1132 -------------------- 1133 1134 To write a new object style BFD, the various sections to be written 1135 have to be created. They are attached to the BFD in the same way as 1136 input sections; data is written to the sections using 1137 `bfd_set_section_contents'. 1138 1139 Any program that creates or combines sections (e.g., the assembler 1140 and linker) must use the `asection' fields `output_section' and 1141 `output_offset' to indicate the file sections to which each section 1142 must be written. (If the section is being created from scratch, 1143 `output_section' should probably point to the section itself and 1144 `output_offset' should probably be zero.) 1145 1146 The data to be written comes from input sections attached (via 1147 `output_section' pointers) to the output sections. The output section 1148 structure can be considered a filter for the input section: the output 1149 section determines the vma of the output data and the name, but the 1150 input section determines the offset into the output section of the data 1151 to be written. 1152 1153 E.g., to create a section "O", starting at 0x100, 0x123 long, 1154 containing two subsections, "A" at offset 0x0 (i.e., at vma 0x100) and 1155 "B" at offset 0x20 (i.e., at vma 0x120) the `asection' structures would 1156 look like: 1157 1158 section name "A" 1159 output_offset 0x00 1160 size 0x20 1161 output_section -----------> section name "O" 1162 | vma 0x100 1163 section name "B" | size 0x123 1164 output_offset 0x20 | 1165 size 0x103 | 1166 output_section --------| 1167 1168 2.6.3 Link orders 1169 ----------------- 1170 1171 The data within a section is stored in a "link_order". These are much 1172 like the fixups in `gas'. The link_order abstraction allows a section 1173 to grow and shrink within itself. 1174 1175 A link_order knows how big it is, and which is the next link_order 1176 and where the raw data for it is; it also points to a list of 1177 relocations which apply to it. 1178 1179 The link_order is used by the linker to perform relaxing on final 1180 code. The compiler creates code which is as big as necessary to make 1181 it work without relaxing, and the user can select whether to relax. 1182 Sometimes relaxing takes a lot of time. The linker runs around the 1183 relocations to see if any are attached to data which can be shrunk, if 1184 so it does it on a link_order by link_order basis. 1185 1186 1187 File: bfd.info, Node: typedef asection, Next: section prototypes, Prev: Section Output, Up: Sections 1188 1189 2.6.4 typedef asection 1190 ---------------------- 1191 1192 Here is the section structure: 1193 1194 1195 typedef struct bfd_section 1196 { 1197 /* The name of the section; the name isn't a copy, the pointer is 1198 the same as that passed to bfd_make_section. */ 1199 const char *name; 1200 1201 /* A unique sequence number. */ 1202 int id; 1203 1204 /* Which section in the bfd; 0..n-1 as sections are created in a bfd. */ 1205 int index; 1206 1207 /* The next section in the list belonging to the BFD, or NULL. */ 1208 struct bfd_section *next; 1209 1210 /* The previous section in the list belonging to the BFD, or NULL. */ 1211 struct bfd_section *prev; 1212 1213 /* The field flags contains attributes of the section. Some 1214 flags are read in from the object file, and some are 1215 synthesized from other information. */ 1216 flagword flags; 1217 1218 #define SEC_NO_FLAGS 0x000 1219 1220 /* Tells the OS to allocate space for this section when loading. 1221 This is clear for a section containing debug information only. */ 1222 #define SEC_ALLOC 0x001 1223 1224 /* Tells the OS to load the section from the file when loading. 1225 This is clear for a .bss section. */ 1226 #define SEC_LOAD 0x002 1227 1228 /* The section contains data still to be relocated, so there is 1229 some relocation information too. */ 1230 #define SEC_RELOC 0x004 1231 1232 /* A signal to the OS that the section contains read only data. */ 1233 #define SEC_READONLY 0x008 1234 1235 /* The section contains code only. */ 1236 #define SEC_CODE 0x010 1237 1238 /* The section contains data only. */ 1239 #define SEC_DATA 0x020 1240 1241 /* The section will reside in ROM. */ 1242 #define SEC_ROM 0x040 1243 1244 /* The section contains constructor information. This section 1245 type is used by the linker to create lists of constructors and 1246 destructors used by `g++'. When a back end sees a symbol 1247 which should be used in a constructor list, it creates a new 1248 section for the type of name (e.g., `__CTOR_LIST__'), attaches 1249 the symbol to it, and builds a relocation. To build the lists 1250 of constructors, all the linker has to do is catenate all the 1251 sections called `__CTOR_LIST__' and relocate the data 1252 contained within - exactly the operations it would peform on 1253 standard data. */ 1254 #define SEC_CONSTRUCTOR 0x080 1255 1256 /* The section has contents - a data section could be 1257 `SEC_ALLOC' | `SEC_HAS_CONTENTS'; a debug section could be 1258 `SEC_HAS_CONTENTS' */ 1259 #define SEC_HAS_CONTENTS 0x100 1260 1261 /* An instruction to the linker to not output the section 1262 even if it has information which would normally be written. */ 1263 #define SEC_NEVER_LOAD 0x200 1264 1265 /* The section contains thread local data. */ 1266 #define SEC_THREAD_LOCAL 0x400 1267 1268 /* The section has GOT references. This flag is only for the 1269 linker, and is currently only used by the elf32-hppa back end. 1270 It will be set if global offset table references were detected 1271 in this section, which indicate to the linker that the section 1272 contains PIC code, and must be handled specially when doing a 1273 static link. */ 1274 #define SEC_HAS_GOT_REF 0x800 1275 1276 /* The section contains common symbols (symbols may be defined 1277 multiple times, the value of a symbol is the amount of 1278 space it requires, and the largest symbol value is the one 1279 used). Most targets have exactly one of these (which we 1280 translate to bfd_com_section_ptr), but ECOFF has two. */ 1281 #define SEC_IS_COMMON 0x1000 1282 1283 /* The section contains only debugging information. For 1284 example, this is set for ELF .debug and .stab sections. 1285 strip tests this flag to see if a section can be 1286 discarded. */ 1287 #define SEC_DEBUGGING 0x2000 1288 1289 /* The contents of this section are held in memory pointed to 1290 by the contents field. This is checked by bfd_get_section_contents, 1291 and the data is retrieved from memory if appropriate. */ 1292 #define SEC_IN_MEMORY 0x4000 1293 1294 /* The contents of this section are to be excluded by the 1295 linker for executable and shared objects unless those 1296 objects are to be further relocated. */ 1297 #define SEC_EXCLUDE 0x8000 1298 1299 /* The contents of this section are to be sorted based on the sum of 1300 the symbol and addend values specified by the associated relocation 1301 entries. Entries without associated relocation entries will be 1302 appended to the end of the section in an unspecified order. */ 1303 #define SEC_SORT_ENTRIES 0x10000 1304 1305 /* When linking, duplicate sections of the same name should be 1306 discarded, rather than being combined into a single section as 1307 is usually done. This is similar to how common symbols are 1308 handled. See SEC_LINK_DUPLICATES below. */ 1309 #define SEC_LINK_ONCE 0x20000 1310 1311 /* If SEC_LINK_ONCE is set, this bitfield describes how the linker 1312 should handle duplicate sections. */ 1313 #define SEC_LINK_DUPLICATES 0x40000 1314 1315 /* This value for SEC_LINK_DUPLICATES means that duplicate 1316 sections with the same name should simply be discarded. */ 1317 #define SEC_LINK_DUPLICATES_DISCARD 0x0 1318 1319 /* This value for SEC_LINK_DUPLICATES means that the linker 1320 should warn if there are any duplicate sections, although 1321 it should still only link one copy. */ 1322 #define SEC_LINK_DUPLICATES_ONE_ONLY 0x80000 1323 1324 /* This value for SEC_LINK_DUPLICATES means that the linker 1325 should warn if any duplicate sections are a different size. */ 1326 #define SEC_LINK_DUPLICATES_SAME_SIZE 0x100000 1327 1328 /* This value for SEC_LINK_DUPLICATES means that the linker 1329 should warn if any duplicate sections contain different 1330 contents. */ 1331 #define SEC_LINK_DUPLICATES_SAME_CONTENTS \ 1332 (SEC_LINK_DUPLICATES_ONE_ONLY | SEC_LINK_DUPLICATES_SAME_SIZE) 1333 1334 /* This section was created by the linker as part of dynamic 1335 relocation or other arcane processing. It is skipped when 1336 going through the first-pass output, trusting that someone 1337 else up the line will take care of it later. */ 1338 #define SEC_LINKER_CREATED 0x200000 1339 1340 /* This section should not be subject to garbage collection. */ 1341 #define SEC_KEEP 0x400000 1342 1343 /* This section contains "short" data, and should be placed 1344 "near" the GP. */ 1345 #define SEC_SMALL_DATA 0x800000 1346 1347 /* Attempt to merge identical entities in the section. 1348 Entity size is given in the entsize field. */ 1349 #define SEC_MERGE 0x1000000 1350 1351 /* If given with SEC_MERGE, entities to merge are zero terminated 1352 strings where entsize specifies character size instead of fixed 1353 size entries. */ 1354 #define SEC_STRINGS 0x2000000 1355 1356 /* This section contains data about section groups. */ 1357 #define SEC_GROUP 0x4000000 1358 1359 /* The section is a COFF shared library section. This flag is 1360 only for the linker. If this type of section appears in 1361 the input file, the linker must copy it to the output file 1362 without changing the vma or size. FIXME: Although this 1363 was originally intended to be general, it really is COFF 1364 specific (and the flag was renamed to indicate this). It 1365 might be cleaner to have some more general mechanism to 1366 allow the back end to control what the linker does with 1367 sections. */ 1368 #define SEC_COFF_SHARED_LIBRARY 0x10000000 1369 1370 /* This section contains data which may be shared with other 1371 executables or shared objects. This is for COFF only. */ 1372 #define SEC_COFF_SHARED 0x20000000 1373 1374 /* When a section with this flag is being linked, then if the size of 1375 the input section is less than a page, it should not cross a page 1376 boundary. If the size of the input section is one page or more, 1377 it should be aligned on a page boundary. This is for TI 1378 TMS320C54X only. */ 1379 #define SEC_TIC54X_BLOCK 0x40000000 1380 1381 /* Conditionally link this section; do not link if there are no 1382 references found to any symbol in the section. This is for TI 1383 TMS320C54X only. */ 1384 #define SEC_TIC54X_CLINK 0x80000000 1385 1386 /* End of section flags. */ 1387 1388 /* Some internal packed boolean fields. */ 1389 1390 /* See the vma field. */ 1391 unsigned int user_set_vma : 1; 1392 1393 /* A mark flag used by some of the linker backends. */ 1394 unsigned int linker_mark : 1; 1395 1396 /* Another mark flag used by some of the linker backends. Set for 1397 output sections that have an input section. */ 1398 unsigned int linker_has_input : 1; 1399 1400 /* Mark flags used by some linker backends for garbage collection. */ 1401 unsigned int gc_mark : 1; 1402 unsigned int gc_mark_from_eh : 1; 1403 1404 /* The following flags are used by the ELF linker. */ 1405 1406 /* Mark sections which have been allocated to segments. */ 1407 unsigned int segment_mark : 1; 1408 1409 /* Type of sec_info information. */ 1410 unsigned int sec_info_type:3; 1411 #define ELF_INFO_TYPE_NONE 0 1412 #define ELF_INFO_TYPE_STABS 1 1413 #define ELF_INFO_TYPE_MERGE 2 1414 #define ELF_INFO_TYPE_EH_FRAME 3 1415 #define ELF_INFO_TYPE_JUST_SYMS 4 1416 1417 /* Nonzero if this section uses RELA relocations, rather than REL. */ 1418 unsigned int use_rela_p:1; 1419 1420 /* Bits used by various backends. The generic code doesn't touch 1421 these fields. */ 1422 1423 /* Nonzero if this section has TLS related relocations. */ 1424 unsigned int has_tls_reloc:1; 1425 1426 /* Nonzero if this section has a gp reloc. */ 1427 unsigned int has_gp_reloc:1; 1428 1429 /* Nonzero if this section needs the relax finalize pass. */ 1430 unsigned int need_finalize_relax:1; 1431 1432 /* Whether relocations have been processed. */ 1433 unsigned int reloc_done : 1; 1434 1435 /* End of internal packed boolean fields. */ 1436 1437 /* The virtual memory address of the section - where it will be 1438 at run time. The symbols are relocated against this. The 1439 user_set_vma flag is maintained by bfd; if it's not set, the 1440 backend can assign addresses (for example, in `a.out', where 1441 the default address for `.data' is dependent on the specific 1442 target and various flags). */ 1443 bfd_vma vma; 1444 1445 /* The load address of the section - where it would be in a 1446 rom image; really only used for writing section header 1447 information. */ 1448 bfd_vma lma; 1449 1450 /* The size of the section in octets, as it will be output. 1451 Contains a value even if the section has no contents (e.g., the 1452 size of `.bss'). */ 1453 bfd_size_type size; 1454 1455 /* For input sections, the original size on disk of the section, in 1456 octets. This field is used by the linker relaxation code. It is 1457 currently only set for sections where the linker relaxation scheme 1458 doesn't cache altered section and reloc contents (stabs, eh_frame, 1459 SEC_MERGE, some coff relaxing targets), and thus the original size 1460 needs to be kept to read the section multiple times. 1461 For output sections, rawsize holds the section size calculated on 1462 a previous linker relaxation pass. */ 1463 bfd_size_type rawsize; 1464 1465 /* If this section is going to be output, then this value is the 1466 offset in *bytes* into the output section of the first byte in the 1467 input section (byte ==> smallest addressable unit on the 1468 target). In most cases, if this was going to start at the 1469 100th octet (8-bit quantity) in the output section, this value 1470 would be 100. However, if the target byte size is 16 bits 1471 (bfd_octets_per_byte is "2"), this value would be 50. */ 1472 bfd_vma output_offset; 1473 1474 /* The output section through which to map on output. */ 1475 struct bfd_section *output_section; 1476 1477 /* The alignment requirement of the section, as an exponent of 2 - 1478 e.g., 3 aligns to 2^3 (or 8). */ 1479 unsigned int alignment_power; 1480 1481 /* If an input section, a pointer to a vector of relocation 1482 records for the data in this section. */ 1483 struct reloc_cache_entry *relocation; 1484 1485 /* If an output section, a pointer to a vector of pointers to 1486 relocation records for the data in this section. */ 1487 struct reloc_cache_entry **orelocation; 1488 1489 /* The number of relocation records in one of the above. */ 1490 unsigned reloc_count; 1491 1492 /* Information below is back end specific - and not always used 1493 or updated. */ 1494 1495 /* File position of section data. */ 1496 file_ptr filepos; 1497 1498 /* File position of relocation info. */ 1499 file_ptr rel_filepos; 1500 1501 /* File position of line data. */ 1502 file_ptr line_filepos; 1503 1504 /* Pointer to data for applications. */ 1505 void *userdata; 1506 1507 /* If the SEC_IN_MEMORY flag is set, this points to the actual 1508 contents. */ 1509 unsigned char *contents; 1510 1511 /* Attached line number information. */ 1512 alent *lineno; 1513 1514 /* Number of line number records. */ 1515 unsigned int lineno_count; 1516 1517 /* Entity size for merging purposes. */ 1518 unsigned int entsize; 1519 1520 /* Points to the kept section if this section is a link-once section, 1521 and is discarded. */ 1522 struct bfd_section *kept_section; 1523 1524 /* When a section is being output, this value changes as more 1525 linenumbers are written out. */ 1526 file_ptr moving_line_filepos; 1527 1528 /* What the section number is in the target world. */ 1529 int target_index; 1530 1531 void *used_by_bfd; 1532 1533 /* If this is a constructor section then here is a list of the 1534 relocations created to relocate items within it. */ 1535 struct relent_chain *constructor_chain; 1536 1537 /* The BFD which owns the section. */ 1538 bfd *owner; 1539 1540 /* A symbol which points at this section only. */ 1541 struct bfd_symbol *symbol; 1542 struct bfd_symbol **symbol_ptr_ptr; 1543 1544 /* Early in the link process, map_head and map_tail are used to build 1545 a list of input sections attached to an output section. Later, 1546 output sections use these fields for a list of bfd_link_order 1547 structs. */ 1548 union { 1549 struct bfd_link_order *link_order; 1550 struct bfd_section *s; 1551 } map_head, map_tail; 1552 } asection; 1553 1554 /* These sections are global, and are managed by BFD. The application 1555 and target back end are not permitted to change the values in 1556 these sections. New code should use the section_ptr macros rather 1557 than referring directly to the const sections. The const sections 1558 may eventually vanish. */ 1559 #define BFD_ABS_SECTION_NAME "*ABS*" 1560 #define BFD_UND_SECTION_NAME "*UND*" 1561 #define BFD_COM_SECTION_NAME "*COM*" 1562 #define BFD_IND_SECTION_NAME "*IND*" 1563 1564 /* The absolute section. */ 1565 extern asection bfd_abs_section; 1566 #define bfd_abs_section_ptr ((asection *) &bfd_abs_section) 1567 #define bfd_is_abs_section(sec) ((sec) == bfd_abs_section_ptr) 1568 /* Pointer to the undefined section. */ 1569 extern asection bfd_und_section; 1570 #define bfd_und_section_ptr ((asection *) &bfd_und_section) 1571 #define bfd_is_und_section(sec) ((sec) == bfd_und_section_ptr) 1572 /* Pointer to the common section. */ 1573 extern asection bfd_com_section; 1574 #define bfd_com_section_ptr ((asection *) &bfd_com_section) 1575 /* Pointer to the indirect section. */ 1576 extern asection bfd_ind_section; 1577 #define bfd_ind_section_ptr ((asection *) &bfd_ind_section) 1578 #define bfd_is_ind_section(sec) ((sec) == bfd_ind_section_ptr) 1579 1580 #define bfd_is_const_section(SEC) \ 1581 ( ((SEC) == bfd_abs_section_ptr) \ 1582 || ((SEC) == bfd_und_section_ptr) \ 1583 || ((SEC) == bfd_com_section_ptr) \ 1584 || ((SEC) == bfd_ind_section_ptr)) 1585 1586 extern const struct bfd_symbol * const bfd_abs_symbol; 1587 extern const struct bfd_symbol * const bfd_com_symbol; 1588 extern const struct bfd_symbol * const bfd_und_symbol; 1589 extern const struct bfd_symbol * const bfd_ind_symbol; 1590 1591 /* Macros to handle insertion and deletion of a bfd's sections. These 1592 only handle the list pointers, ie. do not adjust section_count, 1593 target_index etc. */ 1594 #define bfd_section_list_remove(ABFD, S) \ 1595 do \ 1596 { \ 1597 asection *_s = S; \ 1598 asection *_next = _s->next; \ 1599 asection *_prev = _s->prev; \ 1600 if (_prev) \ 1601 _prev->next = _next; \ 1602 else \ 1603 (ABFD)->sections = _next; \ 1604 if (_next) \ 1605 _next->prev = _prev; \ 1606 else \ 1607 (ABFD)->section_last = _prev; \ 1608 } \ 1609 while (0) 1610 #define bfd_section_list_append(ABFD, S) \ 1611 do \ 1612 { \ 1613 asection *_s = S; \ 1614 bfd *_abfd = ABFD; \ 1615 _s->next = NULL; \ 1616 if (_abfd->section_last) \ 1617 { \ 1618 _s->prev = _abfd->section_last; \ 1619 _abfd->section_last->next = _s; \ 1620 } \ 1621 else \ 1622 { \ 1623 _s->prev = NULL; \ 1624 _abfd->sections = _s; \ 1625 } \ 1626 _abfd->section_last = _s; \ 1627 } \ 1628 while (0) 1629 #define bfd_section_list_prepend(ABFD, S) \ 1630 do \ 1631 { \ 1632 asection *_s = S; \ 1633 bfd *_abfd = ABFD; \ 1634 _s->prev = NULL; \ 1635 if (_abfd->sections) \ 1636 { \ 1637 _s->next = _abfd->sections; \ 1638 _abfd->sections->prev = _s; \ 1639 } \ 1640 else \ 1641 { \ 1642 _s->next = NULL; \ 1643 _abfd->section_last = _s; \ 1644 } \ 1645 _abfd->sections = _s; \ 1646 } \ 1647 while (0) 1648 #define bfd_section_list_insert_after(ABFD, A, S) \ 1649 do \ 1650 { \ 1651 asection *_a = A; \ 1652 asection *_s = S; \ 1653 asection *_next = _a->next; \ 1654 _s->next = _next; \ 1655 _s->prev = _a; \ 1656 _a->next = _s; \ 1657 if (_next) \ 1658 _next->prev = _s; \ 1659 else \ 1660 (ABFD)->section_last = _s; \ 1661 } \ 1662 while (0) 1663 #define bfd_section_list_insert_before(ABFD, B, S) \ 1664 do \ 1665 { \ 1666 asection *_b = B; \ 1667 asection *_s = S; \ 1668 asection *_prev = _b->prev; \ 1669 _s->prev = _prev; \ 1670 _s->next = _b; \ 1671 _b->prev = _s; \ 1672 if (_prev) \ 1673 _prev->next = _s; \ 1674 else \ 1675 (ABFD)->sections = _s; \ 1676 } \ 1677 while (0) 1678 #define bfd_section_removed_from_list(ABFD, S) \ 1679 ((S)->next == NULL ? (ABFD)->section_last != (S) : (S)->next->prev != (S)) 1680 1681 #define BFD_FAKE_SECTION(SEC, FLAGS, SYM, SYM_PTR, NAME, IDX) \ 1682 /* name, id, index, next, prev, flags, user_set_vma, */ \ 1683 { NAME, IDX, 0, NULL, NULL, FLAGS, 0, \ 1684 \ 1685 /* linker_mark, linker_has_input, gc_mark, gc_mark_from_eh, */ \ 1686 0, 0, 1, 0, \ 1687 \ 1688 /* segment_mark, sec_info_type, use_rela_p, has_tls_reloc, */ \ 1689 0, 0, 0, 0, \ 1690 \ 1691 /* has_gp_reloc, need_finalize_relax, reloc_done, */ \ 1692 0, 0, 0, \ 1693 \ 1694 /* vma, lma, size, rawsize */ \ 1695 0, 0, 0, 0, \ 1696 \ 1697 /* output_offset, output_section, alignment_power, */ \ 1698 0, (struct bfd_section *) &SEC, 0, \ 1699 \ 1700 /* relocation, orelocation, reloc_count, filepos, rel_filepos, */ \ 1701 NULL, NULL, 0, 0, 0, \ 1702 \ 1703 /* line_filepos, userdata, contents, lineno, lineno_count, */ \ 1704 0, NULL, NULL, NULL, 0, \ 1705 \ 1706 /* entsize, kept_section, moving_line_filepos, */ \ 1707 0, NULL, 0, \ 1708 \ 1709 /* target_index, used_by_bfd, constructor_chain, owner, */ \ 1710 0, NULL, NULL, NULL, \ 1711 \ 1712 /* symbol, */ \ 1713 (struct bfd_symbol *) SYM, \ 1714 \ 1715 /* symbol_ptr_ptr, */ \ 1716 (struct bfd_symbol **) SYM_PTR, \ 1717 \ 1718 /* map_head, map_tail */ \ 1719 { NULL }, { NULL } \ 1720 } 1721 1722 1723 File: bfd.info, Node: section prototypes, Prev: typedef asection, Up: Sections 1724 1725 2.6.5 Section prototypes 1726 ------------------------ 1727 1728 These are the functions exported by the section handling part of BFD. 1729 1730 2.6.5.1 `bfd_section_list_clear' 1731 ................................ 1732 1733 *Synopsis* 1734 void bfd_section_list_clear (bfd *); 1735 *Description* 1736 Clears the section list, and also resets the section count and hash 1737 table entries. 1738 1739 2.6.5.2 `bfd_get_section_by_name' 1740 ................................. 1741 1742 *Synopsis* 1743 asection *bfd_get_section_by_name (bfd *abfd, const char *name); 1744 *Description* 1745 Run through ABFD and return the one of the `asection's whose name 1746 matches NAME, otherwise `NULL'. *Note Sections::, for more information. 1747 1748 This should only be used in special cases; the normal way to process 1749 all sections of a given name is to use `bfd_map_over_sections' and 1750 `strcmp' on the name (or better yet, base it on the section flags or 1751 something else) for each section. 1752 1753 2.6.5.3 `bfd_get_section_by_name_if' 1754 .................................... 1755 1756 *Synopsis* 1757 asection *bfd_get_section_by_name_if 1758 (bfd *abfd, 1759 const char *name, 1760 bfd_boolean (*func) (bfd *abfd, asection *sect, void *obj), 1761 void *obj); 1762 *Description* 1763 Call the provided function FUNC for each section attached to the BFD 1764 ABFD whose name matches NAME, passing OBJ as an argument. The function 1765 will be called as if by 1766 1767 func (abfd, the_section, obj); 1768 1769 It returns the first section for which FUNC returns true, otherwise 1770 `NULL'. 1771 1772 2.6.5.4 `bfd_get_unique_section_name' 1773 ..................................... 1774 1775 *Synopsis* 1776 char *bfd_get_unique_section_name 1777 (bfd *abfd, const char *templat, int *count); 1778 *Description* 1779 Invent a section name that is unique in ABFD by tacking a dot and a 1780 digit suffix onto the original TEMPLAT. If COUNT is non-NULL, then it 1781 specifies the first number tried as a suffix to generate a unique name. 1782 The value pointed to by COUNT will be incremented in this case. 1783 1784 2.6.5.5 `bfd_make_section_old_way' 1785 .................................. 1786 1787 *Synopsis* 1788 asection *bfd_make_section_old_way (bfd *abfd, const char *name); 1789 *Description* 1790 Create a new empty section called NAME and attach it to the end of the 1791 chain of sections for the BFD ABFD. An attempt to create a section with 1792 a name which is already in use returns its pointer without changing the 1793 section chain. 1794 1795 It has the funny name since this is the way it used to be before it 1796 was rewritten.... 1797 1798 Possible errors are: 1799 * `bfd_error_invalid_operation' - If output has already started for 1800 this BFD. 1801 1802 * `bfd_error_no_memory' - If memory allocation fails. 1803 1804 2.6.5.6 `bfd_make_section_anyway_with_flags' 1805 ............................................ 1806 1807 *Synopsis* 1808 asection *bfd_make_section_anyway_with_flags 1809 (bfd *abfd, const char *name, flagword flags); 1810 *Description* 1811 Create a new empty section called NAME and attach it to the end of the 1812 chain of sections for ABFD. Create a new section even if there is 1813 already a section with that name. Also set the attributes of the new 1814 section to the value FLAGS. 1815 1816 Return `NULL' and set `bfd_error' on error; possible errors are: 1817 * `bfd_error_invalid_operation' - If output has already started for 1818 ABFD. 1819 1820 * `bfd_error_no_memory' - If memory allocation fails. 1821 1822 2.6.5.7 `bfd_make_section_anyway' 1823 ................................. 1824 1825 *Synopsis* 1826 asection *bfd_make_section_anyway (bfd *abfd, const char *name); 1827 *Description* 1828 Create a new empty section called NAME and attach it to the end of the 1829 chain of sections for ABFD. Create a new section even if there is 1830 already a section with that name. 1831 1832 Return `NULL' and set `bfd_error' on error; possible errors are: 1833 * `bfd_error_invalid_operation' - If output has already started for 1834 ABFD. 1835 1836 * `bfd_error_no_memory' - If memory allocation fails. 1837 1838 2.6.5.8 `bfd_make_section_with_flags' 1839 ..................................... 1840 1841 *Synopsis* 1842 asection *bfd_make_section_with_flags 1843 (bfd *, const char *name, flagword flags); 1844 *Description* 1845 Like `bfd_make_section_anyway', but return `NULL' (without calling 1846 bfd_set_error ()) without changing the section chain if there is 1847 already a section named NAME. Also set the attributes of the new 1848 section to the value FLAGS. If there is an error, return `NULL' and set 1849 `bfd_error'. 1850 1851 2.6.5.9 `bfd_make_section' 1852 .......................... 1853 1854 *Synopsis* 1855 asection *bfd_make_section (bfd *, const char *name); 1856 *Description* 1857 Like `bfd_make_section_anyway', but return `NULL' (without calling 1858 bfd_set_error ()) without changing the section chain if there is 1859 already a section named NAME. If there is an error, return `NULL' and 1860 set `bfd_error'. 1861 1862 2.6.5.10 `bfd_set_section_flags' 1863 ................................ 1864 1865 *Synopsis* 1866 bfd_boolean bfd_set_section_flags 1867 (bfd *abfd, asection *sec, flagword flags); 1868 *Description* 1869 Set the attributes of the section SEC in the BFD ABFD to the value 1870 FLAGS. Return `TRUE' on success, `FALSE' on error. Possible error 1871 returns are: 1872 1873 * `bfd_error_invalid_operation' - The section cannot have one or 1874 more of the attributes requested. For example, a .bss section in 1875 `a.out' may not have the `SEC_HAS_CONTENTS' field set. 1876 1877 2.6.5.11 `bfd_map_over_sections' 1878 ................................ 1879 1880 *Synopsis* 1881 void bfd_map_over_sections 1882 (bfd *abfd, 1883 void (*func) (bfd *abfd, asection *sect, void *obj), 1884 void *obj); 1885 *Description* 1886 Call the provided function FUNC for each section attached to the BFD 1887 ABFD, passing OBJ as an argument. The function will be called as if by 1888 1889 func (abfd, the_section, obj); 1890 1891 This is the preferred method for iterating over sections; an 1892 alternative would be to use a loop: 1893 1894 section *p; 1895 for (p = abfd->sections; p != NULL; p = p->next) 1896 func (abfd, p, ...) 1897 1898 2.6.5.12 `bfd_sections_find_if' 1899 ............................... 1900 1901 *Synopsis* 1902 asection *bfd_sections_find_if 1903 (bfd *abfd, 1904 bfd_boolean (*operation) (bfd *abfd, asection *sect, void *obj), 1905 void *obj); 1906 *Description* 1907 Call the provided function OPERATION for each section attached to the 1908 BFD ABFD, passing OBJ as an argument. The function will be called as if 1909 by 1910 1911 operation (abfd, the_section, obj); 1912 1913 It returns the first section for which OPERATION returns true. 1914 1915 2.6.5.13 `bfd_set_section_size' 1916 ............................... 1917 1918 *Synopsis* 1919 bfd_boolean bfd_set_section_size 1920 (bfd *abfd, asection *sec, bfd_size_type val); 1921 *Description* 1922 Set SEC to the size VAL. If the operation is ok, then `TRUE' is 1923 returned, else `FALSE'. 1924 1925 Possible error returns: 1926 * `bfd_error_invalid_operation' - Writing has started to the BFD, so 1927 setting the size is invalid. 1928 1929 2.6.5.14 `bfd_set_section_contents' 1930 ................................... 1931 1932 *Synopsis* 1933 bfd_boolean bfd_set_section_contents 1934 (bfd *abfd, asection *section, const void *data, 1935 file_ptr offset, bfd_size_type count); 1936 *Description* 1937 Sets the contents of the section SECTION in BFD ABFD to the data 1938 starting in memory at DATA. The data is written to the output section 1939 starting at offset OFFSET for COUNT octets. 1940 1941 Normally `TRUE' is returned, else `FALSE'. Possible error returns 1942 are: 1943 * `bfd_error_no_contents' - The output section does not have the 1944 `SEC_HAS_CONTENTS' attribute, so nothing can be written to it. 1945 1946 * and some more too 1947 This routine is front end to the back end function 1948 `_bfd_set_section_contents'. 1949 1950 2.6.5.15 `bfd_get_section_contents' 1951 ................................... 1952 1953 *Synopsis* 1954 bfd_boolean bfd_get_section_contents 1955 (bfd *abfd, asection *section, void *location, file_ptr offset, 1956 bfd_size_type count); 1957 *Description* 1958 Read data from SECTION in BFD ABFD into memory starting at LOCATION. 1959 The data is read at an offset of OFFSET from the start of the input 1960 section, and is read for COUNT bytes. 1961 1962 If the contents of a constructor with the `SEC_CONSTRUCTOR' flag set 1963 are requested or if the section does not have the `SEC_HAS_CONTENTS' 1964 flag set, then the LOCATION is filled with zeroes. If no errors occur, 1965 `TRUE' is returned, else `FALSE'. 1966 1967 2.6.5.16 `bfd_malloc_and_get_section' 1968 ..................................... 1969 1970 *Synopsis* 1971 bfd_boolean bfd_malloc_and_get_section 1972 (bfd *abfd, asection *section, bfd_byte **buf); 1973 *Description* 1974 Read all data from SECTION in BFD ABFD into a buffer, *BUF, malloc'd by 1975 this function. 1976 1977 2.6.5.17 `bfd_copy_private_section_data' 1978 ........................................ 1979 1980 *Synopsis* 1981 bfd_boolean bfd_copy_private_section_data 1982 (bfd *ibfd, asection *isec, bfd *obfd, asection *osec); 1983 *Description* 1984 Copy private section information from ISEC in the BFD IBFD to the 1985 section OSEC in the BFD OBFD. Return `TRUE' on success, `FALSE' on 1986 error. Possible error returns are: 1987 1988 * `bfd_error_no_memory' - Not enough memory exists to create private 1989 data for OSEC. 1990 1991 #define bfd_copy_private_section_data(ibfd, isection, obfd, osection) \ 1992 BFD_SEND (obfd, _bfd_copy_private_section_data, \ 1993 (ibfd, isection, obfd, osection)) 1994 1995 2.6.5.18 `bfd_generic_is_group_section' 1996 ....................................... 1997 1998 *Synopsis* 1999 bfd_boolean bfd_generic_is_group_section (bfd *, const asection *sec); 2000 *Description* 2001 Returns TRUE if SEC is a member of a group. 2002 2003 2.6.5.19 `bfd_generic_discard_group' 2004 .................................... 2005 2006 *Synopsis* 2007 bfd_boolean bfd_generic_discard_group (bfd *abfd, asection *group); 2008 *Description* 2009 Remove all members of GROUP from the output. 2010 2011 2012 File: bfd.info, Node: Symbols, Next: Archives, Prev: Sections, Up: BFD front end 2013 2014 2.7 Symbols 2015 =========== 2016 2017 BFD tries to maintain as much symbol information as it can when it 2018 moves information from file to file. BFD passes information to 2019 applications though the `asymbol' structure. When the application 2020 requests the symbol table, BFD reads the table in the native form and 2021 translates parts of it into the internal format. To maintain more than 2022 the information passed to applications, some targets keep some 2023 information "behind the scenes" in a structure only the particular back 2024 end knows about. For example, the coff back end keeps the original 2025 symbol table structure as well as the canonical structure when a BFD is 2026 read in. On output, the coff back end can reconstruct the output symbol 2027 table so that no information is lost, even information unique to coff 2028 which BFD doesn't know or understand. If a coff symbol table were read, 2029 but were written through an a.out back end, all the coff specific 2030 information would be lost. The symbol table of a BFD is not necessarily 2031 read in until a canonicalize request is made. Then the BFD back end 2032 fills in a table provided by the application with pointers to the 2033 canonical information. To output symbols, the application provides BFD 2034 with a table of pointers to pointers to `asymbol's. This allows 2035 applications like the linker to output a symbol as it was read, since 2036 the "behind the scenes" information will be still available. 2037 2038 * Menu: 2039 2040 * Reading Symbols:: 2041 * Writing Symbols:: 2042 * Mini Symbols:: 2043 * typedef asymbol:: 2044 * symbol handling functions:: 2045 2046 2047 File: bfd.info, Node: Reading Symbols, Next: Writing Symbols, Prev: Symbols, Up: Symbols 2048 2049 2.7.1 Reading symbols 2050 --------------------- 2051 2052 There are two stages to reading a symbol table from a BFD: allocating 2053 storage, and the actual reading process. This is an excerpt from an 2054 application which reads the symbol table: 2055 2056 long storage_needed; 2057 asymbol **symbol_table; 2058 long number_of_symbols; 2059 long i; 2060 2061 storage_needed = bfd_get_symtab_upper_bound (abfd); 2062 2063 if (storage_needed < 0) 2064 FAIL 2065 2066 if (storage_needed == 0) 2067 return; 2068 2069 symbol_table = xmalloc (storage_needed); 2070 ... 2071 number_of_symbols = 2072 bfd_canonicalize_symtab (abfd, symbol_table); 2073 2074 if (number_of_symbols < 0) 2075 FAIL 2076 2077 for (i = 0; i < number_of_symbols; i++) 2078 process_symbol (symbol_table[i]); 2079 2080 All storage for the symbols themselves is in an objalloc connected 2081 to the BFD; it is freed when the BFD is closed. 2082 2083 2084 File: bfd.info, Node: Writing Symbols, Next: Mini Symbols, Prev: Reading Symbols, Up: Symbols 2085 2086 2.7.2 Writing symbols 2087 --------------------- 2088 2089 Writing of a symbol table is automatic when a BFD open for writing is 2090 closed. The application attaches a vector of pointers to pointers to 2091 symbols to the BFD being written, and fills in the symbol count. The 2092 close and cleanup code reads through the table provided and performs 2093 all the necessary operations. The BFD output code must always be 2094 provided with an "owned" symbol: one which has come from another BFD, 2095 or one which has been created using `bfd_make_empty_symbol'. Here is an 2096 example showing the creation of a symbol table with only one element: 2097 2098 #include "bfd.h" 2099 int main (void) 2100 { 2101 bfd *abfd; 2102 asymbol *ptrs[2]; 2103 asymbol *new; 2104 2105 abfd = bfd_openw ("foo","a.out-sunos-big"); 2106 bfd_set_format (abfd, bfd_object); 2107 new = bfd_make_empty_symbol (abfd); 2108 new->name = "dummy_symbol"; 2109 new->section = bfd_make_section_old_way (abfd, ".text"); 2110 new->flags = BSF_GLOBAL; 2111 new->value = 0x12345; 2112 2113 ptrs[0] = new; 2114 ptrs[1] = 0; 2115 2116 bfd_set_symtab (abfd, ptrs, 1); 2117 bfd_close (abfd); 2118 return 0; 2119 } 2120 2121 ./makesym 2122 nm foo 2123 00012345 A dummy_symbol 2124 2125 Many formats cannot represent arbitrary symbol information; for 2126 instance, the `a.out' object format does not allow an arbitrary number 2127 of sections. A symbol pointing to a section which is not one of 2128 `.text', `.data' or `.bss' cannot be described. 2129 2130 2131 File: bfd.info, Node: Mini Symbols, Next: typedef asymbol, Prev: Writing Symbols, Up: Symbols 2132 2133 2.7.3 Mini Symbols 2134 ------------------ 2135 2136 Mini symbols provide read-only access to the symbol table. They use 2137 less memory space, but require more time to access. They can be useful 2138 for tools like nm or objdump, which may have to handle symbol tables of 2139 extremely large executables. 2140 2141 The `bfd_read_minisymbols' function will read the symbols into 2142 memory in an internal form. It will return a `void *' pointer to a 2143 block of memory, a symbol count, and the size of each symbol. The 2144 pointer is allocated using `malloc', and should be freed by the caller 2145 when it is no longer needed. 2146 2147 The function `bfd_minisymbol_to_symbol' will take a pointer to a 2148 minisymbol, and a pointer to a structure returned by 2149 `bfd_make_empty_symbol', and return a `asymbol' structure. The return 2150 value may or may not be the same as the value from 2151 `bfd_make_empty_symbol' which was passed in. 2152 2153 2154 File: bfd.info, Node: typedef asymbol, Next: symbol handling functions, Prev: Mini Symbols, Up: Symbols 2155 2156 2.7.4 typedef asymbol 2157 --------------------- 2158 2159 An `asymbol' has the form: 2160 2161 2162 typedef struct bfd_symbol 2163 { 2164 /* A pointer to the BFD which owns the symbol. This information 2165 is necessary so that a back end can work out what additional 2166 information (invisible to the application writer) is carried 2167 with the symbol. 2168 2169 This field is *almost* redundant, since you can use section->owner 2170 instead, except that some symbols point to the global sections 2171 bfd_{abs,com,und}_section. This could be fixed by making 2172 these globals be per-bfd (or per-target-flavor). FIXME. */ 2173 struct bfd *the_bfd; /* Use bfd_asymbol_bfd(sym) to access this field. */ 2174 2175 /* The text of the symbol. The name is left alone, and not copied; the 2176 application may not alter it. */ 2177 const char *name; 2178 2179 /* The value of the symbol. This really should be a union of a 2180 numeric value with a pointer, since some flags indicate that 2181 a pointer to another symbol is stored here. */ 2182 symvalue value; 2183 2184 /* Attributes of a symbol. */ 2185 #define BSF_NO_FLAGS 0x00 2186 2187 /* The symbol has local scope; `static' in `C'. The value 2188 is the offset into the section of the data. */ 2189 #define BSF_LOCAL 0x01 2190 2191 /* The symbol has global scope; initialized data in `C'. The 2192 value is the offset into the section of the data. */ 2193 #define BSF_GLOBAL 0x02 2194 2195 /* The symbol has global scope and is exported. The value is 2196 the offset into the section of the data. */ 2197 #define BSF_EXPORT BSF_GLOBAL /* No real difference. */ 2198 2199 /* A normal C symbol would be one of: 2200 `BSF_LOCAL', `BSF_FORT_COMM', `BSF_UNDEFINED' or 2201 `BSF_GLOBAL'. */ 2202 2203 /* The symbol is a debugging record. The value has an arbitrary 2204 meaning, unless BSF_DEBUGGING_RELOC is also set. */ 2205 #define BSF_DEBUGGING 0x08 2206 2207 /* The symbol denotes a function entry point. Used in ELF, 2208 perhaps others someday. */ 2209 #define BSF_FUNCTION 0x10 2210 2211 /* Used by the linker. */ 2212 #define BSF_KEEP 0x20 2213 #define BSF_KEEP_G 0x40 2214 2215 /* A weak global symbol, overridable without warnings by 2216 a regular global symbol of the same name. */ 2217 #define BSF_WEAK 0x80 2218 2219 /* This symbol was created to point to a section, e.g. ELF's 2220 STT_SECTION symbols. */ 2221 #define BSF_SECTION_SYM 0x100 2222 2223 /* The symbol used to be a common symbol, but now it is 2224 allocated. */ 2225 #define BSF_OLD_COMMON 0x200 2226 2227 /* The default value for common data. */ 2228 #define BFD_FORT_COMM_DEFAULT_VALUE 0 2229 2230 /* In some files the type of a symbol sometimes alters its 2231 location in an output file - ie in coff a `ISFCN' symbol 2232 which is also `C_EXT' symbol appears where it was 2233 declared and not at the end of a section. This bit is set 2234 by the target BFD part to convey this information. */ 2235 #define BSF_NOT_AT_END 0x400 2236 2237 /* Signal that the symbol is the label of constructor section. */ 2238 #define BSF_CONSTRUCTOR 0x800 2239 2240 /* Signal that the symbol is a warning symbol. The name is a 2241 warning. The name of the next symbol is the one to warn about; 2242 if a reference is made to a symbol with the same name as the next 2243 symbol, a warning is issued by the linker. */ 2244 #define BSF_WARNING 0x1000 2245 2246 /* Signal that the symbol is indirect. This symbol is an indirect 2247 pointer to the symbol with the same name as the next symbol. */ 2248 #define BSF_INDIRECT 0x2000 2249 2250 /* BSF_FILE marks symbols that contain a file name. This is used 2251 for ELF STT_FILE symbols. */ 2252 #define BSF_FILE 0x4000 2253 2254 /* Symbol is from dynamic linking information. */ 2255 #define BSF_DYNAMIC 0x8000 2256 2257 /* The symbol denotes a data object. Used in ELF, and perhaps 2258 others someday. */ 2259 #define BSF_OBJECT 0x10000 2260 2261 /* This symbol is a debugging symbol. The value is the offset 2262 into the section of the data. BSF_DEBUGGING should be set 2263 as well. */ 2264 #define BSF_DEBUGGING_RELOC 0x20000 2265 2266 /* This symbol is thread local. Used in ELF. */ 2267 #define BSF_THREAD_LOCAL 0x40000 2268 2269 flagword flags; 2270 2271 /* A pointer to the section to which this symbol is 2272 relative. This will always be non NULL, there are special 2273 sections for undefined and absolute symbols. */ 2274 struct bfd_section *section; 2275 2276 /* Back end special data. */ 2277 union 2278 { 2279 void *p; 2280 bfd_vma i; 2281 } 2282 udata; 2283 } 2284 asymbol; 2285 2286 2287 File: bfd.info, Node: symbol handling functions, Prev: typedef asymbol, Up: Symbols 2288 2289 2.7.5 Symbol handling functions 2290 ------------------------------- 2291 2292 2.7.5.1 `bfd_get_symtab_upper_bound' 2293 .................................... 2294 2295 *Description* 2296 Return the number of bytes required to store a vector of pointers to 2297 `asymbols' for all the symbols in the BFD ABFD, including a terminal 2298 NULL pointer. If there are no symbols in the BFD, then return 0. If an 2299 error occurs, return -1. 2300 #define bfd_get_symtab_upper_bound(abfd) \ 2301 BFD_SEND (abfd, _bfd_get_symtab_upper_bound, (abfd)) 2302 2303 2.7.5.2 `bfd_is_local_label' 2304 ............................ 2305 2306 *Synopsis* 2307 bfd_boolean bfd_is_local_label (bfd *abfd, asymbol *sym); 2308 *Description* 2309 Return TRUE if the given symbol SYM in the BFD ABFD is a compiler 2310 generated local label, else return FALSE. 2311 2312 2.7.5.3 `bfd_is_local_label_name' 2313 ................................. 2314 2315 *Synopsis* 2316 bfd_boolean bfd_is_local_label_name (bfd *abfd, const char *name); 2317 *Description* 2318 Return TRUE if a symbol with the name NAME in the BFD ABFD is a 2319 compiler generated local label, else return FALSE. This just checks 2320 whether the name has the form of a local label. 2321 #define bfd_is_local_label_name(abfd, name) \ 2322 BFD_SEND (abfd, _bfd_is_local_label_name, (abfd, name)) 2323 2324 2.7.5.4 `bfd_is_target_special_symbol' 2325 ...................................... 2326 2327 *Synopsis* 2328 bfd_boolean bfd_is_target_special_symbol (bfd *abfd, asymbol *sym); 2329 *Description* 2330 Return TRUE iff a symbol SYM in the BFD ABFD is something special to 2331 the particular target represented by the BFD. Such symbols should 2332 normally not be mentioned to the user. 2333 #define bfd_is_target_special_symbol(abfd, sym) \ 2334 BFD_SEND (abfd, _bfd_is_target_special_symbol, (abfd, sym)) 2335 2336 2.7.5.5 `bfd_canonicalize_symtab' 2337 ................................. 2338 2339 *Description* 2340 Read the symbols from the BFD ABFD, and fills in the vector LOCATION 2341 with pointers to the symbols and a trailing NULL. Return the actual 2342 number of symbol pointers, not including the NULL. 2343 #define bfd_canonicalize_symtab(abfd, location) \ 2344 BFD_SEND (abfd, _bfd_canonicalize_symtab, (abfd, location)) 2345 2346 2.7.5.6 `bfd_set_symtab' 2347 ........................ 2348 2349 *Synopsis* 2350 bfd_boolean bfd_set_symtab 2351 (bfd *abfd, asymbol **location, unsigned int count); 2352 *Description* 2353 Arrange that when the output BFD ABFD is closed, the table LOCATION of 2354 COUNT pointers to symbols will be written. 2355 2356 2.7.5.7 `bfd_print_symbol_vandf' 2357 ................................ 2358 2359 *Synopsis* 2360 void bfd_print_symbol_vandf (bfd *abfd, void *file, asymbol *symbol); 2361 *Description* 2362 Print the value and flags of the SYMBOL supplied to the stream FILE. 2363 2364 2.7.5.8 `bfd_make_empty_symbol' 2365 ............................... 2366 2367 *Description* 2368 Create a new `asymbol' structure for the BFD ABFD and return a pointer 2369 to it. 2370 2371 This routine is necessary because each back end has private 2372 information surrounding the `asymbol'. Building your own `asymbol' and 2373 pointing to it will not create the private information, and will cause 2374 problems later on. 2375 #define bfd_make_empty_symbol(abfd) \ 2376 BFD_SEND (abfd, _bfd_make_empty_symbol, (abfd)) 2377 2378 2.7.5.9 `_bfd_generic_make_empty_symbol' 2379 ........................................ 2380 2381 *Synopsis* 2382 asymbol *_bfd_generic_make_empty_symbol (bfd *); 2383 *Description* 2384 Create a new `asymbol' structure for the BFD ABFD and return a pointer 2385 to it. Used by core file routines, binary back-end and anywhere else 2386 where no private info is needed. 2387 2388 2.7.5.10 `bfd_make_debug_symbol' 2389 ................................ 2390 2391 *Description* 2392 Create a new `asymbol' structure for the BFD ABFD, to be used as a 2393 debugging symbol. Further details of its use have yet to be worked out. 2394 #define bfd_make_debug_symbol(abfd,ptr,size) \ 2395 BFD_SEND (abfd, _bfd_make_debug_symbol, (abfd, ptr, size)) 2396 2397 2.7.5.11 `bfd_decode_symclass' 2398 .............................. 2399 2400 *Description* 2401 Return a character corresponding to the symbol class of SYMBOL, or '?' 2402 for an unknown class. 2403 2404 *Synopsis* 2405 int bfd_decode_symclass (asymbol *symbol); 2406 2407 2.7.5.12 `bfd_is_undefined_symclass' 2408 .................................... 2409 2410 *Description* 2411 Returns non-zero if the class symbol returned by bfd_decode_symclass 2412 represents an undefined symbol. Returns zero otherwise. 2413 2414 *Synopsis* 2415 bfd_boolean bfd_is_undefined_symclass (int symclass); 2416 2417 2.7.5.13 `bfd_symbol_info' 2418 .......................... 2419 2420 *Description* 2421 Fill in the basic info about symbol that nm needs. Additional info may 2422 be added by the back-ends after calling this function. 2423 2424 *Synopsis* 2425 void bfd_symbol_info (asymbol *symbol, symbol_info *ret); 2426 2427 2.7.5.14 `bfd_copy_private_symbol_data' 2428 ....................................... 2429 2430 *Synopsis* 2431 bfd_boolean bfd_copy_private_symbol_data 2432 (bfd *ibfd, asymbol *isym, bfd *obfd, asymbol *osym); 2433 *Description* 2434 Copy private symbol information from ISYM in the BFD IBFD to the symbol 2435 OSYM in the BFD OBFD. Return `TRUE' on success, `FALSE' on error. 2436 Possible error returns are: 2437 2438 * `bfd_error_no_memory' - Not enough memory exists to create private 2439 data for OSEC. 2440 2441 #define bfd_copy_private_symbol_data(ibfd, isymbol, obfd, osymbol) \ 2442 BFD_SEND (obfd, _bfd_copy_private_symbol_data, \ 2443 (ibfd, isymbol, obfd, osymbol)) 2444 2445 2446 File: bfd.info, Node: Archives, Next: Formats, Prev: Symbols, Up: BFD front end 2447 2448 2.8 Archives 2449 ============ 2450 2451 *Description* 2452 An archive (or library) is just another BFD. It has a symbol table, 2453 although there's not much a user program will do with it. 2454 2455 The big difference between an archive BFD and an ordinary BFD is 2456 that the archive doesn't have sections. Instead it has a chain of BFDs 2457 that are considered its contents. These BFDs can be manipulated like 2458 any other. The BFDs contained in an archive opened for reading will 2459 all be opened for reading. You may put either input or output BFDs 2460 into an archive opened for output; they will be handled correctly when 2461 the archive is closed. 2462 2463 Use `bfd_openr_next_archived_file' to step through the contents of 2464 an archive opened for input. You don't have to read the entire archive 2465 if you don't want to! Read it until you find what you want. 2466 2467 Archive contents of output BFDs are chained through the `next' 2468 pointer in a BFD. The first one is findable through the `archive_head' 2469 slot of the archive. Set it with `bfd_set_archive_head' (q.v.). A 2470 given BFD may be in only one open output archive at a time. 2471 2472 As expected, the BFD archive code is more general than the archive 2473 code of any given environment. BFD archives may contain files of 2474 different formats (e.g., a.out and coff) and even different 2475 architectures. You may even place archives recursively into archives! 2476 2477 This can cause unexpected confusion, since some archive formats are 2478 more expressive than others. For instance, Intel COFF archives can 2479 preserve long filenames; SunOS a.out archives cannot. If you move a 2480 file from the first to the second format and back again, the filename 2481 may be truncated. Likewise, different a.out environments have different 2482 conventions as to how they truncate filenames, whether they preserve 2483 directory names in filenames, etc. When interoperating with native 2484 tools, be sure your files are homogeneous. 2485 2486 Beware: most of these formats do not react well to the presence of 2487 spaces in filenames. We do the best we can, but can't always handle 2488 this case due to restrictions in the format of archives. Many Unix 2489 utilities are braindead in regards to spaces and such in filenames 2490 anyway, so this shouldn't be much of a restriction. 2491 2492 Archives are supported in BFD in `archive.c'. 2493 2494 2.8.1 Archive functions 2495 ----------------------- 2496 2497 2.8.1.1 `bfd_get_next_mapent' 2498 ............................. 2499 2500 *Synopsis* 2501 symindex bfd_get_next_mapent 2502 (bfd *abfd, symindex previous, carsym **sym); 2503 *Description* 2504 Step through archive ABFD's symbol table (if it has one). Successively 2505 update SYM with the next symbol's information, returning that symbol's 2506 (internal) index into the symbol table. 2507 2508 Supply `BFD_NO_MORE_SYMBOLS' as the PREVIOUS entry to get the first 2509 one; returns `BFD_NO_MORE_SYMBOLS' when you've already got the last one. 2510 2511 A `carsym' is a canonical archive symbol. The only user-visible 2512 element is its name, a null-terminated string. 2513 2514 2.8.1.2 `bfd_set_archive_head' 2515 .............................. 2516 2517 *Synopsis* 2518 bfd_boolean bfd_set_archive_head (bfd *output, bfd *new_head); 2519 *Description* 2520 Set the head of the chain of BFDs contained in the archive OUTPUT to 2521 NEW_HEAD. 2522 2523 2.8.1.3 `bfd_openr_next_archived_file' 2524 ...................................... 2525 2526 *Synopsis* 2527 bfd *bfd_openr_next_archived_file (bfd *archive, bfd *previous); 2528 *Description* 2529 Provided a BFD, ARCHIVE, containing an archive and NULL, open an input 2530 BFD on the first contained element and returns that. Subsequent calls 2531 should pass the archive and the previous return value to return a 2532 created BFD to the next contained element. NULL is returned when there 2533 are no more. 2534 2535 2536 File: bfd.info, Node: Formats, Next: Relocations, Prev: Archives, Up: BFD front end 2537 2538 2.9 File formats 2539 ================ 2540 2541 A format is a BFD concept of high level file contents type. The formats 2542 supported by BFD are: 2543 2544 * `bfd_object' 2545 The BFD may contain data, symbols, relocations and debug info. 2546 2547 * `bfd_archive' 2548 The BFD contains other BFDs and an optional index. 2549 2550 * `bfd_core' 2551 The BFD contains the result of an executable core dump. 2552 2553 2.9.1 File format functions 2554 --------------------------- 2555 2556 2.9.1.1 `bfd_check_format' 2557 .......................... 2558 2559 *Synopsis* 2560 bfd_boolean bfd_check_format (bfd *abfd, bfd_format format); 2561 *Description* 2562 Verify if the file attached to the BFD ABFD is compatible with the 2563 format FORMAT (i.e., one of `bfd_object', `bfd_archive' or `bfd_core'). 2564 2565 If the BFD has been set to a specific target before the call, only 2566 the named target and format combination is checked. If the target has 2567 not been set, or has been set to `default', then all the known target 2568 backends is interrogated to determine a match. If the default target 2569 matches, it is used. If not, exactly one target must recognize the 2570 file, or an error results. 2571 2572 The function returns `TRUE' on success, otherwise `FALSE' with one 2573 of the following error codes: 2574 2575 * `bfd_error_invalid_operation' - if `format' is not one of 2576 `bfd_object', `bfd_archive' or `bfd_core'. 2577 2578 * `bfd_error_system_call' - if an error occured during a read - even 2579 some file mismatches can cause bfd_error_system_calls. 2580 2581 * `file_not_recognised' - none of the backends recognised the file 2582 format. 2583 2584 * `bfd_error_file_ambiguously_recognized' - more than one backend 2585 recognised the file format. 2586 2587 2.9.1.2 `bfd_check_format_matches' 2588 .................................. 2589 2590 *Synopsis* 2591 bfd_boolean bfd_check_format_matches 2592 (bfd *abfd, bfd_format format, char ***matching); 2593 *Description* 2594 Like `bfd_check_format', except when it returns FALSE with `bfd_errno' 2595 set to `bfd_error_file_ambiguously_recognized'. In that case, if 2596 MATCHING is not NULL, it will be filled in with a NULL-terminated list 2597 of the names of the formats that matched, allocated with `malloc'. 2598 Then the user may choose a format and try again. 2599 2600 When done with the list that MATCHING points to, the caller should 2601 free it. 2602 2603 2.9.1.3 `bfd_set_format' 2604 ........................ 2605 2606 *Synopsis* 2607 bfd_boolean bfd_set_format (bfd *abfd, bfd_format format); 2608 *Description* 2609 This function sets the file format of the BFD ABFD to the format 2610 FORMAT. If the target set in the BFD does not support the format 2611 requested, the format is invalid, or the BFD is not open for writing, 2612 then an error occurs. 2613 2614 2.9.1.4 `bfd_format_string' 2615 ........................... 2616 2617 *Synopsis* 2618 const char *bfd_format_string (bfd_format format); 2619 *Description* 2620 Return a pointer to a const string `invalid', `object', `archive', 2621 `core', or `unknown', depending upon the value of FORMAT. 2622 2623 2624 File: bfd.info, Node: Relocations, Next: Core Files, Prev: Formats, Up: BFD front end 2625 2626 2.10 Relocations 2627 ================ 2628 2629 BFD maintains relocations in much the same way it maintains symbols: 2630 they are left alone until required, then read in en-masse and 2631 translated into an internal form. A common routine 2632 `bfd_perform_relocation' acts upon the canonical form to do the fixup. 2633 2634 Relocations are maintained on a per section basis, while symbols are 2635 maintained on a per BFD basis. 2636 2637 All that a back end has to do to fit the BFD interface is to create 2638 a `struct reloc_cache_entry' for each relocation in a particular 2639 section, and fill in the right bits of the structures. 2640 2641 * Menu: 2642 2643 * typedef arelent:: 2644 * howto manager:: 2645 2646 2647 File: bfd.info, Node: typedef arelent, Next: howto manager, Prev: Relocations, Up: Relocations 2648 2649 2.10.1 typedef arelent 2650 ---------------------- 2651 2652 This is the structure of a relocation entry: 2653 2654 2655 typedef enum bfd_reloc_status 2656 { 2657 /* No errors detected. */ 2658 bfd_reloc_ok, 2659 2660 /* The relocation was performed, but there was an overflow. */ 2661 bfd_reloc_overflow, 2662 2663 /* The address to relocate was not within the section supplied. */ 2664 bfd_reloc_outofrange, 2665 2666 /* Used by special functions. */ 2667 bfd_reloc_continue, 2668 2669 /* Unsupported relocation size requested. */ 2670 bfd_reloc_notsupported, 2671 2672 /* Unused. */ 2673 bfd_reloc_other, 2674 2675 /* The symbol to relocate against was undefined. */ 2676 bfd_reloc_undefined, 2677 2678 /* The relocation was performed, but may not be ok - presently 2679 generated only when linking i960 coff files with i960 b.out 2680 symbols. If this type is returned, the error_message argument 2681 to bfd_perform_relocation will be set. */ 2682 bfd_reloc_dangerous 2683 } 2684 bfd_reloc_status_type; 2685 2686 2687 typedef struct reloc_cache_entry 2688 { 2689 /* A pointer into the canonical table of pointers. */ 2690 struct bfd_symbol **sym_ptr_ptr; 2691 2692 /* offset in section. */ 2693 bfd_size_type address; 2694 2695 /* addend for relocation value. */ 2696 bfd_vma addend; 2697 2698 /* Pointer to how to perform the required relocation. */ 2699 reloc_howto_type *howto; 2700 2701 } 2702 arelent; 2703 *Description* 2704 Here is a description of each of the fields within an `arelent': 2705 2706 * `sym_ptr_ptr' 2707 The symbol table pointer points to a pointer to the symbol 2708 associated with the relocation request. It is the pointer into the 2709 table returned by the back end's `canonicalize_symtab' action. *Note 2710 Symbols::. The symbol is referenced through a pointer to a pointer so 2711 that tools like the linker can fix up all the symbols of the same name 2712 by modifying only one pointer. The relocation routine looks in the 2713 symbol and uses the base of the section the symbol is attached to and 2714 the value of the symbol as the initial relocation offset. If the symbol 2715 pointer is zero, then the section provided is looked up. 2716 2717 * `address' 2718 The `address' field gives the offset in bytes from the base of the 2719 section data which owns the relocation record to the first byte of 2720 relocatable information. The actual data relocated will be relative to 2721 this point; for example, a relocation type which modifies the bottom 2722 two bytes of a four byte word would not touch the first byte pointed to 2723 in a big endian world. 2724 2725 * `addend' 2726 The `addend' is a value provided by the back end to be added (!) to 2727 the relocation offset. Its interpretation is dependent upon the howto. 2728 For example, on the 68k the code: 2729 2730 char foo[]; 2731 main() 2732 { 2733 return foo[0x12345678]; 2734 } 2735 2736 Could be compiled into: 2737 2738 linkw fp,#-4 2739 moveb @#12345678,d0 2740 extbl d0 2741 unlk fp 2742 rts 2743 2744 This could create a reloc pointing to `foo', but leave the offset in 2745 the data, something like: 2746 2747 RELOCATION RECORDS FOR [.text]: 2748 offset type value 2749 00000006 32 _foo 2750 2751 00000000 4e56 fffc ; linkw fp,#-4 2752 00000004 1039 1234 5678 ; moveb @#12345678,d0 2753 0000000a 49c0 ; extbl d0 2754 0000000c 4e5e ; unlk fp 2755 0000000e 4e75 ; rts 2756 2757 Using coff and an 88k, some instructions don't have enough space in 2758 them to represent the full address range, and pointers have to be 2759 loaded in two parts. So you'd get something like: 2760 2761 or.u r13,r0,hi16(_foo+0x12345678) 2762 ld.b r2,r13,lo16(_foo+0x12345678) 2763 jmp r1 2764 2765 This should create two relocs, both pointing to `_foo', and with 2766 0x12340000 in their addend field. The data would consist of: 2767 2768 RELOCATION RECORDS FOR [.text]: 2769 offset type value 2770 00000002 HVRT16 _foo+0x12340000 2771 00000006 LVRT16 _foo+0x12340000 2772 2773 00000000 5da05678 ; or.u r13,r0,0x5678 2774 00000004 1c4d5678 ; ld.b r2,r13,0x5678 2775 00000008 f400c001 ; jmp r1 2776 2777 The relocation routine digs out the value from the data, adds it to 2778 the addend to get the original offset, and then adds the value of 2779 `_foo'. Note that all 32 bits have to be kept around somewhere, to cope 2780 with carry from bit 15 to bit 16. 2781 2782 One further example is the sparc and the a.out format. The sparc has 2783 a similar problem to the 88k, in that some instructions don't have room 2784 for an entire offset, but on the sparc the parts are created in odd 2785 sized lumps. The designers of the a.out format chose to not use the 2786 data within the section for storing part of the offset; all the offset 2787 is kept within the reloc. Anything in the data should be ignored. 2788 2789 save %sp,-112,%sp 2790 sethi %hi(_foo+0x12345678),%g2 2791 ldsb [%g2+%lo(_foo+0x12345678)],%i0 2792 ret 2793 restore 2794 2795 Both relocs contain a pointer to `foo', and the offsets contain junk. 2796 2797 RELOCATION RECORDS FOR [.text]: 2798 offset type value 2799 00000004 HI22 _foo+0x12345678 2800 00000008 LO10 _foo+0x12345678 2801 2802 00000000 9de3bf90 ; save %sp,-112,%sp 2803 00000004 05000000 ; sethi %hi(_foo+0),%g2 2804 00000008 f048a000 ; ldsb [%g2+%lo(_foo+0)],%i0 2805 0000000c 81c7e008 ; ret 2806 00000010 81e80000 ; restore 2807 2808 * `howto' 2809 The `howto' field can be imagined as a relocation instruction. It is 2810 a pointer to a structure which contains information on what to do with 2811 all of the other information in the reloc record and data section. A 2812 back end would normally have a relocation instruction set and turn 2813 relocations into pointers to the correct structure on input - but it 2814 would be possible to create each howto field on demand. 2815 2816 2.10.1.1 `enum complain_overflow' 2817 ................................. 2818 2819 Indicates what sort of overflow checking should be done when performing 2820 a relocation. 2821 2822 2823 enum complain_overflow 2824 { 2825 /* Do not complain on overflow. */ 2826 complain_overflow_dont, 2827 2828 /* Complain if the value overflows when considered as a signed 2829 number one bit larger than the field. ie. A bitfield of N bits 2830 is allowed to represent -2**n to 2**n-1. */ 2831 complain_overflow_bitfield, 2832 2833 /* Complain if the value overflows when considered as a signed 2834 number. */ 2835 complain_overflow_signed, 2836 2837 /* Complain if the value overflows when considered as an 2838 unsigned number. */ 2839 complain_overflow_unsigned 2840 }; 2841 2842 2.10.1.2 `reloc_howto_type' 2843 ........................... 2844 2845 The `reloc_howto_type' is a structure which contains all the 2846 information that libbfd needs to know to tie up a back end's data. 2847 2848 struct bfd_symbol; /* Forward declaration. */ 2849 2850 struct reloc_howto_struct 2851 { 2852 /* The type field has mainly a documentary use - the back end can 2853 do what it wants with it, though normally the back end's 2854 external idea of what a reloc number is stored 2855 in this field. For example, a PC relative word relocation 2856 in a coff environment has the type 023 - because that's 2857 what the outside world calls a R_PCRWORD reloc. */ 2858 unsigned int type; 2859 2860 /* The value the final relocation is shifted right by. This drops 2861 unwanted data from the relocation. */ 2862 unsigned int rightshift; 2863 2864 /* The size of the item to be relocated. This is *not* a 2865 power-of-two measure. To get the number of bytes operated 2866 on by a type of relocation, use bfd_get_reloc_size. */ 2867 int size; 2868 2869 /* The number of bits in the item to be relocated. This is used 2870 when doing overflow checking. */ 2871 unsigned int bitsize; 2872 2873 /* Notes that the relocation is relative to the location in the 2874 data section of the addend. The relocation function will 2875 subtract from the relocation value the address of the location 2876 being relocated. */ 2877 bfd_boolean pc_relative; 2878 2879 /* The bit position of the reloc value in the destination. 2880 The relocated value is left shifted by this amount. */ 2881 unsigned int bitpos; 2882 2883 /* What type of overflow error should be checked for when 2884 relocating. */ 2885 enum complain_overflow complain_on_overflow; 2886 2887 /* If this field is non null, then the supplied function is 2888 called rather than the normal function. This allows really 2889 strange relocation methods to be accommodated (e.g., i960 callj 2890 instructions). */ 2891 bfd_reloc_status_type (*special_function) 2892 (bfd *, arelent *, struct bfd_symbol *, void *, asection *, 2893 bfd *, char **); 2894 2895 /* The textual name of the relocation type. */ 2896 char *name; 2897 2898 /* Some formats record a relocation addend in the section contents 2899 rather than with the relocation. For ELF formats this is the 2900 distinction between USE_REL and USE_RELA (though the code checks 2901 for USE_REL == 1/0). The value of this field is TRUE if the 2902 addend is recorded with the section contents; when performing a 2903 partial link (ld -r) the section contents (the data) will be 2904 modified. The value of this field is FALSE if addends are 2905 recorded with the relocation (in arelent.addend); when performing 2906 a partial link the relocation will be modified. 2907 All relocations for all ELF USE_RELA targets should set this field 2908 to FALSE (values of TRUE should be looked on with suspicion). 2909 However, the converse is not true: not all relocations of all ELF 2910 USE_REL targets set this field to TRUE. Why this is so is peculiar 2911 to each particular target. For relocs that aren't used in partial 2912 links (e.g. GOT stuff) it doesn't matter what this is set to. */ 2913 bfd_boolean partial_inplace; 2914 2915 /* src_mask selects the part of the instruction (or data) to be used 2916 in the relocation sum. If the target relocations don't have an 2917 addend in the reloc, eg. ELF USE_REL, src_mask will normally equal 2918 dst_mask to extract the addend from the section contents. If 2919 relocations do have an addend in the reloc, eg. ELF USE_RELA, this 2920 field should be zero. Non-zero values for ELF USE_RELA targets are 2921 bogus as in those cases the value in the dst_mask part of the 2922 section contents should be treated as garbage. */ 2923 bfd_vma src_mask; 2924 2925 /* dst_mask selects which parts of the instruction (or data) are 2926 replaced with a relocated value. */ 2927 bfd_vma dst_mask; 2928 2929 /* When some formats create PC relative instructions, they leave 2930 the value of the pc of the place being relocated in the offset 2931 slot of the instruction, so that a PC relative relocation can 2932 be made just by adding in an ordinary offset (e.g., sun3 a.out). 2933 Some formats leave the displacement part of an instruction 2934 empty (e.g., m88k bcs); this flag signals the fact. */ 2935 bfd_boolean pcrel_offset; 2936 }; 2937 2938 2.10.1.3 `The HOWTO Macro' 2939 .......................... 2940 2941 *Description* 2942 The HOWTO define is horrible and will go away. 2943 #define HOWTO(C, R, S, B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC) \ 2944 { (unsigned) C, R, S, B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC } 2945 2946 *Description* 2947 And will be replaced with the totally magic way. But for the moment, we 2948 are compatible, so do it this way. 2949 #define NEWHOWTO(FUNCTION, NAME, SIZE, REL, IN) \ 2950 HOWTO (0, 0, SIZE, 0, REL, 0, complain_overflow_dont, FUNCTION, \ 2951 NAME, FALSE, 0, 0, IN) 2952 2953 *Description* 2954 This is used to fill in an empty howto entry in an array. 2955 #define EMPTY_HOWTO(C) \ 2956 HOWTO ((C), 0, 0, 0, FALSE, 0, complain_overflow_dont, NULL, \ 2957 NULL, FALSE, 0, 0, FALSE) 2958 2959 *Description* 2960 Helper routine to turn a symbol into a relocation value. 2961 #define HOWTO_PREPARE(relocation, symbol) \ 2962 { \ 2963 if (symbol != NULL) \ 2964 { \ 2965 if (bfd_is_com_section (symbol->section)) \ 2966 { \ 2967 relocation = 0; \ 2968 } \ 2969 else \ 2970 { \ 2971 relocation = symbol->value; \ 2972 } \ 2973 } \ 2974 } 2975 2976 2.10.1.4 `bfd_get_reloc_size' 2977 ............................. 2978 2979 *Synopsis* 2980 unsigned int bfd_get_reloc_size (reloc_howto_type *); 2981 *Description* 2982 For a reloc_howto_type that operates on a fixed number of bytes, this 2983 returns the number of bytes operated on. 2984 2985 2.10.1.5 `arelent_chain' 2986 ........................ 2987 2988 *Description* 2989 How relocs are tied together in an `asection': 2990 typedef struct relent_chain 2991 { 2992 arelent relent; 2993 struct relent_chain *next; 2994 } 2995 arelent_chain; 2996 2997 2.10.1.6 `bfd_check_overflow' 2998 ............................. 2999 3000 *Synopsis* 3001 bfd_reloc_status_type bfd_check_overflow 3002 (enum complain_overflow how, 3003 unsigned int bitsize, 3004 unsigned int rightshift, 3005 unsigned int addrsize, 3006 bfd_vma relocation); 3007 *Description* 3008 Perform overflow checking on RELOCATION which has BITSIZE significant 3009 bits and will be shifted right by RIGHTSHIFT bits, on a machine with 3010 addresses containing ADDRSIZE significant bits. The result is either of 3011 `bfd_reloc_ok' or `bfd_reloc_overflow'. 3012 3013 2.10.1.7 `bfd_perform_relocation' 3014 ................................. 3015 3016 *Synopsis* 3017 bfd_reloc_status_type bfd_perform_relocation 3018 (bfd *abfd, 3019 arelent *reloc_entry, 3020 void *data, 3021 asection *input_section, 3022 bfd *output_bfd, 3023 char **error_message); 3024 *Description* 3025 If OUTPUT_BFD is supplied to this function, the generated image will be 3026 relocatable; the relocations are copied to the output file after they 3027 have been changed to reflect the new state of the world. There are two 3028 ways of reflecting the results of partial linkage in an output file: by 3029 modifying the output data in place, and by modifying the relocation 3030 record. Some native formats (e.g., basic a.out and basic coff) have no 3031 way of specifying an addend in the relocation type, so the addend has 3032 to go in the output data. This is no big deal since in these formats 3033 the output data slot will always be big enough for the addend. Complex 3034 reloc types with addends were invented to solve just this problem. The 3035 ERROR_MESSAGE argument is set to an error message if this return 3036 `bfd_reloc_dangerous'. 3037 3038 2.10.1.8 `bfd_install_relocation' 3039 ................................. 3040 3041 *Synopsis* 3042 bfd_reloc_status_type bfd_install_relocation 3043 (bfd *abfd, 3044 arelent *reloc_entry, 3045 void *data, bfd_vma data_start, 3046 asection *input_section, 3047 char **error_message); 3048 *Description* 3049 This looks remarkably like `bfd_perform_relocation', except it does not 3050 expect that the section contents have been filled in. I.e., it's 3051 suitable for use when creating, rather than applying a relocation. 3052 3053 For now, this function should be considered reserved for the 3054 assembler. 3055 3056 3057 File: bfd.info, Node: howto manager, Prev: typedef arelent, Up: Relocations 3058 3059 2.10.2 The howto manager 3060 ------------------------ 3061 3062 When an application wants to create a relocation, but doesn't know what 3063 the target machine might call it, it can find out by using this bit of 3064 code. 3065 3066 2.10.2.1 `bfd_reloc_code_type' 3067 .............................. 3068 3069 *Description* 3070 The insides of a reloc code. The idea is that, eventually, there will 3071 be one enumerator for every type of relocation we ever do. Pass one of 3072 these values to `bfd_reloc_type_lookup', and it'll return a howto 3073 pointer. 3074 3075 This does mean that the application must determine the correct 3076 enumerator value; you can't get a howto pointer from a random set of 3077 attributes. 3078 3079 Here are the possible values for `enum bfd_reloc_code_real': 3080 3081 -- : BFD_RELOC_64 3082 -- : BFD_RELOC_32 3083 -- : BFD_RELOC_26 3084 -- : BFD_RELOC_24 3085 -- : BFD_RELOC_16 3086 -- : BFD_RELOC_14 3087 -- : BFD_RELOC_8 3088 Basic absolute relocations of N bits. 3089 3090 -- : BFD_RELOC_64_PCREL 3091 -- : BFD_RELOC_32_PCREL 3092 -- : BFD_RELOC_24_PCREL 3093 -- : BFD_RELOC_16_PCREL 3094 -- : BFD_RELOC_12_PCREL 3095 -- : BFD_RELOC_8_PCREL 3096 PC-relative relocations. Sometimes these are relative to the 3097 address of the relocation itself; sometimes they are relative to 3098 the start of the section containing the relocation. It depends on 3099 the specific target. 3100 3101 The 24-bit relocation is used in some Intel 960 configurations. 3102 3103 -- : BFD_RELOC_32_SECREL 3104 Section relative relocations. Some targets need this for DWARF2. 3105 3106 -- : BFD_RELOC_32_GOT_PCREL 3107 -- : BFD_RELOC_16_GOT_PCREL 3108 -- : BFD_RELOC_8_GOT_PCREL 3109 -- : BFD_RELOC_32_GOTOFF 3110 -- : BFD_RELOC_16_GOTOFF 3111 -- : BFD_RELOC_LO16_GOTOFF 3112 -- : BFD_RELOC_HI16_GOTOFF 3113 -- : BFD_RELOC_HI16_S_GOTOFF 3114 -- : BFD_RELOC_8_GOTOFF 3115 -- : BFD_RELOC_64_PLT_PCREL 3116 -- : BFD_RELOC_32_PLT_PCREL 3117 -- : BFD_RELOC_24_PLT_PCREL 3118 -- : BFD_RELOC_16_PLT_PCREL 3119 -- : BFD_RELOC_8_PLT_PCREL 3120 -- : BFD_RELOC_64_PLTOFF 3121 -- : BFD_RELOC_32_PLTOFF 3122 -- : BFD_RELOC_16_PLTOFF 3123 -- : BFD_RELOC_LO16_PLTOFF 3124 -- : BFD_RELOC_HI16_PLTOFF 3125 -- : BFD_RELOC_HI16_S_PLTOFF 3126 -- : BFD_RELOC_8_PLTOFF 3127 For ELF. 3128 3129 -- : BFD_RELOC_68K_GLOB_DAT 3130 -- : BFD_RELOC_68K_JMP_SLOT 3131 -- : BFD_RELOC_68K_RELATIVE 3132 Relocations used by 68K ELF. 3133 3134 -- : BFD_RELOC_32_BASEREL 3135 -- : BFD_RELOC_16_BASEREL 3136 -- : BFD_RELOC_LO16_BASEREL 3137 -- : BFD_RELOC_HI16_BASEREL 3138 -- : BFD_RELOC_HI16_S_BASEREL 3139 -- : BFD_RELOC_8_BASEREL 3140 -- : BFD_RELOC_RVA 3141 Linkage-table relative. 3142 3143 -- : BFD_RELOC_8_FFnn 3144 Absolute 8-bit relocation, but used to form an address like 0xFFnn. 3145 3146 -- : BFD_RELOC_32_PCREL_S2 3147 -- : BFD_RELOC_16_PCREL_S2 3148 -- : BFD_RELOC_23_PCREL_S2 3149 These PC-relative relocations are stored as word displacements - 3150 i.e., byte displacements shifted right two bits. The 30-bit word 3151 displacement (<<32_PCREL_S2>> - 32 bits, shifted 2) is used on the 3152 SPARC. (SPARC tools generally refer to this as <<WDISP30>>.) The 3153 signed 16-bit displacement is used on the MIPS, and the 23-bit 3154 displacement is used on the Alpha. 3155 3156 -- : BFD_RELOC_HI22 3157 -- : BFD_RELOC_LO10 3158 High 22 bits and low 10 bits of 32-bit value, placed into lower 3159 bits of the target word. These are used on the SPARC. 3160 3161 -- : BFD_RELOC_GPREL16 3162 -- : BFD_RELOC_GPREL32 3163 For systems that allocate a Global Pointer register, these are 3164 displacements off that register. These relocation types are 3165 handled specially, because the value the register will have is 3166 decided relatively late. 3167 3168 -- : BFD_RELOC_I960_CALLJ 3169 Reloc types used for i960/b.out. 3170 3171 -- : BFD_RELOC_NONE 3172 -- : BFD_RELOC_SPARC_WDISP22 3173 -- : BFD_RELOC_SPARC22 3174 -- : BFD_RELOC_SPARC13 3175 -- : BFD_RELOC_SPARC_GOT10 3176 -- : BFD_RELOC_SPARC_GOT13 3177 -- : BFD_RELOC_SPARC_GOT22 3178 -- : BFD_RELOC_SPARC_PC10 3179 -- : BFD_RELOC_SPARC_PC22 3180 -- : BFD_RELOC_SPARC_WPLT30 3181 -- : BFD_RELOC_SPARC_COPY 3182 -- : BFD_RELOC_SPARC_GLOB_DAT 3183 -- : BFD_RELOC_SPARC_JMP_SLOT 3184 -- : BFD_RELOC_SPARC_RELATIVE 3185 -- : BFD_RELOC_SPARC_UA16 3186 -- : BFD_RELOC_SPARC_UA32 3187 -- : BFD_RELOC_SPARC_UA64 3188 SPARC ELF relocations. There is probably some overlap with other 3189 relocation types already defined. 3190 3191 -- : BFD_RELOC_SPARC_BASE13 3192 -- : BFD_RELOC_SPARC_BASE22 3193 I think these are specific to SPARC a.out (e.g., Sun 4). 3194 3195 -- : BFD_RELOC_SPARC_64 3196 -- : BFD_RELOC_SPARC_10 3197 -- : BFD_RELOC_SPARC_11 3198 -- : BFD_RELOC_SPARC_OLO10 3199 -- : BFD_RELOC_SPARC_HH22 3200 -- : BFD_RELOC_SPARC_HM10 3201 -- : BFD_RELOC_SPARC_LM22 3202 -- : BFD_RELOC_SPARC_PC_HH22 3203 -- : BFD_RELOC_SPARC_PC_HM10 3204 -- : BFD_RELOC_SPARC_PC_LM22 3205 -- : BFD_RELOC_SPARC_WDISP16 3206 -- : BFD_RELOC_SPARC_WDISP19 3207 -- : BFD_RELOC_SPARC_7 3208 -- : BFD_RELOC_SPARC_6 3209 -- : BFD_RELOC_SPARC_5 3210 -- : BFD_RELOC_SPARC_DISP64 3211 -- : BFD_RELOC_SPARC_PLT32 3212 -- : BFD_RELOC_SPARC_PLT64 3213 -- : BFD_RELOC_SPARC_HIX22 3214 -- : BFD_RELOC_SPARC_LOX10 3215 -- : BFD_RELOC_SPARC_H44 3216 -- : BFD_RELOC_SPARC_M44 3217 -- : BFD_RELOC_SPARC_L44 3218 -- : BFD_RELOC_SPARC_REGISTER 3219 SPARC64 relocations 3220 3221 -- : BFD_RELOC_SPARC_REV32 3222 SPARC little endian relocation 3223 3224 -- : BFD_RELOC_SPARC_TLS_GD_HI22 3225 -- : BFD_RELOC_SPARC_TLS_GD_LO10 3226 -- : BFD_RELOC_SPARC_TLS_GD_ADD 3227 -- : BFD_RELOC_SPARC_TLS_GD_CALL 3228 -- : BFD_RELOC_SPARC_TLS_LDM_HI22 3229 -- : BFD_RELOC_SPARC_TLS_LDM_LO10 3230 -- : BFD_RELOC_SPARC_TLS_LDM_ADD 3231 -- : BFD_RELOC_SPARC_TLS_LDM_CALL 3232 -- : BFD_RELOC_SPARC_TLS_LDO_HIX22 3233 -- : BFD_RELOC_SPARC_TLS_LDO_LOX10 3234 -- : BFD_RELOC_SPARC_TLS_LDO_ADD 3235 -- : BFD_RELOC_SPARC_TLS_IE_HI22 3236 -- : BFD_RELOC_SPARC_TLS_IE_LO10 3237 -- : BFD_RELOC_SPARC_TLS_IE_LD 3238 -- : BFD_RELOC_SPARC_TLS_IE_LDX 3239 -- : BFD_RELOC_SPARC_TLS_IE_ADD 3240 -- : BFD_RELOC_SPARC_TLS_LE_HIX22 3241 -- : BFD_RELOC_SPARC_TLS_LE_LOX10 3242 -- : BFD_RELOC_SPARC_TLS_DTPMOD32 3243 -- : BFD_RELOC_SPARC_TLS_DTPMOD64 3244 -- : BFD_RELOC_SPARC_TLS_DTPOFF32 3245 -- : BFD_RELOC_SPARC_TLS_DTPOFF64 3246 -- : BFD_RELOC_SPARC_TLS_TPOFF32 3247 -- : BFD_RELOC_SPARC_TLS_TPOFF64 3248 SPARC TLS relocations 3249 3250 -- : BFD_RELOC_ALPHA_GPDISP_HI16 3251 Alpha ECOFF and ELF relocations. Some of these treat the symbol or 3252 "addend" in some special way. For GPDISP_HI16 ("gpdisp") 3253 relocations, the symbol is ignored when writing; when reading, it 3254 will be the absolute section symbol. The addend is the 3255 displacement in bytes of the "lda" instruction from the "ldah" 3256 instruction (which is at the address of this reloc). 3257 3258 -- : BFD_RELOC_ALPHA_GPDISP_LO16 3259 For GPDISP_LO16 ("ignore") relocations, the symbol is handled as 3260 with GPDISP_HI16 relocs. The addend is ignored when writing the 3261 relocations out, and is filled in with the file's GP value on 3262 reading, for convenience. 3263 3264 -- : BFD_RELOC_ALPHA_GPDISP 3265 The ELF GPDISP relocation is exactly the same as the GPDISP_HI16 3266 relocation except that there is no accompanying GPDISP_LO16 3267 relocation. 3268 3269 -- : BFD_RELOC_ALPHA_LITERAL 3270 -- : BFD_RELOC_ALPHA_ELF_LITERAL 3271 -- : BFD_RELOC_ALPHA_LITUSE 3272 The Alpha LITERAL/LITUSE relocs are produced by a symbol reference; 3273 the assembler turns it into a LDQ instruction to load the address 3274 of the symbol, and then fills in a register in the real 3275 instruction. 3276 3277 The LITERAL reloc, at the LDQ instruction, refers to the .lita 3278 section symbol. The addend is ignored when writing, but is filled 3279 in with the file's GP value on reading, for convenience, as with 3280 the GPDISP_LO16 reloc. 3281 3282 The ELF_LITERAL reloc is somewhere between 16_GOTOFF and 3283 GPDISP_LO16. It should refer to the symbol to be referenced, as 3284 with 16_GOTOFF, but it generates output not based on the position 3285 within the .got section, but relative to the GP value chosen for 3286 the file during the final link stage. 3287 3288 The LITUSE reloc, on the instruction using the loaded address, 3289 gives information to the linker that it might be able to use to 3290 optimize away some literal section references. The symbol is 3291 ignored (read as the absolute section symbol), and the "addend" 3292 indicates the type of instruction using the register: 1 - "memory" 3293 fmt insn 2 - byte-manipulation (byte offset reg) 3 - jsr (target 3294 of branch) 3295 3296 -- : BFD_RELOC_ALPHA_HINT 3297 The HINT relocation indicates a value that should be filled into 3298 the "hint" field of a jmp/jsr/ret instruction, for possible branch- 3299 prediction logic which may be provided on some processors. 3300 3301 -- : BFD_RELOC_ALPHA_LINKAGE 3302 The LINKAGE relocation outputs a linkage pair in the object file, 3303 which is filled by the linker. 3304 3305 -- : BFD_RELOC_ALPHA_CODEADDR 3306 The CODEADDR relocation outputs a STO_CA in the object file, which 3307 is filled by the linker. 3308 3309 -- : BFD_RELOC_ALPHA_GPREL_HI16 3310 -- : BFD_RELOC_ALPHA_GPREL_LO16 3311 The GPREL_HI/LO relocations together form a 32-bit offset from the 3312 GP register. 3313 3314 -- : BFD_RELOC_ALPHA_BRSGP 3315 Like BFD_RELOC_23_PCREL_S2, except that the source and target must 3316 share a common GP, and the target address is adjusted for 3317 STO_ALPHA_STD_GPLOAD. 3318 3319 -- : BFD_RELOC_ALPHA_TLSGD 3320 -- : BFD_RELOC_ALPHA_TLSLDM 3321 -- : BFD_RELOC_ALPHA_DTPMOD64 3322 -- : BFD_RELOC_ALPHA_GOTDTPREL16 3323 -- : BFD_RELOC_ALPHA_DTPREL64 3324 -- : BFD_RELOC_ALPHA_DTPREL_HI16 3325 -- : BFD_RELOC_ALPHA_DTPREL_LO16 3326 -- : BFD_RELOC_ALPHA_DTPREL16 3327 -- : BFD_RELOC_ALPHA_GOTTPREL16 3328 -- : BFD_RELOC_ALPHA_TPREL64 3329 -- : BFD_RELOC_ALPHA_TPREL_HI16 3330 -- : BFD_RELOC_ALPHA_TPREL_LO16 3331 -- : BFD_RELOC_ALPHA_TPREL16 3332 Alpha thread-local storage relocations. 3333 3334 -- : BFD_RELOC_MIPS_JMP 3335 Bits 27..2 of the relocation address shifted right 2 bits; simple 3336 reloc otherwise. 3337 3338 -- : BFD_RELOC_MIPS16_JMP 3339 The MIPS16 jump instruction. 3340 3341 -- : BFD_RELOC_MIPS16_GPREL 3342 MIPS16 GP relative reloc. 3343 3344 -- : BFD_RELOC_HI16 3345 High 16 bits of 32-bit value; simple reloc. 3346 3347 -- : BFD_RELOC_HI16_S 3348 High 16 bits of 32-bit value but the low 16 bits will be sign 3349 extended and added to form the final result. If the low 16 bits 3350 form a negative number, we need to add one to the high value to 3351 compensate for the borrow when the low bits are added. 3352 3353 -- : BFD_RELOC_LO16 3354 Low 16 bits. 3355 3356 -- : BFD_RELOC_HI16_PCREL 3357 High 16 bits of 32-bit pc-relative value 3358 3359 -- : BFD_RELOC_HI16_S_PCREL 3360 High 16 bits of 32-bit pc-relative value, adjusted 3361 3362 -- : BFD_RELOC_LO16_PCREL 3363 Low 16 bits of pc-relative value 3364 3365 -- : BFD_RELOC_MIPS16_HI16 3366 MIPS16 high 16 bits of 32-bit value. 3367 3368 -- : BFD_RELOC_MIPS16_HI16_S 3369 MIPS16 high 16 bits of 32-bit value but the low 16 bits will be 3370 sign extended and added to form the final result. If the low 16 3371 bits form a negative number, we need to add one to the high value 3372 to compensate for the borrow when the low bits are added. 3373 3374 -- : BFD_RELOC_MIPS16_LO16 3375 MIPS16 low 16 bits. 3376 3377 -- : BFD_RELOC_MIPS_LITERAL 3378 Relocation against a MIPS literal section. 3379 3380 -- : BFD_RELOC_MIPS_GOT16 3381 -- : BFD_RELOC_MIPS_CALL16 3382 -- : BFD_RELOC_MIPS_GOT_HI16 3383 -- : BFD_RELOC_MIPS_GOT_LO16 3384 -- : BFD_RELOC_MIPS_CALL_HI16 3385 -- : BFD_RELOC_MIPS_CALL_LO16 3386 -- : BFD_RELOC_MIPS_SUB 3387 -- : BFD_RELOC_MIPS_GOT_PAGE 3388 -- : BFD_RELOC_MIPS_GOT_OFST 3389 -- : BFD_RELOC_MIPS_GOT_DISP 3390 -- : BFD_RELOC_MIPS_SHIFT5 3391 -- : BFD_RELOC_MIPS_SHIFT6 3392 -- : BFD_RELOC_MIPS_INSERT_A 3393 -- : BFD_RELOC_MIPS_INSERT_B 3394 -- : BFD_RELOC_MIPS_DELETE 3395 -- : BFD_RELOC_MIPS_HIGHEST 3396 -- : BFD_RELOC_MIPS_HIGHER 3397 -- : BFD_RELOC_MIPS_SCN_DISP 3398 -- : BFD_RELOC_MIPS_REL16 3399 -- : BFD_RELOC_MIPS_RELGOT 3400 -- : BFD_RELOC_MIPS_JALR 3401 -- : BFD_RELOC_MIPS_TLS_DTPMOD32 3402 -- : BFD_RELOC_MIPS_TLS_DTPREL32 3403 -- : BFD_RELOC_MIPS_TLS_DTPMOD64 3404 -- : BFD_RELOC_MIPS_TLS_DTPREL64 3405 -- : BFD_RELOC_MIPS_TLS_GD 3406 -- : BFD_RELOC_MIPS_TLS_LDM 3407 -- : BFD_RELOC_MIPS_TLS_DTPREL_HI16 3408 -- : BFD_RELOC_MIPS_TLS_DTPREL_LO16 3409 -- : BFD_RELOC_MIPS_TLS_GOTTPREL 3410 -- : BFD_RELOC_MIPS_TLS_TPREL32 3411 -- : BFD_RELOC_MIPS_TLS_TPREL64 3412 -- : BFD_RELOC_MIPS_TLS_TPREL_HI16 3413 -- : BFD_RELOC_MIPS_TLS_TPREL_LO16 3414 MIPS ELF relocations. 3415 3416 -- : BFD_RELOC_MIPS_COPY 3417 -- : BFD_RELOC_MIPS_JUMP_SLOT 3418 MIPS ELF relocations (VxWorks extensions). 3419 3420 -- : BFD_RELOC_FRV_LABEL16 3421 -- : BFD_RELOC_FRV_LABEL24 3422 -- : BFD_RELOC_FRV_LO16 3423 -- : BFD_RELOC_FRV_HI16 3424 -- : BFD_RELOC_FRV_GPREL12 3425 -- : BFD_RELOC_FRV_GPRELU12 3426 -- : BFD_RELOC_FRV_GPREL32 3427 -- : BFD_RELOC_FRV_GPRELHI 3428 -- : BFD_RELOC_FRV_GPRELLO 3429 -- : BFD_RELOC_FRV_GOT12 3430 -- : BFD_RELOC_FRV_GOTHI 3431 -- : BFD_RELOC_FRV_GOTLO 3432 -- : BFD_RELOC_FRV_FUNCDESC 3433 -- : BFD_RELOC_FRV_FUNCDESC_GOT12 3434 -- : BFD_RELOC_FRV_FUNCDESC_GOTHI 3435 -- : BFD_RELOC_FRV_FUNCDESC_GOTLO 3436 -- : BFD_RELOC_FRV_FUNCDESC_VALUE 3437 -- : BFD_RELOC_FRV_FUNCDESC_GOTOFF12 3438 -- : BFD_RELOC_FRV_FUNCDESC_GOTOFFHI 3439 -- : BFD_RELOC_FRV_FUNCDESC_GOTOFFLO 3440 -- : BFD_RELOC_FRV_GOTOFF12 3441 -- : BFD_RELOC_FRV_GOTOFFHI 3442 -- : BFD_RELOC_FRV_GOTOFFLO 3443 -- : BFD_RELOC_FRV_GETTLSOFF 3444 -- : BFD_RELOC_FRV_TLSDESC_VALUE 3445 -- : BFD_RELOC_FRV_GOTTLSDESC12 3446 -- : BFD_RELOC_FRV_GOTTLSDESCHI 3447 -- : BFD_RELOC_FRV_GOTTLSDESCLO 3448 -- : BFD_RELOC_FRV_TLSMOFF12 3449 -- : BFD_RELOC_FRV_TLSMOFFHI 3450 -- : BFD_RELOC_FRV_TLSMOFFLO 3451 -- : BFD_RELOC_FRV_GOTTLSOFF12 3452 -- : BFD_RELOC_FRV_GOTTLSOFFHI 3453 -- : BFD_RELOC_FRV_GOTTLSOFFLO 3454 -- : BFD_RELOC_FRV_TLSOFF 3455 -- : BFD_RELOC_FRV_TLSDESC_RELAX 3456 -- : BFD_RELOC_FRV_GETTLSOFF_RELAX 3457 -- : BFD_RELOC_FRV_TLSOFF_RELAX 3458 -- : BFD_RELOC_FRV_TLSMOFF 3459 Fujitsu Frv Relocations. 3460 3461 -- : BFD_RELOC_MN10300_GOTOFF24 3462 This is a 24bit GOT-relative reloc for the mn10300. 3463 3464 -- : BFD_RELOC_MN10300_GOT32 3465 This is a 32bit GOT-relative reloc for the mn10300, offset by two 3466 bytes in the instruction. 3467 3468 -- : BFD_RELOC_MN10300_GOT24 3469 This is a 24bit GOT-relative reloc for the mn10300, offset by two 3470 bytes in the instruction. 3471 3472 -- : BFD_RELOC_MN10300_GOT16 3473 This is a 16bit GOT-relative reloc for the mn10300, offset by two 3474 bytes in the instruction. 3475 3476 -- : BFD_RELOC_MN10300_COPY 3477 Copy symbol at runtime. 3478 3479 -- : BFD_RELOC_MN10300_GLOB_DAT 3480 Create GOT entry. 3481 3482 -- : BFD_RELOC_MN10300_JMP_SLOT 3483 Create PLT entry. 3484 3485 -- : BFD_RELOC_MN10300_RELATIVE 3486 Adjust by program base. 3487 3488 -- : BFD_RELOC_386_GOT32 3489 -- : BFD_RELOC_386_PLT32 3490 -- : BFD_RELOC_386_COPY 3491 -- : BFD_RELOC_386_GLOB_DAT 3492 -- : BFD_RELOC_386_JUMP_SLOT 3493 -- : BFD_RELOC_386_RELATIVE 3494 -- : BFD_RELOC_386_GOTOFF 3495 -- : BFD_RELOC_386_GOTPC 3496 -- : BFD_RELOC_386_TLS_TPOFF 3497 -- : BFD_RELOC_386_TLS_IE 3498 -- : BFD_RELOC_386_TLS_GOTIE 3499 -- : BFD_RELOC_386_TLS_LE 3500 -- : BFD_RELOC_386_TLS_GD 3501 -- : BFD_RELOC_386_TLS_LDM 3502 -- : BFD_RELOC_386_TLS_LDO_32 3503 -- : BFD_RELOC_386_TLS_IE_32 3504 -- : BFD_RELOC_386_TLS_LE_32 3505 -- : BFD_RELOC_386_TLS_DTPMOD32 3506 -- : BFD_RELOC_386_TLS_DTPOFF32 3507 -- : BFD_RELOC_386_TLS_TPOFF32 3508 -- : BFD_RELOC_386_TLS_GOTDESC 3509 -- : BFD_RELOC_386_TLS_DESC_CALL 3510 -- : BFD_RELOC_386_TLS_DESC 3511 i386/elf relocations 3512 3513 -- : BFD_RELOC_X86_64_GOT32 3514 -- : BFD_RELOC_X86_64_PLT32 3515 -- : BFD_RELOC_X86_64_COPY 3516 -- : BFD_RELOC_X86_64_GLOB_DAT 3517 -- : BFD_RELOC_X86_64_JUMP_SLOT 3518 -- : BFD_RELOC_X86_64_RELATIVE 3519 -- : BFD_RELOC_X86_64_GOTPCREL 3520 -- : BFD_RELOC_X86_64_32S 3521 -- : BFD_RELOC_X86_64_DTPMOD64 3522 -- : BFD_RELOC_X86_64_DTPOFF64 3523 -- : BFD_RELOC_X86_64_TPOFF64 3524 -- : BFD_RELOC_X86_64_TLSGD 3525 -- : BFD_RELOC_X86_64_TLSLD 3526 -- : BFD_RELOC_X86_64_DTPOFF32 3527 -- : BFD_RELOC_X86_64_GOTTPOFF 3528 -- : BFD_RELOC_X86_64_TPOFF32 3529 -- : BFD_RELOC_X86_64_GOTOFF64 3530 -- : BFD_RELOC_X86_64_GOTPC32 3531 -- : BFD_RELOC_X86_64_GOT64 3532 -- : BFD_RELOC_X86_64_GOTPCREL64 3533 -- : BFD_RELOC_X86_64_GOTPC64 3534 -- : BFD_RELOC_X86_64_GOTPLT64 3535 -- : BFD_RELOC_X86_64_PLTOFF64 3536 -- : BFD_RELOC_X86_64_GOTPC32_TLSDESC 3537 -- : BFD_RELOC_X86_64_TLSDESC_CALL 3538 -- : BFD_RELOC_X86_64_TLSDESC 3539 x86-64/elf relocations 3540 3541 -- : BFD_RELOC_NS32K_IMM_8 3542 -- : BFD_RELOC_NS32K_IMM_16 3543 -- : BFD_RELOC_NS32K_IMM_32 3544 -- : BFD_RELOC_NS32K_IMM_8_PCREL 3545 -- : BFD_RELOC_NS32K_IMM_16_PCREL 3546 -- : BFD_RELOC_NS32K_IMM_32_PCREL 3547 -- : BFD_RELOC_NS32K_DISP_8 3548 -- : BFD_RELOC_NS32K_DISP_16 3549 -- : BFD_RELOC_NS32K_DISP_32 3550 -- : BFD_RELOC_NS32K_DISP_8_PCREL 3551 -- : BFD_RELOC_NS32K_DISP_16_PCREL 3552 -- : BFD_RELOC_NS32K_DISP_32_PCREL 3553 ns32k relocations 3554 3555 -- : BFD_RELOC_PDP11_DISP_8_PCREL 3556 -- : BFD_RELOC_PDP11_DISP_6_PCREL 3557 PDP11 relocations 3558 3559 -- : BFD_RELOC_PJ_CODE_HI16 3560 -- : BFD_RELOC_PJ_CODE_LO16 3561 -- : BFD_RELOC_PJ_CODE_DIR16 3562 -- : BFD_RELOC_PJ_CODE_DIR32 3563 -- : BFD_RELOC_PJ_CODE_REL16 3564 -- : BFD_RELOC_PJ_CODE_REL32 3565 Picojava relocs. Not all of these appear in object files. 3566 3567 -- : BFD_RELOC_PPC_B26 3568 -- : BFD_RELOC_PPC_BA26 3569 -- : BFD_RELOC_PPC_TOC16 3570 -- : BFD_RELOC_PPC_B16 3571 -- : BFD_RELOC_PPC_B16_BRTAKEN 3572 -- : BFD_RELOC_PPC_B16_BRNTAKEN 3573 -- : BFD_RELOC_PPC_BA16 3574 -- : BFD_RELOC_PPC_BA16_BRTAKEN 3575 -- : BFD_RELOC_PPC_BA16_BRNTAKEN 3576 -- : BFD_RELOC_PPC_COPY 3577 -- : BFD_RELOC_PPC_GLOB_DAT 3578 -- : BFD_RELOC_PPC_JMP_SLOT 3579 -- : BFD_RELOC_PPC_RELATIVE 3580 -- : BFD_RELOC_PPC_LOCAL24PC 3581 -- : BFD_RELOC_PPC_EMB_NADDR32 3582 -- : BFD_RELOC_PPC_EMB_NADDR16 3583 -- : BFD_RELOC_PPC_EMB_NADDR16_LO 3584 -- : BFD_RELOC_PPC_EMB_NADDR16_HI 3585 -- : BFD_RELOC_PPC_EMB_NADDR16_HA 3586 -- : BFD_RELOC_PPC_EMB_SDAI16 3587 -- : BFD_RELOC_PPC_EMB_SDA2I16 3588 -- : BFD_RELOC_PPC_EMB_SDA2REL 3589 -- : BFD_RELOC_PPC_EMB_SDA21 3590 -- : BFD_RELOC_PPC_EMB_MRKREF 3591 -- : BFD_RELOC_PPC_EMB_RELSEC16 3592 -- : BFD_RELOC_PPC_EMB_RELST_LO 3593 -- : BFD_RELOC_PPC_EMB_RELST_HI 3594 -- : BFD_RELOC_PPC_EMB_RELST_HA 3595 -- : BFD_RELOC_PPC_EMB_BIT_FLD 3596 -- : BFD_RELOC_PPC_EMB_RELSDA 3597 -- : BFD_RELOC_PPC64_HIGHER 3598 -- : BFD_RELOC_PPC64_HIGHER_S 3599 -- : BFD_RELOC_PPC64_HIGHEST 3600 -- : BFD_RELOC_PPC64_HIGHEST_S 3601 -- : BFD_RELOC_PPC64_TOC16_LO 3602 -- : BFD_RELOC_PPC64_TOC16_HI 3603 -- : BFD_RELOC_PPC64_TOC16_HA 3604 -- : BFD_RELOC_PPC64_TOC 3605 -- : BFD_RELOC_PPC64_PLTGOT16 3606 -- : BFD_RELOC_PPC64_PLTGOT16_LO 3607 -- : BFD_RELOC_PPC64_PLTGOT16_HI 3608 -- : BFD_RELOC_PPC64_PLTGOT16_HA 3609 -- : BFD_RELOC_PPC64_ADDR16_DS 3610 -- : BFD_RELOC_PPC64_ADDR16_LO_DS 3611 -- : BFD_RELOC_PPC64_GOT16_DS 3612 -- : BFD_RELOC_PPC64_GOT16_LO_DS 3613 -- : BFD_RELOC_PPC64_PLT16_LO_DS 3614 -- : BFD_RELOC_PPC64_SECTOFF_DS 3615 -- : BFD_RELOC_PPC64_SECTOFF_LO_DS 3616 -- : BFD_RELOC_PPC64_TOC16_DS 3617 -- : BFD_RELOC_PPC64_TOC16_LO_DS 3618 -- : BFD_RELOC_PPC64_PLTGOT16_DS 3619 -- : BFD_RELOC_PPC64_PLTGOT16_LO_DS 3620 Power(rs6000) and PowerPC relocations. 3621 3622 -- : BFD_RELOC_PPC_TLS 3623 -- : BFD_RELOC_PPC_DTPMOD 3624 -- : BFD_RELOC_PPC_TPREL16 3625 -- : BFD_RELOC_PPC_TPREL16_LO 3626 -- : BFD_RELOC_PPC_TPREL16_HI 3627 -- : BFD_RELOC_PPC_TPREL16_HA 3628 -- : BFD_RELOC_PPC_TPREL 3629 -- : BFD_RELOC_PPC_DTPREL16 3630 -- : BFD_RELOC_PPC_DTPREL16_LO 3631 -- : BFD_RELOC_PPC_DTPREL16_HI 3632 -- : BFD_RELOC_PPC_DTPREL16_HA 3633 -- : BFD_RELOC_PPC_DTPREL 3634 -- : BFD_RELOC_PPC_GOT_TLSGD16 3635 -- : BFD_RELOC_PPC_GOT_TLSGD16_LO 3636 -- : BFD_RELOC_PPC_GOT_TLSGD16_HI 3637 -- : BFD_RELOC_PPC_GOT_TLSGD16_HA 3638 -- : BFD_RELOC_PPC_GOT_TLSLD16 3639 -- : BFD_RELOC_PPC_GOT_TLSLD16_LO 3640 -- : BFD_RELOC_PPC_GOT_TLSLD16_HI 3641 -- : BFD_RELOC_PPC_GOT_TLSLD16_HA 3642 -- : BFD_RELOC_PPC_GOT_TPREL16 3643 -- : BFD_RELOC_PPC_GOT_TPREL16_LO 3644 -- : BFD_RELOC_PPC_GOT_TPREL16_HI 3645 -- : BFD_RELOC_PPC_GOT_TPREL16_HA 3646 -- : BFD_RELOC_PPC_GOT_DTPREL16 3647 -- : BFD_RELOC_PPC_GOT_DTPREL16_LO 3648 -- : BFD_RELOC_PPC_GOT_DTPREL16_HI 3649 -- : BFD_RELOC_PPC_GOT_DTPREL16_HA 3650 -- : BFD_RELOC_PPC64_TPREL16_DS 3651 -- : BFD_RELOC_PPC64_TPREL16_LO_DS 3652 -- : BFD_RELOC_PPC64_TPREL16_HIGHER 3653 -- : BFD_RELOC_PPC64_TPREL16_HIGHERA 3654 -- : BFD_RELOC_PPC64_TPREL16_HIGHEST 3655 -- : BFD_RELOC_PPC64_TPREL16_HIGHESTA 3656 -- : BFD_RELOC_PPC64_DTPREL16_DS 3657 -- : BFD_RELOC_PPC64_DTPREL16_LO_DS 3658 -- : BFD_RELOC_PPC64_DTPREL16_HIGHER 3659 -- : BFD_RELOC_PPC64_DTPREL16_HIGHERA 3660 -- : BFD_RELOC_PPC64_DTPREL16_HIGHEST 3661 -- : BFD_RELOC_PPC64_DTPREL16_HIGHESTA 3662 PowerPC and PowerPC64 thread-local storage relocations. 3663 3664 -- : BFD_RELOC_I370_D12 3665 IBM 370/390 relocations 3666 3667 -- : BFD_RELOC_CTOR 3668 The type of reloc used to build a constructor table - at the moment 3669 probably a 32 bit wide absolute relocation, but the target can 3670 choose. It generally does map to one of the other relocation 3671 types. 3672 3673 -- : BFD_RELOC_ARM_PCREL_BRANCH 3674 ARM 26 bit pc-relative branch. The lowest two bits must be zero 3675 and are not stored in the instruction. 3676 3677 -- : BFD_RELOC_ARM_PCREL_BLX 3678 ARM 26 bit pc-relative branch. The lowest bit must be zero and is 3679 not stored in the instruction. The 2nd lowest bit comes from a 1 3680 bit field in the instruction. 3681 3682 -- : BFD_RELOC_THUMB_PCREL_BLX 3683 Thumb 22 bit pc-relative branch. The lowest bit must be zero and 3684 is not stored in the instruction. The 2nd lowest bit comes from a 3685 1 bit field in the instruction. 3686 3687 -- : BFD_RELOC_ARM_PCREL_CALL 3688 ARM 26-bit pc-relative branch for an unconditional BL or BLX 3689 instruction. 3690 3691 -- : BFD_RELOC_ARM_PCREL_JUMP 3692 ARM 26-bit pc-relative branch for B or conditional BL instruction. 3693 3694 -- : BFD_RELOC_THUMB_PCREL_BRANCH7 3695 -- : BFD_RELOC_THUMB_PCREL_BRANCH9 3696 -- : BFD_RELOC_THUMB_PCREL_BRANCH12 3697 -- : BFD_RELOC_THUMB_PCREL_BRANCH20 3698 -- : BFD_RELOC_THUMB_PCREL_BRANCH23 3699 -- : BFD_RELOC_THUMB_PCREL_BRANCH25 3700 Thumb 7-, 9-, 12-, 20-, 23-, and 25-bit pc-relative branches. The 3701 lowest bit must be zero and is not stored in the instruction. 3702 Note that the corresponding ELF R_ARM_THM_JUMPnn constant has an 3703 "nn" one smaller in all cases. Note further that BRANCH23 3704 corresponds to R_ARM_THM_CALL. 3705 3706 -- : BFD_RELOC_ARM_OFFSET_IMM 3707 12-bit immediate offset, used in ARM-format ldr and str 3708 instructions. 3709 3710 -- : BFD_RELOC_ARM_THUMB_OFFSET 3711 5-bit immediate offset, used in Thumb-format ldr and str 3712 instructions. 3713 3714 -- : BFD_RELOC_ARM_TARGET1 3715 Pc-relative or absolute relocation depending on target. Used for 3716 entries in .init_array sections. 3717 3718 -- : BFD_RELOC_ARM_ROSEGREL32 3719 Read-only segment base relative address. 3720 3721 -- : BFD_RELOC_ARM_SBREL32 3722 Data segment base relative address. 3723 3724 -- : BFD_RELOC_ARM_TARGET2 3725 This reloc is used for references to RTTI data from exception 3726 handling tables. The actual definition depends on the target. It 3727 may be a pc-relative or some form of GOT-indirect relocation. 3728 3729 -- : BFD_RELOC_ARM_PREL31 3730 31-bit PC relative address. 3731 3732 -- : BFD_RELOC_ARM_JUMP_SLOT 3733 -- : BFD_RELOC_ARM_GLOB_DAT 3734 -- : BFD_RELOC_ARM_GOT32 3735 -- : BFD_RELOC_ARM_PLT32 3736 -- : BFD_RELOC_ARM_RELATIVE 3737 -- : BFD_RELOC_ARM_GOTOFF 3738 -- : BFD_RELOC_ARM_GOTPC 3739 Relocations for setting up GOTs and PLTs for shared libraries. 3740 3741 -- : BFD_RELOC_ARM_TLS_GD32 3742 -- : BFD_RELOC_ARM_TLS_LDO32 3743 -- : BFD_RELOC_ARM_TLS_LDM32 3744 -- : BFD_RELOC_ARM_TLS_DTPOFF32 3745 -- : BFD_RELOC_ARM_TLS_DTPMOD32 3746 -- : BFD_RELOC_ARM_TLS_TPOFF32 3747 -- : BFD_RELOC_ARM_TLS_IE32 3748 -- : BFD_RELOC_ARM_TLS_LE32 3749 ARM thread-local storage relocations. 3750 3751 -- : BFD_RELOC_ARM_IMMEDIATE 3752 -- : BFD_RELOC_ARM_ADRL_IMMEDIATE 3753 -- : BFD_RELOC_ARM_T32_IMMEDIATE 3754 -- : BFD_RELOC_ARM_T32_IMM12 3755 -- : BFD_RELOC_ARM_T32_ADD_PC12 3756 -- : BFD_RELOC_ARM_SHIFT_IMM 3757 -- : BFD_RELOC_ARM_SMC 3758 -- : BFD_RELOC_ARM_SWI 3759 -- : BFD_RELOC_ARM_MULTI 3760 -- : BFD_RELOC_ARM_CP_OFF_IMM 3761 -- : BFD_RELOC_ARM_CP_OFF_IMM_S2 3762 -- : BFD_RELOC_ARM_T32_CP_OFF_IMM 3763 -- : BFD_RELOC_ARM_T32_CP_OFF_IMM_S2 3764 -- : BFD_RELOC_ARM_ADR_IMM 3765 -- : BFD_RELOC_ARM_LDR_IMM 3766 -- : BFD_RELOC_ARM_LITERAL 3767 -- : BFD_RELOC_ARM_IN_POOL 3768 -- : BFD_RELOC_ARM_OFFSET_IMM8 3769 -- : BFD_RELOC_ARM_T32_OFFSET_U8 3770 -- : BFD_RELOC_ARM_T32_OFFSET_IMM 3771 -- : BFD_RELOC_ARM_HWLITERAL 3772 -- : BFD_RELOC_ARM_THUMB_ADD 3773 -- : BFD_RELOC_ARM_THUMB_IMM 3774 -- : BFD_RELOC_ARM_THUMB_SHIFT 3775 These relocs are only used within the ARM assembler. They are not 3776 (at present) written to any object files. 3777 3778 -- : BFD_RELOC_SH_PCDISP8BY2 3779 -- : BFD_RELOC_SH_PCDISP12BY2 3780 -- : BFD_RELOC_SH_IMM3 3781 -- : BFD_RELOC_SH_IMM3U 3782 -- : BFD_RELOC_SH_DISP12 3783 -- : BFD_RELOC_SH_DISP12BY2 3784 -- : BFD_RELOC_SH_DISP12BY4 3785 -- : BFD_RELOC_SH_DISP12BY8 3786 -- : BFD_RELOC_SH_DISP20 3787 -- : BFD_RELOC_SH_DISP20BY8 3788 -- : BFD_RELOC_SH_IMM4 3789 -- : BFD_RELOC_SH_IMM4BY2 3790 -- : BFD_RELOC_SH_IMM4BY4 3791 -- : BFD_RELOC_SH_IMM8 3792 -- : BFD_RELOC_SH_IMM8BY2 3793 -- : BFD_RELOC_SH_IMM8BY4 3794 -- : BFD_RELOC_SH_PCRELIMM8BY2 3795 -- : BFD_RELOC_SH_PCRELIMM8BY4 3796 -- : BFD_RELOC_SH_SWITCH16 3797 -- : BFD_RELOC_SH_SWITCH32 3798 -- : BFD_RELOC_SH_USES 3799 -- : BFD_RELOC_SH_COUNT 3800 -- : BFD_RELOC_SH_ALIGN 3801 -- : BFD_RELOC_SH_CODE 3802 -- : BFD_RELOC_SH_DATA 3803 -- : BFD_RELOC_SH_LABEL 3804 -- : BFD_RELOC_SH_LOOP_START 3805 -- : BFD_RELOC_SH_LOOP_END 3806 -- : BFD_RELOC_SH_COPY 3807 -- : BFD_RELOC_SH_GLOB_DAT 3808 -- : BFD_RELOC_SH_JMP_SLOT 3809 -- : BFD_RELOC_SH_RELATIVE 3810 -- : BFD_RELOC_SH_GOTPC 3811 -- : BFD_RELOC_SH_GOT_LOW16 3812 -- : BFD_RELOC_SH_GOT_MEDLOW16 3813 -- : BFD_RELOC_SH_GOT_MEDHI16 3814 -- : BFD_RELOC_SH_GOT_HI16 3815 -- : BFD_RELOC_SH_GOTPLT_LOW16 3816 -- : BFD_RELOC_SH_GOTPLT_MEDLOW16 3817 -- : BFD_RELOC_SH_GOTPLT_MEDHI16 3818 -- : BFD_RELOC_SH_GOTPLT_HI16 3819 -- : BFD_RELOC_SH_PLT_LOW16 3820 -- : BFD_RELOC_SH_PLT_MEDLOW16 3821 -- : BFD_RELOC_SH_PLT_MEDHI16 3822 -- : BFD_RELOC_SH_PLT_HI16 3823 -- : BFD_RELOC_SH_GOTOFF_LOW16 3824 -- : BFD_RELOC_SH_GOTOFF_MEDLOW16 3825 -- : BFD_RELOC_SH_GOTOFF_MEDHI16 3826 -- : BFD_RELOC_SH_GOTOFF_HI16 3827 -- : BFD_RELOC_SH_GOTPC_LOW16 3828 -- : BFD_RELOC_SH_GOTPC_MEDLOW16 3829 -- : BFD_RELOC_SH_GOTPC_MEDHI16 3830 -- : BFD_RELOC_SH_GOTPC_HI16 3831 -- : BFD_RELOC_SH_COPY64 3832 -- : BFD_RELOC_SH_GLOB_DAT64 3833 -- : BFD_RELOC_SH_JMP_SLOT64 3834 -- : BFD_RELOC_SH_RELATIVE64 3835 -- : BFD_RELOC_SH_GOT10BY4 3836 -- : BFD_RELOC_SH_GOT10BY8 3837 -- : BFD_RELOC_SH_GOTPLT10BY4 3838 -- : BFD_RELOC_SH_GOTPLT10BY8 3839 -- : BFD_RELOC_SH_GOTPLT32 3840 -- : BFD_RELOC_SH_SHMEDIA_CODE 3841 -- : BFD_RELOC_SH_IMMU5 3842 -- : BFD_RELOC_SH_IMMS6 3843 -- : BFD_RELOC_SH_IMMS6BY32 3844 -- : BFD_RELOC_SH_IMMU6 3845 -- : BFD_RELOC_SH_IMMS10 3846 -- : BFD_RELOC_SH_IMMS10BY2 3847 -- : BFD_RELOC_SH_IMMS10BY4 3848 -- : BFD_RELOC_SH_IMMS10BY8 3849 -- : BFD_RELOC_SH_IMMS16 3850 -- : BFD_RELOC_SH_IMMU16 3851 -- : BFD_RELOC_SH_IMM_LOW16 3852 -- : BFD_RELOC_SH_IMM_LOW16_PCREL 3853 -- : BFD_RELOC_SH_IMM_MEDLOW16 3854 -- : BFD_RELOC_SH_IMM_MEDLOW16_PCREL 3855 -- : BFD_RELOC_SH_IMM_MEDHI16 3856 -- : BFD_RELOC_SH_IMM_MEDHI16_PCREL 3857 -- : BFD_RELOC_SH_IMM_HI16 3858 -- : BFD_RELOC_SH_IMM_HI16_PCREL 3859 -- : BFD_RELOC_SH_PT_16 3860 -- : BFD_RELOC_SH_TLS_GD_32 3861 -- : BFD_RELOC_SH_TLS_LD_32 3862 -- : BFD_RELOC_SH_TLS_LDO_32 3863 -- : BFD_RELOC_SH_TLS_IE_32 3864 -- : BFD_RELOC_SH_TLS_LE_32 3865 -- : BFD_RELOC_SH_TLS_DTPMOD32 3866 -- : BFD_RELOC_SH_TLS_DTPOFF32 3867 -- : BFD_RELOC_SH_TLS_TPOFF32 3868 Renesas / SuperH SH relocs. Not all of these appear in object 3869 files. 3870 3871 -- : BFD_RELOC_ARC_B22_PCREL 3872 ARC Cores relocs. ARC 22 bit pc-relative branch. The lowest two 3873 bits must be zero and are not stored in the instruction. The high 3874 20 bits are installed in bits 26 through 7 of the instruction. 3875 3876 -- : BFD_RELOC_ARC_B26 3877 ARC 26 bit absolute branch. The lowest two bits must be zero and 3878 are not stored in the instruction. The high 24 bits are installed 3879 in bits 23 through 0. 3880 3881 -- : BFD_RELOC_BFIN_16_IMM 3882 ADI Blackfin 16 bit immediate absolute reloc. 3883 3884 -- : BFD_RELOC_BFIN_16_HIGH 3885 ADI Blackfin 16 bit immediate absolute reloc higher 16 bits. 3886 3887 -- : BFD_RELOC_BFIN_4_PCREL 3888 ADI Blackfin 'a' part of LSETUP. 3889 3890 -- : BFD_RELOC_BFIN_5_PCREL 3891 ADI Blackfin. 3892 3893 -- : BFD_RELOC_BFIN_16_LOW 3894 ADI Blackfin 16 bit immediate absolute reloc lower 16 bits. 3895 3896 -- : BFD_RELOC_BFIN_10_PCREL 3897 ADI Blackfin. 3898 3899 -- : BFD_RELOC_BFIN_11_PCREL 3900 ADI Blackfin 'b' part of LSETUP. 3901 3902 -- : BFD_RELOC_BFIN_12_PCREL_JUMP 3903 ADI Blackfin. 3904 3905 -- : BFD_RELOC_BFIN_12_PCREL_JUMP_S 3906 ADI Blackfin Short jump, pcrel. 3907 3908 -- : BFD_RELOC_BFIN_24_PCREL_CALL_X 3909 ADI Blackfin Call.x not implemented. 3910 3911 -- : BFD_RELOC_BFIN_24_PCREL_JUMP_L 3912 ADI Blackfin Long Jump pcrel. 3913 3914 -- : BFD_RELOC_BFIN_GOT17M4 3915 -- : BFD_RELOC_BFIN_GOTHI 3916 -- : BFD_RELOC_BFIN_GOTLO 3917 -- : BFD_RELOC_BFIN_FUNCDESC 3918 -- : BFD_RELOC_BFIN_FUNCDESC_GOT17M4 3919 -- : BFD_RELOC_BFIN_FUNCDESC_GOTHI 3920 -- : BFD_RELOC_BFIN_FUNCDESC_GOTLO 3921 -- : BFD_RELOC_BFIN_FUNCDESC_VALUE 3922 -- : BFD_RELOC_BFIN_FUNCDESC_GOTOFF17M4 3923 -- : BFD_RELOC_BFIN_FUNCDESC_GOTOFFHI 3924 -- : BFD_RELOC_BFIN_FUNCDESC_GOTOFFLO 3925 -- : BFD_RELOC_BFIN_GOTOFF17M4 3926 -- : BFD_RELOC_BFIN_GOTOFFHI 3927 -- : BFD_RELOC_BFIN_GOTOFFLO 3928 ADI Blackfin FD-PIC relocations. 3929 3930 -- : BFD_RELOC_BFIN_GOT 3931 ADI Blackfin GOT relocation. 3932 3933 -- : BFD_RELOC_BFIN_PLTPC 3934 ADI Blackfin PLTPC relocation. 3935 3936 -- : BFD_ARELOC_BFIN_PUSH 3937 ADI Blackfin arithmetic relocation. 3938 3939 -- : BFD_ARELOC_BFIN_CONST 3940 ADI Blackfin arithmetic relocation. 3941 3942 -- : BFD_ARELOC_BFIN_ADD 3943 ADI Blackfin arithmetic relocation. 3944 3945 -- : BFD_ARELOC_BFIN_SUB 3946 ADI Blackfin arithmetic relocation. 3947 3948 -- : BFD_ARELOC_BFIN_MULT 3949 ADI Blackfin arithmetic relocation. 3950 3951 -- : BFD_ARELOC_BFIN_DIV 3952 ADI Blackfin arithmetic relocation. 3953 3954 -- : BFD_ARELOC_BFIN_MOD 3955 ADI Blackfin arithmetic relocation. 3956 3957 -- : BFD_ARELOC_BFIN_LSHIFT 3958 ADI Blackfin arithmetic relocation. 3959 3960 -- : BFD_ARELOC_BFIN_RSHIFT 3961 ADI Blackfin arithmetic relocation. 3962 3963 -- : BFD_ARELOC_BFIN_AND 3964 ADI Blackfin arithmetic relocation. 3965 3966 -- : BFD_ARELOC_BFIN_OR 3967 ADI Blackfin arithmetic relocation. 3968 3969 -- : BFD_ARELOC_BFIN_XOR 3970 ADI Blackfin arithmetic relocation. 3971 3972 -- : BFD_ARELOC_BFIN_LAND 3973 ADI Blackfin arithmetic relocation. 3974 3975 -- : BFD_ARELOC_BFIN_LOR 3976 ADI Blackfin arithmetic relocation. 3977 3978 -- : BFD_ARELOC_BFIN_LEN 3979 ADI Blackfin arithmetic relocation. 3980 3981 -- : BFD_ARELOC_BFIN_NEG 3982 ADI Blackfin arithmetic relocation. 3983 3984 -- : BFD_ARELOC_BFIN_COMP 3985 ADI Blackfin arithmetic relocation. 3986 3987 -- : BFD_ARELOC_BFIN_PAGE 3988 ADI Blackfin arithmetic relocation. 3989 3990 -- : BFD_ARELOC_BFIN_HWPAGE 3991 ADI Blackfin arithmetic relocation. 3992 3993 -- : BFD_ARELOC_BFIN_ADDR 3994 ADI Blackfin arithmetic relocation. 3995 3996 -- : BFD_RELOC_D10V_10_PCREL_R 3997 Mitsubishi D10V relocs. This is a 10-bit reloc with the right 2 3998 bits assumed to be 0. 3999 4000 -- : BFD_RELOC_D10V_10_PCREL_L 4001 Mitsubishi D10V relocs. This is a 10-bit reloc with the right 2 4002 bits assumed to be 0. This is the same as the previous reloc 4003 except it is in the left container, i.e., shifted left 15 bits. 4004 4005 -- : BFD_RELOC_D10V_18 4006 This is an 18-bit reloc with the right 2 bits assumed to be 0. 4007 4008 -- : BFD_RELOC_D10V_18_PCREL 4009 This is an 18-bit reloc with the right 2 bits assumed to be 0. 4010 4011 -- : BFD_RELOC_D30V_6 4012 Mitsubishi D30V relocs. This is a 6-bit absolute reloc. 4013 4014 -- : BFD_RELOC_D30V_9_PCREL 4015 This is a 6-bit pc-relative reloc with the right 3 bits assumed to 4016 be 0. 4017 4018 -- : BFD_RELOC_D30V_9_PCREL_R 4019 This is a 6-bit pc-relative reloc with the right 3 bits assumed to 4020 be 0. Same as the previous reloc but on the right side of the 4021 container. 4022 4023 -- : BFD_RELOC_D30V_15 4024 This is a 12-bit absolute reloc with the right 3 bitsassumed to be 4025 0. 4026 4027 -- : BFD_RELOC_D30V_15_PCREL 4028 This is a 12-bit pc-relative reloc with the right 3 bits assumed 4029 to be 0. 4030 4031 -- : BFD_RELOC_D30V_15_PCREL_R 4032 This is a 12-bit pc-relative reloc with the right 3 bits assumed 4033 to be 0. Same as the previous reloc but on the right side of the 4034 container. 4035 4036 -- : BFD_RELOC_D30V_21 4037 This is an 18-bit absolute reloc with the right 3 bits assumed to 4038 be 0. 4039 4040 -- : BFD_RELOC_D30V_21_PCREL 4041 This is an 18-bit pc-relative reloc with the right 3 bits assumed 4042 to be 0. 4043 4044 -- : BFD_RELOC_D30V_21_PCREL_R 4045 This is an 18-bit pc-relative reloc with the right 3 bits assumed 4046 to be 0. Same as the previous reloc but on the right side of the 4047 container. 4048 4049 -- : BFD_RELOC_D30V_32 4050 This is a 32-bit absolute reloc. 4051 4052 -- : BFD_RELOC_D30V_32_PCREL 4053 This is a 32-bit pc-relative reloc. 4054 4055 -- : BFD_RELOC_DLX_HI16_S 4056 DLX relocs 4057 4058 -- : BFD_RELOC_DLX_LO16 4059 DLX relocs 4060 4061 -- : BFD_RELOC_DLX_JMP26 4062 DLX relocs 4063 4064 -- : BFD_RELOC_M32C_HI8 4065 -- : BFD_RELOC_M32C_RL_JUMP 4066 -- : BFD_RELOC_M32C_RL_1ADDR 4067 -- : BFD_RELOC_M32C_RL_2ADDR 4068 Renesas M16C/M32C Relocations. 4069 4070 -- : BFD_RELOC_M32R_24 4071 Renesas M32R (formerly Mitsubishi M32R) relocs. This is a 24 bit 4072 absolute address. 4073 4074 -- : BFD_RELOC_M32R_10_PCREL 4075 This is a 10-bit pc-relative reloc with the right 2 bits assumed 4076 to be 0. 4077 4078 -- : BFD_RELOC_M32R_18_PCREL 4079 This is an 18-bit reloc with the right 2 bits assumed to be 0. 4080 4081 -- : BFD_RELOC_M32R_26_PCREL 4082 This is a 26-bit reloc with the right 2 bits assumed to be 0. 4083 4084 -- : BFD_RELOC_M32R_HI16_ULO 4085 This is a 16-bit reloc containing the high 16 bits of an address 4086 used when the lower 16 bits are treated as unsigned. 4087 4088 -- : BFD_RELOC_M32R_HI16_SLO 4089 This is a 16-bit reloc containing the high 16 bits of an address 4090 used when the lower 16 bits are treated as signed. 4091 4092 -- : BFD_RELOC_M32R_LO16 4093 This is a 16-bit reloc containing the lower 16 bits of an address. 4094 4095 -- : BFD_RELOC_M32R_SDA16 4096 This is a 16-bit reloc containing the small data area offset for 4097 use in add3, load, and store instructions. 4098 4099 -- : BFD_RELOC_M32R_GOT24 4100 -- : BFD_RELOC_M32R_26_PLTREL 4101 -- : BFD_RELOC_M32R_COPY 4102 -- : BFD_RELOC_M32R_GLOB_DAT 4103 -- : BFD_RELOC_M32R_JMP_SLOT 4104 -- : BFD_RELOC_M32R_RELATIVE 4105 -- : BFD_RELOC_M32R_GOTOFF 4106 -- : BFD_RELOC_M32R_GOTOFF_HI_ULO 4107 -- : BFD_RELOC_M32R_GOTOFF_HI_SLO 4108 -- : BFD_RELOC_M32R_GOTOFF_LO 4109 -- : BFD_RELOC_M32R_GOTPC24 4110 -- : BFD_RELOC_M32R_GOT16_HI_ULO 4111 -- : BFD_RELOC_M32R_GOT16_HI_SLO 4112 -- : BFD_RELOC_M32R_GOT16_LO 4113 -- : BFD_RELOC_M32R_GOTPC_HI_ULO 4114 -- : BFD_RELOC_M32R_GOTPC_HI_SLO 4115 -- : BFD_RELOC_M32R_GOTPC_LO 4116 For PIC. 4117 4118 -- : BFD_RELOC_V850_9_PCREL 4119 This is a 9-bit reloc 4120 4121 -- : BFD_RELOC_V850_22_PCREL 4122 This is a 22-bit reloc 4123 4124 -- : BFD_RELOC_V850_SDA_16_16_OFFSET 4125 This is a 16 bit offset from the short data area pointer. 4126 4127 -- : BFD_RELOC_V850_SDA_15_16_OFFSET 4128 This is a 16 bit offset (of which only 15 bits are used) from the 4129 short data area pointer. 4130 4131 -- : BFD_RELOC_V850_ZDA_16_16_OFFSET 4132 This is a 16 bit offset from the zero data area pointer. 4133 4134 -- : BFD_RELOC_V850_ZDA_15_16_OFFSET 4135 This is a 16 bit offset (of which only 15 bits are used) from the 4136 zero data area pointer. 4137 4138 -- : BFD_RELOC_V850_TDA_6_8_OFFSET 4139 This is an 8 bit offset (of which only 6 bits are used) from the 4140 tiny data area pointer. 4141 4142 -- : BFD_RELOC_V850_TDA_7_8_OFFSET 4143 This is an 8bit offset (of which only 7 bits are used) from the 4144 tiny data area pointer. 4145 4146 -- : BFD_RELOC_V850_TDA_7_7_OFFSET 4147 This is a 7 bit offset from the tiny data area pointer. 4148 4149 -- : BFD_RELOC_V850_TDA_16_16_OFFSET 4150 This is a 16 bit offset from the tiny data area pointer. 4151 4152 -- : BFD_RELOC_V850_TDA_4_5_OFFSET 4153 This is a 5 bit offset (of which only 4 bits are used) from the 4154 tiny data area pointer. 4155 4156 -- : BFD_RELOC_V850_TDA_4_4_OFFSET 4157 This is a 4 bit offset from the tiny data area pointer. 4158 4159 -- : BFD_RELOC_V850_SDA_16_16_SPLIT_OFFSET 4160 This is a 16 bit offset from the short data area pointer, with the 4161 bits placed non-contiguously in the instruction. 4162 4163 -- : BFD_RELOC_V850_ZDA_16_16_SPLIT_OFFSET 4164 This is a 16 bit offset from the zero data area pointer, with the 4165 bits placed non-contiguously in the instruction. 4166 4167 -- : BFD_RELOC_V850_CALLT_6_7_OFFSET 4168 This is a 6 bit offset from the call table base pointer. 4169 4170 -- : BFD_RELOC_V850_CALLT_16_16_OFFSET 4171 This is a 16 bit offset from the call table base pointer. 4172 4173 -- : BFD_RELOC_V850_LONGCALL 4174 Used for relaxing indirect function calls. 4175 4176 -- : BFD_RELOC_V850_LONGJUMP 4177 Used for relaxing indirect jumps. 4178 4179 -- : BFD_RELOC_V850_ALIGN 4180 Used to maintain alignment whilst relaxing. 4181 4182 -- : BFD_RELOC_V850_LO16_SPLIT_OFFSET 4183 This is a variation of BFD_RELOC_LO16 that can be used in v850e 4184 ld.bu instructions. 4185 4186 -- : BFD_RELOC_MN10300_32_PCREL 4187 This is a 32bit pcrel reloc for the mn10300, offset by two bytes 4188 in the instruction. 4189 4190 -- : BFD_RELOC_MN10300_16_PCREL 4191 This is a 16bit pcrel reloc for the mn10300, offset by two bytes 4192 in the instruction. 4193 4194 -- : BFD_RELOC_TIC30_LDP 4195 This is a 8bit DP reloc for the tms320c30, where the most 4196 significant 8 bits of a 24 bit word are placed into the least 4197 significant 8 bits of the opcode. 4198 4199 -- : BFD_RELOC_TIC54X_PARTLS7 4200 This is a 7bit reloc for the tms320c54x, where the least 4201 significant 7 bits of a 16 bit word are placed into the least 4202 significant 7 bits of the opcode. 4203 4204 -- : BFD_RELOC_TIC54X_PARTMS9 4205 This is a 9bit DP reloc for the tms320c54x, where the most 4206 significant 9 bits of a 16 bit word are placed into the least 4207 significant 9 bits of the opcode. 4208 4209 -- : BFD_RELOC_TIC54X_23 4210 This is an extended address 23-bit reloc for the tms320c54x. 4211 4212 -- : BFD_RELOC_TIC54X_16_OF_23 4213 This is a 16-bit reloc for the tms320c54x, where the least 4214 significant 16 bits of a 23-bit extended address are placed into 4215 the opcode. 4216 4217 -- : BFD_RELOC_TIC54X_MS7_OF_23 4218 This is a reloc for the tms320c54x, where the most significant 7 4219 bits of a 23-bit extended address are placed into the opcode. 4220 4221 -- : BFD_RELOC_FR30_48 4222 This is a 48 bit reloc for the FR30 that stores 32 bits. 4223 4224 -- : BFD_RELOC_FR30_20 4225 This is a 32 bit reloc for the FR30 that stores 20 bits split up 4226 into two sections. 4227 4228 -- : BFD_RELOC_FR30_6_IN_4 4229 This is a 16 bit reloc for the FR30 that stores a 6 bit word 4230 offset in 4 bits. 4231 4232 -- : BFD_RELOC_FR30_8_IN_8 4233 This is a 16 bit reloc for the FR30 that stores an 8 bit byte 4234 offset into 8 bits. 4235 4236 -- : BFD_RELOC_FR30_9_IN_8 4237 This is a 16 bit reloc for the FR30 that stores a 9 bit short 4238 offset into 8 bits. 4239 4240 -- : BFD_RELOC_FR30_10_IN_8 4241 This is a 16 bit reloc for the FR30 that stores a 10 bit word 4242 offset into 8 bits. 4243 4244 -- : BFD_RELOC_FR30_9_PCREL 4245 This is a 16 bit reloc for the FR30 that stores a 9 bit pc relative 4246 short offset into 8 bits. 4247 4248 -- : BFD_RELOC_FR30_12_PCREL 4249 This is a 16 bit reloc for the FR30 that stores a 12 bit pc 4250 relative short offset into 11 bits. 4251 4252 -- : BFD_RELOC_MCORE_PCREL_IMM8BY4 4253 -- : BFD_RELOC_MCORE_PCREL_IMM11BY2 4254 -- : BFD_RELOC_MCORE_PCREL_IMM4BY2 4255 -- : BFD_RELOC_MCORE_PCREL_32 4256 -- : BFD_RELOC_MCORE_PCREL_JSR_IMM11BY2 4257 -- : BFD_RELOC_MCORE_RVA 4258 Motorola Mcore relocations. 4259 4260 -- : BFD_RELOC_MMIX_GETA 4261 -- : BFD_RELOC_MMIX_GETA_1 4262 -- : BFD_RELOC_MMIX_GETA_2 4263 -- : BFD_RELOC_MMIX_GETA_3 4264 These are relocations for the GETA instruction. 4265 4266 -- : BFD_RELOC_MMIX_CBRANCH 4267 -- : BFD_RELOC_MMIX_CBRANCH_J 4268 -- : BFD_RELOC_MMIX_CBRANCH_1 4269 -- : BFD_RELOC_MMIX_CBRANCH_2 4270 -- : BFD_RELOC_MMIX_CBRANCH_3 4271 These are relocations for a conditional branch instruction. 4272 4273 -- : BFD_RELOC_MMIX_PUSHJ 4274 -- : BFD_RELOC_MMIX_PUSHJ_1 4275 -- : BFD_RELOC_MMIX_PUSHJ_2 4276 -- : BFD_RELOC_MMIX_PUSHJ_3 4277 -- : BFD_RELOC_MMIX_PUSHJ_STUBBABLE 4278 These are relocations for the PUSHJ instruction. 4279 4280 -- : BFD_RELOC_MMIX_JMP 4281 -- : BFD_RELOC_MMIX_JMP_1 4282 -- : BFD_RELOC_MMIX_JMP_2 4283 -- : BFD_RELOC_MMIX_JMP_3 4284 These are relocations for the JMP instruction. 4285 4286 -- : BFD_RELOC_MMIX_ADDR19 4287 This is a relocation for a relative address as in a GETA 4288 instruction or a branch. 4289 4290 -- : BFD_RELOC_MMIX_ADDR27 4291 This is a relocation for a relative address as in a JMP 4292 instruction. 4293 4294 -- : BFD_RELOC_MMIX_REG_OR_BYTE 4295 This is a relocation for an instruction field that may be a general 4296 register or a value 0..255. 4297 4298 -- : BFD_RELOC_MMIX_REG 4299 This is a relocation for an instruction field that may be a general 4300 register. 4301 4302 -- : BFD_RELOC_MMIX_BASE_PLUS_OFFSET 4303 This is a relocation for two instruction fields holding a register 4304 and an offset, the equivalent of the relocation. 4305 4306 -- : BFD_RELOC_MMIX_LOCAL 4307 This relocation is an assertion that the expression is not 4308 allocated as a global register. It does not modify contents. 4309 4310 -- : BFD_RELOC_AVR_7_PCREL 4311 This is a 16 bit reloc for the AVR that stores 8 bit pc relative 4312 short offset into 7 bits. 4313 4314 -- : BFD_RELOC_AVR_13_PCREL 4315 This is a 16 bit reloc for the AVR that stores 13 bit pc relative 4316 short offset into 12 bits. 4317 4318 -- : BFD_RELOC_AVR_16_PM 4319 This is a 16 bit reloc for the AVR that stores 17 bit value 4320 (usually program memory address) into 16 bits. 4321 4322 -- : BFD_RELOC_AVR_LO8_LDI 4323 This is a 16 bit reloc for the AVR that stores 8 bit value (usually 4324 data memory address) into 8 bit immediate value of LDI insn. 4325 4326 -- : BFD_RELOC_AVR_HI8_LDI 4327 This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 4328 bit of data memory address) into 8 bit immediate value of LDI insn. 4329 4330 -- : BFD_RELOC_AVR_HH8_LDI 4331 This is a 16 bit reloc for the AVR that stores 8 bit value (most 4332 high 8 bit of program memory address) into 8 bit immediate value 4333 of LDI insn. 4334 4335 -- : BFD_RELOC_AVR_MS8_LDI 4336 This is a 16 bit reloc for the AVR that stores 8 bit value (most 4337 high 8 bit of 32 bit value) into 8 bit immediate value of LDI insn. 4338 4339 -- : BFD_RELOC_AVR_LO8_LDI_NEG 4340 This is a 16 bit reloc for the AVR that stores negated 8 bit value 4341 (usually data memory address) into 8 bit immediate value of SUBI 4342 insn. 4343 4344 -- : BFD_RELOC_AVR_HI8_LDI_NEG 4345 This is a 16 bit reloc for the AVR that stores negated 8 bit value 4346 (high 8 bit of data memory address) into 8 bit immediate value of 4347 SUBI insn. 4348 4349 -- : BFD_RELOC_AVR_HH8_LDI_NEG 4350 This is a 16 bit reloc for the AVR that stores negated 8 bit value 4351 (most high 8 bit of program memory address) into 8 bit immediate 4352 value of LDI or SUBI insn. 4353 4354 -- : BFD_RELOC_AVR_MS8_LDI_NEG 4355 This is a 16 bit reloc for the AVR that stores negated 8 bit value 4356 (msb of 32 bit value) into 8 bit immediate value of LDI insn. 4357 4358 -- : BFD_RELOC_AVR_LO8_LDI_PM 4359 This is a 16 bit reloc for the AVR that stores 8 bit value (usually 4360 command address) into 8 bit immediate value of LDI insn. 4361 4362 -- : BFD_RELOC_AVR_HI8_LDI_PM 4363 This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 4364 bit of command address) into 8 bit immediate value of LDI insn. 4365 4366 -- : BFD_RELOC_AVR_HH8_LDI_PM 4367 This is a 16 bit reloc for the AVR that stores 8 bit value (most 4368 high 8 bit of command address) into 8 bit immediate value of LDI 4369 insn. 4370 4371 -- : BFD_RELOC_AVR_LO8_LDI_PM_NEG 4372 This is a 16 bit reloc for the AVR that stores negated 8 bit value 4373 (usually command address) into 8 bit immediate value of SUBI insn. 4374 4375 -- : BFD_RELOC_AVR_HI8_LDI_PM_NEG 4376 This is a 16 bit reloc for the AVR that stores negated 8 bit value 4377 (high 8 bit of 16 bit command address) into 8 bit immediate value 4378 of SUBI insn. 4379 4380 -- : BFD_RELOC_AVR_HH8_LDI_PM_NEG 4381 This is a 16 bit reloc for the AVR that stores negated 8 bit value 4382 (high 6 bit of 22 bit command address) into 8 bit immediate value 4383 of SUBI insn. 4384 4385 -- : BFD_RELOC_AVR_CALL 4386 This is a 32 bit reloc for the AVR that stores 23 bit value into 4387 22 bits. 4388 4389 -- : BFD_RELOC_AVR_LDI 4390 This is a 16 bit reloc for the AVR that stores all needed bits for 4391 absolute addressing with ldi with overflow check to linktime 4392 4393 -- : BFD_RELOC_AVR_6 4394 This is a 6 bit reloc for the AVR that stores offset for ldd/std 4395 instructions 4396 4397 -- : BFD_RELOC_AVR_6_ADIW 4398 This is a 6 bit reloc for the AVR that stores offset for adiw/sbiw 4399 instructions 4400 4401 -- : BFD_RELOC_390_12 4402 Direct 12 bit. 4403 4404 -- : BFD_RELOC_390_GOT12 4405 12 bit GOT offset. 4406 4407 -- : BFD_RELOC_390_PLT32 4408 32 bit PC relative PLT address. 4409 4410 -- : BFD_RELOC_390_COPY 4411 Copy symbol at runtime. 4412 4413 -- : BFD_RELOC_390_GLOB_DAT 4414 Create GOT entry. 4415 4416 -- : BFD_RELOC_390_JMP_SLOT 4417 Create PLT entry. 4418 4419 -- : BFD_RELOC_390_RELATIVE 4420 Adjust by program base. 4421 4422 -- : BFD_RELOC_390_GOTPC 4423 32 bit PC relative offset to GOT. 4424 4425 -- : BFD_RELOC_390_GOT16 4426 16 bit GOT offset. 4427 4428 -- : BFD_RELOC_390_PC16DBL 4429 PC relative 16 bit shifted by 1. 4430 4431 -- : BFD_RELOC_390_PLT16DBL 4432 16 bit PC rel. PLT shifted by 1. 4433 4434 -- : BFD_RELOC_390_PC32DBL 4435 PC relative 32 bit shifted by 1. 4436 4437 -- : BFD_RELOC_390_PLT32DBL 4438 32 bit PC rel. PLT shifted by 1. 4439 4440 -- : BFD_RELOC_390_GOTPCDBL 4441 32 bit PC rel. GOT shifted by 1. 4442 4443 -- : BFD_RELOC_390_GOT64 4444 64 bit GOT offset. 4445 4446 -- : BFD_RELOC_390_PLT64 4447 64 bit PC relative PLT address. 4448 4449 -- : BFD_RELOC_390_GOTENT 4450 32 bit rel. offset to GOT entry. 4451 4452 -- : BFD_RELOC_390_GOTOFF64 4453 64 bit offset to GOT. 4454 4455 -- : BFD_RELOC_390_GOTPLT12 4456 12-bit offset to symbol-entry within GOT, with PLT handling. 4457 4458 -- : BFD_RELOC_390_GOTPLT16 4459 16-bit offset to symbol-entry within GOT, with PLT handling. 4460 4461 -- : BFD_RELOC_390_GOTPLT32 4462 32-bit offset to symbol-entry within GOT, with PLT handling. 4463 4464 -- : BFD_RELOC_390_GOTPLT64 4465 64-bit offset to symbol-entry within GOT, with PLT handling. 4466 4467 -- : BFD_RELOC_390_GOTPLTENT 4468 32-bit rel. offset to symbol-entry within GOT, with PLT handling. 4469 4470 -- : BFD_RELOC_390_PLTOFF16 4471 16-bit rel. offset from the GOT to a PLT entry. 4472 4473 -- : BFD_RELOC_390_PLTOFF32 4474 32-bit rel. offset from the GOT to a PLT entry. 4475 4476 -- : BFD_RELOC_390_PLTOFF64 4477 64-bit rel. offset from the GOT to a PLT entry. 4478 4479 -- : BFD_RELOC_390_TLS_LOAD 4480 -- : BFD_RELOC_390_TLS_GDCALL 4481 -- : BFD_RELOC_390_TLS_LDCALL 4482 -- : BFD_RELOC_390_TLS_GD32 4483 -- : BFD_RELOC_390_TLS_GD64 4484 -- : BFD_RELOC_390_TLS_GOTIE12 4485 -- : BFD_RELOC_390_TLS_GOTIE32 4486 -- : BFD_RELOC_390_TLS_GOTIE64 4487 -- : BFD_RELOC_390_TLS_LDM32 4488 -- : BFD_RELOC_390_TLS_LDM64 4489 -- : BFD_RELOC_390_TLS_IE32 4490 -- : BFD_RELOC_390_TLS_IE64 4491 -- : BFD_RELOC_390_TLS_IEENT 4492 -- : BFD_RELOC_390_TLS_LE32 4493 -- : BFD_RELOC_390_TLS_LE64 4494 -- : BFD_RELOC_390_TLS_LDO32 4495 -- : BFD_RELOC_390_TLS_LDO64 4496 -- : BFD_RELOC_390_TLS_DTPMOD 4497 -- : BFD_RELOC_390_TLS_DTPOFF 4498 -- : BFD_RELOC_390_TLS_TPOFF 4499 s390 tls relocations. 4500 4501 -- : BFD_RELOC_390_20 4502 -- : BFD_RELOC_390_GOT20 4503 -- : BFD_RELOC_390_GOTPLT20 4504 -- : BFD_RELOC_390_TLS_GOTIE20 4505 Long displacement extension. 4506 4507 -- : BFD_RELOC_IP2K_FR9 4508 Scenix IP2K - 9-bit register number / data address 4509 4510 -- : BFD_RELOC_IP2K_BANK 4511 Scenix IP2K - 4-bit register/data bank number 4512 4513 -- : BFD_RELOC_IP2K_ADDR16CJP 4514 Scenix IP2K - low 13 bits of instruction word address 4515 4516 -- : BFD_RELOC_IP2K_PAGE3 4517 Scenix IP2K - high 3 bits of instruction word address 4518 4519 -- : BFD_RELOC_IP2K_LO8DATA 4520 -- : BFD_RELOC_IP2K_HI8DATA 4521 -- : BFD_RELOC_IP2K_EX8DATA 4522 Scenix IP2K - ext/low/high 8 bits of data address 4523 4524 -- : BFD_RELOC_IP2K_LO8INSN 4525 -- : BFD_RELOC_IP2K_HI8INSN 4526 Scenix IP2K - low/high 8 bits of instruction word address 4527 4528 -- : BFD_RELOC_IP2K_PC_SKIP 4529 Scenix IP2K - even/odd PC modifier to modify snb pcl.0 4530 4531 -- : BFD_RELOC_IP2K_TEXT 4532 Scenix IP2K - 16 bit word address in text section. 4533 4534 -- : BFD_RELOC_IP2K_FR_OFFSET 4535 Scenix IP2K - 7-bit sp or dp offset 4536 4537 -- : BFD_RELOC_VPE4KMATH_DATA 4538 -- : BFD_RELOC_VPE4KMATH_INSN 4539 Scenix VPE4K coprocessor - data/insn-space addressing 4540 4541 -- : BFD_RELOC_VTABLE_INHERIT 4542 -- : BFD_RELOC_VTABLE_ENTRY 4543 These two relocations are used by the linker to determine which of 4544 the entries in a C++ virtual function table are actually used. 4545 When the -gc-sections option is given, the linker will zero out 4546 the entries that are not used, so that the code for those 4547 functions need not be included in the output. 4548 4549 VTABLE_INHERIT is a zero-space relocation used to describe to the 4550 linker the inheritance tree of a C++ virtual function table. The 4551 relocation's symbol should be the parent class' vtable, and the 4552 relocation should be located at the child vtable. 4553 4554 VTABLE_ENTRY is a zero-space relocation that describes the use of a 4555 virtual function table entry. The reloc's symbol should refer to 4556 the table of the class mentioned in the code. Off of that base, 4557 an offset describes the entry that is being used. For Rela hosts, 4558 this offset is stored in the reloc's addend. For Rel hosts, we 4559 are forced to put this offset in the reloc's section offset. 4560 4561 -- : BFD_RELOC_IA64_IMM14 4562 -- : BFD_RELOC_IA64_IMM22 4563 -- : BFD_RELOC_IA64_IMM64 4564 -- : BFD_RELOC_IA64_DIR32MSB 4565 -- : BFD_RELOC_IA64_DIR32LSB 4566 -- : BFD_RELOC_IA64_DIR64MSB 4567 -- : BFD_RELOC_IA64_DIR64LSB 4568 -- : BFD_RELOC_IA64_GPREL22 4569 -- : BFD_RELOC_IA64_GPREL64I 4570 -- : BFD_RELOC_IA64_GPREL32MSB 4571 -- : BFD_RELOC_IA64_GPREL32LSB 4572 -- : BFD_RELOC_IA64_GPREL64MSB 4573 -- : BFD_RELOC_IA64_GPREL64LSB 4574 -- : BFD_RELOC_IA64_LTOFF22 4575 -- : BFD_RELOC_IA64_LTOFF64I 4576 -- : BFD_RELOC_IA64_PLTOFF22 4577 -- : BFD_RELOC_IA64_PLTOFF64I 4578 -- : BFD_RELOC_IA64_PLTOFF64MSB 4579 -- : BFD_RELOC_IA64_PLTOFF64LSB 4580 -- : BFD_RELOC_IA64_FPTR64I 4581 -- : BFD_RELOC_IA64_FPTR32MSB 4582 -- : BFD_RELOC_IA64_FPTR32LSB 4583 -- : BFD_RELOC_IA64_FPTR64MSB 4584 -- : BFD_RELOC_IA64_FPTR64LSB 4585 -- : BFD_RELOC_IA64_PCREL21B 4586 -- : BFD_RELOC_IA64_PCREL21BI 4587 -- : BFD_RELOC_IA64_PCREL21M 4588 -- : BFD_RELOC_IA64_PCREL21F 4589 -- : BFD_RELOC_IA64_PCREL22 4590 -- : BFD_RELOC_IA64_PCREL60B 4591 -- : BFD_RELOC_IA64_PCREL64I 4592 -- : BFD_RELOC_IA64_PCREL32MSB 4593 -- : BFD_RELOC_IA64_PCREL32LSB 4594 -- : BFD_RELOC_IA64_PCREL64MSB 4595 -- : BFD_RELOC_IA64_PCREL64LSB 4596 -- : BFD_RELOC_IA64_LTOFF_FPTR22 4597 -- : BFD_RELOC_IA64_LTOFF_FPTR64I 4598 -- : BFD_RELOC_IA64_LTOFF_FPTR32MSB 4599 -- : BFD_RELOC_IA64_LTOFF_FPTR32LSB 4600 -- : BFD_RELOC_IA64_LTOFF_FPTR64MSB 4601 -- : BFD_RELOC_IA64_LTOFF_FPTR64LSB 4602 -- : BFD_RELOC_IA64_SEGREL32MSB 4603 -- : BFD_RELOC_IA64_SEGREL32LSB 4604 -- : BFD_RELOC_IA64_SEGREL64MSB 4605 -- : BFD_RELOC_IA64_SEGREL64LSB 4606 -- : BFD_RELOC_IA64_SECREL32MSB 4607 -- : BFD_RELOC_IA64_SECREL32LSB 4608 -- : BFD_RELOC_IA64_SECREL64MSB 4609 -- : BFD_RELOC_IA64_SECREL64LSB 4610 -- : BFD_RELOC_IA64_REL32MSB 4611 -- : BFD_RELOC_IA64_REL32LSB 4612 -- : BFD_RELOC_IA64_REL64MSB 4613 -- : BFD_RELOC_IA64_REL64LSB 4614 -- : BFD_RELOC_IA64_LTV32MSB 4615 -- : BFD_RELOC_IA64_LTV32LSB 4616 -- : BFD_RELOC_IA64_LTV64MSB 4617 -- : BFD_RELOC_IA64_LTV64LSB 4618 -- : BFD_RELOC_IA64_IPLTMSB 4619 -- : BFD_RELOC_IA64_IPLTLSB 4620 -- : BFD_RELOC_IA64_COPY 4621 -- : BFD_RELOC_IA64_LTOFF22X 4622 -- : BFD_RELOC_IA64_LDXMOV 4623 -- : BFD_RELOC_IA64_TPREL14 4624 -- : BFD_RELOC_IA64_TPREL22 4625 -- : BFD_RELOC_IA64_TPREL64I 4626 -- : BFD_RELOC_IA64_TPREL64MSB 4627 -- : BFD_RELOC_IA64_TPREL64LSB 4628 -- : BFD_RELOC_IA64_LTOFF_TPREL22 4629 -- : BFD_RELOC_IA64_DTPMOD64MSB 4630 -- : BFD_RELOC_IA64_DTPMOD64LSB 4631 -- : BFD_RELOC_IA64_LTOFF_DTPMOD22 4632 -- : BFD_RELOC_IA64_DTPREL14 4633 -- : BFD_RELOC_IA64_DTPREL22 4634 -- : BFD_RELOC_IA64_DTPREL64I 4635 -- : BFD_RELOC_IA64_DTPREL32MSB 4636 -- : BFD_RELOC_IA64_DTPREL32LSB 4637 -- : BFD_RELOC_IA64_DTPREL64MSB 4638 -- : BFD_RELOC_IA64_DTPREL64LSB 4639 -- : BFD_RELOC_IA64_LTOFF_DTPREL22 4640 Intel IA64 Relocations. 4641 4642 -- : BFD_RELOC_M68HC11_HI8 4643 Motorola 68HC11 reloc. This is the 8 bit high part of an absolute 4644 address. 4645 4646 -- : BFD_RELOC_M68HC11_LO8 4647 Motorola 68HC11 reloc. This is the 8 bit low part of an absolute 4648 address. 4649 4650 -- : BFD_RELOC_M68HC11_3B 4651 Motorola 68HC11 reloc. This is the 3 bit of a value. 4652 4653 -- : BFD_RELOC_M68HC11_RL_JUMP 4654 Motorola 68HC11 reloc. This reloc marks the beginning of a 4655 jump/call instruction. It is used for linker relaxation to 4656 correctly identify beginning of instruction and change some 4657 branches to use PC-relative addressing mode. 4658 4659 -- : BFD_RELOC_M68HC11_RL_GROUP 4660 Motorola 68HC11 reloc. This reloc marks a group of several 4661 instructions that gcc generates and for which the linker 4662 relaxation pass can modify and/or remove some of them. 4663 4664 -- : BFD_RELOC_M68HC11_LO16 4665 Motorola 68HC11 reloc. This is the 16-bit lower part of an 4666 address. It is used for 'call' instruction to specify the symbol 4667 address without any special transformation (due to memory bank 4668 window). 4669 4670 -- : BFD_RELOC_M68HC11_PAGE 4671 Motorola 68HC11 reloc. This is a 8-bit reloc that specifies the 4672 page number of an address. It is used by 'call' instruction to 4673 specify the page number of the symbol. 4674 4675 -- : BFD_RELOC_M68HC11_24 4676 Motorola 68HC11 reloc. This is a 24-bit reloc that represents the 4677 address with a 16-bit value and a 8-bit page number. The symbol 4678 address is transformed to follow the 16K memory bank of 68HC12 4679 (seen as mapped in the window). 4680 4681 -- : BFD_RELOC_M68HC12_5B 4682 Motorola 68HC12 reloc. This is the 5 bits of a value. 4683 4684 -- : BFD_RELOC_16C_NUM08 4685 -- : BFD_RELOC_16C_NUM08_C 4686 -- : BFD_RELOC_16C_NUM16 4687 -- : BFD_RELOC_16C_NUM16_C 4688 -- : BFD_RELOC_16C_NUM32 4689 -- : BFD_RELOC_16C_NUM32_C 4690 -- : BFD_RELOC_16C_DISP04 4691 -- : BFD_RELOC_16C_DISP04_C 4692 -- : BFD_RELOC_16C_DISP08 4693 -- : BFD_RELOC_16C_DISP08_C 4694 -- : BFD_RELOC_16C_DISP16 4695 -- : BFD_RELOC_16C_DISP16_C 4696 -- : BFD_RELOC_16C_DISP24 4697 -- : BFD_RELOC_16C_DISP24_C 4698 -- : BFD_RELOC_16C_DISP24a 4699 -- : BFD_RELOC_16C_DISP24a_C 4700 -- : BFD_RELOC_16C_REG04 4701 -- : BFD_RELOC_16C_REG04_C 4702 -- : BFD_RELOC_16C_REG04a 4703 -- : BFD_RELOC_16C_REG04a_C 4704 -- : BFD_RELOC_16C_REG14 4705 -- : BFD_RELOC_16C_REG14_C 4706 -- : BFD_RELOC_16C_REG16 4707 -- : BFD_RELOC_16C_REG16_C 4708 -- : BFD_RELOC_16C_REG20 4709 -- : BFD_RELOC_16C_REG20_C 4710 -- : BFD_RELOC_16C_ABS20 4711 -- : BFD_RELOC_16C_ABS20_C 4712 -- : BFD_RELOC_16C_ABS24 4713 -- : BFD_RELOC_16C_ABS24_C 4714 -- : BFD_RELOC_16C_IMM04 4715 -- : BFD_RELOC_16C_IMM04_C 4716 -- : BFD_RELOC_16C_IMM16 4717 -- : BFD_RELOC_16C_IMM16_C 4718 -- : BFD_RELOC_16C_IMM20 4719 -- : BFD_RELOC_16C_IMM20_C 4720 -- : BFD_RELOC_16C_IMM24 4721 -- : BFD_RELOC_16C_IMM24_C 4722 -- : BFD_RELOC_16C_IMM32 4723 -- : BFD_RELOC_16C_IMM32_C 4724 NS CR16C Relocations. 4725 4726 -- : BFD_RELOC_CRX_REL4 4727 -- : BFD_RELOC_CRX_REL8 4728 -- : BFD_RELOC_CRX_REL8_CMP 4729 -- : BFD_RELOC_CRX_REL16 4730 -- : BFD_RELOC_CRX_REL24 4731 -- : BFD_RELOC_CRX_REL32 4732 -- : BFD_RELOC_CRX_REGREL12 4733 -- : BFD_RELOC_CRX_REGREL22 4734 -- : BFD_RELOC_CRX_REGREL28 4735 -- : BFD_RELOC_CRX_REGREL32 4736 -- : BFD_RELOC_CRX_ABS16 4737 -- : BFD_RELOC_CRX_ABS32 4738 -- : BFD_RELOC_CRX_NUM8 4739 -- : BFD_RELOC_CRX_NUM16 4740 -- : BFD_RELOC_CRX_NUM32 4741 -- : BFD_RELOC_CRX_IMM16 4742 -- : BFD_RELOC_CRX_IMM32 4743 -- : BFD_RELOC_CRX_SWITCH8 4744 -- : BFD_RELOC_CRX_SWITCH16 4745 -- : BFD_RELOC_CRX_SWITCH32 4746 NS CRX Relocations. 4747 4748 -- : BFD_RELOC_CRIS_BDISP8 4749 -- : BFD_RELOC_CRIS_UNSIGNED_5 4750 -- : BFD_RELOC_CRIS_SIGNED_6 4751 -- : BFD_RELOC_CRIS_UNSIGNED_6 4752 -- : BFD_RELOC_CRIS_SIGNED_8 4753 -- : BFD_RELOC_CRIS_UNSIGNED_8 4754 -- : BFD_RELOC_CRIS_SIGNED_16 4755 -- : BFD_RELOC_CRIS_UNSIGNED_16 4756 -- : BFD_RELOC_CRIS_LAPCQ_OFFSET 4757 -- : BFD_RELOC_CRIS_UNSIGNED_4 4758 These relocs are only used within the CRIS assembler. They are not 4759 (at present) written to any object files. 4760 4761 -- : BFD_RELOC_CRIS_COPY 4762 -- : BFD_RELOC_CRIS_GLOB_DAT 4763 -- : BFD_RELOC_CRIS_JUMP_SLOT 4764 -- : BFD_RELOC_CRIS_RELATIVE 4765 Relocs used in ELF shared libraries for CRIS. 4766 4767 -- : BFD_RELOC_CRIS_32_GOT 4768 32-bit offset to symbol-entry within GOT. 4769 4770 -- : BFD_RELOC_CRIS_16_GOT 4771 16-bit offset to symbol-entry within GOT. 4772 4773 -- : BFD_RELOC_CRIS_32_GOTPLT 4774 32-bit offset to symbol-entry within GOT, with PLT handling. 4775 4776 -- : BFD_RELOC_CRIS_16_GOTPLT 4777 16-bit offset to symbol-entry within GOT, with PLT handling. 4778 4779 -- : BFD_RELOC_CRIS_32_GOTREL 4780 32-bit offset to symbol, relative to GOT. 4781 4782 -- : BFD_RELOC_CRIS_32_PLT_GOTREL 4783 32-bit offset to symbol with PLT entry, relative to GOT. 4784 4785 -- : BFD_RELOC_CRIS_32_PLT_PCREL 4786 32-bit offset to symbol with PLT entry, relative to this 4787 relocation. 4788 4789 -- : BFD_RELOC_860_COPY 4790 -- : BFD_RELOC_860_GLOB_DAT 4791 -- : BFD_RELOC_860_JUMP_SLOT 4792 -- : BFD_RELOC_860_RELATIVE 4793 -- : BFD_RELOC_860_PC26 4794 -- : BFD_RELOC_860_PLT26 4795 -- : BFD_RELOC_860_PC16 4796 -- : BFD_RELOC_860_LOW0 4797 -- : BFD_RELOC_860_SPLIT0 4798 -- : BFD_RELOC_860_LOW1 4799 -- : BFD_RELOC_860_SPLIT1 4800 -- : BFD_RELOC_860_LOW2 4801 -- : BFD_RELOC_860_SPLIT2 4802 -- : BFD_RELOC_860_LOW3 4803 -- : BFD_RELOC_860_LOGOT0 4804 -- : BFD_RELOC_860_SPGOT0 4805 -- : BFD_RELOC_860_LOGOT1 4806 -- : BFD_RELOC_860_SPGOT1 4807 -- : BFD_RELOC_860_LOGOTOFF0 4808 -- : BFD_RELOC_860_SPGOTOFF0 4809 -- : BFD_RELOC_860_LOGOTOFF1 4810 -- : BFD_RELOC_860_SPGOTOFF1 4811 -- : BFD_RELOC_860_LOGOTOFF2 4812 -- : BFD_RELOC_860_LOGOTOFF3 4813 -- : BFD_RELOC_860_LOPC 4814 -- : BFD_RELOC_860_HIGHADJ 4815 -- : BFD_RELOC_860_HAGOT 4816 -- : BFD_RELOC_860_HAGOTOFF 4817 -- : BFD_RELOC_860_HAPC 4818 -- : BFD_RELOC_860_HIGH 4819 -- : BFD_RELOC_860_HIGOT 4820 -- : BFD_RELOC_860_HIGOTOFF 4821 Intel i860 Relocations. 4822 4823 -- : BFD_RELOC_OPENRISC_ABS_26 4824 -- : BFD_RELOC_OPENRISC_REL_26 4825 OpenRISC Relocations. 4826 4827 -- : BFD_RELOC_H8_DIR16A8 4828 -- : BFD_RELOC_H8_DIR16R8 4829 -- : BFD_RELOC_H8_DIR24A8 4830 -- : BFD_RELOC_H8_DIR24R8 4831 -- : BFD_RELOC_H8_DIR32A16 4832 H8 elf Relocations. 4833 4834 -- : BFD_RELOC_XSTORMY16_REL_12 4835 -- : BFD_RELOC_XSTORMY16_12 4836 -- : BFD_RELOC_XSTORMY16_24 4837 -- : BFD_RELOC_XSTORMY16_FPTR16 4838 Sony Xstormy16 Relocations. 4839 4840 -- : BFD_RELOC_XC16X_PAG 4841 -- : BFD_RELOC_XC16X_POF 4842 -- : BFD_RELOC_XC16X_SEG 4843 -- : BFD_RELOC_XC16X_SOF 4844 Infineon Relocations. 4845 4846 -- : BFD_RELOC_VAX_GLOB_DAT 4847 -- : BFD_RELOC_VAX_JMP_SLOT 4848 -- : BFD_RELOC_VAX_RELATIVE 4849 Relocations used by VAX ELF. 4850 4851 -- : BFD_RELOC_MT_PC16 4852 Morpho MT - 16 bit immediate relocation. 4853 4854 -- : BFD_RELOC_MT_HI16 4855 Morpho MT - Hi 16 bits of an address. 4856 4857 -- : BFD_RELOC_MT_LO16 4858 Morpho MT - Low 16 bits of an address. 4859 4860 -- : BFD_RELOC_MT_GNU_VTINHERIT 4861 Morpho MT - Used to tell the linker which vtable entries are used. 4862 4863 -- : BFD_RELOC_MT_GNU_VTENTRY 4864 Morpho MT - Used to tell the linker which vtable entries are used. 4865 4866 -- : BFD_RELOC_MT_PCINSN8 4867 Morpho MT - 8 bit immediate relocation. 4868 4869 -- : BFD_RELOC_MSP430_10_PCREL 4870 -- : BFD_RELOC_MSP430_16_PCREL 4871 -- : BFD_RELOC_MSP430_16 4872 -- : BFD_RELOC_MSP430_16_PCREL_BYTE 4873 -- : BFD_RELOC_MSP430_16_BYTE 4874 -- : BFD_RELOC_MSP430_2X_PCREL 4875 -- : BFD_RELOC_MSP430_RL_PCREL 4876 msp430 specific relocation codes 4877 4878 -- : BFD_RELOC_IQ2000_OFFSET_16 4879 -- : BFD_RELOC_IQ2000_OFFSET_21 4880 -- : BFD_RELOC_IQ2000_UHI16 4881 IQ2000 Relocations. 4882 4883 -- : BFD_RELOC_XTENSA_RTLD 4884 Special Xtensa relocation used only by PLT entries in ELF shared 4885 objects to indicate that the runtime linker should set the value 4886 to one of its own internal functions or data structures. 4887 4888 -- : BFD_RELOC_XTENSA_GLOB_DAT 4889 -- : BFD_RELOC_XTENSA_JMP_SLOT 4890 -- : BFD_RELOC_XTENSA_RELATIVE 4891 Xtensa relocations for ELF shared objects. 4892 4893 -- : BFD_RELOC_XTENSA_PLT 4894 Xtensa relocation used in ELF object files for symbols that may 4895 require PLT entries. Otherwise, this is just a generic 32-bit 4896 relocation. 4897 4898 -- : BFD_RELOC_XTENSA_DIFF8 4899 -- : BFD_RELOC_XTENSA_DIFF16 4900 -- : BFD_RELOC_XTENSA_DIFF32 4901 Xtensa relocations to mark the difference of two local symbols. 4902 These are only needed to support linker relaxation and can be 4903 ignored when not relaxing. The field is set to the value of the 4904 difference assuming no relaxation. The relocation encodes the 4905 position of the first symbol so the linker can determine whether 4906 to adjust the field value. 4907 4908 -- : BFD_RELOC_XTENSA_SLOT0_OP 4909 -- : BFD_RELOC_XTENSA_SLOT1_OP 4910 -- : BFD_RELOC_XTENSA_SLOT2_OP 4911 -- : BFD_RELOC_XTENSA_SLOT3_OP 4912 -- : BFD_RELOC_XTENSA_SLOT4_OP 4913 -- : BFD_RELOC_XTENSA_SLOT5_OP 4914 -- : BFD_RELOC_XTENSA_SLOT6_OP 4915 -- : BFD_RELOC_XTENSA_SLOT7_OP 4916 -- : BFD_RELOC_XTENSA_SLOT8_OP 4917 -- : BFD_RELOC_XTENSA_SLOT9_OP 4918 -- : BFD_RELOC_XTENSA_SLOT10_OP 4919 -- : BFD_RELOC_XTENSA_SLOT11_OP 4920 -- : BFD_RELOC_XTENSA_SLOT12_OP 4921 -- : BFD_RELOC_XTENSA_SLOT13_OP 4922 -- : BFD_RELOC_XTENSA_SLOT14_OP 4923 Generic Xtensa relocations for instruction operands. Only the slot 4924 number is encoded in the relocation. The relocation applies to the 4925 last PC-relative immediate operand, or if there are no PC-relative 4926 immediates, to the last immediate operand. 4927 4928 -- : BFD_RELOC_XTENSA_SLOT0_ALT 4929 -- : BFD_RELOC_XTENSA_SLOT1_ALT 4930 -- : BFD_RELOC_XTENSA_SLOT2_ALT 4931 -- : BFD_RELOC_XTENSA_SLOT3_ALT 4932 -- : BFD_RELOC_XTENSA_SLOT4_ALT 4933 -- : BFD_RELOC_XTENSA_SLOT5_ALT 4934 -- : BFD_RELOC_XTENSA_SLOT6_ALT 4935 -- : BFD_RELOC_XTENSA_SLOT7_ALT 4936 -- : BFD_RELOC_XTENSA_SLOT8_ALT 4937 -- : BFD_RELOC_XTENSA_SLOT9_ALT 4938 -- : BFD_RELOC_XTENSA_SLOT10_ALT 4939 -- : BFD_RELOC_XTENSA_SLOT11_ALT 4940 -- : BFD_RELOC_XTENSA_SLOT12_ALT 4941 -- : BFD_RELOC_XTENSA_SLOT13_ALT 4942 -- : BFD_RELOC_XTENSA_SLOT14_ALT 4943 Alternate Xtensa relocations. Only the slot is encoded in the 4944 relocation. The meaning of these relocations is opcode-specific. 4945 4946 -- : BFD_RELOC_XTENSA_OP0 4947 -- : BFD_RELOC_XTENSA_OP1 4948 -- : BFD_RELOC_XTENSA_OP2 4949 Xtensa relocations for backward compatibility. These have all been 4950 replaced by BFD_RELOC_XTENSA_SLOT0_OP. 4951 4952 -- : BFD_RELOC_XTENSA_ASM_EXPAND 4953 Xtensa relocation to mark that the assembler expanded the 4954 instructions from an original target. The expansion size is 4955 encoded in the reloc size. 4956 4957 -- : BFD_RELOC_XTENSA_ASM_SIMPLIFY 4958 Xtensa relocation to mark that the linker should simplify 4959 assembler-expanded instructions. This is commonly used internally 4960 by the linker after analysis of a BFD_RELOC_XTENSA_ASM_EXPAND. 4961 4962 -- : BFD_RELOC_Z80_DISP8 4963 8 bit signed offset in (ix+d) or (iy+d). 4964 4965 -- : BFD_RELOC_Z8K_DISP7 4966 DJNZ offset. 4967 4968 -- : BFD_RELOC_Z8K_CALLR 4969 CALR offset. 4970 4971 -- : BFD_RELOC_Z8K_IMM4L 4972 4 bit value. 4973 4974 4975 typedef enum bfd_reloc_code_real bfd_reloc_code_real_type; 4976 4977 2.10.2.2 `bfd_reloc_type_lookup' 4978 ................................ 4979 4980 *Synopsis* 4981 reloc_howto_type *bfd_reloc_type_lookup 4982 (bfd *abfd, bfd_reloc_code_real_type code); 4983 *Description* 4984 Return a pointer to a howto structure which, when invoked, will perform 4985 the relocation CODE on data from the architecture noted. 4986 4987 2.10.2.3 `bfd_default_reloc_type_lookup' 4988 ........................................ 4989 4990 *Synopsis* 4991 reloc_howto_type *bfd_default_reloc_type_lookup 4992 (bfd *abfd, bfd_reloc_code_real_type code); 4993 *Description* 4994 Provides a default relocation lookup routine for any architecture. 4995 4996 2.10.2.4 `bfd_get_reloc_code_name' 4997 .................................. 4998 4999 *Synopsis* 5000 const char *bfd_get_reloc_code_name (bfd_reloc_code_real_type code); 5001 *Description* 5002 Provides a printable name for the supplied relocation code. Useful 5003 mainly for printing error messages. 5004 5005 2.10.2.5 `bfd_generic_relax_section' 5006 .................................... 5007 5008 *Synopsis* 5009 bfd_boolean bfd_generic_relax_section 5010 (bfd *abfd, 5011 asection *section, 5012 struct bfd_link_info *, 5013 bfd_boolean *); 5014 *Description* 5015 Provides default handling for relaxing for back ends which don't do 5016 relaxing. 5017 5018 2.10.2.6 `bfd_generic_gc_sections' 5019 .................................. 5020 5021 *Synopsis* 5022 bfd_boolean bfd_generic_gc_sections 5023 (bfd *, struct bfd_link_info *); 5024 *Description* 5025 Provides default handling for relaxing for back ends which don't do 5026 section gc - i.e., does nothing. 5027 5028 2.10.2.7 `bfd_generic_merge_sections' 5029 ..................................... 5030 5031 *Synopsis* 5032 bfd_boolean bfd_generic_merge_sections 5033 (bfd *, struct bfd_link_info *); 5034 *Description* 5035 Provides default handling for SEC_MERGE section merging for back ends 5036 which don't have SEC_MERGE support - i.e., does nothing. 5037 5038 2.10.2.8 `bfd_generic_get_relocated_section_contents' 5039 ..................................................... 5040 5041 *Synopsis* 5042 bfd_byte *bfd_generic_get_relocated_section_contents 5043 (bfd *abfd, 5044 struct bfd_link_info *link_info, 5045 struct bfd_link_order *link_order, 5046 bfd_byte *data, 5047 bfd_boolean relocatable, 5048 asymbol **symbols); 5049 *Description* 5050 Provides default handling of relocation effort for back ends which 5051 can't be bothered to do it efficiently. 5052 5053 5054 File: bfd.info, Node: Core Files, Next: Targets, Prev: Relocations, Up: BFD front end 5055 5056 2.11 Core files 5057 =============== 5058 5059 2.11.1 Core file functions 5060 -------------------------- 5061 5062 *Description* 5063 These are functions pertaining to core files. 5064 5065 2.11.1.1 `bfd_core_file_failing_command' 5066 ........................................ 5067 5068 *Synopsis* 5069 const char *bfd_core_file_failing_command (bfd *abfd); 5070 *Description* 5071 Return a read-only string explaining which program was running when it 5072 failed and produced the core file ABFD. 5073 5074 2.11.1.2 `bfd_core_file_failing_signal' 5075 ....................................... 5076 5077 *Synopsis* 5078 int bfd_core_file_failing_signal (bfd *abfd); 5079 *Description* 5080 Returns the signal number which caused the core dump which generated 5081 the file the BFD ABFD is attached to. 5082 5083 2.11.1.3 `core_file_matches_executable_p' 5084 ......................................... 5085 5086 *Synopsis* 5087 bfd_boolean core_file_matches_executable_p 5088 (bfd *core_bfd, bfd *exec_bfd); 5089 *Description* 5090 Return `TRUE' if the core file attached to CORE_BFD was generated by a 5091 run of the executable file attached to EXEC_BFD, `FALSE' otherwise. 5092 5093 2.11.1.4 `generic_core_file_matches_executable_p' 5094 ................................................. 5095 5096 *Synopsis* 5097 bfd_boolean generic_core_file_matches_executable_p 5098 (bfd *core_bfd, bfd *exec_bfd); 5099 *Description* 5100 Return TRUE if the core file attached to CORE_BFD was generated by a 5101 run of the executable file attached to EXEC_BFD. The match is based on 5102 executable basenames only. 5103 5104 Note: When not able to determine the core file failing command or 5105 the executable name, we still return TRUE even though we're not sure 5106 that core file and executable match. This is to avoid generating a 5107 false warning in situations where we really don't know whether they 5108 match or not. 5109 5110 5111 File: bfd.info, Node: Targets, Next: Architectures, Prev: Core Files, Up: BFD front end 5112 5113 2.12 Targets 5114 ============ 5115 5116 *Description* 5117 Each port of BFD to a different machine requires the creation of a 5118 target back end. All the back end provides to the root part of BFD is a 5119 structure containing pointers to functions which perform certain low 5120 level operations on files. BFD translates the applications's requests 5121 through a pointer into calls to the back end routines. 5122 5123 When a file is opened with `bfd_openr', its format and target are 5124 unknown. BFD uses various mechanisms to determine how to interpret the 5125 file. The operations performed are: 5126 5127 * Create a BFD by calling the internal routine `_bfd_new_bfd', then 5128 call `bfd_find_target' with the target string supplied to 5129 `bfd_openr' and the new BFD pointer. 5130 5131 * If a null target string was provided to `bfd_find_target', look up 5132 the environment variable `GNUTARGET' and use that as the target 5133 string. 5134 5135 * If the target string is still `NULL', or the target string is 5136 `default', then use the first item in the target vector as the 5137 target type, and set `target_defaulted' in the BFD to cause 5138 `bfd_check_format' to loop through all the targets. *Note 5139 bfd_target::. *Note Formats::. 5140 5141 * Otherwise, inspect the elements in the target vector one by one, 5142 until a match on target name is found. When found, use it. 5143 5144 * Otherwise return the error `bfd_error_invalid_target' to 5145 `bfd_openr'. 5146 5147 * `bfd_openr' attempts to open the file using `bfd_open_file', and 5148 returns the BFD. 5149 Once the BFD has been opened and the target selected, the file 5150 format may be determined. This is done by calling `bfd_check_format' on 5151 the BFD with a suggested format. If `target_defaulted' has been set, 5152 each possible target type is tried to see if it recognizes the 5153 specified format. `bfd_check_format' returns `TRUE' when the caller 5154 guesses right. 5155 5156 * Menu: 5157 5158 * bfd_target:: 5159 5160 5161 File: bfd.info, Node: bfd_target, Prev: Targets, Up: Targets 5162 5163 2.12.1 bfd_target 5164 ----------------- 5165 5166 *Description* 5167 This structure contains everything that BFD knows about a target. It 5168 includes things like its byte order, name, and which routines to call 5169 to do various operations. 5170 5171 Every BFD points to a target structure with its `xvec' member. 5172 5173 The macros below are used to dispatch to functions through the 5174 `bfd_target' vector. They are used in a number of macros further down 5175 in `bfd.h', and are also used when calling various routines by hand 5176 inside the BFD implementation. The ARGLIST argument must be 5177 parenthesized; it contains all the arguments to the called function. 5178 5179 They make the documentation (more) unpleasant to read, so if someone 5180 wants to fix this and not break the above, please do. 5181 #define BFD_SEND(bfd, message, arglist) \ 5182 ((*((bfd)->xvec->message)) arglist) 5183 5184 #ifdef DEBUG_BFD_SEND 5185 #undef BFD_SEND 5186 #define BFD_SEND(bfd, message, arglist) \ 5187 (((bfd) && (bfd)->xvec && (bfd)->xvec->message) ? \ 5188 ((*((bfd)->xvec->message)) arglist) : \ 5189 (bfd_assert (__FILE__,__LINE__), NULL)) 5190 #endif 5191 For operations which index on the BFD format: 5192 #define BFD_SEND_FMT(bfd, message, arglist) \ 5193 (((bfd)->xvec->message[(int) ((bfd)->format)]) arglist) 5194 5195 #ifdef DEBUG_BFD_SEND 5196 #undef BFD_SEND_FMT 5197 #define BFD_SEND_FMT(bfd, message, arglist) \ 5198 (((bfd) && (bfd)->xvec && (bfd)->xvec->message) ? \ 5199 (((bfd)->xvec->message[(int) ((bfd)->format)]) arglist) : \ 5200 (bfd_assert (__FILE__,__LINE__), NULL)) 5201 #endif 5202 This is the structure which defines the type of BFD this is. The 5203 `xvec' member of the struct `bfd' itself points here. Each module that 5204 implements access to a different target under BFD, defines one of these. 5205 5206 FIXME, these names should be rationalised with the names of the 5207 entry points which call them. Too bad we can't have one macro to define 5208 them both! 5209 enum bfd_flavour 5210 { 5211 bfd_target_unknown_flavour, 5212 bfd_target_aout_flavour, 5213 bfd_target_coff_flavour, 5214 bfd_target_ecoff_flavour, 5215 bfd_target_xcoff_flavour, 5216 bfd_target_elf_flavour, 5217 bfd_target_ieee_flavour, 5218 bfd_target_nlm_flavour, 5219 bfd_target_oasys_flavour, 5220 bfd_target_tekhex_flavour, 5221 bfd_target_srec_flavour, 5222 bfd_target_ihex_flavour, 5223 bfd_target_som_flavour, 5224 bfd_target_os9k_flavour, 5225 bfd_target_versados_flavour, 5226 bfd_target_msdos_flavour, 5227 bfd_target_ovax_flavour, 5228 bfd_target_evax_flavour, 5229 bfd_target_mmo_flavour, 5230 bfd_target_mach_o_flavour, 5231 bfd_target_pef_flavour, 5232 bfd_target_pef_xlib_flavour, 5233 bfd_target_sym_flavour 5234 }; 5235 5236 enum bfd_endian { BFD_ENDIAN_BIG, BFD_ENDIAN_LITTLE, BFD_ENDIAN_UNKNOWN }; 5237 5238 /* Forward declaration. */ 5239 typedef struct bfd_link_info _bfd_link_info; 5240 5241 typedef struct bfd_target 5242 { 5243 /* Identifies the kind of target, e.g., SunOS4, Ultrix, etc. */ 5244 char *name; 5245 5246 /* The "flavour" of a back end is a general indication about 5247 the contents of a file. */ 5248 enum bfd_flavour flavour; 5249 5250 /* The order of bytes within the data area of a file. */ 5251 enum bfd_endian byteorder; 5252 5253 /* The order of bytes within the header parts of a file. */ 5254 enum bfd_endian header_byteorder; 5255 5256 /* A mask of all the flags which an executable may have set - 5257 from the set `BFD_NO_FLAGS', `HAS_RELOC', ...`D_PAGED'. */ 5258 flagword object_flags; 5259 5260 /* A mask of all the flags which a section may have set - from 5261 the set `SEC_NO_FLAGS', `SEC_ALLOC', ...`SET_NEVER_LOAD'. */ 5262 flagword section_flags; 5263 5264 /* The character normally found at the front of a symbol. 5265 (if any), perhaps `_'. */ 5266 char symbol_leading_char; 5267 5268 /* The pad character for file names within an archive header. */ 5269 char ar_pad_char; 5270 5271 /* The maximum number of characters in an archive header. */ 5272 unsigned short ar_max_namelen; 5273 5274 /* Entries for byte swapping for data. These are different from the 5275 other entry points, since they don't take a BFD as the first argument. 5276 Certain other handlers could do the same. */ 5277 bfd_uint64_t (*bfd_getx64) (const void *); 5278 bfd_int64_t (*bfd_getx_signed_64) (const void *); 5279 void (*bfd_putx64) (bfd_uint64_t, void *); 5280 bfd_vma (*bfd_getx32) (const void *); 5281 bfd_signed_vma (*bfd_getx_signed_32) (const void *); 5282 void (*bfd_putx32) (bfd_vma, void *); 5283 bfd_vma (*bfd_getx16) (const void *); 5284 bfd_signed_vma (*bfd_getx_signed_16) (const void *); 5285 void (*bfd_putx16) (bfd_vma, void *); 5286 5287 /* Byte swapping for the headers. */ 5288 bfd_uint64_t (*bfd_h_getx64) (const void *); 5289 bfd_int64_t (*bfd_h_getx_signed_64) (const void *); 5290 void (*bfd_h_putx64) (bfd_uint64_t, void *); 5291 bfd_vma (*bfd_h_getx32) (const void *); 5292 bfd_signed_vma (*bfd_h_getx_signed_32) (const void *); 5293 void (*bfd_h_putx32) (bfd_vma, void *); 5294 bfd_vma (*bfd_h_getx16) (const void *); 5295 bfd_signed_vma (*bfd_h_getx_signed_16) (const void *); 5296 void (*bfd_h_putx16) (bfd_vma, void *); 5297 5298 /* Format dependent routines: these are vectors of entry points 5299 within the target vector structure, one for each format to check. */ 5300 5301 /* Check the format of a file being read. Return a `bfd_target *' or zero. */ 5302 const struct bfd_target *(*_bfd_check_format[bfd_type_end]) (bfd *); 5303 5304 /* Set the format of a file being written. */ 5305 bfd_boolean (*_bfd_set_format[bfd_type_end]) (bfd *); 5306 5307 /* Write cached information into a file being written, at `bfd_close'. */ 5308 bfd_boolean (*_bfd_write_contents[bfd_type_end]) (bfd *); 5309 The general target vector. These vectors are initialized using the 5310 BFD_JUMP_TABLE macros. 5311 5312 /* Generic entry points. */ 5313 #define BFD_JUMP_TABLE_GENERIC(NAME) \ 5314 NAME##_close_and_cleanup, \ 5315 NAME##_bfd_free_cached_info, \ 5316 NAME##_new_section_hook, \ 5317 NAME##_get_section_contents, \ 5318 NAME##_get_section_contents_in_window 5319 5320 /* Called when the BFD is being closed to do any necessary cleanup. */ 5321 bfd_boolean (*_close_and_cleanup) (bfd *); 5322 /* Ask the BFD to free all cached information. */ 5323 bfd_boolean (*_bfd_free_cached_info) (bfd *); 5324 /* Called when a new section is created. */ 5325 bfd_boolean (*_new_section_hook) (bfd *, sec_ptr); 5326 /* Read the contents of a section. */ 5327 bfd_boolean (*_bfd_get_section_contents) 5328 (bfd *, sec_ptr, void *, file_ptr, bfd_size_type); 5329 bfd_boolean (*_bfd_get_section_contents_in_window) 5330 (bfd *, sec_ptr, bfd_window *, file_ptr, bfd_size_type); 5331 5332 /* Entry points to copy private data. */ 5333 #define BFD_JUMP_TABLE_COPY(NAME) \ 5334 NAME##_bfd_copy_private_bfd_data, \ 5335 NAME##_bfd_merge_private_bfd_data, \ 5336 _bfd_generic_init_private_section_data, \ 5337 NAME##_bfd_copy_private_section_data, \ 5338 NAME##_bfd_copy_private_symbol_data, \ 5339 NAME##_bfd_copy_private_header_data, \ 5340 NAME##_bfd_set_private_flags, \ 5341 NAME##_bfd_print_private_bfd_data 5342 5343 /* Called to copy BFD general private data from one object file 5344 to another. */ 5345 bfd_boolean (*_bfd_copy_private_bfd_data) (bfd *, bfd *); 5346 /* Called to merge BFD general private data from one object file 5347 to a common output file when linking. */ 5348 bfd_boolean (*_bfd_merge_private_bfd_data) (bfd *, bfd *); 5349 /* Called to initialize BFD private section data from one object file 5350 to another. */ 5351 #define bfd_init_private_section_data(ibfd, isec, obfd, osec, link_info) \ 5352 BFD_SEND (obfd, _bfd_init_private_section_data, (ibfd, isec, obfd, osec, link_info)) 5353 bfd_boolean (*_bfd_init_private_section_data) 5354 (bfd *, sec_ptr, bfd *, sec_ptr, struct bfd_link_info *); 5355 /* Called to copy BFD private section data from one object file 5356 to another. */ 5357 bfd_boolean (*_bfd_copy_private_section_data) 5358 (bfd *, sec_ptr, bfd *, sec_ptr); 5359 /* Called to copy BFD private symbol data from one symbol 5360 to another. */ 5361 bfd_boolean (*_bfd_copy_private_symbol_data) 5362 (bfd *, asymbol *, bfd *, asymbol *); 5363 /* Called to copy BFD private header data from one object file 5364 to another. */ 5365 bfd_boolean (*_bfd_copy_private_header_data) 5366 (bfd *, bfd *); 5367 /* Called to set private backend flags. */ 5368 bfd_boolean (*_bfd_set_private_flags) (bfd *, flagword); 5369 5370 /* Called to print private BFD data. */ 5371 bfd_boolean (*_bfd_print_private_bfd_data) (bfd *, void *); 5372 5373 /* Core file entry points. */ 5374 #define BFD_JUMP_TABLE_CORE(NAME) \ 5375 NAME##_core_file_failing_command, \ 5376 NAME##_core_file_failing_signal, \ 5377 NAME##_core_file_matches_executable_p 5378 5379 char * (*_core_file_failing_command) (bfd *); 5380 int (*_core_file_failing_signal) (bfd *); 5381 bfd_boolean (*_core_file_matches_executable_p) (bfd *, bfd *); 5382 5383 /* Archive entry points. */ 5384 #define BFD_JUMP_TABLE_ARCHIVE(NAME) \ 5385 NAME##_slurp_armap, \ 5386 NAME##_slurp_extended_name_table, \ 5387 NAME##_construct_extended_name_table, \ 5388 NAME##_truncate_arname, \ 5389 NAME##_write_armap, \ 5390 NAME##_read_ar_hdr, \ 5391 NAME##_openr_next_archived_file, \ 5392 NAME##_get_elt_at_index, \ 5393 NAME##_generic_stat_arch_elt, \ 5394 NAME##_update_armap_timestamp 5395 5396 bfd_boolean (*_bfd_slurp_armap) (bfd *); 5397 bfd_boolean (*_bfd_slurp_extended_name_table) (bfd *); 5398 bfd_boolean (*_bfd_construct_extended_name_table) 5399 (bfd *, char **, bfd_size_type *, const char **); 5400 void (*_bfd_truncate_arname) (bfd *, const char *, char *); 5401 bfd_boolean (*write_armap) 5402 (bfd *, unsigned int, struct orl *, unsigned int, int); 5403 void * (*_bfd_read_ar_hdr_fn) (bfd *); 5404 bfd * (*openr_next_archived_file) (bfd *, bfd *); 5405 #define bfd_get_elt_at_index(b,i) BFD_SEND (b, _bfd_get_elt_at_index, (b,i)) 5406 bfd * (*_bfd_get_elt_at_index) (bfd *, symindex); 5407 int (*_bfd_stat_arch_elt) (bfd *, struct stat *); 5408 bfd_boolean (*_bfd_update_armap_timestamp) (bfd *); 5409 5410 /* Entry points used for symbols. */ 5411 #define BFD_JUMP_TABLE_SYMBOLS(NAME) \ 5412 NAME##_get_symtab_upper_bound, \ 5413 NAME##_canonicalize_symtab, \ 5414 NAME##_make_empty_symbol, \ 5415 NAME##_print_symbol, \ 5416 NAME##_get_symbol_info, \ 5417 NAME##_bfd_is_local_label_name, \ 5418 NAME##_bfd_is_target_special_symbol, \ 5419 NAME##_get_lineno, \ 5420 NAME##_find_nearest_line, \ 5421 _bfd_generic_find_line, \ 5422 NAME##_find_inliner_info, \ 5423 NAME##_bfd_make_debug_symbol, \ 5424 NAME##_read_minisymbols, \ 5425 NAME##_minisymbol_to_symbol 5426 5427 long (*_bfd_get_symtab_upper_bound) (bfd *); 5428 long (*_bfd_canonicalize_symtab) 5429 (bfd *, struct bfd_symbol **); 5430 struct bfd_symbol * 5431 (*_bfd_make_empty_symbol) (bfd *); 5432 void (*_bfd_print_symbol) 5433 (bfd *, void *, struct bfd_symbol *, bfd_print_symbol_type); 5434 #define bfd_print_symbol(b,p,s,e) BFD_SEND (b, _bfd_print_symbol, (b,p,s,e)) 5435 void (*_bfd_get_symbol_info) 5436 (bfd *, struct bfd_symbol *, symbol_info *); 5437 #define bfd_get_symbol_info(b,p,e) BFD_SEND (b, _bfd_get_symbol_info, (b,p,e)) 5438 bfd_boolean (*_bfd_is_local_label_name) (bfd *, const char *); 5439 bfd_boolean (*_bfd_is_target_special_symbol) (bfd *, asymbol *); 5440 alent * (*_get_lineno) (bfd *, struct bfd_symbol *); 5441 bfd_boolean (*_bfd_find_nearest_line) 5442 (bfd *, struct bfd_section *, struct bfd_symbol **, bfd_vma, 5443 const char **, const char **, unsigned int *); 5444 bfd_boolean (*_bfd_find_line) 5445 (bfd *, struct bfd_symbol **, struct bfd_symbol *, 5446 const char **, unsigned int *); 5447 bfd_boolean (*_bfd_find_inliner_info) 5448 (bfd *, const char **, const char **, unsigned int *); 5449 /* Back-door to allow format-aware applications to create debug symbols 5450 while using BFD for everything else. Currently used by the assembler 5451 when creating COFF files. */ 5452 asymbol * (*_bfd_make_debug_symbol) 5453 (bfd *, void *, unsigned long size); 5454 #define bfd_read_minisymbols(b, d, m, s) \ 5455 BFD_SEND (b, _read_minisymbols, (b, d, m, s)) 5456 long (*_read_minisymbols) 5457 (bfd *, bfd_boolean, void **, unsigned int *); 5458 #define bfd_minisymbol_to_symbol(b, d, m, f) \ 5459 BFD_SEND (b, _minisymbol_to_symbol, (b, d, m, f)) 5460 asymbol * (*_minisymbol_to_symbol) 5461 (bfd *, bfd_boolean, const void *, asymbol *); 5462 5463 /* Routines for relocs. */ 5464 #define BFD_JUMP_TABLE_RELOCS(NAME) \ 5465 NAME##_get_reloc_upper_bound, \ 5466 NAME##_canonicalize_reloc, \ 5467 NAME##_bfd_reloc_type_lookup 5468 5469 long (*_get_reloc_upper_bound) (bfd *, sec_ptr); 5470 long (*_bfd_canonicalize_reloc) 5471 (bfd *, sec_ptr, arelent **, struct bfd_symbol **); 5472 /* See documentation on reloc types. */ 5473 reloc_howto_type * 5474 (*reloc_type_lookup) (bfd *, bfd_reloc_code_real_type); 5475 5476 /* Routines used when writing an object file. */ 5477 #define BFD_JUMP_TABLE_WRITE(NAME) \ 5478 NAME##_set_arch_mach, \ 5479 NAME##_set_section_contents 5480 5481 bfd_boolean (*_bfd_set_arch_mach) 5482 (bfd *, enum bfd_architecture, unsigned long); 5483 bfd_boolean (*_bfd_set_section_contents) 5484 (bfd *, sec_ptr, const void *, file_ptr, bfd_size_type); 5485 5486 /* Routines used by the linker. */ 5487 #define BFD_JUMP_TABLE_LINK(NAME) \ 5488 NAME##_sizeof_headers, \ 5489 NAME##_bfd_get_relocated_section_contents, \ 5490 NAME##_bfd_relax_section, \ 5491 NAME##_bfd_link_hash_table_create, \ 5492 NAME##_bfd_link_hash_table_free, \ 5493 NAME##_bfd_link_add_symbols, \ 5494 NAME##_bfd_link_just_syms, \ 5495 NAME##_bfd_final_link, \ 5496 NAME##_bfd_link_split_section, \ 5497 NAME##_bfd_gc_sections, \ 5498 NAME##_bfd_merge_sections, \ 5499 NAME##_bfd_is_group_section, \ 5500 NAME##_bfd_discard_group, \ 5501 NAME##_section_already_linked \ 5502 5503 int (*_bfd_sizeof_headers) (bfd *, bfd_boolean); 5504 bfd_byte * (*_bfd_get_relocated_section_contents) 5505 (bfd *, struct bfd_link_info *, struct bfd_link_order *, 5506 bfd_byte *, bfd_boolean, struct bfd_symbol **); 5507 5508 bfd_boolean (*_bfd_relax_section) 5509 (bfd *, struct bfd_section *, struct bfd_link_info *, bfd_boolean *); 5510 5511 /* Create a hash table for the linker. Different backends store 5512 different information in this table. */ 5513 struct bfd_link_hash_table * 5514 (*_bfd_link_hash_table_create) (bfd *); 5515 5516 /* Release the memory associated with the linker hash table. */ 5517 void (*_bfd_link_hash_table_free) (struct bfd_link_hash_table *); 5518 5519 /* Add symbols from this object file into the hash table. */ 5520 bfd_boolean (*_bfd_link_add_symbols) (bfd *, struct bfd_link_info *); 5521 5522 /* Indicate that we are only retrieving symbol values from this section. */ 5523 void (*_bfd_link_just_syms) (asection *, struct bfd_link_info *); 5524 5525 /* Do a link based on the link_order structures attached to each 5526 section of the BFD. */ 5527 bfd_boolean (*_bfd_final_link) (bfd *, struct bfd_link_info *); 5528 5529 /* Should this section be split up into smaller pieces during linking. */ 5530 bfd_boolean (*_bfd_link_split_section) (bfd *, struct bfd_section *); 5531 5532 /* Remove sections that are not referenced from the output. */ 5533 bfd_boolean (*_bfd_gc_sections) (bfd *, struct bfd_link_info *); 5534 5535 /* Attempt to merge SEC_MERGE sections. */ 5536 bfd_boolean (*_bfd_merge_sections) (bfd *, struct bfd_link_info *); 5537 5538 /* Is this section a member of a group? */ 5539 bfd_boolean (*_bfd_is_group_section) (bfd *, const struct bfd_section *); 5540 5541 /* Discard members of a group. */ 5542 bfd_boolean (*_bfd_discard_group) (bfd *, struct bfd_section *); 5543 5544 /* Check if SEC has been already linked during a reloceatable or 5545 final link. */ 5546 void (*_section_already_linked) (bfd *, struct bfd_section *); 5547 5548 /* Routines to handle dynamic symbols and relocs. */ 5549 #define BFD_JUMP_TABLE_DYNAMIC(NAME) \ 5550 NAME##_get_dynamic_symtab_upper_bound, \ 5551 NAME##_canonicalize_dynamic_symtab, \ 5552 NAME##_get_synthetic_symtab, \ 5553 NAME##_get_dynamic_reloc_upper_bound, \ 5554 NAME##_canonicalize_dynamic_reloc 5555 5556 /* Get the amount of memory required to hold the dynamic symbols. */ 5557 long (*_bfd_get_dynamic_symtab_upper_bound) (bfd *); 5558 /* Read in the dynamic symbols. */ 5559 long (*_bfd_canonicalize_dynamic_symtab) 5560 (bfd *, struct bfd_symbol **); 5561 /* Create synthetized symbols. */ 5562 long (*_bfd_get_synthetic_symtab) 5563 (bfd *, long, struct bfd_symbol **, long, struct bfd_symbol **, 5564 struct bfd_symbol **); 5565 /* Get the amount of memory required to hold the dynamic relocs. */ 5566 long (*_bfd_get_dynamic_reloc_upper_bound) (bfd *); 5567 /* Read in the dynamic relocs. */ 5568 long (*_bfd_canonicalize_dynamic_reloc) 5569 (bfd *, arelent **, struct bfd_symbol **); 5570 A pointer to an alternative bfd_target in case the current one is not 5571 satisfactory. This can happen when the target cpu supports both big 5572 and little endian code, and target chosen by the linker has the wrong 5573 endianness. The function open_output() in ld/ldlang.c uses this field 5574 to find an alternative output format that is suitable. 5575 /* Opposite endian version of this target. */ 5576 const struct bfd_target * alternative_target; 5577 5578 /* Data for use by back-end routines, which isn't 5579 generic enough to belong in this structure. */ 5580 const void *backend_data; 5581 5582 } bfd_target; 5583 5584 2.12.1.1 `bfd_set_default_target' 5585 ................................. 5586 5587 *Synopsis* 5588 bfd_boolean bfd_set_default_target (const char *name); 5589 *Description* 5590 Set the default target vector to use when recognizing a BFD. This 5591 takes the name of the target, which may be a BFD target name or a 5592 configuration triplet. 5593 5594 2.12.1.2 `bfd_find_target' 5595 .......................... 5596 5597 *Synopsis* 5598 const bfd_target *bfd_find_target (const char *target_name, bfd *abfd); 5599 *Description* 5600 Return a pointer to the transfer vector for the object target named 5601 TARGET_NAME. If TARGET_NAME is `NULL', choose the one in the 5602 environment variable `GNUTARGET'; if that is null or not defined, then 5603 choose the first entry in the target list. Passing in the string 5604 "default" or setting the environment variable to "default" will cause 5605 the first entry in the target list to be returned, and 5606 "target_defaulted" will be set in the BFD. This causes 5607 `bfd_check_format' to loop over all the targets to find the one that 5608 matches the file being read. 5609 5610 2.12.1.3 `bfd_target_list' 5611 .......................... 5612 5613 *Synopsis* 5614 const char ** bfd_target_list (void); 5615 *Description* 5616 Return a freshly malloced NULL-terminated vector of the names of all 5617 the valid BFD targets. Do not modify the names. 5618 5619 2.12.1.4 `bfd_seach_for_target' 5620 ............................... 5621 5622 *Synopsis* 5623 const bfd_target *bfd_search_for_target 5624 (int (*search_func) (const bfd_target *, void *), 5625 void *); 5626 *Description* 5627 Return a pointer to the first transfer vector in the list of transfer 5628 vectors maintained by BFD that produces a non-zero result when passed 5629 to the function SEARCH_FUNC. The parameter DATA is passed, unexamined, 5630 to the search function. 5631 5632 5633 File: bfd.info, Node: Architectures, Next: Opening and Closing, Prev: Targets, Up: BFD front end 5634 5635 2.13 Architectures 5636 ================== 5637 5638 BFD keeps one atom in a BFD describing the architecture of the data 5639 attached to the BFD: a pointer to a `bfd_arch_info_type'. 5640 5641 Pointers to structures can be requested independently of a BFD so 5642 that an architecture's information can be interrogated without access 5643 to an open BFD. 5644 5645 The architecture information is provided by each architecture 5646 package. The set of default architectures is selected by the macro 5647 `SELECT_ARCHITECTURES'. This is normally set up in the 5648 `config/TARGET.mt' file of your choice. If the name is not defined, 5649 then all the architectures supported are included. 5650 5651 When BFD starts up, all the architectures are called with an 5652 initialize method. It is up to the architecture back end to insert as 5653 many items into the list of architectures as it wants to; generally 5654 this would be one for each machine and one for the default case (an 5655 item with a machine field of 0). 5656 5657 BFD's idea of an architecture is implemented in `archures.c'. 5658 5659 2.13.1 bfd_architecture 5660 ----------------------- 5661 5662 *Description* 5663 This enum gives the object file's CPU architecture, in a global 5664 sense--i.e., what processor family does it belong to? Another field 5665 indicates which processor within the family is in use. The machine 5666 gives a number which distinguishes different versions of the 5667 architecture, containing, for example, 2 and 3 for Intel i960 KA and 5668 i960 KB, and 68020 and 68030 for Motorola 68020 and 68030. 5669 enum bfd_architecture 5670 { 5671 bfd_arch_unknown, /* File arch not known. */ 5672 bfd_arch_obscure, /* Arch known, not one of these. */ 5673 bfd_arch_m68k, /* Motorola 68xxx */ 5674 #define bfd_mach_m68000 1 5675 #define bfd_mach_m68008 2 5676 #define bfd_mach_m68010 3 5677 #define bfd_mach_m68020 4 5678 #define bfd_mach_m68030 5 5679 #define bfd_mach_m68040 6 5680 #define bfd_mach_m68060 7 5681 #define bfd_mach_cpu32 8 5682 #define bfd_mach_mcf_isa_a_nodiv 9 5683 #define bfd_mach_mcf_isa_a 10 5684 #define bfd_mach_mcf_isa_a_mac 11 5685 #define bfd_mach_mcf_isa_a_emac 12 5686 #define bfd_mach_mcf_isa_aplus 13 5687 #define bfd_mach_mcf_isa_aplus_mac 14 5688 #define bfd_mach_mcf_isa_aplus_emac 15 5689 #define bfd_mach_mcf_isa_b_nousp 16 5690 #define bfd_mach_mcf_isa_b_nousp_mac 17 5691 #define bfd_mach_mcf_isa_b_nousp_emac 18 5692 #define bfd_mach_mcf_isa_b 19 5693 #define bfd_mach_mcf_isa_b_mac 20 5694 #define bfd_mach_mcf_isa_b_emac 21 5695 #define bfd_mach_mcf_isa_b_float 22 5696 #define bfd_mach_mcf_isa_b_float_mac 23 5697 #define bfd_mach_mcf_isa_b_float_emac 24 5698 bfd_arch_vax, /* DEC Vax */ 5699 bfd_arch_i960, /* Intel 960 */ 5700 /* The order of the following is important. 5701 lower number indicates a machine type that 5702 only accepts a subset of the instructions 5703 available to machines with higher numbers. 5704 The exception is the "ca", which is 5705 incompatible with all other machines except 5706 "core". */ 5707 5708 #define bfd_mach_i960_core 1 5709 #define bfd_mach_i960_ka_sa 2 5710 #define bfd_mach_i960_kb_sb 3 5711 #define bfd_mach_i960_mc 4 5712 #define bfd_mach_i960_xa 5 5713 #define bfd_mach_i960_ca 6 5714 #define bfd_mach_i960_jx 7 5715 #define bfd_mach_i960_hx 8 5716 5717 bfd_arch_or32, /* OpenRISC 32 */ 5718 5719 bfd_arch_sparc, /* SPARC */ 5720 #define bfd_mach_sparc 1 5721 /* The difference between v8plus and v9 is that v9 is a true 64 bit env. */ 5722 #define bfd_mach_sparc_sparclet 2 5723 #define bfd_mach_sparc_sparclite 3 5724 #define bfd_mach_sparc_v8plus 4 5725 #define bfd_mach_sparc_v8plusa 5 /* with ultrasparc add'ns. */ 5726 #define bfd_mach_sparc_sparclite_le 6 5727 #define bfd_mach_sparc_v9 7 5728 #define bfd_mach_sparc_v9a 8 /* with ultrasparc add'ns. */ 5729 #define bfd_mach_sparc_v8plusb 9 /* with cheetah add'ns. */ 5730 #define bfd_mach_sparc_v9b 10 /* with cheetah add'ns. */ 5731 /* Nonzero if MACH has the v9 instruction set. */ 5732 #define bfd_mach_sparc_v9_p(mach) \ 5733 ((mach) >= bfd_mach_sparc_v8plus && (mach) <= bfd_mach_sparc_v9b \ 5734 && (mach) != bfd_mach_sparc_sparclite_le) 5735 /* Nonzero if MACH is a 64 bit sparc architecture. */ 5736 #define bfd_mach_sparc_64bit_p(mach) \ 5737 ((mach) >= bfd_mach_sparc_v9 && (mach) != bfd_mach_sparc_v8plusb) 5738 bfd_arch_mips, /* MIPS Rxxxx */ 5739 #define bfd_mach_mips3000 3000 5740 #define bfd_mach_mips3900 3900 5741 #define bfd_mach_mips4000 4000 5742 #define bfd_mach_mips4010 4010 5743 #define bfd_mach_mips4100 4100 5744 #define bfd_mach_mips4111 4111 5745 #define bfd_mach_mips4120 4120 5746 #define bfd_mach_mips4300 4300 5747 #define bfd_mach_mips4400 4400 5748 #define bfd_mach_mips4600 4600 5749 #define bfd_mach_mips4650 4650 5750 #define bfd_mach_mips5000 5000 5751 #define bfd_mach_mips5400 5400 5752 #define bfd_mach_mips5500 5500 5753 #define bfd_mach_mips6000 6000 5754 #define bfd_mach_mips7000 7000 5755 #define bfd_mach_mips8000 8000 5756 #define bfd_mach_mips9000 9000 5757 #define bfd_mach_mips10000 10000 5758 #define bfd_mach_mips12000 12000 5759 #define bfd_mach_mips16 16 5760 #define bfd_mach_mips5 5 5761 #define bfd_mach_mips_sb1 12310201 /* octal 'SB', 01 */ 5762 #define bfd_mach_mipsisa32 32 5763 #define bfd_mach_mipsisa32r2 33 5764 #define bfd_mach_mipsisa64 64 5765 #define bfd_mach_mipsisa64r2 65 5766 bfd_arch_i386, /* Intel 386 */ 5767 #define bfd_mach_i386_i386 1 5768 #define bfd_mach_i386_i8086 2 5769 #define bfd_mach_i386_i386_intel_syntax 3 5770 #define bfd_mach_x86_64 64 5771 #define bfd_mach_x86_64_intel_syntax 65 5772 bfd_arch_we32k, /* AT&T WE32xxx */ 5773 bfd_arch_tahoe, /* CCI/Harris Tahoe */ 5774 bfd_arch_i860, /* Intel 860 */ 5775 bfd_arch_i370, /* IBM 360/370 Mainframes */ 5776 bfd_arch_romp, /* IBM ROMP PC/RT */ 5777 bfd_arch_convex, /* Convex */ 5778 bfd_arch_m88k, /* Motorola 88xxx */ 5779 bfd_arch_m98k, /* Motorola 98xxx */ 5780 bfd_arch_pyramid, /* Pyramid Technology */ 5781 bfd_arch_h8300, /* Renesas H8/300 (formerly Hitachi H8/300) */ 5782 #define bfd_mach_h8300 1 5783 #define bfd_mach_h8300h 2 5784 #define bfd_mach_h8300s 3 5785 #define bfd_mach_h8300hn 4 5786 #define bfd_mach_h8300sn 5 5787 #define bfd_mach_h8300sx 6 5788 #define bfd_mach_h8300sxn 7 5789 bfd_arch_pdp11, /* DEC PDP-11 */ 5790 bfd_arch_powerpc, /* PowerPC */ 5791 #define bfd_mach_ppc 32 5792 #define bfd_mach_ppc64 64 5793 #define bfd_mach_ppc_403 403 5794 #define bfd_mach_ppc_403gc 4030 5795 #define bfd_mach_ppc_505 505 5796 #define bfd_mach_ppc_601 601 5797 #define bfd_mach_ppc_602 602 5798 #define bfd_mach_ppc_603 603 5799 #define bfd_mach_ppc_ec603e 6031 5800 #define bfd_mach_ppc_604 604 5801 #define bfd_mach_ppc_620 620 5802 #define bfd_mach_ppc_630 630 5803 #define bfd_mach_ppc_750 750 5804 #define bfd_mach_ppc_860 860 5805 #define bfd_mach_ppc_a35 35 5806 #define bfd_mach_ppc_rs64ii 642 5807 #define bfd_mach_ppc_rs64iii 643 5808 #define bfd_mach_ppc_7400 7400 5809 #define bfd_mach_ppc_e500 500 5810 bfd_arch_rs6000, /* IBM RS/6000 */ 5811 #define bfd_mach_rs6k 6000 5812 #define bfd_mach_rs6k_rs1 6001 5813 #define bfd_mach_rs6k_rsc 6003 5814 #define bfd_mach_rs6k_rs2 6002 5815 bfd_arch_hppa, /* HP PA RISC */ 5816 #define bfd_mach_hppa10 10 5817 #define bfd_mach_hppa11 11 5818 #define bfd_mach_hppa20 20 5819 #define bfd_mach_hppa20w 25 5820 bfd_arch_d10v, /* Mitsubishi D10V */ 5821 #define bfd_mach_d10v 1 5822 #define bfd_mach_d10v_ts2 2 5823 #define bfd_mach_d10v_ts3 3 5824 bfd_arch_d30v, /* Mitsubishi D30V */ 5825 bfd_arch_dlx, /* DLX */ 5826 bfd_arch_m68hc11, /* Motorola 68HC11 */ 5827 bfd_arch_m68hc12, /* Motorola 68HC12 */ 5828 #define bfd_mach_m6812_default 0 5829 #define bfd_mach_m6812 1 5830 #define bfd_mach_m6812s 2 5831 bfd_arch_z8k, /* Zilog Z8000 */ 5832 #define bfd_mach_z8001 1 5833 #define bfd_mach_z8002 2 5834 bfd_arch_h8500, /* Renesas H8/500 (formerly Hitachi H8/500) */ 5835 bfd_arch_sh, /* Renesas / SuperH SH (formerly Hitachi SH) */ 5836 #define bfd_mach_sh 1 5837 #define bfd_mach_sh2 0x20 5838 #define bfd_mach_sh_dsp 0x2d 5839 #define bfd_mach_sh2a 0x2a 5840 #define bfd_mach_sh2a_nofpu 0x2b 5841 #define bfd_mach_sh2a_nofpu_or_sh4_nommu_nofpu 0x2a1 5842 #define bfd_mach_sh2a_nofpu_or_sh3_nommu 0x2a2 5843 #define bfd_mach_sh2a_or_sh4 0x2a3 5844 #define bfd_mach_sh2a_or_sh3e 0x2a4 5845 #define bfd_mach_sh2e 0x2e 5846 #define bfd_mach_sh3 0x30 5847 #define bfd_mach_sh3_nommu 0x31 5848 #define bfd_mach_sh3_dsp 0x3d 5849 #define bfd_mach_sh3e 0x3e 5850 #define bfd_mach_sh4 0x40 5851 #define bfd_mach_sh4_nofpu 0x41 5852 #define bfd_mach_sh4_nommu_nofpu 0x42 5853 #define bfd_mach_sh4a 0x4a 5854 #define bfd_mach_sh4a_nofpu 0x4b 5855 #define bfd_mach_sh4al_dsp 0x4d 5856 #define bfd_mach_sh5 0x50 5857 bfd_arch_alpha, /* Dec Alpha */ 5858 #define bfd_mach_alpha_ev4 0x10 5859 #define bfd_mach_alpha_ev5 0x20 5860 #define bfd_mach_alpha_ev6 0x30 5861 bfd_arch_arm, /* Advanced Risc Machines ARM. */ 5862 #define bfd_mach_arm_unknown 0 5863 #define bfd_mach_arm_2 1 5864 #define bfd_mach_arm_2a 2 5865 #define bfd_mach_arm_3 3 5866 #define bfd_mach_arm_3M 4 5867 #define bfd_mach_arm_4 5 5868 #define bfd_mach_arm_4T 6 5869 #define bfd_mach_arm_5 7 5870 #define bfd_mach_arm_5T 8 5871 #define bfd_mach_arm_5TE 9 5872 #define bfd_mach_arm_XScale 10 5873 #define bfd_mach_arm_ep9312 11 5874 #define bfd_mach_arm_iWMMXt 12 5875 bfd_arch_ns32k, /* National Semiconductors ns32000 */ 5876 bfd_arch_w65, /* WDC 65816 */ 5877 bfd_arch_tic30, /* Texas Instruments TMS320C30 */ 5878 bfd_arch_tic4x, /* Texas Instruments TMS320C3X/4X */ 5879 #define bfd_mach_tic3x 30 5880 #define bfd_mach_tic4x 40 5881 bfd_arch_tic54x, /* Texas Instruments TMS320C54X */ 5882 bfd_arch_tic80, /* TI TMS320c80 (MVP) */ 5883 bfd_arch_v850, /* NEC V850 */ 5884 #define bfd_mach_v850 1 5885 #define bfd_mach_v850e 'E' 5886 #define bfd_mach_v850e1 '1' 5887 bfd_arch_arc, /* ARC Cores */ 5888 #define bfd_mach_arc_5 5 5889 #define bfd_mach_arc_6 6 5890 #define bfd_mach_arc_7 7 5891 #define bfd_mach_arc_8 8 5892 bfd_arch_m32c, /* Renesas M16C/M32C. */ 5893 #define bfd_mach_m16c 0x75 5894 #define bfd_mach_m32c 0x78 5895 bfd_arch_m32r, /* Renesas M32R (formerly Mitsubishi M32R/D) */ 5896 #define bfd_mach_m32r 1 /* For backwards compatibility. */ 5897 #define bfd_mach_m32rx 'x' 5898 #define bfd_mach_m32r2 '2' 5899 bfd_arch_mn10200, /* Matsushita MN10200 */ 5900 bfd_arch_mn10300, /* Matsushita MN10300 */ 5901 #define bfd_mach_mn10300 300 5902 #define bfd_mach_am33 330 5903 #define bfd_mach_am33_2 332 5904 bfd_arch_fr30, 5905 #define bfd_mach_fr30 0x46523330 5906 bfd_arch_frv, 5907 #define bfd_mach_frv 1 5908 #define bfd_mach_frvsimple 2 5909 #define bfd_mach_fr300 300 5910 #define bfd_mach_fr400 400 5911 #define bfd_mach_fr450 450 5912 #define bfd_mach_frvtomcat 499 /* fr500 prototype */ 5913 #define bfd_mach_fr500 500 5914 #define bfd_mach_fr550 550 5915 bfd_arch_mcore, 5916 bfd_arch_ia64, /* HP/Intel ia64 */ 5917 #define bfd_mach_ia64_elf64 64 5918 #define bfd_mach_ia64_elf32 32 5919 bfd_arch_ip2k, /* Ubicom IP2K microcontrollers. */ 5920 #define bfd_mach_ip2022 1 5921 #define bfd_mach_ip2022ext 2 5922 bfd_arch_iq2000, /* Vitesse IQ2000. */ 5923 #define bfd_mach_iq2000 1 5924 #define bfd_mach_iq10 2 5925 bfd_arch_mt, 5926 #define bfd_mach_ms1 1 5927 #define bfd_mach_mrisc2 2 5928 #define bfd_mach_ms2 3 5929 bfd_arch_pj, 5930 bfd_arch_avr, /* Atmel AVR microcontrollers. */ 5931 #define bfd_mach_avr1 1 5932 #define bfd_mach_avr2 2 5933 #define bfd_mach_avr3 3 5934 #define bfd_mach_avr4 4 5935 #define bfd_mach_avr5 5 5936 bfd_arch_bfin, /* ADI Blackfin */ 5937 #define bfd_mach_bfin 1 5938 bfd_arch_cr16c, /* National Semiconductor CompactRISC. */ 5939 #define bfd_mach_cr16c 1 5940 bfd_arch_crx, /* National Semiconductor CRX. */ 5941 #define bfd_mach_crx 1 5942 bfd_arch_cris, /* Axis CRIS */ 5943 #define bfd_mach_cris_v0_v10 255 5944 #define bfd_mach_cris_v32 32 5945 #define bfd_mach_cris_v10_v32 1032 5946 bfd_arch_s390, /* IBM s390 */ 5947 #define bfd_mach_s390_31 31 5948 #define bfd_mach_s390_64 64 5949 bfd_arch_openrisc, /* OpenRISC */ 5950 bfd_arch_mmix, /* Donald Knuth's educational processor. */ 5951 bfd_arch_xstormy16, 5952 #define bfd_mach_xstormy16 1 5953 bfd_arch_msp430, /* Texas Instruments MSP430 architecture. */ 5954 #define bfd_mach_msp11 11 5955 #define bfd_mach_msp110 110 5956 #define bfd_mach_msp12 12 5957 #define bfd_mach_msp13 13 5958 #define bfd_mach_msp14 14 5959 #define bfd_mach_msp15 15 5960 #define bfd_mach_msp16 16 5961 #define bfd_mach_msp21 21 5962 #define bfd_mach_msp31 31 5963 #define bfd_mach_msp32 32 5964 #define bfd_mach_msp33 33 5965 #define bfd_mach_msp41 41 5966 #define bfd_mach_msp42 42 5967 #define bfd_mach_msp43 43 5968 #define bfd_mach_msp44 44 5969 bfd_arch_xc16x, /* Infineon's XC16X Series. */ 5970 #define bfd_mach_xc16x 1 5971 #define bfd_mach_xc16xl 2 5972 #define bfd_mach_xc16xs 3 5973 bfd_arch_xtensa, /* Tensilica's Xtensa cores. */ 5974 #define bfd_mach_xtensa 1 5975 bfd_arch_maxq, /* Dallas MAXQ 10/20 */ 5976 #define bfd_mach_maxq10 10 5977 #define bfd_mach_maxq20 20 5978 bfd_arch_z80, 5979 #define bfd_mach_z80strict 1 /* No undocumented opcodes. */ 5980 #define bfd_mach_z80 3 /* With ixl, ixh, iyl, and iyh. */ 5981 #define bfd_mach_z80full 7 /* All undocumented instructions. */ 5982 #define bfd_mach_r800 11 /* R800: successor with multiplication. */ 5983 bfd_arch_last 5984 }; 5985 5986 2.13.2 bfd_arch_info 5987 -------------------- 5988 5989 *Description* 5990 This structure contains information on architectures for use within BFD. 5991 5992 typedef struct bfd_arch_info 5993 { 5994 int bits_per_word; 5995 int bits_per_address; 5996 int bits_per_byte; 5997 enum bfd_architecture arch; 5998 unsigned long mach; 5999 const char *arch_name; 6000 const char *printable_name; 6001 unsigned int section_align_power; 6002 /* TRUE if this is the default machine for the architecture. 6003 The default arch should be the first entry for an arch so that 6004 all the entries for that arch can be accessed via `next'. */ 6005 bfd_boolean the_default; 6006 const struct bfd_arch_info * (*compatible) 6007 (const struct bfd_arch_info *a, const struct bfd_arch_info *b); 6008 6009 bfd_boolean (*scan) (const struct bfd_arch_info *, const char *); 6010 6011 const struct bfd_arch_info *next; 6012 } 6013 bfd_arch_info_type; 6014 6015 2.13.2.1 `bfd_printable_name' 6016 ............................. 6017 6018 *Synopsis* 6019 const char *bfd_printable_name (bfd *abfd); 6020 *Description* 6021 Return a printable string representing the architecture and machine 6022 from the pointer to the architecture info structure. 6023 6024 2.13.2.2 `bfd_scan_arch' 6025 ........................ 6026 6027 *Synopsis* 6028 const bfd_arch_info_type *bfd_scan_arch (const char *string); 6029 *Description* 6030 Figure out if BFD supports any cpu which could be described with the 6031 name STRING. Return a pointer to an `arch_info' structure if a machine 6032 is found, otherwise NULL. 6033 6034 2.13.2.3 `bfd_arch_list' 6035 ........................ 6036 6037 *Synopsis* 6038 const char **bfd_arch_list (void); 6039 *Description* 6040 Return a freshly malloced NULL-terminated vector of the names of all 6041 the valid BFD architectures. Do not modify the names. 6042 6043 2.13.2.4 `bfd_arch_get_compatible' 6044 .................................. 6045 6046 *Synopsis* 6047 const bfd_arch_info_type *bfd_arch_get_compatible 6048 (const bfd *abfd, const bfd *bbfd, bfd_boolean accept_unknowns); 6049 *Description* 6050 Determine whether two BFDs' architectures and machine types are 6051 compatible. Calculates the lowest common denominator between the two 6052 architectures and machine types implied by the BFDs and returns a 6053 pointer to an `arch_info' structure describing the compatible machine. 6054 6055 2.13.2.5 `bfd_default_arch_struct' 6056 .................................. 6057 6058 *Description* 6059 The `bfd_default_arch_struct' is an item of `bfd_arch_info_type' which 6060 has been initialized to a fairly generic state. A BFD starts life by 6061 pointing to this structure, until the correct back end has determined 6062 the real architecture of the file. 6063 extern const bfd_arch_info_type bfd_default_arch_struct; 6064 6065 2.13.2.6 `bfd_set_arch_info' 6066 ............................ 6067 6068 *Synopsis* 6069 void bfd_set_arch_info (bfd *abfd, const bfd_arch_info_type *arg); 6070 *Description* 6071 Set the architecture info of ABFD to ARG. 6072 6073 2.13.2.7 `bfd_default_set_arch_mach' 6074 .................................... 6075 6076 *Synopsis* 6077 bfd_boolean bfd_default_set_arch_mach 6078 (bfd *abfd, enum bfd_architecture arch, unsigned long mach); 6079 *Description* 6080 Set the architecture and machine type in BFD ABFD to ARCH and MACH. 6081 Find the correct pointer to a structure and insert it into the 6082 `arch_info' pointer. 6083 6084 2.13.2.8 `bfd_get_arch' 6085 ....................... 6086 6087 *Synopsis* 6088 enum bfd_architecture bfd_get_arch (bfd *abfd); 6089 *Description* 6090 Return the enumerated type which describes the BFD ABFD's architecture. 6091 6092 2.13.2.9 `bfd_get_mach' 6093 ....................... 6094 6095 *Synopsis* 6096 unsigned long bfd_get_mach (bfd *abfd); 6097 *Description* 6098 Return the long type which describes the BFD ABFD's machine. 6099 6100 2.13.2.10 `bfd_arch_bits_per_byte' 6101 .................................. 6102 6103 *Synopsis* 6104 unsigned int bfd_arch_bits_per_byte (bfd *abfd); 6105 *Description* 6106 Return the number of bits in one of the BFD ABFD's architecture's bytes. 6107 6108 2.13.2.11 `bfd_arch_bits_per_address' 6109 ..................................... 6110 6111 *Synopsis* 6112 unsigned int bfd_arch_bits_per_address (bfd *abfd); 6113 *Description* 6114 Return the number of bits in one of the BFD ABFD's architecture's 6115 addresses. 6116 6117 2.13.2.12 `bfd_default_compatible' 6118 .................................. 6119 6120 *Synopsis* 6121 const bfd_arch_info_type *bfd_default_compatible 6122 (const bfd_arch_info_type *a, const bfd_arch_info_type *b); 6123 *Description* 6124 The default function for testing for compatibility. 6125 6126 2.13.2.13 `bfd_default_scan' 6127 ............................ 6128 6129 *Synopsis* 6130 bfd_boolean bfd_default_scan 6131 (const struct bfd_arch_info *info, const char *string); 6132 *Description* 6133 The default function for working out whether this is an architecture 6134 hit and a machine hit. 6135 6136 2.13.2.14 `bfd_get_arch_info' 6137 ............................. 6138 6139 *Synopsis* 6140 const bfd_arch_info_type *bfd_get_arch_info (bfd *abfd); 6141 *Description* 6142 Return the architecture info struct in ABFD. 6143 6144 2.13.2.15 `bfd_lookup_arch' 6145 ........................... 6146 6147 *Synopsis* 6148 const bfd_arch_info_type *bfd_lookup_arch 6149 (enum bfd_architecture arch, unsigned long machine); 6150 *Description* 6151 Look for the architecture info structure which matches the arguments 6152 ARCH and MACHINE. A machine of 0 matches the machine/architecture 6153 structure which marks itself as the default. 6154 6155 2.13.2.16 `bfd_printable_arch_mach' 6156 ................................... 6157 6158 *Synopsis* 6159 const char *bfd_printable_arch_mach 6160 (enum bfd_architecture arch, unsigned long machine); 6161 *Description* 6162 Return a printable string representing the architecture and machine 6163 type. 6164 6165 This routine is depreciated. 6166 6167 2.13.2.17 `bfd_octets_per_byte' 6168 ............................... 6169 6170 *Synopsis* 6171 unsigned int bfd_octets_per_byte (bfd *abfd); 6172 *Description* 6173 Return the number of octets (8-bit quantities) per target byte (minimum 6174 addressable unit). In most cases, this will be one, but some DSP 6175 targets have 16, 32, or even 48 bits per byte. 6176 6177 2.13.2.18 `bfd_arch_mach_octets_per_byte' 6178 ......................................... 6179 6180 *Synopsis* 6181 unsigned int bfd_arch_mach_octets_per_byte 6182 (enum bfd_architecture arch, unsigned long machine); 6183 *Description* 6184 See bfd_octets_per_byte. 6185 6186 This routine is provided for those cases where a bfd * is not 6187 available 6188 6189 6190 File: bfd.info, Node: Opening and Closing, Next: Internal, Prev: Architectures, Up: BFD front end 6191 6192 2.14 Opening and closing BFDs 6193 ============================= 6194 6195 2.14.1 Functions for opening and closing 6196 ---------------------------------------- 6197 6198 2.14.1.1 `bfd_fopen' 6199 .................... 6200 6201 *Synopsis* 6202 bfd *bfd_fopen (const char *filename, const char *target, 6203 const char *mode, int fd); 6204 *Description* 6205 Open the file FILENAME with the target TARGET. Return a pointer to the 6206 created BFD. If FD is not -1, then `fdopen' is used to open the file; 6207 otherwise, `fopen' is used. MODE is passed directly to `fopen' or 6208 `fdopen'. 6209 6210 Calls `bfd_find_target', so TARGET is interpreted as by that 6211 function. 6212 6213 The new BFD is marked as cacheable iff FD is -1. 6214 6215 If `NULL' is returned then an error has occured. Possible errors 6216 are `bfd_error_no_memory', `bfd_error_invalid_target' or `system_call' 6217 error. 6218 6219 2.14.1.2 `bfd_openr' 6220 .................... 6221 6222 *Synopsis* 6223 bfd *bfd_openr (const char *filename, const char *target); 6224 *Description* 6225 Open the file FILENAME (using `fopen') with the target TARGET. Return 6226 a pointer to the created BFD. 6227 6228 Calls `bfd_find_target', so TARGET is interpreted as by that 6229 function. 6230 6231 If `NULL' is returned then an error has occured. Possible errors 6232 are `bfd_error_no_memory', `bfd_error_invalid_target' or `system_call' 6233 error. 6234 6235 2.14.1.3 `bfd_fdopenr' 6236 ...................... 6237 6238 *Synopsis* 6239 bfd *bfd_fdopenr (const char *filename, const char *target, int fd); 6240 *Description* 6241 `bfd_fdopenr' is to `bfd_fopenr' much like `fdopen' is to `fopen'. It 6242 opens a BFD on a file already described by the FD supplied. 6243 6244 When the file is later `bfd_close'd, the file descriptor will be 6245 closed. If the caller desires that this file descriptor be cached by 6246 BFD (opened as needed, closed as needed to free descriptors for other 6247 opens), with the supplied FD used as an initial file descriptor (but 6248 subject to closure at any time), call bfd_set_cacheable(bfd, 1) on the 6249 returned BFD. The default is to assume no caching; the file descriptor 6250 will remain open until `bfd_close', and will not be affected by BFD 6251 operations on other files. 6252 6253 Possible errors are `bfd_error_no_memory', 6254 `bfd_error_invalid_target' and `bfd_error_system_call'. 6255 6256 2.14.1.4 `bfd_openstreamr' 6257 .......................... 6258 6259 *Synopsis* 6260 bfd *bfd_openstreamr (const char *, const char *, void *); 6261 *Description* 6262 Open a BFD for read access on an existing stdio stream. When the BFD 6263 is passed to `bfd_close', the stream will be closed. 6264 6265 2.14.1.5 `bfd_openr_iovec' 6266 .......................... 6267 6268 *Synopsis* 6269 bfd *bfd_openr_iovec (const char *filename, const char *target, 6270 void *(*open) (struct bfd *nbfd, 6271 void *open_closure), 6272 void *open_closure, 6273 file_ptr (*pread) (struct bfd *nbfd, 6274 void *stream, 6275 void *buf, 6276 file_ptr nbytes, 6277 file_ptr offset), 6278 int (*close) (struct bfd *nbfd, 6279 void *stream)); 6280 *Description* 6281 Create and return a BFD backed by a read-only STREAM. The STREAM is 6282 created using OPEN, accessed using PREAD and destroyed using CLOSE. 6283 6284 Calls `bfd_find_target', so TARGET is interpreted as by that 6285 function. 6286 6287 Calls OPEN (which can call `bfd_zalloc' and `bfd_get_filename') to 6288 obtain the read-only stream backing the BFD. OPEN either succeeds 6289 returning the non-`NULL' STREAM, or fails returning `NULL' (setting 6290 `bfd_error'). 6291 6292 Calls PREAD to request NBYTES of data from STREAM starting at OFFSET 6293 (e.g., via a call to `bfd_read'). PREAD either succeeds returning the 6294 number of bytes read (which can be less than NBYTES when end-of-file), 6295 or fails returning -1 (setting `bfd_error'). 6296 6297 Calls CLOSE when the BFD is later closed using `bfd_close'. CLOSE 6298 either succeeds returning 0, or fails returning -1 (setting 6299 `bfd_error'). 6300 6301 If `bfd_openr_iovec' returns `NULL' then an error has occurred. 6302 Possible errors are `bfd_error_no_memory', `bfd_error_invalid_target' 6303 and `bfd_error_system_call'. 6304 6305 2.14.1.6 `bfd_openw' 6306 .................... 6307 6308 *Synopsis* 6309 bfd *bfd_openw (const char *filename, const char *target); 6310 *Description* 6311 Create a BFD, associated with file FILENAME, using the file format 6312 TARGET, and return a pointer to it. 6313 6314 Possible errors are `bfd_error_system_call', `bfd_error_no_memory', 6315 `bfd_error_invalid_target'. 6316 6317 2.14.1.7 `bfd_close' 6318 .................... 6319 6320 *Synopsis* 6321 bfd_boolean bfd_close (bfd *abfd); 6322 *Description* 6323 Close a BFD. If the BFD was open for writing, then pending operations 6324 are completed and the file written out and closed. If the created file 6325 is executable, then `chmod' is called to mark it as such. 6326 6327 All memory attached to the BFD is released. 6328 6329 The file descriptor associated with the BFD is closed (even if it 6330 was passed in to BFD by `bfd_fdopenr'). 6331 6332 *Returns* 6333 `TRUE' is returned if all is ok, otherwise `FALSE'. 6334 6335 2.14.1.8 `bfd_close_all_done' 6336 ............................. 6337 6338 *Synopsis* 6339 bfd_boolean bfd_close_all_done (bfd *); 6340 *Description* 6341 Close a BFD. Differs from `bfd_close' since it does not complete any 6342 pending operations. This routine would be used if the application had 6343 just used BFD for swapping and didn't want to use any of the writing 6344 code. 6345 6346 If the created file is executable, then `chmod' is called to mark it 6347 as such. 6348 6349 All memory attached to the BFD is released. 6350 6351 *Returns* 6352 `TRUE' is returned if all is ok, otherwise `FALSE'. 6353 6354 2.14.1.9 `bfd_create' 6355 ..................... 6356 6357 *Synopsis* 6358 bfd *bfd_create (const char *filename, bfd *templ); 6359 *Description* 6360 Create a new BFD in the manner of `bfd_openw', but without opening a 6361 file. The new BFD takes the target from the target used by TEMPLATE. 6362 The format is always set to `bfd_object'. 6363 6364 2.14.1.10 `bfd_make_writable' 6365 ............................. 6366 6367 *Synopsis* 6368 bfd_boolean bfd_make_writable (bfd *abfd); 6369 *Description* 6370 Takes a BFD as created by `bfd_create' and converts it into one like as 6371 returned by `bfd_openw'. It does this by converting the BFD to 6372 BFD_IN_MEMORY. It's assumed that you will call `bfd_make_readable' on 6373 this bfd later. 6374 6375 *Returns* 6376 `TRUE' is returned if all is ok, otherwise `FALSE'. 6377 6378 2.14.1.11 `bfd_make_readable' 6379 ............................. 6380 6381 *Synopsis* 6382 bfd_boolean bfd_make_readable (bfd *abfd); 6383 *Description* 6384 Takes a BFD as created by `bfd_create' and `bfd_make_writable' and 6385 converts it into one like as returned by `bfd_openr'. It does this by 6386 writing the contents out to the memory buffer, then reversing the 6387 direction. 6388 6389 *Returns* 6390 `TRUE' is returned if all is ok, otherwise `FALSE'. 6391 6392 2.14.1.12 `bfd_alloc' 6393 ..................... 6394 6395 *Synopsis* 6396 void *bfd_alloc (bfd *abfd, bfd_size_type wanted); 6397 *Description* 6398 Allocate a block of WANTED bytes of memory attached to `abfd' and 6399 return a pointer to it. 6400 6401 2.14.1.13 `bfd_alloc2' 6402 ...................... 6403 6404 *Synopsis* 6405 void *bfd_alloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size); 6406 *Description* 6407 Allocate a block of NMEMB elements of SIZE bytes each of memory 6408 attached to `abfd' and return a pointer to it. 6409 6410 2.14.1.14 `bfd_zalloc' 6411 ...................... 6412 6413 *Synopsis* 6414 void *bfd_zalloc (bfd *abfd, bfd_size_type wanted); 6415 *Description* 6416 Allocate a block of WANTED bytes of zeroed memory attached to `abfd' 6417 and return a pointer to it. 6418 6419 2.14.1.15 `bfd_zalloc2' 6420 ....................... 6421 6422 *Synopsis* 6423 void *bfd_zalloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size); 6424 *Description* 6425 Allocate a block of NMEMB elements of SIZE bytes each of zeroed memory 6426 attached to `abfd' and return a pointer to it. 6427 6428 2.14.1.16 `bfd_calc_gnu_debuglink_crc32' 6429 ........................................ 6430 6431 *Synopsis* 6432 unsigned long bfd_calc_gnu_debuglink_crc32 6433 (unsigned long crc, const unsigned char *buf, bfd_size_type len); 6434 *Description* 6435 Computes a CRC value as used in the .gnu_debuglink section. Advances 6436 the previously computed CRC value by computing and adding in the crc32 6437 for LEN bytes of BUF. 6438 6439 *Returns* 6440 Return the updated CRC32 value. 6441 6442 2.14.1.17 `get_debug_link_info' 6443 ............................... 6444 6445 *Synopsis* 6446 char *get_debug_link_info (bfd *abfd, unsigned long *crc32_out); 6447 *Description* 6448 fetch the filename and CRC32 value for any separate debuginfo 6449 associated with ABFD. Return NULL if no such info found, otherwise 6450 return filename and update CRC32_OUT. 6451 6452 2.14.1.18 `separate_debug_file_exists' 6453 ...................................... 6454 6455 *Synopsis* 6456 bfd_boolean separate_debug_file_exists 6457 (char *name, unsigned long crc32); 6458 *Description* 6459 Checks to see if NAME is a file and if its contents match CRC32. 6460 6461 2.14.1.19 `find_separate_debug_file' 6462 .................................... 6463 6464 *Synopsis* 6465 char *find_separate_debug_file (bfd *abfd); 6466 *Description* 6467 Searches ABFD for a reference to separate debugging information, scans 6468 various locations in the filesystem, including the file tree rooted at 6469 DEBUG_FILE_DIRECTORY, and returns a filename of such debugging 6470 information if the file is found and has matching CRC32. Returns NULL 6471 if no reference to debugging file exists, or file cannot be found. 6472 6473 2.14.1.20 `bfd_follow_gnu_debuglink' 6474 .................................... 6475 6476 *Synopsis* 6477 char *bfd_follow_gnu_debuglink (bfd *abfd, const char *dir); 6478 *Description* 6479 Takes a BFD and searches it for a .gnu_debuglink section. If this 6480 section is found, it examines the section for the name and checksum of 6481 a '.debug' file containing auxiliary debugging information. It then 6482 searches the filesystem for this .debug file in some standard 6483 locations, including the directory tree rooted at DIR, and if found 6484 returns the full filename. 6485 6486 If DIR is NULL, it will search a default path configured into libbfd 6487 at build time. [XXX this feature is not currently implemented]. 6488 6489 *Returns* 6490 `NULL' on any errors or failure to locate the .debug file, otherwise a 6491 pointer to a heap-allocated string containing the filename. The caller 6492 is responsible for freeing this string. 6493 6494 2.14.1.21 `bfd_create_gnu_debuglink_section' 6495 ............................................ 6496 6497 *Synopsis* 6498 struct bfd_section *bfd_create_gnu_debuglink_section 6499 (bfd *abfd, const char *filename); 6500 *Description* 6501 Takes a BFD and adds a .gnu_debuglink section to it. The section is 6502 sized to be big enough to contain a link to the specified FILENAME. 6503 6504 *Returns* 6505 A pointer to the new section is returned if all is ok. Otherwise 6506 `NULL' is returned and bfd_error is set. 6507 6508 2.14.1.22 `bfd_fill_in_gnu_debuglink_section' 6509 ............................................. 6510 6511 *Synopsis* 6512 bfd_boolean bfd_fill_in_gnu_debuglink_section 6513 (bfd *abfd, struct bfd_section *sect, const char *filename); 6514 *Description* 6515 Takes a BFD and containing a .gnu_debuglink section SECT and fills in 6516 the contents of the section to contain a link to the specified 6517 FILENAME. The filename should be relative to the current directory. 6518 6519 *Returns* 6520 `TRUE' is returned if all is ok. Otherwise `FALSE' is returned and 6521 bfd_error is set. 6522 6523 6524 File: bfd.info, Node: Internal, Next: File Caching, Prev: Opening and Closing, Up: BFD front end 6525 6526 2.15 Implementation details 6527 =========================== 6528 6529 2.15.1 Internal functions 6530 ------------------------- 6531 6532 *Description* 6533 These routines are used within BFD. They are not intended for export, 6534 but are documented here for completeness. 6535 6536 2.15.1.1 `bfd_write_bigendian_4byte_int' 6537 ........................................ 6538 6539 *Synopsis* 6540 bfd_boolean bfd_write_bigendian_4byte_int (bfd *, unsigned int); 6541 *Description* 6542 Write a 4 byte integer I to the output BFD ABFD, in big endian order 6543 regardless of what else is going on. This is useful in archives. 6544 6545 2.15.1.2 `bfd_put_size' 6546 ....................... 6547 6548 2.15.1.3 `bfd_get_size' 6549 ....................... 6550 6551 *Description* 6552 These macros as used for reading and writing raw data in sections; each 6553 access (except for bytes) is vectored through the target format of the 6554 BFD and mangled accordingly. The mangling performs any necessary endian 6555 translations and removes alignment restrictions. Note that types 6556 accepted and returned by these macros are identical so they can be 6557 swapped around in macros--for example, `libaout.h' defines `GET_WORD' 6558 to either `bfd_get_32' or `bfd_get_64'. 6559 6560 In the put routines, VAL must be a `bfd_vma'. If we are on a system 6561 without prototypes, the caller is responsible for making sure that is 6562 true, with a cast if necessary. We don't cast them in the macro 6563 definitions because that would prevent `lint' or `gcc -Wall' from 6564 detecting sins such as passing a pointer. To detect calling these with 6565 less than a `bfd_vma', use `gcc -Wconversion' on a host with 64 bit 6566 `bfd_vma''s. 6567 6568 /* Byte swapping macros for user section data. */ 6569 6570 #define bfd_put_8(abfd, val, ptr) \ 6571 ((void) (*((unsigned char *) (ptr)) = (val) & 0xff)) 6572 #define bfd_put_signed_8 \ 6573 bfd_put_8 6574 #define bfd_get_8(abfd, ptr) \ 6575 (*(unsigned char *) (ptr) & 0xff) 6576 #define bfd_get_signed_8(abfd, ptr) \ 6577 (((*(unsigned char *) (ptr) & 0xff) ^ 0x80) - 0x80) 6578 6579 #define bfd_put_16(abfd, val, ptr) \ 6580 BFD_SEND (abfd, bfd_putx16, ((val),(ptr))) 6581 #define bfd_put_signed_16 \ 6582 bfd_put_16 6583 #define bfd_get_16(abfd, ptr) \ 6584 BFD_SEND (abfd, bfd_getx16, (ptr)) 6585 #define bfd_get_signed_16(abfd, ptr) \ 6586 BFD_SEND (abfd, bfd_getx_signed_16, (ptr)) 6587 6588 #define bfd_put_32(abfd, val, ptr) \ 6589 BFD_SEND (abfd, bfd_putx32, ((val),(ptr))) 6590 #define bfd_put_signed_32 \ 6591 bfd_put_32 6592 #define bfd_get_32(abfd, ptr) \ 6593 BFD_SEND (abfd, bfd_getx32, (ptr)) 6594 #define bfd_get_signed_32(abfd, ptr) \ 6595 BFD_SEND (abfd, bfd_getx_signed_32, (ptr)) 6596 6597 #define bfd_put_64(abfd, val, ptr) \ 6598 BFD_SEND (abfd, bfd_putx64, ((val), (ptr))) 6599 #define bfd_put_signed_64 \ 6600 bfd_put_64 6601 #define bfd_get_64(abfd, ptr) \ 6602 BFD_SEND (abfd, bfd_getx64, (ptr)) 6603 #define bfd_get_signed_64(abfd, ptr) \ 6604 BFD_SEND (abfd, bfd_getx_signed_64, (ptr)) 6605 6606 #define bfd_get(bits, abfd, ptr) \ 6607 ((bits) == 8 ? (bfd_vma) bfd_get_8 (abfd, ptr) \ 6608 : (bits) == 16 ? bfd_get_16 (abfd, ptr) \ 6609 : (bits) == 32 ? bfd_get_32 (abfd, ptr) \ 6610 : (bits) == 64 ? bfd_get_64 (abfd, ptr) \ 6611 : (abort (), (bfd_vma) - 1)) 6612 6613 #define bfd_put(bits, abfd, val, ptr) \ 6614 ((bits) == 8 ? bfd_put_8 (abfd, val, ptr) \ 6615 : (bits) == 16 ? bfd_put_16 (abfd, val, ptr) \ 6616 : (bits) == 32 ? bfd_put_32 (abfd, val, ptr) \ 6617 : (bits) == 64 ? bfd_put_64 (abfd, val, ptr) \ 6618 : (abort (), (void) 0)) 6619 6620 2.15.1.4 `bfd_h_put_size' 6621 ......................... 6622 6623 *Description* 6624 These macros have the same function as their `bfd_get_x' brethren, 6625 except that they are used for removing information for the header 6626 records of object files. Believe it or not, some object files keep 6627 their header records in big endian order and their data in little 6628 endian order. 6629 6630 /* Byte swapping macros for file header data. */ 6631 6632 #define bfd_h_put_8(abfd, val, ptr) \ 6633 bfd_put_8 (abfd, val, ptr) 6634 #define bfd_h_put_signed_8(abfd, val, ptr) \ 6635 bfd_put_8 (abfd, val, ptr) 6636 #define bfd_h_get_8(abfd, ptr) \ 6637 bfd_get_8 (abfd, ptr) 6638 #define bfd_h_get_signed_8(abfd, ptr) \ 6639 bfd_get_signed_8 (abfd, ptr) 6640 6641 #define bfd_h_put_16(abfd, val, ptr) \ 6642 BFD_SEND (abfd, bfd_h_putx16, (val, ptr)) 6643 #define bfd_h_put_signed_16 \ 6644 bfd_h_put_16 6645 #define bfd_h_get_16(abfd, ptr) \ 6646 BFD_SEND (abfd, bfd_h_getx16, (ptr)) 6647 #define bfd_h_get_signed_16(abfd, ptr) \ 6648 BFD_SEND (abfd, bfd_h_getx_signed_16, (ptr)) 6649 6650 #define bfd_h_put_32(abfd, val, ptr) \ 6651 BFD_SEND (abfd, bfd_h_putx32, (val, ptr)) 6652 #define bfd_h_put_signed_32 \ 6653 bfd_h_put_32 6654 #define bfd_h_get_32(abfd, ptr) \ 6655 BFD_SEND (abfd, bfd_h_getx32, (ptr)) 6656 #define bfd_h_get_signed_32(abfd, ptr) \ 6657 BFD_SEND (abfd, bfd_h_getx_signed_32, (ptr)) 6658 6659 #define bfd_h_put_64(abfd, val, ptr) \ 6660 BFD_SEND (abfd, bfd_h_putx64, (val, ptr)) 6661 #define bfd_h_put_signed_64 \ 6662 bfd_h_put_64 6663 #define bfd_h_get_64(abfd, ptr) \ 6664 BFD_SEND (abfd, bfd_h_getx64, (ptr)) 6665 #define bfd_h_get_signed_64(abfd, ptr) \ 6666 BFD_SEND (abfd, bfd_h_getx_signed_64, (ptr)) 6667 6668 /* Aliases for the above, which should eventually go away. */ 6669 6670 #define H_PUT_64 bfd_h_put_64 6671 #define H_PUT_32 bfd_h_put_32 6672 #define H_PUT_16 bfd_h_put_16 6673 #define H_PUT_8 bfd_h_put_8 6674 #define H_PUT_S64 bfd_h_put_signed_64 6675 #define H_PUT_S32 bfd_h_put_signed_32 6676 #define H_PUT_S16 bfd_h_put_signed_16 6677 #define H_PUT_S8 bfd_h_put_signed_8 6678 #define H_GET_64 bfd_h_get_64 6679 #define H_GET_32 bfd_h_get_32 6680 #define H_GET_16 bfd_h_get_16 6681 #define H_GET_8 bfd_h_get_8 6682 #define H_GET_S64 bfd_h_get_signed_64 6683 #define H_GET_S32 bfd_h_get_signed_32 6684 #define H_GET_S16 bfd_h_get_signed_16 6685 #define H_GET_S8 bfd_h_get_signed_8 6686 6687 2.15.1.5 `bfd_log2' 6688 ................... 6689 6690 *Synopsis* 6691 unsigned int bfd_log2 (bfd_vma x); 6692 *Description* 6693 Return the log base 2 of the value supplied, rounded up. E.g., an X of 6694 1025 returns 11. A X of 0 returns 0. 6695 6696 6697 File: bfd.info, Node: File Caching, Next: Linker Functions, Prev: Internal, Up: BFD front end 6698 6699 2.16 File caching 6700 ================= 6701 6702 The file caching mechanism is embedded within BFD and allows the 6703 application to open as many BFDs as it wants without regard to the 6704 underlying operating system's file descriptor limit (often as low as 20 6705 open files). The module in `cache.c' maintains a least recently used 6706 list of `BFD_CACHE_MAX_OPEN' files, and exports the name 6707 `bfd_cache_lookup', which runs around and makes sure that the required 6708 BFD is open. If not, then it chooses a file to close, closes it and 6709 opens the one wanted, returning its file handle. 6710 6711 2.16.1 Caching functions 6712 ------------------------ 6713 6714 2.16.1.1 `bfd_cache_init' 6715 ......................... 6716 6717 *Synopsis* 6718 bfd_boolean bfd_cache_init (bfd *abfd); 6719 *Description* 6720 Add a newly opened BFD to the cache. 6721 6722 2.16.1.2 `bfd_cache_close' 6723 .......................... 6724 6725 *Synopsis* 6726 bfd_boolean bfd_cache_close (bfd *abfd); 6727 *Description* 6728 Remove the BFD ABFD from the cache. If the attached file is open, then 6729 close it too. 6730 6731 *Returns* 6732 `FALSE' is returned if closing the file fails, `TRUE' is returned if 6733 all is well. 6734 6735 2.16.1.3 `bfd_cache_close_all' 6736 .............................. 6737 6738 *Synopsis* 6739 bfd_boolean bfd_cache_close_all (void); 6740 *Description* 6741 Remove all BFDs from the cache. If the attached file is open, then 6742 close it too. 6743 6744 *Returns* 6745 `FALSE' is returned if closing one of the file fails, `TRUE' is 6746 returned if all is well. 6747 6748 2.16.1.4 `bfd_open_file' 6749 ........................ 6750 6751 *Synopsis* 6752 FILE* bfd_open_file (bfd *abfd); 6753 *Description* 6754 Call the OS to open a file for ABFD. Return the `FILE *' (possibly 6755 `NULL') that results from this operation. Set up the BFD so that 6756 future accesses know the file is open. If the `FILE *' returned is 6757 `NULL', then it won't have been put in the cache, so it won't have to 6758 be removed from it. 6759 6760 6761 File: bfd.info, Node: Linker Functions, Next: Hash Tables, Prev: File Caching, Up: BFD front end 6762 6763 2.17 Linker Functions 6764 ===================== 6765 6766 The linker uses three special entry points in the BFD target vector. 6767 It is not necessary to write special routines for these entry points 6768 when creating a new BFD back end, since generic versions are provided. 6769 However, writing them can speed up linking and make it use 6770 significantly less runtime memory. 6771 6772 The first routine creates a hash table used by the other routines. 6773 The second routine adds the symbols from an object file to the hash 6774 table. The third routine takes all the object files and links them 6775 together to create the output file. These routines are designed so 6776 that the linker proper does not need to know anything about the symbols 6777 in the object files that it is linking. The linker merely arranges the 6778 sections as directed by the linker script and lets BFD handle the 6779 details of symbols and relocs. 6780 6781 The second routine and third routines are passed a pointer to a 6782 `struct bfd_link_info' structure (defined in `bfdlink.h') which holds 6783 information relevant to the link, including the linker hash table 6784 (which was created by the first routine) and a set of callback 6785 functions to the linker proper. 6786 6787 The generic linker routines are in `linker.c', and use the header 6788 file `genlink.h'. As of this writing, the only back ends which have 6789 implemented versions of these routines are a.out (in `aoutx.h') and 6790 ECOFF (in `ecoff.c'). The a.out routines are used as examples 6791 throughout this section. 6792 6793 * Menu: 6794 6795 * Creating a Linker Hash Table:: 6796 * Adding Symbols to the Hash Table:: 6797 * Performing the Final Link:: 6798 6799 6800 File: bfd.info, Node: Creating a Linker Hash Table, Next: Adding Symbols to the Hash Table, Prev: Linker Functions, Up: Linker Functions 6801 6802 2.17.1 Creating a linker hash table 6803 ----------------------------------- 6804 6805 The linker routines must create a hash table, which must be derived 6806 from `struct bfd_link_hash_table' described in `bfdlink.c'. *Note Hash 6807 Tables::, for information on how to create a derived hash table. This 6808 entry point is called using the target vector of the linker output file. 6809 6810 The `_bfd_link_hash_table_create' entry point must allocate and 6811 initialize an instance of the desired hash table. If the back end does 6812 not require any additional information to be stored with the entries in 6813 the hash table, the entry point may simply create a `struct 6814 bfd_link_hash_table'. Most likely, however, some additional 6815 information will be needed. 6816 6817 For example, with each entry in the hash table the a.out linker 6818 keeps the index the symbol has in the final output file (this index 6819 number is used so that when doing a relocatable link the symbol index 6820 used in the output file can be quickly filled in when copying over a 6821 reloc). The a.out linker code defines the required structures and 6822 functions for a hash table derived from `struct bfd_link_hash_table'. 6823 The a.out linker hash table is created by the function 6824 `NAME(aout,link_hash_table_create)'; it simply allocates space for the 6825 hash table, initializes it, and returns a pointer to it. 6826 6827 When writing the linker routines for a new back end, you will 6828 generally not know exactly which fields will be required until you have 6829 finished. You should simply create a new hash table which defines no 6830 additional fields, and then simply add fields as they become necessary. 6831 6832 6833 File: bfd.info, Node: Adding Symbols to the Hash Table, Next: Performing the Final Link, Prev: Creating a Linker Hash Table, Up: Linker Functions 6834 6835 2.17.2 Adding symbols to the hash table 6836 --------------------------------------- 6837 6838 The linker proper will call the `_bfd_link_add_symbols' entry point for 6839 each object file or archive which is to be linked (typically these are 6840 the files named on the command line, but some may also come from the 6841 linker script). The entry point is responsible for examining the file. 6842 For an object file, BFD must add any relevant symbol information to 6843 the hash table. For an archive, BFD must determine which elements of 6844 the archive should be used and adding them to the link. 6845 6846 The a.out version of this entry point is 6847 `NAME(aout,link_add_symbols)'. 6848 6849 * Menu: 6850 6851 * Differing file formats:: 6852 * Adding symbols from an object file:: 6853 * Adding symbols from an archive:: 6854 6855 6856 File: bfd.info, Node: Differing file formats, Next: Adding symbols from an object file, Prev: Adding Symbols to the Hash Table, Up: Adding Symbols to the Hash Table 6857 6858 2.17.2.1 Differing file formats 6859 ............................... 6860 6861 Normally all the files involved in a link will be of the same format, 6862 but it is also possible to link together different format object files, 6863 and the back end must support that. The `_bfd_link_add_symbols' entry 6864 point is called via the target vector of the file to be added. This 6865 has an important consequence: the function may not assume that the hash 6866 table is the type created by the corresponding 6867 `_bfd_link_hash_table_create' vector. All the `_bfd_link_add_symbols' 6868 function can assume about the hash table is that it is derived from 6869 `struct bfd_link_hash_table'. 6870 6871 Sometimes the `_bfd_link_add_symbols' function must store some 6872 information in the hash table entry to be used by the `_bfd_final_link' 6873 function. In such a case the `creator' field of the hash table must be 6874 checked to make sure that the hash table was created by an object file 6875 of the same format. 6876 6877 The `_bfd_final_link' routine must be prepared to handle a hash 6878 entry without any extra information added by the 6879 `_bfd_link_add_symbols' function. A hash entry without extra 6880 information will also occur when the linker script directs the linker 6881 to create a symbol. Note that, regardless of how a hash table entry is 6882 added, all the fields will be initialized to some sort of null value by 6883 the hash table entry initialization function. 6884 6885 See `ecoff_link_add_externals' for an example of how to check the 6886 `creator' field before saving information (in this case, the ECOFF 6887 external symbol debugging information) in a hash table entry. 6888 6889 6890 File: bfd.info, Node: Adding symbols from an object file, Next: Adding symbols from an archive, Prev: Differing file formats, Up: Adding Symbols to the Hash Table 6891 6892 2.17.2.2 Adding symbols from an object file 6893 ........................................... 6894 6895 When the `_bfd_link_add_symbols' routine is passed an object file, it 6896 must add all externally visible symbols in that object file to the hash 6897 table. The actual work of adding the symbol to the hash table is 6898 normally handled by the function `_bfd_generic_link_add_one_symbol'. 6899 The `_bfd_link_add_symbols' routine is responsible for reading all the 6900 symbols from the object file and passing the correct information to 6901 `_bfd_generic_link_add_one_symbol'. 6902 6903 The `_bfd_link_add_symbols' routine should not use 6904 `bfd_canonicalize_symtab' to read the symbols. The point of providing 6905 this routine is to avoid the overhead of converting the symbols into 6906 generic `asymbol' structures. 6907 6908 `_bfd_generic_link_add_one_symbol' handles the details of combining 6909 common symbols, warning about multiple definitions, and so forth. It 6910 takes arguments which describe the symbol to add, notably symbol flags, 6911 a section, and an offset. The symbol flags include such things as 6912 `BSF_WEAK' or `BSF_INDIRECT'. The section is a section in the object 6913 file, or something like `bfd_und_section_ptr' for an undefined symbol 6914 or `bfd_com_section_ptr' for a common symbol. 6915 6916 If the `_bfd_final_link' routine is also going to need to read the 6917 symbol information, the `_bfd_link_add_symbols' routine should save it 6918 somewhere attached to the object file BFD. However, the information 6919 should only be saved if the `keep_memory' field of the `info' argument 6920 is TRUE, so that the `-no-keep-memory' linker switch is effective. 6921 6922 The a.out function which adds symbols from an object file is 6923 `aout_link_add_object_symbols', and most of the interesting work is in 6924 `aout_link_add_symbols'. The latter saves pointers to the hash tables 6925 entries created by `_bfd_generic_link_add_one_symbol' indexed by symbol 6926 number, so that the `_bfd_final_link' routine does not have to call the 6927 hash table lookup routine to locate the entry. 6928 6929 6930 File: bfd.info, Node: Adding symbols from an archive, Prev: Adding symbols from an object file, Up: Adding Symbols to the Hash Table 6931 6932 2.17.2.3 Adding symbols from an archive 6933 ....................................... 6934 6935 When the `_bfd_link_add_symbols' routine is passed an archive, it must 6936 look through the symbols defined by the archive and decide which 6937 elements of the archive should be included in the link. For each such 6938 element it must call the `add_archive_element' linker callback, and it 6939 must add the symbols from the object file to the linker hash table. 6940 6941 In most cases the work of looking through the symbols in the archive 6942 should be done by the `_bfd_generic_link_add_archive_symbols' function. 6943 This function builds a hash table from the archive symbol table and 6944 looks through the list of undefined symbols to see which elements 6945 should be included. `_bfd_generic_link_add_archive_symbols' is passed 6946 a function to call to make the final decision about adding an archive 6947 element to the link and to do the actual work of adding the symbols to 6948 the linker hash table. 6949 6950 The function passed to `_bfd_generic_link_add_archive_symbols' must 6951 read the symbols of the archive element and decide whether the archive 6952 element should be included in the link. If the element is to be 6953 included, the `add_archive_element' linker callback routine must be 6954 called with the element as an argument, and the elements symbols must 6955 be added to the linker hash table just as though the element had itself 6956 been passed to the `_bfd_link_add_symbols' function. 6957 6958 When the a.out `_bfd_link_add_symbols' function receives an archive, 6959 it calls `_bfd_generic_link_add_archive_symbols' passing 6960 `aout_link_check_archive_element' as the function argument. 6961 `aout_link_check_archive_element' calls `aout_link_check_ar_symbols'. 6962 If the latter decides to add the element (an element is only added if 6963 it provides a real, non-common, definition for a previously undefined 6964 or common symbol) it calls the `add_archive_element' callback and then 6965 `aout_link_check_archive_element' calls `aout_link_add_symbols' to 6966 actually add the symbols to the linker hash table. 6967 6968 The ECOFF back end is unusual in that it does not normally call 6969 `_bfd_generic_link_add_archive_symbols', because ECOFF archives already 6970 contain a hash table of symbols. The ECOFF back end searches the 6971 archive itself to avoid the overhead of creating a new hash table. 6972 6973 6974 File: bfd.info, Node: Performing the Final Link, Prev: Adding Symbols to the Hash Table, Up: Linker Functions 6975 6976 2.17.3 Performing the final link 6977 -------------------------------- 6978 6979 When all the input files have been processed, the linker calls the 6980 `_bfd_final_link' entry point of the output BFD. This routine is 6981 responsible for producing the final output file, which has several 6982 aspects. It must relocate the contents of the input sections and copy 6983 the data into the output sections. It must build an output symbol 6984 table including any local symbols from the input files and the global 6985 symbols from the hash table. When producing relocatable output, it must 6986 modify the input relocs and write them into the output file. There may 6987 also be object format dependent work to be done. 6988 6989 The linker will also call the `write_object_contents' entry point 6990 when the BFD is closed. The two entry points must work together in 6991 order to produce the correct output file. 6992 6993 The details of how this works are inevitably dependent upon the 6994 specific object file format. The a.out `_bfd_final_link' routine is 6995 `NAME(aout,final_link)'. 6996 6997 * Menu: 6998 6999 * Information provided by the linker:: 7000 * Relocating the section contents:: 7001 * Writing the symbol table:: 7002 7003 7004 File: bfd.info, Node: Information provided by the linker, Next: Relocating the section contents, Prev: Performing the Final Link, Up: Performing the Final Link 7005 7006 2.17.3.1 Information provided by the linker 7007 ........................................... 7008 7009 Before the linker calls the `_bfd_final_link' entry point, it sets up 7010 some data structures for the function to use. 7011 7012 The `input_bfds' field of the `bfd_link_info' structure will point 7013 to a list of all the input files included in the link. These files are 7014 linked through the `link_next' field of the `bfd' structure. 7015 7016 Each section in the output file will have a list of `link_order' 7017 structures attached to the `map_head.link_order' field (the 7018 `link_order' structure is defined in `bfdlink.h'). These structures 7019 describe how to create the contents of the output section in terms of 7020 the contents of various input sections, fill constants, and, 7021 eventually, other types of information. They also describe relocs that 7022 must be created by the BFD backend, but do not correspond to any input 7023 file; this is used to support -Ur, which builds constructors while 7024 generating a relocatable object file. 7025 7026 7027 File: bfd.info, Node: Relocating the section contents, Next: Writing the symbol table, Prev: Information provided by the linker, Up: Performing the Final Link 7028 7029 2.17.3.2 Relocating the section contents 7030 ........................................ 7031 7032 The `_bfd_final_link' function should look through the `link_order' 7033 structures attached to each section of the output file. Each 7034 `link_order' structure should either be handled specially, or it should 7035 be passed to the function `_bfd_default_link_order' which will do the 7036 right thing (`_bfd_default_link_order' is defined in `linker.c'). 7037 7038 For efficiency, a `link_order' of type `bfd_indirect_link_order' 7039 whose associated section belongs to a BFD of the same format as the 7040 output BFD must be handled specially. This type of `link_order' 7041 describes part of an output section in terms of a section belonging to 7042 one of the input files. The `_bfd_final_link' function should read the 7043 contents of the section and any associated relocs, apply the relocs to 7044 the section contents, and write out the modified section contents. If 7045 performing a relocatable link, the relocs themselves must also be 7046 modified and written out. 7047 7048 The functions `_bfd_relocate_contents' and 7049 `_bfd_final_link_relocate' provide some general support for performing 7050 the actual relocations, notably overflow checking. Their arguments 7051 include information about the symbol the relocation is against and a 7052 `reloc_howto_type' argument which describes the relocation to perform. 7053 These functions are defined in `reloc.c'. 7054 7055 The a.out function which handles reading, relocating, and writing 7056 section contents is `aout_link_input_section'. The actual relocation 7057 is done in `aout_link_input_section_std' and 7058 `aout_link_input_section_ext'. 7059 7060 7061 File: bfd.info, Node: Writing the symbol table, Prev: Relocating the section contents, Up: Performing the Final Link 7062 7063 2.17.3.3 Writing the symbol table 7064 ................................. 7065 7066 The `_bfd_final_link' function must gather all the symbols in the input 7067 files and write them out. It must also write out all the symbols in 7068 the global hash table. This must be controlled by the `strip' and 7069 `discard' fields of the `bfd_link_info' structure. 7070 7071 The local symbols of the input files will not have been entered into 7072 the linker hash table. The `_bfd_final_link' routine must consider 7073 each input file and include the symbols in the output file. It may be 7074 convenient to do this when looking through the `link_order' structures, 7075 or it may be done by stepping through the `input_bfds' list. 7076 7077 The `_bfd_final_link' routine must also traverse the global hash 7078 table to gather all the externally visible symbols. It is possible 7079 that most of the externally visible symbols may be written out when 7080 considering the symbols of each input file, but it is still necessary 7081 to traverse the hash table since the linker script may have defined 7082 some symbols that are not in any of the input files. 7083 7084 The `strip' field of the `bfd_link_info' structure controls which 7085 symbols are written out. The possible values are listed in 7086 `bfdlink.h'. If the value is `strip_some', then the `keep_hash' field 7087 of the `bfd_link_info' structure is a hash table of symbols to keep; 7088 each symbol should be looked up in this hash table, and only symbols 7089 which are present should be included in the output file. 7090 7091 If the `strip' field of the `bfd_link_info' structure permits local 7092 symbols to be written out, the `discard' field is used to further 7093 controls which local symbols are included in the output file. If the 7094 value is `discard_l', then all local symbols which begin with a certain 7095 prefix are discarded; this is controlled by the 7096 `bfd_is_local_label_name' entry point. 7097 7098 The a.out backend handles symbols by calling 7099 `aout_link_write_symbols' on each input BFD and then traversing the 7100 global hash table with the function `aout_link_write_other_symbol'. It 7101 builds a string table while writing out the symbols, which is written 7102 to the output file at the end of `NAME(aout,final_link)'. 7103 7104 2.17.3.4 `bfd_link_split_section' 7105 ................................. 7106 7107 *Synopsis* 7108 bfd_boolean bfd_link_split_section (bfd *abfd, asection *sec); 7109 *Description* 7110 Return nonzero if SEC should be split during a reloceatable or final 7111 link. 7112 #define bfd_link_split_section(abfd, sec) \ 7113 BFD_SEND (abfd, _bfd_link_split_section, (abfd, sec)) 7114 7115 2.17.3.5 `bfd_section_already_linked' 7116 ..................................... 7117 7118 *Synopsis* 7119 void bfd_section_already_linked (bfd *abfd, asection *sec); 7120 *Description* 7121 Check if SEC has been already linked during a reloceatable or final 7122 link. 7123 #define bfd_section_already_linked(abfd, sec) \ 7124 BFD_SEND (abfd, _section_already_linked, (abfd, sec)) 7125 7126 7127 File: bfd.info, Node: Hash Tables, Prev: Linker Functions, Up: BFD front end 7128 7129 2.18 Hash Tables 7130 ================ 7131 7132 BFD provides a simple set of hash table functions. Routines are 7133 provided to initialize a hash table, to free a hash table, to look up a 7134 string in a hash table and optionally create an entry for it, and to 7135 traverse a hash table. There is currently no routine to delete an 7136 string from a hash table. 7137 7138 The basic hash table does not permit any data to be stored with a 7139 string. However, a hash table is designed to present a base class from 7140 which other types of hash tables may be derived. These derived types 7141 may store additional information with the string. Hash tables were 7142 implemented in this way, rather than simply providing a data pointer in 7143 a hash table entry, because they were designed for use by the linker 7144 back ends. The linker may create thousands of hash table entries, and 7145 the overhead of allocating private data and storing and following 7146 pointers becomes noticeable. 7147 7148 The basic hash table code is in `hash.c'. 7149 7150 * Menu: 7151 7152 * Creating and Freeing a Hash Table:: 7153 * Looking Up or Entering a String:: 7154 * Traversing a Hash Table:: 7155 * Deriving a New Hash Table Type:: 7156 7157 7158 File: bfd.info, Node: Creating and Freeing a Hash Table, Next: Looking Up or Entering a String, Prev: Hash Tables, Up: Hash Tables 7159 7160 2.18.1 Creating and freeing a hash table 7161 ---------------------------------------- 7162 7163 To create a hash table, create an instance of a `struct bfd_hash_table' 7164 (defined in `bfd.h') and call `bfd_hash_table_init' (if you know 7165 approximately how many entries you will need, the function 7166 `bfd_hash_table_init_n', which takes a SIZE argument, may be used). 7167 `bfd_hash_table_init' returns `FALSE' if some sort of error occurs. 7168 7169 The function `bfd_hash_table_init' take as an argument a function to 7170 use to create new entries. For a basic hash table, use the function 7171 `bfd_hash_newfunc'. *Note Deriving a New Hash Table Type::, for why 7172 you would want to use a different value for this argument. 7173 7174 `bfd_hash_table_init' will create an objalloc which will be used to 7175 allocate new entries. You may allocate memory on this objalloc using 7176 `bfd_hash_allocate'. 7177 7178 Use `bfd_hash_table_free' to free up all the memory that has been 7179 allocated for a hash table. This will not free up the `struct 7180 bfd_hash_table' itself, which you must provide. 7181 7182 Use `bfd_hash_set_default_size' to set the default size of hash 7183 table to use. 7184 7185 7186 File: bfd.info, Node: Looking Up or Entering a String, Next: Traversing a Hash Table, Prev: Creating and Freeing a Hash Table, Up: Hash Tables 7187 7188 2.18.2 Looking up or entering a string 7189 -------------------------------------- 7190 7191 The function `bfd_hash_lookup' is used both to look up a string in the 7192 hash table and to create a new entry. 7193 7194 If the CREATE argument is `FALSE', `bfd_hash_lookup' will look up a 7195 string. If the string is found, it will returns a pointer to a `struct 7196 bfd_hash_entry'. If the string is not found in the table 7197 `bfd_hash_lookup' will return `NULL'. You should not modify any of the 7198 fields in the returns `struct bfd_hash_entry'. 7199 7200 If the CREATE argument is `TRUE', the string will be entered into 7201 the hash table if it is not already there. Either way a pointer to a 7202 `struct bfd_hash_entry' will be returned, either to the existing 7203 structure or to a newly created one. In this case, a `NULL' return 7204 means that an error occurred. 7205 7206 If the CREATE argument is `TRUE', and a new entry is created, the 7207 COPY argument is used to decide whether to copy the string onto the 7208 hash table objalloc or not. If COPY is passed as `FALSE', you must be 7209 careful not to deallocate or modify the string as long as the hash table 7210 exists. 7211 7212 7213 File: bfd.info, Node: Traversing a Hash Table, Next: Deriving a New Hash Table Type, Prev: Looking Up or Entering a String, Up: Hash Tables 7214 7215 2.18.3 Traversing a hash table 7216 ------------------------------ 7217 7218 The function `bfd_hash_traverse' may be used to traverse a hash table, 7219 calling a function on each element. The traversal is done in a random 7220 order. 7221 7222 `bfd_hash_traverse' takes as arguments a function and a generic 7223 `void *' pointer. The function is called with a hash table entry (a 7224 `struct bfd_hash_entry *') and the generic pointer passed to 7225 `bfd_hash_traverse'. The function must return a `boolean' value, which 7226 indicates whether to continue traversing the hash table. If the 7227 function returns `FALSE', `bfd_hash_traverse' will stop the traversal 7228 and return immediately. 7229 7230 7231 File: bfd.info, Node: Deriving a New Hash Table Type, Prev: Traversing a Hash Table, Up: Hash Tables 7232 7233 2.18.4 Deriving a new hash table type 7234 ------------------------------------- 7235 7236 Many uses of hash tables want to store additional information which 7237 each entry in the hash table. Some also find it convenient to store 7238 additional information with the hash table itself. This may be done 7239 using a derived hash table. 7240 7241 Since C is not an object oriented language, creating a derived hash 7242 table requires sticking together some boilerplate routines with a few 7243 differences specific to the type of hash table you want to create. 7244 7245 An example of a derived hash table is the linker hash table. The 7246 structures for this are defined in `bfdlink.h'. The functions are in 7247 `linker.c'. 7248 7249 You may also derive a hash table from an already derived hash table. 7250 For example, the a.out linker backend code uses a hash table derived 7251 from the linker hash table. 7252 7253 * Menu: 7254 7255 * Define the Derived Structures:: 7256 * Write the Derived Creation Routine:: 7257 * Write Other Derived Routines:: 7258 7259 7260 File: bfd.info, Node: Define the Derived Structures, Next: Write the Derived Creation Routine, Prev: Deriving a New Hash Table Type, Up: Deriving a New Hash Table Type 7261 7262 2.18.4.1 Define the derived structures 7263 ...................................... 7264 7265 You must define a structure for an entry in the hash table, and a 7266 structure for the hash table itself. 7267 7268 The first field in the structure for an entry in the hash table must 7269 be of the type used for an entry in the hash table you are deriving 7270 from. If you are deriving from a basic hash table this is `struct 7271 bfd_hash_entry', which is defined in `bfd.h'. The first field in the 7272 structure for the hash table itself must be of the type of the hash 7273 table you are deriving from itself. If you are deriving from a basic 7274 hash table, this is `struct bfd_hash_table'. 7275 7276 For example, the linker hash table defines `struct 7277 bfd_link_hash_entry' (in `bfdlink.h'). The first field, `root', is of 7278 type `struct bfd_hash_entry'. Similarly, the first field in `struct 7279 bfd_link_hash_table', `table', is of type `struct bfd_hash_table'. 7280 7281 7282 File: bfd.info, Node: Write the Derived Creation Routine, Next: Write Other Derived Routines, Prev: Define the Derived Structures, Up: Deriving a New Hash Table Type 7283 7284 2.18.4.2 Write the derived creation routine 7285 ........................................... 7286 7287 You must write a routine which will create and initialize an entry in 7288 the hash table. This routine is passed as the function argument to 7289 `bfd_hash_table_init'. 7290 7291 In order to permit other hash tables to be derived from the hash 7292 table you are creating, this routine must be written in a standard way. 7293 7294 The first argument to the creation routine is a pointer to a hash 7295 table entry. This may be `NULL', in which case the routine should 7296 allocate the right amount of space. Otherwise the space has already 7297 been allocated by a hash table type derived from this one. 7298 7299 After allocating space, the creation routine must call the creation 7300 routine of the hash table type it is derived from, passing in a pointer 7301 to the space it just allocated. This will initialize any fields used 7302 by the base hash table. 7303 7304 Finally the creation routine must initialize any local fields for 7305 the new hash table type. 7306 7307 Here is a boilerplate example of a creation routine. FUNCTION_NAME 7308 is the name of the routine. ENTRY_TYPE is the type of an entry in the 7309 hash table you are creating. BASE_NEWFUNC is the name of the creation 7310 routine of the hash table type your hash table is derived from. 7311 7312 struct bfd_hash_entry * 7313 FUNCTION_NAME (struct bfd_hash_entry *entry, 7314 struct bfd_hash_table *table, 7315 const char *string) 7316 { 7317 struct ENTRY_TYPE *ret = (ENTRY_TYPE *) entry; 7318 7319 /* Allocate the structure if it has not already been allocated by a 7320 derived class. */ 7321 if (ret == NULL) 7322 { 7323 ret = bfd_hash_allocate (table, sizeof (* ret)); 7324 if (ret == NULL) 7325 return NULL; 7326 } 7327 7328 /* Call the allocation method of the base class. */ 7329 ret = ((ENTRY_TYPE *) 7330 BASE_NEWFUNC ((struct bfd_hash_entry *) ret, table, string)); 7331 7332 /* Initialize the local fields here. */ 7333 7334 return (struct bfd_hash_entry *) ret; 7335 } 7336 *Description* 7337 The creation routine for the linker hash table, which is in `linker.c', 7338 looks just like this example. FUNCTION_NAME is 7339 `_bfd_link_hash_newfunc'. ENTRY_TYPE is `struct bfd_link_hash_entry'. 7340 BASE_NEWFUNC is `bfd_hash_newfunc', the creation routine for a basic 7341 hash table. 7342 7343 `_bfd_link_hash_newfunc' also initializes the local fields in a 7344 linker hash table entry: `type', `written' and `next'. 7345 7346 7347 File: bfd.info, Node: Write Other Derived Routines, Prev: Write the Derived Creation Routine, Up: Deriving a New Hash Table Type 7348 7349 2.18.4.3 Write other derived routines 7350 ..................................... 7351 7352 You will want to write other routines for your new hash table, as well. 7353 7354 You will want an initialization routine which calls the 7355 initialization routine of the hash table you are deriving from and 7356 initializes any other local fields. For the linker hash table, this is 7357 `_bfd_link_hash_table_init' in `linker.c'. 7358 7359 You will want a lookup routine which calls the lookup routine of the 7360 hash table you are deriving from and casts the result. The linker hash 7361 table uses `bfd_link_hash_lookup' in `linker.c' (this actually takes an 7362 additional argument which it uses to decide how to return the looked up 7363 value). 7364 7365 You may want a traversal routine. This should just call the 7366 traversal routine of the hash table you are deriving from with 7367 appropriate casts. The linker hash table uses `bfd_link_hash_traverse' 7368 in `linker.c'. 7369 7370 These routines may simply be defined as macros. For example, the 7371 a.out backend linker hash table, which is derived from the linker hash 7372 table, uses macros for the lookup and traversal routines. These are 7373 `aout_link_hash_lookup' and `aout_link_hash_traverse' in aoutx.h. 7374 7375 7376 File: bfd.info, Node: BFD back ends, Next: GNU Free Documentation License, Prev: BFD front end, Up: Top 7377 7378 3 BFD back ends 7379 *************** 7380 7381 * Menu: 7382 7383 * What to Put Where:: 7384 * aout :: a.out backends 7385 * coff :: coff backends 7386 * elf :: elf backends 7387 * mmo :: mmo backend 7388 7389 7390 File: bfd.info, Node: What to Put Where, Next: aout, Prev: BFD back ends, Up: BFD back ends 7391 7392 All of BFD lives in one directory. 7393 7394 7395 File: bfd.info, Node: aout, Next: coff, Prev: What to Put Where, Up: BFD back ends 7396 7397 3.1 a.out backends 7398 ================== 7399 7400 *Description* 7401 BFD supports a number of different flavours of a.out format, though the 7402 major differences are only the sizes of the structures on disk, and the 7403 shape of the relocation information. 7404 7405 The support is split into a basic support file `aoutx.h' and other 7406 files which derive functions from the base. One derivation file is 7407 `aoutf1.h' (for a.out flavour 1), and adds to the basic a.out functions 7408 support for sun3, sun4, 386 and 29k a.out files, to create a target 7409 jump vector for a specific target. 7410 7411 This information is further split out into more specific files for 7412 each machine, including `sunos.c' for sun3 and sun4, `newsos3.c' for 7413 the Sony NEWS, and `demo64.c' for a demonstration of a 64 bit a.out 7414 format. 7415 7416 The base file `aoutx.h' defines general mechanisms for reading and 7417 writing records to and from disk and various other methods which BFD 7418 requires. It is included by `aout32.c' and `aout64.c' to form the names 7419 `aout_32_swap_exec_header_in', `aout_64_swap_exec_header_in', etc. 7420 7421 As an example, this is what goes on to make the back end for a sun4, 7422 from `aout32.c': 7423 7424 #define ARCH_SIZE 32 7425 #include "aoutx.h" 7426 7427 Which exports names: 7428 7429 ... 7430 aout_32_canonicalize_reloc 7431 aout_32_find_nearest_line 7432 aout_32_get_lineno 7433 aout_32_get_reloc_upper_bound 7434 ... 7435 7436 from `sunos.c': 7437 7438 #define TARGET_NAME "a.out-sunos-big" 7439 #define VECNAME sunos_big_vec 7440 #include "aoutf1.h" 7441 7442 requires all the names from `aout32.c', and produces the jump vector 7443 7444 sunos_big_vec 7445 7446 The file `host-aout.c' is a special case. It is for a large set of 7447 hosts that use "more or less standard" a.out files, and for which 7448 cross-debugging is not interesting. It uses the standard 32-bit a.out 7449 support routines, but determines the file offsets and addresses of the 7450 text, data, and BSS sections, the machine architecture and machine 7451 type, and the entry point address, in a host-dependent manner. Once 7452 these values have been determined, generic code is used to handle the 7453 object file. 7454 7455 When porting it to run on a new system, you must supply: 7456 7457 HOST_PAGE_SIZE 7458 HOST_SEGMENT_SIZE 7459 HOST_MACHINE_ARCH (optional) 7460 HOST_MACHINE_MACHINE (optional) 7461 HOST_TEXT_START_ADDR 7462 HOST_STACK_END_ADDR 7463 7464 in the file `../include/sys/h-XXX.h' (for your host). These values, 7465 plus the structures and macros defined in `a.out.h' on your host 7466 system, will produce a BFD target that will access ordinary a.out files 7467 on your host. To configure a new machine to use `host-aout.c', specify: 7468 7469 TDEFAULTS = -DDEFAULT_VECTOR=host_aout_big_vec 7470 TDEPFILES= host-aout.o trad-core.o 7471 7472 in the `config/XXX.mt' file, and modify `configure.in' to use the 7473 `XXX.mt' file (by setting "`bfd_target=XXX'") when your configuration 7474 is selected. 7475 7476 3.1.1 Relocations 7477 ----------------- 7478 7479 *Description* 7480 The file `aoutx.h' provides for both the _standard_ and _extended_ 7481 forms of a.out relocation records. 7482 7483 The standard records contain only an address, a symbol index, and a 7484 type field. The extended records (used on 29ks and sparcs) also have a 7485 full integer for an addend. 7486 7487 3.1.2 Internal entry points 7488 --------------------------- 7489 7490 *Description* 7491 `aoutx.h' exports several routines for accessing the contents of an 7492 a.out file, which are gathered and exported in turn by various format 7493 specific files (eg sunos.c). 7494 7495 3.1.2.1 `aout_SIZE_swap_exec_header_in' 7496 ....................................... 7497 7498 *Synopsis* 7499 void aout_SIZE_swap_exec_header_in, 7500 (bfd *abfd, 7501 struct external_exec *bytes, 7502 struct internal_exec *execp); 7503 *Description* 7504 Swap the information in an executable header RAW_BYTES taken from a raw 7505 byte stream memory image into the internal exec header structure EXECP. 7506 7507 3.1.2.2 `aout_SIZE_swap_exec_header_out' 7508 ........................................ 7509 7510 *Synopsis* 7511 void aout_SIZE_swap_exec_header_out 7512 (bfd *abfd, 7513 struct internal_exec *execp, 7514 struct external_exec *raw_bytes); 7515 *Description* 7516 Swap the information in an internal exec header structure EXECP into 7517 the buffer RAW_BYTES ready for writing to disk. 7518 7519 3.1.2.3 `aout_SIZE_some_aout_object_p' 7520 ...................................... 7521 7522 *Synopsis* 7523 const bfd_target *aout_SIZE_some_aout_object_p 7524 (bfd *abfd, 7525 struct internal_exec *execp, 7526 const bfd_target *(*callback_to_real_object_p) (bfd *)); 7527 *Description* 7528 Some a.out variant thinks that the file open in ABFD checking is an 7529 a.out file. Do some more checking, and set up for access if it really 7530 is. Call back to the calling environment's "finish up" function just 7531 before returning, to handle any last-minute setup. 7532 7533 3.1.2.4 `aout_SIZE_mkobject' 7534 ............................ 7535 7536 *Synopsis* 7537 bfd_boolean aout_SIZE_mkobject, (bfd *abfd); 7538 *Description* 7539 Initialize BFD ABFD for use with a.out files. 7540 7541 3.1.2.5 `aout_SIZE_machine_type' 7542 ................................ 7543 7544 *Synopsis* 7545 enum machine_type aout_SIZE_machine_type 7546 (enum bfd_architecture arch, 7547 unsigned long machine, 7548 bfd_boolean *unknown); 7549 *Description* 7550 Keep track of machine architecture and machine type for a.out's. Return 7551 the `machine_type' for a particular architecture and machine, or 7552 `M_UNKNOWN' if that exact architecture and machine can't be represented 7553 in a.out format. 7554 7555 If the architecture is understood, machine type 0 (default) is 7556 always understood. 7557 7558 3.1.2.6 `aout_SIZE_set_arch_mach' 7559 ................................. 7560 7561 *Synopsis* 7562 bfd_boolean aout_SIZE_set_arch_mach, 7563 (bfd *, 7564 enum bfd_architecture arch, 7565 unsigned long machine); 7566 *Description* 7567 Set the architecture and the machine of the BFD ABFD to the values ARCH 7568 and MACHINE. Verify that ABFD's format can support the architecture 7569 required. 7570 7571 3.1.2.7 `aout_SIZE_new_section_hook' 7572 .................................... 7573 7574 *Synopsis* 7575 bfd_boolean aout_SIZE_new_section_hook, 7576 (bfd *abfd, 7577 asection *newsect); 7578 *Description* 7579 Called by the BFD in response to a `bfd_make_section' request. 7580 7581 7582 File: bfd.info, Node: coff, Next: elf, Prev: aout, Up: BFD back ends 7583 7584 3.2 coff backends 7585 ================= 7586 7587 BFD supports a number of different flavours of coff format. The major 7588 differences between formats are the sizes and alignments of fields in 7589 structures on disk, and the occasional extra field. 7590 7591 Coff in all its varieties is implemented with a few common files and 7592 a number of implementation specific files. For example, The 88k bcs 7593 coff format is implemented in the file `coff-m88k.c'. This file 7594 `#include's `coff/m88k.h' which defines the external structure of the 7595 coff format for the 88k, and `coff/internal.h' which defines the 7596 internal structure. `coff-m88k.c' also defines the relocations used by 7597 the 88k format *Note Relocations::. 7598 7599 The Intel i960 processor version of coff is implemented in 7600 `coff-i960.c'. This file has the same structure as `coff-m88k.c', 7601 except that it includes `coff/i960.h' rather than `coff-m88k.h'. 7602 7603 3.2.1 Porting to a new version of coff 7604 -------------------------------------- 7605 7606 The recommended method is to select from the existing implementations 7607 the version of coff which is most like the one you want to use. For 7608 example, we'll say that i386 coff is the one you select, and that your 7609 coff flavour is called foo. Copy `i386coff.c' to `foocoff.c', copy 7610 `../include/coff/i386.h' to `../include/coff/foo.h', and add the lines 7611 to `targets.c' and `Makefile.in' so that your new back end is used. 7612 Alter the shapes of the structures in `../include/coff/foo.h' so that 7613 they match what you need. You will probably also have to add `#ifdef's 7614 to the code in `coff/internal.h' and `coffcode.h' if your version of 7615 coff is too wild. 7616 7617 You can verify that your new BFD backend works quite simply by 7618 building `objdump' from the `binutils' directory, and making sure that 7619 its version of what's going on and your host system's idea (assuming it 7620 has the pretty standard coff dump utility, usually called `att-dump' or 7621 just `dump') are the same. Then clean up your code, and send what 7622 you've done to Cygnus. Then your stuff will be in the next release, and 7623 you won't have to keep integrating it. 7624 7625 3.2.2 How the coff backend works 7626 -------------------------------- 7627 7628 3.2.2.1 File layout 7629 ................... 7630 7631 The Coff backend is split into generic routines that are applicable to 7632 any Coff target and routines that are specific to a particular target. 7633 The target-specific routines are further split into ones which are 7634 basically the same for all Coff targets except that they use the 7635 external symbol format or use different values for certain constants. 7636 7637 The generic routines are in `coffgen.c'. These routines work for 7638 any Coff target. They use some hooks into the target specific code; 7639 the hooks are in a `bfd_coff_backend_data' structure, one of which 7640 exists for each target. 7641 7642 The essentially similar target-specific routines are in 7643 `coffcode.h'. This header file includes executable C code. The 7644 various Coff targets first include the appropriate Coff header file, 7645 make any special defines that are needed, and then include `coffcode.h'. 7646 7647 Some of the Coff targets then also have additional routines in the 7648 target source file itself. 7649 7650 For example, `coff-i960.c' includes `coff/internal.h' and 7651 `coff/i960.h'. It then defines a few constants, such as `I960', and 7652 includes `coffcode.h'. Since the i960 has complex relocation types, 7653 `coff-i960.c' also includes some code to manipulate the i960 relocs. 7654 This code is not in `coffcode.h' because it would not be used by any 7655 other target. 7656 7657 3.2.2.2 Bit twiddling 7658 ..................... 7659 7660 Each flavour of coff supported in BFD has its own header file 7661 describing the external layout of the structures. There is also an 7662 internal description of the coff layout, in `coff/internal.h'. A major 7663 function of the coff backend is swapping the bytes and twiddling the 7664 bits to translate the external form of the structures into the normal 7665 internal form. This is all performed in the `bfd_swap'_thing_direction 7666 routines. Some elements are different sizes between different versions 7667 of coff; it is the duty of the coff version specific include file to 7668 override the definitions of various packing routines in `coffcode.h'. 7669 E.g., the size of line number entry in coff is sometimes 16 bits, and 7670 sometimes 32 bits. `#define'ing `PUT_LNSZ_LNNO' and `GET_LNSZ_LNNO' 7671 will select the correct one. No doubt, some day someone will find a 7672 version of coff which has a varying field size not catered to at the 7673 moment. To port BFD, that person will have to add more `#defines'. 7674 Three of the bit twiddling routines are exported to `gdb'; 7675 `coff_swap_aux_in', `coff_swap_sym_in' and `coff_swap_lineno_in'. `GDB' 7676 reads the symbol table on its own, but uses BFD to fix things up. More 7677 of the bit twiddlers are exported for `gas'; `coff_swap_aux_out', 7678 `coff_swap_sym_out', `coff_swap_lineno_out', `coff_swap_reloc_out', 7679 `coff_swap_filehdr_out', `coff_swap_aouthdr_out', 7680 `coff_swap_scnhdr_out'. `Gas' currently keeps track of all the symbol 7681 table and reloc drudgery itself, thereby saving the internal BFD 7682 overhead, but uses BFD to swap things on the way out, making cross 7683 ports much safer. Doing so also allows BFD (and thus the linker) to 7684 use the same header files as `gas', which makes one avenue to disaster 7685 disappear. 7686 7687 3.2.2.3 Symbol reading 7688 ...................... 7689 7690 The simple canonical form for symbols used by BFD is not rich enough to 7691 keep all the information available in a coff symbol table. The back end 7692 gets around this problem by keeping the original symbol table around, 7693 "behind the scenes". 7694 7695 When a symbol table is requested (through a call to 7696 `bfd_canonicalize_symtab'), a request gets through to 7697 `coff_get_normalized_symtab'. This reads the symbol table from the coff 7698 file and swaps all the structures inside into the internal form. It 7699 also fixes up all the pointers in the table (represented in the file by 7700 offsets from the first symbol in the table) into physical pointers to 7701 elements in the new internal table. This involves some work since the 7702 meanings of fields change depending upon context: a field that is a 7703 pointer to another structure in the symbol table at one moment may be 7704 the size in bytes of a structure at the next. Another pass is made 7705 over the table. All symbols which mark file names (`C_FILE' symbols) 7706 are modified so that the internal string points to the value in the 7707 auxent (the real filename) rather than the normal text associated with 7708 the symbol (`".file"'). 7709 7710 At this time the symbol names are moved around. Coff stores all 7711 symbols less than nine characters long physically within the symbol 7712 table; longer strings are kept at the end of the file in the string 7713 table. This pass moves all strings into memory and replaces them with 7714 pointers to the strings. 7715 7716 The symbol table is massaged once again, this time to create the 7717 canonical table used by the BFD application. Each symbol is inspected 7718 in turn, and a decision made (using the `sclass' field) about the 7719 various flags to set in the `asymbol'. *Note Symbols::. The generated 7720 canonical table shares strings with the hidden internal symbol table. 7721 7722 Any linenumbers are read from the coff file too, and attached to the 7723 symbols which own the functions the linenumbers belong to. 7724 7725 3.2.2.4 Symbol writing 7726 ...................... 7727 7728 Writing a symbol to a coff file which didn't come from a coff file will 7729 lose any debugging information. The `asymbol' structure remembers the 7730 BFD from which the symbol was taken, and on output the back end makes 7731 sure that the same destination target as source target is present. 7732 7733 When the symbols have come from a coff file then all the debugging 7734 information is preserved. 7735 7736 Symbol tables are provided for writing to the back end in a vector 7737 of pointers to pointers. This allows applications like the linker to 7738 accumulate and output large symbol tables without having to do too much 7739 byte copying. 7740 7741 This function runs through the provided symbol table and patches 7742 each symbol marked as a file place holder (`C_FILE') to point to the 7743 next file place holder in the list. It also marks each `offset' field 7744 in the list with the offset from the first symbol of the current symbol. 7745 7746 Another function of this procedure is to turn the canonical value 7747 form of BFD into the form used by coff. Internally, BFD expects symbol 7748 values to be offsets from a section base; so a symbol physically at 7749 0x120, but in a section starting at 0x100, would have the value 0x20. 7750 Coff expects symbols to contain their final value, so symbols have 7751 their values changed at this point to reflect their sum with their 7752 owning section. This transformation uses the `output_section' field of 7753 the `asymbol''s `asection' *Note Sections::. 7754 7755 * `coff_mangle_symbols' 7756 This routine runs though the provided symbol table and uses the 7757 offsets generated by the previous pass and the pointers generated when 7758 the symbol table was read in to create the structured hierarchy 7759 required by coff. It changes each pointer to a symbol into the index 7760 into the symbol table of the asymbol. 7761 7762 * `coff_write_symbols' 7763 This routine runs through the symbol table and patches up the 7764 symbols from their internal form into the coff way, calls the bit 7765 twiddlers, and writes out the table to the file. 7766 7767 3.2.2.5 `coff_symbol_type' 7768 .......................... 7769 7770 *Description* 7771 The hidden information for an `asymbol' is described in a 7772 `combined_entry_type': 7773 7774 7775 typedef struct coff_ptr_struct 7776 { 7777 /* Remembers the offset from the first symbol in the file for 7778 this symbol. Generated by coff_renumber_symbols. */ 7779 unsigned int offset; 7780 7781 /* Should the value of this symbol be renumbered. Used for 7782 XCOFF C_BSTAT symbols. Set by coff_slurp_symbol_table. */ 7783 unsigned int fix_value : 1; 7784 7785 /* Should the tag field of this symbol be renumbered. 7786 Created by coff_pointerize_aux. */ 7787 unsigned int fix_tag : 1; 7788 7789 /* Should the endidx field of this symbol be renumbered. 7790 Created by coff_pointerize_aux. */ 7791 unsigned int fix_end : 1; 7792 7793 /* Should the x_csect.x_scnlen field be renumbered. 7794 Created by coff_pointerize_aux. */ 7795 unsigned int fix_scnlen : 1; 7796 7797 /* Fix up an XCOFF C_BINCL/C_EINCL symbol. The value is the 7798 index into the line number entries. Set by coff_slurp_symbol_table. */ 7799 unsigned int fix_line : 1; 7800 7801 /* The container for the symbol structure as read and translated 7802 from the file. */ 7803 union 7804 { 7805 union internal_auxent auxent; 7806 struct internal_syment syment; 7807 } u; 7808 } combined_entry_type; 7809 7810 7811 /* Each canonical asymbol really looks like this: */ 7812 7813 typedef struct coff_symbol_struct 7814 { 7815 /* The actual symbol which the rest of BFD works with */ 7816 asymbol symbol; 7817 7818 /* A pointer to the hidden information for this symbol */ 7819 combined_entry_type *native; 7820 7821 /* A pointer to the linenumber information for this symbol */ 7822 struct lineno_cache_entry *lineno; 7823 7824 /* Have the line numbers been relocated yet ? */ 7825 bfd_boolean done_lineno; 7826 } coff_symbol_type; 7827 7828 3.2.2.6 `bfd_coff_backend_data' 7829 ............................... 7830 7831 /* COFF symbol classifications. */ 7832 7833 enum coff_symbol_classification 7834 { 7835 /* Global symbol. */ 7836 COFF_SYMBOL_GLOBAL, 7837 /* Common symbol. */ 7838 COFF_SYMBOL_COMMON, 7839 /* Undefined symbol. */ 7840 COFF_SYMBOL_UNDEFINED, 7841 /* Local symbol. */ 7842 COFF_SYMBOL_LOCAL, 7843 /* PE section symbol. */ 7844 COFF_SYMBOL_PE_SECTION 7845 }; 7846 Special entry points for gdb to swap in coff symbol table parts: 7847 typedef struct 7848 { 7849 void (*_bfd_coff_swap_aux_in) 7850 (bfd *, void *, int, int, int, int, void *); 7851 7852 void (*_bfd_coff_swap_sym_in) 7853 (bfd *, void *, void *); 7854 7855 void (*_bfd_coff_swap_lineno_in) 7856 (bfd *, void *, void *); 7857 7858 unsigned int (*_bfd_coff_swap_aux_out) 7859 (bfd *, void *, int, int, int, int, void *); 7860 7861 unsigned int (*_bfd_coff_swap_sym_out) 7862 (bfd *, void *, void *); 7863 7864 unsigned int (*_bfd_coff_swap_lineno_out) 7865 (bfd *, void *, void *); 7866 7867 unsigned int (*_bfd_coff_swap_reloc_out) 7868 (bfd *, void *, void *); 7869 7870 unsigned int (*_bfd_coff_swap_filehdr_out) 7871 (bfd *, void *, void *); 7872 7873 unsigned int (*_bfd_coff_swap_aouthdr_out) 7874 (bfd *, void *, void *); 7875 7876 unsigned int (*_bfd_coff_swap_scnhdr_out) 7877 (bfd *, void *, void *); 7878 7879 unsigned int _bfd_filhsz; 7880 unsigned int _bfd_aoutsz; 7881 unsigned int _bfd_scnhsz; 7882 unsigned int _bfd_symesz; 7883 unsigned int _bfd_auxesz; 7884 unsigned int _bfd_relsz; 7885 unsigned int _bfd_linesz; 7886 unsigned int _bfd_filnmlen; 7887 bfd_boolean _bfd_coff_long_filenames; 7888 bfd_boolean _bfd_coff_long_section_names; 7889 unsigned int _bfd_coff_default_section_alignment_power; 7890 bfd_boolean _bfd_coff_force_symnames_in_strings; 7891 unsigned int _bfd_coff_debug_string_prefix_length; 7892 7893 void (*_bfd_coff_swap_filehdr_in) 7894 (bfd *, void *, void *); 7895 7896 void (*_bfd_coff_swap_aouthdr_in) 7897 (bfd *, void *, void *); 7898 7899 void (*_bfd_coff_swap_scnhdr_in) 7900 (bfd *, void *, void *); 7901 7902 void (*_bfd_coff_swap_reloc_in) 7903 (bfd *abfd, void *, void *); 7904 7905 bfd_boolean (*_bfd_coff_bad_format_hook) 7906 (bfd *, void *); 7907 7908 bfd_boolean (*_bfd_coff_set_arch_mach_hook) 7909 (bfd *, void *); 7910 7911 void * (*_bfd_coff_mkobject_hook) 7912 (bfd *, void *, void *); 7913 7914 bfd_boolean (*_bfd_styp_to_sec_flags_hook) 7915 (bfd *, void *, const char *, asection *, flagword *); 7916 7917 void (*_bfd_set_alignment_hook) 7918 (bfd *, asection *, void *); 7919 7920 bfd_boolean (*_bfd_coff_slurp_symbol_table) 7921 (bfd *); 7922 7923 bfd_boolean (*_bfd_coff_symname_in_debug) 7924 (bfd *, struct internal_syment *); 7925 7926 bfd_boolean (*_bfd_coff_pointerize_aux_hook) 7927 (bfd *, combined_entry_type *, combined_entry_type *, 7928 unsigned int, combined_entry_type *); 7929 7930 bfd_boolean (*_bfd_coff_print_aux) 7931 (bfd *, FILE *, combined_entry_type *, combined_entry_type *, 7932 combined_entry_type *, unsigned int); 7933 7934 void (*_bfd_coff_reloc16_extra_cases) 7935 (bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *, 7936 bfd_byte *, unsigned int *, unsigned int *); 7937 7938 int (*_bfd_coff_reloc16_estimate) 7939 (bfd *, asection *, arelent *, unsigned int, 7940 struct bfd_link_info *); 7941 7942 enum coff_symbol_classification (*_bfd_coff_classify_symbol) 7943 (bfd *, struct internal_syment *); 7944 7945 bfd_boolean (*_bfd_coff_compute_section_file_positions) 7946 (bfd *); 7947 7948 bfd_boolean (*_bfd_coff_start_final_link) 7949 (bfd *, struct bfd_link_info *); 7950 7951 bfd_boolean (*_bfd_coff_relocate_section) 7952 (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *, 7953 struct internal_reloc *, struct internal_syment *, asection **); 7954 7955 reloc_howto_type *(*_bfd_coff_rtype_to_howto) 7956 (bfd *, asection *, struct internal_reloc *, 7957 struct coff_link_hash_entry *, struct internal_syment *, 7958 bfd_vma *); 7959 7960 bfd_boolean (*_bfd_coff_adjust_symndx) 7961 (bfd *, struct bfd_link_info *, bfd *, asection *, 7962 struct internal_reloc *, bfd_boolean *); 7963 7964 bfd_boolean (*_bfd_coff_link_add_one_symbol) 7965 (struct bfd_link_info *, bfd *, const char *, flagword, 7966 asection *, bfd_vma, const char *, bfd_boolean, bfd_boolean, 7967 struct bfd_link_hash_entry **); 7968 7969 bfd_boolean (*_bfd_coff_link_output_has_begun) 7970 (bfd *, struct coff_final_link_info *); 7971 7972 bfd_boolean (*_bfd_coff_final_link_postscript) 7973 (bfd *, struct coff_final_link_info *); 7974 7975 } bfd_coff_backend_data; 7976 7977 #define coff_backend_info(abfd) \ 7978 ((bfd_coff_backend_data *) (abfd)->xvec->backend_data) 7979 7980 #define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \ 7981 ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i)) 7982 7983 #define bfd_coff_swap_sym_in(a,e,i) \ 7984 ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i)) 7985 7986 #define bfd_coff_swap_lineno_in(a,e,i) \ 7987 ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i)) 7988 7989 #define bfd_coff_swap_reloc_out(abfd, i, o) \ 7990 ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o)) 7991 7992 #define bfd_coff_swap_lineno_out(abfd, i, o) \ 7993 ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o)) 7994 7995 #define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \ 7996 ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o)) 7997 7998 #define bfd_coff_swap_sym_out(abfd, i,o) \ 7999 ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o)) 8000 8001 #define bfd_coff_swap_scnhdr_out(abfd, i,o) \ 8002 ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o)) 8003 8004 #define bfd_coff_swap_filehdr_out(abfd, i,o) \ 8005 ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o)) 8006 8007 #define bfd_coff_swap_aouthdr_out(abfd, i,o) \ 8008 ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o)) 8009 8010 #define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz) 8011 #define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz) 8012 #define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz) 8013 #define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz) 8014 #define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz) 8015 #define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz) 8016 #define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz) 8017 #define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen) 8018 #define bfd_coff_long_filenames(abfd) \ 8019 (coff_backend_info (abfd)->_bfd_coff_long_filenames) 8020 #define bfd_coff_long_section_names(abfd) \ 8021 (coff_backend_info (abfd)->_bfd_coff_long_section_names) 8022 #define bfd_coff_default_section_alignment_power(abfd) \ 8023 (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power) 8024 #define bfd_coff_swap_filehdr_in(abfd, i,o) \ 8025 ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o)) 8026 8027 #define bfd_coff_swap_aouthdr_in(abfd, i,o) \ 8028 ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o)) 8029 8030 #define bfd_coff_swap_scnhdr_in(abfd, i,o) \ 8031 ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o)) 8032 8033 #define bfd_coff_swap_reloc_in(abfd, i, o) \ 8034 ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o)) 8035 8036 #define bfd_coff_bad_format_hook(abfd, filehdr) \ 8037 ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr)) 8038 8039 #define bfd_coff_set_arch_mach_hook(abfd, filehdr)\ 8040 ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr)) 8041 #define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\ 8042 ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook)\ 8043 (abfd, filehdr, aouthdr)) 8044 8045 #define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name, section, flags_ptr)\ 8046 ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook)\ 8047 (abfd, scnhdr, name, section, flags_ptr)) 8048 8049 #define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\ 8050 ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr)) 8051 8052 #define bfd_coff_slurp_symbol_table(abfd)\ 8053 ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd)) 8054 8055 #define bfd_coff_symname_in_debug(abfd, sym)\ 8056 ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym)) 8057 8058 #define bfd_coff_force_symnames_in_strings(abfd)\ 8059 (coff_backend_info (abfd)->_bfd_coff_force_symnames_in_strings) 8060 8061 #define bfd_coff_debug_string_prefix_length(abfd)\ 8062 (coff_backend_info (abfd)->_bfd_coff_debug_string_prefix_length) 8063 8064 #define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\ 8065 ((coff_backend_info (abfd)->_bfd_coff_print_aux)\ 8066 (abfd, file, base, symbol, aux, indaux)) 8067 8068 #define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order,\ 8069 reloc, data, src_ptr, dst_ptr)\ 8070 ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\ 8071 (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr)) 8072 8073 #define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\ 8074 ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\ 8075 (abfd, section, reloc, shrink, link_info)) 8076 8077 #define bfd_coff_classify_symbol(abfd, sym)\ 8078 ((coff_backend_info (abfd)->_bfd_coff_classify_symbol)\ 8079 (abfd, sym)) 8080 8081 #define bfd_coff_compute_section_file_positions(abfd)\ 8082 ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\ 8083 (abfd)) 8084 8085 #define bfd_coff_start_final_link(obfd, info)\ 8086 ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\ 8087 (obfd, info)) 8088 #define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\ 8089 ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\ 8090 (obfd, info, ibfd, o, con, rel, isyms, secs)) 8091 #define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\ 8092 ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\ 8093 (abfd, sec, rel, h, sym, addendp)) 8094 #define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\ 8095 ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\ 8096 (obfd, info, ibfd, sec, rel, adjustedp)) 8097 #define bfd_coff_link_add_one_symbol(info, abfd, name, flags, section,\ 8098 value, string, cp, coll, hashp)\ 8099 ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\ 8100 (info, abfd, name, flags, section, value, string, cp, coll, hashp)) 8101 8102 #define bfd_coff_link_output_has_begun(a,p) \ 8103 ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a, p)) 8104 #define bfd_coff_final_link_postscript(a,p) \ 8105 ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a, p)) 8106 8107 3.2.2.7 Writing relocations 8108 ........................... 8109 8110 To write relocations, the back end steps though the canonical 8111 relocation table and create an `internal_reloc'. The symbol index to 8112 use is removed from the `offset' field in the symbol table supplied. 8113 The address comes directly from the sum of the section base address and 8114 the relocation offset; the type is dug directly from the howto field. 8115 Then the `internal_reloc' is swapped into the shape of an 8116 `external_reloc' and written out to disk. 8117 8118 3.2.2.8 Reading linenumbers 8119 ........................... 8120 8121 Creating the linenumber table is done by reading in the entire coff 8122 linenumber table, and creating another table for internal use. 8123 8124 A coff linenumber table is structured so that each function is 8125 marked as having a line number of 0. Each line within the function is 8126 an offset from the first line in the function. The base of the line 8127 number information for the table is stored in the symbol associated 8128 with the function. 8129 8130 Note: The PE format uses line number 0 for a flag indicating a new 8131 source file. 8132 8133 The information is copied from the external to the internal table, 8134 and each symbol which marks a function is marked by pointing its... 8135 8136 How does this work ? 8137 8138 3.2.2.9 Reading relocations 8139 ........................... 8140 8141 Coff relocations are easily transformed into the internal BFD form 8142 (`arelent'). 8143 8144 Reading a coff relocation table is done in the following stages: 8145 8146 * Read the entire coff relocation table into memory. 8147 8148 * Process each relocation in turn; first swap it from the external 8149 to the internal form. 8150 8151 * Turn the symbol referenced in the relocation's symbol index into a 8152 pointer into the canonical symbol table. This table is the same 8153 as the one returned by a call to `bfd_canonicalize_symtab'. The 8154 back end will call that routine and save the result if a 8155 canonicalization hasn't been done. 8156 8157 * The reloc index is turned into a pointer to a howto structure, in 8158 a back end specific way. For instance, the 386 and 960 use the 8159 `r_type' to directly produce an index into a howto table vector; 8160 the 88k subtracts a number from the `r_type' field and creates an 8161 addend field. 8162 8163 8164 File: bfd.info, Node: elf, Next: mmo, Prev: coff, Up: BFD back ends 8165 8166 3.3 ELF backends 8167 ================ 8168 8169 BFD support for ELF formats is being worked on. Currently, the best 8170 supported back ends are for sparc and i386 (running svr4 or Solaris 2). 8171 8172 Documentation of the internals of the support code still needs to be 8173 written. The code is changing quickly enough that we haven't bothered 8174 yet. 8175 8176 3.3.0.1 `bfd_elf_find_section' 8177 .............................. 8178 8179 *Synopsis* 8180 struct elf_internal_shdr *bfd_elf_find_section (bfd *abfd, char *name); 8181 *Description* 8182 Helper functions for GDB to locate the string tables. Since BFD hides 8183 string tables from callers, GDB needs to use an internal hook to find 8184 them. Sun's .stabstr, in particular, isn't even pointed to by the 8185 .stab section, so ordinary mechanisms wouldn't work to find it, even if 8186 we had some. 8187 8188 8189 File: bfd.info, Node: mmo, Prev: elf, Up: BFD back ends 8190 8191 3.4 mmo backend 8192 =============== 8193 8194 The mmo object format is used exclusively together with Professor 8195 Donald E. Knuth's educational 64-bit processor MMIX. The simulator 8196 `mmix' which is available at 8197 `http://www-cs-faculty.stanford.edu/~knuth/programs/mmix.tar.gz' 8198 understands this format. That package also includes a combined 8199 assembler and linker called `mmixal'. The mmo format has no advantages 8200 feature-wise compared to e.g. ELF. It is a simple non-relocatable 8201 object format with no support for archives or debugging information, 8202 except for symbol value information and line numbers (which is not yet 8203 implemented in BFD). See 8204 `http://www-cs-faculty.stanford.edu/~knuth/mmix.html' for more 8205 information about MMIX. The ELF format is used for intermediate object 8206 files in the BFD implementation. 8207 8208 * Menu: 8209 8210 * File layout:: 8211 * Symbol-table:: 8212 * mmo section mapping:: 8213 8214 8215 File: bfd.info, Node: File layout, Next: Symbol-table, Prev: mmo, Up: mmo 8216 8217 3.4.1 File layout 8218 ----------------- 8219 8220 The mmo file contents is not partitioned into named sections as with 8221 e.g. ELF. Memory areas is formed by specifying the location of the 8222 data that follows. Only the memory area `0x0000...00' to `0x01ff...ff' 8223 is executable, so it is used for code (and constants) and the area 8224 `0x2000...00' to `0x20ff...ff' is used for writable data. *Note mmo 8225 section mapping::. 8226 8227 There is provision for specifying "special data" of 65536 different 8228 types. We use type 80 (decimal), arbitrarily chosen the same as the 8229 ELF `e_machine' number for MMIX, filling it with section information 8230 normally found in ELF objects. *Note mmo section mapping::. 8231 8232 Contents is entered as 32-bit words, xor:ed over previous contents, 8233 always zero-initialized. A word that starts with the byte `0x98' forms 8234 a command called a `lopcode', where the next byte distinguished between 8235 the thirteen lopcodes. The two remaining bytes, called the `Y' and `Z' 8236 fields, or the `YZ' field (a 16-bit big-endian number), are used for 8237 various purposes different for each lopcode. As documented in 8238 `http://www-cs-faculty.stanford.edu/~knuth/mmixal-intro.ps.gz', the 8239 lopcodes are: 8240 8241 `lop_quote' 8242 0x98000001. The next word is contents, regardless of whether it 8243 starts with 0x98 or not. 8244 8245 `lop_loc' 8246 0x9801YYZZ, where `Z' is 1 or 2. This is a location directive, 8247 setting the location for the next data to the next 32-bit word 8248 (for Z = 1) or 64-bit word (for Z = 2), plus Y * 2^56. Normally 8249 `Y' is 0 for the text segment and 2 for the data segment. 8250 8251 `lop_skip' 8252 0x9802YYZZ. Increase the current location by `YZ' bytes. 8253 8254 `lop_fixo' 8255 0x9803YYZZ, where `Z' is 1 or 2. Store the current location as 64 8256 bits into the location pointed to by the next 32-bit (Z = 1) or 8257 64-bit (Z = 2) word, plus Y * 2^56. 8258 8259 `lop_fixr' 8260 0x9804YYZZ. `YZ' is stored into the current location plus 2 - 4 * 8261 YZ. 8262 8263 `lop_fixrx' 8264 0x980500ZZ. `Z' is 16 or 24. A value `L' derived from the 8265 following 32-bit word are used in a manner similar to `YZ' in 8266 lop_fixr: it is xor:ed into the current location minus 4 * L. The 8267 first byte of the word is 0 or 1. If it is 1, then L = (LOWEST 24 8268 BITS OF WORD) - 2^Z, if 0, then L = (LOWEST 24 BITS OF WORD). 8269 8270 `lop_file' 8271 0x9806YYZZ. `Y' is the file number, `Z' is count of 32-bit words. 8272 Set the file number to `Y' and the line counter to 0. The next Z 8273 * 4 bytes contain the file name, padded with zeros if the count is 8274 not a multiple of four. The same `Y' may occur multiple times, 8275 but `Z' must be 0 for all but the first occurrence. 8276 8277 `lop_line' 8278 0x9807YYZZ. `YZ' is the line number. Together with lop_file, it 8279 forms the source location for the next 32-bit word. Note that for 8280 each non-lopcode 32-bit word, line numbers are assumed incremented 8281 by one. 8282 8283 `lop_spec' 8284 0x9808YYZZ. `YZ' is the type number. Data until the next lopcode 8285 other than lop_quote forms special data of type `YZ'. *Note mmo 8286 section mapping::. 8287 8288 Other types than 80, (or type 80 with a content that does not 8289 parse) is stored in sections named `.MMIX.spec_data.N' where N is 8290 the `YZ'-type. The flags for such a sections say not to allocate 8291 or load the data. The vma is 0. Contents of multiple occurrences 8292 of special data N is concatenated to the data of the previous 8293 lop_spec Ns. The location in data or code at which the lop_spec 8294 occurred is lost. 8295 8296 `lop_pre' 8297 0x980901ZZ. The first lopcode in a file. The `Z' field forms the 8298 length of header information in 32-bit words, where the first word 8299 tells the time in seconds since `00:00:00 GMT Jan 1 1970'. 8300 8301 `lop_post' 8302 0x980a00ZZ. Z > 32. This lopcode follows after all 8303 content-generating lopcodes in a program. The `Z' field denotes 8304 the value of `rG' at the beginning of the program. The following 8305 256 - Z big-endian 64-bit words are loaded into global registers 8306 `$G' ... `$255'. 8307 8308 `lop_stab' 8309 0x980b0000. The next-to-last lopcode in a program. Must follow 8310 immediately after the lop_post lopcode and its data. After this 8311 lopcode follows all symbols in a compressed format (*note 8312 Symbol-table::). 8313 8314 `lop_end' 8315 0x980cYYZZ. The last lopcode in a program. It must follow the 8316 lop_stab lopcode and its data. The `YZ' field contains the number 8317 of 32-bit words of symbol table information after the preceding 8318 lop_stab lopcode. 8319 8320 Note that the lopcode "fixups"; `lop_fixr', `lop_fixrx' and 8321 `lop_fixo' are not generated by BFD, but are handled. They are 8322 generated by `mmixal'. 8323 8324 This trivial one-label, one-instruction file: 8325 8326 :Main TRAP 1,2,3 8327 8328 can be represented this way in mmo: 8329 8330 0x98090101 - lop_pre, one 32-bit word with timestamp. 8331 <timestamp> 8332 0x98010002 - lop_loc, text segment, using a 64-bit address. 8333 Note that mmixal does not emit this for the file above. 8334 0x00000000 - Address, high 32 bits. 8335 0x00000000 - Address, low 32 bits. 8336 0x98060002 - lop_file, 2 32-bit words for file-name. 8337 0x74657374 - "test" 8338 0x2e730000 - ".s\0\0" 8339 0x98070001 - lop_line, line 1. 8340 0x00010203 - TRAP 1,2,3 8341 0x980a00ff - lop_post, setting $255 to 0. 8342 0x00000000 8343 0x00000000 8344 0x980b0000 - lop_stab for ":Main" = 0, serial 1. 8345 0x203a4040 *Note Symbol-table::. 8346 0x10404020 8347 0x4d206120 8348 0x69016e00 8349 0x81000000 8350 0x980c0005 - lop_end; symbol table contained five 32-bit words. 8351 8352 8353 File: bfd.info, Node: Symbol-table, Next: mmo section mapping, Prev: File layout, Up: mmo 8354 8355 3.4.2 Symbol table format 8356 ------------------------- 8357 8358 From mmixal.w (or really, the generated mmixal.tex) in 8359 `http://www-cs-faculty.stanford.edu/~knuth/programs/mmix.tar.gz'): 8360 "Symbols are stored and retrieved by means of a `ternary search trie', 8361 following ideas of Bentley and Sedgewick. (See ACM-SIAM Symp. on 8362 Discrete Algorithms `8' (1997), 360-369; R.Sedgewick, `Algorithms in C' 8363 (Reading, Mass. Addison-Wesley, 1998), `15.4'.) Each trie node stores 8364 a character, and there are branches to subtries for the cases where a 8365 given character is less than, equal to, or greater than the character 8366 in the trie. There also is a pointer to a symbol table entry if a 8367 symbol ends at the current node." 8368 8369 So it's a tree encoded as a stream of bytes. The stream of bytes 8370 acts on a single virtual global symbol, adding and removing characters 8371 and signalling complete symbol points. Here, we read the stream and 8372 create symbols at the completion points. 8373 8374 First, there's a control byte `m'. If any of the listed bits in `m' 8375 is nonzero, we execute what stands at the right, in the listed order: 8376 8377 (MMO3_LEFT) 8378 0x40 - Traverse left trie. 8379 (Read a new command byte and recurse.) 8380 8381 (MMO3_SYMBITS) 8382 0x2f - Read the next byte as a character and store it in the 8383 current character position; increment character position. 8384 Test the bits of `m': 8385 8386 (MMO3_WCHAR) 8387 0x80 - The character is 16-bit (so read another byte, 8388 merge into current character. 8389 8390 (MMO3_TYPEBITS) 8391 0xf - We have a complete symbol; parse the type, value 8392 and serial number and do what should be done 8393 with a symbol. The type and length information 8394 is in j = (m & 0xf). 8395 8396 (MMO3_REGQUAL_BITS) 8397 j == 0xf: A register variable. The following 8398 byte tells which register. 8399 j <= 8: An absolute symbol. Read j bytes as the 8400 big-endian number the symbol equals. 8401 A j = 2 with two zero bytes denotes an 8402 unknown symbol. 8403 j > 8: As with j <= 8, but add (0x20 << 56) 8404 to the value in the following j - 8 8405 bytes. 8406 8407 Then comes the serial number, as a variant of 8408 uleb128, but better named ubeb128: 8409 Read bytes and shift the previous value left 7 8410 (multiply by 128). Add in the new byte, repeat 8411 until a byte has bit 7 set. The serial number 8412 is the computed value minus 128. 8413 8414 (MMO3_MIDDLE) 8415 0x20 - Traverse middle trie. (Read a new command byte 8416 and recurse.) Decrement character position. 8417 8418 (MMO3_RIGHT) 8419 0x10 - Traverse right trie. (Read a new command byte and 8420 recurse.) 8421 8422 Let's look again at the `lop_stab' for the trivial file (*note File 8423 layout::). 8424 8425 0x980b0000 - lop_stab for ":Main" = 0, serial 1. 8426 0x203a4040 8427 0x10404020 8428 0x4d206120 8429 0x69016e00 8430 0x81000000 8431 8432 This forms the trivial trie (note that the path between ":" and "M" 8433 is redundant): 8434 8435 203a ":" 8436 40 / 8437 40 / 8438 10 \ 8439 40 / 8440 40 / 8441 204d "M" 8442 2061 "a" 8443 2069 "i" 8444 016e "n" is the last character in a full symbol, and 8445 with a value represented in one byte. 8446 00 The value is 0. 8447 81 The serial number is 1. 8448 8449 8450 File: bfd.info, Node: mmo section mapping, Prev: Symbol-table, Up: mmo 8451 8452 3.4.3 mmo section mapping 8453 ------------------------- 8454 8455 The implementation in BFD uses special data type 80 (decimal) to 8456 encapsulate and describe named sections, containing e.g. debug 8457 information. If needed, any datum in the encapsulation will be quoted 8458 using lop_quote. First comes a 32-bit word holding the number of 8459 32-bit words containing the zero-terminated zero-padded segment name. 8460 After the name there's a 32-bit word holding flags describing the 8461 section type. Then comes a 64-bit big-endian word with the section 8462 length (in bytes), then another with the section start address. 8463 Depending on the type of section, the contents might follow, 8464 zero-padded to 32-bit boundary. For a loadable section (such as data 8465 or code), the contents might follow at some later point, not 8466 necessarily immediately, as a lop_loc with the same start address as in 8467 the section description, followed by the contents. This in effect 8468 forms a descriptor that must be emitted before the actual contents. 8469 Sections described this way must not overlap. 8470 8471 For areas that don't have such descriptors, synthetic sections are 8472 formed by BFD. Consecutive contents in the two memory areas 8473 `0x0000...00' to `0x01ff...ff' and `0x2000...00' to `0x20ff...ff' are 8474 entered in sections named `.text' and `.data' respectively. If an area 8475 is not otherwise described, but would together with a neighboring lower 8476 area be less than `0x40000000' bytes long, it is joined with the lower 8477 area and the gap is zero-filled. For other cases, a new section is 8478 formed, named `.MMIX.sec.N'. Here, N is a number, a running count 8479 through the mmo file, starting at 0. 8480 8481 A loadable section specified as: 8482 8483 .section secname,"ax" 8484 TETRA 1,2,3,4,-1,-2009 8485 BYTE 80 8486 8487 and linked to address `0x4', is represented by the sequence: 8488 8489 0x98080050 - lop_spec 80 8490 0x00000002 - two 32-bit words for the section name 8491 0x7365636e - "secn" 8492 0x616d6500 - "ame\0" 8493 0x00000033 - flags CODE, READONLY, LOAD, ALLOC 8494 0x00000000 - high 32 bits of section length 8495 0x0000001c - section length is 28 bytes; 6 * 4 + 1 + alignment to 32 bits 8496 0x00000000 - high 32 bits of section address 8497 0x00000004 - section address is 4 8498 0x98010002 - 64 bits with address of following data 8499 0x00000000 - high 32 bits of address 8500 0x00000004 - low 32 bits: data starts at address 4 8501 0x00000001 - 1 8502 0x00000002 - 2 8503 0x00000003 - 3 8504 0x00000004 - 4 8505 0xffffffff - -1 8506 0xfffff827 - -2009 8507 0x50000000 - 80 as a byte, padded with zeros. 8508 8509 Note that the lop_spec wrapping does not include the section 8510 contents. Compare this to a non-loaded section specified as: 8511 8512 .section thirdsec 8513 TETRA 200001,100002 8514 BYTE 38,40 8515 8516 This, when linked to address `0x200000000000001c', is represented by: 8517 8518 0x98080050 - lop_spec 80 8519 0x00000002 - two 32-bit words for the section name 8520 0x7365636e - "thir" 8521 0x616d6500 - "dsec" 8522 0x00000010 - flag READONLY 8523 0x00000000 - high 32 bits of section length 8524 0x0000000c - section length is 12 bytes; 2 * 4 + 2 + alignment to 32 bits 8525 0x20000000 - high 32 bits of address 8526 0x0000001c - low 32 bits of address 0x200000000000001c 8527 0x00030d41 - 200001 8528 0x000186a2 - 100002 8529 0x26280000 - 38, 40 as bytes, padded with zeros 8530 8531 For the latter example, the section contents must not be loaded in 8532 memory, and is therefore specified as part of the special data. The 8533 address is usually unimportant but might provide information for e.g. 8534 the DWARF 2 debugging format. 8535 8536 8537 File: bfd.info, Node: GNU Free Documentation License, Next: Index, Prev: BFD back ends, Up: Top 8538 8539 Appendix A GNU Free Documentation License 8540 ***************************************** 8541 8542 Version 1.1, March 2000 8543 8544 Copyright (C) 2000, 2003 Free Software Foundation, Inc. 8545 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 8546 8547 Everyone is permitted to copy and distribute verbatim copies 8548 of this license document, but changing it is not allowed. 8549 8550 8551 0. PREAMBLE 8552 8553 The purpose of this License is to make a manual, textbook, or other 8554 written document "free" in the sense of freedom: to assure everyone 8555 the effective freedom to copy and redistribute it, with or without 8556 modifying it, either commercially or noncommercially. Secondarily, 8557 this License preserves for the author and publisher a way to get 8558 credit for their work, while not being considered responsible for 8559 modifications made by others. 8560 8561 This License is a kind of "copyleft", which means that derivative 8562 works of the document must themselves be free in the same sense. 8563 It complements the GNU General Public License, which is a copyleft 8564 license designed for free software. 8565 8566 We have designed this License in order to use it for manuals for 8567 free software, because free software needs free documentation: a 8568 free program should come with manuals providing the same freedoms 8569 that the software does. But this License is not limited to 8570 software manuals; it can be used for any textual work, regardless 8571 of subject matter or whether it is published as a printed book. 8572 We recommend this License principally for works whose purpose is 8573 instruction or reference. 8574 8575 8576 1. APPLICABILITY AND DEFINITIONS 8577 8578 This License applies to any manual or other work that contains a 8579 notice placed by the copyright holder saying it can be distributed 8580 under the terms of this License. The "Document", below, refers to 8581 any such manual or work. Any member of the public is a licensee, 8582 and is addressed as "you." 8583 8584 A "Modified Version" of the Document means any work containing the 8585 Document or a portion of it, either copied verbatim, or with 8586 modifications and/or translated into another language. 8587 8588 A "Secondary Section" is a named appendix or a front-matter 8589 section of the Document that deals exclusively with the 8590 relationship of the publishers or authors of the Document to the 8591 Document's overall subject (or to related matters) and contains 8592 nothing that could fall directly within that overall subject. 8593 (For example, if the Document is in part a textbook of 8594 mathematics, a Secondary Section may not explain any mathematics.) 8595 The relationship could be a matter of historical connection with 8596 the subject or with related matters, or of legal, commercial, 8597 philosophical, ethical or political position regarding them. 8598 8599 The "Invariant Sections" are certain Secondary Sections whose 8600 titles are designated, as being those of Invariant Sections, in 8601 the notice that says that the Document is released under this 8602 License. 8603 8604 The "Cover Texts" are certain short passages of text that are 8605 listed, as Front-Cover Texts or Back-Cover Texts, in the notice 8606 that says that the Document is released under this License. 8607 8608 A "Transparent" copy of the Document means a machine-readable copy, 8609 represented in a format whose specification is available to the 8610 general public, whose contents can be viewed and edited directly 8611 and straightforwardly with generic text editors or (for images 8612 composed of pixels) generic paint programs or (for drawings) some 8613 widely available drawing editor, and that is suitable for input to 8614 text formatters or for automatic translation to a variety of 8615 formats suitable for input to text formatters. A copy made in an 8616 otherwise Transparent file format whose markup has been designed 8617 to thwart or discourage subsequent modification by readers is not 8618 Transparent. A copy that is not "Transparent" is called "Opaque." 8619 8620 Examples of suitable formats for Transparent copies include plain 8621 ASCII without markup, Texinfo input format, LaTeX input format, 8622 SGML or XML using a publicly available DTD, and 8623 standard-conforming simple HTML designed for human modification. 8624 Opaque formats include PostScript, PDF, proprietary formats that 8625 can be read and edited only by proprietary word processors, SGML 8626 or XML for which the DTD and/or processing tools are not generally 8627 available, and the machine-generated HTML produced by some word 8628 processors for output purposes only. 8629 8630 The "Title Page" means, for a printed book, the title page itself, 8631 plus such following pages as are needed to hold, legibly, the 8632 material this License requires to appear in the title page. For 8633 works in formats which do not have any title page as such, "Title 8634 Page" means the text near the most prominent appearance of the 8635 work's title, preceding the beginning of the body of the text. 8636 8637 2. VERBATIM COPYING 8638 8639 You may copy and distribute the Document in any medium, either 8640 commercially or noncommercially, provided that this License, the 8641 copyright notices, and the license notice saying this License 8642 applies to the Document are reproduced in all copies, and that you 8643 add no other conditions whatsoever to those of this License. You 8644 may not use technical measures to obstruct or control the reading 8645 or further copying of the copies you make or distribute. However, 8646 you may accept compensation in exchange for copies. If you 8647 distribute a large enough number of copies you must also follow 8648 the conditions in section 3. 8649 8650 You may also lend copies, under the same conditions stated above, 8651 and you may publicly display copies. 8652 8653 3. COPYING IN QUANTITY 8654 8655 If you publish printed copies of the Document numbering more than 8656 100, and the Document's license notice requires Cover Texts, you 8657 must enclose the copies in covers that carry, clearly and legibly, 8658 all these Cover Texts: Front-Cover Texts on the front cover, and 8659 Back-Cover Texts on the back cover. Both covers must also clearly 8660 and legibly identify you as the publisher of these copies. The 8661 front cover must present the full title with all words of the 8662 title equally prominent and visible. You may add other material 8663 on the covers in addition. Copying with changes limited to the 8664 covers, as long as they preserve the title of the Document and 8665 satisfy these conditions, can be treated as verbatim copying in 8666 other respects. 8667 8668 If the required texts for either cover are too voluminous to fit 8669 legibly, you should put the first ones listed (as many as fit 8670 reasonably) on the actual cover, and continue the rest onto 8671 adjacent pages. 8672 8673 If you publish or distribute Opaque copies of the Document 8674 numbering more than 100, you must either include a 8675 machine-readable Transparent copy along with each Opaque copy, or 8676 state in or with each Opaque copy a publicly-accessible 8677 computer-network location containing a complete Transparent copy 8678 of the Document, free of added material, which the general 8679 network-using public has access to download anonymously at no 8680 charge using public-standard network protocols. If you use the 8681 latter option, you must take reasonably prudent steps, when you 8682 begin distribution of Opaque copies in quantity, to ensure that 8683 this Transparent copy will remain thus accessible at the stated 8684 location until at least one year after the last time you 8685 distribute an Opaque copy (directly or through your agents or 8686 retailers) of that edition to the public. 8687 8688 It is requested, but not required, that you contact the authors of 8689 the Document well before redistributing any large number of 8690 copies, to give them a chance to provide you with an updated 8691 version of the Document. 8692 8693 4. MODIFICATIONS 8694 8695 You may copy and distribute a Modified Version of the Document 8696 under the conditions of sections 2 and 3 above, provided that you 8697 release the Modified Version under precisely this License, with 8698 the Modified Version filling the role of the Document, thus 8699 licensing distribution and modification of the Modified Version to 8700 whoever possesses a copy of it. In addition, you must do these 8701 things in the Modified Version: 8702 8703 A. Use in the Title Page (and on the covers, if any) a title 8704 distinct from that of the Document, and from those of previous 8705 versions (which should, if there were any, be listed in the 8706 History section of the Document). You may use the same title 8707 as a previous version if the original publisher of that version 8708 gives permission. 8709 B. List on the Title Page, as authors, one or more persons or 8710 entities responsible for authorship of the modifications in the 8711 Modified Version, together with at least five of the principal 8712 authors of the Document (all of its principal authors, if it 8713 has less than five). 8714 C. State on the Title page the name of the publisher of the 8715 Modified Version, as the publisher. 8716 D. Preserve all the copyright notices of the Document. 8717 E. Add an appropriate copyright notice for your modifications 8718 adjacent to the other copyright notices. 8719 F. Include, immediately after the copyright notices, a license 8720 notice giving the public permission to use the Modified Version 8721 under the terms of this License, in the form shown in the 8722 Addendum below. 8723 G. Preserve in that license notice the full lists of Invariant 8724 Sections and required Cover Texts given in the Document's 8725 license notice. 8726 H. Include an unaltered copy of this License. 8727 I. Preserve the section entitled "History", and its title, and add 8728 to it an item stating at least the title, year, new authors, and 8729 publisher of the Modified Version as given on the Title Page. 8730 If there is no section entitled "History" in the Document, 8731 create one stating the title, year, authors, and publisher of 8732 the Document as given on its Title Page, then add an item 8733 describing the Modified Version as stated in the previous 8734 sentence. 8735 J. Preserve the network location, if any, given in the Document for 8736 public access to a Transparent copy of the Document, and 8737 likewise the network locations given in the Document for 8738 previous versions it was based on. These may be placed in the 8739 "History" section. You may omit a network location for a work 8740 that was published at least four years before the Document 8741 itself, or if the original publisher of the version it refers 8742 to gives permission. 8743 K. In any section entitled "Acknowledgements" or "Dedications", 8744 preserve the section's title, and preserve in the section all the 8745 substance and tone of each of the contributor acknowledgements 8746 and/or dedications given therein. 8747 L. Preserve all the Invariant Sections of the Document, 8748 unaltered in their text and in their titles. Section numbers 8749 or the equivalent are not considered part of the section titles. 8750 M. Delete any section entitled "Endorsements." Such a section 8751 may not be included in the Modified Version. 8752 N. Do not retitle any existing section as "Endorsements" or to 8753 conflict in title with any Invariant Section. 8754 8755 If the Modified Version includes new front-matter sections or 8756 appendices that qualify as Secondary Sections and contain no 8757 material copied from the Document, you may at your option 8758 designate some or all of these sections as invariant. To do this, 8759 add their titles to the list of Invariant Sections in the Modified 8760 Version's license notice. These titles must be distinct from any 8761 other section titles. 8762 8763 You may add a section entitled "Endorsements", provided it contains 8764 nothing but endorsements of your Modified Version by various 8765 parties-for example, statements of peer review or that the text has 8766 been approved by an organization as the authoritative definition 8767 of a standard. 8768 8769 You may add a passage of up to five words as a Front-Cover Text, 8770 and a passage of up to 25 words as a Back-Cover Text, to the end 8771 of the list of Cover Texts in the Modified Version. Only one 8772 passage of Front-Cover Text and one of Back-Cover Text may be 8773 added by (or through arrangements made by) any one entity. If the 8774 Document already includes a cover text for the same cover, 8775 previously added by you or by arrangement made by the same entity 8776 you are acting on behalf of, you may not add another; but you may 8777 replace the old one, on explicit permission from the previous 8778 publisher that added the old one. 8779 8780 The author(s) and publisher(s) of the Document do not by this 8781 License give permission to use their names for publicity for or to 8782 assert or imply endorsement of any Modified Version. 8783 8784 5. COMBINING DOCUMENTS 8785 8786 You may combine the Document with other documents released under 8787 this License, under the terms defined in section 4 above for 8788 modified versions, provided that you include in the combination 8789 all of the Invariant Sections of all of the original documents, 8790 unmodified, and list them all as Invariant Sections of your 8791 combined work in its license notice. 8792 8793 The combined work need only contain one copy of this License, and 8794 multiple identical Invariant Sections may be replaced with a single 8795 copy. If there are multiple Invariant Sections with the same name 8796 but different contents, make the title of each such section unique 8797 by adding at the end of it, in parentheses, the name of the 8798 original author or publisher of that section if known, or else a 8799 unique number. Make the same adjustment to the section titles in 8800 the list of Invariant Sections in the license notice of the 8801 combined work. 8802 8803 In the combination, you must combine any sections entitled 8804 "History" in the various original documents, forming one section 8805 entitled "History"; likewise combine any sections entitled 8806 "Acknowledgements", and any sections entitled "Dedications." You 8807 must delete all sections entitled "Endorsements." 8808 8809 6. COLLECTIONS OF DOCUMENTS 8810 8811 You may make a collection consisting of the Document and other 8812 documents released under this License, and replace the individual 8813 copies of this License in the various documents with a single copy 8814 that is included in the collection, provided that you follow the 8815 rules of this License for verbatim copying of each of the 8816 documents in all other respects. 8817 8818 You may extract a single document from such a collection, and 8819 distribute it individually under this License, provided you insert 8820 a copy of this License into the extracted document, and follow 8821 this License in all other respects regarding verbatim copying of 8822 that document. 8823 8824 7. AGGREGATION WITH INDEPENDENT WORKS 8825 8826 A compilation of the Document or its derivatives with other 8827 separate and independent documents or works, in or on a volume of 8828 a storage or distribution medium, does not as a whole count as a 8829 Modified Version of the Document, provided no compilation 8830 copyright is claimed for the compilation. Such a compilation is 8831 called an "aggregate", and this License does not apply to the 8832 other self-contained works thus compiled with the Document, on 8833 account of their being thus compiled, if they are not themselves 8834 derivative works of the Document. 8835 8836 If the Cover Text requirement of section 3 is applicable to these 8837 copies of the Document, then if the Document is less than one 8838 quarter of the entire aggregate, the Document's Cover Texts may be 8839 placed on covers that surround only the Document within the 8840 aggregate. Otherwise they must appear on covers around the whole 8841 aggregate. 8842 8843 8. TRANSLATION 8844 8845 Translation is considered a kind of modification, so you may 8846 distribute translations of the Document under the terms of section 8847 4. Replacing Invariant Sections with translations requires special 8848 permission from their copyright holders, but you may include 8849 translations of some or all Invariant Sections in addition to the 8850 original versions of these Invariant Sections. You may include a 8851 translation of this License provided that you also include the 8852 original English version of this License. In case of a 8853 disagreement between the translation and the original English 8854 version of this License, the original English version will prevail. 8855 8856 9. TERMINATION 8857 8858 You may not copy, modify, sublicense, or distribute the Document 8859 except as expressly provided for under this License. Any other 8860 attempt to copy, modify, sublicense or distribute the Document is 8861 void, and will automatically terminate your rights under this 8862 License. However, parties who have received copies, or rights, 8863 from you under this License will not have their licenses 8864 terminated so long as such parties remain in full compliance. 8865 8866 10. FUTURE REVISIONS OF THIS LICENSE 8867 8868 The Free Software Foundation may publish new, revised versions of 8869 the GNU Free Documentation License from time to time. Such new 8870 versions will be similar in spirit to the present version, but may 8871 differ in detail to address new problems or concerns. See 8872 http://www.gnu.org/copyleft/. 8873 8874 Each version of the License is given a distinguishing version 8875 number. If the Document specifies that a particular numbered 8876 version of this License "or any later version" applies to it, you 8877 have the option of following the terms and conditions either of 8878 that specified version or of any later version that has been 8879 published (not as a draft) by the Free Software Foundation. If 8880 the Document does not specify a version number of this License, 8881 you may choose any version ever published (not as a draft) by the 8882 Free Software Foundation. 8883 8884 8885 ADDENDUM: How to use this License for your documents 8886 ==================================================== 8887 8888 To use this License in a document you have written, include a copy of 8889 the License in the document and put the following copyright and license 8890 notices just after the title page: 8891 8892 Copyright (C) YEAR YOUR NAME. 8893 Permission is granted to copy, distribute and/or modify this document 8894 under the terms of the GNU Free Documentation License, Version 1.1 8895 or any later version published by the Free Software Foundation; 8896 with the Invariant Sections being LIST THEIR TITLES, with the 8897 Front-Cover Texts being LIST, and with the Back-Cover Texts being LIST. 8898 A copy of the license is included in the section entitled "GNU 8899 Free Documentation License." 8900 8901 If you have no Invariant Sections, write "with no Invariant Sections" 8902 instead of saying which ones are invariant. If you have no Front-Cover 8903 Texts, write "no Front-Cover Texts" instead of "Front-Cover Texts being 8904 LIST"; likewise for Back-Cover Texts. 8905 8906 If your document contains nontrivial examples of program code, we 8907 recommend releasing these examples in parallel under your choice of 8908 free software license, such as the GNU General Public License, to 8909 permit their use in free software. 8910 8911 8912 File: bfd.info, Node: Index, Prev: GNU Free Documentation License, Up: Top 8913 8914 Index 8915 ***** 8916 8917 [index] 8918 * Menu: 8919 8920 * _bfd_final_link_relocate: Relocating the section contents. 8921 (line 22) 8922 * _bfd_generic_link_add_archive_symbols: Adding symbols from an archive. 8923 (line 12) 8924 * _bfd_generic_link_add_one_symbol: Adding symbols from an object file. 8925 (line 19) 8926 * _bfd_generic_make_empty_symbol: symbol handling functions. 8927 (line 92) 8928 * _bfd_link_add_symbols in target vector: Adding Symbols to the Hash Table. 8929 (line 6) 8930 * _bfd_link_final_link in target vector: Performing the Final Link. 8931 (line 6) 8932 * _bfd_link_hash_table_create in target vector: Creating a Linker Hash Table. 8933 (line 6) 8934 * _bfd_relocate_contents: Relocating the section contents. 8935 (line 22) 8936 * aout_SIZE_machine_type: aout. (line 147) 8937 * aout_SIZE_mkobject: aout. (line 139) 8938 * aout_SIZE_new_section_hook: aout. (line 177) 8939 * aout_SIZE_set_arch_mach: aout. (line 164) 8940 * aout_SIZE_some_aout_object_p: aout. (line 125) 8941 * aout_SIZE_swap_exec_header_in: aout. (line 101) 8942 * aout_SIZE_swap_exec_header_out: aout. (line 113) 8943 * arelent_chain: typedef arelent. (line 339) 8944 * BFD: Overview. (line 6) 8945 * BFD canonical format: Canonical format. (line 11) 8946 * bfd_alloc: Opening and Closing. 8947 (line 203) 8948 * bfd_alloc2: Opening and Closing. 8949 (line 212) 8950 * bfd_alt_mach_code: BFD front end. (line 599) 8951 * bfd_arch_bits_per_address: Architectures. (line 476) 8952 * bfd_arch_bits_per_byte: Architectures. (line 468) 8953 * bfd_arch_get_compatible: Architectures. (line 411) 8954 * bfd_arch_list: Architectures. (line 402) 8955 * bfd_arch_mach_octets_per_byte: Architectures. (line 545) 8956 * BFD_ARELOC_BFIN_ADD: howto manager. (line 887) 8957 * BFD_ARELOC_BFIN_ADDR: howto manager. (line 938) 8958 * BFD_ARELOC_BFIN_AND: howto manager. (line 908) 8959 * BFD_ARELOC_BFIN_COMP: howto manager. (line 929) 8960 * BFD_ARELOC_BFIN_CONST: howto manager. (line 884) 8961 * BFD_ARELOC_BFIN_DIV: howto manager. (line 896) 8962 * BFD_ARELOC_BFIN_HWPAGE: howto manager. (line 935) 8963 * BFD_ARELOC_BFIN_LAND: howto manager. (line 917) 8964 * BFD_ARELOC_BFIN_LEN: howto manager. (line 923) 8965 * BFD_ARELOC_BFIN_LOR: howto manager. (line 920) 8966 * BFD_ARELOC_BFIN_LSHIFT: howto manager. (line 902) 8967 * BFD_ARELOC_BFIN_MOD: howto manager. (line 899) 8968 * BFD_ARELOC_BFIN_MULT: howto manager. (line 893) 8969 * BFD_ARELOC_BFIN_NEG: howto manager. (line 926) 8970 * BFD_ARELOC_BFIN_OR: howto manager. (line 911) 8971 * BFD_ARELOC_BFIN_PAGE: howto manager. (line 932) 8972 * BFD_ARELOC_BFIN_PUSH: howto manager. (line 881) 8973 * BFD_ARELOC_BFIN_RSHIFT: howto manager. (line 905) 8974 * BFD_ARELOC_BFIN_SUB: howto manager. (line 890) 8975 * BFD_ARELOC_BFIN_XOR: howto manager. (line 914) 8976 * bfd_cache_close: File Caching. (line 26) 8977 * bfd_cache_close_all: File Caching. (line 39) 8978 * bfd_cache_init: File Caching. (line 18) 8979 * bfd_calc_gnu_debuglink_crc32: Opening and Closing. 8980 (line 239) 8981 * bfd_canonicalize_reloc: BFD front end. (line 318) 8982 * bfd_canonicalize_symtab: symbol handling functions. 8983 (line 50) 8984 * bfd_check_format: Formats. (line 21) 8985 * bfd_check_format_matches: Formats. (line 52) 8986 * bfd_check_overflow: typedef arelent. (line 351) 8987 * bfd_close: Opening and Closing. 8988 (line 128) 8989 * bfd_close_all_done: Opening and Closing. 8990 (line 146) 8991 * bfd_coff_backend_data: coff. (line 246) 8992 * bfd_copy_private_bfd_data: BFD front end. (line 457) 8993 * bfd_copy_private_header_data: BFD front end. (line 439) 8994 * bfd_copy_private_section_data: section prototypes. (line 255) 8995 * bfd_copy_private_symbol_data: symbol handling functions. 8996 (line 140) 8997 * bfd_core_file_failing_command: Core Files. (line 12) 8998 * bfd_core_file_failing_signal: Core Files. (line 21) 8999 * bfd_create: Opening and Closing. 9000 (line 165) 9001 * bfd_create_gnu_debuglink_section: Opening and Closing. 9002 (line 305) 9003 * bfd_decode_symclass: symbol handling functions. 9004 (line 111) 9005 * bfd_default_arch_struct: Architectures. (line 423) 9006 * bfd_default_compatible: Architectures. (line 485) 9007 * bfd_default_reloc_type_lookup: howto manager. (line 1931) 9008 * bfd_default_scan: Architectures. (line 494) 9009 * bfd_default_set_arch_mach: Architectures. (line 441) 9010 * bfd_elf_find_section: elf. (line 13) 9011 * bfd_errmsg: BFD front end. (line 243) 9012 * bfd_fdopenr: Opening and Closing. 9013 (line 46) 9014 * bfd_fill_in_gnu_debuglink_section: Opening and Closing. 9015 (line 319) 9016 * bfd_find_target: bfd_target. (line 434) 9017 * bfd_follow_gnu_debuglink: Opening and Closing. 9018 (line 284) 9019 * bfd_fopen: Opening and Closing. 9020 (line 9) 9021 * bfd_format_string: Formats. (line 79) 9022 * bfd_generic_discard_group: section prototypes. (line 281) 9023 * bfd_generic_gc_sections: howto manager. (line 1962) 9024 * bfd_generic_get_relocated_section_contents: howto manager. (line 1982) 9025 * bfd_generic_is_group_section: section prototypes. (line 273) 9026 * bfd_generic_merge_sections: howto manager. (line 1972) 9027 * bfd_generic_relax_section: howto manager. (line 1949) 9028 * bfd_get_arch: Architectures. (line 452) 9029 * bfd_get_arch_info: Architectures. (line 504) 9030 * bfd_get_arch_size: BFD front end. (line 362) 9031 * bfd_get_error: BFD front end. (line 226) 9032 * bfd_get_error_handler: BFD front end. (line 294) 9033 * bfd_get_gp_size: BFD front end. (line 403) 9034 * bfd_get_mach: Architectures. (line 460) 9035 * bfd_get_mtime: BFD front end. (line 687) 9036 * bfd_get_next_mapent: Archives. (line 52) 9037 * bfd_get_reloc_code_name: howto manager. (line 1940) 9038 * bfd_get_reloc_size: typedef arelent. (line 330) 9039 * bfd_get_reloc_upper_bound: BFD front end. (line 308) 9040 * bfd_get_section_by_name: section prototypes. (line 17) 9041 * bfd_get_section_by_name_if: section prototypes. (line 31) 9042 * bfd_get_section_contents: section prototypes. (line 228) 9043 * bfd_get_sign_extend_vma: BFD front end. (line 375) 9044 * bfd_get_size <1>: BFD front end. (line 696) 9045 * bfd_get_size: Internal. (line 25) 9046 * bfd_get_symtab_upper_bound: symbol handling functions. 9047 (line 6) 9048 * bfd_get_unique_section_name: section prototypes. (line 50) 9049 * bfd_h_put_size: Internal. (line 97) 9050 * bfd_hash_allocate: Creating and Freeing a Hash Table. 9051 (line 17) 9052 * bfd_hash_lookup: Looking Up or Entering a String. 9053 (line 6) 9054 * bfd_hash_newfunc: Creating and Freeing a Hash Table. 9055 (line 12) 9056 * bfd_hash_set_default_size: Creating and Freeing a Hash Table. 9057 (line 25) 9058 * bfd_hash_table_free: Creating and Freeing a Hash Table. 9059 (line 21) 9060 * bfd_hash_table_init: Creating and Freeing a Hash Table. 9061 (line 6) 9062 * bfd_hash_table_init_n: Creating and Freeing a Hash Table. 9063 (line 6) 9064 * bfd_hash_traverse: Traversing a Hash Table. 9065 (line 6) 9066 * bfd_init: Initialization. (line 11) 9067 * bfd_install_relocation: typedef arelent. (line 392) 9068 * bfd_is_local_label: symbol handling functions. 9069 (line 17) 9070 * bfd_is_local_label_name: symbol handling functions. 9071 (line 26) 9072 * bfd_is_target_special_symbol: symbol handling functions. 9073 (line 38) 9074 * bfd_is_undefined_symclass: symbol handling functions. 9075 (line 120) 9076 * bfd_link_split_section: Writing the symbol table. 9077 (line 44) 9078 * bfd_log2: Internal. (line 164) 9079 * bfd_lookup_arch: Architectures. (line 512) 9080 * bfd_make_debug_symbol: symbol handling functions. 9081 (line 102) 9082 * bfd_make_empty_symbol: symbol handling functions. 9083 (line 78) 9084 * bfd_make_readable: Opening and Closing. 9085 (line 189) 9086 * bfd_make_section: section prototypes. (line 129) 9087 * bfd_make_section_anyway: section prototypes. (line 100) 9088 * bfd_make_section_anyway_with_flags: section prototypes. (line 82) 9089 * bfd_make_section_old_way: section prototypes. (line 62) 9090 * bfd_make_section_with_flags: section prototypes. (line 116) 9091 * bfd_make_writable: Opening and Closing. 9092 (line 175) 9093 * bfd_malloc_and_get_section: section prototypes. (line 245) 9094 * bfd_map_over_sections: section prototypes. (line 155) 9095 * bfd_merge_private_bfd_data: BFD front end. (line 473) 9096 * bfd_octets_per_byte: Architectures. (line 535) 9097 * bfd_open_file: File Caching. (line 52) 9098 * bfd_openr: Opening and Closing. 9099 (line 30) 9100 * bfd_openr_iovec: Opening and Closing. 9101 (line 76) 9102 * bfd_openr_next_archived_file: Archives. (line 78) 9103 * bfd_openstreamr: Opening and Closing. 9104 (line 67) 9105 * bfd_openw: Opening and Closing. 9106 (line 116) 9107 * bfd_perform_relocation: typedef arelent. (line 367) 9108 * bfd_perror: BFD front end. (line 252) 9109 * bfd_preserve_finish: BFD front end. (line 647) 9110 * bfd_preserve_restore: BFD front end. (line 637) 9111 * bfd_preserve_save: BFD front end. (line 621) 9112 * bfd_print_symbol_vandf: symbol handling functions. 9113 (line 70) 9114 * bfd_printable_arch_mach: Architectures. (line 523) 9115 * bfd_printable_name: Architectures. (line 383) 9116 * bfd_put_size: Internal. (line 22) 9117 * BFD_RELOC_12_PCREL: howto manager. (line 39) 9118 * BFD_RELOC_14: howto manager. (line 31) 9119 * BFD_RELOC_16: howto manager. (line 30) 9120 * BFD_RELOC_16_BASEREL: howto manager. (line 80) 9121 * BFD_RELOC_16_GOT_PCREL: howto manager. (line 52) 9122 * BFD_RELOC_16_GOTOFF: howto manager. (line 55) 9123 * BFD_RELOC_16_PCREL: howto manager. (line 38) 9124 * BFD_RELOC_16_PCREL_S2: howto manager. (line 92) 9125 * BFD_RELOC_16_PLT_PCREL: howto manager. (line 63) 9126 * BFD_RELOC_16_PLTOFF: howto manager. (line 67) 9127 * BFD_RELOC_16C_ABS20: howto manager. (line 1655) 9128 * BFD_RELOC_16C_ABS20_C: howto manager. (line 1656) 9129 * BFD_RELOC_16C_ABS24: howto manager. (line 1657) 9130 * BFD_RELOC_16C_ABS24_C: howto manager. (line 1658) 9131 * BFD_RELOC_16C_DISP04: howto manager. (line 1635) 9132 * BFD_RELOC_16C_DISP04_C: howto manager. (line 1636) 9133 * BFD_RELOC_16C_DISP08: howto manager. (line 1637) 9134 * BFD_RELOC_16C_DISP08_C: howto manager. (line 1638) 9135 * BFD_RELOC_16C_DISP16: howto manager. (line 1639) 9136 * BFD_RELOC_16C_DISP16_C: howto manager. (line 1640) 9137 * BFD_RELOC_16C_DISP24: howto manager. (line 1641) 9138 * BFD_RELOC_16C_DISP24_C: howto manager. (line 1642) 9139 * BFD_RELOC_16C_DISP24a: howto manager. (line 1643) 9140 * BFD_RELOC_16C_DISP24a_C: howto manager. (line 1644) 9141 * BFD_RELOC_16C_IMM04: howto manager. (line 1659) 9142 * BFD_RELOC_16C_IMM04_C: howto manager. (line 1660) 9143 * BFD_RELOC_16C_IMM16: howto manager. (line 1661) 9144 * BFD_RELOC_16C_IMM16_C: howto manager. (line 1662) 9145 * BFD_RELOC_16C_IMM20: howto manager. (line 1663) 9146 * BFD_RELOC_16C_IMM20_C: howto manager. (line 1664) 9147 * BFD_RELOC_16C_IMM24: howto manager. (line 1665) 9148 * BFD_RELOC_16C_IMM24_C: howto manager. (line 1666) 9149 * BFD_RELOC_16C_IMM32: howto manager. (line 1667) 9150 * BFD_RELOC_16C_IMM32_C: howto manager. (line 1668) 9151 * BFD_RELOC_16C_NUM08: howto manager. (line 1629) 9152 * BFD_RELOC_16C_NUM08_C: howto manager. (line 1630) 9153 * BFD_RELOC_16C_NUM16: howto manager. (line 1631) 9154 * BFD_RELOC_16C_NUM16_C: howto manager. (line 1632) 9155 * BFD_RELOC_16C_NUM32: howto manager. (line 1633) 9156 * BFD_RELOC_16C_NUM32_C: howto manager. (line 1634) 9157 * BFD_RELOC_16C_REG04: howto manager. (line 1645) 9158 * BFD_RELOC_16C_REG04_C: howto manager. (line 1646) 9159 * BFD_RELOC_16C_REG04a: howto manager. (line 1647) 9160 * BFD_RELOC_16C_REG04a_C: howto manager. (line 1648) 9161 * BFD_RELOC_16C_REG14: howto manager. (line 1649) 9162 * BFD_RELOC_16C_REG14_C: howto manager. (line 1650) 9163 * BFD_RELOC_16C_REG16: howto manager. (line 1651) 9164 * BFD_RELOC_16C_REG16_C: howto manager. (line 1652) 9165 * BFD_RELOC_16C_REG20: howto manager. (line 1653) 9166 * BFD_RELOC_16C_REG20_C: howto manager. (line 1654) 9167 * BFD_RELOC_23_PCREL_S2: howto manager. (line 93) 9168 * BFD_RELOC_24: howto manager. (line 29) 9169 * BFD_RELOC_24_PCREL: howto manager. (line 37) 9170 * BFD_RELOC_24_PLT_PCREL: howto manager. (line 62) 9171 * BFD_RELOC_26: howto manager. (line 28) 9172 * BFD_RELOC_32: howto manager. (line 27) 9173 * BFD_RELOC_32_BASEREL: howto manager. (line 79) 9174 * BFD_RELOC_32_GOT_PCREL: howto manager. (line 51) 9175 * BFD_RELOC_32_GOTOFF: howto manager. (line 54) 9176 * BFD_RELOC_32_PCREL: howto manager. (line 36) 9177 * BFD_RELOC_32_PCREL_S2: howto manager. (line 91) 9178 * BFD_RELOC_32_PLT_PCREL: howto manager. (line 61) 9179 * BFD_RELOC_32_PLTOFF: howto manager. (line 66) 9180 * BFD_RELOC_32_SECREL: howto manager. (line 48) 9181 * BFD_RELOC_386_COPY: howto manager. (line 435) 9182 * BFD_RELOC_386_GLOB_DAT: howto manager. (line 436) 9183 * BFD_RELOC_386_GOT32: howto manager. (line 433) 9184 * BFD_RELOC_386_GOTOFF: howto manager. (line 439) 9185 * BFD_RELOC_386_GOTPC: howto manager. (line 440) 9186 * BFD_RELOC_386_JUMP_SLOT: howto manager. (line 437) 9187 * BFD_RELOC_386_PLT32: howto manager. (line 434) 9188 * BFD_RELOC_386_RELATIVE: howto manager. (line 438) 9189 * BFD_RELOC_386_TLS_DESC: howto manager. (line 455) 9190 * BFD_RELOC_386_TLS_DESC_CALL: howto manager. (line 454) 9191 * BFD_RELOC_386_TLS_DTPMOD32: howto manager. (line 450) 9192 * BFD_RELOC_386_TLS_DTPOFF32: howto manager. (line 451) 9193 * BFD_RELOC_386_TLS_GD: howto manager. (line 445) 9194 * BFD_RELOC_386_TLS_GOTDESC: howto manager. (line 453) 9195 * BFD_RELOC_386_TLS_GOTIE: howto manager. (line 443) 9196 * BFD_RELOC_386_TLS_IE: howto manager. (line 442) 9197 * BFD_RELOC_386_TLS_IE_32: howto manager. (line 448) 9198 * BFD_RELOC_386_TLS_LDM: howto manager. (line 446) 9199 * BFD_RELOC_386_TLS_LDO_32: howto manager. (line 447) 9200 * BFD_RELOC_386_TLS_LE: howto manager. (line 444) 9201 * BFD_RELOC_386_TLS_LE_32: howto manager. (line 449) 9202 * BFD_RELOC_386_TLS_TPOFF: howto manager. (line 441) 9203 * BFD_RELOC_386_TLS_TPOFF32: howto manager. (line 452) 9204 * BFD_RELOC_390_12: howto manager. (line 1346) 9205 * BFD_RELOC_390_20: howto manager. (line 1446) 9206 * BFD_RELOC_390_COPY: howto manager. (line 1355) 9207 * BFD_RELOC_390_GLOB_DAT: howto manager. (line 1358) 9208 * BFD_RELOC_390_GOT12: howto manager. (line 1349) 9209 * BFD_RELOC_390_GOT16: howto manager. (line 1370) 9210 * BFD_RELOC_390_GOT20: howto manager. (line 1447) 9211 * BFD_RELOC_390_GOT64: howto manager. (line 1388) 9212 * BFD_RELOC_390_GOTENT: howto manager. (line 1394) 9213 * BFD_RELOC_390_GOTOFF64: howto manager. (line 1397) 9214 * BFD_RELOC_390_GOTPC: howto manager. (line 1367) 9215 * BFD_RELOC_390_GOTPCDBL: howto manager. (line 1385) 9216 * BFD_RELOC_390_GOTPLT12: howto manager. (line 1400) 9217 * BFD_RELOC_390_GOTPLT16: howto manager. (line 1403) 9218 * BFD_RELOC_390_GOTPLT20: howto manager. (line 1448) 9219 * BFD_RELOC_390_GOTPLT32: howto manager. (line 1406) 9220 * BFD_RELOC_390_GOTPLT64: howto manager. (line 1409) 9221 * BFD_RELOC_390_GOTPLTENT: howto manager. (line 1412) 9222 * BFD_RELOC_390_JMP_SLOT: howto manager. (line 1361) 9223 * BFD_RELOC_390_PC16DBL: howto manager. (line 1373) 9224 * BFD_RELOC_390_PC32DBL: howto manager. (line 1379) 9225 * BFD_RELOC_390_PLT16DBL: howto manager. (line 1376) 9226 * BFD_RELOC_390_PLT32: howto manager. (line 1352) 9227 * BFD_RELOC_390_PLT32DBL: howto manager. (line 1382) 9228 * BFD_RELOC_390_PLT64: howto manager. (line 1391) 9229 * BFD_RELOC_390_PLTOFF16: howto manager. (line 1415) 9230 * BFD_RELOC_390_PLTOFF32: howto manager. (line 1418) 9231 * BFD_RELOC_390_PLTOFF64: howto manager. (line 1421) 9232 * BFD_RELOC_390_RELATIVE: howto manager. (line 1364) 9233 * BFD_RELOC_390_TLS_DTPMOD: howto manager. (line 1441) 9234 * BFD_RELOC_390_TLS_DTPOFF: howto manager. (line 1442) 9235 * BFD_RELOC_390_TLS_GD32: howto manager. (line 1427) 9236 * BFD_RELOC_390_TLS_GD64: howto manager. (line 1428) 9237 * BFD_RELOC_390_TLS_GDCALL: howto manager. (line 1425) 9238 * BFD_RELOC_390_TLS_GOTIE12: howto manager. (line 1429) 9239 * BFD_RELOC_390_TLS_GOTIE20: howto manager. (line 1449) 9240 * BFD_RELOC_390_TLS_GOTIE32: howto manager. (line 1430) 9241 * BFD_RELOC_390_TLS_GOTIE64: howto manager. (line 1431) 9242 * BFD_RELOC_390_TLS_IE32: howto manager. (line 1434) 9243 * BFD_RELOC_390_TLS_IE64: howto manager. (line 1435) 9244 * BFD_RELOC_390_TLS_IEENT: howto manager. (line 1436) 9245 * BFD_RELOC_390_TLS_LDCALL: howto manager. (line 1426) 9246 * BFD_RELOC_390_TLS_LDM32: howto manager. (line 1432) 9247 * BFD_RELOC_390_TLS_LDM64: howto manager. (line 1433) 9248 * BFD_RELOC_390_TLS_LDO32: howto manager. (line 1439) 9249 * BFD_RELOC_390_TLS_LDO64: howto manager. (line 1440) 9250 * BFD_RELOC_390_TLS_LE32: howto manager. (line 1437) 9251 * BFD_RELOC_390_TLS_LE64: howto manager. (line 1438) 9252 * BFD_RELOC_390_TLS_LOAD: howto manager. (line 1424) 9253 * BFD_RELOC_390_TLS_TPOFF: howto manager. (line 1443) 9254 * BFD_RELOC_64: howto manager. (line 26) 9255 * BFD_RELOC_64_PCREL: howto manager. (line 35) 9256 * BFD_RELOC_64_PLT_PCREL: howto manager. (line 60) 9257 * BFD_RELOC_64_PLTOFF: howto manager. (line 65) 9258 * BFD_RELOC_68K_GLOB_DAT: howto manager. (line 74) 9259 * BFD_RELOC_68K_JMP_SLOT: howto manager. (line 75) 9260 * BFD_RELOC_68K_RELATIVE: howto manager. (line 76) 9261 * BFD_RELOC_8: howto manager. (line 32) 9262 * BFD_RELOC_860_COPY: howto manager. (line 1734) 9263 * BFD_RELOC_860_GLOB_DAT: howto manager. (line 1735) 9264 * BFD_RELOC_860_HAGOT: howto manager. (line 1760) 9265 * BFD_RELOC_860_HAGOTOFF: howto manager. (line 1761) 9266 * BFD_RELOC_860_HAPC: howto manager. (line 1762) 9267 * BFD_RELOC_860_HIGH: howto manager. (line 1763) 9268 * BFD_RELOC_860_HIGHADJ: howto manager. (line 1759) 9269 * BFD_RELOC_860_HIGOT: howto manager. (line 1764) 9270 * BFD_RELOC_860_HIGOTOFF: howto manager. (line 1765) 9271 * BFD_RELOC_860_JUMP_SLOT: howto manager. (line 1736) 9272 * BFD_RELOC_860_LOGOT0: howto manager. (line 1748) 9273 * BFD_RELOC_860_LOGOT1: howto manager. (line 1750) 9274 * BFD_RELOC_860_LOGOTOFF0: howto manager. (line 1752) 9275 * BFD_RELOC_860_LOGOTOFF1: howto manager. (line 1754) 9276 * BFD_RELOC_860_LOGOTOFF2: howto manager. (line 1756) 9277 * BFD_RELOC_860_LOGOTOFF3: howto manager. (line 1757) 9278 * BFD_RELOC_860_LOPC: howto manager. (line 1758) 9279 * BFD_RELOC_860_LOW0: howto manager. (line 1741) 9280 * BFD_RELOC_860_LOW1: howto manager. (line 1743) 9281 * BFD_RELOC_860_LOW2: howto manager. (line 1745) 9282 * BFD_RELOC_860_LOW3: howto manager. (line 1747) 9283 * BFD_RELOC_860_PC16: howto manager. (line 1740) 9284 * BFD_RELOC_860_PC26: howto manager. (line 1738) 9285 * BFD_RELOC_860_PLT26: howto manager. (line 1739) 9286 * BFD_RELOC_860_RELATIVE: howto manager. (line 1737) 9287 * BFD_RELOC_860_SPGOT0: howto manager. (line 1749) 9288 * BFD_RELOC_860_SPGOT1: howto manager. (line 1751) 9289 * BFD_RELOC_860_SPGOTOFF0: howto manager. (line 1753) 9290 * BFD_RELOC_860_SPGOTOFF1: howto manager. (line 1755) 9291 * BFD_RELOC_860_SPLIT0: howto manager. (line 1742) 9292 * BFD_RELOC_860_SPLIT1: howto manager. (line 1744) 9293 * BFD_RELOC_860_SPLIT2: howto manager. (line 1746) 9294 * BFD_RELOC_8_BASEREL: howto manager. (line 84) 9295 * BFD_RELOC_8_FFnn: howto manager. (line 88) 9296 * BFD_RELOC_8_GOT_PCREL: howto manager. (line 53) 9297 * BFD_RELOC_8_GOTOFF: howto manager. (line 59) 9298 * BFD_RELOC_8_PCREL: howto manager. (line 40) 9299 * BFD_RELOC_8_PLT_PCREL: howto manager. (line 64) 9300 * BFD_RELOC_8_PLTOFF: howto manager. (line 71) 9301 * BFD_RELOC_ALPHA_BRSGP: howto manager. (line 259) 9302 * BFD_RELOC_ALPHA_CODEADDR: howto manager. (line 250) 9303 * BFD_RELOC_ALPHA_DTPMOD64: howto manager. (line 266) 9304 * BFD_RELOC_ALPHA_DTPREL16: howto manager. (line 271) 9305 * BFD_RELOC_ALPHA_DTPREL64: howto manager. (line 268) 9306 * BFD_RELOC_ALPHA_DTPREL_HI16: howto manager. (line 269) 9307 * BFD_RELOC_ALPHA_DTPREL_LO16: howto manager. (line 270) 9308 * BFD_RELOC_ALPHA_ELF_LITERAL: howto manager. (line 215) 9309 * BFD_RELOC_ALPHA_GOTDTPREL16: howto manager. (line 267) 9310 * BFD_RELOC_ALPHA_GOTTPREL16: howto manager. (line 272) 9311 * BFD_RELOC_ALPHA_GPDISP: howto manager. (line 209) 9312 * BFD_RELOC_ALPHA_GPDISP_HI16: howto manager. (line 195) 9313 * BFD_RELOC_ALPHA_GPDISP_LO16: howto manager. (line 203) 9314 * BFD_RELOC_ALPHA_GPREL_HI16: howto manager. (line 254) 9315 * BFD_RELOC_ALPHA_GPREL_LO16: howto manager. (line 255) 9316 * BFD_RELOC_ALPHA_HINT: howto manager. (line 241) 9317 * BFD_RELOC_ALPHA_LINKAGE: howto manager. (line 246) 9318 * BFD_RELOC_ALPHA_LITERAL: howto manager. (line 214) 9319 * BFD_RELOC_ALPHA_LITUSE: howto manager. (line 216) 9320 * BFD_RELOC_ALPHA_TLSGD: howto manager. (line 264) 9321 * BFD_RELOC_ALPHA_TLSLDM: howto manager. (line 265) 9322 * BFD_RELOC_ALPHA_TPREL16: howto manager. (line 276) 9323 * BFD_RELOC_ALPHA_TPREL64: howto manager. (line 273) 9324 * BFD_RELOC_ALPHA_TPREL_HI16: howto manager. (line 274) 9325 * BFD_RELOC_ALPHA_TPREL_LO16: howto manager. (line 275) 9326 * BFD_RELOC_ARC_B22_PCREL: howto manager. (line 816) 9327 * BFD_RELOC_ARC_B26: howto manager. (line 821) 9328 * BFD_RELOC_ARM_ADR_IMM: howto manager. (line 709) 9329 * BFD_RELOC_ARM_ADRL_IMMEDIATE: howto manager. (line 697) 9330 * BFD_RELOC_ARM_CP_OFF_IMM: howto manager. (line 705) 9331 * BFD_RELOC_ARM_CP_OFF_IMM_S2: howto manager. (line 706) 9332 * BFD_RELOC_ARM_GLOB_DAT: howto manager. (line 678) 9333 * BFD_RELOC_ARM_GOT32: howto manager. (line 679) 9334 * BFD_RELOC_ARM_GOTOFF: howto manager. (line 682) 9335 * BFD_RELOC_ARM_GOTPC: howto manager. (line 683) 9336 * BFD_RELOC_ARM_HWLITERAL: howto manager. (line 716) 9337 * BFD_RELOC_ARM_IMMEDIATE: howto manager. (line 696) 9338 * BFD_RELOC_ARM_IN_POOL: howto manager. (line 712) 9339 * BFD_RELOC_ARM_JUMP_SLOT: howto manager. (line 677) 9340 * BFD_RELOC_ARM_LDR_IMM: howto manager. (line 710) 9341 * BFD_RELOC_ARM_LITERAL: howto manager. (line 711) 9342 * BFD_RELOC_ARM_MULTI: howto manager. (line 704) 9343 * BFD_RELOC_ARM_OFFSET_IMM: howto manager. (line 651) 9344 * BFD_RELOC_ARM_OFFSET_IMM8: howto manager. (line 713) 9345 * BFD_RELOC_ARM_PCREL_BLX: howto manager. (line 622) 9346 * BFD_RELOC_ARM_PCREL_BRANCH: howto manager. (line 618) 9347 * BFD_RELOC_ARM_PCREL_CALL: howto manager. (line 632) 9348 * BFD_RELOC_ARM_PCREL_JUMP: howto manager. (line 636) 9349 * BFD_RELOC_ARM_PLT32: howto manager. (line 680) 9350 * BFD_RELOC_ARM_PREL31: howto manager. (line 674) 9351 * BFD_RELOC_ARM_RELATIVE: howto manager. (line 681) 9352 * BFD_RELOC_ARM_ROSEGREL32: howto manager. (line 663) 9353 * BFD_RELOC_ARM_SBREL32: howto manager. (line 666) 9354 * BFD_RELOC_ARM_SHIFT_IMM: howto manager. (line 701) 9355 * BFD_RELOC_ARM_SMC: howto manager. (line 702) 9356 * BFD_RELOC_ARM_SWI: howto manager. (line 703) 9357 * BFD_RELOC_ARM_T32_ADD_PC12: howto manager. (line 700) 9358 * BFD_RELOC_ARM_T32_CP_OFF_IMM: howto manager. (line 707) 9359 * BFD_RELOC_ARM_T32_CP_OFF_IMM_S2: howto manager. (line 708) 9360 * BFD_RELOC_ARM_T32_IMM12: howto manager. (line 699) 9361 * BFD_RELOC_ARM_T32_IMMEDIATE: howto manager. (line 698) 9362 * BFD_RELOC_ARM_T32_OFFSET_IMM: howto manager. (line 715) 9363 * BFD_RELOC_ARM_T32_OFFSET_U8: howto manager. (line 714) 9364 * BFD_RELOC_ARM_TARGET1: howto manager. (line 659) 9365 * BFD_RELOC_ARM_TARGET2: howto manager. (line 669) 9366 * BFD_RELOC_ARM_THUMB_ADD: howto manager. (line 717) 9367 * BFD_RELOC_ARM_THUMB_IMM: howto manager. (line 718) 9368 * BFD_RELOC_ARM_THUMB_OFFSET: howto manager. (line 655) 9369 * BFD_RELOC_ARM_THUMB_SHIFT: howto manager. (line 719) 9370 * BFD_RELOC_ARM_TLS_DTPMOD32: howto manager. (line 690) 9371 * BFD_RELOC_ARM_TLS_DTPOFF32: howto manager. (line 689) 9372 * BFD_RELOC_ARM_TLS_GD32: howto manager. (line 686) 9373 * BFD_RELOC_ARM_TLS_IE32: howto manager. (line 692) 9374 * BFD_RELOC_ARM_TLS_LDM32: howto manager. (line 688) 9375 * BFD_RELOC_ARM_TLS_LDO32: howto manager. (line 687) 9376 * BFD_RELOC_ARM_TLS_LE32: howto manager. (line 693) 9377 * BFD_RELOC_ARM_TLS_TPOFF32: howto manager. (line 691) 9378 * BFD_RELOC_AVR_13_PCREL: howto manager. (line 1259) 9379 * BFD_RELOC_AVR_16_PM: howto manager. (line 1263) 9380 * BFD_RELOC_AVR_6: howto manager. (line 1338) 9381 * BFD_RELOC_AVR_6_ADIW: howto manager. (line 1342) 9382 * BFD_RELOC_AVR_7_PCREL: howto manager. (line 1255) 9383 * BFD_RELOC_AVR_CALL: howto manager. (line 1330) 9384 * BFD_RELOC_AVR_HH8_LDI: howto manager. (line 1275) 9385 * BFD_RELOC_AVR_HH8_LDI_NEG: howto manager. (line 1294) 9386 * BFD_RELOC_AVR_HH8_LDI_PM: howto manager. (line 1311) 9387 * BFD_RELOC_AVR_HH8_LDI_PM_NEG: howto manager. (line 1325) 9388 * BFD_RELOC_AVR_HI8_LDI: howto manager. (line 1271) 9389 * BFD_RELOC_AVR_HI8_LDI_NEG: howto manager. (line 1289) 9390 * BFD_RELOC_AVR_HI8_LDI_PM: howto manager. (line 1307) 9391 * BFD_RELOC_AVR_HI8_LDI_PM_NEG: howto manager. (line 1320) 9392 * BFD_RELOC_AVR_LDI: howto manager. (line 1334) 9393 * BFD_RELOC_AVR_LO8_LDI: howto manager. (line 1267) 9394 * BFD_RELOC_AVR_LO8_LDI_NEG: howto manager. (line 1284) 9395 * BFD_RELOC_AVR_LO8_LDI_PM: howto manager. (line 1303) 9396 * BFD_RELOC_AVR_LO8_LDI_PM_NEG: howto manager. (line 1316) 9397 * BFD_RELOC_AVR_MS8_LDI: howto manager. (line 1280) 9398 * BFD_RELOC_AVR_MS8_LDI_NEG: howto manager. (line 1299) 9399 * BFD_RELOC_BFIN_10_PCREL: howto manager. (line 841) 9400 * BFD_RELOC_BFIN_11_PCREL: howto manager. (line 844) 9401 * BFD_RELOC_BFIN_12_PCREL_JUMP: howto manager. (line 847) 9402 * BFD_RELOC_BFIN_12_PCREL_JUMP_S: howto manager. (line 850) 9403 * BFD_RELOC_BFIN_16_HIGH: howto manager. (line 829) 9404 * BFD_RELOC_BFIN_16_IMM: howto manager. (line 826) 9405 * BFD_RELOC_BFIN_16_LOW: howto manager. (line 838) 9406 * BFD_RELOC_BFIN_24_PCREL_CALL_X: howto manager. (line 853) 9407 * BFD_RELOC_BFIN_24_PCREL_JUMP_L: howto manager. (line 856) 9408 * BFD_RELOC_BFIN_4_PCREL: howto manager. (line 832) 9409 * BFD_RELOC_BFIN_5_PCREL: howto manager. (line 835) 9410 * BFD_RELOC_BFIN_FUNCDESC: howto manager. (line 862) 9411 * BFD_RELOC_BFIN_FUNCDESC_GOT17M4: howto manager. (line 863) 9412 * BFD_RELOC_BFIN_FUNCDESC_GOTHI: howto manager. (line 864) 9413 * BFD_RELOC_BFIN_FUNCDESC_GOTLO: howto manager. (line 865) 9414 * BFD_RELOC_BFIN_FUNCDESC_GOTOFF17M4: howto manager. (line 867) 9415 * BFD_RELOC_BFIN_FUNCDESC_GOTOFFHI: howto manager. (line 868) 9416 * BFD_RELOC_BFIN_FUNCDESC_GOTOFFLO: howto manager. (line 869) 9417 * BFD_RELOC_BFIN_FUNCDESC_VALUE: howto manager. (line 866) 9418 * BFD_RELOC_BFIN_GOT: howto manager. (line 875) 9419 * BFD_RELOC_BFIN_GOT17M4: howto manager. (line 859) 9420 * BFD_RELOC_BFIN_GOTHI: howto manager. (line 860) 9421 * BFD_RELOC_BFIN_GOTLO: howto manager. (line 861) 9422 * BFD_RELOC_BFIN_GOTOFF17M4: howto manager. (line 870) 9423 * BFD_RELOC_BFIN_GOTOFFHI: howto manager. (line 871) 9424 * BFD_RELOC_BFIN_GOTOFFLO: howto manager. (line 872) 9425 * BFD_RELOC_BFIN_PLTPC: howto manager. (line 878) 9426 * bfd_reloc_code_type: howto manager. (line 10) 9427 * BFD_RELOC_CRIS_16_GOT: howto manager. (line 1715) 9428 * BFD_RELOC_CRIS_16_GOTPLT: howto manager. (line 1721) 9429 * BFD_RELOC_CRIS_32_GOT: howto manager. (line 1712) 9430 * BFD_RELOC_CRIS_32_GOTPLT: howto manager. (line 1718) 9431 * BFD_RELOC_CRIS_32_GOTREL: howto manager. (line 1724) 9432 * BFD_RELOC_CRIS_32_PLT_GOTREL: howto manager. (line 1727) 9433 * BFD_RELOC_CRIS_32_PLT_PCREL: howto manager. (line 1730) 9434 * BFD_RELOC_CRIS_BDISP8: howto manager. (line 1693) 9435 * BFD_RELOC_CRIS_COPY: howto manager. (line 1706) 9436 * BFD_RELOC_CRIS_GLOB_DAT: howto manager. (line 1707) 9437 * BFD_RELOC_CRIS_JUMP_SLOT: howto manager. (line 1708) 9438 * BFD_RELOC_CRIS_LAPCQ_OFFSET: howto manager. (line 1701) 9439 * BFD_RELOC_CRIS_RELATIVE: howto manager. (line 1709) 9440 * BFD_RELOC_CRIS_SIGNED_16: howto manager. (line 1699) 9441 * BFD_RELOC_CRIS_SIGNED_6: howto manager. (line 1695) 9442 * BFD_RELOC_CRIS_SIGNED_8: howto manager. (line 1697) 9443 * BFD_RELOC_CRIS_UNSIGNED_16: howto manager. (line 1700) 9444 * BFD_RELOC_CRIS_UNSIGNED_4: howto manager. (line 1702) 9445 * BFD_RELOC_CRIS_UNSIGNED_5: howto manager. (line 1694) 9446 * BFD_RELOC_CRIS_UNSIGNED_6: howto manager. (line 1696) 9447 * BFD_RELOC_CRIS_UNSIGNED_8: howto manager. (line 1698) 9448 * BFD_RELOC_CRX_ABS16: howto manager. (line 1681) 9449 * BFD_RELOC_CRX_ABS32: howto manager. (line 1682) 9450 * BFD_RELOC_CRX_IMM16: howto manager. (line 1686) 9451 * BFD_RELOC_CRX_IMM32: howto manager. (line 1687) 9452 * BFD_RELOC_CRX_NUM16: howto manager. (line 1684) 9453 * BFD_RELOC_CRX_NUM32: howto manager. (line 1685) 9454 * BFD_RELOC_CRX_NUM8: howto manager. (line 1683) 9455 * BFD_RELOC_CRX_REGREL12: howto manager. (line 1677) 9456 * BFD_RELOC_CRX_REGREL22: howto manager. (line 1678) 9457 * BFD_RELOC_CRX_REGREL28: howto manager. (line 1679) 9458 * BFD_RELOC_CRX_REGREL32: howto manager. (line 1680) 9459 * BFD_RELOC_CRX_REL16: howto manager. (line 1674) 9460 * BFD_RELOC_CRX_REL24: howto manager. (line 1675) 9461 * BFD_RELOC_CRX_REL32: howto manager. (line 1676) 9462 * BFD_RELOC_CRX_REL4: howto manager. (line 1671) 9463 * BFD_RELOC_CRX_REL8: howto manager. (line 1672) 9464 * BFD_RELOC_CRX_REL8_CMP: howto manager. (line 1673) 9465 * BFD_RELOC_CRX_SWITCH16: howto manager. (line 1689) 9466 * BFD_RELOC_CRX_SWITCH32: howto manager. (line 1690) 9467 * BFD_RELOC_CRX_SWITCH8: howto manager. (line 1688) 9468 * BFD_RELOC_CTOR: howto manager. (line 612) 9469 * BFD_RELOC_D10V_10_PCREL_L: howto manager. (line 945) 9470 * BFD_RELOC_D10V_10_PCREL_R: howto manager. (line 941) 9471 * BFD_RELOC_D10V_18: howto manager. (line 950) 9472 * BFD_RELOC_D10V_18_PCREL: howto manager. (line 953) 9473 * BFD_RELOC_D30V_15: howto manager. (line 968) 9474 * BFD_RELOC_D30V_15_PCREL: howto manager. (line 972) 9475 * BFD_RELOC_D30V_15_PCREL_R: howto manager. (line 976) 9476 * BFD_RELOC_D30V_21: howto manager. (line 981) 9477 * BFD_RELOC_D30V_21_PCREL: howto manager. (line 985) 9478 * BFD_RELOC_D30V_21_PCREL_R: howto manager. (line 989) 9479 * BFD_RELOC_D30V_32: howto manager. (line 994) 9480 * BFD_RELOC_D30V_32_PCREL: howto manager. (line 997) 9481 * BFD_RELOC_D30V_6: howto manager. (line 956) 9482 * BFD_RELOC_D30V_9_PCREL: howto manager. (line 959) 9483 * BFD_RELOC_D30V_9_PCREL_R: howto manager. (line 963) 9484 * BFD_RELOC_DLX_HI16_S: howto manager. (line 1000) 9485 * BFD_RELOC_DLX_JMP26: howto manager. (line 1006) 9486 * BFD_RELOC_DLX_LO16: howto manager. (line 1003) 9487 * BFD_RELOC_FR30_10_IN_8: howto manager. (line 1185) 9488 * BFD_RELOC_FR30_12_PCREL: howto manager. (line 1193) 9489 * BFD_RELOC_FR30_20: howto manager. (line 1169) 9490 * BFD_RELOC_FR30_48: howto manager. (line 1166) 9491 * BFD_RELOC_FR30_6_IN_4: howto manager. (line 1173) 9492 * BFD_RELOC_FR30_8_IN_8: howto manager. (line 1177) 9493 * BFD_RELOC_FR30_9_IN_8: howto manager. (line 1181) 9494 * BFD_RELOC_FR30_9_PCREL: howto manager. (line 1189) 9495 * BFD_RELOC_FRV_FUNCDESC: howto manager. (line 377) 9496 * BFD_RELOC_FRV_FUNCDESC_GOT12: howto manager. (line 378) 9497 * BFD_RELOC_FRV_FUNCDESC_GOTHI: howto manager. (line 379) 9498 * BFD_RELOC_FRV_FUNCDESC_GOTLO: howto manager. (line 380) 9499 * BFD_RELOC_FRV_FUNCDESC_GOTOFF12: howto manager. (line 382) 9500 * BFD_RELOC_FRV_FUNCDESC_GOTOFFHI: howto manager. (line 383) 9501 * BFD_RELOC_FRV_FUNCDESC_GOTOFFLO: howto manager. (line 384) 9502 * BFD_RELOC_FRV_FUNCDESC_VALUE: howto manager. (line 381) 9503 * BFD_RELOC_FRV_GETTLSOFF: howto manager. (line 388) 9504 * BFD_RELOC_FRV_GETTLSOFF_RELAX: howto manager. (line 401) 9505 * BFD_RELOC_FRV_GOT12: howto manager. (line 374) 9506 * BFD_RELOC_FRV_GOTHI: howto manager. (line 375) 9507 * BFD_RELOC_FRV_GOTLO: howto manager. (line 376) 9508 * BFD_RELOC_FRV_GOTOFF12: howto manager. (line 385) 9509 * BFD_RELOC_FRV_GOTOFFHI: howto manager. (line 386) 9510 * BFD_RELOC_FRV_GOTOFFLO: howto manager. (line 387) 9511 * BFD_RELOC_FRV_GOTTLSDESC12: howto manager. (line 390) 9512 * BFD_RELOC_FRV_GOTTLSDESCHI: howto manager. (line 391) 9513 * BFD_RELOC_FRV_GOTTLSDESCLO: howto manager. (line 392) 9514 * BFD_RELOC_FRV_GOTTLSOFF12: howto manager. (line 396) 9515 * BFD_RELOC_FRV_GOTTLSOFFHI: howto manager. (line 397) 9516 * BFD_RELOC_FRV_GOTTLSOFFLO: howto manager. (line 398) 9517 * BFD_RELOC_FRV_GPREL12: howto manager. (line 369) 9518 * BFD_RELOC_FRV_GPREL32: howto manager. (line 371) 9519 * BFD_RELOC_FRV_GPRELHI: howto manager. (line 372) 9520 * BFD_RELOC_FRV_GPRELLO: howto manager. (line 373) 9521 * BFD_RELOC_FRV_GPRELU12: howto manager. (line 370) 9522 * BFD_RELOC_FRV_HI16: howto manager. (line 368) 9523 * BFD_RELOC_FRV_LABEL16: howto manager. (line 365) 9524 * BFD_RELOC_FRV_LABEL24: howto manager. (line 366) 9525 * BFD_RELOC_FRV_LO16: howto manager. (line 367) 9526 * BFD_RELOC_FRV_TLSDESC_RELAX: howto manager. (line 400) 9527 * BFD_RELOC_FRV_TLSDESC_VALUE: howto manager. (line 389) 9528 * BFD_RELOC_FRV_TLSMOFF: howto manager. (line 403) 9529 * BFD_RELOC_FRV_TLSMOFF12: howto manager. (line 393) 9530 * BFD_RELOC_FRV_TLSMOFFHI: howto manager. (line 394) 9531 * BFD_RELOC_FRV_TLSMOFFLO: howto manager. (line 395) 9532 * BFD_RELOC_FRV_TLSOFF: howto manager. (line 399) 9533 * BFD_RELOC_FRV_TLSOFF_RELAX: howto manager. (line 402) 9534 * BFD_RELOC_GPREL16: howto manager. (line 106) 9535 * BFD_RELOC_GPREL32: howto manager. (line 107) 9536 * BFD_RELOC_H8_DIR16A8: howto manager. (line 1772) 9537 * BFD_RELOC_H8_DIR16R8: howto manager. (line 1773) 9538 * BFD_RELOC_H8_DIR24A8: howto manager. (line 1774) 9539 * BFD_RELOC_H8_DIR24R8: howto manager. (line 1775) 9540 * BFD_RELOC_H8_DIR32A16: howto manager. (line 1776) 9541 * BFD_RELOC_HI16: howto manager. (line 289) 9542 * BFD_RELOC_HI16_BASEREL: howto manager. (line 82) 9543 * BFD_RELOC_HI16_GOTOFF: howto manager. (line 57) 9544 * BFD_RELOC_HI16_PCREL: howto manager. (line 301) 9545 * BFD_RELOC_HI16_PLTOFF: howto manager. (line 69) 9546 * BFD_RELOC_HI16_S: howto manager. (line 292) 9547 * BFD_RELOC_HI16_S_BASEREL: howto manager. (line 83) 9548 * BFD_RELOC_HI16_S_GOTOFF: howto manager. (line 58) 9549 * BFD_RELOC_HI16_S_PCREL: howto manager. (line 304) 9550 * BFD_RELOC_HI16_S_PLTOFF: howto manager. (line 70) 9551 * BFD_RELOC_HI22: howto manager. (line 101) 9552 * BFD_RELOC_I370_D12: howto manager. (line 609) 9553 * BFD_RELOC_I960_CALLJ: howto manager. (line 113) 9554 * BFD_RELOC_IA64_COPY: howto manager. (line 1565) 9555 * BFD_RELOC_IA64_DIR32LSB: howto manager. (line 1510) 9556 * BFD_RELOC_IA64_DIR32MSB: howto manager. (line 1509) 9557 * BFD_RELOC_IA64_DIR64LSB: howto manager. (line 1512) 9558 * BFD_RELOC_IA64_DIR64MSB: howto manager. (line 1511) 9559 * BFD_RELOC_IA64_DTPMOD64LSB: howto manager. (line 1575) 9560 * BFD_RELOC_IA64_DTPMOD64MSB: howto manager. (line 1574) 9561 * BFD_RELOC_IA64_DTPREL14: howto manager. (line 1577) 9562 * BFD_RELOC_IA64_DTPREL22: howto manager. (line 1578) 9563 * BFD_RELOC_IA64_DTPREL32LSB: howto manager. (line 1581) 9564 * BFD_RELOC_IA64_DTPREL32MSB: howto manager. (line 1580) 9565 * BFD_RELOC_IA64_DTPREL64I: howto manager. (line 1579) 9566 * BFD_RELOC_IA64_DTPREL64LSB: howto manager. (line 1583) 9567 * BFD_RELOC_IA64_DTPREL64MSB: howto manager. (line 1582) 9568 * BFD_RELOC_IA64_FPTR32LSB: howto manager. (line 1527) 9569 * BFD_RELOC_IA64_FPTR32MSB: howto manager. (line 1526) 9570 * BFD_RELOC_IA64_FPTR64I: howto manager. (line 1525) 9571 * BFD_RELOC_IA64_FPTR64LSB: howto manager. (line 1529) 9572 * BFD_RELOC_IA64_FPTR64MSB: howto manager. (line 1528) 9573 * BFD_RELOC_IA64_GPREL22: howto manager. (line 1513) 9574 * BFD_RELOC_IA64_GPREL32LSB: howto manager. (line 1516) 9575 * BFD_RELOC_IA64_GPREL32MSB: howto manager. (line 1515) 9576 * BFD_RELOC_IA64_GPREL64I: howto manager. (line 1514) 9577 * BFD_RELOC_IA64_GPREL64LSB: howto manager. (line 1518) 9578 * BFD_RELOC_IA64_GPREL64MSB: howto manager. (line 1517) 9579 * BFD_RELOC_IA64_IMM14: howto manager. (line 1506) 9580 * BFD_RELOC_IA64_IMM22: howto manager. (line 1507) 9581 * BFD_RELOC_IA64_IMM64: howto manager. (line 1508) 9582 * BFD_RELOC_IA64_IPLTLSB: howto manager. (line 1564) 9583 * BFD_RELOC_IA64_IPLTMSB: howto manager. (line 1563) 9584 * BFD_RELOC_IA64_LDXMOV: howto manager. (line 1567) 9585 * BFD_RELOC_IA64_LTOFF22: howto manager. (line 1519) 9586 * BFD_RELOC_IA64_LTOFF22X: howto manager. (line 1566) 9587 * BFD_RELOC_IA64_LTOFF64I: howto manager. (line 1520) 9588 * BFD_RELOC_IA64_LTOFF_DTPMOD22: howto manager. (line 1576) 9589 * BFD_RELOC_IA64_LTOFF_DTPREL22: howto manager. (line 1584) 9590 * BFD_RELOC_IA64_LTOFF_FPTR22: howto manager. (line 1541) 9591 * BFD_RELOC_IA64_LTOFF_FPTR32LSB: howto manager. (line 1544) 9592 * BFD_RELOC_IA64_LTOFF_FPTR32MSB: howto manager. (line 1543) 9593 * BFD_RELOC_IA64_LTOFF_FPTR64I: howto manager. (line 1542) 9594 * BFD_RELOC_IA64_LTOFF_FPTR64LSB: howto manager. (line 1546) 9595 * BFD_RELOC_IA64_LTOFF_FPTR64MSB: howto manager. (line 1545) 9596 * BFD_RELOC_IA64_LTOFF_TPREL22: howto manager. (line 1573) 9597 * BFD_RELOC_IA64_LTV32LSB: howto manager. (line 1560) 9598 * BFD_RELOC_IA64_LTV32MSB: howto manager. (line 1559) 9599 * BFD_RELOC_IA64_LTV64LSB: howto manager. (line 1562) 9600 * BFD_RELOC_IA64_LTV64MSB: howto manager. (line 1561) 9601 * BFD_RELOC_IA64_PCREL21B: howto manager. (line 1530) 9602 * BFD_RELOC_IA64_PCREL21BI: howto manager. (line 1531) 9603 * BFD_RELOC_IA64_PCREL21F: howto manager. (line 1533) 9604 * BFD_RELOC_IA64_PCREL21M: howto manager. (line 1532) 9605 * BFD_RELOC_IA64_PCREL22: howto manager. (line 1534) 9606 * BFD_RELOC_IA64_PCREL32LSB: howto manager. (line 1538) 9607 * BFD_RELOC_IA64_PCREL32MSB: howto manager. (line 1537) 9608 * BFD_RELOC_IA64_PCREL60B: howto manager. (line 1535) 9609 * BFD_RELOC_IA64_PCREL64I: howto manager. (line 1536) 9610 * BFD_RELOC_IA64_PCREL64LSB: howto manager. (line 1540) 9611 * BFD_RELOC_IA64_PCREL64MSB: howto manager. (line 1539) 9612 * BFD_RELOC_IA64_PLTOFF22: howto manager. (line 1521) 9613 * BFD_RELOC_IA64_PLTOFF64I: howto manager. (line 1522) 9614 * BFD_RELOC_IA64_PLTOFF64LSB: howto manager. (line 1524) 9615 * BFD_RELOC_IA64_PLTOFF64MSB: howto manager. (line 1523) 9616 * BFD_RELOC_IA64_REL32LSB: howto manager. (line 1556) 9617 * BFD_RELOC_IA64_REL32MSB: howto manager. (line 1555) 9618 * BFD_RELOC_IA64_REL64LSB: howto manager. (line 1558) 9619 * BFD_RELOC_IA64_REL64MSB: howto manager. (line 1557) 9620 * BFD_RELOC_IA64_SECREL32LSB: howto manager. (line 1552) 9621 * BFD_RELOC_IA64_SECREL32MSB: howto manager. (line 1551) 9622 * BFD_RELOC_IA64_SECREL64LSB: howto manager. (line 1554) 9623 * BFD_RELOC_IA64_SECREL64MSB: howto manager. (line 1553) 9624 * BFD_RELOC_IA64_SEGREL32LSB: howto manager. (line 1548) 9625 * BFD_RELOC_IA64_SEGREL32MSB: howto manager. (line 1547) 9626 * BFD_RELOC_IA64_SEGREL64LSB: howto manager. (line 1550) 9627 * BFD_RELOC_IA64_SEGREL64MSB: howto manager. (line 1549) 9628 * BFD_RELOC_IA64_TPREL14: howto manager. (line 1568) 9629 * BFD_RELOC_IA64_TPREL22: howto manager. (line 1569) 9630 * BFD_RELOC_IA64_TPREL64I: howto manager. (line 1570) 9631 * BFD_RELOC_IA64_TPREL64LSB: howto manager. (line 1572) 9632 * BFD_RELOC_IA64_TPREL64MSB: howto manager. (line 1571) 9633 * BFD_RELOC_IP2K_ADDR16CJP: howto manager. (line 1458) 9634 * BFD_RELOC_IP2K_BANK: howto manager. (line 1455) 9635 * BFD_RELOC_IP2K_EX8DATA: howto manager. (line 1466) 9636 * BFD_RELOC_IP2K_FR9: howto manager. (line 1452) 9637 * BFD_RELOC_IP2K_FR_OFFSET: howto manager. (line 1479) 9638 * BFD_RELOC_IP2K_HI8DATA: howto manager. (line 1465) 9639 * BFD_RELOC_IP2K_HI8INSN: howto manager. (line 1470) 9640 * BFD_RELOC_IP2K_LO8DATA: howto manager. (line 1464) 9641 * BFD_RELOC_IP2K_LO8INSN: howto manager. (line 1469) 9642 * BFD_RELOC_IP2K_PAGE3: howto manager. (line 1461) 9643 * BFD_RELOC_IP2K_PC_SKIP: howto manager. (line 1473) 9644 * BFD_RELOC_IP2K_TEXT: howto manager. (line 1476) 9645 * BFD_RELOC_IQ2000_OFFSET_16: howto manager. (line 1823) 9646 * BFD_RELOC_IQ2000_OFFSET_21: howto manager. (line 1824) 9647 * BFD_RELOC_IQ2000_UHI16: howto manager. (line 1825) 9648 * BFD_RELOC_LO10: howto manager. (line 102) 9649 * BFD_RELOC_LO16: howto manager. (line 298) 9650 * BFD_RELOC_LO16_BASEREL: howto manager. (line 81) 9651 * BFD_RELOC_LO16_GOTOFF: howto manager. (line 56) 9652 * BFD_RELOC_LO16_PCREL: howto manager. (line 307) 9653 * BFD_RELOC_LO16_PLTOFF: howto manager. (line 68) 9654 * BFD_RELOC_M32C_HI8: howto manager. (line 1009) 9655 * BFD_RELOC_M32C_RL_1ADDR: howto manager. (line 1011) 9656 * BFD_RELOC_M32C_RL_2ADDR: howto manager. (line 1012) 9657 * BFD_RELOC_M32C_RL_JUMP: howto manager. (line 1010) 9658 * BFD_RELOC_M32R_10_PCREL: howto manager. (line 1019) 9659 * BFD_RELOC_M32R_18_PCREL: howto manager. (line 1023) 9660 * BFD_RELOC_M32R_24: howto manager. (line 1015) 9661 * BFD_RELOC_M32R_26_PCREL: howto manager. (line 1026) 9662 * BFD_RELOC_M32R_26_PLTREL: howto manager. (line 1045) 9663 * BFD_RELOC_M32R_COPY: howto manager. (line 1046) 9664 * BFD_RELOC_M32R_GLOB_DAT: howto manager. (line 1047) 9665 * BFD_RELOC_M32R_GOT16_HI_SLO: howto manager. (line 1056) 9666 * BFD_RELOC_M32R_GOT16_HI_ULO: howto manager. (line 1055) 9667 * BFD_RELOC_M32R_GOT16_LO: howto manager. (line 1057) 9668 * BFD_RELOC_M32R_GOT24: howto manager. (line 1044) 9669 * BFD_RELOC_M32R_GOTOFF: howto manager. (line 1050) 9670 * BFD_RELOC_M32R_GOTOFF_HI_SLO: howto manager. (line 1052) 9671 * BFD_RELOC_M32R_GOTOFF_HI_ULO: howto manager. (line 1051) 9672 * BFD_RELOC_M32R_GOTOFF_LO: howto manager. (line 1053) 9673 * BFD_RELOC_M32R_GOTPC24: howto manager. (line 1054) 9674 * BFD_RELOC_M32R_GOTPC_HI_SLO: howto manager. (line 1059) 9675 * BFD_RELOC_M32R_GOTPC_HI_ULO: howto manager. (line 1058) 9676 * BFD_RELOC_M32R_GOTPC_LO: howto manager. (line 1060) 9677 * BFD_RELOC_M32R_HI16_SLO: howto manager. (line 1033) 9678 * BFD_RELOC_M32R_HI16_ULO: howto manager. (line 1029) 9679 * BFD_RELOC_M32R_JMP_SLOT: howto manager. (line 1048) 9680 * BFD_RELOC_M32R_LO16: howto manager. (line 1037) 9681 * BFD_RELOC_M32R_RELATIVE: howto manager. (line 1049) 9682 * BFD_RELOC_M32R_SDA16: howto manager. (line 1040) 9683 * BFD_RELOC_M68HC11_24: howto manager. (line 1620) 9684 * BFD_RELOC_M68HC11_3B: howto manager. (line 1595) 9685 * BFD_RELOC_M68HC11_HI8: howto manager. (line 1587) 9686 * BFD_RELOC_M68HC11_LO16: howto manager. (line 1609) 9687 * BFD_RELOC_M68HC11_LO8: howto manager. (line 1591) 9688 * BFD_RELOC_M68HC11_PAGE: howto manager. (line 1615) 9689 * BFD_RELOC_M68HC11_RL_GROUP: howto manager. (line 1604) 9690 * BFD_RELOC_M68HC11_RL_JUMP: howto manager. (line 1598) 9691 * BFD_RELOC_M68HC12_5B: howto manager. (line 1626) 9692 * BFD_RELOC_MCORE_PCREL_32: howto manager. (line 1200) 9693 * BFD_RELOC_MCORE_PCREL_IMM11BY2: howto manager. (line 1198) 9694 * BFD_RELOC_MCORE_PCREL_IMM4BY2: howto manager. (line 1199) 9695 * BFD_RELOC_MCORE_PCREL_IMM8BY4: howto manager. (line 1197) 9696 * BFD_RELOC_MCORE_PCREL_JSR_IMM11BY2: howto manager. (line 1201) 9697 * BFD_RELOC_MCORE_RVA: howto manager. (line 1202) 9698 * BFD_RELOC_MIPS16_GPREL: howto manager. (line 286) 9699 * BFD_RELOC_MIPS16_HI16: howto manager. (line 310) 9700 * BFD_RELOC_MIPS16_HI16_S: howto manager. (line 313) 9701 * BFD_RELOC_MIPS16_JMP: howto manager. (line 283) 9702 * BFD_RELOC_MIPS16_LO16: howto manager. (line 319) 9703 * BFD_RELOC_MIPS_CALL16: howto manager. (line 326) 9704 * BFD_RELOC_MIPS_CALL_HI16: howto manager. (line 329) 9705 * BFD_RELOC_MIPS_CALL_LO16: howto manager. (line 330) 9706 * BFD_RELOC_MIPS_COPY: howto manager. (line 361) 9707 * BFD_RELOC_MIPS_DELETE: howto manager. (line 339) 9708 * BFD_RELOC_MIPS_GOT16: howto manager. (line 325) 9709 * BFD_RELOC_MIPS_GOT_DISP: howto manager. (line 334) 9710 * BFD_RELOC_MIPS_GOT_HI16: howto manager. (line 327) 9711 * BFD_RELOC_MIPS_GOT_LO16: howto manager. (line 328) 9712 * BFD_RELOC_MIPS_GOT_OFST: howto manager. (line 333) 9713 * BFD_RELOC_MIPS_GOT_PAGE: howto manager. (line 332) 9714 * BFD_RELOC_MIPS_HIGHER: howto manager. (line 341) 9715 * BFD_RELOC_MIPS_HIGHEST: howto manager. (line 340) 9716 * BFD_RELOC_MIPS_INSERT_A: howto manager. (line 337) 9717 * BFD_RELOC_MIPS_INSERT_B: howto manager. (line 338) 9718 * BFD_RELOC_MIPS_JALR: howto manager. (line 345) 9719 * BFD_RELOC_MIPS_JMP: howto manager. (line 279) 9720 * BFD_RELOC_MIPS_JUMP_SLOT: howto manager. (line 362) 9721 * BFD_RELOC_MIPS_LITERAL: howto manager. (line 322) 9722 * BFD_RELOC_MIPS_REL16: howto manager. (line 343) 9723 * BFD_RELOC_MIPS_RELGOT: howto manager. (line 344) 9724 * BFD_RELOC_MIPS_SCN_DISP: howto manager. (line 342) 9725 * BFD_RELOC_MIPS_SHIFT5: howto manager. (line 335) 9726 * BFD_RELOC_MIPS_SHIFT6: howto manager. (line 336) 9727 * BFD_RELOC_MIPS_SUB: howto manager. (line 331) 9728 * BFD_RELOC_MIPS_TLS_DTPMOD32: howto manager. (line 346) 9729 * BFD_RELOC_MIPS_TLS_DTPMOD64: howto manager. (line 348) 9730 * BFD_RELOC_MIPS_TLS_DTPREL32: howto manager. (line 347) 9731 * BFD_RELOC_MIPS_TLS_DTPREL64: howto manager. (line 349) 9732 * BFD_RELOC_MIPS_TLS_DTPREL_HI16: howto manager. (line 352) 9733 * BFD_RELOC_MIPS_TLS_DTPREL_LO16: howto manager. (line 353) 9734 * BFD_RELOC_MIPS_TLS_GD: howto manager. (line 350) 9735 * BFD_RELOC_MIPS_TLS_GOTTPREL: howto manager. (line 354) 9736 * BFD_RELOC_MIPS_TLS_LDM: howto manager. (line 351) 9737 * BFD_RELOC_MIPS_TLS_TPREL32: howto manager. (line 355) 9738 * BFD_RELOC_MIPS_TLS_TPREL64: howto manager. (line 356) 9739 * BFD_RELOC_MIPS_TLS_TPREL_HI16: howto manager. (line 357) 9740 * BFD_RELOC_MIPS_TLS_TPREL_LO16: howto manager. (line 358) 9741 * BFD_RELOC_MMIX_ADDR19: howto manager. (line 1231) 9742 * BFD_RELOC_MMIX_ADDR27: howto manager. (line 1235) 9743 * BFD_RELOC_MMIX_BASE_PLUS_OFFSET: howto manager. (line 1247) 9744 * BFD_RELOC_MMIX_CBRANCH: howto manager. (line 1211) 9745 * BFD_RELOC_MMIX_CBRANCH_1: howto manager. (line 1213) 9746 * BFD_RELOC_MMIX_CBRANCH_2: howto manager. (line 1214) 9747 * BFD_RELOC_MMIX_CBRANCH_3: howto manager. (line 1215) 9748 * BFD_RELOC_MMIX_CBRANCH_J: howto manager. (line 1212) 9749 * BFD_RELOC_MMIX_GETA: howto manager. (line 1205) 9750 * BFD_RELOC_MMIX_GETA_1: howto manager. (line 1206) 9751 * BFD_RELOC_MMIX_GETA_2: howto manager. (line 1207) 9752 * BFD_RELOC_MMIX_GETA_3: howto manager. (line 1208) 9753 * BFD_RELOC_MMIX_JMP: howto manager. (line 1225) 9754 * BFD_RELOC_MMIX_JMP_1: howto manager. (line 1226) 9755 * BFD_RELOC_MMIX_JMP_2: howto manager. (line 1227) 9756 * BFD_RELOC_MMIX_JMP_3: howto manager. (line 1228) 9757 * BFD_RELOC_MMIX_LOCAL: howto manager. (line 1251) 9758 * BFD_RELOC_MMIX_PUSHJ: howto manager. (line 1218) 9759 * BFD_RELOC_MMIX_PUSHJ_1: howto manager. (line 1219) 9760 * BFD_RELOC_MMIX_PUSHJ_2: howto manager. (line 1220) 9761 * BFD_RELOC_MMIX_PUSHJ_3: howto manager. (line 1221) 9762 * BFD_RELOC_MMIX_PUSHJ_STUBBABLE: howto manager. (line 1222) 9763 * BFD_RELOC_MMIX_REG: howto manager. (line 1243) 9764 * BFD_RELOC_MMIX_REG_OR_BYTE: howto manager. (line 1239) 9765 * BFD_RELOC_MN10300_16_PCREL: howto manager. (line 1135) 9766 * BFD_RELOC_MN10300_32_PCREL: howto manager. (line 1131) 9767 * BFD_RELOC_MN10300_COPY: howto manager. (line 421) 9768 * BFD_RELOC_MN10300_GLOB_DAT: howto manager. (line 424) 9769 * BFD_RELOC_MN10300_GOT16: howto manager. (line 417) 9770 * BFD_RELOC_MN10300_GOT24: howto manager. (line 413) 9771 * BFD_RELOC_MN10300_GOT32: howto manager. (line 409) 9772 * BFD_RELOC_MN10300_GOTOFF24: howto manager. (line 406) 9773 * BFD_RELOC_MN10300_JMP_SLOT: howto manager. (line 427) 9774 * BFD_RELOC_MN10300_RELATIVE: howto manager. (line 430) 9775 * BFD_RELOC_MSP430_10_PCREL: howto manager. (line 1814) 9776 * BFD_RELOC_MSP430_16: howto manager. (line 1816) 9777 * BFD_RELOC_MSP430_16_BYTE: howto manager. (line 1818) 9778 * BFD_RELOC_MSP430_16_PCREL: howto manager. (line 1815) 9779 * BFD_RELOC_MSP430_16_PCREL_BYTE: howto manager. (line 1817) 9780 * BFD_RELOC_MSP430_2X_PCREL: howto manager. (line 1819) 9781 * BFD_RELOC_MSP430_RL_PCREL: howto manager. (line 1820) 9782 * BFD_RELOC_MT_GNU_VTENTRY: howto manager. (line 1808) 9783 * BFD_RELOC_MT_GNU_VTINHERIT: howto manager. (line 1805) 9784 * BFD_RELOC_MT_HI16: howto manager. (line 1799) 9785 * BFD_RELOC_MT_LO16: howto manager. (line 1802) 9786 * BFD_RELOC_MT_PC16: howto manager. (line 1796) 9787 * BFD_RELOC_MT_PCINSN8: howto manager. (line 1811) 9788 * BFD_RELOC_NONE: howto manager. (line 116) 9789 * BFD_RELOC_NS32K_DISP_16: howto manager. (line 493) 9790 * BFD_RELOC_NS32K_DISP_16_PCREL: howto manager. (line 496) 9791 * BFD_RELOC_NS32K_DISP_32: howto manager. (line 494) 9792 * BFD_RELOC_NS32K_DISP_32_PCREL: howto manager. (line 497) 9793 * BFD_RELOC_NS32K_DISP_8: howto manager. (line 492) 9794 * BFD_RELOC_NS32K_DISP_8_PCREL: howto manager. (line 495) 9795 * BFD_RELOC_NS32K_IMM_16: howto manager. (line 487) 9796 * BFD_RELOC_NS32K_IMM_16_PCREL: howto manager. (line 490) 9797 * BFD_RELOC_NS32K_IMM_32: howto manager. (line 488) 9798 * BFD_RELOC_NS32K_IMM_32_PCREL: howto manager. (line 491) 9799 * BFD_RELOC_NS32K_IMM_8: howto manager. (line 486) 9800 * BFD_RELOC_NS32K_IMM_8_PCREL: howto manager. (line 489) 9801 * BFD_RELOC_OPENRISC_ABS_26: howto manager. (line 1768) 9802 * BFD_RELOC_OPENRISC_REL_26: howto manager. (line 1769) 9803 * BFD_RELOC_PDP11_DISP_6_PCREL: howto manager. (line 501) 9804 * BFD_RELOC_PDP11_DISP_8_PCREL: howto manager. (line 500) 9805 * BFD_RELOC_PJ_CODE_DIR16: howto manager. (line 506) 9806 * BFD_RELOC_PJ_CODE_DIR32: howto manager. (line 507) 9807 * BFD_RELOC_PJ_CODE_HI16: howto manager. (line 504) 9808 * BFD_RELOC_PJ_CODE_LO16: howto manager. (line 505) 9809 * BFD_RELOC_PJ_CODE_REL16: howto manager. (line 508) 9810 * BFD_RELOC_PJ_CODE_REL32: howto manager. (line 509) 9811 * BFD_RELOC_PPC64_ADDR16_DS: howto manager. (line 554) 9812 * BFD_RELOC_PPC64_ADDR16_LO_DS: howto manager. (line 555) 9813 * BFD_RELOC_PPC64_DTPREL16_DS: howto manager. (line 601) 9814 * BFD_RELOC_PPC64_DTPREL16_HIGHER: howto manager. (line 603) 9815 * BFD_RELOC_PPC64_DTPREL16_HIGHERA: howto manager. (line 604) 9816 * BFD_RELOC_PPC64_DTPREL16_HIGHEST: howto manager. (line 605) 9817 * BFD_RELOC_PPC64_DTPREL16_HIGHESTA: howto manager. (line 606) 9818 * BFD_RELOC_PPC64_DTPREL16_LO_DS: howto manager. (line 602) 9819 * BFD_RELOC_PPC64_GOT16_DS: howto manager. (line 556) 9820 * BFD_RELOC_PPC64_GOT16_LO_DS: howto manager. (line 557) 9821 * BFD_RELOC_PPC64_HIGHER: howto manager. (line 542) 9822 * BFD_RELOC_PPC64_HIGHER_S: howto manager. (line 543) 9823 * BFD_RELOC_PPC64_HIGHEST: howto manager. (line 544) 9824 * BFD_RELOC_PPC64_HIGHEST_S: howto manager. (line 545) 9825 * BFD_RELOC_PPC64_PLT16_LO_DS: howto manager. (line 558) 9826 * BFD_RELOC_PPC64_PLTGOT16: howto manager. (line 550) 9827 * BFD_RELOC_PPC64_PLTGOT16_DS: howto manager. (line 563) 9828 * BFD_RELOC_PPC64_PLTGOT16_HA: howto manager. (line 553) 9829 * BFD_RELOC_PPC64_PLTGOT16_HI: howto manager. (line 552) 9830 * BFD_RELOC_PPC64_PLTGOT16_LO: howto manager. (line 551) 9831 * BFD_RELOC_PPC64_PLTGOT16_LO_DS: howto manager. (line 564) 9832 * BFD_RELOC_PPC64_SECTOFF_DS: howto manager. (line 559) 9833 * BFD_RELOC_PPC64_SECTOFF_LO_DS: howto manager. (line 560) 9834 * BFD_RELOC_PPC64_TOC: howto manager. (line 549) 9835 * BFD_RELOC_PPC64_TOC16_DS: howto manager. (line 561) 9836 * BFD_RELOC_PPC64_TOC16_HA: howto manager. (line 548) 9837 * BFD_RELOC_PPC64_TOC16_HI: howto manager. (line 547) 9838 * BFD_RELOC_PPC64_TOC16_LO: howto manager. (line 546) 9839 * BFD_RELOC_PPC64_TOC16_LO_DS: howto manager. (line 562) 9840 * BFD_RELOC_PPC64_TPREL16_DS: howto manager. (line 595) 9841 * BFD_RELOC_PPC64_TPREL16_HIGHER: howto manager. (line 597) 9842 * BFD_RELOC_PPC64_TPREL16_HIGHERA: howto manager. (line 598) 9843 * BFD_RELOC_PPC64_TPREL16_HIGHEST: howto manager. (line 599) 9844 * BFD_RELOC_PPC64_TPREL16_HIGHESTA: howto manager. (line 600) 9845 * BFD_RELOC_PPC64_TPREL16_LO_DS: howto manager. (line 596) 9846 * BFD_RELOC_PPC_B16: howto manager. (line 515) 9847 * BFD_RELOC_PPC_B16_BRNTAKEN: howto manager. (line 517) 9848 * BFD_RELOC_PPC_B16_BRTAKEN: howto manager. (line 516) 9849 * BFD_RELOC_PPC_B26: howto manager. (line 512) 9850 * BFD_RELOC_PPC_BA16: howto manager. (line 518) 9851 * BFD_RELOC_PPC_BA16_BRNTAKEN: howto manager. (line 520) 9852 * BFD_RELOC_PPC_BA16_BRTAKEN: howto manager. (line 519) 9853 * BFD_RELOC_PPC_BA26: howto manager. (line 513) 9854 * BFD_RELOC_PPC_COPY: howto manager. (line 521) 9855 * BFD_RELOC_PPC_DTPMOD: howto manager. (line 568) 9856 * BFD_RELOC_PPC_DTPREL: howto manager. (line 578) 9857 * BFD_RELOC_PPC_DTPREL16: howto manager. (line 574) 9858 * BFD_RELOC_PPC_DTPREL16_HA: howto manager. (line 577) 9859 * BFD_RELOC_PPC_DTPREL16_HI: howto manager. (line 576) 9860 * BFD_RELOC_PPC_DTPREL16_LO: howto manager. (line 575) 9861 * BFD_RELOC_PPC_EMB_BIT_FLD: howto manager. (line 540) 9862 * BFD_RELOC_PPC_EMB_MRKREF: howto manager. (line 535) 9863 * BFD_RELOC_PPC_EMB_NADDR16: howto manager. (line 527) 9864 * BFD_RELOC_PPC_EMB_NADDR16_HA: howto manager. (line 530) 9865 * BFD_RELOC_PPC_EMB_NADDR16_HI: howto manager. (line 529) 9866 * BFD_RELOC_PPC_EMB_NADDR16_LO: howto manager. (line 528) 9867 * BFD_RELOC_PPC_EMB_NADDR32: howto manager. (line 526) 9868 * BFD_RELOC_PPC_EMB_RELSDA: howto manager. (line 541) 9869 * BFD_RELOC_PPC_EMB_RELSEC16: howto manager. (line 536) 9870 * BFD_RELOC_PPC_EMB_RELST_HA: howto manager. (line 539) 9871 * BFD_RELOC_PPC_EMB_RELST_HI: howto manager. (line 538) 9872 * BFD_RELOC_PPC_EMB_RELST_LO: howto manager. (line 537) 9873 * BFD_RELOC_PPC_EMB_SDA21: howto manager. (line 534) 9874 * BFD_RELOC_PPC_EMB_SDA2I16: howto manager. (line 532) 9875 * BFD_RELOC_PPC_EMB_SDA2REL: howto manager. (line 533) 9876 * BFD_RELOC_PPC_EMB_SDAI16: howto manager. (line 531) 9877 * BFD_RELOC_PPC_GLOB_DAT: howto manager. (line 522) 9878 * BFD_RELOC_PPC_GOT_DTPREL16: howto manager. (line 591) 9879 * BFD_RELOC_PPC_GOT_DTPREL16_HA: howto manager. (line 594) 9880 * BFD_RELOC_PPC_GOT_DTPREL16_HI: howto manager. (line 593) 9881 * BFD_RELOC_PPC_GOT_DTPREL16_LO: howto manager. (line 592) 9882 * BFD_RELOC_PPC_GOT_TLSGD16: howto manager. (line 579) 9883 * BFD_RELOC_PPC_GOT_TLSGD16_HA: howto manager. (line 582) 9884 * BFD_RELOC_PPC_GOT_TLSGD16_HI: howto manager. (line 581) 9885 * BFD_RELOC_PPC_GOT_TLSGD16_LO: howto manager. (line 580) 9886 * BFD_RELOC_PPC_GOT_TLSLD16: howto manager. (line 583) 9887 * BFD_RELOC_PPC_GOT_TLSLD16_HA: howto manager. (line 586) 9888 * BFD_RELOC_PPC_GOT_TLSLD16_HI: howto manager. (line 585) 9889 * BFD_RELOC_PPC_GOT_TLSLD16_LO: howto manager. (line 584) 9890 * BFD_RELOC_PPC_GOT_TPREL16: howto manager. (line 587) 9891 * BFD_RELOC_PPC_GOT_TPREL16_HA: howto manager. (line 590) 9892 * BFD_RELOC_PPC_GOT_TPREL16_HI: howto manager. (line 589) 9893 * BFD_RELOC_PPC_GOT_TPREL16_LO: howto manager. (line 588) 9894 * BFD_RELOC_PPC_JMP_SLOT: howto manager. (line 523) 9895 * BFD_RELOC_PPC_LOCAL24PC: howto manager. (line 525) 9896 * BFD_RELOC_PPC_RELATIVE: howto manager. (line 524) 9897 * BFD_RELOC_PPC_TLS: howto manager. (line 567) 9898 * BFD_RELOC_PPC_TOC16: howto manager. (line 514) 9899 * BFD_RELOC_PPC_TPREL: howto manager. (line 573) 9900 * BFD_RELOC_PPC_TPREL16: howto manager. (line 569) 9901 * BFD_RELOC_PPC_TPREL16_HA: howto manager. (line 572) 9902 * BFD_RELOC_PPC_TPREL16_HI: howto manager. (line 571) 9903 * BFD_RELOC_PPC_TPREL16_LO: howto manager. (line 570) 9904 * BFD_RELOC_RVA: howto manager. (line 85) 9905 * BFD_RELOC_SH_ALIGN: howto manager. (line 745) 9906 * BFD_RELOC_SH_CODE: howto manager. (line 746) 9907 * BFD_RELOC_SH_COPY: howto manager. (line 751) 9908 * BFD_RELOC_SH_COPY64: howto manager. (line 776) 9909 * BFD_RELOC_SH_COUNT: howto manager. (line 744) 9910 * BFD_RELOC_SH_DATA: howto manager. (line 747) 9911 * BFD_RELOC_SH_DISP12: howto manager. (line 727) 9912 * BFD_RELOC_SH_DISP12BY2: howto manager. (line 728) 9913 * BFD_RELOC_SH_DISP12BY4: howto manager. (line 729) 9914 * BFD_RELOC_SH_DISP12BY8: howto manager. (line 730) 9915 * BFD_RELOC_SH_DISP20: howto manager. (line 731) 9916 * BFD_RELOC_SH_DISP20BY8: howto manager. (line 732) 9917 * BFD_RELOC_SH_GLOB_DAT: howto manager. (line 752) 9918 * BFD_RELOC_SH_GLOB_DAT64: howto manager. (line 777) 9919 * BFD_RELOC_SH_GOT10BY4: howto manager. (line 780) 9920 * BFD_RELOC_SH_GOT10BY8: howto manager. (line 781) 9921 * BFD_RELOC_SH_GOT_HI16: howto manager. (line 759) 9922 * BFD_RELOC_SH_GOT_LOW16: howto manager. (line 756) 9923 * BFD_RELOC_SH_GOT_MEDHI16: howto manager. (line 758) 9924 * BFD_RELOC_SH_GOT_MEDLOW16: howto manager. (line 757) 9925 * BFD_RELOC_SH_GOTOFF_HI16: howto manager. (line 771) 9926 * BFD_RELOC_SH_GOTOFF_LOW16: howto manager. (line 768) 9927 * BFD_RELOC_SH_GOTOFF_MEDHI16: howto manager. (line 770) 9928 * BFD_RELOC_SH_GOTOFF_MEDLOW16: howto manager. (line 769) 9929 * BFD_RELOC_SH_GOTPC: howto manager. (line 755) 9930 * BFD_RELOC_SH_GOTPC_HI16: howto manager. (line 775) 9931 * BFD_RELOC_SH_GOTPC_LOW16: howto manager. (line 772) 9932 * BFD_RELOC_SH_GOTPC_MEDHI16: howto manager. (line 774) 9933 * BFD_RELOC_SH_GOTPC_MEDLOW16: howto manager. (line 773) 9934 * BFD_RELOC_SH_GOTPLT10BY4: howto manager. (line 782) 9935 * BFD_RELOC_SH_GOTPLT10BY8: howto manager. (line 783) 9936 * BFD_RELOC_SH_GOTPLT32: howto manager. (line 784) 9937 * BFD_RELOC_SH_GOTPLT_HI16: howto manager. (line 763) 9938 * BFD_RELOC_SH_GOTPLT_LOW16: howto manager. (line 760) 9939 * BFD_RELOC_SH_GOTPLT_MEDHI16: howto manager. (line 762) 9940 * BFD_RELOC_SH_GOTPLT_MEDLOW16: howto manager. (line 761) 9941 * BFD_RELOC_SH_IMM3: howto manager. (line 725) 9942 * BFD_RELOC_SH_IMM3U: howto manager. (line 726) 9943 * BFD_RELOC_SH_IMM4: howto manager. (line 733) 9944 * BFD_RELOC_SH_IMM4BY2: howto manager. (line 734) 9945 * BFD_RELOC_SH_IMM4BY4: howto manager. (line 735) 9946 * BFD_RELOC_SH_IMM8: howto manager. (line 736) 9947 * BFD_RELOC_SH_IMM8BY2: howto manager. (line 737) 9948 * BFD_RELOC_SH_IMM8BY4: howto manager. (line 738) 9949 * BFD_RELOC_SH_IMM_HI16: howto manager. (line 802) 9950 * BFD_RELOC_SH_IMM_HI16_PCREL: howto manager. (line 803) 9951 * BFD_RELOC_SH_IMM_LOW16: howto manager. (line 796) 9952 * BFD_RELOC_SH_IMM_LOW16_PCREL: howto manager. (line 797) 9953 * BFD_RELOC_SH_IMM_MEDHI16: howto manager. (line 800) 9954 * BFD_RELOC_SH_IMM_MEDHI16_PCREL: howto manager. (line 801) 9955 * BFD_RELOC_SH_IMM_MEDLOW16: howto manager. (line 798) 9956 * BFD_RELOC_SH_IMM_MEDLOW16_PCREL: howto manager. (line 799) 9957 * BFD_RELOC_SH_IMMS10: howto manager. (line 790) 9958 * BFD_RELOC_SH_IMMS10BY2: howto manager. (line 791) 9959 * BFD_RELOC_SH_IMMS10BY4: howto manager. (line 792) 9960 * BFD_RELOC_SH_IMMS10BY8: howto manager. (line 793) 9961 * BFD_RELOC_SH_IMMS16: howto manager. (line 794) 9962 * BFD_RELOC_SH_IMMS6: howto manager. (line 787) 9963 * BFD_RELOC_SH_IMMS6BY32: howto manager. (line 788) 9964 * BFD_RELOC_SH_IMMU16: howto manager. (line 795) 9965 * BFD_RELOC_SH_IMMU5: howto manager. (line 786) 9966 * BFD_RELOC_SH_IMMU6: howto manager. (line 789) 9967 * BFD_RELOC_SH_JMP_SLOT: howto manager. (line 753) 9968 * BFD_RELOC_SH_JMP_SLOT64: howto manager. (line 778) 9969 * BFD_RELOC_SH_LABEL: howto manager. (line 748) 9970 * BFD_RELOC_SH_LOOP_END: howto manager. (line 750) 9971 * BFD_RELOC_SH_LOOP_START: howto manager. (line 749) 9972 * BFD_RELOC_SH_PCDISP12BY2: howto manager. (line 724) 9973 * BFD_RELOC_SH_PCDISP8BY2: howto manager. (line 723) 9974 * BFD_RELOC_SH_PCRELIMM8BY2: howto manager. (line 739) 9975 * BFD_RELOC_SH_PCRELIMM8BY4: howto manager. (line 740) 9976 * BFD_RELOC_SH_PLT_HI16: howto manager. (line 767) 9977 * BFD_RELOC_SH_PLT_LOW16: howto manager. (line 764) 9978 * BFD_RELOC_SH_PLT_MEDHI16: howto manager. (line 766) 9979 * BFD_RELOC_SH_PLT_MEDLOW16: howto manager. (line 765) 9980 * BFD_RELOC_SH_PT_16: howto manager. (line 804) 9981 * BFD_RELOC_SH_RELATIVE: howto manager. (line 754) 9982 * BFD_RELOC_SH_RELATIVE64: howto manager. (line 779) 9983 * BFD_RELOC_SH_SHMEDIA_CODE: howto manager. (line 785) 9984 * BFD_RELOC_SH_SWITCH16: howto manager. (line 741) 9985 * BFD_RELOC_SH_SWITCH32: howto manager. (line 742) 9986 * BFD_RELOC_SH_TLS_DTPMOD32: howto manager. (line 810) 9987 * BFD_RELOC_SH_TLS_DTPOFF32: howto manager. (line 811) 9988 * BFD_RELOC_SH_TLS_GD_32: howto manager. (line 805) 9989 * BFD_RELOC_SH_TLS_IE_32: howto manager. (line 808) 9990 * BFD_RELOC_SH_TLS_LD_32: howto manager. (line 806) 9991 * BFD_RELOC_SH_TLS_LDO_32: howto manager. (line 807) 9992 * BFD_RELOC_SH_TLS_LE_32: howto manager. (line 809) 9993 * BFD_RELOC_SH_TLS_TPOFF32: howto manager. (line 812) 9994 * BFD_RELOC_SH_USES: howto manager. (line 743) 9995 * BFD_RELOC_SPARC13: howto manager. (line 119) 9996 * BFD_RELOC_SPARC22: howto manager. (line 118) 9997 * BFD_RELOC_SPARC_10: howto manager. (line 141) 9998 * BFD_RELOC_SPARC_11: howto manager. (line 142) 9999 * BFD_RELOC_SPARC_5: howto manager. (line 154) 10000 * BFD_RELOC_SPARC_6: howto manager. (line 153) 10001 * BFD_RELOC_SPARC_64: howto manager. (line 140) 10002 * BFD_RELOC_SPARC_7: howto manager. (line 152) 10003 * BFD_RELOC_SPARC_BASE13: howto manager. (line 136) 10004 * BFD_RELOC_SPARC_BASE22: howto manager. (line 137) 10005 * BFD_RELOC_SPARC_COPY: howto manager. (line 126) 10006 * BFD_RELOC_SPARC_DISP64: howto manager. (line 155) 10007 * BFD_RELOC_SPARC_GLOB_DAT: howto manager. (line 127) 10008 * BFD_RELOC_SPARC_GOT10: howto manager. (line 120) 10009 * BFD_RELOC_SPARC_GOT13: howto manager. (line 121) 10010 * BFD_RELOC_SPARC_GOT22: howto manager. (line 122) 10011 * BFD_RELOC_SPARC_H44: howto manager. (line 160) 10012 * BFD_RELOC_SPARC_HH22: howto manager. (line 144) 10013 * BFD_RELOC_SPARC_HIX22: howto manager. (line 158) 10014 * BFD_RELOC_SPARC_HM10: howto manager. (line 145) 10015 * BFD_RELOC_SPARC_JMP_SLOT: howto manager. (line 128) 10016 * BFD_RELOC_SPARC_L44: howto manager. (line 162) 10017 * BFD_RELOC_SPARC_LM22: howto manager. (line 146) 10018 * BFD_RELOC_SPARC_LOX10: howto manager. (line 159) 10019 * BFD_RELOC_SPARC_M44: howto manager. (line 161) 10020 * BFD_RELOC_SPARC_OLO10: howto manager. (line 143) 10021 * BFD_RELOC_SPARC_PC10: howto manager. (line 123) 10022 * BFD_RELOC_SPARC_PC22: howto manager. (line 124) 10023 * BFD_RELOC_SPARC_PC_HH22: howto manager. (line 147) 10024 * BFD_RELOC_SPARC_PC_HM10: howto manager. (line 148) 10025 * BFD_RELOC_SPARC_PC_LM22: howto manager. (line 149) 10026 * BFD_RELOC_SPARC_PLT32: howto manager. (line 156) 10027 * BFD_RELOC_SPARC_PLT64: howto manager. (line 157) 10028 * BFD_RELOC_SPARC_REGISTER: howto manager. (line 163) 10029 * BFD_RELOC_SPARC_RELATIVE: howto manager. (line 129) 10030 * BFD_RELOC_SPARC_REV32: howto manager. (line 166) 10031 * BFD_RELOC_SPARC_TLS_DTPMOD32: howto manager. (line 187) 10032 * BFD_RELOC_SPARC_TLS_DTPMOD64: howto manager. (line 188) 10033 * BFD_RELOC_SPARC_TLS_DTPOFF32: howto manager. (line 189) 10034 * BFD_RELOC_SPARC_TLS_DTPOFF64: howto manager. (line 190) 10035 * BFD_RELOC_SPARC_TLS_GD_ADD: howto manager. (line 171) 10036 * BFD_RELOC_SPARC_TLS_GD_CALL: howto manager. (line 172) 10037 * BFD_RELOC_SPARC_TLS_GD_HI22: howto manager. (line 169) 10038 * BFD_RELOC_SPARC_TLS_GD_LO10: howto manager. (line 170) 10039 * BFD_RELOC_SPARC_TLS_IE_ADD: howto manager. (line 184) 10040 * BFD_RELOC_SPARC_TLS_IE_HI22: howto manager. (line 180) 10041 * BFD_RELOC_SPARC_TLS_IE_LD: howto manager. (line 182) 10042 * BFD_RELOC_SPARC_TLS_IE_LDX: howto manager. (line 183) 10043 * BFD_RELOC_SPARC_TLS_IE_LO10: howto manager. (line 181) 10044 * BFD_RELOC_SPARC_TLS_LDM_ADD: howto manager. (line 175) 10045 * BFD_RELOC_SPARC_TLS_LDM_CALL: howto manager. (line 176) 10046 * BFD_RELOC_SPARC_TLS_LDM_HI22: howto manager. (line 173) 10047 * BFD_RELOC_SPARC_TLS_LDM_LO10: howto manager. (line 174) 10048 * BFD_RELOC_SPARC_TLS_LDO_ADD: howto manager. (line 179) 10049 * BFD_RELOC_SPARC_TLS_LDO_HIX22: howto manager. (line 177) 10050 * BFD_RELOC_SPARC_TLS_LDO_LOX10: howto manager. (line 178) 10051 * BFD_RELOC_SPARC_TLS_LE_HIX22: howto manager. (line 185) 10052 * BFD_RELOC_SPARC_TLS_LE_LOX10: howto manager. (line 186) 10053 * BFD_RELOC_SPARC_TLS_TPOFF32: howto manager. (line 191) 10054 * BFD_RELOC_SPARC_TLS_TPOFF64: howto manager. (line 192) 10055 * BFD_RELOC_SPARC_UA16: howto manager. (line 130) 10056 * BFD_RELOC_SPARC_UA32: howto manager. (line 131) 10057 * BFD_RELOC_SPARC_UA64: howto manager. (line 132) 10058 * BFD_RELOC_SPARC_WDISP16: howto manager. (line 150) 10059 * BFD_RELOC_SPARC_WDISP19: howto manager. (line 151) 10060 * BFD_RELOC_SPARC_WDISP22: howto manager. (line 117) 10061 * BFD_RELOC_SPARC_WPLT30: howto manager. (line 125) 10062 * BFD_RELOC_THUMB_PCREL_BLX: howto manager. (line 627) 10063 * BFD_RELOC_THUMB_PCREL_BRANCH12: howto manager. (line 641) 10064 * BFD_RELOC_THUMB_PCREL_BRANCH20: howto manager. (line 642) 10065 * BFD_RELOC_THUMB_PCREL_BRANCH23: howto manager. (line 643) 10066 * BFD_RELOC_THUMB_PCREL_BRANCH25: howto manager. (line 644) 10067 * BFD_RELOC_THUMB_PCREL_BRANCH7: howto manager. (line 639) 10068 * BFD_RELOC_THUMB_PCREL_BRANCH9: howto manager. (line 640) 10069 * BFD_RELOC_TIC30_LDP: howto manager. (line 1139) 10070 * BFD_RELOC_TIC54X_16_OF_23: howto manager. (line 1157) 10071 * BFD_RELOC_TIC54X_23: howto manager. (line 1154) 10072 * BFD_RELOC_TIC54X_MS7_OF_23: howto manager. (line 1162) 10073 * BFD_RELOC_TIC54X_PARTLS7: howto manager. (line 1144) 10074 * BFD_RELOC_TIC54X_PARTMS9: howto manager. (line 1149) 10075 * bfd_reloc_type_lookup: howto manager. (line 1920) 10076 * BFD_RELOC_V850_22_PCREL: howto manager. (line 1066) 10077 * BFD_RELOC_V850_9_PCREL: howto manager. (line 1063) 10078 * BFD_RELOC_V850_ALIGN: howto manager. (line 1124) 10079 * BFD_RELOC_V850_CALLT_16_16_OFFSET: howto manager. (line 1115) 10080 * BFD_RELOC_V850_CALLT_6_7_OFFSET: howto manager. (line 1112) 10081 * BFD_RELOC_V850_LO16_SPLIT_OFFSET: howto manager. (line 1127) 10082 * BFD_RELOC_V850_LONGCALL: howto manager. (line 1118) 10083 * BFD_RELOC_V850_LONGJUMP: howto manager. (line 1121) 10084 * BFD_RELOC_V850_SDA_15_16_OFFSET: howto manager. (line 1072) 10085 * BFD_RELOC_V850_SDA_16_16_OFFSET: howto manager. (line 1069) 10086 * BFD_RELOC_V850_SDA_16_16_SPLIT_OFFSET: howto manager. (line 1104) 10087 * BFD_RELOC_V850_TDA_16_16_OFFSET: howto manager. (line 1094) 10088 * BFD_RELOC_V850_TDA_4_4_OFFSET: howto manager. (line 1101) 10089 * BFD_RELOC_V850_TDA_4_5_OFFSET: howto manager. (line 1097) 10090 * BFD_RELOC_V850_TDA_6_8_OFFSET: howto manager. (line 1083) 10091 * BFD_RELOC_V850_TDA_7_7_OFFSET: howto manager. (line 1091) 10092 * BFD_RELOC_V850_TDA_7_8_OFFSET: howto manager. (line 1087) 10093 * BFD_RELOC_V850_ZDA_15_16_OFFSET: howto manager. (line 1079) 10094 * BFD_RELOC_V850_ZDA_16_16_OFFSET: howto manager. (line 1076) 10095 * BFD_RELOC_V850_ZDA_16_16_SPLIT_OFFSET: howto manager. (line 1108) 10096 * BFD_RELOC_VAX_GLOB_DAT: howto manager. (line 1791) 10097 * BFD_RELOC_VAX_JMP_SLOT: howto manager. (line 1792) 10098 * BFD_RELOC_VAX_RELATIVE: howto manager. (line 1793) 10099 * BFD_RELOC_VPE4KMATH_DATA: howto manager. (line 1482) 10100 * BFD_RELOC_VPE4KMATH_INSN: howto manager. (line 1483) 10101 * BFD_RELOC_VTABLE_ENTRY: howto manager. (line 1487) 10102 * BFD_RELOC_VTABLE_INHERIT: howto manager. (line 1486) 10103 * BFD_RELOC_X86_64_32S: howto manager. (line 465) 10104 * BFD_RELOC_X86_64_COPY: howto manager. (line 460) 10105 * BFD_RELOC_X86_64_DTPMOD64: howto manager. (line 466) 10106 * BFD_RELOC_X86_64_DTPOFF32: howto manager. (line 471) 10107 * BFD_RELOC_X86_64_DTPOFF64: howto manager. (line 467) 10108 * BFD_RELOC_X86_64_GLOB_DAT: howto manager. (line 461) 10109 * BFD_RELOC_X86_64_GOT32: howto manager. (line 458) 10110 * BFD_RELOC_X86_64_GOT64: howto manager. (line 476) 10111 * BFD_RELOC_X86_64_GOTOFF64: howto manager. (line 474) 10112 * BFD_RELOC_X86_64_GOTPC32: howto manager. (line 475) 10113 * BFD_RELOC_X86_64_GOTPC32_TLSDESC: howto manager. (line 481) 10114 * BFD_RELOC_X86_64_GOTPC64: howto manager. (line 478) 10115 * BFD_RELOC_X86_64_GOTPCREL: howto manager. (line 464) 10116 * BFD_RELOC_X86_64_GOTPCREL64: howto manager. (line 477) 10117 * BFD_RELOC_X86_64_GOTPLT64: howto manager. (line 479) 10118 * BFD_RELOC_X86_64_GOTTPOFF: howto manager. (line 472) 10119 * BFD_RELOC_X86_64_JUMP_SLOT: howto manager. (line 462) 10120 * BFD_RELOC_X86_64_PLT32: howto manager. (line 459) 10121 * BFD_RELOC_X86_64_PLTOFF64: howto manager. (line 480) 10122 * BFD_RELOC_X86_64_RELATIVE: howto manager. (line 463) 10123 * BFD_RELOC_X86_64_TLSDESC: howto manager. (line 483) 10124 * BFD_RELOC_X86_64_TLSDESC_CALL: howto manager. (line 482) 10125 * BFD_RELOC_X86_64_TLSGD: howto manager. (line 469) 10126 * BFD_RELOC_X86_64_TLSLD: howto manager. (line 470) 10127 * BFD_RELOC_X86_64_TPOFF32: howto manager. (line 473) 10128 * BFD_RELOC_X86_64_TPOFF64: howto manager. (line 468) 10129 * BFD_RELOC_XC16X_PAG: howto manager. (line 1785) 10130 * BFD_RELOC_XC16X_POF: howto manager. (line 1786) 10131 * BFD_RELOC_XC16X_SEG: howto manager. (line 1787) 10132 * BFD_RELOC_XC16X_SOF: howto manager. (line 1788) 10133 * BFD_RELOC_XSTORMY16_12: howto manager. (line 1780) 10134 * BFD_RELOC_XSTORMY16_24: howto manager. (line 1781) 10135 * BFD_RELOC_XSTORMY16_FPTR16: howto manager. (line 1782) 10136 * BFD_RELOC_XSTORMY16_REL_12: howto manager. (line 1779) 10137 * BFD_RELOC_XTENSA_ASM_EXPAND: howto manager. (line 1897) 10138 * BFD_RELOC_XTENSA_ASM_SIMPLIFY: howto manager. (line 1902) 10139 * BFD_RELOC_XTENSA_DIFF16: howto manager. (line 1844) 10140 * BFD_RELOC_XTENSA_DIFF32: howto manager. (line 1845) 10141 * BFD_RELOC_XTENSA_DIFF8: howto manager. (line 1843) 10142 * BFD_RELOC_XTENSA_GLOB_DAT: howto manager. (line 1833) 10143 * BFD_RELOC_XTENSA_JMP_SLOT: howto manager. (line 1834) 10144 * BFD_RELOC_XTENSA_OP0: howto manager. (line 1891) 10145 * BFD_RELOC_XTENSA_OP1: howto manager. (line 1892) 10146 * BFD_RELOC_XTENSA_OP2: howto manager. (line 1893) 10147 * BFD_RELOC_XTENSA_PLT: howto manager. (line 1838) 10148 * BFD_RELOC_XTENSA_RELATIVE: howto manager. (line 1835) 10149 * BFD_RELOC_XTENSA_RTLD: howto manager. (line 1828) 10150 * BFD_RELOC_XTENSA_SLOT0_ALT: howto manager. (line 1873) 10151 * BFD_RELOC_XTENSA_SLOT0_OP: howto manager. (line 1853) 10152 * BFD_RELOC_XTENSA_SLOT10_ALT: howto manager. (line 1883) 10153 * BFD_RELOC_XTENSA_SLOT10_OP: howto manager. (line 1863) 10154 * BFD_RELOC_XTENSA_SLOT11_ALT: howto manager. (line 1884) 10155 * BFD_RELOC_XTENSA_SLOT11_OP: howto manager. (line 1864) 10156 * BFD_RELOC_XTENSA_SLOT12_ALT: howto manager. (line 1885) 10157 * BFD_RELOC_XTENSA_SLOT12_OP: howto manager. (line 1865) 10158 * BFD_RELOC_XTENSA_SLOT13_ALT: howto manager. (line 1886) 10159 * BFD_RELOC_XTENSA_SLOT13_OP: howto manager. (line 1866) 10160 * BFD_RELOC_XTENSA_SLOT14_ALT: howto manager. (line 1887) 10161 * BFD_RELOC_XTENSA_SLOT14_OP: howto manager. (line 1867) 10162 * BFD_RELOC_XTENSA_SLOT1_ALT: howto manager. (line 1874) 10163 * BFD_RELOC_XTENSA_SLOT1_OP: howto manager. (line 1854) 10164 * BFD_RELOC_XTENSA_SLOT2_ALT: howto manager. (line 1875) 10165 * BFD_RELOC_XTENSA_SLOT2_OP: howto manager. (line 1855) 10166 * BFD_RELOC_XTENSA_SLOT3_ALT: howto manager. (line 1876) 10167 * BFD_RELOC_XTENSA_SLOT3_OP: howto manager. (line 1856) 10168 * BFD_RELOC_XTENSA_SLOT4_ALT: howto manager. (line 1877) 10169 * BFD_RELOC_XTENSA_SLOT4_OP: howto manager. (line 1857) 10170 * BFD_RELOC_XTENSA_SLOT5_ALT: howto manager. (line 1878) 10171 * BFD_RELOC_XTENSA_SLOT5_OP: howto manager. (line 1858) 10172 * BFD_RELOC_XTENSA_SLOT6_ALT: howto manager. (line 1879) 10173 * BFD_RELOC_XTENSA_SLOT6_OP: howto manager. (line 1859) 10174 * BFD_RELOC_XTENSA_SLOT7_ALT: howto manager. (line 1880) 10175 * BFD_RELOC_XTENSA_SLOT7_OP: howto manager. (line 1860) 10176 * BFD_RELOC_XTENSA_SLOT8_ALT: howto manager. (line 1881) 10177 * BFD_RELOC_XTENSA_SLOT8_OP: howto manager. (line 1861) 10178 * BFD_RELOC_XTENSA_SLOT9_ALT: howto manager. (line 1882) 10179 * BFD_RELOC_XTENSA_SLOT9_OP: howto manager. (line 1862) 10180 * BFD_RELOC_Z80_DISP8: howto manager. (line 1907) 10181 * BFD_RELOC_Z8K_CALLR: howto manager. (line 1913) 10182 * BFD_RELOC_Z8K_DISP7: howto manager. (line 1910) 10183 * BFD_RELOC_Z8K_IMM4L: howto manager. (line 1916) 10184 * bfd_scan_arch: Architectures. (line 392) 10185 * bfd_scan_vma: BFD front end. (line 423) 10186 * bfd_seach_for_target: bfd_target. (line 459) 10187 * bfd_section_already_linked: Writing the symbol table. 10188 (line 55) 10189 * bfd_section_list_clear: section prototypes. (line 8) 10190 * bfd_sections_find_if: section prototypes. (line 176) 10191 * bfd_set_arch_info: Architectures. (line 433) 10192 * bfd_set_archive_head: Archives. (line 69) 10193 * bfd_set_default_target: bfd_target. (line 424) 10194 * bfd_set_error: BFD front end. (line 235) 10195 * bfd_set_error_handler: BFD front end. (line 275) 10196 * bfd_set_error_program_name: BFD front end. (line 284) 10197 * bfd_set_file_flags: BFD front end. (line 343) 10198 * bfd_set_format: Formats. (line 68) 10199 * bfd_set_gp_size: BFD front end. (line 413) 10200 * bfd_set_private_flags: BFD front end. (line 490) 10201 * bfd_set_reloc: BFD front end. (line 333) 10202 * bfd_set_section_contents: section prototypes. (line 207) 10203 * bfd_set_section_flags: section prototypes. (line 140) 10204 * bfd_set_section_size: section prototypes. (line 193) 10205 * bfd_set_start_address: BFD front end. (line 392) 10206 * bfd_set_symtab: symbol handling functions. 10207 (line 60) 10208 * bfd_symbol_info: symbol handling functions. 10209 (line 130) 10210 * bfd_target_list: bfd_target. (line 450) 10211 * bfd_write_bigendian_4byte_int: Internal. (line 13) 10212 * bfd_zalloc: Opening and Closing. 10213 (line 221) 10214 * bfd_zalloc2: Opening and Closing. 10215 (line 230) 10216 * coff_symbol_type: coff. (line 186) 10217 * core_file_matches_executable_p: Core Files. (line 30) 10218 * find_separate_debug_file: Opening and Closing. 10219 (line 272) 10220 * generic_core_file_matches_executable_p: Core Files. (line 40) 10221 * get_debug_link_info: Opening and Closing. 10222 (line 253) 10223 * Hash tables: Hash Tables. (line 6) 10224 * internal object-file format: Canonical format. (line 11) 10225 * Linker: Linker Functions. (line 6) 10226 * Other functions: BFD front end. (line 505) 10227 * separate_debug_file_exists: Opening and Closing. 10228 (line 263) 10229 * struct bfd_iovec: BFD front end. (line 657) 10230 * target vector (_bfd_final_link): Performing the Final Link. 10231 (line 6) 10232 * target vector (_bfd_link_add_symbols): Adding Symbols to the Hash Table. 10233 (line 6) 10234 * target vector (_bfd_link_hash_table_create): Creating a Linker Hash Table. 10235 (line 6) 10236 * The HOWTO Macro: typedef arelent. (line 291) 10237 * what is it?: Overview. (line 6) 10238 10239 10240 10241 Tag Table: 10242 Node: Top754 10243 Node: Overview1086 10244 Node: History2137 10245 Node: How It Works3083 10246 Node: What BFD Version 2 Can Do4625 10247 Node: BFD information loss5940 10248 Node: Canonical format8472 10249 Node: BFD front end12844 10250 Node: Memory Usage38458 10251 Node: Initialization39686 10252 Node: Sections40145 10253 Node: Section Input40628 10254 Node: Section Output41993 10255 Node: typedef asection44479 10256 Node: section prototypes69436 10257 Node: Symbols79116 10258 Node: Reading Symbols80711 10259 Node: Writing Symbols81818 10260 Node: Mini Symbols83527 10261 Node: typedef asymbol84501 10262 Node: symbol handling functions89419 10263 Node: Archives94761 10264 Node: Formats98487 10265 Node: Relocations101435 10266 Node: typedef arelent102162 10267 Node: howto manager117973 10268 Node: Core Files180253 10269 Node: Targets182070 10270 Node: bfd_target184040 10271 Node: Architectures204120 10272 Node: Opening and Closing225552 10273 Node: Internal236554 10274 Node: File Caching242887 10275 Node: Linker Functions244801 10276 Node: Creating a Linker Hash Table246474 10277 Node: Adding Symbols to the Hash Table248212 10278 Node: Differing file formats249112 10279 Node: Adding symbols from an object file250860 10280 Node: Adding symbols from an archive253011 10281 Node: Performing the Final Link255425 10282 Node: Information provided by the linker256667 10283 Node: Relocating the section contents257821 10284 Node: Writing the symbol table259572 10285 Node: Hash Tables262565 10286 Node: Creating and Freeing a Hash Table263763 10287 Node: Looking Up or Entering a String265013 10288 Node: Traversing a Hash Table266266 10289 Node: Deriving a New Hash Table Type267055 10290 Node: Define the Derived Structures268121 10291 Node: Write the Derived Creation Routine269202 10292 Node: Write Other Derived Routines271826 10293 Node: BFD back ends273141 10294 Node: What to Put Where273411 10295 Node: aout273549 10296 Node: coff279867 10297 Node: elf304344 10298 Node: mmo305207 10299 Node: File layout306135 10300 Node: Symbol-table311782 10301 Node: mmo section mapping315551 10302 Node: GNU Free Documentation License319203 10303 Node: Index338928 10304 10305 End Tag Table 10306
