Gitiles
Code Review Sign In
gerrit-public.fairphone.software / toolchain / llvm-project / 42225e50f3ec3184b375442719b3945b82251fe0 / . / llvm / docs / tutorial / JITTutorial1.html
blob: b4054a16431759172761d00b550de800b70c670d [file] [log] [blame]
Owen Andersonb207ff22007-10-20 05:23:06 +0000[diff] [blame]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
Owen Anderson3295cfd2007-10-22 06:35:07 +0000[diff] [blame]22<!-- *********************************************************************** -->
Owen Anderson3295cfd2007-10-22 06:35:07 +0000[diff] [blame]23<div class="doc_section"><a name="intro">A First Function</a></div>
24<!-- *********************************************************************** -->
25
Owen Andersonb207ff22007-10-20 05:23:06 +0000[diff] [blame]26<div class="doc_text">
27
Chris Lattnera1ad2bf2008-02-10 19:11:04 +0000[diff] [blame]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>
Owen Andersonb207ff22007-10-20 05:23:06 +0000[diff] [blame]29
30<div class="doc_code">
31<pre>
Owen Anderson9f2be012007-10-20 05:41:39 +0000[diff] [blame]32int mul_add(int x, int y, int z) {
33 return x * y + z;
34}
Owen Andersonb207ff22007-10-20 05:23:06 +0000[diff] [blame]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>
Owen Anderson9f2be012007-10-20 05:41:39 +0000[diff] [blame]42define i32 @mul_add(i32 %x, i32 %y, i32 %z) {
43entry:
44 %tmp = mul i32 %x, %y
45 %tmp2 = add i32 %tmp, %z
46 ret i32 %tmp2
47}
Owen Andersonb207ff22007-10-20 05:23:06 +0000[diff] [blame]48</pre>
49</div>
50
Bill Wendling8912f212008-05-19 00:19:02 +0000[diff] [blame]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>
Owen Andersonb207ff22007-10-20 05:23:06 +0000[diff] [blame]52
Owen Anderson4c209da2007-10-25 06:49:29 +0000[diff] [blame]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>
Gabor Greif42225e52009-03-11 20:23:40 +0000[diff] [blame^]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"
Owen Anderson4c209da2007-10-25 06:49:29 +0000[diff] [blame]64</pre>
65</div>
Owen Andersonb207ff22007-10-20 05:23:06 +0000[diff] [blame]66
Bill Wendling8912f212008-05-19 00:19:02 +0000[diff] [blame]67<p>Now, let's get started on our real program. Here's what our basic <code>main()</code> will look like:</p>
Owen Andersonb207ff22007-10-20 05:23:06 +0000[diff] [blame]68
69<div class="doc_code">
70<pre>
71using namespace llvm;
72
73Module* makeLLVMModule();
74
75int main(int argc, char**argv) {
76 Module* Mod = makeLLVMModule();
77
78 verifyModule(*Mod, PrintMessageAction);
79
80 PassManager PM;
81 PM.add(new PrintModulePass(&amp;llvm::cout));
82 PM.run(*Mod);
83
Bill Wendling08226ea2008-05-19 00:15:33 +0000[diff] [blame]84 delete Mod;
Owen Andersonb207ff22007-10-20 05:23:06 +0000[diff] [blame]85 return 0;
86}
87</pre>
88</div>
89
Chris Lattnera1ad2bf2008-02-10 19:11:04 +0000[diff] [blame]90<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>
Owen Andersonb207ff22007-10-20 05:23:06 +0000[diff] [blame]91
Bill Wendling8912f212008-05-19 00:19:02 +0000[diff] [blame]92<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>
Owen Andersonb207ff22007-10-20 05:23:06 +0000[diff] [blame]93
Bill Wendlingdc73a702008-05-19 00:05:30 +0000[diff] [blame]94<p>Finally, we instantiate an LLVM <code>PassManager</code> and run
95the <code>PrintModulePass</code> on our module. LLVM uses an explicit pass
96infrastructure to manage optimizations and various other things.
97A <code>PassManager</code>, as should be obvious from its name, manages passes:
98it is responsible for scheduling them, invoking them, and ensuring the proper
99disposal after we’re done with them. For this example, we’re just using a
100trivial pass that prints out our module in textual form.</p>
Owen Andersonb207ff22007-10-20 05:23:06 +0000[diff] [blame]101
Bill Wendling8912f212008-05-19 00:19:02 +0000[diff] [blame]102<p>Now onto the interesting part: creating and populating a module. Here's the
Bill Wendlingdc73a702008-05-19 00:05:30 +0000[diff] [blame]103first chunk of our <code>makeLLVMModule()</code>:</p>
Owen Andersonb207ff22007-10-20 05:23:06 +0000[diff] [blame]104
105<div class="doc_code">
106<pre>
107Module* makeLLVMModule() {
108 // Module Construction
109 Module* mod = new Module("test");
110</pre>
111</div>
112
113<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>
114
115<div class="doc_code">
116<pre>
Chris Lattnera1ad2bf2008-02-10 19:11:04 +0000[diff] [blame]117 Constant* c = mod-&gt;getOrInsertFunction("mul_add",
Owen Andersonbbed0432007-10-22 06:29:31 +0000[diff] [blame]118 /*ret type*/ IntegerType::get(32),
119 /*args*/ IntegerType::get(32),
120 IntegerType::get(32),
121 IntegerType::get(32),
122 /*varargs terminated with null*/ NULL);
Owen Andersonb207ff22007-10-20 05:23:06 +0000[diff] [blame]123
Owen Andersonf747ab12007-10-20 05:40:47 +0000[diff] [blame]124 Function* mul_add = cast&lt;Function&gt;(c);
Chris Lattnera1ad2bf2008-02-10 19:11:04 +0000[diff] [blame]125 mul_add-&gt;setCallingConv(CallingConv::C);
Owen Andersonb207ff22007-10-20 05:23:06 +0000[diff] [blame]126</pre>
127</div>
128
Chris Lattnera1ad2bf2008-02-10 19:11:04 +0000[diff] [blame]129<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>
Owen Andersonb207ff22007-10-20 05:23:06 +0000[diff] [blame]130
Chris Lattnera1ad2bf2008-02-10 19:11:04 +0000[diff] [blame]131<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>.
Owen Andersonf747ab12007-10-20 05:40:47 +0000[diff] [blame]132
Bill Wendlingdc73a702008-05-19 00:05:30 +0000[diff] [blame]133<p>In addition, we set the calling convention for our new function to be the C
134calling convention. This isn’t strictly necessary, but it ensures that our new
135function will interoperate properly with C code, which is a good thing.</p>
Owen Andersonb207ff22007-10-20 05:23:06 +0000[diff] [blame]136
137<div class="doc_code">
138<pre>
Chris Lattnera1ad2bf2008-02-10 19:11:04 +0000[diff] [blame]139 Function::arg_iterator args = mul_add-&gt;arg_begin();
Owen Andersonb207ff22007-10-20 05:23:06 +0000[diff] [blame]140 Value* x = args++;
Chris Lattnera1ad2bf2008-02-10 19:11:04 +0000[diff] [blame]141 x-&gt;setName("x");
Owen Andersonb207ff22007-10-20 05:23:06 +0000[diff] [blame]142 Value* y = args++;
Chris Lattnera1ad2bf2008-02-10 19:11:04 +0000[diff] [blame]143 y-&gt;setName("y");
Owen Andersonb207ff22007-10-20 05:23:06 +0000[diff] [blame]144 Value* z = args++;
Chris Lattnera1ad2bf2008-02-10 19:11:04 +0000[diff] [blame]145 z-&gt;setName("z");
Owen Andersonb207ff22007-10-20 05:23:06 +0000[diff] [blame]146</pre>
147</div>
148
Bill Wendling8912f212008-05-19 00:19:02 +0000[diff] [blame]149<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>
Owen Andersonb207ff22007-10-20 05:23:06 +0000[diff] [blame]150
Chris Lattnera1ad2bf2008-02-10 19:11:04 +0000[diff] [blame]151<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>
Owen Andersonb207ff22007-10-20 05:23:06 +0000[diff] [blame]152
153<div class="doc_code">
154<pre>
Gabor Greif5b665492008-04-19 22:25:09 +0000[diff] [blame]155 BasicBlock* block = BasicBlock::Create("entry", mul_add);
Gabor Greifbfdf23f2009-03-11 19:51:07 +0000[diff] [blame]156 IRBuilder&lt;&gt; builder(block);
Owen Andersonb207ff22007-10-20 05:23:06 +0000[diff] [blame]157</pre>
158</div>
159
Duncan Sandsa07136e2008-04-13 06:22:09 +0000[diff] [blame]160<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>
Owen Andersonb207ff22007-10-20 05:23:06 +0000[diff] [blame]161
162<div class="doc_code">
163<pre>
164 Value* tmp = builder.CreateBinOp(Instruction::Mul,
Bill Wendling08226ea2008-05-19 00:15:33 +0000[diff] [blame]165 x, y, "tmp");
Owen Andersonb207ff22007-10-20 05:23:06 +0000[diff] [blame]166 Value* tmp2 = builder.CreateBinOp(Instruction::Add,
167 tmp, z, "tmp2");
168
169 builder.CreateRet(tmp2);
Owen Andersonbbed0432007-10-22 06:29:31 +0000[diff] [blame]170
171 return mod;
Owen Andersonb207ff22007-10-20 05:23:06 +0000[diff] [blame]172}
173</pre>
174</div>
175
Bill Wendling8912f212008-05-19 00:19:02 +0000[diff] [blame]176<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>
Owen Andersonb207ff22007-10-20 05:23:06 +0000[diff] [blame]177
Bill Wendling8912f212008-05-19 00:19:02 +0000[diff] [blame]178<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>
Owen Andersonb207ff22007-10-20 05:23:06 +0000[diff] [blame]179
Owen Anderson4c209da2007-10-25 06:49:29 +0000[diff] [blame]180<div class="doc_code">
181<pre>
Owen Andersonce268212008-03-24 21:38:01 +0000[diff] [blame]182# c++ -g tut1.cpp `llvm-config --cxxflags --ldflags --libs core` -o tut1
Chris Lattnera1ad2bf2008-02-10 19:11:04 +0000[diff] [blame]183# ./tut1
Owen Anderson4c209da2007-10-25 06:49:29 +0000[diff] [blame]184</pre>
185</div>
186
187<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>
Owen Andersonb207ff22007-10-20 05:23:06 +0000[diff] [blame]188
Chris Lattnera1ad2bf2008-02-10 19:11:04 +0000[diff] [blame]189<a href="JITTutorial2.html">Next: A More Complicated Function</a>
Owen Andersonb207ff22007-10-20 05:23:06 +0000[diff] [blame]190</div>
191
Owen Andersonaf8059c2007-10-25 06:45:01 +0000[diff] [blame]192<!-- *********************************************************************** -->
193<hr>
194<address>
195 <a href="http://jigsaw.w3.org/css-validator/check/referer"><img
196 src="http://jigsaw.w3.org/css-validator/images/vcss" alt="Valid CSS!"></a>
197 <a href="http://validator.w3.org/check/referer"><img
198 src="http://www.w3.org/Icons/valid-html401" alt="Valid HTML 4.01!"></a>
199
200 <a href="mailto:owen@apple.com">Owen Anderson</a><br>
201 <a href="http://llvm.org">The LLVM Compiler Infrastructure</a><br>
202 Last modified: $Date: 2007-10-17 11:05:13 -0700 (Wed, 17 Oct 2007) $
203</address>
204
Owen Andersonb207ff22007-10-20 05:23:06 +0000[diff] [blame]205</body>
Duncan Sandsf8bc4062007-11-05 15:15:50 +0000[diff] [blame]206</html>