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 <table width="100%" bgcolor="#330077" border=0 cellpadding=4 cellspacing=0>
   7 <tr><td>&nbsp; <font size=+3 color="#EEEEFF" face="Georgia,Palatino,Times,Roman"><b>LLVM Programmer's Manual</b></font></td>
   8 </tr></table>
   9
  10 <ol>
  11   <li><a href="#introduction">Introduction</a>
  12   <li><a href="#general">General Information</a>
  13   <ul>
  14     <li><a href="#stl">The C++ Standard Template Library</a>
  15     <li>The isa&lt;&gt;, cast&lt;&gt; and dyn_cast&lt;&gt; templates
  16   </ul>
  17   <li><a href="#common">Helpful Hints for Common Operations</a>
  18   <ul>
  19     <li><a href="#inspection">Basic Inspection and Traversal Routines</a>
  20     <ul>
  21       <li><a href="#iterate_function">Iterating over the <tt>BasicBlock</tt>s
  22                                        in a <tt>Function</tt></a>
  23       <li><a href="#iterate_basicblock">Iterating over the <tt>Instruction</tt>s
  24                                        in a <tt>BasicBlock</tt></a>
  25       <li><a href="#iterate_convert">Turning an iterator into a class
  26                                         pointer</a>
  27       <li><a href="#iterate_complex">Finding call sites: a more complex example</a>
  28     </ul>
  29     <li><a href="#simplechanges">Making simple changes</a>
  30     <ul>
  31       <li>Creating and inserting new <tt>Instruction</tt>s
  32       <li>Deleting <tt>Instruction</tt>s
  33       <li>Replacing an <tt>Instruction</tt> with another <tt>Value</tt>
  34     </ul>
  35 <!--
  36     <li>Working with the Control Flow Graph
  37     <ul>
  38       <li>Accessing predecessors and successors of a <tt>BasicBlock</tt>
  39       <li>
  40       <li>
  41     </ul>
  42 -->
  43     <li>Useful LLVM APIs
  44     <ul>
  45       <li>isa&lt;&gt;, cast&lt;&gt;, and dyn_cast&lt;&gt; templates
  46 <!--
  47       <li>The general graph API
  48       <li>The <tt>InstVisitor</tt> template
  49       <li>The DEBUG() macro
  50       <li>The <tt>Statistic</tt> template
  51 -->
  52     </ul>
  53 <!--
  54     <li>Useful related topics
  55     <ul>
  56       <li>The <tt>-time-passes</tt> option
  57       <li>How to use the LLVM Makefile system
  58       <li>How to write a regression test
  59       <li>
  60     </ul>
  61 -->
  62   </ul>
  63   <li><a href="#coreclasses">The Core LLVM Class Hierarchy Reference</a>
  64   <ul>
  65     <li><a href="#Value">The <tt>Value</tt> class</a>
  66     <ul>
  67       <li><a href="#User">The <tt>User</tt> class</a>
  68       <ul>
  69         <li><a href="#Instruction">The <tt>Instruction</tt> class</a>
  70         <ul>
  71         <li>
  72         <li>
  73         </ul>
  74         <li><a href="#GlobalValue">The <tt>GlobalValue</tt> class</a>
  75         <ul>
  76           <li><a href="#BasicBlock">The <tt>BasicBlock</tt> class</a>
  77           <li><a href="#Function">The <tt>Function</tt> class</a>
  78           <li><a href="#GlobalVariable">The <tt>GlobalVariable</tt> class</a>
  79         </ul>
  80         <li><a href="#Module">The <tt>Module</tt> class</a>
  81         <li><a href="#Constant">The <tt>Constant</tt> class</a>
  82         <ul>
  83         <li>
  84         <li>
  85         </ul>
  86       </ul>
  87       <li><a href="#Type">The <tt>Type</tt> class</a>
  88       <li><a href="#Argument">The <tt>Argument</tt> class</a>
  89     </ul>
  90     <li>The <tt>SymbolTable</tt> class
  91     <li>The <tt>ilist</tt> and <tt>iplist</tt> classes
  92     <ul>
  93       <li>Creating, inserting, moving and deleting from LLVM lists
  94     </ul>
  95     <li>Important iterator invalidation semantics to be aware of
  96   </ul>
  97
  98   <p><b>Written by <a href="mailto:dhurjati@cs.uiuc.edu">Dinakar Dhurjati</a>
  99       and <a href="mailto:sabre@nondot.org">Chris Lattner</a></b><p>
 100 </ol>
 101
 102
 103 <!-- *********************************************************************** -->
 104 <table width="100%" bgcolor="#330077" border=0 cellpadding=4 cellspacing=0>
 105 <tr><td align=center><font color="#EEEEFF" size=+2 face="Georgia,Palatino"><b>
 106 <a name="introduction">Introduction
 107 </b></font></td></tr></table><ul>
 108 <!-- *********************************************************************** -->
 109
 110 This document is meant to highlight some of the important classes and interfaces
 111 available in the LLVM source-base.  This manual is not intended to explain what
 112 LLVM is, how it works, and what LLVM code looks like.  It assumes that you know
 113 the basics of LLVM and are interested in writing transformations or otherwise
 114 analyzing or manipulating the code.<p>
 115
 116 This document should get you oriented so that you can find your way in the
 117 continuously growing source code that makes up the LLVM infrastructure.  Note
 118 that this manual is not intended to serve as a replacement for reading the
 119 source code, so if you think there should be a method in one of these classes to
 120 do something, but it's not listed, check the source.  Links to the <a
 121 href="/doxygen/">doxygen</a> sources are provided to make this as easy as
 122 possible.<p>
 123
 124 The first section of this document describes general information that is useful
 125 to know when working in the LLVM infrastructure, and the second describes the
 126 Core LLVM classes.  In the future this manual will be extended with information
 127 describing how to use extension libraries, such as dominator information, CFG
 128 traversal routines, and useful utilities like the <tt><a
 129 href="/doxygen/InstVisitor_8h-source.html">InstVisitor</a></tt> template.<p>
 130
 131
 132 <!-- *********************************************************************** -->
 133 </ul><table width="100%" bgcolor="#330077" border=0 cellpadding=4 cellspacing=0>
 134 <tr><td align=center><font color="#EEEEFF" size=+2 face="Georgia,Palatino"><b>
 135 <a name="general">General Information
 136 </b></font></td></tr></table><ul>
 137 <!-- *********************************************************************** -->
 138
 139 This section contains general information that is useful if you are working in
 140 the LLVM source-base, but that isn't specific to any particular API.<p>
 141
 142
 143 <!-- ======================================================================= -->
 144 </ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
 145 <tr><td>&nbsp;</td><td width="100%">&nbsp;
 146 <font color="#EEEEFF" face="Georgia,Palatino"><b>
 147 <a name="stl">The C++ Standard Template Library</a>
 148 </b></font></td></tr></table><ul>
 149
 150 LLVM makes heavy use of the C++ Standard Template Library (STL), perhaps much
 151 more than you are used to, or have seen before.  Because of this, you might want
 152 to do a little background reading in the techniques used and capabilities of the
 153 library.  There are many good pages that discuss the STL, and several books on
 154 the subject that you can get, so it will not be discussed in this document.<p>
 155
 156 Here are some useful links:<p>
 157 <ol>
 158 <li><a href="http://www.dinkumware.com/htm_cpl/index.html">Dinkumware C++
 159 Library reference</a> - an excellent reference for the STL and other parts of
 160 the standard C++ library.<br>
 161
 162 <li><a href="http://www.parashift.com/c++-faq-lite/">C++ Frequently Asked
 163 Questions</a>
 164
 165 <li><a href="http://www.sgi.com/tech/stl/">SGI's STL Programmer's Guide</a> -
 166 Contains a useful <a
 167 href="http://www.sgi.com/tech/stl/stl_introduction.html">Introduction to the
 168 STL</a>.
 169
 170 <li><a href="http://www.research.att.com/~bs/C++.html">Bjarne Stroustrup's C++
 171 Page</a>
 172
 173 </ol><p>
 174
 175 You are also encouraged to take a look at the <a
 176 href="CodingStandards.html">LLVM Coding Standards</a> guide which focuses on how
 177 to write maintainable code more than where to put your curly braces.<p>
 178
 179
 180
 181 <!-- *********************************************************************** -->
 182 </ul><table width="100%" bgcolor="#330077" border=0 cellpadding=4 cellspacing=0>
 183 <tr><td align=center><font color="#EEEEFF" size=+2 face="Georgia,Palatino"><b>
 184 <a name="common">Helpful Hints for Common Operations
 185 </b></font></td></tr></table><ul>
 186 <!-- *********************************************************************** -->
 187
 188 This section describes how to perform some very simple transformations of LLVM
 189 code.  This is meant to give examples of common idioms used, showing the
 190 practical side of LLVM transformations.<p>
 191
 192 Because this is a "how-to" section, you should also read about the main classes
 193 that you will be working with.  The <a href="#coreclasses">Core LLVM Class
 194 Hierarchy Reference</a> contains details and descriptions of the main classes
 195 that you should know about.<p>
 196
 197 <!-- NOTE: this section should be heavy on example code -->
 198
 199
 200 <!-- ======================================================================= -->
 201 </ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
 202 <tr><td>&nbsp;</td><td width="100%">&nbsp;
 203 <font color="#EEEEFF" face="Georgia,Palatino"><b>
 204 <a name="inspection">Basic Inspection and Traversal Routines</a>
 205 </b></font></td></tr></table><ul>
 206
 207
 208 <!-- LLVM has heirarchical representation: Module, Function, BasicBlock,
 209 Instruction.  Common patterns for all levels. -->
 210
 211 <!-- _______________________________________________________________________ -->
 212 </ul><h4><a name="iterate_function"><hr size=0>Iterating over the
 213 <tt>BasicBlock</tt>s in a <tt>Function</tt> </h4><ul>
 214
 215 It's quite common to have a <tt>Function</tt> instance that you'd like
 216 to transform in some way; in particular, you'd like to manipulate its
 217 <tt>BasicBlock</tt>s.  To facilitate this, you'll need to iterate over
 218 all of the <tt>BasicBlock</tt>s that constitute the <tt>Function</tt>.
 219 The following is an example that prints the name of a
 220 <tt>BasicBlock</tt> and the number of <tt>Instruction</tt>s it
 221 contains:
 222
 223 <pre>
 224   // func is a pointer to a Function instance
 225   for(Function::iterator i = func->begin(), e = func->end(); i != e; ++i) {
 226
 227       // print out the name of the basic block if it has one, and then the
 228       // number of instructions that it contains
 229
 230       cerr << "Basic block (name=" << i->getName() << ") has "
 231            << i->size() << " instructions.\n";
 232   }
 233 </pre>
 234
 235 Note that i can be used as if it were a pointer for the purposes of
 236 invoking member functions of the <tt>Instruction</tt> class.  This is
 237 because the indirection operator is overloaded for the iterator
 238 classes.  In the above code, the expression <tt>i->size()</tt> is
 239 exactly equivalent to <tt>(*i).size()</tt> just like you'd expect.
 240
 241 <!-- _______________________________________________________________________ -->
 242 </ul><h4><a name="iterate_basicblock"><hr size=0>Iterating over the
 243 <tt>Instruction</tt>s in a <tt>BasicBlock</tt> </h4><ul>
 244
 245 Just like when dealing with <tt>BasicBlock</tt>s in <tt>Function</tt>s, it's
 246 easy to iterate over the individual instructions that make up
 247 <tt>BasicBlock</tt>s.  Here's a code snippet that prints out each instruction in
 248 a <tt>BasicBlock</tt>:
 249
 250 <pre>
 251   // blk is a pointer to a BasicBlock instance
 252   for(BasicBlock::iterator i = blk->begin(), e = blk->end(); i != e; ++i) {
 253      // the next statement works since operator<<(ostream&,...)
 254      // is overloaded for Instruction&
 255
 256      cerr << *i << endl;
 257   }
 258 </pre>
 259
 260 However, this isn't really the best way to print out the contents of a
 261 <tt>BasicBlock</tt>!  Since the ostream operators are overloaded for
 262 virtually anything you'll care about, you could have just invoked the
 263 print routine on the basic block itself: <tt>cerr << blk <<
 264 endl;</tt>.  You might expect this to print out the pointer value of
 265 blk, but operator<< is overloaded for BasicBlock* as well: if you
 266 really want to print the pointer value explicitly, you'll have to
 267 cast.
 268
 269 <!-- _______________________________________________________________________ -->
 270 </ul><h4><a name="iterate_convert"><hr size=0>Turning an iterator into a class
 271 pointer </h4><ul>
 272
 273 Sometimes, it'll be useful to grab a reference (or pointer) to a class
 274 instance when all you've got at hand is an iterator.  Well, extracting
 275 a reference or a pointer from an iterator is very straightforward.
 276 Assuming that <tt>i</tt> is a <tt>BasicBlock::iterator</tt> and
 277 <tt>j</tt> is a <tt>BasicBlock::const_iterator</tt>:
 278
 279 <pre>
 280     Instruction& inst = *i;   // grab reference to instruction reference
 281     Instruction* pinst = &*i; // grab pointer to instruction reference
 282     const Instruction& inst = *j;
 283 </pre>
 284 However, the iterators you'll be working with in the LLVM framework
 285 are special: they will automatically convert to a ptr-to-instance type
 286 whenever they need to.  Instead of dereferencing the iterator and then
 287 taking the address of the result, you can simply assign the iterator
 288 to the proper pointer type and you get the dereference and address-of
 289 operation as a result of the assignment (behind the scenes, this is a
 290 result of overloading casting mechanisms).  Thus the last line of the
 291 last example,
 292
 293 <pre>Instruction* pinst = &*i;</pre>
 294
 295 is semantically equivalent to
 296
 297 <pre>Instruction* pinst = i;</pre>
 298
 299 <b>Caveat emptor</b>: The above syntax works <i>only</i> when you're
 300 <i>not</i> working with <tt>dyn_cast</tt>.  The template definition of
 301 <tt>dyn_cast</tt> isn't implemented to handle this yet, so you'll
 302 still need the following in order for things to work properly:
 303
 304 <pre>
 305 BasicBlock::iterator bbi = ...;
 306 BranchInst* b = dyn_cast<BranchInst>(&*bbi);
 307 </pre>
 308
 309 The following code snippet illustrates use of the conversion
 310 constructors provided by LLVM iterators.  By using these, you can
 311 explicitly grab the iterator of something without actually obtaining
 312 it via iteration over some structure:
 313
 314 <pre>
 315 void printNextInstruction(Instruction* inst) {
 316     BasicBlock::iterator it(inst);
 317     ++it; // after this line, it refers to the instruction after *inst.
 318     if(it != inst->getParent()->end()) cerr << *it << endl;
 319 }
 320 </pre>
 321
 322 Of course, this example is strictly pedagogical, because it'd be
 323 better to do something like
 324
 325 <pre>if(inst->getNext()) cerr << inst->getNext() << endl;</pre>
 326
 327
 328 <!--   dereferenced iterator = Class &
 329        iterators have converting constructor for 'Class *'
 330        iterators automatically convert to 'Class *' except in dyn_cast<> case
 331  -->
 332
 333 <!--
 334 _______________________________________________________________________
 335 --> </ul><h4><a name="iterate_complex"><hr size=0>Finding call sites:
 336 a slightly more complex example
 337 </h4><ul>
 338
 339 Say that you're writing a FunctionPass and would like to count all the
 340 locations in the entire module (that is, across every <tt>Function</tt>)
 341 where a certain function named foo (that takes an int and returns an
 342 int) is called.  As you'll learn later, you may want to use an
 343 <tt>InstVisitor</tt> to accomplish this in a much more straightforward
 344 manner, but this example will allow us to explore how you'd do it if
 345 you didn't have <tt>InstVisitor</tt> around.  In pseudocode, this is
 346 what we want to do:
 347
 348 <pre>
 349 initialize callCounter to zero
 350 for each Function f in the Module
 351     for each BasicBlock b in f
 352       for each Instruction i in b
 353         if(i is a CallInst and foo is the function it calls)
 354           increment callCounter
 355 </pre>
 356
 357 And the actual code is (remember, since we're writing a
 358 <tt>FunctionPass</tt> our <tt>FunctionPass</tt>-derived class simply
 359 has to override the <tt>runOnFunction</tt> method...):
 360
 361 <pre>
 362
 363 // Assume callCounter is a private member of the pass class being written,
 364 // and has been initialized in the pass class constructor.
 365
 366 virtual runOnFunction(Function& F) {
 367
 368     // Remember, we assumed that the signature of foo was "int foo(int)";
 369     // the first thing we'll do is grab the pointer to that function (as a
 370     // Function*) so we can use it later when we're examining the
 371     // parameters of a CallInst.  All of the code before the call to
 372     // Module::getOrInsertFunction() is in preparation to do symbol-table
 373     // to find the function pointer.
 374
 375     vector<const Type*> params;
 376     params.push_back(Type::IntTy);
 377     const FunctionType* fooType = FunctionType::get(Type::IntTy, params);
 378     Function* foo = F.getParent()->getOrInsertFunction("foo", fooType);
 379
 380     // Start iterating and (as per the pseudocode), increment callCounter.
 381
 382     for(Function::iterator b = F.begin(), be = F.end(); b != be; ++b) {
 383        for(BasicBlock::iterator i = b->begin(); ie = b->end(); i != ie; ++i) {
 384            if(CallInst* callInst = dyn_cast<CallInst>(&*inst)) {
 385                // we know we've encountered a call instruction, so we
 386                // need to determine if it's a call to foo or not
 387
 388                if(callInst->getCalledFunction() == foo)
 389                    ++callCounter;
 390            }
 391        }
 392     }
 393 }
 394 </pre>
 395
 396 We could then print out the value of callCounter (if we wanted to)
 397 inside the doFinalization method of our FunctionPass.
 398
 399
 400 <!-- ======================================================================= -->
 401 </ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
 402 <tr><td>&nbsp;</td><td width="100%">&nbsp;
 403 <font color="#EEEEFF" face="Georgia,Palatino"><b>
 404 <a name="simplechanges">Making simple changes</a>
 405 </b></font></td></tr></table><ul>
 406
 407 <!-- Value::replaceAllUsesWith
 408      User::replaceUsesOfWith
 409   Point out: include/llvm/Transforms/Utils/
 410     especially BasicBlockUtils.h with:
 411          ReplaceInstWithValue, ReplaceInstWithInst
 412
 413 -->
 414
 415
 416 <!-- *********************************************************************** -->
 417 </ul><table width="100%" bgcolor="#330077" border=0 cellpadding=4 cellspacing=0>
 418 <tr><td align=center><font color="#EEEEFF" size=+2 face="Georgia,Palatino"><b>
 419 <a name="coreclasses">The Core LLVM Class Hierarchy Reference
 420 </b></font></td></tr></table><ul>
 421 <!-- *********************************************************************** -->
 422
 423 The Core LLVM classes are the primary means of representing the program being
 424 inspected or transformed.  The core LLVM classes are defined in header files in
 425 the <tt>include/llvm/</tt> directory, and implemented in the <tt>lib/VMCore</tt>
 426 directory.<p>
 427
 428
 429 <!-- ======================================================================= -->
 430 </ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
 431 <tr><td>&nbsp;</td><td width="100%">&nbsp;
 432 <font color="#EEEEFF" face="Georgia,Palatino"><b>
 433 <a name="Value">The <tt>Value</tt> class</a>
 434 </b></font></td></tr></table><ul>
 435
 436 <tt>#include "<a href="/doxygen/Value_8h-source.html">llvm/Value.h</a>"</tt></b><br>
 437 doxygen info: <a href="/doxygen/classValue.html">Value Class</a><p>
 438
 439
 440 The <tt>Value</tt> class is the most important class in LLVM Source base.  It
 441 represents a typed value that may be used (among other things) as an operand to
 442 an instruction.  There are many different types of <tt>Value</tt>s, such as <a
 443 href="#Constant"><tt>Constant</tt></a>s, <a
 444 href="#Argument"><tt>Argument</tt></a>s, and even <a
 445 href="#Instruction"><tt>Instruction</tt></a>s and <a
 446 href="#Function"><tt>Function</tt></a>s are <tt>Value</tt>s.<p>
 447
 448 A particular <tt>Value</tt> may be used many times in the LLVM representation
 449 for a program.  For example, an incoming argument to a function (represented
 450 with an instance of the <a href="#Argument">Argument</a> class) is "used" by
 451 every instruction in the function that references the argument.  To keep track
 452 of this relationship, the <tt>Value</tt> class keeps a list of all of the <a
 453 href="#User"><tt>User</tt></a>s that is using it (the <a
 454 href="#User"><tt>User</tt></a> class is a base class for all nodes in the LLVM
 455 graph that can refer to <tt>Value</tt>s).  This use list is how LLVM represents
 456 def-use information in the program, and is accessible through the <tt>use_</tt>*
 457 methods, shown below.<p>
 458
 459 Because LLVM is a typed representation, every LLVM <tt>Value</tt> is typed, and
 460 this <a href="#Type">Type</a> is available through the <tt>getType()</tt>
 461 method.  <a name="#nameWarning">In addition, all LLVM values can be named.  The
 462 "name" of the <tt>Value</tt> is symbolic string printed in the LLVM code:<p>
 463
 464 <pre>
 465    %<b>foo</b> = add int 1, 2
 466 </pre>
 467
 468 The name of this instruction is "foo".  <b>NOTE</b> that the name of any value
 469 may be missing (an empty string), so names should <b>ONLY</b> be used for
 470 debugging (making the source code easier to read, debugging printouts), they
 471 should not be used to keep track of values or map between them.  For this
 472 purpose, use a <tt>std::map</tt> of pointers to the <tt>Value</tt> itself
 473 instead.<p>
 474
 475 One important aspect of LLVM is that there is no distinction between an SSA
 476 variable and the operation that produces it.  Because of this, any reference to
 477 the value produced by an instruction (or the value available as an incoming
 478 argument, for example) is represented as a direct pointer to the class that
 479 represents this value.  Although this may take some getting used to, it
 480 simplifies the representation and makes it easier to manipulate.<p>
 481
 482
 483 <!-- _______________________________________________________________________ -->
 484 </ul><h4><a name="m_Value"><hr size=0>Important Public Members of
 485 the <tt>Value</tt> class</h4><ul>
 486
 487 <li><tt>Value::use_iterator</tt> - Typedef for iterator over the use-list<br>
 488     <tt>Value::use_const_iterator</tt>
 489                  - Typedef for const_iterator over the use-list<br>
 490     <tt>unsigned use_size()</tt> - Returns the number of users of the value.<br>
 491     <tt>bool use_empty()</tt> - Returns true if there are no users.<br>
 492     <tt>use_iterator use_begin()</tt>
 493                  - Get an iterator to the start of the use-list.<br>
 494     <tt>use_iterator use_end()</tt>
 495                  - Get an iterator to the end of the use-list.<br>
 496     <tt><a href="#User">User</a> *use_back()</tt>
 497                  - Returns the last element in the list.<p>
 498
 499 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>
 500
 501 <li><tt><a href="#Type">Type</a> *getType() const</tt><p>
 502 This method returns the Type of the Value.
 503
 504 <li><tt>bool hasName() const</tt><br>
 505     <tt>std::string getName() const</tt><br>
 506     <tt>void setName(const std::string &amp;Name)</tt><p>
 507
 508 This family of methods is used to access and assign a name to a <tt>Value</tt>,
 509 be aware of the <a href="#nameWarning">precaution above</a>.<p>
 510
 511
 512 <li><tt>void replaceAllUsesWith(Value *V)</tt><p>
 513
 514 This method traverses the use list of a <tt>Value</tt> changing all <a
 515 href="#User"><tt>User</tt>'s</a> of the current value to refer to "<tt>V</tt>"
 516 instead.  For example, if you detect that an instruction always produces a
 517 constant value (for example through constant folding), you can replace all uses
 518 of the instruction with the constant like this:<p>
 519
 520 <pre>
 521   Inst-&gt;replaceAllUsesWith(ConstVal);
 522 </pre><p>
 523
 524
 525
 526 <!-- ======================================================================= -->
 527 </ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
 528 <tr><td>&nbsp;</td><td width="100%">&nbsp;
 529 <font color="#EEEEFF" face="Georgia,Palatino"><b>
 530 <a name="User">The <tt>User</tt> class</a>
 531 </b></font></td></tr></table><ul>
 532
 533 <tt>#include "<a href="/doxygen/User_8h-source.html">llvm/User.h</a>"</tt></b><br>
 534 doxygen info: <a href="/doxygen/classUser.html">User Class</a><br>
 535 Superclass: <a href="#Value"><tt>Value</tt></a><p>
 536
 537
 538 The <tt>User</tt> class is the common base class of all LLVM nodes that may
 539 refer to <a href="#Value"><tt>Value</tt></a>s.  It exposes a list of "Operands"
 540 that are all of the <a href="#Value"><tt>Value</tt></a>s that the User is
 541 referring to.  The <tt>User</tt> class itself is a subclass of
 542 <tt>Value</tt>.<p>
 543
 544 The operands of a <tt>User</tt> point directly to the LLVM <a
 545 href="#Value"><tt>Value</tt></a> that it refers to.  Because LLVM uses Static
 546 Single Assignment (SSA) form, there can only be one definition referred to,
 547 allowing this direct connection.  This connection provides the use-def
 548 information in LLVM.<p>
 549
 550 <!-- _______________________________________________________________________ -->
 551 </ul><h4><a name="m_User"><hr size=0>Important Public Members of
 552 the <tt>User</tt> class</h4><ul>
 553
 554 The <tt>User</tt> class exposes the operand list in two ways: through an index
 555 access interface and through an iterator based interface.<p>
 556
 557 <li><tt>Value *getOperand(unsigned i)</tt><br>
 558     <tt>unsigned getNumOperands()</tt><p>
 559
 560 These two methods expose the operands of the <tt>User</tt> in a convenient form
 561 for direct access.<p>
 562
 563 <li><tt>User::op_iterator</tt> - Typedef for iterator over the operand list<br>
 564     <tt>User::op_const_iterator</tt>
 565     <tt>use_iterator op_begin()</tt>
 566                  - Get an iterator to the start of the operand list.<br>
 567     <tt>use_iterator op_end()</tt>
 568                  - Get an iterator to the end of the operand list.<p>
 569
 570 Together, these methods make up the iterator based interface to the operands of
 571 a <tt>User</tt>.<p>
 572
 573
 574
 575 <!-- ======================================================================= -->
 576 </ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
 577 <tr><td>&nbsp;</td><td width="100%">&nbsp;
 578 <font color="#EEEEFF" face="Georgia,Palatino"><b>
 579 <a name="Instruction">The <tt>Instruction</tt> class</a>
 580 </b></font></td></tr></table><ul>
 581
 582 <tt>#include "<a
 583 href="/doxygen/Instruction_8h-source.html">llvm/Instruction.h</a>"</tt></b><br>
 584 doxygen info: <a href="/doxygen/classInstruction.html">Instruction Class</a><br>
 585 Superclasses: <a href="#User"><tt>User</tt></a>, <a
 586 href="#Value"><tt>Value</tt></a><p>
 587
 588 The <tt>Instruction</tt> class is the common base class for all LLVM
 589 instructions.  It provides only a few methods, but is a very commonly used
 590 class.  The primary data tracked by the <tt>Instruction</tt> class itself is the
 591 opcode (instruction type) and the parent <a
 592 href="#BasicBlock"><tt>BasicBlock</tt></a> the <tt>Instruction</tt> is embedded
 593 into.  To represent a specific type of instruction, one of many subclasses of
 594 <tt>Instruction</tt> are used.<p>
 595
 596 Because the <tt>Instruction</tt> class subclasses the <a
 597 href="#User"><tt>User</tt></a> class, its operands can be accessed in the same
 598 way as for other <a href="#User"><tt>User</tt></a>s (with the
 599 <tt>getOperand()</tt>/<tt>getNumOperands()</tt> and
 600 <tt>op_begin()</tt>/<tt>op_end()</tt> methods).<p>
 601
 602
 603 <!-- _______________________________________________________________________ -->
 604 </ul><h4><a name="m_Instruction"><hr size=0>Important Public Members of
 605 the <tt>Instruction</tt> class</h4><ul>
 606
 607 <li><tt><a href="#BasicBlock">BasicBlock</a> *getParent()</tt><p>
 608
 609 Returns the <a href="#BasicBlock"><tt>BasicBlock</tt></a> that this
 610 <tt>Instruction</tt> is embedded into.<p>
 611
 612 <li><tt>bool hasSideEffects()</tt><p>
 613
 614 Returns true if the instruction has side effects, i.e. it is a <tt>call</tt>,
 615 <tt>free</tt>, <tt>invoke</tt>, or <tt>store</tt>.<p>
 616
 617 <li><tt>unsigned getOpcode()</tt><p>
 618
 619 Returns the opcode for the <tt>Instruction</tt>.<p>
 620
 621 <!--
 622
 623 \subsection{Subclasses of Instruction :}
 624 \begin{itemize}
 625 <li>BinaryOperator : This subclass of Instruction defines a general interface to the all the instructions involvong  binary operators in LLVM.
 626         \begin{itemize}
 627         <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.
 628         \end{itemize}
 629 <li>TerminatorInst : This subclass of Instructions defines an interface for all instructions that can terminate a BasicBlock.
 630         \begin{itemize}
 631          <li> <tt>unsigned getNumSuccessors()</tt>: Returns the number of successors for this terminator instruction.
 632         <li><tt>BasicBlock *getSuccessor(unsigned i)</tt>: As the name suggests returns the ith successor BasicBlock.
 633         <li><tt>void setSuccessor(unsigned i, BasicBlock *B)</tt>: sets BasicBlock B as the ith succesor to this terminator instruction.
 634         \end{itemize}
 635
 636 <li>PHINode : This represents the PHI instructions in the SSA form.
 637         \begin{itemize}
 638         <li><tt> unsigned getNumIncomingValues()</tt>: Returns the number of incoming edges to this PHI node.
 639         <li><tt> Value *getIncomingValue(unsigned i)</tt>: Returns the ith incoming Value.
 640         <li><tt>void setIncomingValue(unsigned i, Value *V)</tt>: Sets the ith incoming Value as V
 641         <li><tt>BasicBlock *getIncomingBlock(unsigned i)</tt>: Returns the Basic Block corresponding to the ith incoming Value.
 642         <li><tt> void addIncoming(Value *D, BasicBlock *BB)</tt>:
 643         Add an incoming value to the end of the PHI list
 644         <li><tt> int getBasicBlockIndex(const BasicBlock *BB) const</tt>:
 645         Returns the first index of the specified basic block in the value list for this PHI.  Returns -1 if no instance.
 646         \end{itemize}
 647 <li>CastInst : In LLVM all casts have to be done through explicit cast instructions. CastInst defines the interface to the cast instructions.
 648 <li>CallInst : This defines an interface to the call instruction in LLVM. ARguments to the function are nothing but operands of the instruction.
 649         \begin{itemize}
 650         <li>: <tt>Function *getCalledFunction()</tt>: Returns a handle to the function that is being called by this Function.
 651         \end{itemize}
 652 <li>LoadInst, StoreInst, GetElemPtrInst : These subclasses represent load, store and getelementptr instructions in LLVM.
 653         \begin{itemize}
 654         <li><tt>Value * getPointerOperand ()</tt>: Returns the Pointer Operand which is typically the 0th operand.
 655         \end{itemize}
 656 <li>BranchInst : This is a subclass of TerminatorInst and defines the interface for conditional and unconditional branches in LLVM.
 657         \begin{itemize}
 658         <li><tt>bool isConditional()</tt>: Returns true if the branch is a conditional branch else returns false
 659         <li> <tt>Value *getCondition()</tt>: Returns the condition if it is a conditional branch else returns null.
 660         <li> <tt>void setUnconditionalDest(BasicBlock *Dest)</tt>: Changes the current branch to an unconditional one targetting the specified block.
 661         \end{itemize}
 662
 663 \end{itemize}
 664
 665 -->
 666
 667
 668 <!-- ======================================================================= -->
 669 </ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
 670 <tr><td>&nbsp;</td><td width="100%">&nbsp;
 671 <font color="#EEEEFF" face="Georgia,Palatino"><b>
 672 <a name="BasicBlock">The <tt>BasicBlock</tt> class</a>
 673 </b></font></td></tr></table><ul>
 674
 675 <tt>#include "<a
 676 href="/doxygen/BasicBlock_8h-source.html">llvm/BasicBlock.h</a>"</tt></b><br>
 677 doxygen info: <a href="/doxygen/classBasicBlock.html">BasicBlock Class</a><br>
 678 Superclass: <a href="#Value"><tt>Value</tt></a><p>
 679
 680
 681 This class represents a single entry multiple exit section of the code, commonly
 682 known as a basic block by the compiler community.  The <tt>BasicBlock</tt> class
 683 maintains a list of <a href="#Instruction"><tt>Instruction</tt></a>s, which form
 684 the body of the block.  Matching the language definition, the last element of
 685 this list of instructions is always a terminator instruction (a subclass of the
 686 <a href="#TerminatorInst"><tt>TerminatorInst</tt></a> class).<p>
 687
 688 In addition to tracking the list of instructions that make up the block, the
 689 <tt>BasicBlock</tt> class also keeps track of the <a
 690 href="#Function"><tt>Function</tt></a> that it is embedded into.<p>
 691
 692 Note that <tt>BasicBlock</tt>s themselves are <a
 693 href="#Value"><tt>Value</tt></a>s, because they are referenced by instructions
 694 like branches and can go in the switch tables.  <tt>BasicBlock</tt>s have type
 695 <tt>label</tt>.<p>
 696
 697
 698 <!-- _______________________________________________________________________ -->
 699 </ul><h4><a name="m_BasicBlock"><hr size=0>Important Public Members of
 700 the <tt>BasicBlock</tt> class</h4><ul>
 701
 702 <li><tt>BasicBlock(const std::string &amp;Name = "", <a
 703 href="#Function">Function</a> *Parent = 0)</tt><p>
 704
 705 The <tt>BasicBlock</tt> constructor is used to create new basic blocks for
 706 insertion into a function.  The constructor simply takes a name for the new
 707 block, and optionally a <a href="#Function"><tt>Function</tt></a> to insert it
 708 into.  If the <tt>Parent</tt> parameter is specified, the new
 709 <tt>BasicBlock</tt> is automatically inserted at the end of the specified <a
 710 href="#Function"><tt>Function</tt></a>, if not specified, the BasicBlock must be
 711 manually inserted into the <a href="#Function"><tt>Function</tt></a>.<p>
 712
 713 <li><tt>BasicBlock::iterator</tt> - Typedef for instruction list iterator<br>
 714     <tt>BasicBlock::const_iterator</tt> - Typedef for const_iterator.<br>
 715     <tt>begin()</tt>, <tt>end()</tt>, <tt>front()</tt>, <tt>back()</tt>,
 716     <tt>size()</tt>, <tt>empty()</tt>, <tt>rbegin()</tt>, <tt>rend()</tt><p>
 717
 718 These methods and typedefs are forwarding functions that have the same semantics
 719 as the standard library methods of the same names.  These methods expose the
 720 underlying instruction list of a basic block in a way that is easy to
 721 manipulate.  To get the full complement of container operations (including
 722 operations to update the list), you must use the <tt>getInstList()</tt>
 723 method.<p>
 724
 725 <li><tt>BasicBlock::InstListType &amp;getInstList()</tt><p>
 726
 727 This method is used to get access to the underlying container that actually
 728 holds the Instructions.  This method must be used when there isn't a forwarding
 729 function in the <tt>BasicBlock</tt> class for the operation that you would like
 730 to perform.  Because there are no forwarding functions for "updating"
 731 operations, you need to use this if you want to update the contents of a
 732 <tt>BasicBlock</tt>.<p>
 733
 734 <li><tt><A href="#Function">Function</a> *getParent()</tt><p>
 735
 736 Returns a pointer to <a href="#Function"><tt>Function</tt></a> the block is
 737 embedded into, or a null pointer if it is homeless.<p>
 738
 739 <li><tt><a href="#TerminatorInst">TerminatorInst</a> *getTerminator()</tt><p>
 740
 741 Returns a pointer to the terminator instruction that appears at the end of the
 742 <tt>BasicBlock</tt>.  If there is no terminator instruction, or if the last
 743 instruction in the block is not a terminator, then a null pointer is
 744 returned.<p>
 745
 746
 747 <!-- ======================================================================= -->
 748 </ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
 749 <tr><td>&nbsp;</td><td width="100%">&nbsp;
 750 <font color="#EEEEFF" face="Georgia,Palatino"><b>
 751 <a name="GlobalValue">The <tt>GlobalValue</tt> class</a>
 752 </b></font></td></tr></table><ul>
 753
 754 <tt>#include "<a
 755 href="/doxygen/GlobalValue_8h-source.html">llvm/GlobalValue.h</a>"</tt></b><br>
 756 doxygen info: <a href="/doxygen/classGlobalValue.html">GlobalValue Class</a><br>
 757 Superclasses: <a href="#User"><tt>User</tt></a>, <a
 758 href="#Value"><tt>Value</tt></a><p>
 759
 760 Global values (<A href="#GlobalVariable"><tt>GlobalVariable</tt></a>s or <a
 761 href="#Function"><tt>Function</tt></a>s) are the only LLVM values that are
 762 visible in the bodies of all <a href="#Function"><tt>Function</tt></a>s.
 763 Because they are visible at global scope, they are also subject to linking with
 764 other globals defined in different translation units.  To control the linking
 765 process, <tt>GlobalValue</tt>s know their linkage rules.  Specifically,
 766 <tt>GlobalValue</tt>s know whether they have internal or external linkage.<p>
 767
 768 If a <tt>GlobalValue</tt> has internal linkage (equivalent to being
 769 <tt>static</tt> in C), it is not visible to code outside the current translation
 770 unit, and does not participate in linking.  If it has external linkage, it is
 771 visible to external code, and does participate in linking.  In addition to
 772 linkage information, <tt>GlobalValue</tt>s keep track of which <a
 773 href="#Module"><tt>Module</tt></a> they are currently part of.<p>
 774
 775 Because <tt>GlobalValue</tt>s are memory objects, they are always referred to by
 776 their address.  As such, the <a href="#Type"><tt>Type</tt></a> of a global is
 777 always a pointer to its contents.  This is explained in the LLVM Language
 778 Reference Manual.<p>
 779
 780
 781 <!-- _______________________________________________________________________ -->
 782 </ul><h4><a name="m_GlobalValue"><hr size=0>Important Public Members of
 783 the <tt>GlobalValue</tt> class</h4><ul>
 784
 785 <li><tt>bool hasInternalLinkage() const</tt><br>
 786     <tt>bool hasExternalLinkage() const</tt><br>
 787     <tt>void setInternalLinkage(bool HasInternalLinkage)</tt><p>
 788
 789 These methods manipulate the linkage characteristics of the
 790 <tt>GlobalValue</tt>.<p>
 791
 792 <li><tt><a href="#Module">Module</a> *getParent()</tt><p>
 793
 794 This returns the <a href="#Module"><tt>Module</tt></a> that the GlobalValue is
 795 currently embedded into.<p>
 796
 797
 798
 799 <!-- ======================================================================= -->
 800 </ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
 801 <tr><td>&nbsp;</td><td width="100%">&nbsp;
 802 <font color="#EEEEFF" face="Georgia,Palatino"><b>
 803 <a name="Function">The <tt>Function</tt> class</a>
 804 </b></font></td></tr></table><ul>
 805
 806 <tt>#include "<a
 807 href="/doxygen/Function_8h-source.html">llvm/Function.h</a>"</tt></b><br>
 808 doxygen info: <a href="/doxygen/classFunction.html">Function Class</a><br>
 809 Superclasses: <a href="#GlobalValue"><tt>GlobalValue</tt></a>, <a
 810 href="#User"><tt>User</tt></a>, <a href="#Value"><tt>Value</tt></a><p>
 811
 812 The <tt>Function</tt> class represents a single procedure in LLVM.  It is
 813 actually one of the more complex classes in the LLVM heirarchy because it must
 814 keep track of a large amount of data.  The <tt>Function</tt> class keeps track
 815 of a list of <a href="#BasicBlock"><tt>BasicBlock</tt></a>s, a list of formal <a
 816 href="#Argument"><tt>Argument</tt></a>s, and a <a
 817 href="#SymbolTable"><tt>SymbolTable</tt></a>.<p>
 818
 819 The list of <a href="#BasicBlock"><tt>BasicBlock</tt></a>s is the most commonly
 820 used part of <tt>Function</tt> objects.  The list imposes an implicit ordering
 821 of the blocks in the function, which indicate how the code will be layed out by
 822 the backend.  Additionally, the first <a
 823 href="#BasicBlock"><tt>BasicBlock</tt></a> is the implicit entry node for the
 824 <tt>Function</tt>.  It is not legal in LLVM explicitly branch to this initial
 825 block.  There are no implicit exit nodes, and in fact there may be multiple exit
 826 nodes from a single <tt>Function</tt>.  If the <a
 827 href="#BasicBlock"><tt>BasicBlock</tt></a> list is empty, this indicates that
 828 the <tt>Function</tt> is actually a function declaration: the actual body of the
 829 function hasn't been linked in yet.<p>
 830
 831 In addition to a list of <a href="#BasicBlock"><tt>BasicBlock</tt></a>s, the
 832 <tt>Function</tt> class also keeps track of the list of formal <a
 833 href="#Argument"><tt>Argument</tt></a>s that the function receives.  This
 834 container manages the lifetime of the <a href="#Argument"><tt>Argument</tt></a>
 835 nodes, just like the <a href="#BasicBlock"><tt>BasicBlock</tt></a> list does for
 836 the <a href="#BasicBlock"><tt>BasicBlock</tt></a>s.<p>
 837
 838 The <a href="#SymbolTable"><tt>SymbolTable</tt></a> is a very rarely used LLVM
 839 feature that is only used when you have to look up a value by name.  Aside from
 840 that, the <a href="#SymbolTable"><tt>SymbolTable</tt></a> is used internally to
 841 make sure that there are not conflicts between the names of <a
 842 href="#Instruction"><tt>Instruction</tt></a>s, <a
 843 href="#BasicBlock"><tt>BasicBlock</tt></a>s, or <a
 844 href="#Argument"><tt>Argument</tt></a>s in the function body.<p>
 845
 846
 847 <!-- _______________________________________________________________________ -->
 848 </ul><h4><a name="m_Function"><hr size=0>Important Public Members of
 849 the <tt>Function</tt> class</h4><ul>
 850
 851 <li><tt>Function(const <a href="#FunctionType">FunctionType</a> *Ty, bool isInternal, const std::string &amp;N = "")</tt><p>
 852
 853 Constructor used when you need to create new <tt>Function</tt>s to add the the
 854 program.  The constructor must specify the type of the function to create and
 855 whether or not it should start out with internal or external linkage.<p>
 856
 857 <li><tt>bool isExternal()</tt><p>
 858
 859 Return whether or not the <tt>Function</tt> has a body defined.  If the function
 860 is "external", it does not have a body, and thus must be resolved by linking
 861 with a function defined in a different translation unit.<p>
 862
 863
 864 <li><tt>Function::iterator</tt> - Typedef for basic block list iterator<br>
 865     <tt>Function::const_iterator</tt> - Typedef for const_iterator.<br>
 866     <tt>begin()</tt>, <tt>end()</tt>, <tt>front()</tt>, <tt>back()</tt>,
 867     <tt>size()</tt>, <tt>empty()</tt>, <tt>rbegin()</tt>, <tt>rend()</tt><p>
 868
 869 These are forwarding methods that make it easy to access the contents of a
 870 <tt>Function</tt> object's <a href="#BasicBlock"><tt>BasicBlock</tt></a>
 871 list.<p>
 872
 873 <li><tt>Function::BasicBlockListType &amp;getBasicBlockList()</tt><p>
 874
 875 Returns the list of <a href="#BasicBlock"><tt>BasicBlock</tt></a>s.  This is
 876 neccesary to use when you need to update the list or perform a complex action
 877 that doesn't have a forwarding method.<p>
 878
 879
 880 <li><tt>Function::aiterator</tt> - Typedef for the argument list iterator<br>
 881     <tt>Function::const_aiterator</tt> - Typedef for const_iterator.<br>
 882     <tt>abegin()</tt>, <tt>aend()</tt>, <tt>afront()</tt>, <tt>aback()</tt>,
 883     <tt>asize()</tt>, <tt>aempty()</tt>, <tt>arbegin()</tt>, <tt>arend()</tt><p>
 884
 885 These are forwarding methods that make it easy to access the contents of a
 886 <tt>Function</tt> object's <a href="#Argument"><tt>Argument</tt></a> list.<p>
 887
 888 <li><tt>Function::ArgumentListType &amp;getArgumentList()</tt><p>
 889
 890 Returns the list of <a href="#Argument"><tt>Argument</tt></a>s.  This is
 891 neccesary to use when you need to update the list or perform a complex action
 892 that doesn't have a forwarding method.<p>
 893
 894
 895
 896 <li><tt><a href="#BasicBlock">BasicBlock</a> &getEntryNode()</tt><p>
 897
 898 Returns the entry <a href="#BasicBlock"><tt>BasicBlock</tt></a> for the
 899 function.  Because the entry block for the function is always the first block,
 900 this returns the first block of the <tt>Function</tt>.<p>
 901
 902 <li><tt><a href="#Type">Type</a> *getReturnType()</tt><br>
 903     <tt><a href="#FunctionType">FunctionType</a> *getFunctionType()</tt><p>
 904
 905 This traverses the <a href="#Type"><tt>Type</tt></a> of the <tt>Function</tt>
 906 and returns the return type of the function, or the <a
 907 href="#FunctionType"><tt>FunctionType</tt></a> of the actual function.<p>
 908
 909
 910 <li><tt>bool hasSymbolTable() const</tt><p>
 911
 912 Return true if the <tt>Function</tt> has a symbol table allocated to it and if
 913 there is at least one entry in it.<p>
 914
 915 <li><tt><a href="#SymbolTable">SymbolTable</a> *getSymbolTable()</tt><p>
 916
 917 Return a pointer to the <a href="#SymbolTable"><tt>SymbolTable</tt></a> for this
 918 <tt>Function</tt> or a null pointer if one has not been allocated (because there
 919 are no named values in the function).<p>
 920
 921 <li><tt><a href="#SymbolTable">SymbolTable</a> *getSymbolTableSure()</tt><p>
 922
 923 Return a pointer to the <a href="#SymbolTable"><tt>SymbolTable</tt></a> for this
 924 <tt>Function</tt> or allocate a new <a
 925 href="#SymbolTable"><tt>SymbolTable</tt></a> if one is not already around.  This
 926 should only be used when adding elements to the <a
 927 href="#SymbolTable"><tt>SymbolTable</tt></a>, so that empty symbol tables are
 928 not left laying around.<p>
 929
 930
 931
 932 <!-- ======================================================================= -->
 933 </ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
 934 <tr><td>&nbsp;</td><td width="100%">&nbsp;
 935 <font color="#EEEEFF" face="Georgia,Palatino"><b>
 936 <a name="GlobalVariable">The <tt>GlobalVariable</tt> class</a>
 937 </b></font></td></tr></table><ul>
 938
 939 <tt>#include "<a
 940 href="/doxygen/GlobalVariable_8h-source.html">llvm/GlobalVariable.h</a>"</tt></b><br>
 941 doxygen info: <a href="/doxygen/classGlobalVariable.html">GlobalVariable Class</a><br>
 942 Superclasses: <a href="#GlobalValue"><tt>GlobalValue</tt></a>, <a
 943 href="#User"><tt>User</tt></a>, <a href="#Value"><tt>Value</tt></a><p>
 944
 945 Global variables are represented with the (suprise suprise)
 946 <tt>GlobalVariable</tt> class.  Like functions, <tt>GlobalVariable</tt>s are
 947 also subclasses of <a href="#GlobalValue"><tt>GlobalValue</tt></a>, and as such
 948 are always referenced by their address (global values must live in memory, so
 949 their "name" refers to their address).  Global variables may have an initial
 950 value (which must be a <a href="#Constant"><tt>Constant</tt></a>), and if they
 951 have an initializer, they may be marked as "constant" themselves (indicating
 952 that their contents never change at runtime).<p>
 953
 954
 955 <!-- _______________________________________________________________________ -->
 956 </ul><h4><a name="m_GlobalVariable"><hr size=0>Important Public Members of the
 957 <tt>GlobalVariable</tt> class</h4><ul>
 958
 959 <li><tt>GlobalVariable(const <a href="#Type">Type</a> *Ty, bool isConstant, bool
 960 isInternal, <a href="#Constant">Constant</a> *Initializer = 0, const std::string
 961 &amp;Name = "")</tt><p>
 962
 963 Create a new global variable of the specified type.  If <tt>isConstant</tt> is
 964 true then the global variable will be marked as unchanging for the program, and
 965 if <tt>isInternal</tt> is true the resultant global variable will have internal
 966 linkage.  Optionally an initializer and name may be specified for the global variable as well.<p>
 967
 968
 969 <li><tt>bool isConstant() const</tt><p>
 970
 971 Returns true if this is a global variable is known not to be modified at
 972 runtime.<p>
 973
 974
 975 <li><tt>bool hasInitializer()</tt><p>
 976
 977 Returns true if this <tt>GlobalVariable</tt> has an intializer.<p>
 978
 979
 980 <li><tt><a href="#Constant">Constant</a> *getInitializer()</tt><p>
 981
 982 Returns the intial value for a <tt>GlobalVariable</tt>.  It is not legal to call
 983 this method if there is no initializer.<p>
 984
 985
 986 <!-- ======================================================================= -->
 987 </ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
 988 <tr><td>&nbsp;</td><td width="100%">&nbsp;
 989 <font color="#EEEEFF" face="Georgia,Palatino"><b>
 990 <a name="Module">The <tt>Module</tt> class</a>
 991 </b></font></td></tr></table><ul>
 992
 993 <tt>#include "<a
 994 href="/doxygen/Module_8h-source.html">llvm/Module.h</a>"</tt></b><br>
 995 doxygen info: <a href="/doxygen/classModule.html">Module Class</a><p>
 996
 997 The <tt>Module</tt> class represents the top level structure present in LLVM
 998 programs.  An LLVM module is effectively either a translation unit of the
 999 original program or a combination of several translation units merged by the
