No empty .Rs/.Re

[netbsd-mini2440.git] / gnu / dist / gdb6 / bfd / doc / bfd.info-2

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".

\x1f
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.

\x1f
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.

\x1f
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::

\x1f
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.
      <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.

\x1f
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.

\x1f
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.

\x1f
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.

\x1f
File: bfd.info,  Node: BFD Index,  Prev: GNU Free Documentation License,  Up: Top

BFD Index
*********

\0\b[index\0\b]
* 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)