Author: resistor
Date: Tue Oct 23 01:03:24 2007
New Revision: 43241
URL: http://llvm.org/viewvc/llvm-project?rev=43241&view=rev
Log:
Add the second of the "basic topics" tutorials.
Added:
llvm/trunk/docs/tutorial/JITTutorial2-1.png (with props)
llvm/trunk/docs/tutorial/JITTutorial2.html
Modified:
llvm/trunk/docs/tutorial/index.html
Added: llvm/trunk/docs/tutorial/JITTutorial2-1.png
URL:
http://llvm.org/viewvc/llvm-project/llvm/trunk/docs/tutorial/JITTutorial2-1.png?rev=43241&view=auto
==============================================================================
Binary file - no diff available.
Propchange: llvm/trunk/docs/tutorial/JITTutorial2-1.png
------------------------------------------------------------------------------
svn:mime-type = application/octet-stream
Added: llvm/trunk/docs/tutorial/JITTutorial2.html
URL:
http://llvm.org/viewvc/llvm-project/llvm/trunk/docs/tutorial/JITTutorial2.html?rev=43241&view=auto
==============================================================================
--- llvm/trunk/docs/tutorial/JITTutorial2.html (added)
+++ llvm/trunk/docs/tutorial/JITTutorial2.html Tue Oct 23 01:03:24 2007
@@ -0,0 +1,186 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
+ "http://www.w3.org/TR/html4/strict.dtd";>
+
+<html>
+<head>
+ <title>LLVM Tutorial 2: A More Complicated Function</title>
+ <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+ <meta name="author" content="Owen Anderson">
+ <meta name="description"
+ content="LLVM Tutorial 2: A More Complicated Function.">
+ <link rel="stylesheet" href="../llvm.css" type="text/css">
+</head>
+
+<body>
+
+<div class="doc_title"> LLVM Tutorial 2: A More Complicated Function </div>
+
+<div class="doc_author">
+ <p>Written by <a href="mailto:[EMAIL PROTECTED]">Owen Anderson</a></p>
+</div>
+
+<!-- ***********************************************************************
-->
+<div class="doc_section"><a name="intro">Code Samples</a></div>
+<!-- ***********************************************************************
-->
+
+<div class="doc_text">
+All the code in this example can be downloaded at Tutorial2.tar.bz2 or
Tutorial2.zip.
+</div>
+
+<!-- ***********************************************************************
-->
+<div class="doc_section"><a name="intro">A First Function</a></div>
+<!-- ***********************************************************************
-->
+
+<div class="doc_text">
+
+<p>Now that we understand the basics of creating functions in LLVM, let's move
on to a more complicated example: something with control flow. As an example,
let's consider Euclid's Greatest Common Denominator (GCD) algorithm:</p>
+
+<div class="doc_code">
+<pre>
+unsigned gcd(unsigned x, unsigned y) {
+ if(x == y) {
+ return x;
+ } else if(x < y) {
+ return gcd(x, y - x);
+ } else {
+ return gcd(x - y, y);
+ }
+}
+</pre>
+</div>
+
+<p>With this example, we'll learn how to create functions with multiple blocks
and control flow, and how to make function calls within your LLVM code. For
starters, consider the diagram below.</p>
+
+<div style="text-align: center;"><img src="JITTutorial2-1.png" alt="GCD CFG"
width="60%" /></div>
+
+<p>The above is a graphical representation of a program in LLVM IR. It places
each basic block on a node of a graph, and uses directed edges to indicate flow
control. These blocks will be serialized when written to a text or bitcode
file, but it is often useful conceptually to think of them as a graph. Again,
if you are unsure about the code in the diagram, you should skim through the <a
href=../LangRef.html">LLVM Language Reference Manual</a> and convince yourself
that it is, in fact, the GCD algorithm.</p>
+
+<p>The first part of our code is the same as from first tutorial. The same
basic setup is required: creating a module, verifying it, and running the
<code>PrintModulePass</code> on it. Even the first segment of
<code>makeLLVMModule()</code> looks the same, because <code>gcd</code> happens
the have the same prototype as our <code>mul_add</code> function.</p>
+
+<div class="doc_code">
+<pre>
+#include <llvm/Module.h>
+#include <llvm/Function.h>
+#include <llvm/PassManager.h>
+#include <llvm/Analysis/Verifier.h>
+#include <llvm/Assembly/PrintModulePass.h>
+#include <llvm/Support/LLVMBuilder.h>
+
+using namespace llvm;
+
+Module* makeLLVMModule();
+
+int main(int argc, char**argv) {
+ Module* Mod = makeLLVMModule();
+
+ verifyModule(*Mod, PrintMessageAction);
+
+ PassManager PM;
+ PM.add(new PrintModulePass(&llvm::cout));
+ PM.run(*Mod);
+
+ return 0;
+}
+
+Module* makeLLVMModule() {
+ Module* mod = new Module("tut2");
+
+ Constant* c = mod->getOrInsertFunction("gcd",
+ IntegerType::get(32),
+ IntegerType::get(32),
+ IntegerType::get(32),
+ NULL);
+ Function* gcd = cast<Function>(c);
+
+ Function::arg_iterator args = gcd->arg_begin();
+ Value* x = args++;
+ x->setName("x");
+ Value* y = args++;
+ y->setName("y");
+</pre>
+</div>
+
+<p>Here, however, is where our code begins to diverge from the first tutorial.
Because <code>gcd</code> has control flow, it is composed of multiple blocks
interconnected by branching (<code>br</code>) instructions. For those familiar
with assembly language, a block is similar to a labeled set of instructions.
For those not familiar with assembly language, a block is basically a set of
instructions that can be branched to and is executed linearly until the block
is terminated by one of a small number of control flow instructions, such as
<code>br</code> or <code>ret</code>.</p>
+
+<p>Blocks corresponds to the nodes in the diagram we looked at in the
beginning of this tutorial. From the diagram, we can see that this function
contains five blocks, so we'll go ahead and create them. Note that, in this
code sample, we're making use of LLVM's automatic name uniquing, since we're
giving two blocks the same name.</p>
+
+<div class="doc_code">
+<pre>
+ BasicBlock* entry = new BasicBlock("entry", gcd);
+ BasicBlock* ret = new BasicBlock("return", gcd);
+ BasicBlock* cond_false = new BasicBlock("cond_false", gcd);
+ BasicBlock* cond_true = new BasicBlock("cond_true", gcd);
+ BasicBlock* cond_false_2 = new BasicBlock("cond_false", gcd);
+</pre>
+</div>
+
+<p>Now, we're ready to begin generate code! We'll start with the
<code>entry</code> block. This block corresponds to the top-level if-statement
in the original C code, so we need to compare <code>x == y</code> To achieve
this, we perform an explicity comparison using <code>ICmpEQ</code>.
<code>ICmpEQ</code> stands for an <em>integer comparison for equality</em> and
returns a 1-bit integer result. This 1-bit result is then used as the input to
a conditional branch, with <code>ret</code> as the <code>true</code> and
<code>cond_false</code> as the <code>false</code> case.</p>
+
+<div class="doc_code">
+<pre>
+ LLVMBuilder builder(entry);
+ Value* xEqualsY = builder.CreateICmpEQ(x, y, "tmp");
+ builder.CreateCondBr(xEqualsY, ret, cond_false);
+</pre>
+</div>
+
+<p>Our next block, <code>ret</code>, is pretty simple: it just returns the
value of <code>x</code>. Recall that this block is only reached if <code>x ==
y</code>, so this is the correct behavior. Notice that, instead of creating a
new <code>LLVMBuilder</code> for each block, we can use
<code>SetInsertPoint</code> to retarget our existing one. This saves on
construction and memory allocation costs.</p>
+
+<div class="doc_code">
+<pre>
+ builder.SetInsertPoint(ret);
+ builder.CreateRet(x);
+</pre>
+</div>
+
+<p><code>cond_false</code> is a more interesting block: we now know that
<code>x != y</code>, so we must branch again to determine which of
<code>x</code> and <code>y</code> is larger. This is achieved using the
<code>ICmpULT</code> instruction, which stands for <em>integer comparison for
unsigned less-than</em>. In LLVM, integer types do not carry sign; a 32-bit
integer pseudo-register can interpreted as signed or unsigned without casting.
Whether a signed or unsigned interpretation is desired is specified in the
instruction. This is why several instructions in the LLVM IR, such as integer
less-than, include a specifier for signed or unsigned.</p>
+
+<p>Also, note that we're again making use of LLVM's automatic name uniquing,
this time at a register level. We've deliberately chosen to name every
instruction "tmp", to illustrate that LLVM will give them all unique names
without getting confused.</p>
+
+<div class="doc_code">
+<pre>
+ builder.SetInsertPoint(cond_false);
+ Value* xLessThanY = builder.CreateICmpULT(x, y, "tmp");
+ builder.CreateCondBr(xLessThanY, cond_true, cond_false_2);
+</pre>
+</div>
+
+<p>Our last two blocks are quite similar; they're both recursive calls to
<code>gcd</code> with different parameters. To create a call instruction, we
have to create a <code>vector</code> (or any other container with
<code>InputInterator</code>s) to hold the arguments. We then pass in the
beginning and ending iterators for this vector.</p>
+
+<div class="doc_code">
+<pre>
+ builder.SetInsertPoint(cond_true);
+ Value* yMinusX = builder.CreateSub(y, x, "tmp");
+ std::vector<Value*> args1;
+ args1.push_back(x);
+ args1.push_back(yMinusX);
+ Value* recur_1 = builder.CreateCall(gcd, args1.begin(), args1.end(), "tmp");
+ builder.CreateRet(recur_1);
+
+ builder.SetInsertPoint(cond_false_2);
+ Value* xMinusY = builder.CreateSub(x, y, "tmp");
+ std::vector<Value*> args2;
+ args2.push_back(xMinusY);
+ args2.push_back(y);
+ Value* recur_2 = builder.CreateCall(gcd, args2.begin(), args2.end(), "tmp");
+ builder.CreateRet(recur_2);
+
+ return mod;
+}
+</pre>
+</div>
+
+<p>And that's it! You can compile your code and execute your code in the same
way as before, by executing:</p>
+
+<div class="doc_code">
+<pre>
+# c++ -g tut2.cpp `llvm-config --cppflags` `llvm-config --ldflags` \
+ `llvm-config --libs core` -o tut2
+# ./tut2
+</pre>
+</div>
+
+</div>
+
+</body>
+</html>
\ No newline at end of file
Modified: llvm/trunk/docs/tutorial/index.html
URL:
http://llvm.org/viewvc/llvm-project/llvm/trunk/docs/tutorial/index.html?rev=43241&r1=43240&r2=43241&view=diff
==============================================================================
--- llvm/trunk/docs/tutorial/index.html (original)
+++ llvm/trunk/docs/tutorial/index.html Tue Oct 23 01:03:24 2007
@@ -19,7 +19,7 @@
<li>Simple JIT Tutorials
<ol>
<li><a href="JITTutorial1.html">A First Function</a></li>
- <li><!--<a href="Tutorial2.html">-->A More Complicated Function</li>
+ <li><a href="JITTutorial2.html">A More Complicated Function</a></li>
<li><!--<a href="Tutorial3.html">-->Running Optimizations</li>
<li><!--<a href="Tutorial4.html">-->Reading and Writing Bitcode</li>
<li><!--<a href="Tutorial5.html">-->Invoking the JIT</li>
_______________________________________________
llvm-commits mailing list
[email protected]
http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
![[llvm-commits] [llvm] r43241 - in /llvm/trunk/docs/tutorial: JITTutorial2-1.png JITTutorial2.html index.html](/search?l=llvm-commits@cs.uiuc.edu&q=subject:%22%5C%5Bllvm%5C-commits%5C%5D+%5C%5Bllvm%5C%5D+r43241+%5C-+in+%5C%2Fllvm%5C%2Ftrunk%5C%2Fdocs%5C%2Ftutorial%5C%3A+JITTutorial2%5C-1.png+JITTutorial2.html+index.html%22&o=newest){kind=link}
