Untitled Document: BFD back ends

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

# 3. BFD back ends

> 3.1 What to Put Where |  |
> 3.2 a.out backends |  |
> 3.3 coff backends |  |
> 3.4 ELF backends |  | elf backends
> 3.5 mmo backend |  |

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 3.1 What to Put Where

All of BFD lives in one directory.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 3.2 a.out backends

Description
BFD supports a number of different flavours of a.out format, though the major differences are only the sizes of the structures on disk, and the shape of the relocation information.

The support is split into a basic support file ``aoutx.h'` and other files which derive functions from the base. One derivation file is ``aoutf1.h'` (for a.out flavour 1), and adds to the basic a.out functions support for sun3, sun4, 386 and 29k a.out files, to create a target jump vector for a specific target.

This information is further split out into more specific files for each machine, including ``sunos.c'` for sun3 and sun4, ``newsos3.c'` for the Sony NEWS, and ``demo64.c'` for a demonstration of a 64 bit a.out format.

The base file ``aoutx.h'` defines general mechanisms for reading and writing records to and from disk and various other methods which BFD requires. It is included by ``aout32.c'` and ``aout64.c'` to form the names `aout_32_swap_exec_header_in`, `aout_64_swap_exec_header_in`, etc.

As an example, this is what goes on to make the back end for a sun4, from ``aout32.c'`:

           #define ARCH_SIZE 32
           #include "aoutx.h"

Which exports names:

           ...
           aout_32_canonicalize_reloc
           aout_32_find_nearest_line
           aout_32_get_lineno
           aout_32_get_reloc_upper_bound
           ...

from ``sunos.c'`:

           #define TARGET_NAME "a.out-sunos-big"
           #define VECNAME    sunos_big_vec
           #include "aoutf1.h"

requires all the names from ``aout32.c'`, and produces the jump vector

           sunos_big_vec

The file ``host-aout.c'` is a special case. It is for a large set of hosts that use "more or less standard" a.out files, and for which cross-debugging is not interesting. It uses the standard 32-bit a.out support routines, but determines the file offsets and addresses of the text, data, and BSS sections, the machine architecture and machine type, and the entry point address, in a host-dependent manner. Once these values have been determined, generic code is used to handle the object file.

When porting it to run on a new system, you must supply:

            HOST_PAGE_SIZE
            HOST_SEGMENT_SIZE
            HOST_MACHINE_ARCH       (optional)
            HOST_MACHINE_MACHINE    (optional)
            HOST_TEXT_START_ADDR
            HOST_STACK_END_ADDR

in the file ``../include/sys/h-XXX.h'` (for your host). These values, plus the structures and macros defined in ``a.out.h'` on your host system, will produce a BFD target that will access ordinary a.out files on your host. To configure a new machine to use ``host-aout.c'`, specify:

           TDEFAULTS = -DDEFAULT_VECTOR=host_aout_big_vec
           TDEPFILES= host-aout.o trad-core.o

in the ``config/XXX.mt'` file, and modify ``configure.in'` to use the ``XXX.mt'` file (by setting "`bfd_target=XXX`") when your configuration is selected.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 3.2.1 Relocations

Description
The file ``aoutx.h'` provides for both the standard and extended forms of a.out relocation records.

The standard records contain only an address, a symbol index, and a type field. The extended records (used on 29ks and sparcs) also have a full integer for an addend.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 3.2.2 Internal entry points

Description
``aoutx.h'` exports several routines for accessing the contents of an a.out file, which are gathered and exported in turn by various format specific files (eg sunos.c).

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

#### 3.2.2.1 `aout_size_swap_exec_header_in`

Synopsis

    void aout_size_swap_exec_header_in,
       (bfd *abfd,
        struct external_exec *bytes,
        struct internal_exec *execp);

Description
Swap the information in an executable header raw_bytes taken from a raw byte stream memory image into the internal exec header structure execp.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

#### 3.2.2.2 `aout_size_swap_exec_header_out`

Synopsis

    void aout_size_swap_exec_header_out
       (bfd *abfd,
        struct internal_exec *execp,
        struct external_exec *raw_bytes);

