Remove trailing whitespace at the end of lines

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@21380 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Misha Brukman 2005-04-20 16:42:34 +00:00
parent d6a29a5304
commit 237cef4b0b
4 changed files with 41 additions and 41 deletions

View File

@ -1,10 +1,10 @@
//===-- 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
@ -60,7 +60,7 @@ void emitArith (std::string op, char delta, std::ofstream &dest) {
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";
@ -172,7 +172,7 @@ int main (int argc, char **argv) {
char *sourceFileName = argv[1];
char *destFileName = argv[2];
std::ifstream src (sourceFileName);
if (!src.good()) {
std::cerr << sourceFileName << ": " << strerror(errno) << "\n";
@ -184,7 +184,7 @@ int main (int argc, char **argv) {
std::cerr << destFileName << ": " << strerror(errno) << "\n";
return 1;
}
emitDeclarations(dest);
emitMainFunctionProlog(dest);
@ -199,7 +199,7 @@ int main (int argc, char **argv) {
repeatCount = 0;
}
consume (lastCh, repeatCount, dest);
emitMainFunctionEpilog(dest);
src.close();

View File

@ -1,10 +1,10 @@
//===--- 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
@ -17,7 +17,7 @@
// 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".
//
@ -38,10 +38,10 @@ static Function *CreateFibFunction(Module *M) {
// 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);
@ -61,11 +61,11 @@ static Function *CreateFibFunction(Module *M) {
// 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);
@ -73,7 +73,7 @@ static Function *CreateFibFunction(Module *M) {
// 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);
@ -90,7 +90,7 @@ int main(int argc, char **argv) {
// 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);

View File

@ -1,37 +1,37 @@
//===-- 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"
@ -56,7 +56,7 @@ int main() {
// 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);
@ -67,7 +67,7 @@ int main() {
// 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);
@ -88,7 +88,7 @@ int main() {
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);

View File

@ -1,10 +1,10 @@
//===- 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",
@ -26,36 +26,36 @@ int main() {
// 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;