This is ../.././bfd/doc/bfd.info, produced by makeinfo version 4.8 from ../.././bfd/doc/bfd.texinfo. START-INFO-DIR-ENTRY * Bfd: (bfd). The Binary File Descriptor library. END-INFO-DIR-ENTRY This file documents the BFD library. Copyright (C) 1991, 2000, 2001, 2003 Free Software Foundation, Inc. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.1 or any later version published by the Free Software Foundation; with no Invariant Sections, with no Front-Cover Texts, and with no Back-Cover Texts. A copy of the license is included in the section entitled "GNU Free Documentation License".  File: bfd.info, Node: coff, Next: elf, Prev: aout, Up: BFD back ends 3.2 coff backends ================= BFD supports a number of different flavours of coff format. The major differences between formats are the sizes and alignments of fields in structures on disk, and the occasional extra field. Coff in all its varieties is implemented with a few common files and a number of implementation specific files. For example, The 88k bcs coff format is implemented in the file `coff-m88k.c'. This file `#include's `coff/m88k.h' which defines the external structure of the coff format for the 88k, and `coff/internal.h' which defines the internal structure. `coff-m88k.c' also defines the relocations used by the 88k format *Note Relocations::. The Intel i960 processor version of coff is implemented in `coff-i960.c'. This file has the same structure as `coff-m88k.c', except that it includes `coff/i960.h' rather than `coff-m88k.h'. 3.2.1 Porting to a new version of coff -------------------------------------- The recommended method is to select from the existing implementations the version of coff which is most like the one you want to use. For example, we'll say that i386 coff is the one you select, and that your coff flavour is called foo. Copy `i386coff.c' to `foocoff.c', copy `../include/coff/i386.h' to `../include/coff/foo.h', and add the lines to `targets.c' and `Makefile.in' so that your new back end is used. Alter the shapes of the structures in `../include/coff/foo.h' so that they match what you need. You will probably also have to add `#ifdef's to the code in `coff/internal.h' and `coffcode.h' if your version of coff is too wild. You can verify that your new BFD backend works quite simply by building `objdump' from the `binutils' directory, and making sure that its version of what's going on and your host system's idea (assuming it has the pretty standard coff dump utility, usually called `att-dump' or just `dump') are the same. Then clean up your code, and send what you've done to Cygnus. Then your stuff will be in the next release, and you won't have to keep integrating it. 3.2.2 How the coff backend works -------------------------------- 3.2.2.1 File layout ................... The Coff backend is split into generic routines that are applicable to any Coff target and routines that are specific to a particular target. The target-specific routines are further split into ones which are basically the same for all Coff targets except that they use the external symbol format or use different values for certain constants. The generic routines are in `coffgen.c'. These routines work for any Coff target. They use some hooks into the target specific code; the hooks are in a `bfd_coff_backend_data' structure, one of which exists for each target. The essentially similar target-specific routines are in `coffcode.h'. This header file includes executable C code. The various Coff targets first include the appropriate Coff header file, make any special defines that are needed, and then include `coffcode.h'. Some of the Coff targets then also have additional routines in the target source file itself. For example, `coff-i960.c' includes `coff/internal.h' and `coff/i960.h'. It then defines a few constants, such as `I960', and includes `coffcode.h'. Since the i960 has complex relocation types, `coff-i960.c' also includes some code to manipulate the i960 relocs. This code is not in `coffcode.h' because it would not be used by any other target. 3.2.2.2 Bit twiddling ..................... Each flavour of coff supported in BFD has its own header file describing the external layout of the structures. There is also an internal description of the coff layout, in `coff/internal.h'. A major function of the coff backend is swapping the bytes and twiddling the bits to translate the external form of the structures into the normal internal form. This is all performed in the `bfd_swap'_thing_direction routines. Some elements are different sizes between different versions of coff; it is the duty of the coff version specific include file to override the definitions of various packing routines in `coffcode.h'. E.g., the size of line number entry in coff is sometimes 16 bits, and sometimes 32 bits. `#define'ing `PUT_LNSZ_LNNO' and `GET_LNSZ_LNNO' will select the correct one. No doubt, some day someone will find a version of coff which has a varying field size not catered to at the moment. To port BFD, that person will have to add more `#defines'. Three of the bit twiddling routines are exported to `gdb'; `coff_swap_aux_in', `coff_swap_sym_in' and `coff_swap_lineno_in'. `GDB' reads the symbol table on its own, but uses BFD to fix things up. More of the bit twiddlers are exported for `gas'; `coff_swap_aux_out', `coff_swap_sym_out', `coff_swap_lineno_out', `coff_swap_reloc_out', `coff_swap_filehdr_out', `coff_swap_aouthdr_out', `coff_swap_scnhdr_out'. `Gas' currently keeps track of all the symbol table and reloc drudgery itself, thereby saving the internal BFD overhead, but uses BFD to swap things on the way out, making cross ports much safer. Doing so also allows BFD (and thus the linker) to use the same header files as `gas', which makes one avenue to disaster disappear. 3.2.2.3 Symbol reading ...................... The simple canonical form for symbols used by BFD is not rich enough to keep all the information available in a coff symbol table. The back end gets around this problem by keeping the original symbol table around, "behind the scenes". When a symbol table is requested (through a call to `bfd_canonicalize_symtab'), a request gets through to `coff_get_normalized_symtab'. This reads the symbol table from the coff file and swaps all the structures inside into the internal form. It also fixes up all the pointers in the table (represented in the file by offsets from the first symbol in the table) into physical pointers to elements in the new internal table. This involves some work since the meanings of fields change depending upon context: a field that is a pointer to another structure in the symbol table at one moment may be the size in bytes of a structure at the next. Another pass is made over the table. All symbols which mark file names (`C_FILE' symbols) are modified so that the internal string points to the value in the auxent (the real filename) rather than the normal text associated with the symbol (`".file"'). At this time the symbol names are moved around. Coff stores all symbols less than nine characters long physically within the symbol table; longer strings are kept at the end of the file in the string table. This pass moves all strings into memory and replaces them with pointers to the strings. The symbol table is massaged once again, this time to create the canonical table used by the BFD application. Each symbol is inspected in turn, and a decision made (using the `sclass' field) about the various flags to set in the `asymbol'. *Note Symbols::. The generated canonical table shares strings with the hidden internal symbol table. Any linenumbers are read from the coff file too, and attached to the symbols which own the functions the linenumbers belong to. 3.2.2.4 Symbol writing ...................... Writing a symbol to a coff file which didn't come from a coff file will lose any debugging information. The `asymbol' structure remembers the BFD from which the symbol was taken, and on output the back end makes sure that the same destination target as source target is present. When the symbols have come from a coff file then all the debugging information is preserved. Symbol tables are provided for writing to the back end in a vector of pointers to pointers. This allows applications like the linker to accumulate and output large symbol tables without having to do too much byte copying. This function runs through the provided symbol table and patches each symbol marked as a file place holder (`C_FILE') to point to the next file place holder in the list. It also marks each `offset' field in the list with the offset from the first symbol of the current symbol. Another function of this procedure is to turn the canonical value form of BFD into the form used by coff. Internally, BFD expects symbol values to be offsets from a section base; so a symbol physically at 0x120, but in a section starting at 0x100, would have the value 0x20. Coff expects symbols to contain their final value, so symbols have their values changed at this point to reflect their sum with their owning section. This transformation uses the `output_section' field of the `asymbol''s `asection' *Note Sections::. * `coff_mangle_symbols' This routine runs though the provided symbol table and uses the offsets generated by the previous pass and the pointers generated when the symbol table was read in to create the structured hierarchy required by coff. It changes each pointer to a symbol into the index into the symbol table of the asymbol. * `coff_write_symbols' This routine runs through the symbol table and patches up the symbols from their internal form into the coff way, calls the bit twiddlers, and writes out the table to the file. 3.2.2.5 `coff_symbol_type' .......................... *Description* The hidden information for an `asymbol' is described in a `combined_entry_type': typedef struct coff_ptr_struct { /* Remembers the offset from the first symbol in the file for this symbol. Generated by coff_renumber_symbols. */ unsigned int offset; /* Should the value of this symbol be renumbered. Used for XCOFF C_BSTAT symbols. Set by coff_slurp_symbol_table. */ unsigned int fix_value : 1; /* Should the tag field of this symbol be renumbered. Created by coff_pointerize_aux. */ unsigned int fix_tag : 1; /* Should the endidx field of this symbol be renumbered. Created by coff_pointerize_aux. */ unsigned int fix_end : 1; /* Should the x_csect.x_scnlen field be renumbered. Created by coff_pointerize_aux. */ unsigned int fix_scnlen : 1; /* Fix up an XCOFF C_BINCL/C_EINCL symbol. The value is the index into the line number entries. Set by coff_slurp_symbol_table. */ unsigned int fix_line : 1; /* The container for the symbol structure as read and translated from the file. */ union { union internal_auxent auxent; struct internal_syment syment; } u; } combined_entry_type; /* Each canonical asymbol really looks like this: */ typedef struct coff_symbol_struct { /* The actual symbol which the rest of BFD works with */ asymbol symbol; /* A pointer to the hidden information for this symbol */ combined_entry_type *native; /* A pointer to the linenumber information for this symbol */ struct lineno_cache_entry *lineno; /* Have the line numbers been relocated yet ? */ bfd_boolean done_lineno; } coff_symbol_type; 3.2.2.6 `bfd_coff_backend_data' ............................... /* COFF symbol classifications. */ enum coff_symbol_classification { /* Global symbol. */ COFF_SYMBOL_GLOBAL, /* Common symbol. */ COFF_SYMBOL_COMMON, /* Undefined symbol. */ COFF_SYMBOL_UNDEFINED, /* Local symbol. */ COFF_SYMBOL_LOCAL, /* PE section symbol. */ COFF_SYMBOL_PE_SECTION }; Special entry points for gdb to swap in coff symbol table parts: typedef struct { void (*_bfd_coff_swap_aux_in) (bfd *, void *, int, int, int, int, void *); void (*_bfd_coff_swap_sym_in) (bfd *, void *, void *); void (*_bfd_coff_swap_lineno_in) (bfd *, void *, void *); unsigned int (*_bfd_coff_swap_aux_out) (bfd *, void *, int, int, int, int, void *); unsigned int (*_bfd_coff_swap_sym_out) (bfd *, void *, void *); unsigned int (*_bfd_coff_swap_lineno_out) (bfd *, void *, void *); unsigned int (*_bfd_coff_swap_reloc_out) (bfd *, void *, void *); unsigned int (*_bfd_coff_swap_filehdr_out) (bfd *, void *, void *); unsigned int (*_bfd_coff_swap_aouthdr_out) (bfd *, void *, void *); unsigned int (*_bfd_coff_swap_scnhdr_out) (bfd *, void *, void *); unsigned int _bfd_filhsz; unsigned int _bfd_aoutsz; unsigned int _bfd_scnhsz; unsigned int _bfd_symesz; unsigned int _bfd_auxesz; unsigned int _bfd_relsz; unsigned int _bfd_linesz; unsigned int _bfd_filnmlen; bfd_boolean _bfd_coff_long_filenames; bfd_boolean _bfd_coff_long_section_names; unsigned int _bfd_coff_default_section_alignment_power; bfd_boolean _bfd_coff_force_symnames_in_strings; unsigned int _bfd_coff_debug_string_prefix_length; void (*_bfd_coff_swap_filehdr_in) (bfd *, void *, void *); void (*_bfd_coff_swap_aouthdr_in) (bfd *, void *, void *); void (*_bfd_coff_swap_scnhdr_in) (bfd *, void *, void *); void (*_bfd_coff_swap_reloc_in) (bfd *abfd, void *, void *); bfd_boolean (*_bfd_coff_bad_format_hook) (bfd *, void *); bfd_boolean (*_bfd_coff_set_arch_mach_hook) (bfd *, void *); void * (*_bfd_coff_mkobject_hook) (bfd *, void *, void *); bfd_boolean (*_bfd_styp_to_sec_flags_hook) (bfd *, void *, const char *, asection *, flagword *); void (*_bfd_set_alignment_hook) (bfd *, asection *, void *); bfd_boolean (*_bfd_coff_slurp_symbol_table) (bfd *); bfd_boolean (*_bfd_coff_symname_in_debug) (bfd *, struct internal_syment *); bfd_boolean (*_bfd_coff_pointerize_aux_hook) (bfd *, combined_entry_type *, combined_entry_type *, unsigned int, combined_entry_type *); bfd_boolean (*_bfd_coff_print_aux) (bfd *, FILE *, combined_entry_type *, combined_entry_type *, combined_entry_type *, unsigned int); void (*_bfd_coff_reloc16_extra_cases) (bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *, bfd_byte *, unsigned int *, unsigned int *); int (*_bfd_coff_reloc16_estimate) (bfd *, asection *, arelent *, unsigned int, struct bfd_link_info *); enum coff_symbol_classification (*_bfd_coff_classify_symbol) (bfd *, struct internal_syment *); bfd_boolean (*_bfd_coff_compute_section_file_positions) (bfd *); bfd_boolean (*_bfd_coff_start_final_link) (bfd *, struct bfd_link_info *); bfd_boolean (*_bfd_coff_relocate_section) (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *, struct internal_reloc *, struct internal_syment *, asection **); reloc_howto_type *(*_bfd_coff_rtype_to_howto) (bfd *, asection *, struct internal_reloc *, struct coff_link_hash_entry *, struct internal_syment *, bfd_vma *); bfd_boolean (*_bfd_coff_adjust_symndx) (bfd *, struct bfd_link_info *, bfd *, asection *, struct internal_reloc *, bfd_boolean *); bfd_boolean (*_bfd_coff_link_add_one_symbol) (struct bfd_link_info *, bfd *, const char *, flagword, asection *, bfd_vma, const char *, bfd_boolean, bfd_boolean, struct bfd_link_hash_entry **); bfd_boolean (*_bfd_coff_link_output_has_begun) (bfd *, struct coff_final_link_info *); bfd_boolean (*_bfd_coff_final_link_postscript) (bfd *, struct coff_final_link_info *); } bfd_coff_backend_data; #define coff_backend_info(abfd) \ ((bfd_coff_backend_data *) (abfd)->xvec->backend_data) #define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \ ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i)) #define bfd_coff_swap_sym_in(a,e,i) \ ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i)) #define bfd_coff_swap_lineno_in(a,e,i) \ ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i)) #define bfd_coff_swap_reloc_out(abfd, i, o) \ ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o)) #define bfd_coff_swap_lineno_out(abfd, i, o) \ ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o)) #define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \ ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o)) #define bfd_coff_swap_sym_out(abfd, i,o) \ ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o)) #define bfd_coff_swap_scnhdr_out(abfd, i,o) \ ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o)) #define bfd_coff_swap_filehdr_out(abfd, i,o) \ ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o)) #define bfd_coff_swap_aouthdr_out(abfd, i,o) \ ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o)) #define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz) #define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz) #define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz) #define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz) #define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz) #define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz) #define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz) #define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen) #define bfd_coff_long_filenames(abfd) \ (coff_backend_info (abfd)->_bfd_coff_long_filenames) #define bfd_coff_long_section_names(abfd) \ (coff_backend_info (abfd)->_bfd_coff_long_section_names) #define bfd_coff_default_section_alignment_power(abfd) \ (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power) #define bfd_coff_swap_filehdr_in(abfd, i,o) \ ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o)) #define bfd_coff_swap_aouthdr_in(abfd, i,o) \ ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o)) #define bfd_coff_swap_scnhdr_in(abfd, i,o) \ ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o)) #define bfd_coff_swap_reloc_in(abfd, i, o) \ ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o)) #define bfd_coff_bad_format_hook(abfd, filehdr) \ ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr)) #define bfd_coff_set_arch_mach_hook(abfd, filehdr)\ ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr)) #define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\ ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook)\ (abfd, filehdr, aouthdr)) #define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name, section, flags_ptr)\ ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook)\ (abfd, scnhdr, name, section, flags_ptr)) #define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\ ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr)) #define bfd_coff_slurp_symbol_table(abfd)\ ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd)) #define bfd_coff_symname_in_debug(abfd, sym)\ ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym)) #define bfd_coff_force_symnames_in_strings(abfd)\ (coff_backend_info (abfd)->_bfd_coff_force_symnames_in_strings) #define bfd_coff_debug_string_prefix_length(abfd)\ (coff_backend_info (abfd)->_bfd_coff_debug_string_prefix_length) #define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\ ((coff_backend_info (abfd)->_bfd_coff_print_aux)\ (abfd, file, base, symbol, aux, indaux)) #define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order,\ reloc, data, src_ptr, dst_ptr)\ ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\ (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr)) #define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\ ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\ (abfd, section, reloc, shrink, link_info)) #define bfd_coff_classify_symbol(abfd, sym)\ ((coff_backend_info (abfd)->_bfd_coff_classify_symbol)\ (abfd, sym)) #define bfd_coff_compute_section_file_positions(abfd)\ ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\ (abfd)) #define bfd_coff_start_final_link(obfd, info)\ ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\ (obfd, info)) #define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\ ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\ (obfd, info, ibfd, o, con, rel, isyms, secs)) #define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\ ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\ (abfd, sec, rel, h, sym, addendp)) #define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\ ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\ (obfd, info, ibfd, sec, rel, adjustedp)) #define bfd_coff_link_add_one_symbol(info, abfd, name, flags, section,\ value, string, cp, coll, hashp)\ ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\ (info, abfd, name, flags, section, value, string, cp, coll, hashp)) #define bfd_coff_link_output_has_begun(a,p) \ ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a, p)) #define bfd_coff_final_link_postscript(a,p) \ ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a, p)) 3.2.2.7 Writing relocations ........................... To write relocations, the back end steps though the canonical relocation table and create an `internal_reloc'. The symbol index to use is removed from the `offset' field in the symbol table supplied. The address comes directly from the sum of the section base address and the relocation offset; the type is dug directly from the howto field. Then the `internal_reloc' is swapped into the shape of an `external_reloc' and written out to disk. 3.2.2.8 Reading linenumbers ........................... Creating the linenumber table is done by reading in the entire coff linenumber table, and creating another table for internal use. A coff linenumber table is structured so that each function is marked as having a line number of 0. Each line within the function is an offset from the first line in the function. The base of the line number information for the table is stored in the symbol associated with the function. Note: The PE format uses line number 0 for a flag indicating a new source file. The information is copied from the external to the internal table, and each symbol which marks a function is marked by pointing its... How does this work ? 3.2.2.9 Reading relocations ........................... Coff relocations are easily transformed into the internal BFD form (`arelent'). Reading a coff relocation table is done in the following stages: * Read the entire coff relocation table into memory. * Process each relocation in turn; first swap it from the external to the internal form. * Turn the symbol referenced in the relocation's symbol index into a pointer into the canonical symbol table. This table is the same as the one returned by a call to `bfd_canonicalize_symtab'. The back end will call that routine and save the result if a canonicalization hasn't been done. * The reloc index is turned into a pointer to a howto structure, in a back end specific way. For instance, the 386 and 960 use the `r_type' to directly produce an index into a howto table vector; the 88k subtracts a number from the `r_type' field and creates an addend field.  File: bfd.info, Node: elf, Next: mmo, Prev: coff, Up: BFD back ends 3.3 ELF backends ================ BFD support for ELF formats is being worked on. Currently, the best supported back ends are for sparc and i386 (running svr4 or Solaris 2). Documentation of the internals of the support code still needs to be written. The code is changing quickly enough that we haven't bothered yet. 3.3.0.1 `bfd_elf_find_section' .............................. *Synopsis* struct elf_internal_shdr *bfd_elf_find_section (bfd *abfd, char *name); *Description* Helper functions for GDB to locate the string tables. Since BFD hides string tables from callers, GDB needs to use an internal hook to find them. Sun's .stabstr, in particular, isn't even pointed to by the .stab section, so ordinary mechanisms wouldn't work to find it, even if we had some.  File: bfd.info, Node: mmo, Prev: elf, Up: BFD back ends 3.4 mmo backend =============== The mmo object format is used exclusively together with Professor Donald E. Knuth's educational 64-bit processor MMIX. The simulator `mmix' which is available at `http://www-cs-faculty.stanford.edu/~knuth/programs/mmix.tar.gz' understands this format. That package also includes a combined assembler and linker called `mmixal'. The mmo format has no advantages feature-wise compared to e.g. ELF. It is a simple non-relocatable object format with no support for archives or debugging information, except for symbol value information and line numbers (which is not yet implemented in BFD). See `http://www-cs-faculty.stanford.edu/~knuth/mmix.html' for more information about MMIX. The ELF format is used for intermediate object files in the BFD implementation. * Menu: * File layout:: * Symbol-table:: * mmo section mapping::  File: bfd.info, Node: File layout, Next: Symbol-table, Prev: mmo, Up: mmo 3.4.1 File layout ----------------- The mmo file contents is not partitioned into named sections as with e.g. ELF. Memory areas is formed by specifying the location of the data that follows. Only the memory area `0x0000...00' to `0x01ff...ff' is executable, so it is used for code (and constants) and the area `0x2000...00' to `0x20ff...ff' is used for writable data. *Note mmo section mapping::. There is provision for specifying "special data" of 65536 different types. We use type 80 (decimal), arbitrarily chosen the same as the ELF `e_machine' number for MMIX, filling it with section information normally found in ELF objects. *Note mmo section mapping::. Contents is entered as 32-bit words, xor:ed over previous contents, always zero-initialized. A word that starts with the byte `0x98' forms a command called a `lopcode', where the next byte distinguished between the thirteen lopcodes. The two remaining bytes, called the `Y' and `Z' fields, or the `YZ' field (a 16-bit big-endian number), are used for various purposes different for each lopcode. As documented in `http://www-cs-faculty.stanford.edu/~knuth/mmixal-intro.ps.gz', the lopcodes are: `lop_quote' 0x98000001. The next word is contents, regardless of whether it starts with 0x98 or not. `lop_loc' 0x9801YYZZ, where `Z' is 1 or 2. This is a location directive, setting the location for the next data to the next 32-bit word (for Z = 1) or 64-bit word (for Z = 2), plus Y * 2^56. Normally `Y' is 0 for the text segment and 2 for the data segment. `lop_skip' 0x9802YYZZ. Increase the current location by `YZ' bytes. `lop_fixo' 0x9803YYZZ, where `Z' is 1 or 2. Store the current location as 64 bits into the location pointed to by the next 32-bit (Z = 1) or 64-bit (Z = 2) word, plus Y * 2^56. `lop_fixr' 0x9804YYZZ. `YZ' is stored into the current location plus 2 - 4 * YZ. `lop_fixrx' 0x980500ZZ. `Z' is 16 or 24. A value `L' derived from the following 32-bit word are used in a manner similar to `YZ' in lop_fixr: it is xor:ed into the current location minus 4 * L. The first byte of the word is 0 or 1. If it is 1, then L = (LOWEST 24 BITS OF WORD) - 2^Z, if 0, then L = (LOWEST 24 BITS OF WORD). `lop_file' 0x9806YYZZ. `Y' is the file number, `Z' is count of 32-bit words. Set the file number to `Y' and the line counter to 0. The next Z * 4 bytes contain the file name, padded with zeros if the count is not a multiple of four. The same `Y' may occur multiple times, but `Z' must be 0 for all but the first occurrence. `lop_line' 0x9807YYZZ. `YZ' is the line number. Together with lop_file, it forms the source location for the next 32-bit word. Note that for each non-lopcode 32-bit word, line numbers are assumed incremented by one. `lop_spec' 0x9808YYZZ. `YZ' is the type number. Data until the next lopcode other than lop_quote forms special data of type `YZ'. *Note mmo section mapping::. Other types than 80, (or type 80 with a content that does not parse) is stored in sections named `.MMIX.spec_data.N' where N is the `YZ'-type. The flags for such a sections say not to allocate or load the data. The vma is 0. Contents of multiple occurrences of special data N is concatenated to the data of the previous lop_spec Ns. The location in data or code at which the lop_spec occurred is lost. `lop_pre' 0x980901ZZ. The first lopcode in a file. The `Z' field forms the length of header information in 32-bit words, where the first word tells the time in seconds since `00:00:00 GMT Jan 1 1970'. `lop_post' 0x980a00ZZ. Z > 32. This lopcode follows after all content-generating lopcodes in a program. The `Z' field denotes the value of `rG' at the beginning of the program. The following 256 - Z big-endian 64-bit words are loaded into global registers `$G' ... `$255'. `lop_stab' 0x980b0000. The next-to-last lopcode in a program. Must follow immediately after the lop_post lopcode and its data. After this lopcode follows all symbols in a compressed format (*note Symbol-table::). `lop_end' 0x980cYYZZ. The last lopcode in a program. It must follow the lop_stab lopcode and its data. The `YZ' field contains the number of 32-bit words of symbol table information after the preceding lop_stab lopcode. Note that the lopcode "fixups"; `lop_fixr', `lop_fixrx' and `lop_fixo' are not generated by BFD, but are handled. They are generated by `mmixal'. This trivial one-label, one-instruction file: :Main TRAP 1,2,3 can be represented this way in mmo: 0x98090101 - lop_pre, one 32-bit word with timestamp. 0x98010002 - lop_loc, text segment, using a 64-bit address. Note that mmixal does not emit this for the file above. 0x00000000 - Address, high 32 bits. 0x00000000 - Address, low 32 bits. 0x98060002 - lop_file, 2 32-bit words for file-name. 0x74657374 - "test" 0x2e730000 - ".s\0\0" 0x98070001 - lop_line, line 1. 0x00010203 - TRAP 1,2,3 0x980a00ff - lop_post, setting $255 to 0. 0x00000000 0x00000000 0x980b0000 - lop_stab for ":Main" = 0, serial 1. 0x203a4040 *Note Symbol-table::. 0x10404020 0x4d206120 0x69016e00 0x81000000 0x980c0005 - lop_end; symbol table contained five 32-bit words.  File: bfd.info, Node: Symbol-table, Next: mmo section mapping, Prev: File layout, Up: mmo 3.4.2 Symbol table format ------------------------- From mmixal.w (or really, the generated mmixal.tex) in `http://www-cs-faculty.stanford.edu/~knuth/programs/mmix.tar.gz'): "Symbols are stored and retrieved by means of a `ternary search trie', following ideas of Bentley and Sedgewick. (See ACM-SIAM Symp. on Discrete Algorithms `8' (1997), 360-369; R.Sedgewick, `Algorithms in C' (Reading, Mass. Addison-Wesley, 1998), `15.4'.) Each trie node stores a character, and there are branches to subtries for the cases where a given character is less than, equal to, or greater than the character in the trie. There also is a pointer to a symbol table entry if a symbol ends at the current node." So it's a tree encoded as a stream of bytes. The stream of bytes acts on a single virtual global symbol, adding and removing characters and signalling complete symbol points. Here, we read the stream and create symbols at the completion points. First, there's a control byte `m'. If any of the listed bits in `m' is nonzero, we execute what stands at the right, in the listed order: (MMO3_LEFT) 0x40 - Traverse left trie. (Read a new command byte and recurse.) (MMO3_SYMBITS) 0x2f - Read the next byte as a character and store it in the current character position; increment character position. Test the bits of `m': (MMO3_WCHAR) 0x80 - The character is 16-bit (so read another byte, merge into current character. (MMO3_TYPEBITS) 0xf - We have a complete symbol; parse the type, value and serial number and do what should be done with a symbol. The type and length information is in j = (m & 0xf). (MMO3_REGQUAL_BITS) j == 0xf: A register variable. The following byte tells which register. j <= 8: An absolute symbol. Read j bytes as the big-endian number the symbol equals. A j = 2 with two zero bytes denotes an unknown symbol. j > 8: As with j <= 8, but add (0x20 << 56) to the value in the following j - 8 bytes. Then comes the serial number, as a variant of uleb128, but better named ubeb128: Read bytes and shift the previous value left 7 (multiply by 128). Add in the new byte, repeat until a byte has bit 7 set. The serial number is the computed value minus 128. (MMO3_MIDDLE) 0x20 - Traverse middle trie. (Read a new command byte and recurse.) Decrement character position. (MMO3_RIGHT) 0x10 - Traverse right trie. (Read a new command byte and recurse.) Let's look again at the `lop_stab' for the trivial file (*note File layout::). 0x980b0000 - lop_stab for ":Main" = 0, serial 1. 0x203a4040 0x10404020 0x4d206120 0x69016e00 0x81000000 This forms the trivial trie (note that the path between ":" and "M" is redundant): 203a ":" 40 / 40 / 10 \ 40 / 40 / 204d "M" 2061 "a" 2069 "i" 016e "n" is the last character in a full symbol, and with a value represented in one byte. 00 The value is 0. 81 The serial number is 1.  File: bfd.info, Node: mmo section mapping, Prev: Symbol-table, Up: mmo 3.4.3 mmo section mapping ------------------------- The implementation in BFD uses special data type 80 (decimal) to encapsulate and describe named sections, containing e.g. debug information. If needed, any datum in the encapsulation will be quoted using lop_quote. First comes a 32-bit word holding the number of 32-bit words containing the zero-terminated zero-padded segment name. After the name there's a 32-bit word holding flags describing the section type. Then comes a 64-bit big-endian word with the section length (in bytes), then another with the section start address. Depending on the type of section, the contents might follow, zero-padded to 32-bit boundary. For a loadable section (such as data or code), the contents might follow at some later point, not necessarily immediately, as a lop_loc with the same start address as in the section description, followed by the contents. This in effect forms a descriptor that must be emitted before the actual contents. Sections described this way must not overlap. For areas that don't have such descriptors, synthetic sections are formed by BFD. Consecutive contents in the two memory areas `0x0000...00' to `0x01ff...ff' and `0x2000...00' to `0x20ff...ff' are entered in sections named `.text' and `.data' respectively. If an area is not otherwise described, but would together with a neighboring lower area be less than `0x40000000' bytes long, it is joined with the lower area and the gap is zero-filled. For other cases, a new section is formed, named `.MMIX.sec.N'. Here, N is a number, a running count through the mmo file, starting at 0. A loadable section specified as: .section secname,"ax" TETRA 1,2,3,4,-1,-2009 BYTE 80 and linked to address `0x4', is represented by the sequence: 0x98080050 - lop_spec 80 0x00000002 - two 32-bit words for the section name 0x7365636e - "secn" 0x616d6500 - "ame\0" 0x00000033 - flags CODE, READONLY, LOAD, ALLOC 0x00000000 - high 32 bits of section length 0x0000001c - section length is 28 bytes; 6 * 4 + 1 + alignment to 32 bits 0x00000000 - high 32 bits of section address 0x00000004 - section address is 4 0x98010002 - 64 bits with address of following data 0x00000000 - high 32 bits of address 0x00000004 - low 32 bits: data starts at address 4 0x00000001 - 1 0x00000002 - 2 0x00000003 - 3 0x00000004 - 4 0xffffffff - -1 0xfffff827 - -2009 0x50000000 - 80 as a byte, padded with zeros. Note that the lop_spec wrapping does not include the section contents. Compare this to a non-loaded section specified as: .section thirdsec TETRA 200001,100002 BYTE 38,40 This, when linked to address `0x200000000000001c', is represented by: 0x98080050 - lop_spec 80 0x00000002 - two 32-bit words for the section name 0x7365636e - "thir" 0x616d6500 - "dsec" 0x00000010 - flag READONLY 0x00000000 - high 32 bits of section length 0x0000000c - section length is 12 bytes; 2 * 4 + 2 + alignment to 32 bits 0x20000000 - high 32 bits of address 0x0000001c - low 32 bits of address 0x200000000000001c 0x00030d41 - 200001 0x000186a2 - 100002 0x26280000 - 38, 40 as bytes, padded with zeros For the latter example, the section contents must not be loaded in memory, and is therefore specified as part of the special data. The address is usually unimportant but might provide information for e.g. the DWARF 2 debugging format.  File: bfd.info, Node: GNU Free Documentation License, Next: BFD Index, Prev: BFD back ends, Up: Top Appendix A GNU Free Documentation License ***************************************** Version 1.1, March 2000 Copyright (C) 2000, 2003 Free Software Foundation, Inc. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. 0. PREAMBLE The purpose of this License is to make a manual, textbook, or other written document "free" in the sense of freedom: to assure everyone the effective freedom to copy and redistribute it, with or without modifying it, either commercially or noncommercially. Secondarily, this License preserves for the author and publisher a way to get credit for their work, while not being considered responsible for modifications made by others. This License is a kind of "copyleft", which means that derivative works of the document must themselves be free in the same sense. It complements the GNU General Public License, which is a copyleft license designed for free software. We have designed this License in order to use it for manuals for free software, because free software needs free documentation: a free program should come with manuals providing the same freedoms that the software does. But this License is not limited to software manuals; it can be used for any textual work, regardless of subject matter or whether it is published as a printed book. We recommend this License principally for works whose purpose is instruction or reference. 1. APPLICABILITY AND DEFINITIONS This License applies to any manual or other work that contains a notice placed by the copyright holder saying it can be distributed under the terms of this License. The "Document", below, refers to any such manual or work. Any member of the public is a licensee, and is addressed as "you." A "Modified Version" of the Document means any work containing the Document or a portion of it, either copied verbatim, or with modifications and/or translated into another language. A "Secondary Section" is a named appendix or a front-matter section of the Document that deals exclusively with the relationship of the publishers or authors of the Document to the Document's overall subject (or to related matters) and contains nothing that could fall directly within that overall subject. (For example, if the Document is in part a textbook of mathematics, a Secondary Section may not explain any mathematics.) The relationship could be a matter of historical connection with the subject or with related matters, or of legal, commercial, philosophical, ethical or political position regarding them. The "Invariant Sections" are certain Secondary Sections whose titles are designated, as being those of Invariant Sections, in the notice that says that the Document is released under this License. The "Cover Texts" are certain short passages of text that are listed, as Front-Cover Texts or Back-Cover Texts, in the notice that says that the Document is released under this License. A "Transparent" copy of the Document means a machine-readable copy, represented in a format whose specification is available to the general public, whose contents can be viewed and edited directly and straightforwardly with generic text editors or (for images composed of pixels) generic paint programs or (for drawings) some widely available drawing editor, and that is suitable for input to text formatters or for automatic translation to a variety of formats suitable for input to text formatters. A copy made in an otherwise Transparent file format whose markup has been designed to thwart or discourage subsequent modification by readers is not Transparent. A copy that is not "Transparent" is called "Opaque." Examples of suitable formats for Transparent copies include plain ASCII without markup, Texinfo input format, LaTeX input format, SGML or XML using a publicly available DTD, and standard-conforming simple HTML designed for human modification. Opaque formats include PostScript, PDF, proprietary formats that can be read and edited only by proprietary word processors, SGML or XML for which the DTD and/or processing tools are not generally available, and the machine-generated HTML produced by some word processors for output purposes only. The "Title Page" means, for a printed book, the title page itself, plus such following pages as are needed to hold, legibly, the material this License requires to appear in the title page. For works in formats which do not have any title page as such, "Title Page" means the text near the most prominent appearance of the work's title, preceding the beginning of the body of the text. 2. VERBATIM COPYING You may copy and distribute the Document in any medium, either commercially or noncommercially, provided that this License, the copyright notices, and the license notice saying this License applies to the Document are reproduced in all copies, and that you add no other conditions whatsoever to those of this License. You may not use technical measures to obstruct or control the reading or further copying of the copies you make or distribute. However, you may accept compensation in exchange for copies. If you distribute a large enough number of copies you must also follow the conditions in section 3. You may also lend copies, under the same conditions stated above, and you may publicly display copies. 3. COPYING IN QUANTITY If you publish printed copies of the Document numbering more than 100, and the Document's license notice requires Cover Texts, you must enclose the copies in covers that carry, clearly and legibly, all these Cover Texts: Front-Cover Texts on the front cover, and Back-Cover Texts on the back cover. Both covers must also clearly and legibly identify you as the publisher of these copies. The front cover must present the full title with all words of the title equally prominent and visible. You may add other material on the covers in addition. Copying with changes limited to the covers, as long as they preserve the title of the Document and satisfy these conditions, can be treated as verbatim copying in other respects. If the required texts for either cover are too voluminous to fit legibly, you should put the first ones listed (as many as fit reasonably) on the actual cover, and continue the rest onto adjacent pages. If you publish or distribute Opaque copies of the Document numbering more than 100, you must either include a machine-readable Transparent copy along with each Opaque copy, or state in or with each Opaque copy a publicly-accessible computer-network location containing a complete Transparent copy of the Document, free of added material, which the general network-using public has access to download anonymously at no charge using public-standard network protocols. If you use the latter option, you must take reasonably prudent steps, when you begin distribution of Opaque copies in quantity, to ensure that this Transparent copy will remain thus accessible at the stated location until at least one year after the last time you distribute an Opaque copy (directly or through your agents or retailers) of that edition to the public. It is requested, but not required, that you contact the authors of the Document well before redistributing any large number of copies, to give them a chance to provide you with an updated version of the Document. 4. MODIFICATIONS You may copy and distribute a Modified Version of the Document under the conditions of sections 2 and 3 above, provided that you release the Modified Version under precisely this License, with the Modified Version filling the role of the Document, thus licensing distribution and modification of the Modified Version to whoever possesses a copy of it. In addition, you must do these things in the Modified Version: A. Use in the Title Page (and on the covers, if any) a title distinct from that of the Document, and from those of previous versions (which should, if there were any, be listed in the History section of the Document). You may use the same title as a previous version if the original publisher of that version gives permission. B. List on the Title Page, as authors, one or more persons or entities responsible for authorship of the modifications in the Modified Version, together with at least five of the principal authors of the Document (all of its principal authors, if it has less than five). C. State on the Title page the name of the publisher of the Modified Version, as the publisher. D. Preserve all the copyright notices of the Document. E. Add an appropriate copyright notice for your modifications adjacent to the other copyright notices. F. Include, immediately after the copyright notices, a license notice giving the public permission to use the Modified Version under the terms of this License, in the form shown in the Addendum below. G. Preserve in that license notice the full lists of Invariant Sections and required Cover Texts given in the Document's license notice. H. Include an unaltered copy of this License. I. Preserve the section entitled "History", and its title, and add to it an item stating at least the title, year, new authors, and publisher of the Modified Version as given on the Title Page. If there is no section entitled "History" in the Document, create one stating the title, year, authors, and publisher of the Document as given on its Title Page, then add an item describing the Modified Version as stated in the previous sentence. J. Preserve the network location, if any, given in the Document for public access to a Transparent copy of the Document, and likewise the network locations given in the Document for previous versions it was based on. These may be placed in the "History" section. You may omit a network location for a work that was published at least four years before the Document itself, or if the original publisher of the version it refers to gives permission. K. In any section entitled "Acknowledgements" or "Dedications", preserve the section's title, and preserve in the section all the substance and tone of each of the contributor acknowledgements and/or dedications given therein. L. Preserve all the Invariant Sections of the Document, unaltered in their text and in their titles. Section numbers or the equivalent are not considered part of the section titles. M. Delete any section entitled "Endorsements." Such a section may not be included in the Modified Version. N. Do not retitle any existing section as "Endorsements" or to conflict in title with any Invariant Section. If the Modified Version includes new front-matter sections or appendices that qualify as Secondary Sections and contain no material copied from the Document, you may at your option designate some or all of these sections as invariant. To do this, add their titles to the list of Invariant Sections in the Modified Version's license notice. These titles must be distinct from any other section titles. You may add a section entitled "Endorsements", provided it contains nothing but endorsements of your Modified Version by various parties-for example, statements of peer review or that the text has been approved by an organization as the authoritative definition of a standard. You may add a passage of up to five words as a Front-Cover Text, and a passage of up to 25 words as a Back-Cover Text, to the end of the list of Cover Texts in the Modified Version. Only one passage of Front-Cover Text and one of Back-Cover Text may be added by (or through arrangements made by) any one entity. If the Document already includes a cover text for the same cover, previously added by you or by arrangement made by the same entity you are acting on behalf of, you may not add another; but you may replace the old one, on explicit permission from the previous publisher that added the old one. The author(s) and publisher(s) of the Document do not by this License give permission to use their names for publicity for or to assert or imply endorsement of any Modified Version. 5. COMBINING DOCUMENTS You may combine the Document with other documents released under this License, under the terms defined in section 4 above for modified versions, provided that you include in the combination all of the Invariant Sections of all of the original documents, unmodified, and list them all as Invariant Sections of your combined work in its license notice. The combined work need only contain one copy of this License, and multiple identical Invariant Sections may be replaced with a single copy. If there are multiple Invariant Sections with the same name but different contents, make the title of each such section unique by adding at the end of it, in parentheses, the name of the original author or publisher of that section if known, or else a unique number. Make the same adjustment to the section titles in the list of Invariant Sections in the license notice of the combined work. In the combination, you must combine any sections entitled "History" in the various original documents, forming one section entitled "History"; likewise combine any sections entitled "Acknowledgements", and any sections entitled "Dedications." You must delete all sections entitled "Endorsements." 6. COLLECTIONS OF DOCUMENTS You may make a collection consisting of the Document and other documents released under this License, and replace the individual copies of this License in the various documents with a single copy that is included in the collection, provided that you follow the rules of this License for verbatim copying of each of the documents in all other respects. You may extract a single document from such a collection, and distribute it individually under this License, provided you insert a copy of this License into the extracted document, and follow this License in all other respects regarding verbatim copying of that document. 7. AGGREGATION WITH INDEPENDENT WORKS A compilation of the Document or its derivatives with other separate and independent documents or works, in or on a volume of a storage or distribution medium, does not as a whole count as a Modified Version of the Document, provided no compilation copyright is claimed for the compilation. Such a compilation is called an "aggregate", and this License does not apply to the other self-contained works thus compiled with the Document, on account of their being thus compiled, if they are not themselves derivative works of the Document. If the Cover Text requirement of section 3 is applicable to these copies of the Document, then if the Document is less than one quarter of the entire aggregate, the Document's Cover Texts may be placed on covers that surround only the Document within the aggregate. Otherwise they must appear on covers around the whole aggregate. 8. TRANSLATION Translation is considered a kind of modification, so you may distribute translations of the Document under the terms of section 4. Replacing Invariant Sections with translations requires special permission from their copyright holders, but you may include translations of some or all Invariant Sections in addition to the original versions of these Invariant Sections. You may include a translation of this License provided that you also include the original English version of this License. In case of a disagreement between the translation and the original English version of this License, the original English version will prevail. 9. TERMINATION You may not copy, modify, sublicense, or distribute the Document except as expressly provided for under this License. Any other attempt to copy, modify, sublicense or distribute the Document is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 10. FUTURE REVISIONS OF THIS LICENSE The Free Software Foundation may publish new, revised versions of the GNU Free Documentation License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. See http://www.gnu.org/copyleft/. Each version of the License is given a distinguishing version number. If the Document specifies that a particular numbered version of this License "or any later version" applies to it, you have the option of following the terms and conditions either of that specified version or of any later version that has been published (not as a draft) by the Free Software Foundation. If the Document does not specify a version number of this License, you may choose any version ever published (not as a draft) by the Free Software Foundation. ADDENDUM: How to use this License for your documents ==================================================== To use this License in a document you have written, include a copy of the License in the document and put the following copyright and license notices just after the title page: Copyright (C) YEAR YOUR NAME. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.1 or any later version published by the Free Software Foundation; with the Invariant Sections being LIST THEIR TITLES, with the Front-Cover Texts being LIST, and with the Back-Cover Texts being LIST. A copy of the license is included in the section entitled "GNU Free Documentation License." If you have no Invariant Sections, write "with no Invariant Sections" instead of saying which ones are invariant. If you have no Front-Cover Texts, write "no Front-Cover Texts" instead of "Front-Cover Texts being LIST"; likewise for Back-Cover Texts. If your document contains nontrivial examples of program code, we recommend releasing these examples in parallel under your choice of free software license, such as the GNU General Public License, to permit their use in free software.  File: bfd.info, Node: BFD Index, Prev: GNU Free Documentation License, Up: Top BFD Index ********* [index] * Menu: * _bfd_final_link_relocate: Relocating the section contents. (line 22) * _bfd_generic_link_add_archive_symbols: Adding symbols from an archive. (line 12) * _bfd_generic_link_add_one_symbol: Adding symbols from an object file. (line 19) * _bfd_generic_make_empty_symbol: symbol handling functions. (line 92) * _bfd_link_add_symbols in target vector: Adding Symbols to the Hash Table. (line 6) * _bfd_link_final_link in target vector: Performing the Final Link. (line 6) * _bfd_link_hash_table_create in target vector: Creating a Linker Hash Table. (line 6) * _bfd_relocate_contents: Relocating the section contents. (line 22) * aout_SIZE_machine_type: aout. (line 147) * aout_SIZE_mkobject: aout. (line 139) * aout_SIZE_new_section_hook: aout. (line 177) * aout_SIZE_set_arch_mach: aout. (line 164) * aout_SIZE_some_aout_object_p: aout. (line 125) * aout_SIZE_swap_exec_header_in: aout. (line 101) * aout_SIZE_swap_exec_header_out: aout. (line 113) * arelent_chain: typedef arelent. (line 339) * BFD: Overview. (line 6) * BFD canonical format: Canonical format. (line 11) * bfd_alloc: Opening and Closing. (line 203) * bfd_alloc2: Opening and Closing. (line 212) * bfd_alt_mach_code: BFD front end. (line 599) * bfd_arch_bits_per_address: Architectures. (line 476) * bfd_arch_bits_per_byte: Architectures. (line 468) * bfd_arch_get_compatible: Architectures. (line 411) * bfd_arch_list: Architectures. (line 402) * bfd_arch_mach_octets_per_byte: Architectures. (line 545) * BFD_ARELOC_BFIN_ADD: howto manager. (line 897) * BFD_ARELOC_BFIN_ADDR: howto manager. (line 948) * BFD_ARELOC_BFIN_AND: howto manager. (line 918) * BFD_ARELOC_BFIN_COMP: howto manager. (line 939) * BFD_ARELOC_BFIN_CONST: howto manager. (line 894) * BFD_ARELOC_BFIN_DIV: howto manager. (line 906) * BFD_ARELOC_BFIN_HWPAGE: howto manager. (line 945) * BFD_ARELOC_BFIN_LAND: howto manager. (line 927) * BFD_ARELOC_BFIN_LEN: howto manager. (line 933) * BFD_ARELOC_BFIN_LOR: howto manager. (line 930) * BFD_ARELOC_BFIN_LSHIFT: howto manager. (line 912) * BFD_ARELOC_BFIN_MOD: howto manager. (line 909) * BFD_ARELOC_BFIN_MULT: howto manager. (line 903) * BFD_ARELOC_BFIN_NEG: howto manager. (line 936) * BFD_ARELOC_BFIN_OR: howto manager. (line 921) * BFD_ARELOC_BFIN_PAGE: howto manager. (line 942) * BFD_ARELOC_BFIN_PUSH: howto manager. (line 891) * BFD_ARELOC_BFIN_RSHIFT: howto manager. (line 915) * BFD_ARELOC_BFIN_SUB: howto manager. (line 900) * BFD_ARELOC_BFIN_XOR: howto manager. (line 924) * bfd_cache_close: File Caching. (line 26) * bfd_cache_close_all: File Caching. (line 39) * bfd_cache_init: File Caching. (line 18) * bfd_calc_gnu_debuglink_crc32: Opening and Closing. (line 239) * bfd_canonicalize_reloc: BFD front end. (line 318) * bfd_canonicalize_symtab: symbol handling functions. (line 50) * bfd_check_format: Formats. (line 21) * bfd_check_format_matches: Formats. (line 52) * bfd_check_overflow: typedef arelent. (line 351) * bfd_close: Opening and Closing. (line 128) * bfd_close_all_done: Opening and Closing. (line 146) * bfd_coff_backend_data: coff. (line 246) * bfd_copy_private_bfd_data: BFD front end. (line 457) * bfd_copy_private_header_data: BFD front end. (line 439) * bfd_copy_private_section_data: section prototypes. (line 255) * bfd_copy_private_symbol_data: symbol handling functions. (line 140) * bfd_core_file_failing_command: Core Files. (line 12) * bfd_core_file_failing_signal: Core Files. (line 21) * bfd_create: Opening and Closing. (line 165) * bfd_create_gnu_debuglink_section: Opening and Closing. (line 305) * bfd_decode_symclass: symbol handling functions. (line 111) * bfd_default_arch_struct: Architectures. (line 423) * bfd_default_compatible: Architectures. (line 485) * bfd_default_reloc_type_lookup: howto manager. (line 1941) * bfd_default_scan: Architectures. (line 494) * bfd_default_set_arch_mach: Architectures. (line 441) * bfd_elf_find_section: elf. (line 13) * bfd_errmsg: BFD front end. (line 243) * bfd_fdopenr: Opening and Closing. (line 46) * bfd_fill_in_gnu_debuglink_section: Opening and Closing. (line 319) * bfd_find_target: bfd_target. (line 434) * bfd_follow_gnu_debuglink: Opening and Closing. (line 284) * bfd_fopen: Opening and Closing. (line 9) * bfd_format_string: Formats. (line 79) * bfd_generic_discard_group: section prototypes. (line 281) * bfd_generic_gc_sections: howto manager. (line 1972) * bfd_generic_get_relocated_section_contents: howto manager. (line 1992) * bfd_generic_is_group_section: section prototypes. (line 273) * bfd_generic_merge_sections: howto manager. (line 1982) * bfd_generic_relax_section: howto manager. (line 1959) * bfd_get_arch: Architectures. (line 452) * bfd_get_arch_info: Architectures. (line 504) * bfd_get_arch_size: BFD front end. (line 362) * bfd_get_error: BFD front end. (line 226) * bfd_get_error_handler: BFD front end. (line 294) * bfd_get_gp_size: BFD front end. (line 403) * bfd_get_mach: Architectures. (line 460) * bfd_get_mtime: BFD front end. (line 687) * bfd_get_next_mapent: Archives. (line 52) * bfd_get_reloc_code_name: howto manager. (line 1950) * bfd_get_reloc_size: typedef arelent. (line 330) * bfd_get_reloc_upper_bound: BFD front end. (line 308) * bfd_get_section_by_name: section prototypes. (line 17) * bfd_get_section_by_name_if: section prototypes. (line 31) * bfd_get_section_contents: section prototypes. (line 228) * bfd_get_sign_extend_vma: BFD front end. (line 375) * bfd_get_size <1>: Internal. (line 25) * bfd_get_size: BFD front end. (line 696) * bfd_get_symtab_upper_bound: symbol handling functions. (line 6) * bfd_get_unique_section_name: section prototypes. (line 50) * bfd_h_put_size: Internal. (line 97) * bfd_hash_allocate: Creating and Freeing a Hash Table. (line 17) * bfd_hash_lookup: Looking Up or Entering a String. (line 6) * bfd_hash_newfunc: Creating and Freeing a Hash Table. (line 12) * bfd_hash_set_default_size: Creating and Freeing a Hash Table. (line 25) * bfd_hash_table_free: Creating and Freeing a Hash Table. (line 21) * bfd_hash_table_init: Creating and Freeing a Hash Table. (line 6) * bfd_hash_table_init_n: Creating and Freeing a Hash Table. (line 6) * bfd_hash_traverse: Traversing a Hash Table. (line 6) * bfd_init: Initialization. (line 11) * bfd_install_relocation: typedef arelent. (line 392) * bfd_is_local_label: symbol handling functions. (line 17) * bfd_is_local_label_name: symbol handling functions. (line 26) * bfd_is_target_special_symbol: symbol handling functions. (line 38) * bfd_is_undefined_symclass: symbol handling functions. (line 120) * bfd_link_split_section: Writing the symbol table. (line 44) * bfd_log2: Internal. (line 164) * bfd_lookup_arch: Architectures. (line 512) * bfd_make_debug_symbol: symbol handling functions. (line 102) * bfd_make_empty_symbol: symbol handling functions. (line 78) * bfd_make_readable: Opening and Closing. (line 189) * bfd_make_section: section prototypes. (line 129) * bfd_make_section_anyway: section prototypes. (line 100) * bfd_make_section_anyway_with_flags: section prototypes. (line 82) * bfd_make_section_old_way: section prototypes. (line 62) * bfd_make_section_with_flags: section prototypes. (line 116) * bfd_make_writable: Opening and Closing. (line 175) * bfd_malloc_and_get_section: section prototypes. (line 245) * bfd_map_over_sections: section prototypes. (line 155) * bfd_merge_private_bfd_data: BFD front end. (line 473) * bfd_octets_per_byte: Architectures. (line 535) * bfd_open_file: File Caching. (line 52) * bfd_openr: Opening and Closing. (line 30) * bfd_openr_iovec: Opening and Closing. (line 76) * bfd_openr_next_archived_file: Archives. (line 78) * bfd_openstreamr: Opening and Closing. (line 67) * bfd_openw: Opening and Closing. (line 116) * bfd_perform_relocation: typedef arelent. (line 367) * bfd_perror: BFD front end. (line 252) * bfd_preserve_finish: BFD front end. (line 647) * bfd_preserve_restore: BFD front end. (line 637) * bfd_preserve_save: BFD front end. (line 621) * bfd_print_symbol_vandf: symbol handling functions. (line 70) * bfd_printable_arch_mach: Architectures. (line 523) * bfd_printable_name: Architectures. (line 383) * bfd_put_size: Internal. (line 22) * BFD_RELOC_12_PCREL: howto manager. (line 39) * BFD_RELOC_14: howto manager. (line 31) * BFD_RELOC_16: howto manager. (line 30) * BFD_RELOC_16_BASEREL: howto manager. (line 80) * BFD_RELOC_16_GOT_PCREL: howto manager. (line 52) * BFD_RELOC_16_GOTOFF: howto manager. (line 55) * BFD_RELOC_16_PCREL: howto manager. (line 38) * BFD_RELOC_16_PCREL_S2: howto manager. (line 92) * BFD_RELOC_16_PLT_PCREL: howto manager. (line 63) * BFD_RELOC_16_PLTOFF: howto manager. (line 67) * BFD_RELOC_16C_ABS20: howto manager. (line 1665) * BFD_RELOC_16C_ABS20_C: howto manager. (line 1666) * BFD_RELOC_16C_ABS24: howto manager. (line 1667) * BFD_RELOC_16C_ABS24_C: howto manager. (line 1668) * BFD_RELOC_16C_DISP04: howto manager. (line 1645) * BFD_RELOC_16C_DISP04_C: howto manager. (line 1646) * BFD_RELOC_16C_DISP08: howto manager. (line 1647) * BFD_RELOC_16C_DISP08_C: howto manager. (line 1648) * BFD_RELOC_16C_DISP16: howto manager. (line 1649) * BFD_RELOC_16C_DISP16_C: howto manager. (line 1650) * BFD_RELOC_16C_DISP24: howto manager. (line 1651) * BFD_RELOC_16C_DISP24_C: howto manager. (line 1652) * BFD_RELOC_16C_DISP24a: howto manager. (line 1653) * BFD_RELOC_16C_DISP24a_C: howto manager. (line 1654) * BFD_RELOC_16C_IMM04: howto manager. (line 1669) * BFD_RELOC_16C_IMM04_C: howto manager. (line 1670) * BFD_RELOC_16C_IMM16: howto manager. (line 1671) * BFD_RELOC_16C_IMM16_C: howto manager. (line 1672) * BFD_RELOC_16C_IMM20: howto manager. (line 1673) * BFD_RELOC_16C_IMM20_C: howto manager. (line 1674) * BFD_RELOC_16C_IMM24: howto manager. (line 1675) * BFD_RELOC_16C_IMM24_C: howto manager. (line 1676) * BFD_RELOC_16C_IMM32: howto manager. (line 1677) * BFD_RELOC_16C_IMM32_C: howto manager. (line 1678) * BFD_RELOC_16C_NUM08: howto manager. (line 1639) * BFD_RELOC_16C_NUM08_C: howto manager. (line 1640) * BFD_RELOC_16C_NUM16: howto manager. (line 1641) * BFD_RELOC_16C_NUM16_C: howto manager. (line 1642) * BFD_RELOC_16C_NUM32: howto manager. (line 1643) * BFD_RELOC_16C_NUM32_C: howto manager. (line 1644) * BFD_RELOC_16C_REG04: howto manager. (line 1655) * BFD_RELOC_16C_REG04_C: howto manager. (line 1656) * BFD_RELOC_16C_REG04a: howto manager. (line 1657) * BFD_RELOC_16C_REG04a_C: howto manager. (line 1658) * BFD_RELOC_16C_REG14: howto manager. (line 1659) * BFD_RELOC_16C_REG14_C: howto manager. (line 1660) * BFD_RELOC_16C_REG16: howto manager. (line 1661) * BFD_RELOC_16C_REG16_C: howto manager. (line 1662) * BFD_RELOC_16C_REG20: howto manager. (line 1663) * BFD_RELOC_16C_REG20_C: howto manager. (line 1664) * BFD_RELOC_23_PCREL_S2: howto manager. (line 93) * BFD_RELOC_24: howto manager. (line 29) * BFD_RELOC_24_PCREL: howto manager. (line 37) * BFD_RELOC_24_PLT_PCREL: howto manager. (line 62) * BFD_RELOC_26: howto manager. (line 28) * BFD_RELOC_32: howto manager. (line 27) * BFD_RELOC_32_BASEREL: howto manager. (line 79) * BFD_RELOC_32_GOT_PCREL: howto manager. (line 51) * BFD_RELOC_32_GOTOFF: howto manager. (line 54) * BFD_RELOC_32_PCREL: howto manager. (line 36) * BFD_RELOC_32_PCREL_S2: howto manager. (line 91) * BFD_RELOC_32_PLT_PCREL: howto manager. (line 61) * BFD_RELOC_32_PLTOFF: howto manager. (line 66) * BFD_RELOC_32_SECREL: howto manager. (line 48) * BFD_RELOC_386_COPY: howto manager. (line 435) * BFD_RELOC_386_GLOB_DAT: howto manager. (line 436) * BFD_RELOC_386_GOT32: howto manager. (line 433) * BFD_RELOC_386_GOTOFF: howto manager. (line 439) * BFD_RELOC_386_GOTPC: howto manager. (line 440) * BFD_RELOC_386_JUMP_SLOT: howto manager. (line 437) * BFD_RELOC_386_PLT32: howto manager. (line 434) * BFD_RELOC_386_RELATIVE: howto manager. (line 438) * BFD_RELOC_386_TLS_DESC: howto manager. (line 455) * BFD_RELOC_386_TLS_DESC_CALL: howto manager. (line 454) * BFD_RELOC_386_TLS_DTPMOD32: howto manager. (line 450) * BFD_RELOC_386_TLS_DTPOFF32: howto manager. (line 451) * BFD_RELOC_386_TLS_GD: howto manager. (line 445) * BFD_RELOC_386_TLS_GOTDESC: howto manager. (line 453) * BFD_RELOC_386_TLS_GOTIE: howto manager. (line 443) * BFD_RELOC_386_TLS_IE: howto manager. (line 442) * BFD_RELOC_386_TLS_IE_32: howto manager. (line 448) * BFD_RELOC_386_TLS_LDM: howto manager. (line 446) * BFD_RELOC_386_TLS_LDO_32: howto manager. (line 447) * BFD_RELOC_386_TLS_LE: howto manager. (line 444) * BFD_RELOC_386_TLS_LE_32: howto manager. (line 449) * BFD_RELOC_386_TLS_TPOFF: howto manager. (line 441) * BFD_RELOC_386_TLS_TPOFF32: howto manager. (line 452) * BFD_RELOC_390_12: howto manager. (line 1356) * BFD_RELOC_390_20: howto manager. (line 1456) * BFD_RELOC_390_COPY: howto manager. (line 1365) * BFD_RELOC_390_GLOB_DAT: howto manager. (line 1368) * BFD_RELOC_390_GOT12: howto manager. (line 1359) * BFD_RELOC_390_GOT16: howto manager. (line 1380) * BFD_RELOC_390_GOT20: howto manager. (line 1457) * BFD_RELOC_390_GOT64: howto manager. (line 1398) * BFD_RELOC_390_GOTENT: howto manager. (line 1404) * BFD_RELOC_390_GOTOFF64: howto manager. (line 1407) * BFD_RELOC_390_GOTPC: howto manager. (line 1377) * BFD_RELOC_390_GOTPCDBL: howto manager. (line 1395) * BFD_RELOC_390_GOTPLT12: howto manager. (line 1410) * BFD_RELOC_390_GOTPLT16: howto manager. (line 1413) * BFD_RELOC_390_GOTPLT20: howto manager. (line 1458) * BFD_RELOC_390_GOTPLT32: howto manager. (line 1416) * BFD_RELOC_390_GOTPLT64: howto manager. (line 1419) * BFD_RELOC_390_GOTPLTENT: howto manager. (line 1422) * BFD_RELOC_390_JMP_SLOT: howto manager. (line 1371) * BFD_RELOC_390_PC16DBL: howto manager. (line 1383) * BFD_RELOC_390_PC32DBL: howto manager. (line 1389) * BFD_RELOC_390_PLT16DBL: howto manager. (line 1386) * BFD_RELOC_390_PLT32: howto manager. (line 1362) * BFD_RELOC_390_PLT32DBL: howto manager. (line 1392) * BFD_RELOC_390_PLT64: howto manager. (line 1401) * BFD_RELOC_390_PLTOFF16: howto manager. (line 1425) * BFD_RELOC_390_PLTOFF32: howto manager. (line 1428) * BFD_RELOC_390_PLTOFF64: howto manager. (line 1431) * BFD_RELOC_390_RELATIVE: howto manager. (line 1374) * BFD_RELOC_390_TLS_DTPMOD: howto manager. (line 1451) * BFD_RELOC_390_TLS_DTPOFF: howto manager. (line 1452) * BFD_RELOC_390_TLS_GD32: howto manager. (line 1437) * BFD_RELOC_390_TLS_GD64: howto manager. (line 1438) * BFD_RELOC_390_TLS_GDCALL: howto manager. (line 1435) * BFD_RELOC_390_TLS_GOTIE12: howto manager. (line 1439) * BFD_RELOC_390_TLS_GOTIE20: howto manager. (line 1459) * BFD_RELOC_390_TLS_GOTIE32: howto manager. (line 1440) * BFD_RELOC_390_TLS_GOTIE64: howto manager. (line 1441) * BFD_RELOC_390_TLS_IE32: howto manager. (line 1444) * BFD_RELOC_390_TLS_IE64: howto manager. (line 1445) * BFD_RELOC_390_TLS_IEENT: howto manager. (line 1446) * BFD_RELOC_390_TLS_LDCALL: howto manager. (line 1436) * BFD_RELOC_390_TLS_LDM32: howto manager. (line 1442) * BFD_RELOC_390_TLS_LDM64: howto manager. (line 1443) * BFD_RELOC_390_TLS_LDO32: howto manager. (line 1449) * BFD_RELOC_390_TLS_LDO64: howto manager. (line 1450) * BFD_RELOC_390_TLS_LE32: howto manager. (line 1447) * BFD_RELOC_390_TLS_LE64: howto manager. (line 1448) * BFD_RELOC_390_TLS_LOAD: howto manager. (line 1434) * BFD_RELOC_390_TLS_TPOFF: howto manager. (line 1453) * BFD_RELOC_64: howto manager. (line 26) * BFD_RELOC_64_PCREL: howto manager. (line 35) * BFD_RELOC_64_PLT_PCREL: howto manager. (line 60) * BFD_RELOC_64_PLTOFF: howto manager. (line 65) * BFD_RELOC_68K_GLOB_DAT: howto manager. (line 74) * BFD_RELOC_68K_JMP_SLOT: howto manager. (line 75) * BFD_RELOC_68K_RELATIVE: howto manager. (line 76) * BFD_RELOC_8: howto manager. (line 32) * BFD_RELOC_860_COPY: howto manager. (line 1744) * BFD_RELOC_860_GLOB_DAT: howto manager. (line 1745) * BFD_RELOC_860_HAGOT: howto manager. (line 1770) * BFD_RELOC_860_HAGOTOFF: howto manager. (line 1771) * BFD_RELOC_860_HAPC: howto manager. (line 1772) * BFD_RELOC_860_HIGH: howto manager. (line 1773) * BFD_RELOC_860_HIGHADJ: howto manager. (line 1769) * BFD_RELOC_860_HIGOT: howto manager. (line 1774) * BFD_RELOC_860_HIGOTOFF: howto manager. (line 1775) * BFD_RELOC_860_JUMP_SLOT: howto manager. (line 1746) * BFD_RELOC_860_LOGOT0: howto manager. (line 1758) * BFD_RELOC_860_LOGOT1: howto manager. (line 1760) * BFD_RELOC_860_LOGOTOFF0: howto manager. (line 1762) * BFD_RELOC_860_LOGOTOFF1: howto manager. (line 1764) * BFD_RELOC_860_LOGOTOFF2: howto manager. (line 1766) * BFD_RELOC_860_LOGOTOFF3: howto manager. (line 1767) * BFD_RELOC_860_LOPC: howto manager. (line 1768) * BFD_RELOC_860_LOW0: howto manager. (line 1751) * BFD_RELOC_860_LOW1: howto manager. (line 1753) * BFD_RELOC_860_LOW2: howto manager. (line 1755) * BFD_RELOC_860_LOW3: howto manager. (line 1757) * BFD_RELOC_860_PC16: howto manager. (line 1750) * BFD_RELOC_860_PC26: howto manager. (line 1748) * BFD_RELOC_860_PLT26: howto manager. (line 1749) * BFD_RELOC_860_RELATIVE: howto manager. (line 1747) * BFD_RELOC_860_SPGOT0: howto manager. (line 1759) * BFD_RELOC_860_SPGOT1: howto manager. (line 1761) * BFD_RELOC_860_SPGOTOFF0: howto manager. (line 1763) * BFD_RELOC_860_SPGOTOFF1: howto manager. (line 1765) * BFD_RELOC_860_SPLIT0: howto manager. (line 1752) * BFD_RELOC_860_SPLIT1: howto manager. (line 1754) * BFD_RELOC_860_SPLIT2: howto manager. (line 1756) * BFD_RELOC_8_BASEREL: howto manager. (line 84) * BFD_RELOC_8_FFnn: howto manager. (line 88) * BFD_RELOC_8_GOT_PCREL: howto manager. (line 53) * BFD_RELOC_8_GOTOFF: howto manager. (line 59) * BFD_RELOC_8_PCREL: howto manager. (line 40) * BFD_RELOC_8_PLT_PCREL: howto manager. (line 64) * BFD_RELOC_8_PLTOFF: howto manager. (line 71) * BFD_RELOC_ALPHA_BRSGP: howto manager. (line 259) * BFD_RELOC_ALPHA_CODEADDR: howto manager. (line 250) * BFD_RELOC_ALPHA_DTPMOD64: howto manager. (line 266) * BFD_RELOC_ALPHA_DTPREL16: howto manager. (line 271) * BFD_RELOC_ALPHA_DTPREL64: howto manager. (line 268) * BFD_RELOC_ALPHA_DTPREL_HI16: howto manager. (line 269) * BFD_RELOC_ALPHA_DTPREL_LO16: howto manager. (line 270) * BFD_RELOC_ALPHA_ELF_LITERAL: howto manager. (line 215) * BFD_RELOC_ALPHA_GOTDTPREL16: howto manager. (line 267) * BFD_RELOC_ALPHA_GOTTPREL16: howto manager. (line 272) * BFD_RELOC_ALPHA_GPDISP: howto manager. (line 209) * BFD_RELOC_ALPHA_GPDISP_HI16: howto manager. (line 195) * BFD_RELOC_ALPHA_GPDISP_LO16: howto manager. (line 203) * BFD_RELOC_ALPHA_GPREL_HI16: howto manager. (line 254) * BFD_RELOC_ALPHA_GPREL_LO16: howto manager. (line 255) * BFD_RELOC_ALPHA_HINT: howto manager. (line 241) * BFD_RELOC_ALPHA_LINKAGE: howto manager. (line 246) * BFD_RELOC_ALPHA_LITERAL: howto manager. (line 214) * BFD_RELOC_ALPHA_LITUSE: howto manager. (line 216) * BFD_RELOC_ALPHA_TLSGD: howto manager. (line 264) * BFD_RELOC_ALPHA_TLSLDM: howto manager. (line 265) * BFD_RELOC_ALPHA_TPREL16: howto manager. (line 276) * BFD_RELOC_ALPHA_TPREL64: howto manager. (line 273) * BFD_RELOC_ALPHA_TPREL_HI16: howto manager. (line 274) * BFD_RELOC_ALPHA_TPREL_LO16: howto manager. (line 275) * BFD_RELOC_ARC_B22_PCREL: howto manager. (line 826) * BFD_RELOC_ARC_B26: howto manager. (line 831) * BFD_RELOC_ARM_ADR_IMM: howto manager. (line 719) * BFD_RELOC_ARM_ADRL_IMMEDIATE: howto manager. (line 707) * BFD_RELOC_ARM_CP_OFF_IMM: howto manager. (line 715) * BFD_RELOC_ARM_CP_OFF_IMM_S2: howto manager. (line 716) * BFD_RELOC_ARM_GLOB_DAT: howto manager. (line 688) * BFD_RELOC_ARM_GOT32: howto manager. (line 689) * BFD_RELOC_ARM_GOTOFF: howto manager. (line 692) * BFD_RELOC_ARM_GOTPC: howto manager. (line 693) * BFD_RELOC_ARM_HWLITERAL: howto manager. (line 726) * BFD_RELOC_ARM_IMMEDIATE: howto manager. (line 706) * BFD_RELOC_ARM_IN_POOL: howto manager. (line 722) * BFD_RELOC_ARM_JUMP_SLOT: howto manager. (line 687) * BFD_RELOC_ARM_LDR_IMM: howto manager. (line 720) * BFD_RELOC_ARM_LITERAL: howto manager. (line 721) * BFD_RELOC_ARM_MOVT: howto manager. (line 678) * BFD_RELOC_ARM_MOVT_PCREL: howto manager. (line 680) * BFD_RELOC_ARM_MOVW: howto manager. (line 677) * BFD_RELOC_ARM_MOVW_PCREL: howto manager. (line 679) * BFD_RELOC_ARM_MULTI: howto manager. (line 714) * BFD_RELOC_ARM_OFFSET_IMM: howto manager. (line 651) * BFD_RELOC_ARM_OFFSET_IMM8: howto manager. (line 723) * BFD_RELOC_ARM_PCREL_BLX: howto manager. (line 622) * BFD_RELOC_ARM_PCREL_BRANCH: howto manager. (line 618) * BFD_RELOC_ARM_PCREL_CALL: howto manager. (line 632) * BFD_RELOC_ARM_PCREL_JUMP: howto manager. (line 636) * BFD_RELOC_ARM_PLT32: howto manager. (line 690) * BFD_RELOC_ARM_PREL31: howto manager. (line 674) * BFD_RELOC_ARM_RELATIVE: howto manager. (line 691) * BFD_RELOC_ARM_ROSEGREL32: howto manager. (line 663) * BFD_RELOC_ARM_SBREL32: howto manager. (line 666) * BFD_RELOC_ARM_SHIFT_IMM: howto manager. (line 711) * BFD_RELOC_ARM_SMC: howto manager. (line 712) * BFD_RELOC_ARM_SWI: howto manager. (line 713) * BFD_RELOC_ARM_T32_ADD_PC12: howto manager. (line 710) * BFD_RELOC_ARM_T32_CP_OFF_IMM: howto manager. (line 717) * BFD_RELOC_ARM_T32_CP_OFF_IMM_S2: howto manager. (line 718) * BFD_RELOC_ARM_T32_IMM12: howto manager. (line 709) * BFD_RELOC_ARM_T32_IMMEDIATE: howto manager. (line 708) * BFD_RELOC_ARM_T32_OFFSET_IMM: howto manager. (line 725) * BFD_RELOC_ARM_T32_OFFSET_U8: howto manager. (line 724) * BFD_RELOC_ARM_TARGET1: howto manager. (line 659) * BFD_RELOC_ARM_TARGET2: howto manager. (line 669) * BFD_RELOC_ARM_THUMB_ADD: howto manager. (line 727) * BFD_RELOC_ARM_THUMB_IMM: howto manager. (line 728) * BFD_RELOC_ARM_THUMB_MOVT: howto manager. (line 682) * BFD_RELOC_ARM_THUMB_MOVT_PCREL: howto manager. (line 684) * BFD_RELOC_ARM_THUMB_MOVW: howto manager. (line 681) * BFD_RELOC_ARM_THUMB_MOVW_PCREL: howto manager. (line 683) * BFD_RELOC_ARM_THUMB_OFFSET: howto manager. (line 655) * BFD_RELOC_ARM_THUMB_SHIFT: howto manager. (line 729) * BFD_RELOC_ARM_TLS_DTPMOD32: howto manager. (line 700) * BFD_RELOC_ARM_TLS_DTPOFF32: howto manager. (line 699) * BFD_RELOC_ARM_TLS_GD32: howto manager. (line 696) * BFD_RELOC_ARM_TLS_IE32: howto manager. (line 702) * BFD_RELOC_ARM_TLS_LDM32: howto manager. (line 698) * BFD_RELOC_ARM_TLS_LDO32: howto manager. (line 697) * BFD_RELOC_ARM_TLS_LE32: howto manager. (line 703) * BFD_RELOC_ARM_TLS_TPOFF32: howto manager. (line 701) * BFD_RELOC_AVR_13_PCREL: howto manager. (line 1269) * BFD_RELOC_AVR_16_PM: howto manager. (line 1273) * BFD_RELOC_AVR_6: howto manager. (line 1348) * BFD_RELOC_AVR_6_ADIW: howto manager. (line 1352) * BFD_RELOC_AVR_7_PCREL: howto manager. (line 1265) * BFD_RELOC_AVR_CALL: howto manager. (line 1340) * BFD_RELOC_AVR_HH8_LDI: howto manager. (line 1285) * BFD_RELOC_AVR_HH8_LDI_NEG: howto manager. (line 1304) * BFD_RELOC_AVR_HH8_LDI_PM: howto manager. (line 1321) * BFD_RELOC_AVR_HH8_LDI_PM_NEG: howto manager. (line 1335) * BFD_RELOC_AVR_HI8_LDI: howto manager. (line 1281) * BFD_RELOC_AVR_HI8_LDI_NEG: howto manager. (line 1299) * BFD_RELOC_AVR_HI8_LDI_PM: howto manager. (line 1317) * BFD_RELOC_AVR_HI8_LDI_PM_NEG: howto manager. (line 1330) * BFD_RELOC_AVR_LDI: howto manager. (line 1344) * BFD_RELOC_AVR_LO8_LDI: howto manager. (line 1277) * BFD_RELOC_AVR_LO8_LDI_NEG: howto manager. (line 1294) * BFD_RELOC_AVR_LO8_LDI_PM: howto manager. (line 1313) * BFD_RELOC_AVR_LO8_LDI_PM_NEG: howto manager. (line 1326) * BFD_RELOC_AVR_MS8_LDI: howto manager. (line 1290) * BFD_RELOC_AVR_MS8_LDI_NEG: howto manager. (line 1309) * BFD_RELOC_BFIN_10_PCREL: howto manager. (line 851) * BFD_RELOC_BFIN_11_PCREL: howto manager. (line 854) * BFD_RELOC_BFIN_12_PCREL_JUMP: howto manager. (line 857) * BFD_RELOC_BFIN_12_PCREL_JUMP_S: howto manager. (line 860) * BFD_RELOC_BFIN_16_HIGH: howto manager. (line 839) * BFD_RELOC_BFIN_16_IMM: howto manager. (line 836) * BFD_RELOC_BFIN_16_LOW: howto manager. (line 848) * BFD_RELOC_BFIN_24_PCREL_CALL_X: howto manager. (line 863) * BFD_RELOC_BFIN_24_PCREL_JUMP_L: howto manager. (line 866) * BFD_RELOC_BFIN_4_PCREL: howto manager. (line 842) * BFD_RELOC_BFIN_5_PCREL: howto manager. (line 845) * BFD_RELOC_BFIN_FUNCDESC: howto manager. (line 872) * BFD_RELOC_BFIN_FUNCDESC_GOT17M4: howto manager. (line 873) * BFD_RELOC_BFIN_FUNCDESC_GOTHI: howto manager. (line 874) * BFD_RELOC_BFIN_FUNCDESC_GOTLO: howto manager. (line 875) * BFD_RELOC_BFIN_FUNCDESC_GOTOFF17M4: howto manager. (line 877) * BFD_RELOC_BFIN_FUNCDESC_GOTOFFHI: howto manager. (line 878) * BFD_RELOC_BFIN_FUNCDESC_GOTOFFLO: howto manager. (line 879) * BFD_RELOC_BFIN_FUNCDESC_VALUE: howto manager. (line 876) * BFD_RELOC_BFIN_GOT: howto manager. (line 885) * BFD_RELOC_BFIN_GOT17M4: howto manager. (line 869) * BFD_RELOC_BFIN_GOTHI: howto manager. (line 870) * BFD_RELOC_BFIN_GOTLO: howto manager. (line 871) * BFD_RELOC_BFIN_GOTOFF17M4: howto manager. (line 880) * BFD_RELOC_BFIN_GOTOFFHI: howto manager. (line 881) * BFD_RELOC_BFIN_GOTOFFLO: howto manager. (line 882) * BFD_RELOC_BFIN_PLTPC: howto manager. (line 888) * bfd_reloc_code_type: howto manager. (line 10) * BFD_RELOC_CRIS_16_GOT: howto manager. (line 1725) * BFD_RELOC_CRIS_16_GOTPLT: howto manager. (line 1731) * BFD_RELOC_CRIS_32_GOT: howto manager. (line 1722) * BFD_RELOC_CRIS_32_GOTPLT: howto manager. (line 1728) * BFD_RELOC_CRIS_32_GOTREL: howto manager. (line 1734) * BFD_RELOC_CRIS_32_PLT_GOTREL: howto manager. (line 1737) * BFD_RELOC_CRIS_32_PLT_PCREL: howto manager. (line 1740) * BFD_RELOC_CRIS_BDISP8: howto manager. (line 1703) * BFD_RELOC_CRIS_COPY: howto manager. (line 1716) * BFD_RELOC_CRIS_GLOB_DAT: howto manager. (line 1717) * BFD_RELOC_CRIS_JUMP_SLOT: howto manager. (line 1718) * BFD_RELOC_CRIS_LAPCQ_OFFSET: howto manager. (line 1711) * BFD_RELOC_CRIS_RELATIVE: howto manager. (line 1719) * BFD_RELOC_CRIS_SIGNED_16: howto manager. (line 1709) * BFD_RELOC_CRIS_SIGNED_6: howto manager. (line 1705) * BFD_RELOC_CRIS_SIGNED_8: howto manager. (line 1707) * BFD_RELOC_CRIS_UNSIGNED_16: howto manager. (line 1710) * BFD_RELOC_CRIS_UNSIGNED_4: howto manager. (line 1712) * BFD_RELOC_CRIS_UNSIGNED_5: howto manager. (line 1704) * BFD_RELOC_CRIS_UNSIGNED_6: howto manager. (line 1706) * BFD_RELOC_CRIS_UNSIGNED_8: howto manager. (line 1708) * BFD_RELOC_CRX_ABS16: howto manager. (line 1691) * BFD_RELOC_CRX_ABS32: howto manager. (line 1692) * BFD_RELOC_CRX_IMM16: howto manager. (line 1696) * BFD_RELOC_CRX_IMM32: howto manager. (line 1697) * BFD_RELOC_CRX_NUM16: howto manager. (line 1694) * BFD_RELOC_CRX_NUM32: howto manager. (line 1695) * BFD_RELOC_CRX_NUM8: howto manager. (line 1693) * BFD_RELOC_CRX_REGREL12: howto manager. (line 1687) * BFD_RELOC_CRX_REGREL22: howto manager. (line 1688) * BFD_RELOC_CRX_REGREL28: howto manager. (line 1689) * BFD_RELOC_CRX_REGREL32: howto manager. (line 1690) * BFD_RELOC_CRX_REL16: howto manager. (line 1684) * BFD_RELOC_CRX_REL24: howto manager. (line 1685) * BFD_RELOC_CRX_REL32: howto manager. (line 1686) * BFD_RELOC_CRX_REL4: howto manager. (line 1681) * BFD_RELOC_CRX_REL8: howto manager. (line 1682) * BFD_RELOC_CRX_REL8_CMP: howto manager. (line 1683) * BFD_RELOC_CRX_SWITCH16: howto manager. (line 1699) * BFD_RELOC_CRX_SWITCH32: howto manager. (line 1700) * BFD_RELOC_CRX_SWITCH8: howto manager. (line 1698) * BFD_RELOC_CTOR: howto manager. (line 612) * BFD_RELOC_D10V_10_PCREL_L: howto manager. (line 955) * BFD_RELOC_D10V_10_PCREL_R: howto manager. (line 951) * BFD_RELOC_D10V_18: howto manager. (line 960) * BFD_RELOC_D10V_18_PCREL: howto manager. (line 963) * BFD_RELOC_D30V_15: howto manager. (line 978) * BFD_RELOC_D30V_15_PCREL: howto manager. (line 982) * BFD_RELOC_D30V_15_PCREL_R: howto manager. (line 986) * BFD_RELOC_D30V_21: howto manager. (line 991) * BFD_RELOC_D30V_21_PCREL: howto manager. (line 995) * BFD_RELOC_D30V_21_PCREL_R: howto manager. (line 999) * BFD_RELOC_D30V_32: howto manager. (line 1004) * BFD_RELOC_D30V_32_PCREL: howto manager. (line 1007) * BFD_RELOC_D30V_6: howto manager. (line 966) * BFD_RELOC_D30V_9_PCREL: howto manager. (line 969) * BFD_RELOC_D30V_9_PCREL_R: howto manager. (line 973) * BFD_RELOC_DLX_HI16_S: howto manager. (line 1010) * BFD_RELOC_DLX_JMP26: howto manager. (line 1016) * BFD_RELOC_DLX_LO16: howto manager. (line 1013) * BFD_RELOC_FR30_10_IN_8: howto manager. (line 1195) * BFD_RELOC_FR30_12_PCREL: howto manager. (line 1203) * BFD_RELOC_FR30_20: howto manager. (line 1179) * BFD_RELOC_FR30_48: howto manager. (line 1176) * BFD_RELOC_FR30_6_IN_4: howto manager. (line 1183) * BFD_RELOC_FR30_8_IN_8: howto manager. (line 1187) * BFD_RELOC_FR30_9_IN_8: howto manager. (line 1191) * BFD_RELOC_FR30_9_PCREL: howto manager. (line 1199) * BFD_RELOC_FRV_FUNCDESC: howto manager. (line 377) * BFD_RELOC_FRV_FUNCDESC_GOT12: howto manager. (line 378) * BFD_RELOC_FRV_FUNCDESC_GOTHI: howto manager. (line 379) * BFD_RELOC_FRV_FUNCDESC_GOTLO: howto manager. (line 380) * BFD_RELOC_FRV_FUNCDESC_GOTOFF12: howto manager. (line 382) * BFD_RELOC_FRV_FUNCDESC_GOTOFFHI: howto manager. (line 383) * BFD_RELOC_FRV_FUNCDESC_GOTOFFLO: howto manager. (line 384) * BFD_RELOC_FRV_FUNCDESC_VALUE: howto manager. (line 381) * BFD_RELOC_FRV_GETTLSOFF: howto manager. (line 388) * BFD_RELOC_FRV_GETTLSOFF_RELAX: howto manager. (line 401) * BFD_RELOC_FRV_GOT12: howto manager. (line 374) * BFD_RELOC_FRV_GOTHI: howto manager. (line 375) * BFD_RELOC_FRV_GOTLO: howto manager. (line 376) * BFD_RELOC_FRV_GOTOFF12: howto manager. (line 385) * BFD_RELOC_FRV_GOTOFFHI: howto manager. (line 386) * BFD_RELOC_FRV_GOTOFFLO: howto manager. (line 387) * BFD_RELOC_FRV_GOTTLSDESC12: howto manager. (line 390) * BFD_RELOC_FRV_GOTTLSDESCHI: howto manager. (line 391) * BFD_RELOC_FRV_GOTTLSDESCLO: howto manager. (line 392) * BFD_RELOC_FRV_GOTTLSOFF12: howto manager. (line 396) * BFD_RELOC_FRV_GOTTLSOFFHI: howto manager. (line 397) * BFD_RELOC_FRV_GOTTLSOFFLO: howto manager. (line 398) * BFD_RELOC_FRV_GPREL12: howto manager. (line 369) * BFD_RELOC_FRV_GPREL32: howto manager. (line 371) * BFD_RELOC_FRV_GPRELHI: howto manager. (line 372) * BFD_RELOC_FRV_GPRELLO: howto manager. (line 373) * BFD_RELOC_FRV_GPRELU12: howto manager. (line 370) * BFD_RELOC_FRV_HI16: howto manager. (line 368) * BFD_RELOC_FRV_LABEL16: howto manager. (line 365) * BFD_RELOC_FRV_LABEL24: howto manager. (line 366) * BFD_RELOC_FRV_LO16: howto manager. (line 367) * BFD_RELOC_FRV_TLSDESC_RELAX: howto manager. (line 400) * BFD_RELOC_FRV_TLSDESC_VALUE: howto manager. (line 389) * BFD_RELOC_FRV_TLSMOFF: howto manager. (line 403) * BFD_RELOC_FRV_TLSMOFF12: howto manager. (line 393) * BFD_RELOC_FRV_TLSMOFFHI: howto manager. (line 394) * BFD_RELOC_FRV_TLSMOFFLO: howto manager. (line 395) * BFD_RELOC_FRV_TLSOFF: howto manager. (line 399) * BFD_RELOC_FRV_TLSOFF_RELAX: howto manager. (line 402) * BFD_RELOC_GPREL16: howto manager. (line 106) * BFD_RELOC_GPREL32: howto manager. (line 107) * BFD_RELOC_H8_DIR16A8: howto manager. (line 1782) * BFD_RELOC_H8_DIR16R8: howto manager. (line 1783) * BFD_RELOC_H8_DIR24A8: howto manager. (line 1784) * BFD_RELOC_H8_DIR24R8: howto manager. (line 1785) * BFD_RELOC_H8_DIR32A16: howto manager. (line 1786) * BFD_RELOC_HI16: howto manager. (line 289) * BFD_RELOC_HI16_BASEREL: howto manager. (line 82) * BFD_RELOC_HI16_GOTOFF: howto manager. (line 57) * BFD_RELOC_HI16_PCREL: howto manager. (line 301) * BFD_RELOC_HI16_PLTOFF: howto manager. (line 69) * BFD_RELOC_HI16_S: howto manager. (line 292) * BFD_RELOC_HI16_S_BASEREL: howto manager. (line 83) * BFD_RELOC_HI16_S_GOTOFF: howto manager. (line 58) * BFD_RELOC_HI16_S_PCREL: howto manager. (line 304) * BFD_RELOC_HI16_S_PLTOFF: howto manager. (line 70) * BFD_RELOC_HI22: howto manager. (line 101) * BFD_RELOC_I370_D12: howto manager. (line 609) * BFD_RELOC_I960_CALLJ: howto manager. (line 113) * BFD_RELOC_IA64_COPY: howto manager. (line 1575) * BFD_RELOC_IA64_DIR32LSB: howto manager. (line 1520) * BFD_RELOC_IA64_DIR32MSB: howto manager. (line 1519) * BFD_RELOC_IA64_DIR64LSB: howto manager. (line 1522) * BFD_RELOC_IA64_DIR64MSB: howto manager. (line 1521) * BFD_RELOC_IA64_DTPMOD64LSB: howto manager. (line 1585) * BFD_RELOC_IA64_DTPMOD64MSB: howto manager. (line 1584) * BFD_RELOC_IA64_DTPREL14: howto manager. (line 1587) * BFD_RELOC_IA64_DTPREL22: howto manager. (line 1588) * BFD_RELOC_IA64_DTPREL32LSB: howto manager. (line 1591) * BFD_RELOC_IA64_DTPREL32MSB: howto manager. (line 1590) * BFD_RELOC_IA64_DTPREL64I: howto manager. (line 1589) * BFD_RELOC_IA64_DTPREL64LSB: howto manager. (line 1593) * BFD_RELOC_IA64_DTPREL64MSB: howto manager. (line 1592) * BFD_RELOC_IA64_FPTR32LSB: howto manager. (line 1537) * BFD_RELOC_IA64_FPTR32MSB: howto manager. (line 1536) * BFD_RELOC_IA64_FPTR64I: howto manager. (line 1535) * BFD_RELOC_IA64_FPTR64LSB: howto manager. (line 1539) * BFD_RELOC_IA64_FPTR64MSB: howto manager. (line 1538) * BFD_RELOC_IA64_GPREL22: howto manager. (line 1523) * BFD_RELOC_IA64_GPREL32LSB: howto manager. (line 1526) * BFD_RELOC_IA64_GPREL32MSB: howto manager. (line 1525) * BFD_RELOC_IA64_GPREL64I: howto manager. (line 1524) * BFD_RELOC_IA64_GPREL64LSB: howto manager. (line 1528) * BFD_RELOC_IA64_GPREL64MSB: howto manager. (line 1527) * BFD_RELOC_IA64_IMM14: howto manager. (line 1516) * BFD_RELOC_IA64_IMM22: howto manager. (line 1517) * BFD_RELOC_IA64_IMM64: howto manager. (line 1518) * BFD_RELOC_IA64_IPLTLSB: howto manager. (line 1574) * BFD_RELOC_IA64_IPLTMSB: howto manager. (line 1573) * BFD_RELOC_IA64_LDXMOV: howto manager. (line 1577) * BFD_RELOC_IA64_LTOFF22: howto manager. (line 1529) * BFD_RELOC_IA64_LTOFF22X: howto manager. (line 1576) * BFD_RELOC_IA64_LTOFF64I: howto manager. (line 1530) * BFD_RELOC_IA64_LTOFF_DTPMOD22: howto manager. (line 1586) * BFD_RELOC_IA64_LTOFF_DTPREL22: howto manager. (line 1594) * BFD_RELOC_IA64_LTOFF_FPTR22: howto manager. (line 1551) * BFD_RELOC_IA64_LTOFF_FPTR32LSB: howto manager. (line 1554) * BFD_RELOC_IA64_LTOFF_FPTR32MSB: howto manager. (line 1553) * BFD_RELOC_IA64_LTOFF_FPTR64I: howto manager. (line 1552) * BFD_RELOC_IA64_LTOFF_FPTR64LSB: howto manager. (line 1556) * BFD_RELOC_IA64_LTOFF_FPTR64MSB: howto manager. (line 1555) * BFD_RELOC_IA64_LTOFF_TPREL22: howto manager. (line 1583) * BFD_RELOC_IA64_LTV32LSB: howto manager. (line 1570) * BFD_RELOC_IA64_LTV32MSB: howto manager. (line 1569) * BFD_RELOC_IA64_LTV64LSB: howto manager. (line 1572) * BFD_RELOC_IA64_LTV64MSB: howto manager. (line 1571) * BFD_RELOC_IA64_PCREL21B: howto manager. (line 1540) * BFD_RELOC_IA64_PCREL21BI: howto manager. (line 1541) * BFD_RELOC_IA64_PCREL21F: howto manager. (line 1543) * BFD_RELOC_IA64_PCREL21M: howto manager. (line 1542) * BFD_RELOC_IA64_PCREL22: howto manager. (line 1544) * BFD_RELOC_IA64_PCREL32LSB: howto manager. (line 1548) * BFD_RELOC_IA64_PCREL32MSB: howto manager. (line 1547) * BFD_RELOC_IA64_PCREL60B: howto manager. (line 1545) * BFD_RELOC_IA64_PCREL64I: howto manager. (line 1546) * BFD_RELOC_IA64_PCREL64LSB: howto manager. (line 1550) * BFD_RELOC_IA64_PCREL64MSB: howto manager. (line 1549) * BFD_RELOC_IA64_PLTOFF22: howto manager. (line 1531) * BFD_RELOC_IA64_PLTOFF64I: howto manager. (line 1532) * BFD_RELOC_IA64_PLTOFF64LSB: howto manager. (line 1534) * BFD_RELOC_IA64_PLTOFF64MSB: howto manager. (line 1533) * BFD_RELOC_IA64_REL32LSB: howto manager. (line 1566) * BFD_RELOC_IA64_REL32MSB: howto manager. (line 1565) * BFD_RELOC_IA64_REL64LSB: howto manager. (line 1568) * BFD_RELOC_IA64_REL64MSB: howto manager. (line 1567) * BFD_RELOC_IA64_SECREL32LSB: howto manager. (line 1562) * BFD_RELOC_IA64_SECREL32MSB: howto manager. (line 1561) * BFD_RELOC_IA64_SECREL64LSB: howto manager. (line 1564) * BFD_RELOC_IA64_SECREL64MSB: howto manager. (line 1563) * BFD_RELOC_IA64_SEGREL32LSB: howto manager. (line 1558) * BFD_RELOC_IA64_SEGREL32MSB: howto manager. (line 1557) * BFD_RELOC_IA64_SEGREL64LSB: howto manager. (line 1560) * BFD_RELOC_IA64_SEGREL64MSB: howto manager. (line 1559) * BFD_RELOC_IA64_TPREL14: howto manager. (line 1578) * BFD_RELOC_IA64_TPREL22: howto manager. (line 1579) * BFD_RELOC_IA64_TPREL64I: howto manager. (line 1580) * BFD_RELOC_IA64_TPREL64LSB: howto manager. (line 1582) * BFD_RELOC_IA64_TPREL64MSB: howto manager. (line 1581) * BFD_RELOC_IP2K_ADDR16CJP: howto manager. (line 1468) * BFD_RELOC_IP2K_BANK: howto manager. (line 1465) * BFD_RELOC_IP2K_EX8DATA: howto manager. (line 1476) * BFD_RELOC_IP2K_FR9: howto manager. (line 1462) * BFD_RELOC_IP2K_FR_OFFSET: howto manager. (line 1489) * BFD_RELOC_IP2K_HI8DATA: howto manager. (line 1475) * BFD_RELOC_IP2K_HI8INSN: howto manager. (line 1480) * BFD_RELOC_IP2K_LO8DATA: howto manager. (line 1474) * BFD_RELOC_IP2K_LO8INSN: howto manager. (line 1479) * BFD_RELOC_IP2K_PAGE3: howto manager. (line 1471) * BFD_RELOC_IP2K_PC_SKIP: howto manager. (line 1483) * BFD_RELOC_IP2K_TEXT: howto manager. (line 1486) * BFD_RELOC_IQ2000_OFFSET_16: howto manager. (line 1833) * BFD_RELOC_IQ2000_OFFSET_21: howto manager. (line 1834) * BFD_RELOC_IQ2000_UHI16: howto manager. (line 1835) * BFD_RELOC_LO10: howto manager. (line 102) * BFD_RELOC_LO16: howto manager. (line 298) * BFD_RELOC_LO16_BASEREL: howto manager. (line 81) * BFD_RELOC_LO16_GOTOFF: howto manager. (line 56) * BFD_RELOC_LO16_PCREL: howto manager. (line 307) * BFD_RELOC_LO16_PLTOFF: howto manager. (line 68) * BFD_RELOC_M32C_HI8: howto manager. (line 1019) * BFD_RELOC_M32C_RL_1ADDR: howto manager. (line 1021) * BFD_RELOC_M32C_RL_2ADDR: howto manager. (line 1022) * BFD_RELOC_M32C_RL_JUMP: howto manager. (line 1020) * BFD_RELOC_M32R_10_PCREL: howto manager. (line 1029) * BFD_RELOC_M32R_18_PCREL: howto manager. (line 1033) * BFD_RELOC_M32R_24: howto manager. (line 1025) * BFD_RELOC_M32R_26_PCREL: howto manager. (line 1036) * BFD_RELOC_M32R_26_PLTREL: howto manager. (line 1055) * BFD_RELOC_M32R_COPY: howto manager. (line 1056) * BFD_RELOC_M32R_GLOB_DAT: howto manager. (line 1057) * BFD_RELOC_M32R_GOT16_HI_SLO: howto manager. (line 1066) * BFD_RELOC_M32R_GOT16_HI_ULO: howto manager. (line 1065) * BFD_RELOC_M32R_GOT16_LO: howto manager. (line 1067) * BFD_RELOC_M32R_GOT24: howto manager. (line 1054) * BFD_RELOC_M32R_GOTOFF: howto manager. (line 1060) * BFD_RELOC_M32R_GOTOFF_HI_SLO: howto manager. (line 1062) * BFD_RELOC_M32R_GOTOFF_HI_ULO: howto manager. (line 1061) * BFD_RELOC_M32R_GOTOFF_LO: howto manager. (line 1063) * BFD_RELOC_M32R_GOTPC24: howto manager. (line 1064) * BFD_RELOC_M32R_GOTPC_HI_SLO: howto manager. (line 1069) * BFD_RELOC_M32R_GOTPC_HI_ULO: howto manager. (line 1068) * BFD_RELOC_M32R_GOTPC_LO: howto manager. (line 1070) * BFD_RELOC_M32R_HI16_SLO: howto manager. (line 1043) * BFD_RELOC_M32R_HI16_ULO: howto manager. (line 1039) * BFD_RELOC_M32R_JMP_SLOT: howto manager. (line 1058) * BFD_RELOC_M32R_LO16: howto manager. (line 1047) * BFD_RELOC_M32R_RELATIVE: howto manager. (line 1059) * BFD_RELOC_M32R_SDA16: howto manager. (line 1050) * BFD_RELOC_M68HC11_24: howto manager. (line 1630) * BFD_RELOC_M68HC11_3B: howto manager. (line 1605) * BFD_RELOC_M68HC11_HI8: howto manager. (line 1597) * BFD_RELOC_M68HC11_LO16: howto manager. (line 1619) * BFD_RELOC_M68HC11_LO8: howto manager. (line 1601) * BFD_RELOC_M68HC11_PAGE: howto manager. (line 1625) * BFD_RELOC_M68HC11_RL_GROUP: howto manager. (line 1614) * BFD_RELOC_M68HC11_RL_JUMP: howto manager. (line 1608) * BFD_RELOC_M68HC12_5B: howto manager. (line 1636) * BFD_RELOC_MCORE_PCREL_32: howto manager. (line 1210) * BFD_RELOC_MCORE_PCREL_IMM11BY2: howto manager. (line 1208) * BFD_RELOC_MCORE_PCREL_IMM4BY2: howto manager. (line 1209) * BFD_RELOC_MCORE_PCREL_IMM8BY4: howto manager. (line 1207) * BFD_RELOC_MCORE_PCREL_JSR_IMM11BY2: howto manager. (line 1211) * BFD_RELOC_MCORE_RVA: howto manager. (line 1212) * BFD_RELOC_MIPS16_GPREL: howto manager. (line 286) * BFD_RELOC_MIPS16_HI16: howto manager. (line 310) * BFD_RELOC_MIPS16_HI16_S: howto manager. (line 313) * BFD_RELOC_MIPS16_JMP: howto manager. (line 283) * BFD_RELOC_MIPS16_LO16: howto manager. (line 319) * BFD_RELOC_MIPS_CALL16: howto manager. (line 326) * BFD_RELOC_MIPS_CALL_HI16: howto manager. (line 329) * BFD_RELOC_MIPS_CALL_LO16: howto manager. (line 330) * BFD_RELOC_MIPS_COPY: howto manager. (line 361) * BFD_RELOC_MIPS_DELETE: howto manager. (line 339) * BFD_RELOC_MIPS_GOT16: howto manager. (line 325) * BFD_RELOC_MIPS_GOT_DISP: howto manager. (line 334) * BFD_RELOC_MIPS_GOT_HI16: howto manager. (line 327) * BFD_RELOC_MIPS_GOT_LO16: howto manager. (line 328) * BFD_RELOC_MIPS_GOT_OFST: howto manager. (line 333) * BFD_RELOC_MIPS_GOT_PAGE: howto manager. (line 332) * BFD_RELOC_MIPS_HIGHER: howto manager. (line 341) * BFD_RELOC_MIPS_HIGHEST: howto manager. (line 340) * BFD_RELOC_MIPS_INSERT_A: howto manager. (line 337) * BFD_RELOC_MIPS_INSERT_B: howto manager. (line 338) * BFD_RELOC_MIPS_JALR: howto manager. (line 345) * BFD_RELOC_MIPS_JMP: howto manager. (line 279) * BFD_RELOC_MIPS_JUMP_SLOT: howto manager. (line 362) * BFD_RELOC_MIPS_LITERAL: howto manager. (line 322) * BFD_RELOC_MIPS_REL16: howto manager. (line 343) * BFD_RELOC_MIPS_RELGOT: howto manager. (line 344) * BFD_RELOC_MIPS_SCN_DISP: howto manager. (line 342) * BFD_RELOC_MIPS_SHIFT5: howto manager. (line 335) * BFD_RELOC_MIPS_SHIFT6: howto manager. (line 336) * BFD_RELOC_MIPS_SUB: howto manager. (line 331) * BFD_RELOC_MIPS_TLS_DTPMOD32: howto manager. (line 346) * BFD_RELOC_MIPS_TLS_DTPMOD64: howto manager. (line 348) * BFD_RELOC_MIPS_TLS_DTPREL32: howto manager. (line 347) * BFD_RELOC_MIPS_TLS_DTPREL64: howto manager. (line 349) * BFD_RELOC_MIPS_TLS_DTPREL_HI16: howto manager. (line 352) * BFD_RELOC_MIPS_TLS_DTPREL_LO16: howto manager. (line 353) * BFD_RELOC_MIPS_TLS_GD: howto manager. (line 350) * BFD_RELOC_MIPS_TLS_GOTTPREL: howto manager. (line 354) * BFD_RELOC_MIPS_TLS_LDM: howto manager. (line 351) * BFD_RELOC_MIPS_TLS_TPREL32: howto manager. (line 355) * BFD_RELOC_MIPS_TLS_TPREL64: howto manager. (line 356) * BFD_RELOC_MIPS_TLS_TPREL_HI16: howto manager. (line 357) * BFD_RELOC_MIPS_TLS_TPREL_LO16: howto manager. (line 358) * BFD_RELOC_MMIX_ADDR19: howto manager. (line 1241) * BFD_RELOC_MMIX_ADDR27: howto manager. (line 1245) * BFD_RELOC_MMIX_BASE_PLUS_OFFSET: howto manager. (line 1257) * BFD_RELOC_MMIX_CBRANCH: howto manager. (line 1221) * BFD_RELOC_MMIX_CBRANCH_1: howto manager. (line 1223) * BFD_RELOC_MMIX_CBRANCH_2: howto manager. (line 1224) * BFD_RELOC_MMIX_CBRANCH_3: howto manager. (line 1225) * BFD_RELOC_MMIX_CBRANCH_J: howto manager. (line 1222) * BFD_RELOC_MMIX_GETA: howto manager. (line 1215) * BFD_RELOC_MMIX_GETA_1: howto manager. (line 1216) * BFD_RELOC_MMIX_GETA_2: howto manager. (line 1217) * BFD_RELOC_MMIX_GETA_3: howto manager. (line 1218) * BFD_RELOC_MMIX_JMP: howto manager. (line 1235) * BFD_RELOC_MMIX_JMP_1: howto manager. (line 1236) * BFD_RELOC_MMIX_JMP_2: howto manager. (line 1237) * BFD_RELOC_MMIX_JMP_3: howto manager. (line 1238) * BFD_RELOC_MMIX_LOCAL: howto manager. (line 1261) * BFD_RELOC_MMIX_PUSHJ: howto manager. (line 1228) * BFD_RELOC_MMIX_PUSHJ_1: howto manager. (line 1229) * BFD_RELOC_MMIX_PUSHJ_2: howto manager. (line 1230) * BFD_RELOC_MMIX_PUSHJ_3: howto manager. (line 1231) * BFD_RELOC_MMIX_PUSHJ_STUBBABLE: howto manager. (line 1232) * BFD_RELOC_MMIX_REG: howto manager. (line 1253) * BFD_RELOC_MMIX_REG_OR_BYTE: howto manager. (line 1249) * BFD_RELOC_MN10300_16_PCREL: howto manager. (line 1145) * BFD_RELOC_MN10300_32_PCREL: howto manager. (line 1141) * BFD_RELOC_MN10300_COPY: howto manager. (line 421) * BFD_RELOC_MN10300_GLOB_DAT: howto manager. (line 424) * BFD_RELOC_MN10300_GOT16: howto manager. (line 417) * BFD_RELOC_MN10300_GOT24: howto manager. (line 413) * BFD_RELOC_MN10300_GOT32: howto manager. (line 409) * BFD_RELOC_MN10300_GOTOFF24: howto manager. (line 406) * BFD_RELOC_MN10300_JMP_SLOT: howto manager. (line 427) * BFD_RELOC_MN10300_RELATIVE: howto manager. (line 430) * BFD_RELOC_MSP430_10_PCREL: howto manager. (line 1824) * BFD_RELOC_MSP430_16: howto manager. (line 1826) * BFD_RELOC_MSP430_16_BYTE: howto manager. (line 1828) * BFD_RELOC_MSP430_16_PCREL: howto manager. (line 1825) * BFD_RELOC_MSP430_16_PCREL_BYTE: howto manager. (line 1827) * BFD_RELOC_MSP430_2X_PCREL: howto manager. (line 1829) * BFD_RELOC_MSP430_RL_PCREL: howto manager. (line 1830) * BFD_RELOC_MT_GNU_VTENTRY: howto manager. (line 1818) * BFD_RELOC_MT_GNU_VTINHERIT: howto manager. (line 1815) * BFD_RELOC_MT_HI16: howto manager. (line 1809) * BFD_RELOC_MT_LO16: howto manager. (line 1812) * BFD_RELOC_MT_PC16: howto manager. (line 1806) * BFD_RELOC_MT_PCINSN8: howto manager. (line 1821) * BFD_RELOC_NONE: howto manager. (line 116) * BFD_RELOC_NS32K_DISP_16: howto manager. (line 493) * BFD_RELOC_NS32K_DISP_16_PCREL: howto manager. (line 496) * BFD_RELOC_NS32K_DISP_32: howto manager. (line 494) * BFD_RELOC_NS32K_DISP_32_PCREL: howto manager. (line 497) * BFD_RELOC_NS32K_DISP_8: howto manager. (line 492) * BFD_RELOC_NS32K_DISP_8_PCREL: howto manager. (line 495) * BFD_RELOC_NS32K_IMM_16: howto manager. (line 487) * BFD_RELOC_NS32K_IMM_16_PCREL: howto manager. (line 490) * BFD_RELOC_NS32K_IMM_32: howto manager. (line 488) * BFD_RELOC_NS32K_IMM_32_PCREL: howto manager. (line 491) * BFD_RELOC_NS32K_IMM_8: howto manager. (line 486) * BFD_RELOC_NS32K_IMM_8_PCREL: howto manager. (line 489) * BFD_RELOC_OPENRISC_ABS_26: howto manager. (line 1778) * BFD_RELOC_OPENRISC_REL_26: howto manager. (line 1779) * BFD_RELOC_PDP11_DISP_6_PCREL: howto manager. (line 501) * BFD_RELOC_PDP11_DISP_8_PCREL: howto manager. (line 500) * BFD_RELOC_PJ_CODE_DIR16: howto manager. (line 506) * BFD_RELOC_PJ_CODE_DIR32: howto manager. (line 507) * BFD_RELOC_PJ_CODE_HI16: howto manager. (line 504) * BFD_RELOC_PJ_CODE_LO16: howto manager. (line 505) * BFD_RELOC_PJ_CODE_REL16: howto manager. (line 508) * BFD_RELOC_PJ_CODE_REL32: howto manager. (line 509) * BFD_RELOC_PPC64_ADDR16_DS: howto manager. (line 554) * BFD_RELOC_PPC64_ADDR16_LO_DS: howto manager. (line 555) * BFD_RELOC_PPC64_DTPREL16_DS: howto manager. (line 601) * BFD_RELOC_PPC64_DTPREL16_HIGHER: howto manager. (line 603) * BFD_RELOC_PPC64_DTPREL16_HIGHERA: howto manager. (line 604) * BFD_RELOC_PPC64_DTPREL16_HIGHEST: howto manager. (line 605) * BFD_RELOC_PPC64_DTPREL16_HIGHESTA: howto manager. (line 606) * BFD_RELOC_PPC64_DTPREL16_LO_DS: howto manager. (line 602) * BFD_RELOC_PPC64_GOT16_DS: howto manager. (line 556) * BFD_RELOC_PPC64_GOT16_LO_DS: howto manager. (line 557) * BFD_RELOC_PPC64_HIGHER: howto manager. (line 542) * BFD_RELOC_PPC64_HIGHER_S: howto manager. (line 543) * BFD_RELOC_PPC64_HIGHEST: howto manager. (line 544) * BFD_RELOC_PPC64_HIGHEST_S: howto manager. (line 545) * BFD_RELOC_PPC64_PLT16_LO_DS: howto manager. (line 558) * BFD_RELOC_PPC64_PLTGOT16: howto manager. (line 550) * BFD_RELOC_PPC64_PLTGOT16_DS: howto manager. (line 563) * BFD_RELOC_PPC64_PLTGOT16_HA: howto manager. (line 553) * BFD_RELOC_PPC64_PLTGOT16_HI: howto manager. (line 552) * BFD_RELOC_PPC64_PLTGOT16_LO: howto manager. (line 551) * BFD_RELOC_PPC64_PLTGOT16_LO_DS: howto manager. (line 564) * BFD_RELOC_PPC64_SECTOFF_DS: howto manager. (line 559) * BFD_RELOC_PPC64_SECTOFF_LO_DS: howto manager. (line 560) * BFD_RELOC_PPC64_TOC: howto manager. (line 549) * BFD_RELOC_PPC64_TOC16_DS: howto manager. (line 561) * BFD_RELOC_PPC64_TOC16_HA: howto manager. (line 548) * BFD_RELOC_PPC64_TOC16_HI: howto manager. (line 547) * BFD_RELOC_PPC64_TOC16_LO: howto manager. (line 546) * BFD_RELOC_PPC64_TOC16_LO_DS: howto manager. (line 562) * BFD_RELOC_PPC64_TPREL16_DS: howto manager. (line 595) * BFD_RELOC_PPC64_TPREL16_HIGHER: howto manager. (line 597) * BFD_RELOC_PPC64_TPREL16_HIGHERA: howto manager. (line 598) * BFD_RELOC_PPC64_TPREL16_HIGHEST: howto manager. (line 599) * BFD_RELOC_PPC64_TPREL16_HIGHESTA: howto manager. (line 600) * BFD_RELOC_PPC64_TPREL16_LO_DS: howto manager. (line 596) * BFD_RELOC_PPC_B16: howto manager. (line 515) * BFD_RELOC_PPC_B16_BRNTAKEN: howto manager. (line 517) * BFD_RELOC_PPC_B16_BRTAKEN: howto manager. (line 516) * BFD_RELOC_PPC_B26: howto manager. (line 512) * BFD_RELOC_PPC_BA16: howto manager. (line 518) * BFD_RELOC_PPC_BA16_BRNTAKEN: howto manager. (line 520) * BFD_RELOC_PPC_BA16_BRTAKEN: howto manager. (line 519) * BFD_RELOC_PPC_BA26: howto manager. (line 513) * BFD_RELOC_PPC_COPY: howto manager. (line 521) * BFD_RELOC_PPC_DTPMOD: howto manager. (line 568) * BFD_RELOC_PPC_DTPREL: howto manager. (line 578) * BFD_RELOC_PPC_DTPREL16: howto manager. (line 574) * BFD_RELOC_PPC_DTPREL16_HA: howto manager. (line 577) * BFD_RELOC_PPC_DTPREL16_HI: howto manager. (line 576) * BFD_RELOC_PPC_DTPREL16_LO: howto manager. (line 575) * BFD_RELOC_PPC_EMB_BIT_FLD: howto manager. (line 540) * BFD_RELOC_PPC_EMB_MRKREF: howto manager. (line 535) * BFD_RELOC_PPC_EMB_NADDR16: howto manager. (line 527) * BFD_RELOC_PPC_EMB_NADDR16_HA: howto manager. (line 530) * BFD_RELOC_PPC_EMB_NADDR16_HI: howto manager. (line 529) * BFD_RELOC_PPC_EMB_NADDR16_LO: howto manager. (line 528) * BFD_RELOC_PPC_EMB_NADDR32: howto manager. (line 526) * BFD_RELOC_PPC_EMB_RELSDA: howto manager. (line 541) * BFD_RELOC_PPC_EMB_RELSEC16: howto manager. (line 536) * BFD_RELOC_PPC_EMB_RELST_HA: howto manager. (line 539) * BFD_RELOC_PPC_EMB_RELST_HI: howto manager. (line 538) * BFD_RELOC_PPC_EMB_RELST_LO: howto manager. (line 537) * BFD_RELOC_PPC_EMB_SDA21: howto manager. (line 534) * BFD_RELOC_PPC_EMB_SDA2I16: howto manager. (line 532) * BFD_RELOC_PPC_EMB_SDA2REL: howto manager. (line 533) * BFD_RELOC_PPC_EMB_SDAI16: howto manager. (line 531) * BFD_RELOC_PPC_GLOB_DAT: howto manager. (line 522) * BFD_RELOC_PPC_GOT_DTPREL16: howto manager. (line 591) * BFD_RELOC_PPC_GOT_DTPREL16_HA: howto manager. (line 594) * BFD_RELOC_PPC_GOT_DTPREL16_HI: howto manager. (line 593) * BFD_RELOC_PPC_GOT_DTPREL16_LO: howto manager. (line 592) * BFD_RELOC_PPC_GOT_TLSGD16: howto manager. (line 579) * BFD_RELOC_PPC_GOT_TLSGD16_HA: howto manager. (line 582) * BFD_RELOC_PPC_GOT_TLSGD16_HI: howto manager. (line 581) * BFD_RELOC_PPC_GOT_TLSGD16_LO: howto manager. (line 580) * BFD_RELOC_PPC_GOT_TLSLD16: howto manager. (line 583) * BFD_RELOC_PPC_GOT_TLSLD16_HA: howto manager. (line 586) * BFD_RELOC_PPC_GOT_TLSLD16_HI: howto manager. (line 585) * BFD_RELOC_PPC_GOT_TLSLD16_LO: howto manager. (line 584) * BFD_RELOC_PPC_GOT_TPREL16: howto manager. (line 587) * BFD_RELOC_PPC_GOT_TPREL16_HA: howto manager. (line 590) * BFD_RELOC_PPC_GOT_TPREL16_HI: howto manager. (line 589) * BFD_RELOC_PPC_GOT_TPREL16_LO: howto manager. (line 588) * BFD_RELOC_PPC_JMP_SLOT: howto manager. (line 523) * BFD_RELOC_PPC_LOCAL24PC: howto manager. (line 525) * BFD_RELOC_PPC_RELATIVE: howto manager. (line 524) * BFD_RELOC_PPC_TLS: howto manager. (line 567) * BFD_RELOC_PPC_TOC16: howto manager. (line 514) * BFD_RELOC_PPC_TPREL: howto manager. (line 573) * BFD_RELOC_PPC_TPREL16: howto manager. (line 569) * BFD_RELOC_PPC_TPREL16_HA: howto manager. (line 572) * BFD_RELOC_PPC_TPREL16_HI: howto manager. (line 571) * BFD_RELOC_PPC_TPREL16_LO: howto manager. (line 570) * BFD_RELOC_RVA: howto manager. (line 85) * BFD_RELOC_SH_ALIGN: howto manager. (line 755) * BFD_RELOC_SH_CODE: howto manager. (line 756) * BFD_RELOC_SH_COPY: howto manager. (line 761) * BFD_RELOC_SH_COPY64: howto manager. (line 786) * BFD_RELOC_SH_COUNT: howto manager. (line 754) * BFD_RELOC_SH_DATA: howto manager. (line 757) * BFD_RELOC_SH_DISP12: howto manager. (line 737) * BFD_RELOC_SH_DISP12BY2: howto manager. (line 738) * BFD_RELOC_SH_DISP12BY4: howto manager. (line 739) * BFD_RELOC_SH_DISP12BY8: howto manager. (line 740) * BFD_RELOC_SH_DISP20: howto manager. (line 741) * BFD_RELOC_SH_DISP20BY8: howto manager. (line 742) * BFD_RELOC_SH_GLOB_DAT: howto manager. (line 762) * BFD_RELOC_SH_GLOB_DAT64: howto manager. (line 787) * BFD_RELOC_SH_GOT10BY4: howto manager. (line 790) * BFD_RELOC_SH_GOT10BY8: howto manager. (line 791) * BFD_RELOC_SH_GOT_HI16: howto manager. (line 769) * BFD_RELOC_SH_GOT_LOW16: howto manager. (line 766) * BFD_RELOC_SH_GOT_MEDHI16: howto manager. (line 768) * BFD_RELOC_SH_GOT_MEDLOW16: howto manager. (line 767) * BFD_RELOC_SH_GOTOFF_HI16: howto manager. (line 781) * BFD_RELOC_SH_GOTOFF_LOW16: howto manager. (line 778) * BFD_RELOC_SH_GOTOFF_MEDHI16: howto manager. (line 780) * BFD_RELOC_SH_GOTOFF_MEDLOW16: howto manager. (line 779) * BFD_RELOC_SH_GOTPC: howto manager. (line 765) * BFD_RELOC_SH_GOTPC_HI16: howto manager. (line 785) * BFD_RELOC_SH_GOTPC_LOW16: howto manager. (line 782) * BFD_RELOC_SH_GOTPC_MEDHI16: howto manager. (line 784) * BFD_RELOC_SH_GOTPC_MEDLOW16: howto manager. (line 783) * BFD_RELOC_SH_GOTPLT10BY4: howto manager. (line 792) * BFD_RELOC_SH_GOTPLT10BY8: howto manager. (line 793) * BFD_RELOC_SH_GOTPLT32: howto manager. (line 794) * BFD_RELOC_SH_GOTPLT_HI16: howto manager. (line 773) * BFD_RELOC_SH_GOTPLT_LOW16: howto manager. (line 770) * BFD_RELOC_SH_GOTPLT_MEDHI16: howto manager. (line 772) * BFD_RELOC_SH_GOTPLT_MEDLOW16: howto manager. (line 771) * BFD_RELOC_SH_IMM3: howto manager. (line 735) * BFD_RELOC_SH_IMM3U: howto manager. (line 736) * BFD_RELOC_SH_IMM4: howto manager. (line 743) * BFD_RELOC_SH_IMM4BY2: howto manager. (line 744) * BFD_RELOC_SH_IMM4BY4: howto manager. (line 745) * BFD_RELOC_SH_IMM8: howto manager. (line 746) * BFD_RELOC_SH_IMM8BY2: howto manager. (line 747) * BFD_RELOC_SH_IMM8BY4: howto manager. (line 748) * BFD_RELOC_SH_IMM_HI16: howto manager. (line 812) * BFD_RELOC_SH_IMM_HI16_PCREL: howto manager. (line 813) * BFD_RELOC_SH_IMM_LOW16: howto manager. (line 806) * BFD_RELOC_SH_IMM_LOW16_PCREL: howto manager. (line 807) * BFD_RELOC_SH_IMM_MEDHI16: howto manager. (line 810) * BFD_RELOC_SH_IMM_MEDHI16_PCREL: howto manager. (line 811) * BFD_RELOC_SH_IMM_MEDLOW16: howto manager. (line 808) * BFD_RELOC_SH_IMM_MEDLOW16_PCREL: howto manager. (line 809) * BFD_RELOC_SH_IMMS10: howto manager. (line 800) * BFD_RELOC_SH_IMMS10BY2: howto manager. (line 801) * BFD_RELOC_SH_IMMS10BY4: howto manager. (line 802) * BFD_RELOC_SH_IMMS10BY8: howto manager. (line 803) * BFD_RELOC_SH_IMMS16: howto manager. (line 804) * BFD_RELOC_SH_IMMS6: howto manager. (line 797) * BFD_RELOC_SH_IMMS6BY32: howto manager. (line 798) * BFD_RELOC_SH_IMMU16: howto manager. (line 805) * BFD_RELOC_SH_IMMU5: howto manager. (line 796) * BFD_RELOC_SH_IMMU6: howto manager. (line 799) * BFD_RELOC_SH_JMP_SLOT: howto manager. (line 763) * BFD_RELOC_SH_JMP_SLOT64: howto manager. (line 788) * BFD_RELOC_SH_LABEL: howto manager. (line 758) * BFD_RELOC_SH_LOOP_END: howto manager. (line 760) * BFD_RELOC_SH_LOOP_START: howto manager. (line 759) * BFD_RELOC_SH_PCDISP12BY2: howto manager. (line 734) * BFD_RELOC_SH_PCDISP8BY2: howto manager. (line 733) * BFD_RELOC_SH_PCRELIMM8BY2: howto manager. (line 749) * BFD_RELOC_SH_PCRELIMM8BY4: howto manager. (line 750) * BFD_RELOC_SH_PLT_HI16: howto manager. (line 777) * BFD_RELOC_SH_PLT_LOW16: howto manager. (line 774) * BFD_RELOC_SH_PLT_MEDHI16: howto manager. (line 776) * BFD_RELOC_SH_PLT_MEDLOW16: howto manager. (line 775) * BFD_RELOC_SH_PT_16: howto manager. (line 814) * BFD_RELOC_SH_RELATIVE: howto manager. (line 764) * BFD_RELOC_SH_RELATIVE64: howto manager. (line 789) * BFD_RELOC_SH_SHMEDIA_CODE: howto manager. (line 795) * BFD_RELOC_SH_SWITCH16: howto manager. (line 751) * BFD_RELOC_SH_SWITCH32: howto manager. (line 752) * BFD_RELOC_SH_TLS_DTPMOD32: howto manager. (line 820) * BFD_RELOC_SH_TLS_DTPOFF32: howto manager. (line 821) * BFD_RELOC_SH_TLS_GD_32: howto manager. (line 815) * BFD_RELOC_SH_TLS_IE_32: howto manager. (line 818) * BFD_RELOC_SH_TLS_LD_32: howto manager. (line 816) * BFD_RELOC_SH_TLS_LDO_32: howto manager. (line 817) * BFD_RELOC_SH_TLS_LE_32: howto manager. (line 819) * BFD_RELOC_SH_TLS_TPOFF32: howto manager. (line 822) * BFD_RELOC_SH_USES: howto manager. (line 753) * BFD_RELOC_SPARC13: howto manager. (line 119) * BFD_RELOC_SPARC22: howto manager. (line 118) * BFD_RELOC_SPARC_10: howto manager. (line 141) * BFD_RELOC_SPARC_11: howto manager. (line 142) * BFD_RELOC_SPARC_5: howto manager. (line 154) * BFD_RELOC_SPARC_6: howto manager. (line 153) * BFD_RELOC_SPARC_64: howto manager. (line 140) * BFD_RELOC_SPARC_7: howto manager. (line 152) * BFD_RELOC_SPARC_BASE13: howto manager. (line 136) * BFD_RELOC_SPARC_BASE22: howto manager. (line 137) * BFD_RELOC_SPARC_COPY: howto manager. (line 126) * BFD_RELOC_SPARC_DISP64: howto manager. (line 155) * BFD_RELOC_SPARC_GLOB_DAT: howto manager. (line 127) * BFD_RELOC_SPARC_GOT10: howto manager. (line 120) * BFD_RELOC_SPARC_GOT13: howto manager. (line 121) * BFD_RELOC_SPARC_GOT22: howto manager. (line 122) * BFD_RELOC_SPARC_H44: howto manager. (line 160) * BFD_RELOC_SPARC_HH22: howto manager. (line 144) * BFD_RELOC_SPARC_HIX22: howto manager. (line 158) * BFD_RELOC_SPARC_HM10: howto manager. (line 145) * BFD_RELOC_SPARC_JMP_SLOT: howto manager. (line 128) * BFD_RELOC_SPARC_L44: howto manager. (line 162) * BFD_RELOC_SPARC_LM22: howto manager. (line 146) * BFD_RELOC_SPARC_LOX10: howto manager. (line 159) * BFD_RELOC_SPARC_M44: howto manager. (line 161) * BFD_RELOC_SPARC_OLO10: howto manager. (line 143) * BFD_RELOC_SPARC_PC10: howto manager. (line 123) * BFD_RELOC_SPARC_PC22: howto manager. (line 124) * BFD_RELOC_SPARC_PC_HH22: howto manager. (line 147) * BFD_RELOC_SPARC_PC_HM10: howto manager. (line 148) * BFD_RELOC_SPARC_PC_LM22: howto manager. (line 149) * BFD_RELOC_SPARC_PLT32: howto manager. (line 156) * BFD_RELOC_SPARC_PLT64: howto manager. (line 157) * BFD_RELOC_SPARC_REGISTER: howto manager. (line 163) * BFD_RELOC_SPARC_RELATIVE: howto manager. (line 129) * BFD_RELOC_SPARC_REV32: howto manager. (line 166) * BFD_RELOC_SPARC_TLS_DTPMOD32: howto manager. (line 187) * BFD_RELOC_SPARC_TLS_DTPMOD64: howto manager. (line 188) * BFD_RELOC_SPARC_TLS_DTPOFF32: howto manager. (line 189) * BFD_RELOC_SPARC_TLS_DTPOFF64: howto manager. (line 190) * BFD_RELOC_SPARC_TLS_GD_ADD: howto manager. (line 171) * BFD_RELOC_SPARC_TLS_GD_CALL: howto manager. (line 172) * BFD_RELOC_SPARC_TLS_GD_HI22: howto manager. (line 169) * BFD_RELOC_SPARC_TLS_GD_LO10: howto manager. (line 170) * BFD_RELOC_SPARC_TLS_IE_ADD: howto manager. (line 184) * BFD_RELOC_SPARC_TLS_IE_HI22: howto manager. (line 180) * BFD_RELOC_SPARC_TLS_IE_LD: howto manager. (line 182) * BFD_RELOC_SPARC_TLS_IE_LDX: howto manager. (line 183) * BFD_RELOC_SPARC_TLS_IE_LO10: howto manager. (line 181) * BFD_RELOC_SPARC_TLS_LDM_ADD: howto manager. (line 175) * BFD_RELOC_SPARC_TLS_LDM_CALL: howto manager. (line 176) * BFD_RELOC_SPARC_TLS_LDM_HI22: howto manager. (line 173) * BFD_RELOC_SPARC_TLS_LDM_LO10: howto manager. (line 174) * BFD_RELOC_SPARC_TLS_LDO_ADD: howto manager. (line 179) * BFD_RELOC_SPARC_TLS_LDO_HIX22: howto manager. (line 177) * BFD_RELOC_SPARC_TLS_LDO_LOX10: howto manager. (line 178) * BFD_RELOC_SPARC_TLS_LE_HIX22: howto manager. (line 185) * BFD_RELOC_SPARC_TLS_LE_LOX10: howto manager. (line 186) * BFD_RELOC_SPARC_TLS_TPOFF32: howto manager. (line 191) * BFD_RELOC_SPARC_TLS_TPOFF64: howto manager. (line 192) * BFD_RELOC_SPARC_UA16: howto manager. (line 130) * BFD_RELOC_SPARC_UA32: howto manager. (line 131) * BFD_RELOC_SPARC_UA64: howto manager. (line 132) * BFD_RELOC_SPARC_WDISP16: howto manager. (line 150) * BFD_RELOC_SPARC_WDISP19: howto manager. (line 151) * BFD_RELOC_SPARC_WDISP22: howto manager. (line 117) * BFD_RELOC_SPARC_WPLT30: howto manager. (line 125) * BFD_RELOC_THUMB_PCREL_BLX: howto manager. (line 627) * BFD_RELOC_THUMB_PCREL_BRANCH12: howto manager. (line 641) * BFD_RELOC_THUMB_PCREL_BRANCH20: howto manager. (line 642) * BFD_RELOC_THUMB_PCREL_BRANCH23: howto manager. (line 643) * BFD_RELOC_THUMB_PCREL_BRANCH25: howto manager. (line 644) * BFD_RELOC_THUMB_PCREL_BRANCH7: howto manager. (line 639) * BFD_RELOC_THUMB_PCREL_BRANCH9: howto manager. (line 640) * BFD_RELOC_TIC30_LDP: howto manager. (line 1149) * BFD_RELOC_TIC54X_16_OF_23: howto manager. (line 1167) * BFD_RELOC_TIC54X_23: howto manager. (line 1164) * BFD_RELOC_TIC54X_MS7_OF_23: howto manager. (line 1172) * BFD_RELOC_TIC54X_PARTLS7: howto manager. (line 1154) * BFD_RELOC_TIC54X_PARTMS9: howto manager. (line 1159) * bfd_reloc_type_lookup: howto manager. (line 1930) * BFD_RELOC_V850_22_PCREL: howto manager. (line 1076) * BFD_RELOC_V850_9_PCREL: howto manager. (line 1073) * BFD_RELOC_V850_ALIGN: howto manager. (line 1134) * BFD_RELOC_V850_CALLT_16_16_OFFSET: howto manager. (line 1125) * BFD_RELOC_V850_CALLT_6_7_OFFSET: howto manager. (line 1122) * BFD_RELOC_V850_LO16_SPLIT_OFFSET: howto manager. (line 1137) * BFD_RELOC_V850_LONGCALL: howto manager. (line 1128) * BFD_RELOC_V850_LONGJUMP: howto manager. (line 1131) * BFD_RELOC_V850_SDA_15_16_OFFSET: howto manager. (line 1082) * BFD_RELOC_V850_SDA_16_16_OFFSET: howto manager. (line 1079) * BFD_RELOC_V850_SDA_16_16_SPLIT_OFFSET: howto manager. (line 1114) * BFD_RELOC_V850_TDA_16_16_OFFSET: howto manager. (line 1104) * BFD_RELOC_V850_TDA_4_4_OFFSET: howto manager. (line 1111) * BFD_RELOC_V850_TDA_4_5_OFFSET: howto manager. (line 1107) * BFD_RELOC_V850_TDA_6_8_OFFSET: howto manager. (line 1093) * BFD_RELOC_V850_TDA_7_7_OFFSET: howto manager. (line 1101) * BFD_RELOC_V850_TDA_7_8_OFFSET: howto manager. (line 1097) * BFD_RELOC_V850_ZDA_15_16_OFFSET: howto manager. (line 1089) * BFD_RELOC_V850_ZDA_16_16_OFFSET: howto manager. (line 1086) * BFD_RELOC_V850_ZDA_16_16_SPLIT_OFFSET: howto manager. (line 1118) * BFD_RELOC_VAX_GLOB_DAT: howto manager. (line 1801) * BFD_RELOC_VAX_JMP_SLOT: howto manager. (line 1802) * BFD_RELOC_VAX_RELATIVE: howto manager. (line 1803) * BFD_RELOC_VPE4KMATH_DATA: howto manager. (line 1492) * BFD_RELOC_VPE4KMATH_INSN: howto manager. (line 1493) * BFD_RELOC_VTABLE_ENTRY: howto manager. (line 1497) * BFD_RELOC_VTABLE_INHERIT: howto manager. (line 1496) * BFD_RELOC_X86_64_32S: howto manager. (line 465) * BFD_RELOC_X86_64_COPY: howto manager. (line 460) * BFD_RELOC_X86_64_DTPMOD64: howto manager. (line 466) * BFD_RELOC_X86_64_DTPOFF32: howto manager. (line 471) * BFD_RELOC_X86_64_DTPOFF64: howto manager. (line 467) * BFD_RELOC_X86_64_GLOB_DAT: howto manager. (line 461) * BFD_RELOC_X86_64_GOT32: howto manager. (line 458) * BFD_RELOC_X86_64_GOT64: howto manager. (line 476) * BFD_RELOC_X86_64_GOTOFF64: howto manager. (line 474) * BFD_RELOC_X86_64_GOTPC32: howto manager. (line 475) * BFD_RELOC_X86_64_GOTPC32_TLSDESC: howto manager. (line 481) * BFD_RELOC_X86_64_GOTPC64: howto manager. (line 478) * BFD_RELOC_X86_64_GOTPCREL: howto manager. (line 464) * BFD_RELOC_X86_64_GOTPCREL64: howto manager. (line 477) * BFD_RELOC_X86_64_GOTPLT64: howto manager. (line 479) * BFD_RELOC_X86_64_GOTTPOFF: howto manager. (line 472) * BFD_RELOC_X86_64_JUMP_SLOT: howto manager. (line 462) * BFD_RELOC_X86_64_PLT32: howto manager. (line 459) * BFD_RELOC_X86_64_PLTOFF64: howto manager. (line 480) * BFD_RELOC_X86_64_RELATIVE: howto manager. (line 463) * BFD_RELOC_X86_64_TLSDESC: howto manager. (line 483) * BFD_RELOC_X86_64_TLSDESC_CALL: howto manager. (line 482) * BFD_RELOC_X86_64_TLSGD: howto manager. (line 469) * BFD_RELOC_X86_64_TLSLD: howto manager. (line 470) * BFD_RELOC_X86_64_TPOFF32: howto manager. (line 473) * BFD_RELOC_X86_64_TPOFF64: howto manager. (line 468) * BFD_RELOC_XC16X_PAG: howto manager. (line 1795) * BFD_RELOC_XC16X_POF: howto manager. (line 1796) * BFD_RELOC_XC16X_SEG: howto manager. (line 1797) * BFD_RELOC_XC16X_SOF: howto manager. (line 1798) * BFD_RELOC_XSTORMY16_12: howto manager. (line 1790) * BFD_RELOC_XSTORMY16_24: howto manager. (line 1791) * BFD_RELOC_XSTORMY16_FPTR16: howto manager. (line 1792) * BFD_RELOC_XSTORMY16_REL_12: howto manager. (line 1789) * BFD_RELOC_XTENSA_ASM_EXPAND: howto manager. (line 1907) * BFD_RELOC_XTENSA_ASM_SIMPLIFY: howto manager. (line 1912) * BFD_RELOC_XTENSA_DIFF16: howto manager. (line 1854) * BFD_RELOC_XTENSA_DIFF32: howto manager. (line 1855) * BFD_RELOC_XTENSA_DIFF8: howto manager. (line 1853) * BFD_RELOC_XTENSA_GLOB_DAT: howto manager. (line 1843) * BFD_RELOC_XTENSA_JMP_SLOT: howto manager. (line 1844) * BFD_RELOC_XTENSA_OP0: howto manager. (line 1901) * BFD_RELOC_XTENSA_OP1: howto manager. (line 1902) * BFD_RELOC_XTENSA_OP2: howto manager. (line 1903) * BFD_RELOC_XTENSA_PLT: howto manager. (line 1848) * BFD_RELOC_XTENSA_RELATIVE: howto manager. (line 1845) * BFD_RELOC_XTENSA_RTLD: howto manager. (line 1838) * BFD_RELOC_XTENSA_SLOT0_ALT: howto manager. (line 1883) * BFD_RELOC_XTENSA_SLOT0_OP: howto manager. (line 1863) * BFD_RELOC_XTENSA_SLOT10_ALT: howto manager. (line 1893) * BFD_RELOC_XTENSA_SLOT10_OP: howto manager. (line 1873) * BFD_RELOC_XTENSA_SLOT11_ALT: howto manager. (line 1894) * BFD_RELOC_XTENSA_SLOT11_OP: howto manager. (line 1874) * BFD_RELOC_XTENSA_SLOT12_ALT: howto manager. (line 1895) * BFD_RELOC_XTENSA_SLOT12_OP: howto manager. (line 1875) * BFD_RELOC_XTENSA_SLOT13_ALT: howto manager. (line 1896) * BFD_RELOC_XTENSA_SLOT13_OP: howto manager. (line 1876) * BFD_RELOC_XTENSA_SLOT14_ALT: howto manager. (line 1897) * BFD_RELOC_XTENSA_SLOT14_OP: howto manager. (line 1877) * BFD_RELOC_XTENSA_SLOT1_ALT: howto manager. (line 1884) * BFD_RELOC_XTENSA_SLOT1_OP: howto manager. (line 1864) * BFD_RELOC_XTENSA_SLOT2_ALT: howto manager. (line 1885) * BFD_RELOC_XTENSA_SLOT2_OP: howto manager. (line 1865) * BFD_RELOC_XTENSA_SLOT3_ALT: howto manager. (line 1886) * BFD_RELOC_XTENSA_SLOT3_OP: howto manager. (line 1866) * BFD_RELOC_XTENSA_SLOT4_ALT: howto manager. (line 1887) * BFD_RELOC_XTENSA_SLOT4_OP: howto manager. (line 1867) * BFD_RELOC_XTENSA_SLOT5_ALT: howto manager. (line 1888) * BFD_RELOC_XTENSA_SLOT5_OP: howto manager. (line 1868) * BFD_RELOC_XTENSA_SLOT6_ALT: howto manager. (line 1889) * BFD_RELOC_XTENSA_SLOT6_OP: howto manager. (line 1869) * BFD_RELOC_XTENSA_SLOT7_ALT: howto manager. (line 1890) * BFD_RELOC_XTENSA_SLOT7_OP: howto manager. (line 1870) * BFD_RELOC_XTENSA_SLOT8_ALT: howto manager. (line 1891) * BFD_RELOC_XTENSA_SLOT8_OP: howto manager. (line 1871) * BFD_RELOC_XTENSA_SLOT9_ALT: howto manager. (line 1892) * BFD_RELOC_XTENSA_SLOT9_OP: howto manager. (line 1872) * BFD_RELOC_Z80_DISP8: howto manager. (line 1917) * BFD_RELOC_Z8K_CALLR: howto manager. (line 1923) * BFD_RELOC_Z8K_DISP7: howto manager. (line 1920) * BFD_RELOC_Z8K_IMM4L: howto manager. (line 1926) * bfd_scan_arch: Architectures. (line 392) * bfd_scan_vma: BFD front end. (line 423) * bfd_seach_for_target: bfd_target. (line 459) * bfd_section_already_linked: Writing the symbol table. (line 55) * bfd_section_list_clear: section prototypes. (line 8) * bfd_sections_find_if: section prototypes. (line 176) * bfd_set_arch_info: Architectures. (line 433) * bfd_set_archive_head: Archives. (line 69) * bfd_set_default_target: bfd_target. (line 424) * bfd_set_error: BFD front end. (line 235) * bfd_set_error_handler: BFD front end. (line 275) * bfd_set_error_program_name: BFD front end. (line 284) * bfd_set_file_flags: BFD front end. (line 343) * bfd_set_format: Formats. (line 68) * bfd_set_gp_size: BFD front end. (line 413) * bfd_set_private_flags: BFD front end. (line 490) * bfd_set_reloc: BFD front end. (line 333) * bfd_set_section_contents: section prototypes. (line 207) * bfd_set_section_flags: section prototypes. (line 140) * bfd_set_section_size: section prototypes. (line 193) * bfd_set_start_address: BFD front end. (line 392) * bfd_set_symtab: symbol handling functions. (line 60) * bfd_symbol_info: symbol handling functions. (line 130) * bfd_target_list: bfd_target. (line 450) * bfd_write_bigendian_4byte_int: Internal. (line 13) * bfd_zalloc: Opening and Closing. (line 221) * bfd_zalloc2: Opening and Closing. (line 230) * coff_symbol_type: coff. (line 186) * core_file_matches_executable_p: Core Files. (line 30) * find_separate_debug_file: Opening and Closing. (line 272) * generic_core_file_matches_executable_p: Core Files. (line 40) * get_debug_link_info: Opening and Closing. (line 253) * Hash tables: Hash Tables. (line 6) * internal object-file format: Canonical format. (line 11) * Linker: Linker Functions. (line 6) * Other functions: BFD front end. (line 505) * separate_debug_file_exists: Opening and Closing. (line 263) * struct bfd_iovec: BFD front end. (line 657) * target vector (_bfd_final_link): Performing the Final Link. (line 6) * target vector (_bfd_link_add_symbols): Adding Symbols to the Hash Table. (line 6) * target vector (_bfd_link_hash_table_create): Creating a Linker Hash Table. (line 6) * The HOWTO Macro: typedef arelent. (line 291) * what is it?: Overview. (line 6)