Remove trailing whitespace

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

16 files changed, 228 insertions, 228 deletions

diff --git a/lib/Support/Annotation.cpp b/lib/Support/Annotation.cpp
index d35904e9b8..b46e218416 100644
--- a/lib/Support/Annotation.cpp
+++ b/lib/Support/Annotation.cpp
@@ -1,10 +1,10 @@
 //===-- Annotation.cpp - Implement the Annotation Classes -----------------===//
-// 
+//
 //                     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 implements the AnnotationManager class.
@@ -67,7 +67,7 @@ AnnotationID AnnotationManager::getID(const std::string &Name, Factory Fact,
                                       void *Data) {
   AnnotationID Result(getID(Name));
   registerAnnotationFactory(Result, Fact, Data);
-  return Result;                      
+  return Result;
 }
 
 // getName - This function is especially slow, but that's okay because it should
@@ -82,7 +82,7 @@ const std::string &AnnotationManager::getName(AnnotationID ID) {  // ID -> Name
 }
 
 // registerAnnotationFactory - This method is used to register a callback
-// function used to create an annotation on demand if it is needed by the 
+// function used to create an annotation on demand if it is needed by the
 // Annotable::findOrCreateAnnotation method.
 //
 void AnnotationManager::registerAnnotationFactory(AnnotationID ID, AnnFactory F,
@@ -96,7 +96,7 @@ void AnnotationManager::registerAnnotationFactory(AnnotationID ID, AnnFactory F,
 // createAnnotation - Create an annotation of the specified ID for the
 // specified object, using a register annotation creation function.
 //
-Annotation *AnnotationManager::createAnnotation(AnnotationID ID, 
+Annotation *AnnotationManager::createAnnotation(AnnotationID ID,
                                                 const Annotable *Obj) {
   FactMapType::iterator I = getFactMap().find(ID.ID);
   if (I == getFactMap().end()) return 0;
diff --git a/lib/Support/CommandLine.cpp b/lib/Support/CommandLine.cpp
index f73ec6d878..73d26cf619 100644
--- a/lib/Support/CommandLine.cpp
+++ b/lib/Support/CommandLine.cpp
@@ -1,10 +1,10 @@
 //===-- CommandLine.cpp - Command line parser implementation --------------===//
-// 
+//
 //                     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 class implements a command line argument processor that is useful when
@@ -68,7 +68,7 @@ static std::vector<Option*> &getPositionalOpts() {
 
 static void AddArgument(const char *ArgName, Option *Opt) {
   if (getOption(ArgName)) {
-    std::cerr << ProgramName << ": CommandLine Error: Argument '" 
+    std::cerr << ProgramName << ": CommandLine Error: Argument '"
               << ArgName << "' defined more than once!\n";
   } else {
     // Add argument to the argument map!
@@ -78,7 +78,7 @@ static void AddArgument(const char *ArgName, Option *Opt) {
 
 // RemoveArgument - It's possible that the argument is no longer in the map if
 // options have already been processed and the map has been deleted!
-// 
+//
 static void RemoveArgument(const char *ArgName, Option *Opt) {
   if(getOpts().empty()) return;
 
@@ -107,15 +107,15 @@ static inline bool ProvideOption(Option *Handler, const char *ArgName,
     break;
   case ValueDisallowed:
     if (*Value != 0)
-      return Handler->error(" does not allow a value! '" + 
+      return Handler->error(" does not allow a value! '" +
                             std::string(Value) + "' specified.");
     break;
-  case ValueOptional: 
+  case ValueOptional:
     break;
-  default: 
-    std::cerr << ProgramName 
-              << ": Bad ValueMask flag! CommandLine usage error:" 
-              << Handler->getValueExpectedFlag() << "\n"; 
+  default:
+    std::cerr << ProgramName
+              << ": Bad ValueMask flag! CommandLine usage error:"
+              << Handler->getValueExpectedFlag() << "\n";
     abort();
     break;
   }
@@ -124,7 +124,7 @@ static inline bool ProvideOption(Option *Handler, const char *ArgName,
   return Handler->addOccurrence(i, ArgName, Value);
 }
 
-static bool ProvidePositionalOption(Option *Handler, const std::string &Arg, 
+static bool ProvidePositionalOption(Option *Handler, const std::string &Arg,
                                     int i) {
   int Dummy = i;
   return ProvideOption(Handler, Handler->ArgStr, Arg.c_str(), 0, 0, Dummy);
@@ -147,7 +147,7 @@ static inline bool isPrefixedOrGrouping(const Option *O) {
 //
 static Option *getOptionPred(std::string Name, unsigned &Length,
                              bool (*Pred)(const Option*)) {
-  
+
   Option *Op = getOption(Name);
   if (Op && Pred(Op)) {
     Length = Name.length();
@@ -236,7 +236,7 @@ void cl::ParseEnvironmentOptions(const char *progName, const char *envVar,
   // Check args.
   assert(progName && "Program name not specified");
   assert(envVar && "Environment variable name missing");
-  
+
   // Get the environment variable they want us to parse options out of.
   const char *envValue = getenv (envVar);
   if (!envValue)
@@ -265,7 +265,7 @@ void cl::ParseEnvironmentOptions(const char *progName, const char *envVar,
 /// that as well.
 static Option *LookupOption(const char *&Arg, const char *&Value) {
   while (*Arg == '-') ++Arg;  // Eat leading dashes
-  
+
   const char *ArgEnd = Arg;
   while (*ArgEnd && *ArgEnd != '=')
     ++ArgEnd; // Scan till end of argument name...
@@ -273,7 +273,7 @@ static Option *LookupOption(const char *&Arg, const char *&Value) {
   Value = ArgEnd;
   if (*Value)           // If we have an equals sign...
     ++Value;            // Advance to value...
-  
+
   if (*Arg == 0) return 0;
 
   // Look up the option.
@@ -366,7 +366,7 @@ void cl::ParseCommandLineOptions(int &argc, char **argv,
         // All of the positional arguments have been fulfulled, give the rest to
         // the consume after option... if it's specified...
         //
-        if (PositionalVals.size() >= NumPositionalRequired && 
+        if (PositionalVals.size() >= NumPositionalRequired &&
             ConsumeAfterOpt != 0) {
           for (++i; i < argc; ++i)
             PositionalVals.push_back(std::make_pair(argv[i],i));
@@ -402,7 +402,7 @@ void cl::ParseCommandLineOptions(int &argc, char **argv,
         if (RealName.size() > 1) {
           unsigned Length = 0;
           Option *PGOpt = getOptionPred(RealName, Length, isPrefixedOrGrouping);
-  
+
           // If the option is a prefixed option, then the value is simply the
           // rest of the name...  so fall through to later processing, by
           // setting up the argument name flags and value fields.
@@ -415,13 +415,13 @@ void cl::ParseCommandLineOptions(int &argc, char **argv,
           } else if (PGOpt) {
             // This must be a grouped option... handle them now.
             assert(isGrouping(PGOpt) && "Broken getOptionPred!");
-            
+
             do {
               // Move current arg name out of RealName into RealArgName...
               std::string RealArgName(RealName.begin(),
                                       RealName.begin() + Length);
               RealName.erase(RealName.begin(), RealName.begin() + Length);
-              
+
               // Because ValueRequired is an invalid flag for grouped arguments,
               // we don't need to pass argc/argv in...
               //
@@ -430,11 +430,11 @@ void cl::ParseCommandLineOptions(int &argc, char **argv,
               int Dummy;
               ErrorParsing |= ProvideOption(PGOpt, RealArgName.c_str(),
                                             "", 0, 0, Dummy);
-              
+
               // Get the next grouping option...
               PGOpt = getOptionPred(RealName, Length, isGrouping);
             } while (PGOpt && Length != RealName.size());
-            
+
             Handler = PGOpt; // Ate all of the options.
           }
         }
@@ -473,13 +473,13 @@ void cl::ParseCommandLineOptions(int &argc, char **argv,
     // active one...
     if (Handler->getFormattingFlag() == cl::Positional)
       ActivePositionalArg = Handler;
-    else 
+    else
       ErrorParsing |= ProvideOption(Handler, ArgName, Value, argc, argv, i);
   }
 
   // Check and handle positional arguments now...
   if (NumPositionalRequired > PositionalVals.size()) {
-    std::cerr << ProgramName 
+    std::cerr << ProgramName
               << ": Not enough positional command line arguments specified!\n"
               << "Must specify at least " << NumPositionalRequired
               << " positional arguments: See: " << argv[0] << " --help\n";
@@ -491,7 +491,7 @@ void cl::ParseCommandLineOptions(int &argc, char **argv,
     unsigned ValNo = 0, NumVals = PositionalVals.size();
     for (unsigned i = 0, e = PositionalOpts.size(); i != e; ++i) {
       if (RequiresValue(PositionalOpts[i])) {
-        ProvidePositionalOption(PositionalOpts[i], PositionalVals[ValNo].first, 
+        ProvidePositionalOption(PositionalOpts[i], PositionalVals[ValNo].first,
                                 PositionalVals[ValNo].second);
         ValNo++;
         --NumPositionalRequired;  // We fulfilled our duty...
@@ -542,7 +542,7 @@ void cl::ParseCommandLineOptions(int &argc, char **argv,
                                               PositionalVals[ValNo].second);
       ValNo++;
     }
-    
+
     // Handle over all of the rest of the arguments to the
     // cl::ConsumeAfter command line option...
     for (; ValNo != PositionalVals.size(); ++ValNo)
@@ -552,7 +552,7 @@ void cl::ParseCommandLineOptions(int &argc, char **argv,
   }
 
   // Loop over args and make sure all required args are specified!
-  for (std::map<std::string, Option*>::iterator I = Opts.begin(), 
+  for (std::map<std::string, Option*>::iterator I = Opts.begin(),
          E = Opts.end(); I != E; ++I) {
     switch (I->second->getNumOccurrencesFlag()) {
     case Required:
@@ -688,7 +688,7 @@ unsigned basic_parser_impl::getOptionWidth(const Option &O) const {
   return Len + 6;
 }
 
-// printOptionInfo - Print out information about this option.  The 
+// printOptionInfo - Print out information about this option.  The
 // to-be-maintained width is specified.
 //
 void basic_parser_impl::printOptionInfo(const Option &O,
@@ -709,7 +709,7 @@ void basic_parser_impl::printOptionInfo(const Option &O,
 //
 bool parser<bool>::parse(Option &O, const char *ArgName,
                          const std::string &Arg, bool &Value) {
-  if (Arg == "" || Arg == "true" || Arg == "TRUE" || Arg == "True" || 
+  if (Arg == "" || Arg == "true" || Arg == "TRUE" || Arg == "True" ||
       Arg == "1") {
     Value = true;
   } else if (Arg == "false" || Arg == "FALSE" || Arg == "False" || Arg == "0") {
@@ -727,7 +727,7 @@ bool parser<int>::parse(Option &O, const char *ArgName,
                         const std::string &Arg, int &Value) {
   char *End;
   Value = (int)strtol(Arg.c_str(), &End, 0);
-  if (*End != 0) 
+  if (*End != 0)
     return O.error(": '" + Arg + "' value invalid for integer argument!");
   return false;
 }
@@ -753,7 +753,7 @@ static bool parseDouble(Option &O, const std::string &Arg, double &Value) {
   const char *ArgStart = Arg.c_str();
   char *End;
   Value = strtod(ArgStart, &End);
-  if (*End != 0) 
+  if (*End != 0)
     return O.error(": '" +Arg+ "' value invalid for floating point argument!");
   return false;
 }
@@ -808,7 +808,7 @@ unsigned generic_parser_base::getOptionWidth(const Option &O) const {
   }
 }
 
-// printOptionInfo - Print out information about this option.  The 
+// printOptionInfo - Print out information about this option.  The
 // to-be-maintained width is specified.
 //
 void generic_parser_base::printOptionInfo(const Option &O,
@@ -825,7 +825,7 @@ void generic_parser_base::printOptionInfo(const Option &O,
     }
   } else {
     if (O.HelpStr[0])
-      std::cerr << "  " << O.HelpStr << "\n"; 
+      std::cerr << "  " << O.HelpStr << "\n";
     for (unsigned i = 0, e = getNumOptions(); i != e; ++i) {
       unsigned L = std::strlen(getOption(i));
       std::cerr << "    -" << getOption(i) << std::string(GlobalWidth-L-8, ' ')
@@ -867,7 +867,7 @@ public:
     copy(getOpts().begin(), getOpts().end(), std::back_inserter(Options));
 
     // Eliminate Hidden or ReallyHidden arguments, depending on ShowHidden
-    Options.erase(std::remove_if(Options.begin(), Options.end(), 
+    Options.erase(std::remove_if(Options.begin(), Options.end(),
                          std::ptr_fun(ShowHidden ? isReallyHidden : isHidden)),
                   Options.end());
 
@@ -928,7 +928,7 @@ class VersionPrinter {
 public:
   void operator=(bool OptionWasSpecified) {
     if (OptionWasSpecified) {
-      std::cerr << "Low Level Virtual Machine (" << PACKAGE_NAME << ") " 
+      std::cerr << "Low Level Virtual Machine (" << PACKAGE_NAME << ") "
                 << PACKAGE_VERSION << " (see http://llvm.cs.uiuc.edu/)\n";
       getOpts().clear();  // Don't bother making option dtors remove from map.
       exit(1);
@@ -943,7 +943,7 @@ public:
 HelpPrinter NormalPrinter(false);
 HelpPrinter HiddenPrinter(true);
 
-cl::opt<HelpPrinter, true, parser<bool> > 
+cl::opt<HelpPrinter, true, parser<bool> >
 HOp("help", cl::desc("display available options (--help-hidden for more)"),
     cl::location(NormalPrinter), cl::ValueDisallowed);
 
@@ -954,7 +954,7 @@ HHOp("help-hidden", cl::desc("display all available options"),
 // Define the --version option that prints out the LLVM version for the tool
 VersionPrinter VersionPrinterInstance;
 cl::opt<VersionPrinter, true, parser<bool> >
-VersOp("version", cl::desc("display the version"), 
+VersOp("version", cl::desc("display the version"),
     cl::location(VersionPrinterInstance), cl::ValueDisallowed);
 
 
@@ -962,10 +962,10 @@ VersOp("version", cl::desc("display the version"),
 
 // Utility function for printing the help message.
 void cl::PrintHelpMessage() {
-  // This looks weird, but it actually prints the help message. The 
+  // This looks weird, but it actually prints the help message. The
   // NormalPrinter variable is a HelpPrinter and the help gets printed when
   // its operator= is invoked. That's because the "normal" usages of the
-  // help printer is to be assigned true/false depending on whether the 
+  // help printer is to be assigned true/false depending on whether the
   // --help option was given or not. Since we're circumventing that we have
   // to make it look like --help was given, so we assign true.
   NormalPrinter = true;
diff --git a/lib/Support/Compressor.cpp b/lib/Support/Compressor.cpp
index 49088b88eb..7396d4ad25 100644
--- a/lib/Support/Compressor.cpp
+++ b/lib/Support/Compressor.cpp
@@ -1,10 +1,10 @@
 //===- lib/Support/Compressor.cpp -------------------------------*- C++ -*-===//
-// 
+//
 //                     The LLVM Compiler Infrastructure
 //
-// This file was developed by Reid Spencer and is distributed under the 
+// This file was developed by Reid Spencer and is distributed under the
 // University of Illinois Open Source License. See LICENSE.TXT for details.
-// 
+//
 //===----------------------------------------------------------------------===//
 //
 // This file implements the llvm::Compressor class, an abstraction for memory
@@ -26,7 +26,7 @@ enum CompressionTypes {
   COMP_TYPE_BZIP2 = '2',
 };
 
-static int getdata(char*& buffer, size_t &size, 
+static int getdata(char*& buffer, size_t &size,
                    llvm::Compressor::OutputDataCallback* cb, void* context) {
   buffer = 0;
   size = 0;
@@ -36,7 +36,7 @@ static int getdata(char*& buffer, size_t &size,
   return result;
 }
 
-static int getdata_uns(char*& buffer, unsigned &size, 
+static int getdata_uns(char*& buffer, unsigned &size,
 		       llvm::Compressor::OutputDataCallback* cb, void* context) {
   size_t SizeOut;
   int Res = getdata(buffer, SizeOut, cb, context);
@@ -45,7 +45,7 @@ static int getdata_uns(char*& buffer, unsigned &size,
 }
 
 //===----------------------------------------------------------------------===//
-//=== NULLCOMP - a compression like set of routines that just copies data 
+//=== NULLCOMP - a compression like set of routines that just copies data
 //===            without doing any compression. This is provided so that if the
 //===            configured environment doesn't have a compression library the
 //===            program can still work, albeit using more data/memory.
@@ -121,26 +121,26 @@ namespace {
 
 /// This structure is only used when a bytecode file is compressed.
 /// As bytecode is being decompressed, the memory buffer might need
-/// to be reallocated. The buffer allocation is handled in a callback 
+/// to be reallocated. The buffer allocation is handled in a callback
 /// and this structure is needed to retain information across calls
 /// to the callback.
 /// @brief An internal buffer object used for handling decompression
 struct BufferContext {
   char* buff;
   size_t size;
-  BufferContext(size_t compressedSize) { 
+  BufferContext(size_t compressedSize) {
     // Null to indicate malloc of a new block
-    buff = 0; 
+    buff = 0;
 
     // Compute the initial length of the uncompression buffer. Note that this
     // is twice the length of the compressed buffer and will be doubled again
-    // in the callback for an initial allocation of 4x compressedSize.  This 
-    // calculation is based on the typical compression ratio of bzip2 on LLVM 
-    // bytecode files which typically ranges in the 50%-75% range.   Since we 
-    // typically get at least 50%, doubling is insufficient. By using a 4x 
+    // in the callback for an initial allocation of 4x compressedSize.  This
+    // calculation is based on the typical compression ratio of bzip2 on LLVM
+    // bytecode files which typically ranges in the 50%-75% range.   Since we
+    // typically get at least 50%, doubling is insufficient. By using a 4x
     // multiplier on the first allocation, we minimize the impact of having to
     // copy the buffer on reallocation.
-    size = compressedSize*2; 
+    size = compressedSize*2;
   }
 
   /// trimTo - Reduce the size of the buffer down to the specified amount.  This
@@ -154,7 +154,7 @@ struct BufferContext {
 
   /// This function handles allocation of the buffer used for decompression of
   /// compressed bytecode files. It is called by Compressor::decompress which is
-  /// called by BytecodeReader::ParseBytecode. 
+  /// called by BytecodeReader::ParseBytecode.
   static size_t callback(char*&buff, size_t &sz, void* ctxt){
     // Case the context variable to our BufferContext
     BufferContext* bc = reinterpret_cast<BufferContext*>(ctxt);
@@ -168,9 +168,9 @@ struct BufferContext {
     // Figure out what to return to the Compressor. If this is the first call,
     // then bc->buff will be null. In this case we want to return the entire
     // buffer because there was no previous allocation.  Otherwise, when the
-    // buffer is reallocated, we save the new base pointer in the 
-    // BufferContext.buff field but return the address of only the extension, 
-    // mid-way through the buffer (since its size was doubled). Furthermore, 
+    // buffer is reallocated, we save the new base pointer in the
+    // BufferContext.buff field but return the address of only the extension,
+    // mid-way through the buffer (since its size was doubled). Furthermore,
     // the sz result must be 1/2 the total size of the buffer.
     if (bc->buff == 0 ) {
       buff = bc->buff = new_buff;
@@ -189,18 +189,18 @@ struct BufferContext {
   }
 };
 
-} // end anonymous namespace 
+} // end anonymous namespace
 
 
 namespace {
 
 // This structure retains the context when compressing the bytecode file. The
 // WriteCompressedData function below uses it to keep track of the previously
-// filled chunk of memory (which it writes) and how many bytes have been 
+// filled chunk of memory (which it writes) and how many bytes have been
 // written.
 struct WriterContext {
   // Initialize the context
-  WriterContext(std::ostream*OS, size_t CS) 
+  WriterContext(std::ostream*OS, size_t CS)
     : chunk(0), sz(0), written(0), compSize(CS), Out(OS) {}
 
   // Make sure we clean up memory
@@ -219,10 +219,10 @@ struct WriterContext {
     sz = 0;
   }
 
-  // This function is a callback used by the Compressor::compress function to 
+  // This function is a callback used by the Compressor::compress function to
   // allocate memory for the compression buffer. This function fulfills that
   // responsibility but also writes the previous (now filled) buffer out to the
-  // stream. 
+  // stream.
   static size_t callback(char*& buffer, size_t &size, void* context) {
     // Cast the context to the structure it must point to.
     WriterContext* ctxt = reinterpret_cast<WriterContext*>(context);
@@ -259,7 +259,7 @@ struct WriterContext {
 }  // end anonymous namespace
 
 // Compress in one of three ways
-size_t Compressor::compress(const char* in, size_t size, 
+size_t Compressor::compress(const char* in, size_t size,
                             OutputDataCallback* cb, void* context) {
   assert(in && "Can't compress null buffer");
   assert(size && "Can't compress empty buffer");
@@ -355,7 +355,7 @@ size_t Compressor::compressToNewBuffer(const char* in, size_t size, char*&out) {
   return result;
 }
 
-size_t 
+size_t
 Compressor::compressToStream(const char*in, size_t size, std::ostream& out) {
   // Set up the context and writer
   WriterContext ctxt(&out, size / 2);
@@ -460,7 +460,7 @@ size_t Compressor::decompress(const char *in, size_t size,
   return result;
 }
 
-size_t 
+size_t
 Compressor::decompressToNewBuffer(const char* in, size_t size, char*&out) {
   BufferContext bc(size);
   size_t result = decompress(in,size,BufferContext::callback,(void*)&bc);
@@ -468,7 +468,7 @@ Compressor::decompressToNewBuffer(const char* in, size_t size, char*&out) {
   return result;
 }
 
-size_t 
+size_t
 Compressor::decompressToStream(const char*in, size_t size, std::ostream& out){
   // Set up the context and writer
   WriterContext ctxt(&out,size / 2);
diff --git a/lib/Support/Debug.cpp b/lib/Support/Debug.cpp
index a58716763a..394d9c1109 100644
--- a/lib/Support/Debug.cpp
+++ b/lib/Support/Debug.cpp
@@ -1,10 +1,10 @@
 //===-- Debug.cpp - An easy way to add debug output to your 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 file implements a handle way of adding debugging information to your
diff --git a/lib/Support/FileUtilities.cpp b/lib/Support/FileUtilities.cpp
index 6a65ccae3e..dd296f30a2 100644
--- a/lib/Support/FileUtilities.cpp
+++ b/lib/Support/FileUtilities.cpp
@@ -1,10 +1,10 @@
 //===- Support/FileUtilities.cpp - File System Utilities ------------------===//
-// 
+//
 //                     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 implements a family of utility functions which are useful for doing
@@ -24,7 +24,7 @@ using namespace llvm;
 static bool isNumberChar(char C) {
   switch (C) {
   case '0': case '1': case '2': case '3': case '4':
-  case '5': case '6': case '7': case '8': case '9': 
+  case '5': case '6': case '7': case '8': case '9':
   case '.': case '+': case '-':
   case 'e':
   case 'E': return true;
@@ -47,7 +47,7 @@ static bool CompareNumbers(char *&F1P, char *&F2P, char *F1End, char *F2End,
                            double AbsTolerance, double RelTolerance,
                            std::string *ErrorMsg) {
   char *F1NumEnd, *F2NumEnd;
-  double V1 = 0.0, V2 = 0.0; 
+  double V1 = 0.0, V2 = 0.0;
 
   // If one of the positions is at a space and the other isn't, chomp up 'til
   // the end of the space.
@@ -142,7 +142,7 @@ int llvm::DiffFilesWithTolerance(const sys::Path &FileA,
       return 1;
 
     // Now its safe to mmap the files into memory becasue both files
-    // have a non-zero size. 
+    // have a non-zero size.
     sys::MappedFile F1(FileA);
     sys::MappedFile F2(FileB);
     F1.map();
@@ -171,7 +171,7 @@ int llvm::DiffFilesWithTolerance(const sys::Path &FileA,
     // If the files need padding, do so now.
     PadFileIfNeeded(File1Start, File1End, F1P);
     PadFileIfNeeded(File2Start, File2End, F2P);
-    
+
     bool CompareFailed = false;
     while (1) {
       // Scan for the end of file or next difference.
diff --git a/lib/Support/IsInf.cpp b/lib/Support/IsInf.cpp
index e2943b05b5..070ed4fcc1 100644
--- a/lib/Support/IsInf.cpp
+++ b/lib/Support/IsInf.cpp
@@ -1,10 +1,10 @@
 //===-- IsInf.cpp - Platform-independent wrapper around C99 isinf() -------===//
-// 
+//
 //                     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.
-// 
+//
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Config/config.h"
@@ -26,7 +26,7 @@ static int isinf(double x) { return !finite(x) && x==x; }
 #define isinf(X) (!_finite(X))
 #elif defined(_AIX) && defined(__GNUC__)
 // GCC's fixincludes seems to be removing the isinf() declaration from the
-// system header /usr/include/math.h 
+// system header /usr/include/math.h
 # include <math.h>
 static int isinf(double x) { return !finite(x) && x==x; }
 #else
diff --git a/lib/Support/IsNAN.cpp b/lib/Support/IsNAN.cpp
index f7bb4e3d8e..3300b7b47f 100644
--- a/lib/Support/IsNAN.cpp
+++ b/lib/Support/IsNAN.cpp
@@ -1,13 +1,13 @@
 //===-- IsNAN.cpp ---------------------------------------------------------===//
-// 
+//
 //                     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.
-// 
+//
 //===----------------------------------------------------------------------===//
 //
-// Platform-independent wrapper around C99 isnan(). 
+// Platform-independent wrapper around C99 isnan().
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/lib/Support/PluginLoader.cpp b/lib/Support/PluginLoader.cpp
index 39e3c0afa5..85b2a310e7 100644
--- a/lib/Support/PluginLoader.cpp
+++ b/lib/Support/PluginLoader.cpp
@@ -1,10 +1,10 @@
 //===-- PluginLoader.cpp - Implement -load command line option ------------===//
-// 
+//
 //                     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 implements the -load <plugin> command line option handler.
diff --git a/lib/Support/SlowOperationInformer.cpp b/lib/Support/SlowOperationInformer.cpp
index 43faaadaae..671add188e 100644
--- a/lib/Support/SlowOperationInformer.cpp
+++ b/lib/Support/SlowOperationInformer.cpp
@@ -1,12 +1,12 @@
 //===-- SlowOperationInformer.cpp - Keep the user informed ----------------===//
-// 
+//
 //                     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 implements the SlowOperationInformer class for the LLVM debugger.
 //
 //===----------------------------------------------------------------------===//
diff --git a/lib/Support/Statistic.cpp b/lib/Support/Statistic.cpp
index f4d9c7b9e2..f94f246bae 100644
--- a/lib/Support/Statistic.cpp
+++ b/lib/Support/Statistic.cpp
@@ -1,10 +1,10 @@
 //===-- Statistic.cpp - Easy way to expose stats information --------------===//
-// 
+//
 //                     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 implements the 'Statistic' class, which is designed to be an easy
@@ -78,9 +78,9 @@ void StatisticBase::destroy() const {
     // Figure out how long the biggest Value and Name fields are...
     unsigned MaxNameLen = 0, MaxValLen = 0;
     for (unsigned i = 0, e = AccumStats->size(); i != e; ++i) {
-      MaxValLen = std::max(MaxValLen, 
+      MaxValLen = std::max(MaxValLen,
                            (unsigned)(*AccumStats)[i].Value.length());
-      MaxNameLen = std::max(MaxNameLen, 
+      MaxNameLen = std::max(MaxNameLen,
                             (unsigned)std::strlen((*AccumStats)[i].Name));
     }
 
diff --git a/lib/Support/StringExtras.cpp b/lib/Support/StringExtras.cpp
index e8d423a74d..c4016f3e71 100644
--- a/lib/Support/StringExtras.cpp
+++ b/lib/Support/StringExtras.cpp
@@ -1,10 +1,10 @@
 //===-- StringExtras.cpp - Implement the StringExtras header --------------===//
-// 
+//
 //                     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 implements the StringExtras.h header
@@ -35,9 +35,9 @@ std::string llvm::getToken(std::string &Source, const char *Delimiters) {
 
   // Create the return token.
   std::string Result = std::string(Source.begin()+Start, Source.begin()+End);
-  
+
   // Erase the token that we read in.
   Source.erase(Source.begin(), Source.begin()+End);
-  
+
   return Result;
 }
diff --git a/lib/Support/SystemUtils.cpp b/lib/Support/SystemUtils.cpp
index 764f6be4eb..c77f962553 100644
--- a/lib/Support/SystemUtils.cpp
+++ b/lib/Support/SystemUtils.cpp
@@ -1,10 +1,10 @@
 //===- SystemUtils.cpp - Utilities for low-level system tasks -------------===//
-// 
+//
 //                     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 contains functions used to do a variety of low-level, often
@@ -42,14 +42,14 @@ bool llvm::CheckBytecodeOutputToConsole(std::ostream* stream_to_check,
 #undef FindExecutable   // needed on windows :(
 sys::Path llvm::FindExecutable(const std::string &ExeName,
                                const std::string &ProgramPath) {
-  // First check the directory that the calling program is in.  We can do this  
+  // First check the directory that the calling program is in.  We can do this
   // if ProgramPath contains at least one / character, indicating that it is a
   // relative path to bugpoint itself.
   sys::Pa