\section{Definitions and Basic Types}

The following definitions and basic types are referenced throughout the rest of this document.

\subsection{Definitions}

\begin{description}
\item[Offset] Offsets represent an address relative to the start address(base) of the object file. For executables, the Offset represents an absolute address.
The following definitions deal with the symbol table interface.
\item[Object File] An object file is the representation of code that a compiler or assembler generates by processing a source code file. It represents .o's, a.out's and shared libraries.
\item[Region] A region represents a contiguous area of the file that contains executable code or readable data; for example, an ELF section.
\item[Symbol] A symbol represents an entry in the symbol table, and may identify a function, variable or other structure within the file.
\item[Function] A function represents a code object within the file represented by one or more symbols.
\item[Variable] A variable represents a data object within the file represented by one or more symbols.
\item[Module] A module represents a particular source file in cases where multiple files were compiled into a single binary object; if this information is not present, or if the binary object is a shared library, we use a single default module.
\item[Archive] An archive represents a collection of binary objects stored in a single file (e.g., a static archive). 
\item[Relocations] These provide the necessary information for inter-object references between two object files.
\item[Exception Blocks] These contain the information necessary for run-time exception handling
The following definitions deal with members of the Symbol class.
\item[Mangled Name] A mangled name for a symbol provides a way of encoding additional information about a function, structure, class or another data type in a symbol name. It is a technique used to solve various problems caused by the need to resolve unique names for programming entities in many modern programming languages. For example, a function foo with signature void foo() has a mangled name $_Z8foov$ when compiled with gcc.
\item[Pretty Name] A pretty name for a symbol represents a user-level symbolic name for a symbol. For example, foo can be a pretty name for a function declared as void foo().
\item[Typed Name] A typed name for a symbol represents the user-level symbolic name complete with the signature. For example, void foo() can be a typed name for the function foo.
\item[Symbol Linkage] The symbol linkage for a symbol gives information on the visibility (binding) of this symbol, whether it is visible only in the object file where it is defined (local), if it is visible to all the object files that are being linked (global), or if its a weak alias to a global symbol.
\item[Symbol Type] Symbol type for a symbol represents the category of symbols to which it belongs. It can be a function symbol or a variable symbol or a module symbol.
The following definitions deal with the type and the local variable interface.
\item[Type] A type represents the data type of a variable or a parameter. This can represent language pre-defined types (e.g. int, float), pre-defined types in the object (e.g., structures or unions), or user-defined types.
\item[Local Variable] A local variable represents a variable that has been declared within the scope of a sub-routine or a parameter to a sub-routine.
\end{description}

\subsection{Basic Types}

\begin{apient}
typedef unsigned long Offset
\end{apient}
\apidesc{An integer value that contains an offset from base address of the object file.}
\begin{apient}
typedef int typeId_t
\end{apient}
\apidesc{A unique handle for identifying a type. Each of types is assigned a globally unique ID. This way it is easier to identify any data type of a variable or a parameter.}
\begin{apient}
typedef ... PID
\end{apient}
\apidesc{A handle for identifying a process that is used by the dynamic components of SymtabAPI. On UNIX platforms PID is a int, on Windows it is a HANDLE that refers to a process.}
\begin{apient}
typedef unsigned long Address
\end{apient}
\apidesc{An integer value that represents an address in a process. This is used by the dynamic components of SymtabAPI.}
