From 729eb14ae8b1a1002a212a99cdc411659670fbd4 Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Sun, 10 Feb 2008 19:11:04 +0000 Subject: Various updates from Sam Bishop: "I have been working my way through the JIT and Kaleidoscope tutorials in my (minuscule) spare time. Thanks again for writing them! I have attached a patch containing some minor changes, ranging from spelling and grammar fixes to adding a "Next: " hyperlink to the bottom of each page. Every page has been given the "next link" treatment, but otherwise I'm only half way through the Kaleidoscope tutorial. I will send a follow-on patch if time permits." git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@46933 91177308-0d34-0410-b5e6-96231b3b80d8 --- docs/tutorial/JITTutorial1.html | 31 ++++++++++++++++--------------- 1 file changed, 16 insertions(+), 15 deletions(-) (limited to 'docs/tutorial/JITTutorial1.html') diff --git a/docs/tutorial/JITTutorial1.html b/docs/tutorial/JITTutorial1.html index fb906cd677..ef026c0fd6 100644 --- a/docs/tutorial/JITTutorial1.html +++ b/docs/tutorial/JITTutorial1.html @@ -25,7 +25,7 @@
-

For starters, lets 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:

+

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:

@@ -86,7 +86,7 @@ int main(int argc, char**argv) {
-

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 and function declarations and implementations. Here, we’ve declared a makeLLVMModule() function to do the real work of creating the module. Don’t worry, we’ll be looking at that one next!

+

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 makeLLVMModule() function to do the real work of creating the module. Don’t worry, we’ll be looking at that one next!

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.

@@ -106,7 +106,7 @@ Module* makeLLVMModule() { 
-  Constant* c = mod->getOrInsertFunction("mul_add",
+  Constant* c = mod->getOrInsertFunction("mul_add",
   /*ret type*/                           IntegerType::get(32),
   /*args*/                               IntegerType::get(32),
                                          IntegerType::get(32),
@@ -114,31 +114,31 @@ Module* makeLLVMModule() {
   /*varargs terminated with null*/       NULL);
   
   Function* mul_add = cast<Function>(c);
-  mul_add->setCallingConv(CallingConv::C);
+  mul_add->setCallingConv(CallingConv::C);
-

We construct our Function by calling getOrInsertFunction() on our module, passing in the name, return type, and argument types of the function. In the case of our mul_add function, that means one 32-bit integer for the return value, and three 32-bit integers for the arguments.

+

We construct our Function by calling getOrInsertFunction() on our module, passing in the name, return type, and argument types of the function. In the case of our mul_add function, that means one 32-bit integer for the return value and three 32-bit integers for the arguments.

-

You'll notice that getOrInsertFunction doesn't actually return a Function*. This is because, if the function already existed, but with a different prototype, getOrInsertFunction will return a cast of the existing function to the desired prototype. Since we know that there's not already a mul_add function, we can safely just cast c to a Function*. +

You'll notice that getOrInsertFunction() doesn't actually return a Function*. This is because getOrInsertFunction() 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 mul_add function, we can safely just cast c to a Function*.

In addition, we set the calling convention for our new function to be the C calling convention. This isn’t strictly necessary, but it insures that our new function will interoperate properly with C code, which is a good thing.

-  Function::arg_iterator args = mul_add->arg_begin();
+  Function::arg_iterator args = mul_add->arg_begin();
   Value* x = args++;
-  x->setName("x");
+  x->setName("x");
   Value* y = args++;
-  y->setName("y");
+  y->setName("y");
   Value* z = args++;
-  z->setName("z");
+  z->setName("z");
-

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 iterator over the arguments of our function, and call setName() on them. We’ll also keep the pointer to x, y, and z around, since we’ll need them when we get around to creating instructions.

+

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 setName() on them. We’ll also keep the pointer to x, y, and z around, since we’ll need them when we get around to creating instructions.

-

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!

+

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:

@@ -165,17 +165,18 @@ Module* makeLLVMModule() {
 
 
The final step in creating our function is to create the instructions that make it up.  Our mul_add function is composed of just three instructions: a multiply, an add, and a return.  LLVMBuilder gives us a simple interface for constructing these instructions and appending them to the “entry” block.  Each of the calls to LLVMBuilder returns a Value* that represents the value yielded by the instruction.  You’ll also notice that, above, x, y, and z are also Value*’s, so it’s clear that instructions operate on Value*’s.

 
-
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 commandline as a guide:

+
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:

 
 

 
-# c++ -g tut2.cpp `llvm-config --cppflags --ldflags --libs core` -o tut2
-# ./tut2
+# c++ -g tut1.cpp `llvm-config --cppflags --ldflags --libs core` -o tut1
+# ./tut1
 

 

 
 
The llvm-config 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.

 
+Next: A More Complicated Function
-- cgit v1.2.3-70-g09d2