----------------------------------------------------------------------------

Relocation

Relocation is the process of connecting symbolic references with
symbolic definitions. For example, when a program calls a function, the
associated call instruction must transfer control to the proper destination
address at execution. Relocatable files must have relocation entries which
are necessary because they contain information that describes how to modify
their section contents, thus allowing executable and shared object files to
hold the right information for a process's program image. 

   typedef struct {
        Elf32_Addr      r_offset;
        Elf32_Word      r_info;
   } Elf32_Rel;


   typedef struct {
        Elf32_Addr      r_offset;
        Elf32_Word      r_info;
        Elf32_Sword     r_addend;
   } Elf32_Rela;

Figure 8-7 Relocation Entries

r_offset
     This member gives the location at which to apply the relocation action.
     For a relocatable file, the value is the byte offset from the beginning
     of the section to the storage unit affected by the relocation. For an
     executable file or a shared object, the value is the virtual address of
     the storage unit affected by the relocation.

r_info
     This member gives both the symbol table index with respect to which the
     relocation must be made, and the type of relocation to apply. For
     example, a call instruction's relocation entry would hold the symbol
     table index of the function being called. If the index is STN_UNDEF,
     the undefined symbol index, the relocation uses 0 as the symbol value.
     Relocation types are processor-specific; descriptions of their behavior
     appear below. When the text below refers to a relocation entry's
     relocation type or symbol table index, it means the result of applying
     ELF32_R_TYPE or ELF32_R_SYM, respectively, to the entry's r_info
     member.

     #define ELF32_R_SYM(i)    ((i)>>8)
     #define ELF32_R_TYPE(i)   ((unsigned char)(i))
     #define ELF32_R_INFO(s,t) (((s)<<8)+(unsigned char)(t))

r_addend
     This member specifies a constant addend used to compute the value to be
     stored into the relocatable field.

As specified previously, only Elf32_Rela entries contain an explicit addend.
Entries of type Elf32_Rel store an implicit addend in the location to be
modified. Depending on the processor architecture, one form or the other
might be necessary or more convenient. Consequently, an implementation for a
particular machine may use one form exclusively or either form depending on
context.

A relocation section references two other sections: a symbol table and a
section to modify. The section header's sh_info and sh_link members specify
these relationships. Relocation entries for different object files have
slightly different interpretations for the r_offset member.

----------------------------------------------------------------------------
NOTE: See ``Section header'', for more information.
----------------------------------------------------------------------------

   * In relocatable files, r_offset holds a section offset. The relocation
     section itself describes how to modify another section in the file;
     relocation offsets designate a storage unit within the second section.

   * In executable and shared object files, r_offset holds a virtual
     address. To make these files' relocation entries more useful for the
     dynamic linker, the section offset (file interpretation) gives way to a
     virtual address (memory interpretation).

Although the interpretation of r_offset changes for different object files
to allow efficient access by the relevant programs, the relocation types'
meanings stay the same.