From 237cef4b0b94b17ca065efad484f386f42579b61 Mon Sep 17 00:00:00 2001 From: Misha Brukman Date: Wed, 20 Apr 2005 16:42:34 +0000 Subject: [PATCH] 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 --- examples/BFtoLLVM/BFtoLLVM.cpp | 12 ++++++------ examples/Fibonacci/fibonacci.cpp | 18 +++++++++--------- examples/HowToUseJIT/HowToUseJIT.cpp | 30 +++++++++++++++--------------- examples/ModuleMaker/ModuleMaker.cpp | 22 +++++++++++----------- 4 files changed, 41 insertions(+), 41 deletions(-) diff --git a/examples/BFtoLLVM/BFtoLLVM.cpp b/examples/BFtoLLVM/BFtoLLVM.cpp index b870676fb8b..159d0b619d8 100644 --- a/examples/BFtoLLVM/BFtoLLVM.cpp +++ b/examples/BFtoLLVM/BFtoLLVM.cpp @@ -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(); diff --git a/examples/Fibonacci/fibonacci.cpp b/examples/Fibonacci/fibonacci.cpp index afffce74084..2bef63bb158 100644 --- a/examples/Fibonacci/fibonacci.cpp +++ b/examples/Fibonacci/fibonacci.cpp @@ -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); diff --git a/examples/HowToUseJIT/HowToUseJIT.cpp b/examples/HowToUseJIT/HowToUseJIT.cpp index 3762dfe3cb4..31ea4f45404 100644 --- a/examples/HowToUseJIT/HowToUseJIT.cpp +++ b/examples/HowToUseJIT/HowToUseJIT.cpp @@ -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 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); diff --git a/examples/ModuleMaker/ModuleMaker.cpp b/examples/ModuleMaker/ModuleMaker.cpp index 10764463697..04c6a9f95bf 100644 --- a/examples/ModuleMaker/ModuleMaker.cpp +++ b/examples/ModuleMaker/ModuleMaker.cpp @@ -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(), /*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; -- 2.11.0