Description
Swap the information in an internal exec header structure execp into the buffer raw_bytes ready for writing to disk.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

#### 3.2.2.3 `aout_size_some_aout_object_p`

Synopsis

    const bfd_target *aout_size_some_aout_object_p
       (bfd *abfd,
        struct internal_exec *execp,
        const bfd_target *(*callback_to_real_object_p) (bfd *));

Description
Some a.out variant thinks that the file open in abfd checking is an a.out file. Do some more checking, and set up for access if it really is. Call back to the calling environment's "finish up" function just before returning, to handle any last-minute setup.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

#### 3.2.2.4 `aout_size_mkobject`

Synopsis

    bfd_boolean aout_size_mkobject, (bfd *abfd);

Description
Initialize BFD abfd for use with a.out files.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

#### 3.2.2.5 `aout_size_machine_type`

Synopsis

    enum machine_type  aout_size_machine_type
       (enum bfd_architecture arch,
        unsigned long machine,
        bfd_boolean *unknown);

Description
Keep track of machine architecture and machine type for a.out's. Return the `machine_type` for a particular architecture and machine, or `M_UNKNOWN` if that exact architecture and machine can't be represented in a.out format.

If the architecture is understood, machine type 0 (default) is always understood.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

#### 3.2.2.6 `aout_size_set_arch_mach`

Synopsis

    bfd_boolean aout_size_set_arch_mach,
       (bfd *,
        enum bfd_architecture arch,
        unsigned long machine);

Description
Set the architecture and the machine of the BFD abfd to the values arch and machine. Verify that abfd's format can support the architecture required.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

#### 3.2.2.7 `aout_size_new_section_hook`

Synopsis

    bfd_boolean aout_size_new_section_hook,
       (bfd *abfd,
        asection *newsect);

Description
Called by the BFD in response to a `bfd_make_section` request.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 3.3 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 See section 2.10 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'`.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 3.3.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.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 3.3.2 How the coff backend works

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

#### 3.3.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.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

#### 3.3.2.2 Coff long section names

In the standard Coff object format, section names are limited to the eight bytes available in the `s_name` field of the `SCNHDR` section header structure. The format requires the field to be NUL-padded, but not necessarily NUL-terminated, so the longest section names permitted are a full eight characters.

The Microsoft PE variants of the Coff object file format add an extension to support the use of long section names. This extension is defined in section 4 of the Microsoft PE/COFF specification (rev 8.1). If a section name is too long to fit into the section header's `s_name` field, it is instead placed into the string table, and the `s_name` field is filled with a slash ("/") followed by the ASCII decimal representation of the offset of the full name relative to the string table base.

Note that this implies that the extension can only be used in object files, as executables do not contain a string table. The standard specifies that long section names from objects emitted into executable images are to be truncated.

However, as a GNU extension, BFD can generate executable images that contain a string table and long section names. This would appear to be technically valid, as the standard only says that Coff debugging information is deprecated, not forbidden, and in practice it works, although some tools that parse PE files expecting the MS standard format may become confused; ``PEview'` is one known example.

The functionality is supported in BFD by code implemented under the control of the macro `COFF_LONG_SECTION_NAMES`. If not defined, the format does not support long section names in any way. If defined, it is used to initialise a flag, `_bfd_coff_long_section_names`, and a hook function pointer, `_bfd_coff_set_long_section_names`, in the Coff backend data structure. The flag controls the generation of long section names in output BFDs at runtime; if it is false, as it will be by default when generating an executable image, long section names are truncated; if true, the long section names extension is employed. The hook points to a function that allows the value of the flag to be altered at runtime, on formats that support long section names at all; on other formats it points to a stub that returns an error indication.

With input BFDs, the flag is set according to whether any long section names are detected while reading the section headers. For a completely new BFD, the flag is set to the default for the target format. This information can be used by a client of the BFD library when deciding what output format to generate, and means that a BFD that is opened for read and subsequently converted to a writeable BFD and modified in-place will retain whatever format it had on input.

