docs/tutorial/JITTutorial1.html

   1 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
   2                       "http://www.w3.org/TR/html4/strict.dtd">
   3
   4 <html>
   5 <head>
   6   <title>LLVM Tutorial 1: A First Function</title>
   7   <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
   8   <meta name="author" content="Owen Anderson">
   9   <meta name="description"
  10   content="LLVM Tutorial 1: A First Function.">
  11   <link rel="stylesheet" href="../llvm.css" type="text/css">
  12 </head>
  13
  14 <body>
  15
  16 <div class="doc_title"> LLVM Tutorial 1: A First Function </div>
  17
  18 <div class="doc_author">
  19   <p>Written by <a href="mailto:owen@apple.com">Owen Anderson</a></p>
  20 </div>
  21
  22 <!-- *********************************************************************** -->
  23 <div class="doc_section"><a name="intro">A First Function</a></div>
  24 <!-- *********************************************************************** -->
  25
  26 <div class="doc_text">
  27
  28 <p>For starters, let's consider a relatively straightforward function that takes three integer parameters and returns an arithmetic combination of them.  This is nice and simple, especially since it involves no control flow:</p>
  29
  30 <div class="doc_code">
  31 <pre>
  32 int mul_add(int x, int y, int z) {
  33   return x * y + z;
  34 }
  35 </pre>
  36 </div>
  37
  38 <p>As a preview, the LLVM IR we’re going to end up generating for this function will look like:</p>
  39
  40 <div class="doc_code">
  41 <pre>
  42 define i32 @mul_add(i32 %x, i32 %y, i32 %z) {
  43 entry:
  44   %tmp = mul i32 %x, %y
  45   %tmp2 = add i32 %tmp, %z
  46   ret i32 %tmp2
  47 }
  48 </pre>
  49 </div>
  50
  51 <p>If you're unsure what the above code says, skim through the <a href="../LangRef.html">LLVM Language Reference Manual</a> and convince yourself that the above LLVM IR is actually equivalent to the original function.  Once you’re satisfied with that, let's move on to actually generating it programmatically!</p>
  52
  53 <p>Of course, before we can start, we need to <code>#include</code> the appropriate LLVM header files:</p>
  54
  55 <div class="doc_code">
  56 <pre>
  57 #include "llvm/Module.h"
  58 #include "llvm/Function.h"
  59 #include "llvm/PassManager.h"
  60 #include "llvm/CallingConv.h"
  61 #include "llvm/Analysis/Verifier.h"
  62 #include "llvm/Assembly/PrintModulePass.h"
  63 #include "llvm/Support/IRBuilder.h"
  64 #include "llvm/Support/raw_ostream.h"
  65 </pre>
  66 </div>
  67
  68 <p>Now, let's get started on our real program.  Here's what our basic <code>main()</code> will look like:</p>
  69
  70 <div class="doc_code">
  71 <pre>
  72 using namespace llvm;
  73
  74 Module* makeLLVMModule();
  75
  76 int main(int argc, char**argv) {
  77   Module* Mod = makeLLVMModule();
  78
  79   verifyModule(*Mod, PrintMessageAction);
  80
  81   PassManager PM;
  82   PM.add(createPrintModulePass(&amp;outs()));
  83   PM.run(*Mod);
  84
  85   delete Mod;
  86   return 0;
  87 }
  88 </pre>
  89 </div>
  90
  91 <p>The first segment is pretty simple: it creates an LLVM “module.”  In LLVM, a module represents a single unit of code that is to be processed together.  A module contains things like global variables, function declarations, and implementations.  Here we’ve declared a <code>makeLLVMModule()</code> function to do the real work of creating the module.  Don’t worry, we’ll be looking at that one next!</p>
  92
  93 <p>The second segment runs the LLVM module verifier on our newly created module.  While this probably isn’t really necessary for a simple module like this one, it's always a good idea, especially if you’re generating LLVM IR based on some input.  The verifier will print an error message if your LLVM module is malformed in any way.</p>
  94
  95 <p>Finally, we instantiate an LLVM <code>PassManager</code> and run
  96 the <code>PrintModulePass</code> on our module.  LLVM uses an explicit pass
  97 infrastructure to manage optimizations and various other things.
  98 A <code>PassManager</code>, as should be obvious from its name, manages passes:
  99 it is responsible for scheduling them, invoking them, and ensuring the proper
 100 disposal after we’re done with them.  For this example, we’re just using a
 101 trivial pass that prints out our module in textual form.</p>
 102
 103 <p>Now onto the interesting part: creating and populating a module.  Here's the
 104 first chunk of our <code>makeLLVMModule()</code>:</p>
 105
 106 <div class="doc_code">
 107 <pre>
 108 Module* makeLLVMModule() {
 109   // Module Construction
 110   Module* mod = new Module("test", getGlobalContext());
 111 </pre>
 112 </div>
 113
 114 <p>Exciting, isn’t it!?  All we’re doing here is instantiating a module and giving it a name.  The name isn’t particularly important unless you’re going to be dealing with multiple modules at once.</p>
 115
 116 <div class="doc_code">
 117 <pre>
 118   Constant* c = mod-&gt;getOrInsertFunction("mul_add",
 119   /*ret type*/                           IntegerType::get(32),
 120   /*args*/                               IntegerType::get(32),
 121                                          IntegerType::get(32),
 122                                          IntegerType::get(32),
 123   /*varargs terminated with null*/       NULL);
 124
 125   Function* mul_add = cast&lt;Function&gt;(c);
 126   mul_add-&gt;setCallingConv(CallingConv::C);
 127 </pre>
 128 </div>
 129
 130 <p>We construct our <code>Function</code> by calling <code>getOrInsertFunction()</code> on our module, passing in the name, return type, and argument types of the function.  In the case of our <code>mul_add</code> function, that means one 32-bit integer for the return value and three 32-bit integers for the arguments.</p>
 131
 132 <p>You'll notice that <code>getOrInsertFunction()</code> doesn't actually return a <code>Function*</code>.  This is because <code>getOrInsertFunction()</code> will return a cast of the existing function if the function already existed with a different prototype.  Since we know that there's not already a <code>mul_add</code> function, we can safely just cast <code>c</code> to a <code>Function*</code>.
 133
 134 <p>In addition, we set the calling convention for our new function to be the C
 135 calling convention.  This isn’t strictly necessary, but it ensures that our new
 136 function will interoperate properly with C code, which is a good thing.</p>
 137
 138 <div class="doc_code">
 139 <pre>
 140   Function::arg_iterator args = mul_add-&gt;arg_begin();
 141   Value* x = args++;
 142   x-&gt;setName("x");
 143   Value* y = args++;
 144   y-&gt;setName("y");
 145   Value* z = args++;
 146   z-&gt;setName("z");
 147 </pre>
 148 </div>
 149
 150 <p>While we’re setting up our function, let's also give names to the parameters.  This also isn’t strictly necessary (LLVM will generate names for them if you don’t specify them), but it’ll make looking at our output somewhat more pleasant.  To name the parameters, we iterate over the arguments of our function and call <code>setName()</code> on them.  We’ll also keep the pointer to <code>x</code>, <code>y</code>, and <code>z</code> around, since we’ll need them when we get around to creating instructions.</p>
 151
 152 <p>Great!  We have a function now.  But what good is a function if it has no body?  Before we start working on a body for our new function, we need to recall some details of the LLVM IR.  The IR, being an abstract assembly language, represents control flow using jumps (we call them branches), both conditional and unconditional.  The straight-line sequences of code between branches are called basic blocks, or just blocks.  To create a body for our function, we fill it with blocks:</p>
 153
 154 <div class="doc_code">
 155 <pre>
 156   BasicBlock* block = BasicBlock::Create(getGlobalContext(), "entry", mul_add);
 157   IRBuilder&lt;&gt; builder(block);
 158 </pre>
 159 </div>
 160
 161 <p>We create a new basic block, as you might expect, by calling its constructor.  All we need to tell it is its name and the function to which it belongs.  In addition, we’re creating an <code>IRBuilder</code> object, which is a convenience interface for creating instructions and appending them to the end of a block.  Instructions can be created through their constructors as well, but some of their interfaces are quite complicated.  Unless you need a lot of control, using <code>IRBuilder</code> will make your life simpler.</p>
 162
 163 <div class="doc_code">
 164 <pre>
 165   Value* tmp = builder.CreateBinOp(Instruction::Mul,
 166                                    x, y, "tmp");
 167   Value* tmp2 = builder.CreateBinOp(Instruction::Add,
 168                                     tmp, z, "tmp2");
 169
 170   builder.CreateRet(tmp2);
 171
 172   return mod;
 173 }
 174 </pre>
 175 </div>
 176
 177 <p>The final step in creating our function is to create the instructions that make it up.  Our <code>mul_add</code> function is composed of just three instructions: a multiply, an add, and a return.  <code>IRBuilder</code> gives us a simple interface for constructing these instructions and appending them to the “entry” block.  Each of the calls to <code>IRBuilder</code> returns a <code>Value*</code> that represents the value yielded by the instruction.  You’ll also notice that, above, <code>x</code>, <code>y</code>, and <code>z</code> are also <code>Value*</code>'s, so it's clear that instructions operate on <code>Value*</code>'s.</p>
 178
 179 <p>And that's it!  Now you can compile and run your code, and get a wonderful textual print out of the LLVM IR we saw at the beginning.  To compile, use the following command line as a guide:</p>
 180
 181 <div class="doc_code">
 182 <pre>
 183 # c++ -g tut1.cpp `llvm-config --cxxflags --ldflags --libs core` -o tut1
 184 # ./tut1
 185 </pre>
 186 </div>
 187
 188 <p>The <code>llvm-config</code> utility is used to obtain the necessary GCC-compatible compiler flags for linking with LLVM.  For this example, we only need the 'core' library.  We'll use others once we start adding optimizers and the JIT engine.</p>
 189
 190 <a href="JITTutorial2.html">Next: A More Complicated Function</a>
 191 </div>
 192
 193 <!-- *********************************************************************** -->
 194 <hr>
 195 <address>
 196   <a href="http://jigsaw.w3.org/css-validator/check/referer"><img
 197   src="http://jigsaw.w3.org/css-validator/images/vcss" alt="Valid CSS!"></a>
 198   <a href="http://validator.w3.org/check/referer"><img
 199   src="http://www.w3.org/Icons/valid-html401" alt="Valid HTML 4.01!"></a>
 200
 201   <a href="mailto:owen@apple.com">Owen Anderson</a><br>
 202   <a href="http://llvm.org">The LLVM Compiler Infrastructure</a><br>
 203   Last modified: $Date: 2009-07-21 11:05:13 -0700 (Tue, 21 Jul 2009) $
 204 </address>
 205
 206 </body>
 207 </html>