Remove trailing whitespace

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@21422 91177308-0d34-0410-b5e6-96231b3b80d8

lib/ExecutionEngine/JIT/Intercept.cpp

@@ -1,10 +1,10 @@
 //===-- Intercept.cpp - System function interception routines -------------===//
-// 
+//
 //                     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.
-// 
+//
 //===----------------------------------------------------------------------===//
 //
 // If a function call occurs to an external function, the JIT is designed to use
@@ -50,7 +50,7 @@ static void runAtExitHandlers() {
 #if defined(__linux__)
 #if defined(HAVE_SYS_STAT_H)
 #include <sys/stat.h>
-#endif 
+#endif
 void *FunctionPointers[] = {
   (void *) stat,
   (void *) fstat,
@@ -84,9 +84,9 @@ static int jit_atexit(void (*Fn)(void)) {
 }
 
 //===----------------------------------------------------------------------===//
-// 
+//
 /// getPointerToNamedFunction - This method returns the address of the specified
-/// function by using the dynamic loader interface.  As such it is only useful 
+/// function by using the dynamic loader interface.  As such it is only useful
 /// for resolving library symbols, not code generated symbols.
 ///
 void *JIT::getPointerToNamedFunction(const std::string &Name) {

lib/ExecutionEngine/JIT/JIT.cpp

@@ -1,10 +1,10 @@
 //===-- JIT.cpp - LLVM Just in Time Compiler ------------------------------===//
-// 
+//
 //                     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 tool implements a just-in-time compiler for LLVM, allowing direct
@@ -35,7 +35,7 @@ JIT::JIT(ModuleProvider *MP, TargetMachine &tm, TargetJITInfo &tji)
 
   // Initialize MCE
   MCE = createEmitter(*this);
-  
+
   // Add target data
   PM.add(new TargetData(TM.getTargetData()));
 
@@ -77,7 +77,7 @@ GenericValue JIT::runFunction(Function *F,
   if (RetTy == Type::IntTy || RetTy == Type::UIntTy || RetTy == Type::VoidTy) {
     switch (ArgValues.size()) {
     case 3:
-      if ((FTy->getParamType(0) == Type::IntTy || 
+      if ((FTy->getParamType(0) == Type::IntTy ||
            FTy->getParamType(0) == Type::UIntTy) &&
           isa<PointerType>(FTy->getParamType(1)) &&
           isa<PointerType>(FTy->getParamType(2))) {
@@ -92,7 +92,7 @@ GenericValue JIT::runFunction(Function *F,
       }
       break;
     case 2:
-      if ((FTy->getParamType(0) == Type::IntTy || 
+      if ((FTy->getParamType(0) == Type::IntTy ||
            FTy->getParamType(0) == Type::UIntTy) &&
           isa<PointerType>(FTy->getParamType(1))) {
         int (*PF)(int, char **) = (int(*)(int, char **))FPtr;
@@ -105,7 +105,7 @@ GenericValue JIT::runFunction(Function *F,
       break;
     case 1:
       if (FTy->getNumParams() == 1 &&
-          (FTy->getParamType(0) == Type::IntTy || 
+          (FTy->getParamType(0) == Type::IntTy ||
            FTy->getParamType(0) == Type::UIntTy)) {
         GenericValue rv;
         int (*PF)(int) = (int(*)(int))FPtr;
@@ -239,7 +239,7 @@ void *JIT::getPointerToFunction(Function *F) {
     return Addr;   // Check if function already code gen'd
 
   // Make sure we read in the function if it exists in this Module
-  if (F->hasNotBeenReadFromBytecode()) 
+  if (F->hasNotBeenReadFromBytecode())
     try {
       MP->materializeFunction(F);
     } catch ( std::string& errmsg ) {

lib/ExecutionEngine/JIT/JIT.h

@@ -1,10 +1,10 @@
 //===-- JIT.h - Class definition for the JIT --------------------*- 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 file defines the top-level JIT data structure.
@@ -30,7 +30,7 @@ class MachineCodeEmitter;
 class JIT : public ExecutionEngine {
   TargetMachine &TM;       // The current target we are compiling to
   TargetJITInfo &TJI;      // The JITInfo for the target we are compiling to
-  
+
   FunctionPassManager PM;  // Passes to compile a function
   MachineCodeEmitter *MCE; // MCE object
 
@@ -67,7 +67,7 @@ public:
 
   // CompilationCallback - Invoked the first time that a call site is found,
   // which causes lazy compilation of the target function.
-  // 
+  //
   static void CompilationCallback();
 
   /// getPointerToFunction - This returns the address of the specified function,

lib/ExecutionEngine/JIT/JITEmitter.cpp

@@ -1,10 +1,10 @@
 //===-- JITEmitter.cpp - Write machine code to executable memory ----------===//
-// 
+//
 //                     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 file defines a MachineCodeEmitter object that is used by the JIT to
@@ -54,7 +54,7 @@ namespace {
   public:
     JITMemoryManager();
     ~JITMemoryManager();
-    
+
     inline unsigned char *allocateStub(unsigned StubSize);
     inline unsigned char *allocateConstant(unsigned ConstantSize,
                                            unsigned Alignment);
@@ -190,7 +190,7 @@ void *JITResolver::getFunctionStub(Function *F) {
   void *Actual = (void*)LazyResolverFn;
   if (F->isExternal() && F->hasExternalLinkage())
     Actual = TheJIT->getPointerToFunction(F);
-    
+
   // Otherwise, codegen a new stub.  For now, the stub will call the lazy
   // resolver function.
   Stub = TheJIT->getJITInfo().emitFunctionStub(Actual, MCE);
@@ -230,7 +230,7 @@ void *JITResolver::getExternalFunctionStub(void *FnAddr) {
 /// it if necessary, then returns the resultant function pointer.
 void *JITResolver::JITCompilerFn(void *Stub) {
   JITResolver &JR = getJITResolver();
-  
+
   // The address given to us for the stub may not be exactly right, it might be
   // a little bit after the stub.  As such, use upper_bound to find it.
   std::map<void*, Function*>::iterator I =
@@ -373,7 +373,7 @@ void JITEmitter::finishFunction(MachineFunction &F) {
       void *ResultPtr;
       if (MR.isString()) {
         ResultPtr = TheJIT->getPointerToNamedFunction(MR.getString());
-        
+
         // If the target REALLY wants a stub for this function, emit it now.
         if (!MR.doesntNeedFunctionStub())
           ResultPtr = getJITResolver(this).getExternalFunctionStub(ResultPtr);

lib/ExecutionEngine/JIT/TargetSelect.cpp

@@ -1,10 +1,10 @@
 //===-- TargetSelect.cpp - Target Chooser Code ----------------------------===//
-// 
+//
 //                     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 just asks the TargetMachineRegistry for the appropriate JIT to use, and