If `COFF_LONG_SECTION_NAMES` is simply defined (blank), or is defined to the value "1", then long section names are enabled by default; if it is defined to the value zero, they are disabled by default (but still accepted in input BFDs). The header ``coffcode.h'` defines a macro, `COFF_DEFAULT_LONG_SECTION_NAMES`, which is used in the backends to initialise the backend data structure fields appropriately; see the comments for further detail.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

#### 3.3.2.3 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.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

#### 3.3.2.4 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`. See section 2.7 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.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

#### 3.3.2.5 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` See section 2.6 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.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

#### 3.3.2.6 `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;

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

#### 3.3.2.7 `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;
      bfd_boolean (*_bfd_coff_set_long_section_names)
        (bfd *, int);

      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_boolean (*_bfd_coff_print_pdata)
        (bfd *, void *);

    } 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_set_long_section_names(abfd, enable) \
      ((coff_backend_info (abfd)->_bfd_coff_set_long_section_names) (abfd, enable))
    #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))

    #define bfd_coff_have_print_pdata(a) \
      (coff_backend_info (a)->_bfd_coff_print_pdata)
    #define bfd_coff_print_pdata(a,p) \
      ((coff_backend_info (a)->_bfd_coff_print_pdata) (a, p))

    /* Macro: Returns true if the bfd is a PE executable as opposed to a
       PE object file.  */
    #define bfd_pei_p(abfd) \
      (CONST_STRNEQ ((abfd)->xvec->name, "pei-"))

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

#### 3.3.2.8 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.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

#### 3.3.2.9 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 ?

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

#### 3.3.2.10 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.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 3.4 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.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 3.5 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.

> 3.5.1 File layout |  |
> 3.5.2 Symbol table format |  |
> 3.5.3 mmo section mapping |  |

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 3.5.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. See section 3.5.3 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. See section 3.5.3 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'`. See section 3.5.3 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 (see section 3.5.2 Symbol table format).

