+<div class="doc_subsection">
+ <a name="simplechanges">Making simple changes</a>
+</div>
+
+<div class="doc_text">
+
+<p>There are some primitive transformation operations present in the LLVM
+infrastructure that are worth knowing about. When performing
+transformations, it's fairly common to manipulate the contents of basic
+blocks. This section describes some of the common methods for doing so
+and gives example code.</p>
+
+</div>
+
+<!--_______________________________________________________________________-->
+<div class="doc_subsubsection">
+ <a name="schanges_creating">Creating and inserting new
+ <tt>Instruction</tt>s</a>
+</div>
+
+<div class="doc_text">
+
+<p><i>Instantiating Instructions</i></p>
+
+<p>Creation of <tt>Instruction</tt>s is straight-forward: simply call the
+constructor for the kind of instruction to instantiate and provide the necessary
+parameters. For example, an <tt>AllocaInst</tt> only <i>requires</i> a
+(const-ptr-to) <tt>Type</tt>. Thus:</p>
+
+<div class="doc_code">
+<pre>
+AllocaInst* ai = new AllocaInst(Type::IntTy);
+</pre>
+</div>
+
+<p>will create an <tt>AllocaInst</tt> instance that represents the allocation of
+one integer in the current stack frame, at runtime. Each <tt>Instruction</tt>
+subclass is likely to have varying default parameters which change the semantics
+of the instruction, so refer to the <a
+href="/doxygen/classllvm_1_1Instruction.html">doxygen documentation for the subclass of
+Instruction</a> that you're interested in instantiating.</p>
+
+<p><i>Naming values</i></p>
+
+<p>It is very useful to name the values of instructions when you're able to, as
+this facilitates the debugging of your transformations. If you end up looking
+at generated LLVM machine code, you definitely want to have logical names
+associated with the results of instructions! By supplying a value for the
+<tt>Name</tt> (default) parameter of the <tt>Instruction</tt> constructor, you
+associate a logical name with the result of the instruction's execution at
+runtime. For example, say that I'm writing a transformation that dynamically
+allocates space for an integer on the stack, and that integer is going to be
+used as some kind of index by some other code. To accomplish this, I place an
+<tt>AllocaInst</tt> at the first point in the first <tt>BasicBlock</tt> of some
+<tt>Function</tt>, and I'm intending to use it within the same
+<tt>Function</tt>. I might do:</p>
+
+<div class="doc_code">
+<pre>
+AllocaInst* pa = new AllocaInst(Type::IntTy, 0, "indexLoc");
+</pre>
+</div>
+
+<p>where <tt>indexLoc</tt> is now the logical name of the instruction's
+execution value, which is a pointer to an integer on the runtime stack.</p>
+
+<p><i>Inserting instructions</i></p>
+
+<p>There are essentially two ways to insert an <tt>Instruction</tt>
+into an existing sequence of instructions that form a <tt>BasicBlock</tt>:</p>
+
+<ul>
+ <li>Insertion into an explicit instruction list
+
+ <p>Given a <tt>BasicBlock* pb</tt>, an <tt>Instruction* pi</tt> within that
+ <tt>BasicBlock</tt>, and a newly-created instruction we wish to insert
+ before <tt>*pi</tt>, we do the following: </p>
+
+<div class="doc_code">
+<pre>
+BasicBlock *pb = ...;
+Instruction *pi = ...;
+Instruction *newInst = new Instruction(...);
+
+pb->getInstList().insert(pi, newInst); // <i>Inserts newInst before pi in pb</i>
+</pre>
+</div>
+
+ <p>Appending to the end of a <tt>BasicBlock</tt> is so common that
+ the <tt>Instruction</tt> class and <tt>Instruction</tt>-derived
+ classes provide constructors which take a pointer to a
+ <tt>BasicBlock</tt> to be appended to. For example code that
+ looked like: </p>
+
+<div class="doc_code">
+<pre>
+BasicBlock *pb = ...;
+Instruction *newInst = new Instruction(...);
+
+pb->getInstList().push_back(newInst); // <i>Appends newInst to pb</i>
+</pre>
+</div>
+
+ <p>becomes: </p>
+
+<div class="doc_code">
+<pre>
+BasicBlock *pb = ...;
+Instruction *newInst = new Instruction(..., pb);
+</pre>
+</div>
+
+ <p>which is much cleaner, especially if you are creating
+ long instruction streams.</p></li>
+
+ <li>Insertion into an implicit instruction list
+
+ <p><tt>Instruction</tt> instances that are already in <tt>BasicBlock</tt>s
+ are implicitly associated with an existing instruction list: the instruction
+ list of the enclosing basic block. Thus, we could have accomplished the same
+ thing as the above code without being given a <tt>BasicBlock</tt> by doing:
+ </p>
+
+<div class="doc_code">
+<pre>
+Instruction *pi = ...;
+Instruction *newInst = new Instruction(...);
+
+pi->getParent()->getInstList().insert(pi, newInst);
+</pre>
+</div>
+
+ <p>In fact, this sequence of steps occurs so frequently that the
+ <tt>Instruction</tt> class and <tt>Instruction</tt>-derived classes provide
+ constructors which take (as a default parameter) a pointer to an
+ <tt>Instruction</tt> which the newly-created <tt>Instruction</tt> should
+ precede. That is, <tt>Instruction</tt> constructors are capable of
+ inserting the newly-created instance into the <tt>BasicBlock</tt> of a
+ provided instruction, immediately before that instruction. Using an
+ <tt>Instruction</tt> constructor with a <tt>insertBefore</tt> (default)
+ parameter, the above code becomes:</p>
+
+<div class="doc_code">
+<pre>
+Instruction* pi = ...;
+Instruction* newInst = new Instruction(..., pi);
+</pre>
+</div>
+
+ <p>which is much cleaner, especially if you're creating a lot of
+ instructions and adding them to <tt>BasicBlock</tt>s.</p></li>
+</ul>
+
+</div>
+
+<!--_______________________________________________________________________-->
+<div class="doc_subsubsection">
+ <a name="schanges_deleting">Deleting <tt>Instruction</tt>s</a>
+</div>
+
+<div class="doc_text">
+
+<p>Deleting an instruction from an existing sequence of instructions that form a
+<a href="#BasicBlock"><tt>BasicBlock</tt></a> is very straight-forward. First,
+you must have a pointer to the instruction that you wish to delete. Second, you
+need to obtain the pointer to that instruction's basic block. You use the
+pointer to the basic block to get its list of instructions and then use the
+erase function to remove your instruction. For example:</p>
+
+<div class="doc_code">
+<pre>
+<a href="#Instruction">Instruction</a> *I = .. ;
+<a href="#BasicBlock">BasicBlock</a> *BB = I->getParent();
+
+BB->getInstList().erase(I);
+</pre>
+</div>
+
+</div>
+
+<!--_______________________________________________________________________-->
+<div class="doc_subsubsection">
+ <a name="schanges_replacing">Replacing an <tt>Instruction</tt> with another
+ <tt>Value</tt></a>
+</div>
+
+<div class="doc_text">
+
+<p><i>Replacing individual instructions</i></p>
+
+<p>Including "<a href="/doxygen/BasicBlockUtils_8h-source.html">llvm/Transforms/Utils/BasicBlockUtils.h</a>"
+permits use of two very useful replace functions: <tt>ReplaceInstWithValue</tt>
+and <tt>ReplaceInstWithInst</tt>.</p>
+
+<h4><a name="schanges_deleting">Deleting <tt>Instruction</tt>s</a></h4>
+
+<ul>
+ <li><tt>ReplaceInstWithValue</tt>
+
+ <p>This function replaces all uses (within a basic block) of a given
+ instruction with a value, and then removes the original instruction. The
+ following example illustrates the replacement of the result of a particular
+ <tt>AllocaInst</tt> that allocates memory for a single integer with a null
+ pointer to an integer.</p>
+
+<div class="doc_code">
+<pre>
+AllocaInst* instToReplace = ...;
+BasicBlock::iterator ii(instToReplace);
+
+ReplaceInstWithValue(instToReplace->getParent()->getInstList(), ii,
+ Constant::getNullValue(PointerType::get(Type::IntTy)));
+</pre></div></li>
+
+ <li><tt>ReplaceInstWithInst</tt>
+
+ <p>This function replaces a particular instruction with another
+ instruction. The following example illustrates the replacement of one
+ <tt>AllocaInst</tt> with another.</p>
+
+<div class="doc_code">
+<pre>
+AllocaInst* instToReplace = ...;
+BasicBlock::iterator ii(instToReplace);
+
+ReplaceInstWithInst(instToReplace->getParent()->getInstList(), ii,
+ new AllocaInst(Type::IntTy, 0, "ptrToReplacedInt"));
+</pre></div></li>
+</ul>
+
+<p><i>Replacing multiple uses of <tt>User</tt>s and <tt>Value</tt>s</i></p>
+
+<p>You can use <tt>Value::replaceAllUsesWith</tt> and
+<tt>User::replaceUsesOfWith</tt> to change more than one use at a time. See the
+doxygen documentation for the <a href="/doxygen/structllvm_1_1Value.html">Value Class</a>
+and <a href="/doxygen/classllvm_1_1User.html">User Class</a>, respectively, for more
+information.</p>
+
+<!-- Value::replaceAllUsesWith User::replaceUsesOfWith Point out:
+include/llvm/Transforms/Utils/ especially BasicBlockUtils.h with:
+ReplaceInstWithValue, ReplaceInstWithInst -->
+
+</div>
+
+<!-- *********************************************************************** -->
+<div class="doc_section">
+ <a name="advanced">Advanced Topics</a>
+</div>
+<!-- *********************************************************************** -->
+
+<div class="doc_text">
+<p>
+This section describes some of the advanced or obscure API's that most clients
+do not need to be aware of. These API's tend manage the inner workings of the
+LLVM system, and only need to be accessed in unusual circumstances.
+</p>
+</div>
+
+<!-- ======================================================================= -->
+<div class="doc_subsection">
+ <a name="TypeResolve">LLVM Type Resolution</a>
+</div>
+
+<div class="doc_text">
+
+<p>
+The LLVM type system has a very simple goal: allow clients to compare types for
+structural equality with a simple pointer comparison (aka a shallow compare).
+This goal makes clients much simpler and faster, and is used throughout the LLVM
+system.
+</p>
+
+<p>
+Unfortunately achieving this goal is not a simple matter. In particular,
+recursive types and late resolution of opaque types makes the situation very
+difficult to handle. Fortunately, for the most part, our implementation makes
+most clients able to be completely unaware of the nasty internal details. The
+primary case where clients are exposed to the inner workings of it are when
+building a recursive type. In addition to this case, the LLVM bytecode reader,
+assembly parser, and linker also have to be aware of the inner workings of this
+system.
+</p>
+
+<p>
+For our purposes below, we need three concepts. First, an "Opaque Type" is
+exactly as defined in the <a href="LangRef.html#t_opaque">language
+reference</a>. Second an "Abstract Type" is any type which includes an
+opaque type as part of its type graph (for example "<tt>{ opaque, int }</tt>").
+Third, a concrete type is a type that is not an abstract type (e.g. "<tt>[ int,
+float }</tt>").
+</p>
+
+</div>
+
+<!-- ______________________________________________________________________ -->
+<div class="doc_subsubsection">
+ <a name="BuildRecType">Basic Recursive Type Construction</a>
+</div>
+
+<div class="doc_text">
+
+<p>
+Because the most common question is "how do I build a recursive type with LLVM",
+we answer it now and explain it as we go. Here we include enough to cause this
+to be emitted to an output .ll file:
+</p>
+
+<div class="doc_code">
+<pre>
+%mylist = type { %mylist*, int }
+</pre>
+</div>
+
+<p>
+To build this, use the following LLVM APIs:
+</p>
+
+<div class="doc_code">
+<pre>
+// <i>Create the initial outer struct</i>
+<a href="#PATypeHolder">PATypeHolder</a> StructTy = OpaqueType::get();
+std::vector<const Type*> Elts;
+Elts.push_back(PointerType::get(StructTy));
+Elts.push_back(Type::IntTy);
+StructType *NewSTy = StructType::get(Elts);
+
+// <i>At this point, NewSTy = "{ opaque*, int }". Tell VMCore that</i>
+// <i>the struct and the opaque type are actually the same.</i>
+cast<OpaqueType>(StructTy.get())-><a href="#refineAbstractTypeTo">refineAbstractTypeTo</a>(NewSTy);
+
+// <i>NewSTy is potentially invalidated, but StructTy (a <a href="#PATypeHolder">PATypeHolder</a>) is</i>
+// <i>kept up-to-date</i>
+NewSTy = cast<StructType>(StructTy.get());
+
+// <i>Add a name for the type to the module symbol table (optional)</i>
+MyModule->addTypeName("mylist", NewSTy);
+</pre>
+</div>
+
+<p>
+This code shows the basic approach used to build recursive types: build a
+non-recursive type using 'opaque', then use type unification to close the cycle.
+The type unification step is performed by the <tt><a
+ref="#refineAbstractTypeTo">refineAbstractTypeTo</a></tt> method, which is
+described next. After that, we describe the <a
+href="#PATypeHolder">PATypeHolder class</a>.
+</p>
+
+</div>
+
+<!-- ______________________________________________________________________ -->
+<div class="doc_subsubsection">
+ <a name="refineAbstractTypeTo">The <tt>refineAbstractTypeTo</tt> method</a>
+</div>
+
+<div class="doc_text">
+<p>
+The <tt>refineAbstractTypeTo</tt> method starts the type unification process.
+While this method is actually a member of the DerivedType class, it is most
+often used on OpaqueType instances. Type unification is actually a recursive
+process. After unification, types can become structurally isomorphic to
+existing types, and all duplicates are deleted (to preserve pointer equality).
+</p>
+
+<p>
+In the example above, the OpaqueType object is definitely deleted.
+Additionally, if there is an "{ \2*, int}" type already created in the system,
+the pointer and struct type created are <b>also</b> deleted. Obviously whenever
+a type is deleted, any "Type*" pointers in the program are invalidated. As
+such, it is safest to avoid having <i>any</i> "Type*" pointers to abstract types
+live across a call to <tt>refineAbstractTypeTo</tt> (note that non-abstract
+types can never move or be deleted). To deal with this, the <a
+href="#PATypeHolder">PATypeHolder</a> class is used to maintain a stable
+reference to a possibly refined type, and the <a
+href="#AbstractTypeUser">AbstractTypeUser</a> class is used to update more
+complex datastructures.
+</p>
+
+</div>
+
+<!-- ______________________________________________________________________ -->
+<div class="doc_subsubsection">
+ <a name="PATypeHolder">The PATypeHolder Class</a>
+</div>
+
+<div class="doc_text">
+<p>
+PATypeHolder is a form of a "smart pointer" for Type objects. When VMCore
+happily goes about nuking types that become isomorphic to existing types, it
+automatically updates all PATypeHolder objects to point to the new type. In the
+example above, this allows the code to maintain a pointer to the resultant
+resolved recursive type, even though the Type*'s are potentially invalidated.
+</p>
+
+<p>
+PATypeHolder is an extremely light-weight object that uses a lazy union-find
+implementation to update pointers. For example the pointer from a Value to its
+Type is maintained by PATypeHolder objects.
+</p>
+
+</div>
+
+<!-- ______________________________________________________________________ -->
+<div class="doc_subsubsection">
+ <a name="AbstractTypeUser">The AbstractTypeUser Class</a>
+</div>
+
+<div class="doc_text">
+
+<p>
+Some data structures need more to perform more complex updates when types get
+resolved. The <a href="#SymbolTable">SymbolTable</a> class, for example, needs
+move and potentially merge type planes in its representation when a pointer
+changes.</p>
+
+<p>
+To support this, a class can derive from the AbstractTypeUser class. This class
+allows it to get callbacks when certain types are resolved. To register to get
+callbacks for a particular type, the DerivedType::{add/remove}AbstractTypeUser
+methods can be called on a type. Note that these methods only work for <i>
+abstract</i> types. Concrete types (those that do not include an opaque objects
+somewhere) can never be refined.
+</p>
+</div>
+
+
+<!-- ======================================================================= -->
+<div class="doc_subsection">
+ <a name="SymbolTable">The <tt>SymbolTable</tt> class</a>
+</div>
+
+<div class="doc_text">
+<p>This class provides a symbol table that the <a
+href="#Function"><tt>Function</tt></a> and <a href="#Module">
+<tt>Module</tt></a> classes use for naming definitions. The symbol table can
+provide a name for any <a href="#Value"><tt>Value</tt></a> or <a
+href="#Type"><tt>Type</tt></a>. <tt>SymbolTable</tt> is an abstract data
+type. It hides the data it contains and provides access to it through a
+controlled interface.</p>
+
+<p>Note that the symbol table class is should not be directly accessed by most
+clients. It should only be used when iteration over the symbol table names
+themselves are required, which is very special purpose. Note that not all LLVM
+<a href="#Value">Value</a>s have names, and those without names (i.e. they have
+an empty name) do not exist in the symbol table.
+</p>
+
+<p>To use the <tt>SymbolTable</tt> well, you need to understand the
+structure of the information it holds. The class contains two
+<tt>std::map</tt> objects. The first, <tt>pmap</tt>, is a map of
+<tt>Type*</tt> to maps of name (<tt>std::string</tt>) to <tt>Value*</tt>.
+The second, <tt>tmap</tt>, is a map of names to <tt>Type*</tt>. Thus, Values
+are stored in two-dimensions and accessed by <tt>Type</tt> and name. Types,
+however, are stored in a single dimension and accessed only by name.</p>
+
+<p>The interface of this class provides three basic types of operations:
+<ol>
+ <li><em>Accessors</em>. Accessors provide read-only access to information
+ such as finding a value for a name with the
+ <a href="#SymbolTable_lookup">lookup</a> method.</li>
+ <li><em>Mutators</em>. Mutators allow the user to add information to the
+ <tt>SymbolTable</tt> with methods like
+ <a href="#SymbolTable_insert"><tt>insert</tt></a>.</li>
+ <li><em>Iterators</em>. Iterators allow the user to traverse the content
+ of the symbol table in well defined ways, such as the method
+ <a href="#SymbolTable_type_begin"><tt>type_begin</tt></a>.</li>
+</ol>
+
+<h3>Accessors</h3>
+<dl>
+ <dt><tt>Value* lookup(const Type* Ty, const std::string& name) const</tt>:
+ </dt>
+ <dd>The <tt>lookup</tt> method searches the type plane given by the
+ <tt>Ty</tt> parameter for a <tt>Value</tt> with the provided <tt>name</tt>.
+ If a suitable <tt>Value</tt> is not found, null is returned.</dd>
+
+ <dt><tt>Type* lookupType( const std::string& name) const</tt>:</dt>
+ <dd>The <tt>lookupType</tt> method searches through the types for a
+ <tt>Type</tt> with the provided <tt>name</tt>. If a suitable <tt>Type</tt>
+ is not found, null is returned.</dd>
+
+ <dt><tt>bool hasTypes() const</tt>:</dt>
+ <dd>This function returns true if an entry has been made into the type
+ map.</dd>
+
+ <dt><tt>bool isEmpty() const</tt>:</dt>
+ <dd>This function returns true if both the value and types maps are
+ empty</dd>
+</dl>
+
+<h3>Mutators</h3>
+<dl>
+ <dt><tt>void insert(Value *Val)</tt>:</dt>
+ <dd>This method adds the provided value to the symbol table. The Value must
+ have both a name and a type which are extracted and used to place the value
+ in the correct type plane under the value's name.</dd>
+
+ <dt><tt>void insert(const std::string& Name, Value *Val)</tt>:</dt>
+ <dd> Inserts a constant or type into the symbol table with the specified
+ name. There can be a many to one mapping between names and constants
+ or types.</dd>
+
+ <dt><tt>void insert(const std::string& Name, Type *Typ)</tt>:</dt>
+ <dd> Inserts a type into the symbol table with the specified name. There
+ can be a many-to-one mapping between names and types. This method
+ allows a type with an existing entry in the symbol table to get
+ a new name.</dd>
+
+ <dt><tt>void remove(Value* Val)</tt>:</dt>
+ <dd> This method removes a named value from the symbol table. The
+ type and name of the Value are extracted from \p N and used to
+ lookup the Value in the correct type plane. If the Value is
+ not in the symbol table, this method silently ignores the
+ request.</dd>
+
+ <dt><tt>void remove(Type* Typ)</tt>:</dt>
+ <dd> This method removes a named type from the symbol table. The
+ name of the type is extracted from \P T and used to look up
+ the Type in the type map. If the Type is not in the symbol
+ table, this method silently ignores the request.</dd>
+
+ <dt><tt>Value* remove(const std::string& Name, Value *Val)</tt>:</dt>
+ <dd> Remove a constant or type with the specified name from the
+ symbol table.</dd>
+
+ <dt><tt>Type* remove(const std::string& Name, Type* T)</tt>:</dt>
+ <dd> Remove a type with the specified name from the symbol table.
+ Returns the removed Type.</dd>
+
+ <dt><tt>Value *value_remove(const value_iterator& It)</tt>:</dt>
+ <dd> Removes a specific value from the symbol table.
+ Returns the removed value.</dd>
+
+ <dt><tt>bool strip()</tt>:</dt>
+ <dd> This method will strip the symbol table of its names leaving
+ the type and values. </dd>
+
+ <dt><tt>void clear()</tt>:</dt>
+ <dd>Empty the symbol table completely.</dd>
+</dl>
+
+<h3>Iteration</h3>
+<p>The following functions describe three types of iterators you can obtain
+the beginning or end of the sequence for both const and non-const. It is
+important to keep track of the different kinds of iterators. There are
+three idioms worth pointing out:</p>
+
+<table>
+ <tr><th>Units</th><th>Iterator</th><th>Idiom</th></tr>
+ <tr>
+ <td align="left">Planes Of name/Value maps</td><td>PI</td>
+ <td align="left"><pre><tt>
+for (SymbolTable::plane_const_iterator PI = ST.plane_begin(),
+ PE = ST.plane_end(); PI != PE; ++PI ) {
+ PI->first // <i>This is the Type* of the plane</i>
+ PI->second // <i>This is the SymbolTable::ValueMap of name/Value pairs</i>
+}
+ </tt></pre></td>
+ </tr>
+ <tr>
+ <td align="left">All name/Type Pairs</td><td>TI</td>
+ <td align="left"><pre><tt>
+for (SymbolTable::type_const_iterator TI = ST.type_begin(),
+ TE = ST.type_end(); TI != TE; ++TI ) {
+ TI->first // <i>This is the name of the type</i>
+ TI->second // <i>This is the Type* value associated with the name</i>
+}
+ </tt></pre></td>
+ </tr>
+ <tr>
+ <td align="left">name/Value pairs in a plane</td><td>VI</td>
+ <td align="left"><pre><tt>
+for (SymbolTable::value_const_iterator VI = ST.value_begin(SomeType),
+ VE = ST.value_end(SomeType); VI != VE; ++VI ) {
+ VI->first // <i>This is the name of the Value</i>
+ VI->second // <i>This is the Value* value associated with the name</i>
+}
+ </tt></pre></td>
+ </tr>
+</table>
+
+<p>Using the recommended iterator names and idioms will help you avoid
+making mistakes. Of particular note, make sure that whenever you use
+value_begin(SomeType) that you always compare the resulting iterator
+with value_end(SomeType) not value_end(SomeOtherType) or else you
+will loop infinitely.</p>
+
+<dl>
+
+ <dt><tt>plane_iterator plane_begin()</tt>:</dt>
+ <dd>Get an iterator that starts at the beginning of the type planes.
+ The iterator will iterate over the Type/ValueMap pairs in the
+ type planes. </dd>
+
+ <dt><tt>plane_const_iterator plane_begin() const</tt>:</dt>
+ <dd>Get a const_iterator that starts at the beginning of the type
+ planes. The iterator will iterate over the Type/ValueMap pairs
+ in the type planes. </dd>
+
+ <dt><tt>plane_iterator plane_end()</tt>:</dt>
+ <dd>Get an iterator at the end of the type planes. This serves as
+ the marker for end of iteration over the type planes.</dd>
+
+ <dt><tt>plane_const_iterator plane_end() const</tt>:</dt>
+ <dd>Get a const_iterator at the end of the type planes. This serves as
+ the marker for end of iteration over the type planes.</dd>
+
+ <dt><tt>value_iterator value_begin(const Type *Typ)</tt>:</dt>
+ <dd>Get an iterator that starts at the beginning of a type plane.
+ The iterator will iterate over the name/value pairs in the type plane.
+ Note: The type plane must already exist before using this.</dd>
+
+ <dt><tt>value_const_iterator value_begin(const Type *Typ) const</tt>:</dt>
+ <dd>Get a const_iterator that starts at the beginning of a type plane.
+ The iterator will iterate over the name/value pairs in the type plane.
+ Note: The type plane must already exist before using this.</dd>
+
+ <dt><tt>value_iterator value_end(const Type *Typ)</tt>:</dt>
+ <dd>Get an iterator to the end of a type plane. This serves as the marker
+ for end of iteration of the type plane.
+ Note: The type plane must already exist before using this.</dd>
+
+ <dt><tt>value_const_iterator value_end(const Type *Typ) const</tt>:</dt>
+ <dd>Get a const_iterator to the end of a type plane. This serves as the
+ marker for end of iteration of the type plane.
+ Note: the type plane must already exist before using this.</dd>
+
+ <dt><tt>type_iterator type_begin()</tt>:</dt>
+ <dd>Get an iterator to the start of the name/Type map.</dd>
+
+ <dt><tt>type_const_iterator type_begin() cons</tt>:</dt>
+ <dd> Get a const_iterator to the start of the name/Type map.</dd>
+
+ <dt><tt>type_iterator type_end()</tt>:</dt>
+ <dd>Get an iterator to the end of the name/Type map. This serves as the
+ marker for end of iteration of the types.</dd>
+
+ <dt><tt>type_const_iterator type_end() const</tt>:</dt>
+ <dd>Get a const-iterator to the end of the name/Type map. This serves
+ as the marker for end of iteration of the types.</dd>
+
+ <dt><tt>plane_const_iterator find(const Type* Typ ) const</tt>:</dt>
+ <dd>This method returns a plane_const_iterator for iteration over
+ the type planes starting at a specific plane, given by \p Ty.</dd>
+
+ <dt><tt>plane_iterator find( const Type* Typ </tt>:</dt>
+ <dd>This method returns a plane_iterator for iteration over the
+ type planes starting at a specific plane, given by \p Ty.</dd>
+
+</dl>
+</div>