1
0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-23 19:23:23 +01:00

Make a couple organizational changes. Type no longer derives from Value

(hasn't for ages) so move it up one level in the table of contents.
Type needs to be understood before Value so move it before Value. Make
the descriptions of types stand out a little more.  Add references to the
doxygen for the Type class.

llvm-svn: 33122
This commit is contained in:
Reid Spencer 2007-01-12 17:26:25 +00:00
parent dc1430cb98
commit 01779f41de

View File

@ -99,6 +99,7 @@ with another <tt>Value</tt></a> </li>
<li><a href="#coreclasses">The Core LLVM Class Hierarchy Reference</a>
<ul>
<li><a href="#Type">The <tt>Type</tt> class</a> </li>
<li><a href="#Value">The <tt>Value</tt> class</a>
<ul>
<li><a href="#User">The <tt>User</tt> class</a>
@ -122,7 +123,6 @@ with another <tt>Value</tt></a> </li>
</li>
</ul>
</li>
<li><a href="#Type">The <tt>Type</tt> class</a> </li>
<li><a href="#Argument">The <tt>Argument</tt> class</a></li>
</ul>
</li>
@ -1602,6 +1602,8 @@ will loop infinitely.</p>
<!-- *********************************************************************** -->
<div class="doc_text">
<p><tt>#include "<a href="/doxygen/Type_8h-source.html">llvm/Type.h</a>"</tt>
<br>doxygen info: <a href="/doxygen/classllvm_1_1Type.html">Type Class</a></p>
<p>The Core LLVM classes are the primary means of representing the program
being inspected or transformed. The core LLVM classes are defined in
@ -1610,6 +1612,120 @@ the <tt>lib/VMCore</tt> directory.</p>
</div>
<!-- ======================================================================= -->
<div class="doc_subsection">
<a name="Type">The <tt>Type</tt> class and Derived Types</a>
</div>
<div class="doc_text">
<p><tt>Type</tt> is a superclass of all type classes. Every <tt>Value</tt> has
a <tt>Type</tt>. <tt>Type</tt> cannot be instantiated directly but only
through its subclasses. Certain primitive types (<tt>VoidType</tt>,
<tt>LabelType</tt>, <tt>FloatType</tt> and <tt>DoubleType</tt>) have hidden
subclasses. They are hidden because they offer no useful functionality beyond
what the <tt>Type</tt> class offers except to distinguish themselves from
other subclasses of <tt>Type</tt>.</p>
<p>All other types are subclasses of <tt>DerivedType</tt>. Types can be
named, but this is not a requirement. There exists exactly
one instance of a given shape at any one time. This allows type equality to
be performed with address equality of the Type Instance. That is, given two
<tt>Type*</tt> values, the types are identical if the pointers are identical.
</p>
</div>
<!-- _______________________________________________________________________ -->
<div class="doc_subsubsection">
<a name="m_Value">Important Public Methods</a>
</div>
<div class="doc_text">
<ul>
<li><tt>bool isInteger() const</tt>: Returns true for any integer type except
a one-bit integer (i1). </li>
<li><tt>bool isIntegral() const</tt>: Returns true for any integer type
including a one-bit integer.</li>
<li><tt>bool isFloatingPoint()</tt>: Return true if this is one of the two
floating point types.</li>
<li><tt>bool isAbstract()</tt>: Return true if the type is abstract (contains
an OpaqueType anywhere in its definition).</li>
<li><tt>bool isSized()</tt>: Return true if the type has known size. Things
that don't have a size are abstract types, labels and void.</li>
</ul>
</div>
<!-- _______________________________________________________________________ -->
<div class="doc_subsubsection">
<a name="m_Value">Important Derived Types</a>
</div>
<div class="doc_text">
<dl>
<dt><tt>IntegerType</tt></dt>
<dd>Subclass of DerivedType that represents integer types of any bit width.
Any bit width between <tt>IntegerType::MIN_INT_BITS</tt> (1) and
<tt>IntegerType::MAX_INT_BITS</tt> (~8 million) can be represented.
<ul>
<li><tt>static const IntegerType* get(unsigned NumBits)</tt>: get an integer
type of a specific bit width.</li>
<li><tt>unsigned getBitWidth() const</tt>: Get the bit width of an integer
type.</li>
</ul>
</dd>
<dt><tt>SequentialType</tt></dt>
<dd>This is subclassed by ArrayType and PointerType
<ul>
<li><tt>const Type * getElementType() const</tt>: Returns the type of each
of the elements in the sequential type. </li>
</ul>
</dd>
<dt><tt>ArrayType</tt></dt>
<dd>This is a subclass of SequentialType and defines the interface for array
types.
<ul>
<li><tt>unsigned getNumElements() const</tt>: Returns the number of
elements in the array. </li>
</ul>
</dd>
<dt><tt>PointerType</tt></dt>
<dd>Subclass of SequentialType for pointer types.</li>
<dt><tt>PackedType</tt></dt>
<dd>Subclass of SequentialType for packed (vector) types. A
packed type is similar to an ArrayType but is distinguished because it is
a first class type wherease ArrayType is not. Packed types are used for
vector operations and are usually small vectors of of an integer or floating
point type.</dd>
<dt><tt>StructType</tt></dt>
<dd>Subclass of DerivedTypes for struct types.</dd>
<dt><tt>FunctionType</tt></dt>
<dd>Subclass of DerivedTypes for function types.
<ul>
<li><tt>bool isVarArg() const</tt>: Returns true if its a vararg
function</li>
<li><tt> const Type * getReturnType() const</tt>: Returns the
return type of the function.</li>
<li><tt>const Type * getParamType (unsigned i)</tt>: Returns
the type of the ith parameter.</li>
<li><tt> const unsigned getNumParams() const</tt>: Returns the
number of formal parameters.</li>
</ul>
</dd>
<dt><tt>OpaqueType</tt></dt>
<dd>Sublcass of DerivedType for abstract types. This class
defines no content and is used as a placeholder for some other type. Note
that OpaqueType is used (temporarily) during type resolution for forward
references of types. Once the referenced type is resolved, the OpaqueType
is replaced with the actual type. OpaqueType can also be used for data
abstraction. At link time opaque types can be resolved to actual types
of the same name.</dd>
</dl>
</div>
<!-- ======================================================================= -->
<div class="doc_subsection">
<a name="Value">The <tt>Value</tt> class</a>
@ -2421,113 +2537,6 @@ the various types of Constants.</p>
</li>
</ul>
</div>
<!-- ======================================================================= -->
<div class="doc_subsection">
<a name="Type">The <tt>Type</tt> class and Derived Types</a>
</div>
<div class="doc_text">
<p><tt>Type</tt> is a superclass of all type classes. Every <tt>Value</tt> has
a <tt>Type</tt>. <tt>Type</tt> cannot be instantiated directly but only
through its subclasses. Certain primitive types (<tt>VoidType</tt>,
<tt>LabelType</tt>, <tt>FloatType</tt> and <tt>DoubleType</tt>) have hidden
subclasses. They are hidden because they offer no useful functionality beyond
what the <tt>Type</tt> class offers except to distinguish themselves from
other subclasses of <tt>Type</tt>.</p>
<p>All other types are subclasses of <tt>DerivedType</tt>. Types can be
named, but this is not a requirement. There exists exactly
one instance of a given shape at any one time. This allows type equality to
be performed with address equality of the Type Instance. That is, given two
<tt>Type*</tt> values, the types are identical if the pointers are identical.
</p>
</div>
<!-- _______________________________________________________________________ -->
<div class="doc_subsubsection">
<a name="m_Value">Important Public Methods</a>
</div>
<div class="doc_text">
<ul>
<li><tt>bool isInteger() const</tt>: Returns true for any integer type except
a one-bit integer (i1). </li>
<li><tt>bool isIntegral() const</tt>: Returns true for any integer type
including a one-bit integer.</li>
<li><tt>bool isFloatingPoint()</tt>: Return true if this is one of the two
floating point types.</li>
<li><tt>bool isAbstract()</tt>: Return true if the type is abstract (contains
an OpaqueType anywhere in its definition).</li>
<li><tt>bool isSized()</tt>: Return true if the type has known size. Things
that don't have a size are abstract types, labels and void.</li>
</ul>
</div>
<!-- _______________________________________________________________________ -->
<div class="doc_subsubsection">
<a name="m_Value">Important Derived Types</a>
</div>
<div class="doc_text">
<ul>
<li>IntegerType: Subclass of DerivedType that represents integer types of
any bit width. Any bit width between <tt>IntegerType::MIN_INT_BITS</tt> (1)
and <tt>IntegerType::MAX_INT_BITS</tt> (~8 million) can be represented.
<ul>
<li><tt>static const IntegerType* get(unsigned NumBits)</tt>: get an integer
type of a specific bit width.</li>
<li><tt>unsigned getBitWidth() const</tt>: Get the bit width of an integer
type.</li>
</ul>
</li>
<li>SequentialType : This is subclassed by ArrayType and PointerType
<ul>
<li><tt>const Type * getElementType() const</tt>: Returns the type of each
of the elements in the sequential type. </li>
</ul>
</li>
<li>ArrayType : This is a subclass of SequentialType and defines interface for
array types.
<ul>
<li><tt>unsigned getNumElements() const</tt>: Returns the number of
elements in the array. </li>
</ul>
</li>
<li>PointerType : Subclass of SequentialType for pointer types. </li>
<li>PackedType: Subclass of SequentialType for packed (vector) types. A
packed type is similar to an ArrayType but is distinguished because it is
a first class type wherease ArrayType is not. Packed types are used for
vector operations and are usually small vectors of of an integer or floating
point type.</dd>
<li>StructType : subclass of DerivedTypes for struct types </li>
<li>FunctionType : subclass of DerivedTypes for function types.
<ul>
<li><tt>bool isVarArg() const</tt>: Returns true if its a vararg
function</li>
<li><tt> const Type * getReturnType() const</tt>: Returns the
return type of the function.</li>
<li><tt>const Type * getParamType (unsigned i)</tt>: Returns
the type of the ith parameter.</li>
<li><tt> const unsigned getNumParams() const</tt>: Returns the
number of formal parameters.</li>
</ul>
</li>
<li>OpaqueType: Sublcass of DerivedType for abstract types. This class
defines no content and is used as a placeholder for some other type. Note
that OpaqueType is used (temporarily) during type resolution for forward
references of types. Once the referenced type is resolved, the OpaqueType
is replaced with the actual type. OpaqueType can also be used for data
abstraction. At link time opaque types can be resolved to actual types
of the same name.</li>
</ul>
</div>
<!-- ======================================================================= -->
<div class="doc_subsection">
<a name="Argument">The <tt>Argument</tt> class</a>