//===-- BFtoLLVM.cpp - BF language Front End for LLVM ---------------------===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This is a simple front end for the BF language. It is compatible with the
std::string ptr = gensym (op + "ptr"),
val = gensym (op + "val"),
result = gensym (op + "result");
- dest << ptr << " = load sbyte** %ptrbox\n"
+ dest << ptr << " = load sbyte** %ptrbox\n"
<< val << " = load sbyte* " << ptr << "\n"
<< result << " = add sbyte " << val << ", " << (int)delta << "\n"
<< "store sbyte " << result << ", sbyte* " << ptr << "\n";
char *sourceFileName = argv[1];
char *destFileName = argv[2];
-
+
std::ifstream src (sourceFileName);
if (!src.good()) {
std::cerr << sourceFileName << ": " << strerror(errno) << "\n";
std::cerr << destFileName << ": " << strerror(errno) << "\n";
return 1;
}
-
+
emitDeclarations(dest);
emitMainFunctionProlog(dest);
repeatCount = 0;
}
consume (lastCh, repeatCount, dest);
-
+
emitMainFunctionEpilog(dest);
src.close();
//===--- examples/Fibonacci/fibonacci.cpp - An example use of the JIT -----===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by Valery A. Khamenya and is distributed under the
// University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This small program provides an example of how to build quickly a small module
// if(x<=2) return 1;
// return fib(x-1)+fib(x-2);
// }
-//
+//
// Once we have this, we compile the module via JIT, then execute the `fib'
// function and return result to a driver, i.e. to a "host program".
//
// Create the fib function and insert it into module M. This function is said
// to return an int and take an int parameter.
Function *FibF = M->getOrInsertFunction("fib", Type::IntTy, Type::IntTy, 0);
-
+
// Add a basic block to the function.
BasicBlock *BB = new BasicBlock("EntryBlock", FibF);
-
+
// Get pointers to the constants.
Value *One = ConstantSInt::get(Type::IntTy, 1);
Value *Two = ConstantSInt::get(Type::IntTy, 2);
// Create: ret int 1
new ReturnInst(One, RetBB);
-
+
// create fib(x-1)
Value *Sub = BinaryOperator::createSub(ArgX, One, "arg", RecurseBB);
Value *CallFibX1 = new CallInst(FibF, Sub, "fibx1", RecurseBB);
-
+
// create fib(x-2)
Sub = BinaryOperator::createSub(ArgX, Two, "arg", RecurseBB);
Value *CallFibX2 = new CallInst(FibF, Sub, "fibx2", RecurseBB);
// fib(x-1)+fib(x-2)
Value *Sum = BinaryOperator::createAdd(CallFibX1, CallFibX2,
"addresult", RecurseBB);
-
+
// Create the return instruction and add it to the basic block
new ReturnInst(Sum, RecurseBB);
// We are about to create the "fib" function:
Function *FibF = CreateFibFunction(M);
- // Now we going to create JIT
+ // Now we going to create JIT
ExistingModuleProvider *MP = new ExistingModuleProvider(M);
ExecutionEngine *EE = ExecutionEngine::create(MP, false);
//===-- examples/HowToUseJIT/HowToUseJIT.cpp - An example use of the JIT --===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by Valery A. Khamenya and is distributed under the
// University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This small program provides an example of how to quickly build a small
-// module with two functions and execute it with the JIT.
-//
-// Goal:
+// module with two functions and execute it with the JIT.
+//
+// Goal:
// The goal of this snippet is to create in the memory
// the LLVM module consisting of two functions as follow:
//
// int add1(int x) {
// return x+1;
// }
-//
+//
// int foo() {
// return add1(10);
// }
-//
-// then compile the module via JIT, then execute the `foo'
+//
+// then compile the module via JIT, then execute the `foo'
// function and return result to a driver, i.e. to a "host program".
-//
+//
// Some remarks and questions:
-//
+//
// - could we invoke some code using noname functions too?
-// e.g. evaluate "foo()+foo()" without fears to introduce
+// e.g. evaluate "foo()+foo()" without fears to introduce
// conflict of temporary function name with some real
// existing function name?
-//
+//
//===----------------------------------------------------------------------===//
#include "llvm/Module.h"
// Add a basic block to the function. As before, it automatically inserts
// because of the last argument.
BasicBlock *BB = new BasicBlock("EntryBlock", Add1F);
-
+
// Get pointers to the constant `1'.
Value *One = ConstantSInt::get(Type::IntTy, 1);
// Create the add instruction, inserting it into the end of BB.
Instruction *Add = BinaryOperator::createAdd(One, ArgX, "addresult", BB);
-
+
// Create the return instruction and add it to the basic block
new ReturnInst(Add, BB);
std::vector<Value*> Params;
Params.push_back(Ten);
CallInst * Add1CallRes = new CallInst(Add1F, Params, "add1", BB);
-
+
// Create the return instruction and add it to the basic block.
new ReturnInst(Add1CallRes, BB);
//===- examples/ModuleMaker/ModuleMaker.cpp - Example project ---*- C++ -*-===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This programs is a simple example that creates an LLVM module "from scratch",
// Create the "module" or "program" or "translation unit" to hold the
// function
Module *M = new Module("test");
-
+
// Create the main function: first create the type 'int ()'
FunctionType *FT = FunctionType::get(Type::IntTy, std::vector<const Type*>(),
/*not vararg*/false);
-
+
// By passing a module as the last parameter to the Function constructor,
// it automatically gets appended to the Module.
Function *F = new Function(FT, Function::ExternalLinkage, "main", M);
-
+
// Add a basic block to the function... again, it automatically inserts
// because of the last argument.
BasicBlock *BB = new BasicBlock("EntryBlock", F);
-
+
// Get pointers to the constant integers...
Value *Two = ConstantSInt::get(Type::IntTy, 2);
Value *Three = ConstantSInt::get(Type::IntTy, 3);
-
+
// Create the add instruction... does not insert...
Instruction *Add = BinaryOperator::create(Instruction::Add, Two, Three,
"addresult");
-
+
// explicitly insert it into the basic block...
BB->getInstList().push_back(Add);
-
+
// Create the return instruction and add it to the basic block
BB->getInstList().push_back(new ReturnInst(Add));
-
+
// Output the bytecode file to stdout
WriteBytecodeToFile(M, std::cout);
-
+
// Delete the module and all of its contents.
delete M;
return 0;
projects / oota-llvm.git / commitdiff