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

@@ -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();

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);
 

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

@@ -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;