1000 linker.  The <tt>Module</tt> class keeps track of a list of <a
1001 href="#Function"><tt>Function</tt></a>s, a list of <a
1002 href="#GlobalVariable"><tt>GlobalVariable</tt></a>s, and a <a
1003 href="#SymbolTable"><tt>SymbolTable</tt></a>.  Additionally, it contains a few
1004 helpful member functions that try to make common operations easy.<p>
1005
1006
1007 <!-- _______________________________________________________________________ -->
1008 </ul><h4><a name="m_Module"><hr size=0>Important Public Members of the
1009 <tt>Module</tt> class</h4><ul>
1010
1011 <li><tt>Module::iterator</tt> - Typedef for function list iterator<br>
1012     <tt>Module::const_iterator</tt> - Typedef for const_iterator.<br>
1013     <tt>begin()</tt>, <tt>end()</tt>, <tt>front()</tt>, <tt>back()</tt>,
1014     <tt>size()</tt>, <tt>empty()</tt>, <tt>rbegin()</tt>, <tt>rend()</tt><p>
1015
1016 These are forwarding methods that make it easy to access the contents of a
1017 <tt>Module</tt> object's <a href="#Function"><tt>Function</tt></a>
1018 list.<p>
1019
1020 <li><tt>Module::FunctionListType &amp;getFunctionList()</tt><p>
1021
1022 Returns the list of <a href="#Function"><tt>Function</tt></a>s.  This is
1023 neccesary to use when you need to update the list or perform a complex action
1024 that doesn't have a forwarding method.<p>
1025
1026 <!--  Global Variable -->
1027 <hr size=0>
1028
1029 <li><tt>Module::giterator</tt> - Typedef for global variable list iterator<br>
1030     <tt>Module::const_giterator</tt> - Typedef for const_iterator.<br>
1031     <tt>gbegin()</tt>, <tt>gend()</tt>, <tt>gfront()</tt>, <tt>gback()</tt>,
1032     <tt>gsize()</tt>, <tt>gempty()</tt>, <tt>grbegin()</tt>, <tt>grend()</tt><p>
1033
1034 These are forwarding methods that make it easy to access the contents of a
1035 <tt>Module</tt> object's <a href="#GlobalVariable"><tt>GlobalVariable</tt></a>
1036 list.<p>
1037
1038 <li><tt>Module::GlobalListType &amp;getGlobalList()</tt><p>
1039
1040 Returns the list of <a href="#GlobalVariable"><tt>GlobalVariable</tt></a>s.
1041 This is neccesary to use when you need to update the list or perform a complex
1042 action that doesn't have a forwarding method.<p>
1043
1044
1045 <!--  Symbol table stuff -->
1046 <hr size=0>
1047
1048 <li><tt>bool hasSymbolTable() const</tt><p>
1049
1050 Return true if the <tt>Module</tt> has a symbol table allocated to it and if
1051 there is at least one entry in it.<p>
1052
1053 <li><tt><a href="#SymbolTable">SymbolTable</a> *getSymbolTable()</tt><p>
1054
1055 Return a pointer to the <a href="#SymbolTable"><tt>SymbolTable</tt></a> for this
1056 <tt>Module</tt> or a null pointer if one has not been allocated (because there
1057 are no named values in the function).<p>
1058
1059 <li><tt><a href="#SymbolTable">SymbolTable</a> *getSymbolTableSure()</tt><p>
1060
1061 Return a pointer to the <a href="#SymbolTable"><tt>SymbolTable</tt></a> for this
1062 <tt>Module</tt> or allocate a new <a
1063 href="#SymbolTable"><tt>SymbolTable</tt></a> if one is not already around.  This
1064 should only be used when adding elements to the <a
1065 href="#SymbolTable"><tt>SymbolTable</tt></a>, so that empty symbol tables are
1066 not left laying around.<p>
1067
1068
1069 <!--  Convenience methods -->
1070 <hr size=0>
1071
1072 <li><tt><a href="#Function">Function</a> *getFunction(const std::string &amp;Name, const <a href="#FunctionType">FunctionType</a> *Ty)</tt><p>
1073
1074 Look up the specified function in the <tt>Module</tt> <a
1075 href="#SymbolTable"><tt>SymbolTable</tt></a>. If it does not exist, return
1076 <tt>null</tt>.<p>
1077
1078
1079 <li><tt><a href="#Function">Function</a> *getOrInsertFunction(const std::string
1080          &amp;Name, const <a href="#FunctionType">FunctionType</a> *T)</tt><p>
1081
1082 Look up the specified function in the <tt>Module</tt> <a
1083 href="#SymbolTable"><tt>SymbolTable</tt></a>. If it does not exist, add an
1084 external declaration for the function and return it.<p>
1085
1086
1087 <li><tt>std::string getTypeName(const <a href="#Type">Type</a> *Ty)</tt><p>
1088
1089 If there is at least one entry in the <a
1090 href="#SymbolTable"><tt>SymbolTable</tt></a> for the specified <a
1091 href="#Type"><tt>Type</tt></a>, return it.  Otherwise return the empty
1092 string.<p>
1093
1094
1095 <li><tt>bool addTypeName(const std::string &Name, const <a href="#Type">Type</a>
1096 *Ty)</tt><p>
1097
1098 Insert an entry in the <a href="#SymbolTable"><tt>SymbolTable</tt></a> mapping
1099 <tt>Name</tt> to <tt>Ty</tt>. If there is already an entry for this name, true
1100 is returned and the <a href="#SymbolTable"><tt>SymbolTable</tt></a> is not
1101 modified.<p>
1102
1103
1104 <!-- ======================================================================= -->
1105 </ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
1106 <tr><td>&nbsp;</td><td width="100%">&nbsp;
1107 <font color="#EEEEFF" face="Georgia,Palatino"><b>
1108 <a name="Constant">The <tt>Constant</tt> class and subclasses</a>
1109 </b></font></td></tr></table><ul>
1110
1111 Constant represents a base class for different types of constants. It is
1112 subclassed by ConstantBool, ConstantInt, ConstantSInt, ConstantUInt,
1113 ConstantArray etc for representing the various types of Constants.<p>
1114
1115
1116 <!-- _______________________________________________________________________ -->
1117 </ul><h4><a name="m_Value"><hr size=0>Important Public Methods</h4><ul>
1118
1119 <li><tt>bool isConstantExpr()</tt>: Returns true if it is a ConstantExpr
1120
1121
1122
1123
1124 \subsection{Important Subclasses of Constant}
1125 \begin{itemize}
1126 <li>ConstantSInt : This subclass of Constant represents a signed integer constant.
1127         \begin{itemize}
1128         <li><tt>int64_t getValue () const</tt>: Returns the underlying value of this constant.
1129         \end{itemize}
1130 <li>ConstantUInt : This class represents an unsigned integer.
1131         \begin{itemize}
1132         <li><tt>uint64_t getValue () const</tt>: Returns the underlying value of this constant.
1133         \end{itemize}
1134 <li>ConstantFP : This class represents a floating point constant.
1135         \begin{itemize}
1136         <li><tt>double getValue () const</tt>: Returns the underlying value of this constant.
1137         \end{itemize}
1138 <li>ConstantBool : This represents a boolean constant.
1139         \begin{itemize}
1140         <li><tt>bool getValue () const</tt>: Returns the underlying value of this constant.
1141         \end{itemize}
1142 <li>ConstantArray : This represents a constant array.
1143         \begin{itemize}
1144         <li><tt>const std::vector<Use> &amp;getValues() const</tt>: Returns a Vecotr of component constants that makeup this array.
1145         \end{itemize}
1146 <li>ConstantStruct : This represents a constant struct.
1147         \begin{itemize}
1148         <li><tt>const std::vector<Use> &amp;getValues() const</tt>: Returns a Vecotr of component constants that makeup this array.
1149         \end{itemize}
1150 <li>ConstantPointerRef : This represents a constant pointer value that is initialized to point to a global value, which lies at a constant fixed address.
1151         \begin{itemize}
1152 <li><tt>GlobalValue *getValue()</tt>: Returns the global value to which this pointer is pointing to.
1153         \end{itemize}
1154 \end{itemize}
1155
1156
1157 <!-- ======================================================================= -->
1158 </ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
1159 <tr><td>&nbsp;</td><td width="100%">&nbsp;
1160 <font color="#EEEEFF" face="Georgia,Palatino"><b>
1161 <a name="Type">The <tt>Type</tt> class and Derived Types</a>
1162 </b></font></td></tr></table><ul>
1163
1164 Type as noted earlier is also a subclass of a Value class.  Any primitive
1165 type (like int, short etc) in LLVM is an instance of Type Class.  All
1166 other types are instances of subclasses of type like FunctionType,
1167 ArrayType etc. DerivedType is the interface for all such dervied types
1168 including FunctionType, ArrayType, PointerType, StructType. Types can have
1169 names. They can be recursive (StructType). There exists exactly one instance
1170 of any type structure at a time. This allows using pointer equality of Type *s for comparing types.
1171
1172 <!-- _______________________________________________________________________ -->
1173 </ul><h4><a name="m_Value"><hr size=0>Important Public Methods</h4><ul>
1174
1175 <li><tt>PrimitiveID getPrimitiveID () const</tt>: Returns the base type of the type.
1176 <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.
1177 <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.
1178 <li><tt> bool isInteger () const</tt>: Equilivent to isSigned() || isUnsigned(), but with only a single virtual function invocation.
1179 <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.
1180
1181 <li><tt>bool isFloatingPoint ()</tt>: Return true if this is one of the two floating point types.
1182 <li><tt>bool isRecursive () const</tt>: Returns rue if the type graph contains a cycle.
1183 <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.
1184 <li><tt>bool isPrimitiveType () const</tt>: Returns true if it is a primitive type.
1185 <li><tt>bool isDerivedType () const</tt>: Returns true if it is a derived type.
1186 <li><tt>const Type * getContainedType (unsigned i) const</tt>:
1187 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.
1188 <li><tt>unsigned getNumContainedTypes () const</tt>: Return the number of types in the derived type.
1189
1190
1191
1192 \subsection{Derived Types}
1193 \begin{itemize}
1194 <li>SequentialType : This is subclassed by ArrayType and PointerType
1195         \begin{itemize}
1196         <li><tt>const Type * getElementType () const</tt>: Returns the type of each of the elements in the sequential type.
1197         \end{itemize}
1198 <li>ArrayType : This is a subclass of SequentialType and defines interface for array types.
1199         \begin{itemize}
1200         <li><tt>unsigned getNumElements () const</tt>: Returns the number of elements in the array.
1201         \end{itemize}
1202 <li>PointerType : Subclass of SequentialType for  pointer types.
1203 <li>StructType : subclass of DerivedTypes for struct types
1204 <li>FunctionType : subclass of DerivedTypes for function types.
1205         \begin{itemize}
1206
1207         <li><tt>bool isVarArg () const</tt>: Returns true if its a vararg function
1208         <li><tt> const Type * getReturnType () const</tt>: Returns the return type of the function.
1209         <li><tt> const ParamTypes &amp;getParamTypes () const</tt>: Returns a vector of parameter types.
1210         <li><tt>const Type * getParamType (unsigned i)</tt>: Returns the type of the ith parameter.
1211         <li><tt> const unsigned getNumParams () const</tt>: Returns the number of formal parameters.
1212         \end{itemize}
1213 \end{itemize}
1214
1215
1216
1217
1218 <!-- ======================================================================= -->
1219 </ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
1220 <tr><td>&nbsp;</td><td width="100%">&nbsp;
1221 <font color="#EEEEFF" face="Georgia,Palatino"><b>
1222 <a name="Argument">The <tt>Argument</tt> class</a>
1223 </b></font></td></tr></table><ul>
1224
1225 This subclass of Value defines the interface for incoming formal arguments to a
1226 function. A Function maitanis a list of its formal arguments. An argument has a
1227 pointer to the parent Function.
1228
1229
1230
1231
1232 <!-- *********************************************************************** -->
1233 </ul>
1234 <!-- *********************************************************************** -->
1235
1236 <hr><font size-1>
1237 <address>By: <a href="mailto:dhurjati@cs.uiuc.edu">Dinakar Dhurjati</a> and
1238 <a href="mailto:sabre@nondot.org">Chris Lattner</a></address>
1239 <!-- Created: Tue Aug  6 15:00:33 CDT 2002 -->
1240 <!-- hhmts start -->
1241 Last modified: Fri Sep  6 16:37:49 EDT 2002
1242 <!-- hhmts end -->
1243 </font></body></html>