`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   See section 3.5.2 Symbol table format.
     0x10404020
     0x4d206120
     0x69016e00
     0x81000000
     0x980c0005 - lop_end; symbol table contained five 32-bit words.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 3.5.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 (see section 3.5.1 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.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 3.5.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.

Version 1.3, 3 November 2008

    Copyright (C) 2000, 2001, 2002, 2007, 2008 Free Software Foundation, Inc.
    http://fsf.org/

    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 functional and useful 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, in any medium, that contains a notice placed by the copyright holder saying it can be distributed under the terms of this License. Such a notice grants a world-wide, royalty-free license, unlimited in duration, to use that work under the conditions stated herein. The "Document", below, refers to any such manual or work. Any member of the public is a licensee, and is addressed as "you". You accept the license if you copy, modify or distribute the work in a way requiring permission under copyright law.

   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. (Thus, 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. If a section does not fit the above definition of Secondary then it is not allowed to be designated as Invariant. The Document may contain zero Invariant Sections. If the Document does not identify any Invariant Sections then there are none.

   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 Front-Cover Text may be at most 5 words, and a Back-Cover Text may be at most 25 words.

   A "Transparent" copy of the Document means a machine-readable copy, represented in a format whose specification is available to the general public, that is suitable for revising the document 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, or absence of markup, has been arranged to thwart or discourage subsequent modification by readers is not Transparent. An image format is not Transparent if used for any substantial amount of text. 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, PostScript or PDF designed for human modification. Examples of transparent image formats include PNG, XCF and JPG. Opaque formats include 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, PostScript or PDF 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.

   The "publisher" means any person or entity that distributes copies of the Document to the public.

   A section "Entitled XYZ" means a named subunit of the Document whose title either is precisely XYZ or contains XYZ in parentheses following text that translates XYZ in another language. (Here XYZ stands for a specific section name mentioned below, such as "Acknowledgements", "Dedications", "Endorsements", or "History".) To "Preserve the Title" of such a section when you modify the Document means that it remains a section "Entitled XYZ" according to this definition.

   The Document may include Warranty Disclaimers next to the notice which states that this License applies to the Document. These Warranty Disclaimers are considered to be included by reference in this License, but only as regards disclaiming warranties: any other implication that these Warranty Disclaimers may have is void and has no effect on the meaning of this License.

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 (or copies in media that commonly have printed covers) 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 computer-network location from which the general network-using public has access to download using public-standard network protocols a complete Transparent copy of the Document, free of added material. 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:

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

   2. 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 fewer than five), unless they release you from this requirement.

   3. State on the Title page the name of the publisher of the Modified Version, as the publisher.

   4. Preserve all the copyright notices of the Document.

   5. Add an appropriate copyright notice for your modifications adjacent to the other copyright notices.

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

   7. Preserve in that license notice the full lists of Invariant Sections and required Cover Texts given in the Document's license notice.

   8. Include an unaltered copy of this License.

   9. Preserve the section Entitled "History", Preserve 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.

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

   11. For any section Entitled "Acknowledgements" or "Dedications", Preserve the Title of the section, and preserve in the section all the substance and tone of each of the contributor acknowledgements and/or dedications given therein.

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

   13. Delete any section Entitled "Endorsements". Such a section may not be included in the Modified Version.

   14. Do not retitle any existing section to be Entitled "Endorsements" or to conflict in title with any Invariant Section.

   15. Preserve any Warranty Disclaimers.

   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, and that you preserve all their Warranty Disclaimers.

   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, is called an "aggregate" if the copyright resulting from the compilation is not used to limit the legal rights of the compilation's users beyond what the individual works permit. When the Document is included in an aggregate, this License does not apply to the other works in the aggregate which 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 half of the entire aggregate, the Document's Cover Texts may be placed on covers that bracket the Document within the aggregate, or the electronic equivalent of covers if the Document is in electronic form. Otherwise they must appear on printed covers that bracket 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, and all the license notices in the Document, and any Warranty Disclaimers, provided that you also include the original English version of this License and the original versions of those notices and disclaimers. In case of a disagreement between the translation and the original version of this License or a notice or disclaimer, the original version will prevail.

   If a section in the Document is Entitled "Acknowledgements", "Dedications", or "History", the requirement (section 4) to Preserve its Title (section 1) will typically require changing the actual title.

9. TERMINATION

   You may not copy, modify, sublicense, or distribute the Document except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense, or distribute it is void, and will automatically terminate your rights under this License.

   However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation.

   Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice.

   Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License. If your rights have been terminated and not permanently reinstated, receipt of a copy of some or all of the same material does not give you any rights to use it.

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. If the Document specifies that a proxy can decide which future versions of this License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Document.

11. RELICENSING

    "Massive Multiauthor Collaboration Site" (or "MMC Site") means any World Wide Web server that publishes copyrightable works and also provides prominent facilities for anybody to edit those works. A public wiki that anybody can edit is an example of such a server. A "Massive Multiauthor Collaboration" (or "MMC") contained in the site means any set of copyrightable works thus published on the MMC site.

    "CC-BY-SA" means the Creative Commons Attribution-Share Alike 3.0 license published by Creative Commons Corporation, a not-for-profit corporation with a principal place of business in San Francisco, California, as well as future copyleft versions of that license published by that same organization.

    "Incorporate" means to publish or republish a Document, in whole or in part, as part of another Document.

    An MMC is "eligible for relicensing" if it is licensed under this License, and if all works that were first published under this License somewhere other than this MMC, and subsequently incorporated in whole or in part into the MMC, (1) had no cover texts or invariant sections, and (2) were thus incorporated prior to November 1, 2008.

    The operator of an MMC Site may republish an MMC contained in the site under CC-BY-SA on the same site at any time before August 1, 2009, provided the MMC is eligible for relicensing.

## 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.3
      or any later version published by the Free Software Foundation;
      with no Invariant Sections, no Front-Cover Texts, and no Back-Cover
      Texts.  A copy of the license is included in the section entitled ``GNU
      Free Documentation License''.

If you have Invariant Sections, Front-Cover Texts and Back-Cover Texts, replace the "with...Texts." line with this:

        with the Invariant Sections being list their titles, with
        the Front-Cover Texts being list, and with the Back-Cover Texts
        being list.

If you have Invariant Sections without Cover Texts, or some other combination of the three, merge those two alternatives to suit the situation.

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.

[ << ] | [ >> ] |  |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

This document was generated by GNAT Mailserver on April, 10 2014 using texi2html