docs/ProgrammersManual.html

   1 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
   2 <html><head><title>LLVM Programmer's Manual</title></head>
   3
   4 <body bgcolor=white>
   5
   6
   7 <table width="100%" bgcolor="#330077" border=0 cellpadding=4 cellspacing=0>
   8 <tr><td>&nbsp; <font size=+3 color="#EEEEFF" face="Georgia,Palatino,Times,Roman"><b>LLVM Programmer's Manual</b></font></td>
   9 </tr></table>
  10
  11 <ol>
  12   <li><a href="#introduction">Introduction</a>
  13   <li><a href="#general">General Information</a>
  14   <ul>
  15     <li><a href="#stl">The C++ Standard Template Library</a>
  16     <li>The isa&lt;&gt;, cast&lt;&gt; and dyn_cast&lt;&gt; templates
  17   </ul>
  18   <li><a href="#coreclasses">The Core LLVM Class Heirarchy</a>
  19   <ul>
  20     <li><a href="#Value">The <tt>Value</tt> class</a>
  21     <ul>
  22       <li><a href="#User">The <tt>User</tt> class</a>
  23       <ul>
  24         <li><a href="#Instruction">The <tt>Instruction</tt> class</a>
  25         <ul>
  26         <li>
  27         <li>
  28         </ul>
  29         <li><a href="#GlobalValue">The <tt>GlobalValue</tt> class</a>
  30         <ul>
  31           <li><a href="#BasicBlock">The <tt>BasicBlock</tt> class</a>
  32           <li><a href="#Function">The <tt>Function</tt> class</a>
  33           <li><a href="#GlobalVariable">The <tt>GlobalVariable</tt> class</a>
  34         </ul>
  35         <li><a href="#Module">The <tt>Module</tt> class</a>
  36         <li><a href="#Constant">The <tt>Constant</tt> class</a>
  37         <ul>
  38         <li>
  39         <li>
  40         </ul>
  41       </ul>
  42       <li><a href="#Type">The <tt>Type</tt> class</a>
  43       <li><a href="#Argument">The <tt>Argument</tt> class</a>
  44     </ul>
  45     <li>The <tt>SymbolTable</tt> class
  46     <li>The <tt>ilist</tt> and <tt>iplist</tt> classes
  47     <ul>
  48       <li>Creating, inserting, moving and deleting from LLVM lists
  49     </ul>
  50     <li>Important iterator invalidation semantics to be aware of
  51   </ul>
  52
  53 <!--
  54 III. Useful things to know about the LLVM source base:
  55
  56 III.1 Useful links that introduce the STL
  57 III.2 isa<>, cast<>, dyn_cast<>
  58 III.3 Makefiles, useful options
  59 III.4 How to use opt & analyze to debug stuff
  60 III.5 How to write a regression test
  61 III.6 DEBUG() and Statistics (-debug & -stats)
  62 III.7 The -time-passes option
  63 III.8 ... more as needed ...
  64
  65 -->
  66
  67   <p><b>Written by <a href="mailto:dhurjati@cs.uiuc.edu">Dinakar Dhurjati</a>
  68       and <a href="mailto:sabre@nondot.org">Chris Lattner</a></b><p>
  69 </ol>
  70
  71
  72 <!-- *********************************************************************** -->
  73 <table width="100%" bgcolor="#330077" border=0 cellpadding=4 cellspacing=0>
  74 <tr><td align=center><font color="#EEEEFF" size=+2 face="Georgia,Palatino"><b>
  75 <a name="introduction">Introduction
  76 </b></font></td></tr></table><ul>
  77 <!-- *********************************************************************** -->
  78
  79 This document is meant to hi-light some of the important classes and interfaces
  80 available in the LLVM source-base.  This manual is not indended to explain what
  81 LLVM is, how it works, and what LLVM code looks like.  It assumes that you know
  82 the basics of LLVM and are interested in writing transformations or otherwise
  83 analyzing or manipulating the code.<p>
  84
  85 This document should get you oriented so that you can find your way in the
  86 continuously growing source code that makes up the LLVM infrastructure.  Note
  87 that this manual is not intended to serve as a replacement for reading the
  88 source code, so if you think there should be a method in one of these classes to
  89 do something, but it's not listed, check the source.  Links to the <a
  90 href="/doxygen/">doxygen</a> sources are provided to make this as easy as
  91 possible.<p>
  92
  93 The first section of this document describes general information that is useful
  94 to know when working in the LLVM infrastructure, and the second describes the
  95 Core LLVM classes.  In the future this manual will be extended with information
  96 describing how to use extension libraries, such as dominator information, CFG
  97 traversal routines, and useful utilities like the <tt><a
  98 href="/doxygen/InstVisitor_8h-source.html">InstVisitor</a></tt> template.<p>
  99
 100
 101 <!-- *********************************************************************** -->
 102 </ul><table width="100%" bgcolor="#330077" border=0 cellpadding=4 cellspacing=0>
 103 <tr><td align=center><font color="#EEEEFF" size=+2 face="Georgia,Palatino"><b>
 104 <a name="general">General Information
 105 </b></font></td></tr></table><ul>
 106 <!-- *********************************************************************** -->
 107
 108 This section contains general information that is useful if you are working in
 109 the LLVM source-base, but that isn't specific to any particular API.<p>
 110
 111
 112 <!-- ======================================================================= -->
 113 </ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
 114 <tr><td>&nbsp;</td><td width="100%">&nbsp;
 115 <font color="#EEEEFF" face="Georgia,Palatino"><b>
 116 <a name="stl">The C++ Standard Template Library</a>
 117 </b></font></td></tr></table><ul>
 118
 119 LLVM makes heavy use of the C++ Standard Template Library (STL), perhaps much
 120 more than you are used to, or have seen before.  Because of this, you might want
 121 to do a little background reading in the techniques used and capabilities of the
 122 library.  There are many good pages that discuss the STL, and several books on
 123 the subject that you can get, so it will not be discussed in this document.<p>
 124
 125 Here are some useful links:<p>
 126 <ol>
 127 <li><a href="http://www.dinkumware.com/htm_cpl/index.html">Dinkumware C++
 128 Library reference</a> - an excellent reference for the STL and other parts of
 129 the standard C++ library.<br>
 130
 131 <li><a href="http://www.parashift.com/c++-faq-lite/">C++ Frequently Asked
 132 Questions</a>
 133
 134 <li><a href="http://www.sgi.com/tech/stl/">SGI's STL Programmer's Guide</a> -
 135 Contains a useful <a
 136 href="http://www.sgi.com/tech/stl/stl_introduction.html">Introduction to the
 137 STL</a>.
 138
 139 <li><a href="http://www.research.att.com/~bs/C++.html">Bjarne Stroustrup's C++
 140 Page</a>
 141
 142 </ol><p>
 143
 144 You are also encouraged to take a look at the <a
 145 href="CodingStandards.html">LLVM Coding Standards</a> guide which focuses on how
 146 to write maintainable code more than where to put your curly braces.<p>
 147
 148
 149
 150 <!-- *********************************************************************** -->
 151 </ul><table width="100%" bgcolor="#330077" border=0 cellpadding=4 cellspacing=0>
 152 <tr><td align=center><font color="#EEEEFF" size=+2 face="Georgia,Palatino"><b>
 153 <a name="coreclasses">The Core LLVM Class Heirarchy
 154 </b></font></td></tr></table><ul>
 155 <!-- *********************************************************************** -->
 156
 157 The Core LLVM classes are the primary means of representing the program being
 158 inspected or transformed.  The core LLVM classes are defined in header files in
 159 the <tt>include/llvm/</tt> directory, and implemented in the <tt>lib/VMCore</tt>
 160 directory.<p>
 161
 162
 163 <!-- ======================================================================= -->
 164 </ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
 165 <tr><td>&nbsp;</td><td width="100%">&nbsp;
 166 <font color="#EEEEFF" face="Georgia,Palatino"><b>
 167 <a name="Value">The <tt>Value</tt> class</a>
 168 </b></font></td></tr></table><ul>
 169
 170 <tt>#include "<a href="/doxygen/Value_8h-source.html">llvm/Value.h</a>"</tt></b><br>
 171 doxygen info: <a href="/doxygen/classValue.html">Value Class</a><p>
 172
 173
 174 The <tt>Value</tt> class is the most important class in LLVM Source base.  It
 175 represents a typed value that may be used (among other things) as an operand to
 176 an instruction.  There are many different types of <tt>Value</tt>s, such as <a
 177 href="#Constant"><tt>Constant</tt></a>s, <a
 178 href="#Argument"><tt>Argument</tt></a>s, and even <a
 179 href="#Instruction"><tt>Instruction</tt></a>s and <a
 180 href="#Function"><tt>Function</tt></a>s are <tt>Value</tt>s.<p>
 181
 182 A particular <tt>Value</tt> may be used many times in the LLVM representation
 183 for a program.  For example, an incoming argument to a function (represented
 184 with an instance of the <a href="#Argument">Argument</a> class) is "used" by
 185 every instruction in the function that references the argument.  To keep track
 186 of this relationship, the <tt>Value</tt> class keeps a list of all of the <a
 187 href="#User"><tt>User</tt></a>s that is using it (the <a
 188 href="#User"><tt>User</tt></a> class is a base class for all nodes in the LLVM
 189 graph that can refer to <tt>Value</tt>s).  This use list is how LLVM represents
 190 def-use information in the program, and is accessable through the <tt>use_</tt>*
 191 methods, shown below.<p>
 192
 193 Because LLVM is a typed representation, every LLVM <tt>Value</tt> is typed, and
 194 this <a href="#Type">Type</a> is available through the <tt>getType()</tt>
 195 method.  <a name="#nameWarning">In addition, all LLVM values can be named.  The
 196 "name" of the <tt>Value</tt> is symbolic string printed in the LLVM code:<p>
 197
 198 <pre>
 199    %<b>foo</b> = add int 1, 2
 200 </pre>
 201
 202 The name of this instruction is "foo".  <b>NOTE</b> that the name of any value
 203 may be missing (an empty string), so names should <b>ONLY</b> be used for
 204 debugging (making the source code easier to read, debugging printouts), they
 205 should not be used to keep track of values or map between them.  For this
 206 purpose, use a <tt>std::map</tt> of pointers to the <tt>Value</tt> itself
 207 instead.<p>
 208
 209 One important aspect of LLVM is that there is no distinction between an SSA
 210 variable and the operation that produces it.  Because of this, any reference to
 211 the value produced by an instruction (or the value available as an incoming
 212 argument, for example) is represented as a direct pointer to the class that
 213 represents this value.  Although this may take some getting used to, it
 214 simplifies the representation and makes it easier to manipulate.<p>
 215
 216
 217 <!-- _______________________________________________________________________ -->
 218 </ul><h4><a name="m_Value"><hr size=0>Important Public Members of
 219 the <tt>Value</tt> class</h4><ul>
 220
 221 <li><tt>Value::use_iterator</tt> - Typedef for iterator over the use-list<br>
 222     <tt>Value::use_const_iterator</tt>
 223                  - Typedef for const_iterator over the use-list<br>
 224     <tt>unsigned use_size()</tt> - Returns the number of users of the value.<br>
 225     <tt>bool use_empty()</tt> - Returns true if there are no users.<br>
 226     <tt>use_iterator use_begin()</tt>
 227                  - Get an iterator to the start of the use-list.<br>
 228     <tt>use_iterator use_end()</tt>
 229                  - Get an iterator to the end of the use-list.<br>
 230     <tt><a href="#User">User</a> *use_back()</tt>
 231                  - Returns the last element in the list.<p>
 232
 233 These methods are the interface to access the def-use information in LLVM.  As with all other iterators in LLVM, the naming conventions follow the conventions defined by the <a href="#stl">STL</a>.<p>
 234
 235 <li><tt><a href="#Type">Type</a> *getType() const</tt><p>
 236 This method returns the Type of the Value.
 237
 238 <li><tt>bool hasName() const</tt><br>
 239     <tt>std::string getName() const</tt><br>
 240     <tt>void setName(const std::string &amp;Name)</tt><p>
 241
 242 This family of methods is used to access and assign a name to a <tt>Value</tt>,
 243 be aware of the <a href="#nameWarning">precaution above</a>.<p>
 244
 245
 246 <li><tt>void replaceAllUsesWith(Value *V)</tt><p>
 247
 248 This method traverses the use list of a <tt>Value</tt> changing all <a
 249 href="#User"><tt>User</tt>'s</a> of the current value to refer to "<tt>V</tt>"
 250 instead.  For example, if you detect that an instruction always produces a
 251 constant value (for example through constant folding), you can replace all uses
 252 of the instruction with the constant like this:<p>
 253
 254 <pre>
 255   Inst-&gt;replaceAllUsesWith(ConstVal);
 256 </pre><p>
 257
 258
 259
 260 <!-- ======================================================================= -->
 261 </ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
 262 <tr><td>&nbsp;</td><td width="100%">&nbsp;
 263 <font color="#EEEEFF" face="Georgia,Palatino"><b>
 264 <a name="User">The <tt>User</tt> class</a>
 265 </b></font></td></tr></table><ul>
 266
 267 <tt>#include "<a href="/doxygen/User_8h-source.html">llvm/User.h</a>"</tt></b><br>
 268 doxygen info: <a href="/doxygen/classUser.html">User Class</a><br>
 269 Superclass: <a href="#Value"><tt>Value</tt></a><p>
 270
 271
 272 The <tt>User</tt> class is the common base class of all LLVM nodes that may
 273 refer to <a href="#Value"><tt>Value</tt></a>s.  It exposes a list of "Operands"
 274 that are all of the <a href="#Value"><tt>Value</tt></a>s that the User is
 275 referring to.  The <tt>User</tt> class itself is a subclass of
 276 <tt>Value</tt>.<p>
 277
 278 The operands of a <tt>User</tt> point directly to the LLVM <a
 279 href="#Value"><tt>Value</tt></a> that it refers to.  Because LLVM uses Static
 280 Single Assignment (SSA) form, there can only be one definition referred to,
 281 allowing this direct connection.  This connection provides the use-def
 282 information in LLVM.<p>
 283
 284 <!-- _______________________________________________________________________ -->
 285 </ul><h4><a name="m_User"><hr size=0>Important Public Members of
 286 the <tt>User</tt> class</h4><ul>
 287
 288 The <tt>User</tt> class exposes the operand list in two ways: through an index
 289 access interface and through an iterator based interface.<p>
 290
 291 <li><tt>Value *getOperand(unsigned i)</tt><br>
 292     <tt>unsigned getNumOperands()</tt><p>
 293
 294 These two methods expose the operands of the <tt>User</tt> in a convenient form
 295 for direct access.<p>
 296
 297 <li><tt>User::op_iterator</tt> - Typedef for iterator over the operand list<br>
 298     <tt>User::op_const_iterator</tt>
 299     <tt>use_iterator op_begin()</tt>
 300                  - Get an iterator to the start of the operand list.<br>
 301     <tt>use_iterator op_end()</tt>
 302                  - Get an iterator to the end of the operand list.<p>
 303
 304 Together, these methods make up the iterator based interface to the operands of
 305 a <tt>User</tt>.<p>
 306
 307
 308
 309 <!-- ======================================================================= -->
 310 </ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
 311 <tr><td>&nbsp;</td><td width="100%">&nbsp;
 312 <font color="#EEEEFF" face="Georgia,Palatino"><b>
 313 <a name="Instruction">The <tt>Instruction</tt> class</a>
 314 </b></font></td></tr></table><ul>
 315
 316 <tt>#include "<a
 317 href="/doxygen/Instruction_8h-source.html">llvm/Instruction.h</a>"</tt></b><br>
 318 doxygen info: <a href="/doxygen/classInstruction.html">Instruction Class</a><br>
 319 Superclasses: <a href="#User"><tt>User</tt></a>, <a
 320 href="#Value"><tt>Value</tt></a><p>
 321
 322 The <tt>Instruction</tt> class is the common base class for all LLVM
 323 instructions.  It provides only a few methods, but is a very commonly used
 324 class.  The primary data tracked by the <tt>Instruction</tt> class itself is the
 325 opcode (instruction type) and the parent <a
 326 href="#BasicBlock"><tt>BasicBlock</tt></a> the <tt>Instruction</tt> is embedded
 327 into.  To represent a specific type of instruction, one of many subclasses of
 328 <tt>Instruction</tt> are used.<p>
 329
 330 Because the <tt>Instruction</tt> class subclasses the <a
 331 href="#User"><tt>User</tt></a> class, its operands can be accessed in the same
 332 way as for other <a href="#User"><tt>User</tt></a>s (with the
 333 <tt>getOperand()</tt>/<tt>getNumOperands()</tt> and
 334 <tt>op_begin()</tt>/<tt>op_end()</tt> methods).<p>
 335
 336
 337 <!-- _______________________________________________________________________ -->
 338 </ul><h4><a name="m_Instruction"><hr size=0>Important Public Members of
 339 the <tt>Instruction</tt> class</h4><ul>
 340
 341 <li><tt><a href="#BasicBlock">BasicBlock</a> *getParent()</tt><p>
 342
 343 Returns the <a href="#BasicBlock"><tt>BasicBlock</tt></a> that this
 344 <tt>Instruction</tt> is embedded into.<p>
 345
 346 <li><tt>bool hasSideEffects()</tt><p>
 347
 348 Returns true if the instruction has side effects, i.e. it is a <tt>call</tt>,
 349 <tt>free</tt>, <tt>invoke</tt>, or <tt>store</tt>.<p>
 350
 351 <li><tt>unsigned getOpcode()</tt><p>
 352
 353 Returns the opcode for the <tt>Instruction</tt>.<p>
 354
 355 <!--
 356
 357 \subsection{Subclasses of Instruction :}
 358 \begin{itemize}
 359 <li>BinaryOperator : This subclass of Instruction defines a general interface to the all the instructions involvong  binary operators in LLVM.
 360         \begin{itemize}
 361         <li><tt>bool swapOperands()</tt>: Exchange the two operands to this instruction. If the instruction cannot be reversed (i.e. if it's a Div), it returns true.
 362         \end{itemize}
 363 <li>TerminatorInst : This subclass of Instructions defines an interface for all instructions that can terminate a BasicBlock.
 364         \begin{itemize}
 365          <li> <tt>unsigned getNumSuccessors()</tt>: Returns the number of successors for this terminator instruction.
 366         <li><tt>BasicBlock *getSuccessor(unsigned i)</tt>: As the name suggests returns the ith successor BasicBlock.
 367         <li><tt>void setSuccessor(unsigned i, BasicBlock *B)</tt>: sets BasicBlock B as the ith succesor to this terminator instruction.
 368         \end{itemize}
 369
 370 <li>PHINode : This represents the PHI instructions in the SSA form.
 371         \begin{itemize}
 372         <li><tt> unsigned getNumIncomingValues()</tt>: Returns the number of incoming edges to this PHI node.
 373         <li><tt> Value *getIncomingValue(unsigned i)</tt>: Returns the ith incoming Value.
 374         <li><tt>void setIncomingValue(unsigned i, Value *V)</tt>: Sets the ith incoming Value as V
 375         <li><tt>BasicBlock *getIncomingBlock(unsigned i)</tt>: Returns the Basic Block corresponding to the ith incoming Value.
 376         <li><tt> void addIncoming(Value *D, BasicBlock *BB)</tt>:
 377         Add an incoming value to the end of the PHI list
 378         <li><tt> int getBasicBlockIndex(const BasicBlock *BB) const</tt>:
 379         Returns the first index of the specified basic block in the value list for this PHI.  Returns -1 if no instance.
 380         \end{itemize}
 381 <li>CastInst : In LLVM all casts have to be done through explicit cast instructions. CastInst defines the interface to the cast instructions.
 382 <li>CallInst : This defines an interface to the call instruction in LLVM. ARguments to the function are nothing but operands of the instruction.
 383         \begin{itemize}
 384         <li>: <tt>Function *getCalledFunction()</tt>: Returns a handle to the function that is being called by this Function.
 385         \end{itemize}
 386 <li>LoadInst, StoreInst, GetElemPtrInst : These subclasses represent load, store and getelementptr instructions in LLVM.
 387         \begin{itemize}
 388         <li><tt>Value * getPointerOperand ()</tt>: Returns the Pointer Operand which is typically the 0th operand.
 389         \end{itemize}
 390 <li>BranchInst : This is a subclass of TerminatorInst and defines the interface for conditional and unconditional branches in LLVM.
 391         \begin{itemize}
 392         <li><tt>bool isConditional()</tt>: Returns true if the branch is a conditional branch else returns false
 393         <li> <tt>Value *getCondition()</tt>: Returns the condition if it is a conditional branch else returns null.
 394         <li> <tt>void setUnconditionalDest(BasicBlock *Dest)</tt>: Changes the current branch to an unconditional one targetting the specified block.
 395         \end{itemize}
 396
 397 \end{itemize}
 398
 399 -->
 400
 401
 402 <!-- ======================================================================= -->
 403 </ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
 404 <tr><td>&nbsp;</td><td width="100%">&nbsp;
 405 <font color="#EEEEFF" face="Georgia,Palatino"><b>
 406 <a name="BasicBlock">The <tt>BasicBlock</tt> class</a>
 407 </b></font></td></tr></table><ul>
 408
 409 <tt>#include "<a
 410 href="/doxygen/BasicBlock_8h-source.html">llvm/BasicBlock.h</a>"</tt></b><br>
 411 doxygen info: <a href="/doxygen/classBasicBlock.html">BasicBlock Class</a><br>
 412 Superclass: <a href="#Value"><tt>Value</tt></a><p>
 413
 414
 415 This class represents a single entry multiple exit section of the code, commonly
 416 known as a basic block by the compiler community.  The <tt>BasicBlock</tt> class
 417 maintains a list of <a href="#Instruction"><tt>Instruction</tt></a>s, which form
 418 the body of the block.  Matching the language definition, the last element of
 419 this list of instructions is always a terminator instruction (a subclass of the
 420 <a href="#TerminatorInst"><tt>TerminatorInst</tt></a> class).<p>
 421
 422 In addition to tracking the list of instructions that make up the block, the
 423 <tt>BasicBlock</tt> class also keeps track of the <a
 424 href="#Function"><tt>Function</tt></a> that it is embedded into.<p>
 425
 426 Note that <tt>BasicBlock</tt>s themselves are <a
 427 href="#Value"><tt>Value</tt></a>s, because they are referenced by instructions
 428 like branches and can go in the switch tables.  <tt>BasicBlock</tt>s have type
 429 <tt>label</tt>.<p>
 430
 431
 432 <!-- _______________________________________________________________________ -->
 433 </ul><h4><a name="m_BasicBlock"><hr size=0>Important Public Members of
 434 the <tt>BasicBlock</tt> class</h4><ul>
 435
 436 <li><tt>BasicBlock(const std::string &amp;Name = "", <a
 437 href="#Function">Function</a> *Parent = 0)</tt><p>
 438
 439 The <tt>BasicBlock</tt> constructor is used to create new basic blocks for
 440 insertion into a function.  The constructor simply takes a name for the new
 441 block, and optionally a <a href="#Function"><tt>Function</tt></a> to insert it
 442 into.  If the <tt>Parent</tt> parameter is specified, the new
 443 <tt>BasicBlock</tt> is automatically inserted at the end of the specified <a
 444 href="#Function"><tt>Function</tt></a>, if not specified, the BasicBlock must be
 445 manually inserted into the <a href="#Function"><tt>Function</tt></a>.<p>
 446
 447 <li><tt>BasicBlock::iterator</tt> - Typedef for instruction list iterator<br>
 448     <tt>BasicBlock::const_iterator</tt> - Typedef for const_iterator.<br>
 449     <tt>begin()</tt>, <tt>end()</tt>, <tt>front()</tt>, <tt>back()</tt>,
 450     <tt>size()</tt>, <tt>empty()</tt>, <tt>rbegin()</tt>, <tt>rend()</tt><p>
 451
 452 These methods and typedefs are forwarding functions that have the same semantics
 453 as the standard library methods of the same names.  These methods expose the
 454 underlying instruction list of a basic block in a way that is easy to
 455 manipulate.  To get the full complement of container operations (including
 456 operations to update the list), you must use the <tt>getInstList()</tt>
 457 method.<p>
 458
 459 <li><tt>BasicBlock::InstListType &amp;getInstList()</tt><p>
 460
 461 This method is used to get access to the underlying container that actually
 462 holds the Instructions.  This method must be used when there isn't a forwarding
 463 function in the <tt>BasicBlock</tt> class for the operation that you would like
 464 to perform.  Because there are no forwarding functions for "updating"
 465 operations, you need to use this if you want to update the contents of a
 466 <tt>BasicBlock</tt>.<p>
 467
 468 <li><tt><A href="#Function">Function</a> *getParent()</tt><p>
 469
 470 Returns a pointer to <a href="#Function"><tt>Function</tt></a> the block is
 471 embedded into, or a null pointer if it is homeless.<p>
 472
 473 <li><tt><a href="#TerminatorInst">TerminatorInst</a> *getTerminator()</tt><p>
 474
 475 Returns a pointer to the terminator instruction that appears at the end of the
 476 <tt>BasicBlock</tt>.  If there is no terminator instruction, or if the last
 477 instruction in the block is not a terminator, then a null pointer is
 478 returned.<p>
 479
 480
 481 <!-- ======================================================================= -->
 482 </ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
 483 <tr><td>&nbsp;</td><td width="100%">&nbsp;
 484 <font color="#EEEEFF" face="Georgia,Palatino"><b>
 485 <a name="GlobalValue">The <tt>GlobalValue</tt> class</a>
 486 </b></font></td></tr></table><ul>
 487
 488 <tt>#include "<a
 489 href="/doxygen/GlobalValue_8h-source.html">llvm/GlobalValue.h</a>"</tt></b><br>
 490 doxygen info: <a href="/doxygen/classGlobalValue.html">GlobalValue Class</a><br>
 491 Superclasses: <a href="#User"><tt>User</tt></a>, <a
 492 href="#Value"><tt>Value</tt></a><p>
 493
 494 Global values (<A href="#GlobalVariable"><tt>GlobalVariable</tt></a>s or <a
 495 href="#Function"><tt>Function</tt></a>s) are the only LLVM values that are
 496 visible in the bodies of all <a href="#Function"><tt>Function</tt></a>s.
 497 Because they are visible at global scope, they are also subject to linking with
 498 other globals defined in different translation units.  To control the linking
 499 process, <tt>GlobalValue</tt>s know their linkage rules.  Specifically,
 500 <tt>GlobalValue</tt>s know whether they have internal or external linkage.<p>
 501
 502 If a <tt>GlobalValue</tt> has internal linkage (equivalent to being
 503 <tt>static</tt> in C), it is not visible to code outside the current translation
 504 unit, and does not participate in linking.  If it has external linkage, it is
 505 visible to external code, and does participate in linking.  In addition to
 506 linkage information, <tt>GlobalValue</tt>s keep track of which <a
 507 href="#Module"><tt>Module</tt></a> they are currently part of.<p>
 508
 509 Because <tt>GlobalValue</tt>s are memory objects, they are always referred to by
 510 their address.  As such, the <a href="#Type"><tt>Type</tt></a> of a global is
 511 always a pointer to its contents.  This is explained in the LLVM Language
 512 Reference Manual.<p>
 513
 514
 515 <!-- _______________________________________________________________________ -->
 516 </ul><h4><a name="m_GlobalValue"><hr size=0>Important Public Members of
 517 the <tt>GlobalValue</tt> class</h4><ul>
 518
 519 <li><tt>bool hasInternalLinkage() const</tt><br>
 520     <tt>bool hasExternalLinkage() const</tt><br>
 521     <tt>void setInternalLinkage(bool HasInternalLinkage)</tt><p>
 522
 523 These methods manipulate the linkage characteristics of the
 524 <tt>GlobalValue</tt>.<p>
 525
 526 <li><tt><a href="#Module">Module</a> *getParent()</tt><p>
 527
 528 This returns the <a href="#Module"><tt>Module</tt></a> that the GlobalValue is
 529 currently embedded into.<p>
 530
 531
 532
 533 <!-- ======================================================================= -->
 534 </ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
 535 <tr><td>&nbsp;</td><td width="100%">&nbsp;
 536 <font color="#EEEEFF" face="Georgia,Palatino"><b>
 537 <a name="Function">The <tt>Function</tt> class</a>
 538 </b></font></td></tr></table><ul>
 539
 540 <tt>#include "<a
 541 href="/doxygen/Function_8h-source.html">llvm/Function.h</a>"</tt></b><br>
 542 doxygen info: <a href="/doxygen/classFunction.html">Function Class</a><br>
 543 Superclasses: <a href="#GlobalValue"><tt>GlobalValue</tt></a>, <a
 544 href="#User"><tt>User</tt></a>, <a href="#Value"><tt>Value</tt></a><p>
 545
 546 The <tt>Function</tt> class represents a single procedure in LLVM.  It is
 547 actually one of the more complex classes in the LLVM heirarchy because it must
 548 keep track of a large amount of data.  The <tt>Function</tt> class keeps track
 549 of a list of <a href="#BasicBlock"><tt>BasicBlock</tt></a>s, a list of formal <a
 550 href="#Argument"><tt>Argument</tt></a>s, and a <a
 551 href="#SymbolTable"><tt>SymbolTable</tt></a>.<p>
 552
 553 The list of <a href="#BasicBlock"><tt>BasicBlock</tt></a>s is the most commonly
 554 used part of <tt>Function</tt> objects.  The list imposes an implicit ordering
 555 of the blocks in the function, which indicate how the code will be layed out by
 556 the backend.  Additionally, the first <a
 557 href="#BasicBlock"><tt>BasicBlock</tt></a> is the implicit entry node for the
 558 <tt>Function</tt>.  It is not legal in LLVM explicitly branch to this initial
 559 block.  There are no implicit exit nodes, and in fact there may be multiple exit
 560 nodes from a single <tt>Function</tt>.  If the <a
 561 href="#BasicBlock"><tt>BasicBlock</tt></a> list is empty, this indicates that
 562 the <tt>Function</tt> is actually a function declaration: the actual body of the
 563 function hasn't been linked in yet.<p>
 564
 565 In addition to a list of <a href="#BasicBlock"><tt>BasicBlock</tt></a>s, the
 566 <tt>Function</tt> class also keeps track of the list of formal <a
 567 href="#Argument"><tt>Argument</tt></a>s that the function receives.  This
 568 container manages the lifetime of the <a href="#Argument"><tt>Argument</tt></a>
 569 nodes, just like the <a href="#BasicBlock"><tt>BasicBlock</tt></a> list does for
 570 the <a href="#BasicBlock"><tt>BasicBlock</tt></a>s.<p>
 571
 572 The <a href="#SymbolTable"><tt>SymbolTable</tt></a> is a very rarely used LLVM
 573 feature that is only used when you have to look up a value by name.  Aside from
 574 that, the <a href="#SymbolTable"><tt>SymbolTable</tt></a> is used internally to
 575 make sure that there are not conflicts between the names of <a
 576 href="#Instruction"><tt>Instruction</tt></a>s, <a
 577 href="#BasicBlock"><tt>BasicBlock</tt></a>s, or <a
 578 href="#Argument"><tt>Argument</tt></a>s in the function body.<p>
 579
 580
 581 <!-- _______________________________________________________________________ -->
 582 </ul><h4><a name="m_Function"><hr size=0>Important Public Members of
 583 the <tt>Function</tt> class</h4><ul>
 584
 585 <li><tt>Function(const <a href="#FunctionType">FunctionType</a> *Ty, bool isInternal, const std::string &amp;N = "")</tt><p>
 586
 587 Constructor used when you need to create new <tt>Function</tt>s to add the the
 588 program.  The constructor must specify the type of the function to create and
 589 whether or not it should start out with internal or external linkage.<p>
 590
 591 <li><tt>bool isExternal()</tt><p>
 592
 593 Return whether or not the <tt>Function</tt> has a body defined.  If the function
 594 is "external", it does not have a body, and thus must be resolved by linking
 595 with a function defined in a different translation unit.<p>
 596
 597
 598 <li><tt>Function::iterator</tt> - Typedef for basic block list iterator<br>
 599     <tt>Function::const_iterator</tt> - Typedef for const_iterator.<br>
 600     <tt>begin()</tt>, <tt>end()</tt>, <tt>front()</tt>, <tt>back()</tt>,
 601     <tt>size()</tt>, <tt>empty()</tt>, <tt>rbegin()</tt>, <tt>rend()</tt><p>
 602
 603 These are forwarding methods that make it easy to access the contents of a
 604 <tt>Function</tt> object's <a href="#BasicBlock"><tt>BasicBlock</tt></a>
 605 list.<p>
 606
 607 <li><tt>Function::BasicBlockListType &amp;getBasicBlockList()</tt><p>
 608
 609 Returns the list of <a href="#BasicBlock"><tt>BasicBlock</tt></a>s.  This is
 610 neccesary to use when you need to update the list or perform a complex action
 611 that doesn't have a forwarding method.<p>
 612
 613
 614 <li><tt>Function::aiterator</tt> - Typedef for the argument list iterator<br>
 615     <tt>Function::const_aiterator</tt> - Typedef for const_iterator.<br>
 616     <tt>abegin()</tt>, <tt>aend()</tt>, <tt>afront()</tt>, <tt>aback()</tt>,
 617     <tt>asize()</tt>, <tt>aempty()</tt>, <tt>arbegin()</tt>, <tt>arend()</tt><p>
 618
 619 These are forwarding methods that make it easy to access the contents of a
 620 <tt>Function</tt> object's <a href="#Argument"><tt>Argument</tt></a> list.<p>
 621
 622 <li><tt>Function::ArgumentListType &amp;getArgumentList()</tt><p>
 623
 624 Returns the list of <a href="#Argument"><tt>Argument</tt></a>s.  This is
 625 neccesary to use when you need to update the list or perform a complex action
 626 that doesn't have a forwarding method.<p>
 627
 628
 629
 630 <li><tt><a href="#BasicBlock">BasicBlock</a> &getEntryNode()</tt><p>
 631
 632 Returns the entry <a href="#BasicBlock"><tt>BasicBlock</tt></a> for the
 633 function.  Because the entry block for the function is always the first block,
 634 this returns the first block of the <tt>Function</tt>.<p>
 635
 636 <li><tt><a href="#Type">Type</a> *getReturnType()</tt><br>
 637     <tt><a href="#FunctionType">FunctionType</a> *getFunctionType()</tt><p>
 638
 639 This traverses the <a href="#Type"><tt>Type</tt></a> of the <tt>Function</tt>
 640 and returns the return type of the function, or the <a
 641 href="#FunctionType"><tt>FunctionType</tt></a> of the actual function.<p>
 642
 643
 644 <li><tt>bool hasSymbolTable() const</tt><p>
 645
 646 Return true if the <tt>Function</tt> has a symbol table allocated to it and if
 647 there is at least one entry in it.<p>
 648
 649 <li><tt><a href="#SymbolTable">SymbolTable</a> *getSymbolTable()</tt><p>
 650
 651 Return a pointer to the <a href="#SymbolTable"><tt>SymbolTable</tt></a> for this
 652 <tt>Function</tt> or a null pointer if one has not been allocated (because there
 653 are no named values in the function).<p>
 654
 655 <li><tt><a href="#SymbolTable">SymbolTable</a> *getSymbolTableSure()</tt><p>
 656
 657 Return a pointer to the <a href="#SymbolTable"><tt>SymbolTable</tt></a> for this
 658 <tt>Function</tt> or allocate a new <a
 659 href="#SymbolTable"><tt>SymbolTable</tt></a> if one is not already around.  This
 660 should only be used when adding elements to the <a
 661 href="#SymbolTable"><tt>SymbolTable</tt></a>, so that empty symbol tables are
 662 not left laying around.<p>
 663
 664
 665
 666 <!-- ======================================================================= -->
 667 </ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
 668 <tr><td>&nbsp;</td><td width="100%">&nbsp;
 669 <font color="#EEEEFF" face="Georgia,Palatino"><b>
 670 <a name="GlobalVariable">The <tt>GlobalVariable</tt> class</a>
 671 </b></font></td></tr></table><ul>
 672
 673 <tt>#include "<a
 674 href="/doxygen/GlobalVariable_8h-source.html">llvm/GlobalVariable.h</a>"</tt></b><br>
 675 doxygen info: <a href="/doxygen/classGlobalVariable.html">GlobalVariable Class</a><br>
 676 Superclasses: <a href="#GlobalValue"><tt>GlobalValue</tt></a>, <a
 677 href="#User"><tt>User</tt></a>, <a href="#Value"><tt>Value</tt></a><p>
 678
 679 Global variables are represented with the (suprise suprise)
 680 <tt>GlobalVariable</tt> class.  Like functions, <tt>GlobalVariable</tt>s are
 681 also subclasses of <a href="#GlobalValue"><tt>GlobalValue</tt></a>, and as such
 682 are always referenced by their address (global values must live in memory, so
 683 their "name" refers to their address).  Global variables may have an initial
 684 value (which must be a <a href="#Constant"><tt>Constant</tt></a>), and if they
 685 have an initializer, they may be marked as "constant" themselves (indicating
 686 that their contents never change at runtime).<p>
 687
 688
 689 <!-- _______________________________________________________________________ -->
 690 </ul><h4><a name="m_GlobalVariable"><hr size=0>Important Public Members of the
 691 <tt>GlobalVariable</tt> class</h4><ul>
 692
 693 <li><tt>GlobalVariable(const <a href="#Type">Type</a> *Ty, bool isConstant, bool
 694 isInternal, <a href="#Constant">Constant</a> *Initializer = 0, const std::string
 695 &amp;Name = "")</tt><p>
 696
 697 Create a new global variable of the specified type.  If <tt>isConstant</tt> is
 698 true then the global variable will be marked as unchanging for the program, and
 699 if <tt>isInternal</tt> is true the resultant global variable will have internal
 700 linkage.  Optionally an initializer and name may be specified for the global variable as well.<p>
 701
 702
 703 <li><tt>bool isConstant() const</tt><p>
 704
 705 Returns true if this is a global variable is known not to be modified at
 706 runtime.<p>
 707
 708
 709 <li><tt>bool hasInitializer()</tt><p>
 710
 711 Returns true if this <tt>GlobalVariable</tt> has an intializer.<p>
 712
 713
 714 <li><tt><a href="#Constant">Constant</a> *getInitializer()</tt><p>
 715
 716 Returns the intial value for a <tt>GlobalVariable</tt>.  It is not legal to call
 717 this method if there is no initializer.<p>
 718
 719
 720 <!-- ======================================================================= -->
 721 </ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
 722 <tr><td>&nbsp;</td><td width="100%">&nbsp;
 723 <font color="#EEEEFF" face="Georgia,Palatino"><b>
 724 <a name="Module">The <tt>Module</tt> class</a>
 725 </b></font></td></tr></table><ul>
 726
 727 <tt>#include "<a
 728 href="/doxygen/Module_8h-source.html">llvm/Module.h</a>"</tt></b><br>
 729 doxygen info: <a href="/doxygen/classModule.html">Module Class</a><p>
 730
 731 The <tt>Module</tt> class represents the top level structure present in LLVM
 732 programs.  An LLVM module is effectively either a translation unit of the
 733 original program or a combination of several translation units merged by the
 734 linker.  The <tt>Module</tt> class keeps track of a list of <a
 735 href="#Function"><tt>Function</tt></a>s, a list of <a
 736 href="#GlobalVariable"><tt>GlobalVariable</tt></a>s, and a <a
 737 href="#SymbolTable"><tt>SymbolTable</tt></a>.  Additionally, it contains a few
 738 helpful member functions that try to make common operations easy.<p>
 739
 740
 741 <!-- _______________________________________________________________________ -->
 742 </ul><h4><a name="m_Module"><hr size=0>Important Public Members of the
 743 <tt>Module</tt> class</h4><ul>
 744
 745 <li><tt>Module::iterator</tt> - Typedef for function list iterator<br>
 746     <tt>Module::const_iterator</tt> - Typedef for const_iterator.<br>
 747     <tt>begin()</tt>, <tt>end()</tt>, <tt>front()</tt>, <tt>back()</tt>,
 748     <tt>size()</tt>, <tt>empty()</tt>, <tt>rbegin()</tt>, <tt>rend()</tt><p>
 749
 750 These are forwarding methods that make it easy to access the contents of a
 751 <tt>Module</tt> object's <a href="#Function"><tt>Function</tt></a>
 752 list.<p>
 753
 754 <li><tt>Module::FunctionListType &amp;getFunctionList()</tt><p>
 755
 756 Returns the list of <a href="#Function"><tt>Function</tt></a>s.  This is
 757 neccesary to use when you need to update the list or perform a complex action
 758 that doesn't have a forwarding method.<p>
 759
 760 <!--  Global Variable -->
 761 <hr size=0>
 762
 763 <li><tt>Module::giterator</tt> - Typedef for global variable list iterator<br>
 764     <tt>Module::const_giterator</tt> - Typedef for const_iterator.<br>
 765     <tt>gbegin()</tt>, <tt>gend()</tt>, <tt>gfront()</tt>, <tt>gback()</tt>,
 766     <tt>gsize()</tt>, <tt>gempty()</tt>, <tt>grbegin()</tt>, <tt>grend()</tt><p>
 767
 768 These are forwarding methods that make it easy to access the contents of a
 769 <tt>Module</tt> object's <a href="#GlobalVariable"><tt>GlobalVariable</tt></a>
 770 list.<p>
 771
 772 <li><tt>Module::GlobalListType &amp;getGlobalList()</tt><p>
 773
 774 Returns the list of <a href="#GlobalVariable"><tt>GlobalVariable</tt></a>s.
 775 This is neccesary to use when you need to update the list or perform a complex
 776 action that doesn't have a forwarding method.<p>
 777
 778
 779 <!--  Symbol table stuff -->
 780 <hr size=0>
 781
 782 <li><tt>bool hasSymbolTable() const</tt><p>
 783
 784 Return true if the <tt>Module</tt> has a symbol table allocated to it and if
 785 there is at least one entry in it.<p>
 786
 787 <li><tt><a href="#SymbolTable">SymbolTable</a> *getSymbolTable()</tt><p>
 788
 789 Return a pointer to the <a href="#SymbolTable"><tt>SymbolTable</tt></a> for this
 790 <tt>Module</tt> or a null pointer if one has not been allocated (because there
 791 are no named values in the function).<p>
 792
 793 <li><tt><a href="#SymbolTable">SymbolTable</a> *getSymbolTableSure()</tt><p>
 794
 795 Return a pointer to the <a href="#SymbolTable"><tt>SymbolTable</tt></a> for this
 796 <tt>Module</tt> or allocate a new <a
 797 href="#SymbolTable"><tt>SymbolTable</tt></a> if one is not already around.  This
 798 should only be used when adding elements to the <a
 799 href="#SymbolTable"><tt>SymbolTable</tt></a>, so that empty symbol tables are
 800 not left laying around.<p>
 801
 802
 803 <!--  Convenience methods -->
 804 <hr size=0>
 805
 806 <li><tt><a href="#Function">Function</a> *getFunction(const std::string &amp;Name, const <a href="#FunctionType">FunctionType</a> *Ty)</tt><p>
 807
 808 Look up the specified function in the <tt>Module</tt> <a
 809 href="#SymbolTable"><tt>SymbolTable</tt></a>. If it does not exist, return
 810 <tt>null</tt>.<p>
 811
 812
 813 <li><tt><a href="#Function">Function</a> *getOrInsertFunction(const std::string
 814          &amp;Name, const <a href="#FunctionType">FunctionType</a> *T)</tt><p>
 815
 816 Look up the specified function in the <tt>Module</tt> <a
 817 href="#SymbolTable"><tt>SymbolTable</tt></a>. If it does not exist, add an
 818 external declaration for the function and return it.<p>
 819
 820
 821 <li><tt>std::string getTypeName(const <a href="#Type">Type</a> *Ty)</tt><p>
 822
 823 If there is at least one entry in the <a
 824 href="#SymbolTable"><tt>SymbolTable</tt></a> for the specified <a
 825 href="#Type"><tt>Type</tt></a>, return it.  Otherwise return the empty
 826 string.<p>
 827
 828
 829 <li><tt>bool addTypeName(const std::string &Name, const <a href="#Type">Type</a>
 830 *Ty)</tt><p>
 831
 832 Insert an entry in the <a href="#SymbolTable"><tt>SymbolTable</tt></a> mapping
 833 <tt>Name</tt> to <tt>Ty</tt>. If there is already an entry for this name, true
 834 is returned and the <a href="#SymbolTable"><tt>SymbolTable</tt></a> is not
 835 modified.<p>
 836
 837
 838 <!-- ======================================================================= -->
 839 </ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
 840 <tr><td>&nbsp;</td><td width="100%">&nbsp;
 841 <font color="#EEEEFF" face="Georgia,Palatino"><b>
 842 <a name="Constant">The <tt>Constant</tt> class and subclasses</a>
 843 </b></font></td></tr></table><ul>
 844
 845 Constant represents a base class for different types of constants. It is
 846 subclassed by ConstantBool, ConstantInt, ConstantSInt, ConstantUInt,
 847 ConstantArray etc for representing the various types of Constants.<p>
 848
 849
 850 <!-- _______________________________________________________________________ -->
 851 </ul><h4><a name="m_Value"><hr size=0>Important Public Methods</h4><ul>
 852
 853 <li><tt>bool isConstantExpr()</tt>: Returns true if it is a ConstantExpr
 854
 855
 856
 857
 858 \subsection{Important Subclasses of Constant}
 859 \begin{itemize}
 860 <li>ConstantSInt : This subclass of Constant represents a signed integer constant.
 861         \begin{itemize}
 862         <li><tt>int64_t getValue () const</tt>: Returns the underlying value of this constant.
 863         \end{itemize}
 864 <li>ConstantUInt : This class represents an unsigned integer.
 865         \begin{itemize}
 866         <li><tt>uint64_t getValue () const</tt>: Returns the underlying value of this constant.
 867         \end{itemize}
 868 <li>ConstantFP : This class represents a floating point constant.
 869         \begin{itemize}
 870         <li><tt>double getValue () const</tt>: Returns the underlying value of this constant.
 871         \end{itemize}
 872 <li>ConstantBool : This represents a boolean constant.
 873         \begin{itemize}
 874         <li><tt>bool getValue () const</tt>: Returns the underlying value of this constant.
 875         \end{itemize}
 876 <li>ConstantArray : This represents a constant array.
 877         \begin{itemize}
 878         <li><tt>const std::vector<Use> &amp;getValues() const</tt>: Returns a Vecotr of component constants that makeup this array.
 879         \end{itemize}
 880 <li>ConstantStruct : This represents a constant struct.
 881         \begin{itemize}
 882         <li><tt>const std::vector<Use> &amp;getValues() const</tt>: Returns a Vecotr of component constants that makeup this array.
 883         \end{itemize}
 884 <li>ConstantPointerRef : This represents a constant pointer value that is initialized to point to a global value, which lies at a constant fixed address.
 885         \begin{itemize}
 886 <li><tt>GlobalValue *getValue()</tt>: Returns the global value to which this pointer is pointing to.
 887         \end{itemize}
 888 \end{itemize}
 889
 890
 891 <!-- ======================================================================= -->
 892 </ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
 893 <tr><td>&nbsp;</td><td width="100%">&nbsp;
 894 <font color="#EEEEFF" face="Georgia,Palatino"><b>
 895 <a name="Type">The <tt>Type</tt> class and Derived Types</a>
 896 </b></font></td></tr></table><ul>
 897
 898 Type as noted earlier is also a subclass of a Value class.  Any primitive
 899 type (like int, short etc) in LLVM is an instance of Type Class.  All
 900 other types are instances of subclasses of type like FunctionType,
 901 ArrayType etc. DerivedType is the interface for all such dervied types
 902 including FunctionType, ArrayType, PointerType, StructType. Types can have
 903 names. They can be recursive (StructType). There exists exactly one instance
 904 of any type structure at a time. This allows using pointer equality of Type *s for comparing types.
 905
 906 <!-- _______________________________________________________________________ -->
 907 </ul><h4><a name="m_Value"><hr size=0>Important Public Methods</h4><ul>
 908
 909 <li><tt>PrimitiveID getPrimitiveID () const</tt>: Returns the base type of the type.
 910 <li><tt> bool isSigned () const</tt>: Returns whether an integral numeric type is signed. This is true for SByteTy, ShortTy, IntTy, LongTy. Note that this is not true for Float and Double.
 911 <li><tt>bool isUnsigned () const</tt>: Returns whether a numeric type is unsigned. This is not quite the complement of isSigned... nonnumeric types return false as they do with isSigned. This returns true for UByteTy, UShortTy, UIntTy, and ULongTy.
 912 <li><tt> bool isInteger () const</tt>: Equilivent to isSigned() || isUnsigned(), but with only a single virtual function invocation.
 913 <li><tt>bool isIntegral () const</tt>: Returns true if this is an integral type, which is either Bool type or one of the Integer types.
 914
 915 <li><tt>bool isFloatingPoint ()</tt>: Return true if this is one of the two floating point types.
 916 <li><tt>bool isRecursive () const</tt>: Returns rue if the type graph contains a cycle.
 917 <li><tt>isLosslesslyConvertableTo (const Type *Ty) const</tt>: Return true if this type can be converted to 'Ty' without any reinterpretation of bits. For example, uint to int.
 918 <li><tt>bool isPrimitiveType () const</tt>: Returns true if it is a primitive type.
 919 <li><tt>bool isDerivedType () const</tt>: Returns true if it is a derived type.
 920 <li><tt>const Type * getContainedType (unsigned i) const</tt>:
 921 This method is used to implement the type iterator. For derived types, this returns the types 'contained' in the derived type, returning 0 when 'i' becomes invalid. This allows the user to iterate over the types in a struct, for example, really easily.
 922 <li><tt>unsigned getNumContainedTypes () const</tt>: Return the number of types in the derived type.
 923
 924
 925
 926 \subsection{Derived Types}
 927 \begin{itemize}
 928 <li>SequentialType : This is subclassed by ArrayType and PointerType
 929         \begin{itemize}
 930         <li><tt>const Type * getElementType () const</tt>: Returns the type of each of the elements in the sequential type.
 931         \end{itemize}
 932 <li>ArrayType : This is a subclass of SequentialType and defines interface for array types.
 933         \begin{itemize}
 934         <li><tt>unsigned getNumElements () const</tt>: Returns the number of elements in the array.
 935         \end{itemize}
 936 <li>PointerType : Subclass of SequentialType for  pointer types.
 937 <li>StructType : subclass of DerivedTypes for struct types
 938 <li>FunctionType : subclass of DerivedTypes for function types.
 939         \begin{itemize}
 940
 941         <li><tt>bool isVarArg () const</tt>: Returns true if its a vararg function
 942         <li><tt> const Type * getReturnType () const</tt>: Returns the return type of the function.
 943         <li><tt> const ParamTypes &amp;getParamTypes () const</tt>: Returns a vector of parameter types.
 944         <li><tt>const Type * getParamType (unsigned i)</tt>: Returns the type of the ith parameter.
 945         <li><tt> const unsigned getNumParams () const</tt>: Returns the number of formal parameters.
 946         \end{itemize}
 947 \end{itemize}
 948
 949
 950
 951
 952 <!-- ======================================================================= -->
 953 </ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
 954 <tr><td>&nbsp;</td><td width="100%">&nbsp;
 955 <font color="#EEEEFF" face="Georgia,Palatino"><b>
 956 <a name="Argument">The <tt>Argument</tt> class</a>
 957 </b></font></td></tr></table><ul>
 958
 959 This subclass of Value defines the interface for incoming formal arguments to a
 960 function. A Function maitanis a list of its formal arguments. An argument has a
 961 pointer to the parent Function.
 962
 963
 964
 965
 966 <!-- *********************************************************************** -->
 967 </ul>
 968 <!-- *********************************************************************** -->
 969
 970 <hr><font size-1>
 971 <address>By: <a href="mailto:dhurjati@cs.uiuc.edu">Dinakar Dhurjati</a> and
 972 <a href="mailto:sabre@nondot.org">Chris Lattner</a></address>
 973 <!-- Created: Tue Aug  6 15:00:33 CDT 2002 -->
 974 <!-- hhmts start -->
 975 Last modified: Fri Sep  6 09:47:35 CDT 2002
 976 <!-- hhmts end -->
 977 </font></body></html>