From: Chris Lattner <sabre@nondot.org>
Date: Mon, 23 Jul 2001 17:46:59 +0000 (+0000)
Subject: Moved inline/llvm/Tools/* to include/llvm/Support/*
X-Git-Url: http://demsky.eecs.uci.edu/git/?a=commitdiff_plain;h=57dbb3ad63b6a0e77798edb156ef43daa3bfc67e;p=oota-llvm.git

Moved inline/llvm/Tools/* to include/llvm/Support/*


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

diff --git a/include/llvm/Bytecode/Primitives.h b/include/llvm/Bytecode/Primitives.h
index e5f93e718cf..d687fb81859 100644
--- a/include/llvm/Bytecode/Primitives.h
+++ b/include/llvm/Bytecode/Primitives.h
@@ -12,7 +12,7 @@
 #ifndef LLVM_BYTECODE_PRIMITIVES_H
 #define LLVM_BYTECODE_PRIMITIVES_H
 
-#include "llvm/Tools/DataTypes.h"
+#include "llvm/Support/DataTypes.h"
 #include <string>
 #include <vector>
 
diff --git a/include/llvm/CodeGen/MachineInstr.h b/include/llvm/CodeGen/MachineInstr.h
index 72f299f0150..5c6fb62928a 100644
--- a/include/llvm/CodeGen/MachineInstr.h
+++ b/include/llvm/CodeGen/MachineInstr.h
@@ -16,7 +16,7 @@
 #define LLVM_CODEGEN_MACHINEINSTR_H
 
 #include "llvm/CodeGen/InstrForest.h"
-#include "llvm/Tools/DataTypes.h"
+#include "llvm/Support/DataTypes.h"
 #include "llvm/Support/Unique.h"
 #include "llvm/CodeGen/TargetMachine.h"
 
diff --git a/include/llvm/CodeGen/TargetMachine.h b/include/llvm/CodeGen/TargetMachine.h
index 97bcc54e25a..0be7e54bafc 100644
--- a/include/llvm/CodeGen/TargetMachine.h
+++ b/include/llvm/CodeGen/TargetMachine.h
@@ -13,7 +13,7 @@
 #define LLVM_CODEGEN_TARGETMACHINE_H
 
 #include "llvm/Support/Unique.h"
-#include "llvm/Tools/DataTypes.h"
+#include "llvm/Support/DataTypes.h"
 #include <string>
 
 class Type;
diff --git a/include/llvm/ConstPoolVals.h b/include/llvm/ConstPoolVals.h
index a9730c2f8a0..a2a5d8a7ff1 100644
--- a/include/llvm/ConstPoolVals.h
+++ b/include/llvm/ConstPoolVals.h
@@ -10,7 +10,7 @@
 
 #include "llvm/User.h"
 #include "llvm/SymTabValue.h"
-#include "llvm/Tools/DataTypes.h"
+#include "llvm/Support/DataTypes.h"
 #include <vector>
 
 class ArrayType;
diff --git a/include/llvm/Support/DataTypes.h b/include/llvm/Support/DataTypes.h
new file mode 100644
index 00000000000..84b8a65ab12
--- /dev/null
+++ b/include/llvm/Support/DataTypes.h
@@ -0,0 +1,25 @@
+
+// TODO: This file sucks.  Not only does it not work, but this stuff should be
+// autoconfiscated anyways. Major FIXME
+
+
+#ifndef LLVM_SUPPORT_DATATYPES_H
+#define LLVM_SUPPORT_DATATYPES_H
+
+// Should define the following:
+//   LITTLE_ENDIAN if applicable
+//   int64_t 
+//   uint64_t
+
+#ifdef LINUX
+#include <stdint.h>       // Defined by ISO C 99
+#include <endian.h>
+
+#else
+#include <sys/types.h>
+#ifdef _LITTLE_ENDIAN
+#define LITTLE_ENDIAN 1
+#endif
+#endif
+
+#endif
diff --git a/include/llvm/Support/HashExtras.h b/include/llvm/Support/HashExtras.h
new file mode 100644
index 00000000000..ecd572e3d9e
--- /dev/null
+++ b/include/llvm/Support/HashExtras.h
@@ -0,0 +1,22 @@
+//===-- HashExtras.h - Useful functions for STL hash containers --*- C++ -*--=//
+//
+// This file contains some templates that are useful if you are working with the
+// STL Hashed containers.
+//
+// No library is required when using these functinons.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_HASHEXTRAS_H
+#define LLVM_SUPPORT_HASHEXTRAS_H
+
+#include <string>
+#include <hash_map>
+
+template <> struct hash<string> {
+  size_t operator()(string const &str) const {
+    return hash<char const *>()(str.c_str());
+  }
+};
+
+#endif
diff --git a/include/llvm/Support/STLExtras.h b/include/llvm/Support/STLExtras.h
new file mode 100644
index 00000000000..867e1128196
--- /dev/null
+++ b/include/llvm/Support/STLExtras.h
@@ -0,0 +1,210 @@
+//===-- STLExtras.h - Useful functions when working with the STL -*- C++ -*--=//
+//
+// This file contains some templates that are useful if you are working with the
+// STL at all.
+//
+// No library is required when using these functinons.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_STL_EXTRAS_H
+#define LLVM_SUPPORT_STL_EXTRAS_H
+
+#include <functional>
+
+//===----------------------------------------------------------------------===//
+//     Extra additions to <functional>
+//===----------------------------------------------------------------------===//
+
+// bind_obj - Often times you want to apply the member function of an object
+// as a unary functor.  This macro is shorthand that makes it happen less
+// verbosely.
+//
+// Example:
+//  struct Summer { void accumulate(int x); }
+//  vector<int> Numbers;
+//  Summer MyS;
+//  for_each(Numbers.begin(), Numbers.end(),
+//           bind_obj(&MyS, &Summer::accumulate));
+//
+// TODO: When I get lots of extra time, convert this from an evil macro
+//
+#define bind_obj(OBJ, METHOD) std::bind1st(std::mem_fun(METHOD), OBJ)
+
+
+// bitwise_or - This is a simple functor that applys operator| on its two 
+// arguments to get a boolean result.
+//
+template<class Ty>
+struct bitwise_or : public binary_function<Ty, Ty, bool> {
+  bool operator()(const Ty& left, const Ty& right) const {
+    return left | right;
+  }
+};
+
+
+// deleter - Very very very simple method that is used to invoke operator
+// delete on something.  It is used like this: 
+//
+//   for_each(V.begin(), B.end(), deleter<cfg::Interval>);
+//
+template <class T> 
+static inline void deleter(T *Ptr) { 
+  delete Ptr; 
+}
+
+
+
+//===----------------------------------------------------------------------===//
+//     Extra additions to <iterator>
+//===----------------------------------------------------------------------===//
+
+// mapped_iterator - This is a simple iterator adapter that causes a function to
+// be dereferenced whenever operator* is invoked on the iterator.
+//
+// It turns out that this is disturbingly similar to boost::transform_iterator
+//
+#if 1
+template <class RootIt, class UnaryFunc>
+class mapped_iterator {
+  RootIt current;
+public:
+  typedef typename iterator_traits<RootIt>::iterator_category
+          iterator_category;
+  typedef typename iterator_traits<RootIt>::difference_type
+          difference_type;
+  typedef typename UnaryFunc::result_type value_type;
+  typedef typename UnaryFunc::result_type *pointer;
+  typedef void reference;        // Can't modify value returned by fn
+
+  typedef RootIt iterator_type;
+  typedef mapped_iterator<RootIt, UnaryFunc> _Self;
+
+  inline RootIt &getCurrent() const { return current; }
+
+  inline explicit mapped_iterator(const RootIt &I) : current(I) {}
+  inline mapped_iterator(const mapped_iterator &It) : current(It.current) {}
+
+  inline value_type operator*() const {   // All this work to do this 
+    return UnaryFunc()(*current);         // little change
+  }
+
+  _Self& operator++() { ++current; return *this; }
+  _Self& operator--() { --current; return *this; }
+  _Self  operator++(int) { _Self __tmp = *this; ++current; return __tmp; }
+  _Self  operator--(int) { _Self __tmp = *this; --current; return __tmp; }
+  _Self  operator+    (difference_type n) const { return _Self(current + n); }
+  _Self& operator+=   (difference_type n) { current += n; return *this; }
+  _Self  operator-    (difference_type n) const { return _Self(current - n); }
+  _Self& operator-=   (difference_type n) { current -= n; return *this; }
+  reference operator[](difference_type n) const { return *(*this + n); }  
+
+  inline bool operator==(const _Self &X) const { return current == X.current; }
+  inline bool operator< (const _Self &X) const { return current <  X.current; }
+
+  inline difference_type operator-(const _Self &X) const {
+    return current - X.current;
+  }
+};
+
+template <class _Iterator, class Func>
+inline mapped_iterator<_Iterator, Func> 
+operator+(typename mapped_iterator<_Iterator, Func>::difference_type N,
+          const mapped_iterator<_Iterator, Func>& X) {
+  return mapped_iterator<_Iterator, Func>(X.getCurrent() - N);
+}
+
+#else
+
+// This fails to work, because some iterators are not classes, for example
+// vector iterators are commonly value_type **'s
+template <class RootIt, class UnaryFunc>
+class mapped_iterator : public RootIt {
+public:
+  typedef typename UnaryFunc::result_type value_type;
+  typedef typename UnaryFunc::result_type *pointer;
+  typedef void reference;        // Can't modify value returned by fn
+
+  typedef mapped_iterator<RootIt, UnaryFunc> _Self;
+  typedef RootIt super;
+  inline explicit mapped_iterator(const RootIt &I) : super(I) {}
+  inline mapped_iterator(const super &It) : super(It) {}
+
+  inline value_type operator*() const {     // All this work to do 
+    return UnaryFunc(super::operator*());   // this little thing
+  }
+};
+#endif
+
+// map_iterator - Provide a convenient way to create mapped_iterators, just like
+// make_pair is useful for creating pairs...
+//
+template <class ItTy, class FuncTy>
+inline mapped_iterator<ItTy, FuncTy> map_iterator(const ItTy &I, FuncTy F) {
+  return mapped_iterator<ItTy, FuncTy>(I);
+}
+
+
+//===----------------------------------------------------------------------===//
+//     Extra additions to <algorithm>
+//===----------------------------------------------------------------------===//
+
+// apply_until - Apply a functor to a sequence continually, unless the
+// functor returns true.  Return true if the functor returned true, return false
+// if the functor never returned true.
+//
+template <class InputIt, class Function>
+bool apply_until(InputIt First, InputIt Last, Function Func) {
+  for ( ; First != Last; ++First)
+    if (Func(*First)) return true;
+  return false;
+}
+
+
+// reduce - Reduce a sequence values into a single value, given an initial
+// value and an operator.
+//
+template <class InputIt, class Function, class ValueType>
+ValueType reduce(InputIt First, InputIt Last, Function Func, ValueType Value) {
+  for ( ; First != Last; ++First)
+    Value = Func(*First, Value);
+  return Value;
+}
+
+#if 1   // This is likely to be more efficient
+
+// reduce_apply - Reduce the result of applying a function to each value in a
+// sequence, given an initial value, an operator, a function, and a sequence.
+//
+template <class InputIt, class Function, class ValueType, class TransFunc>
+inline ValueType reduce_apply(InputIt First, InputIt Last, Function Func, 
+			      ValueType Value, TransFunc XForm) {
+  for ( ; First != Last; ++First)
+    Value = Func(XForm(*First), Value);
+  return Value;
+}
+
+#else  // This is arguably more elegant
+
+// reduce_apply - Reduce the result of applying a function to each value in a
+// sequence, given an initial value, an operator, a function, and a sequence.
+//
+template <class InputIt, class Function, class ValueType, class TransFunc>
+inline ValueType reduce_apply2(InputIt First, InputIt Last, Function Func, 
+			       ValueType Value, TransFunc XForm) {
+  return reduce(map_iterator(First, XForm), map_iterator(Last, XForm),
+		Func, Value);
+}
+#endif
+
+
+// reduce_apply_bool - Reduce the result of applying a (bool returning) function
+// to each value in a sequence.  All of the bools returned by the mapped
+// function are bitwise or'd together, and the result is returned.
+//
+template <class InputIt, class Function>
+inline bool reduce_apply_bool(InputIt First, InputIt Last, Function Func) {
+  return reduce_apply(First, Last, bitwise_or<bool>(), false, Func);
+}
+
+#endif
diff --git a/include/llvm/Support/StringExtras.h b/include/llvm/Support/StringExtras.h
new file mode 100644
index 00000000000..585a42ca4c8
--- /dev/null
+++ b/include/llvm/Support/StringExtras.h
@@ -0,0 +1,70 @@
+//===-- StringExtras.h - Useful string functions -----------------*- C++ -*--=//
+//
+// This file contains some functions that are useful when dealing with strings.
+// No library is required when using these functinons.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TOOLS_STRING_EXTRAS_H
+#define LLVM_TOOLS_STRING_EXTRAS_H
+
+#include <string>
+#include <stdio.h>
+#include "llvm/Support/DataTypes.h"
+
+static inline string utostr(uint64_t X, bool isNeg = false) {
+  char Buffer[40];
+  char *BufPtr = Buffer+39;
+
+  *BufPtr = 0;                  // Null terminate buffer...
+  if (X == 0) *--BufPtr = '0';  // Handle special case...
+
+  while (X) {
+    *--BufPtr = '0' + (X % 10);
+    X /= 10;
+  }
+
+  if (isNeg) *--BufPtr = '-';   // Add negative sign...
+
+  return string(BufPtr);
+}
+
+static inline string itostr(int64_t X) {
+  if (X < 0) 
+    return utostr((uint64_t)-X, true);
+  else
+    return utostr((uint64_t)X);
+}
+
+
+static inline string utostr(unsigned X, bool isNeg = false) {
+  char Buffer[20];
+  char *BufPtr = Buffer+19;
+
+  *BufPtr = 0;                  // Null terminate buffer...
+  if (X == 0) *--BufPtr = '0';  // Handle special case...
+
+  while (X) {
+    *--BufPtr = '0' + (X % 10);
+    X /= 10;
+  }
+
+  if (isNeg) *--BufPtr = '-';   // Add negative sign...
+
+  return string(BufPtr);
+}
+
+static inline string itostr(int X) {
+  if (X < 0) 
+    return utostr((unsigned)-X, true);
+  else
+    return utostr((unsigned)X);
+}
+
+static inline string ftostr(double V) {
+  char Buffer[200];
+  snprintf(Buffer, 200, "%f", V);
+  return Buffer;
+}
+
+#endif
diff --git a/include/llvm/Tools/CommandLine.h b/include/llvm/Tools/CommandLine.h
deleted file mode 100644
index 35d96d49229..00000000000
--- a/include/llvm/Tools/CommandLine.h
+++ /dev/null
@@ -1,284 +0,0 @@
-//===-- llvm/Tools/CommandLine.h - Command line parser for tools -*- C++ -*--=//
-//
-// This class implements a command line argument processor that is useful when
-// creating a tool.  It provides a simple, minimalistic interface that is easily
-// extensible and supports nonlocal (library) command line options.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_TOOLS_COMMANDLINE_H
-#define LLVM_TOOLS_COMMANDLINE_H
-
-#include <string>
-#include <vector>
-#include <utility>
-#include <stdarg.h>
-
-namespace cl {   // Short namespace to make usage concise
-
-//===----------------------------------------------------------------------===//
-// ParseCommandLineOptions - Minimalistic command line option processing entry
-//
-void cl::ParseCommandLineOptions(int &argc, char **argv,
-				 const char *Overview = 0);
-
-
-//===----------------------------------------------------------------------===//
-// Global flags permitted to be passed to command line arguments
-
-enum FlagsOptions {
-  NoFlags         = 0x00,      // Marker to make explicit that we have no flags
-
-  // Flags for the number of occurances allowed...
-  Optional        = 0x00,      // Zero or One occurance
-  ZeroOrMore      = 0x01,      // Zero or more occurances allowed
-  Required        = 0x02,      // One occurance required
-  OneOrMore       = 0x03,      // One or more occurances required
-  OccurancesMask  = 0x07,
-
-  // Number of arguments to a value expected...
-  //Optional      = 0x00,      // The value can oppear... or not
-  ValueRequired   = 0x08,      // The value is required to appear!
-  ValueDisallowed = 0x10,      // A value may not be specified (for flags)
-  ValueMask       = 0x18,
-
-  // Control whether -help shows the command line option...
-  Hidden          = 0x20,      // -help doesn't -help-hidden does
-  ReallyHidden    = 0x60,      // Neither -help nor -help-hidden show this arg
-  HiddenMask      = 0x60,
-};
-
-
-//===----------------------------------------------------------------------===//
-// Option Base class
-//
-class Option {
-  friend void cl::ParseCommandLineOptions(int &, char **, const char *Overview);
-
-  // handleOccurances - Overriden by subclasses to handle the value passed into
-  // an argument.  Should return true if there was an error processing the
-  // argument and the program should exit.
-  //
-  virtual bool handleOccurance(const char *ArgName, const string &Arg) = 0;
-
-  int NumOccurances;          // The number of times specified
-public:
-  const char * const ArgStr;  // The argument string itself (ex: "help", "o")
-  const char * const HelpStr; // The descriptive text message for --help
-  const int Flags;            // Flags for the argument
-
-protected:
-  Option(const char *ArgStr, const char *Message, int Flags);
-  Option(int flags) : ArgStr(""), HelpStr(""), Flags(flags) {}
-
-  // Prints option name followed by message.  Always returns true.
-  bool error(string Message, const char *ArgName = 0);
-
-  // addOccurance - Wrapper around handleOccurance that enforces Flags
-  //
-  bool addOccurance(const char *ArgName, const string &Value);
-
-public:
-  // Return the width of the option tag for printing...
-  virtual unsigned getOptionWidth() const;
-
-  // printOptionInfo - Print out information about this option.  The 
-  // to-be-maintained width is specified.
-  //
-  virtual void printOptionInfo(unsigned GlobalWidth) const;
-
-public:
-  inline int getNumOccurances() const { return NumOccurances; }
-  virtual ~Option() {}
-};
-
-
-//===----------------------------------------------------------------------===//
-// Boolean/flag command line option
-//
-class Flag : public Option {
-  bool Value;
-  virtual bool handleOccurance(const char *ArgName, const string &Arg);
-public:
-  inline Flag(const char *ArgStr, const char *Message, int Flags = 0, 
-	      bool DefaultVal = 0) : Option(ArgStr, Message, Flags), 
-				     Value(DefaultVal) {}
-  operator bool() const { return Value; }
-  inline bool getValue() const { return Value; }
-  inline void setValue(bool Val) { Value = Val; }
-};
-
-
-
-//===----------------------------------------------------------------------===//
-// Integer valued command line option
-//
-class Int : public Option {
-  int Value;
-  virtual bool handleOccurance(const char *ArgName, const string &Arg);
-public:
-  inline Int(const char *ArgStr, const char *Help, int Flags = 0,
-	     int DefaultVal = 0) : Option(ArgStr, Help, Flags | ValueRequired),
-				   Value(DefaultVal) {}
-  inline operator int() const { return Value; }
-  inline int getValue() const { return Value; }
-  inline void setValue(int Val) { Value = Val; }
-};
-
-
-//===----------------------------------------------------------------------===//
-// String valued command line option
-//
-class String : public Option {
-  string Value;
-  virtual bool handleOccurance(const char *ArgName, const string &Arg);
-public:
-  inline String(const char *ArgStr, const char *Help, int Flags = 0, 
-		const char *DefaultVal = "") 
-    : Option(ArgStr, Help, Flags | ValueRequired), Value(DefaultVal) {}
-
-  inline const string &getValue() const { return Value; }
-  inline void setValue(const string &Val) { Value = Val; }
-};
-
-
-//===----------------------------------------------------------------------===//
-// Enum valued command line option
-//
-#define clEnumVal(ENUMVAL, DESC) #ENUMVAL, ENUMVAL, DESC
-#define clEnumValN(ENUMVAL, FLAGNAME, DESC) FLAGNAME, ENUMVAL, DESC
-
-// EnumBase - Base class for all enum/varargs related argument types...
-class EnumBase : public Option {
-protected:
-  // Use a vector instead of a map, because the lists should be short,
-  // the overhead is less, and most importantly, it keeps them in the order
-  // inserted so we can print our option out nicely.
-  vector<pair<const char *, pair<int, const char *> > > ValueMap;
-
-  inline EnumBase(const char *ArgStr, const char *Help, int Flags)
-    : Option(ArgStr, Help, Flags) {}
-  inline EnumBase(int Flags) : Option(Flags) {}
-
-  // processValues - Incorporate the specifed varargs arglist into the 
-  // ValueMap.
-  //
-  void processValues(va_list Vals);
-
-  // registerArgs - notify the system about these new arguments
-  void registerArgs();
-
-public:
-  // Turn an enum into the arg name that activates it
-  const char *getArgName(int ID) const;
-  const char *getArgDescription(int ID) const;
-};
-
-class EnumValueBase : public EnumBase {
-protected:
-  int Value;
-  inline EnumValueBase(const char *ArgStr, const char *Help, int Flags)
-    : EnumBase(ArgStr, Help, Flags) {}
-  inline EnumValueBase(int Flags) : EnumBase(Flags) {}
-
-  // handleOccurance - Set Value to the enum value specified by Arg
-  virtual bool handleOccurance(const char *ArgName, const string &Arg);
-
-  // Return the width of the option tag for printing...
-  virtual unsigned getOptionWidth() const;
-
-  // printOptionInfo - Print out information about this option.  The 
-  // to-be-maintained width is specified.
-  //
-  virtual void printOptionInfo(unsigned GlobalWidth) const;
-};
-
-template <class E>  // The enum we are representing
-class Enum : public EnumValueBase {
-public:
-  inline Enum(const char *ArgStr, int Flags, const char *Help, ...)
-    : EnumValueBase(ArgStr, Help, Flags | ValueRequired) {
-    va_list Values;
-    va_start(Values, Help);
-    processValues(Values);
-    va_end(Values);
-    Value = ValueMap.front().second.first; // Grab default value
-  }
-
-  inline E getValue() const { return (E)Value; }
-  inline void setValue(E Val) { Value = (E)Val; }
-};
-
-
-//===----------------------------------------------------------------------===//
-// Enum flags command line option
-//
-class EnumFlagsBase : public EnumValueBase {
-protected:
-  virtual bool handleOccurance(const char *ArgName, const string &Arg);
-  inline EnumFlagsBase(int Flags) : EnumValueBase(Flags | ValueDisallowed) {}
-
-  // Return the width of the option tag for printing...
-  virtual unsigned getOptionWidth() const;
-
-  // printOptionInfo - Print out information about this option.  The 
-  // to-be-maintained width is specified.
-  //
-  virtual void printOptionInfo(unsigned GlobalWidth) const;
-};
-
-template <class E>  // The enum we are representing
-class EnumFlags : public EnumFlagsBase {
-public:
-  inline EnumFlags(int Flags, ...) : EnumFlagsBase(Flags) {
-    va_list Values;
-    va_start(Values, Flags);
-    processValues(Values);
-    va_end(Values);
-    registerArgs();
-    Value = ValueMap.front().second.first; // Grab default value
-  }
-  inline E getValue() const { return (E)Value; }
-  inline void setValue(E Val) { Value = (E)Val; }
-};
-
-
-//===----------------------------------------------------------------------===//
-// Enum list command line option
-//
-class EnumListBase : public EnumBase {
-protected:
-  vector<int> Values;  // The options specified so far.
-
-  inline EnumListBase(int Flags) 
-    : EnumBase(Flags | ValueDisallowed | ZeroOrMore) {}
-  virtual bool handleOccurance(const char *ArgName, const string &Arg);
-
-  // Return the width of the option tag for printing...
-  virtual unsigned getOptionWidth() const;
-
-  // printOptionInfo - Print out information about this option.  The 
-  // to-be-maintained width is specified.
-  //
-  virtual void printOptionInfo(unsigned GlobalWidth) const;
-public:
-  inline unsigned size() { return Values.size(); }
-};
-
-template <class E>  // The enum we are representing
-class EnumList : public EnumListBase {
-public:
-  inline EnumList(int Flags, ...) : EnumListBase(Flags) {
-    va_list Values;
-    va_start(Values, Flags);
-    processValues(Values);
-    va_end(Values);
-    registerArgs();
-  }
-  inline E getValue(unsigned i) const { return (E)Values[i]; }
-  inline E operator[](unsigned i) const { return (E)Values[i]; }
-};
-
-} // End namespace cl
-
-#endif
diff --git a/include/llvm/Tools/DataTypes.h b/include/llvm/Tools/DataTypes.h
deleted file mode 100644
index ada16c24da3..00000000000
--- a/include/llvm/Tools/DataTypes.h
+++ /dev/null
@@ -1,26 +0,0 @@
-
-// TODO: This file sucks.  Not only does it not work, but this stuff should be
-// autoconfiscated anyways. Major FIXME
-
-
-#ifndef LLVM_TOOLS_DATATYPES_H
-#define LLVM_TOOLS_DATATYPES_H
-
-// Should define the following:
-//   LITTLE_ENDIAN if applicable
-//   int64_t 
-//   uint64_t
-
-#ifdef LINUX
-#include <stdint.h>       // Defined by ISO C 99
-#include <endian.h>
-
-#else
-#include <sys/types.h>
-#ifdef _LITTLE_ENDIAN
-#define LITTLE_ENDIAN 1
-#endif
-#endif
-
-
-#endif
diff --git a/include/llvm/Tools/STLExtras.h b/include/llvm/Tools/STLExtras.h
deleted file mode 100644
index 933db3a8ff4..00000000000
--- a/include/llvm/Tools/STLExtras.h
+++ /dev/null
@@ -1,210 +0,0 @@
-//===-- STLExtras.h - Useful functions when working with the STL --*- C++ -*--=//
-//
-// This file contains some templates that are useful if you are working with the
-// STL at all.
-//
-// No library is required when using these functinons.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_TOOLS_STL_EXTRAS_H
-#define LLVM_TOOLS_STL_EXTRAS_H
-
-#include <functional>
-
-//===----------------------------------------------------------------------===//
-//     Extra additions to <functional>
-//===----------------------------------------------------------------------===//
-
-// bind_obj - Often times you want to apply the member function of an object
-// as a unary functor.  This macro is shorthand that makes it happen less
-// verbosely.
-//
-// Example:
-//  struct Summer { void accumulate(int x); }
-//  vector<int> Numbers;
-//  Summer MyS;
-//  for_each(Numbers.begin(), Numbers.end(),
-//           bind_obj(&MyS, &Summer::accumulate));
-//
-// TODO: When I get lots of extra time, convert this from an evil macro
-//
-#define bind_obj(OBJ, METHOD) std::bind1st(std::mem_fun(METHOD), OBJ)
-
-
-// bitwise_or - This is a simple functor that applys operator| on its two 
-// arguments to get a boolean result.
-//
-template<class Ty>
-struct bitwise_or : public binary_function<Ty, Ty, bool> {
-  bool operator()(const Ty& left, const Ty& right) const {
-    return left | right;
-  }
-};
-
-
-// deleter - Very very very simple method that is used to invoke operator
-// delete on something.  It is used like this: 
-//
-//   for_each(V.begin(), B.end(), deleter<cfg::Interval>);
-//
-template <class T> 
-static inline void deleter(T *Ptr) { 
-  delete Ptr; 
-}
-
-
-
-//===----------------------------------------------------------------------===//
-//     Extra additions to <iterator>
-//===----------------------------------------------------------------------===//
-
-// mapped_iterator - This is a simple iterator adapter that causes a function to
-// be dereferenced whenever operator* is invoked on the iterator.
-//
-// It turns out that this is disturbingly similar to boost::transform_iterator
-//
-#if 1
-template <class RootIt, class UnaryFunc>
-class mapped_iterator {
-  RootIt current;
-public:
-  typedef typename iterator_traits<RootIt>::iterator_category
-          iterator_category;
-  typedef typename iterator_traits<RootIt>::difference_type
-          difference_type;
-  typedef typename UnaryFunc::result_type value_type;
-  typedef typename UnaryFunc::result_type *pointer;
-  typedef void reference;        // Can't modify value returned by fn
-
-  typedef RootIt iterator_type;
-  typedef mapped_iterator<RootIt, UnaryFunc> _Self;
-
-  inline RootIt &getCurrent() const { return current; }
-
-  inline explicit mapped_iterator(const RootIt &I) : current(I) {}
-  inline mapped_iterator(const mapped_iterator &It) : current(It.current) {}
-
-  inline value_type operator*() const {   // All this work to do this 
-    return UnaryFunc()(*current);         // little change
-  }
-
-  _Self& operator++() { ++current; return *this; }
-  _Self& operator--() { --current; return *this; }
-  _Self  operator++(int) { _Self __tmp = *this; ++current; return __tmp; }
-  _Self  operator--(int) { _Self __tmp = *this; --current; return __tmp; }
-  _Self  operator+    (difference_type n) const { return _Self(current + n); }
-  _Self& operator+=   (difference_type n) { current += n; return *this; }
-  _Self  operator-    (difference_type n) const { return _Self(current - n); }
-  _Self& operator-=   (difference_type n) { current -= n; return *this; }
-  reference operator[](difference_type n) const { return *(*this + n); }  
-
-  inline bool operator==(const _Self &X) const { return current == X.current; }
-  inline bool operator< (const _Self &X) const { return current <  X.current; }
-
-  inline difference_type operator-(const _Self &X) const {
-    return current - X.current;
-  }
-};
-
-template <class _Iterator, class Func>
-inline mapped_iterator<_Iterator, Func> 
-operator+(typename mapped_iterator<_Iterator, Func>::difference_type N,
-          const mapped_iterator<_Iterator, Func>& X) {
-  return mapped_iterator<_Iterator, Func>(X.getCurrent() - N);
-}
-
-#else
-
-// This fails to work, because some iterators are not classes, for example
-// vector iterators are commonly value_type **'s
-template <class RootIt, class UnaryFunc>
-class mapped_iterator : public RootIt {
-public:
-  typedef typename UnaryFunc::result_type value_type;
-  typedef typename UnaryFunc::result_type *pointer;
-  typedef void reference;        // Can't modify value returned by fn
-
-  typedef mapped_iterator<RootIt, UnaryFunc> _Self;
-  typedef RootIt super;
-  inline explicit mapped_iterator(const RootIt &I) : super(I) {}
-  inline mapped_iterator(const super &It) : super(It) {}
-
-  inline value_type operator*() const {     // All this work to do 
-    return UnaryFunc(super::operator*());   // this little thing
-  }
-};
-#endif
-
-// map_iterator - Provide a convenient way to create mapped_iterators, just like
-// make_pair is useful for creating pairs...
-//
-template <class ItTy, class FuncTy>
-inline mapped_iterator<ItTy, FuncTy> map_iterator(const ItTy &I, FuncTy F) {
-  return mapped_iterator<ItTy, FuncTy>(I);
-}
-
-
-//===----------------------------------------------------------------------===//
-//     Extra additions to <algorithm>
-//===----------------------------------------------------------------------===//
-
-// apply_until - Apply a functor to a sequence continually, unless the
-// functor returns true.  Return true if the functor returned true, return false
-// if the functor never returned true.
-//
-template <class InputIt, class Function>
-bool apply_until(InputIt First, InputIt Last, Function Func) {
-  for ( ; First != Last; ++First)
-    if (Func(*First)) return true;
-  return false;
-}
-
-
-// reduce - Reduce a sequence values into a single value, given an initial
-// value and an operator.
-//
-template <class InputIt, class Function, class ValueType>
-ValueType reduce(InputIt First, InputIt Last, Function Func, ValueType Value) {
-  for ( ; First != Last; ++First)
-    Value = Func(*First, Value);
-  return Value;
-}
-
-#if 1   // This is likely to be more efficient
-
-// reduce_apply - Reduce the result of applying a function to each value in a
-// sequence, given an initial value, an operator, a function, and a sequence.
-//
-template <class InputIt, class Function, class ValueType, class TransFunc>
-inline ValueType reduce_apply(InputIt First, InputIt Last, Function Func, 
-			      ValueType Value, TransFunc XForm) {
-  for ( ; First != Last; ++First)
-    Value = Func(XForm(*First), Value);
-  return Value;
-}
-
-#else  // This is arguably more elegant
-
-// reduce_apply - Reduce the result of applying a function to each value in a
-// sequence, given an initial value, an operator, a function, and a sequence.
-//
-template <class InputIt, class Function, class ValueType, class TransFunc>
-inline ValueType reduce_apply2(InputIt First, InputIt Last, Function Func, 
-			       ValueType Value, TransFunc XForm) {
-  return reduce(map_iterator(First, XForm), map_iterator(Last, XForm),
-		Func, Value);
-}
-#endif
-
-
-// reduce_apply_bool - Reduce the result of applying a (bool returning) function
-// to each value in a sequence.  All of the bools returned by the mapped
-// function are bitwise or'd together, and the result is returned.
-//
-template <class InputIt, class Function>
-inline bool reduce_apply_bool(InputIt First, InputIt Last, Function Func) {
-  return reduce_apply(First, Last, bitwise_or<bool>(), false, Func);
-}
-
-#endif
diff --git a/include/llvm/Tools/StringExtras.h b/include/llvm/Tools/StringExtras.h
deleted file mode 100644
index 819da2f0546..00000000000
--- a/include/llvm/Tools/StringExtras.h
+++ /dev/null
@@ -1,70 +0,0 @@
-//===-- StringExtras.h - Useful string functions -----------------*- C++ -*--=//
-//
-// This file contains some functions that are useful when dealing with strings.
-// No library is required when using these functinons.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_TOOLS_STRING_EXTRAS_H
-#define LLVM_TOOLS_STRING_EXTRAS_H
-
-#include <string>
-#include <stdio.h>
-#include "llvm/Tools/DataTypes.h"
-
-static inline string utostr(uint64_t X, bool isNeg = false) {
-  char Buffer[40];
-  char *BufPtr = Buffer+39;
-
-  *BufPtr = 0;                  // Null terminate buffer...
-  if (X == 0) *--BufPtr = '0';  // Handle special case...
-
-  while (X) {
-    *--BufPtr = '0' + (X % 10);
-    X /= 10;
-  }
-
-  if (isNeg) *--BufPtr = '-';   // Add negative sign...
-
-  return string(BufPtr);
-}
-
-static inline string itostr(int64_t X) {
-  if (X < 0) 
-    return utostr((uint64_t)-X, true);
-  else
-    return utostr((uint64_t)X);
-}
-
-
-static inline string utostr(unsigned X, bool isNeg = false) {
-  char Buffer[20];
-  char *BufPtr = Buffer+19;
-
-  *BufPtr = 0;                  // Null terminate buffer...
-  if (X == 0) *--BufPtr = '0';  // Handle special case...
-
-  while (X) {
-    *--BufPtr = '0' + (X % 10);
-    X /= 10;
-  }
-
-  if (isNeg) *--BufPtr = '-';   // Add negative sign...
-
-  return string(BufPtr);
-}
-
-static inline string itostr(int X) {
-  if (X < 0) 
-    return utostr((unsigned)-X, true);
-  else
-    return utostr((unsigned)X);
-}
-
-static inline string ftostr(double V) {
-  char Buffer[200];
-  snprintf(Buffer, 200, "%f", V);
-  return Buffer;
-}
-
-#endif
diff --git a/lib/Analysis/IntervalPartition.cpp b/lib/Analysis/IntervalPartition.cpp
index bbdcbef65f4..4bff950a82e 100644
--- a/lib/Analysis/IntervalPartition.cpp
+++ b/lib/Analysis/IntervalPartition.cpp
@@ -6,7 +6,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Analysis/IntervalIterator.h"
-#include "llvm/Tools/STLExtras.h"
+#include "llvm/Support/STLExtras.h"
 
 using namespace cfg;
 
diff --git a/lib/Analysis/LoopDepth.cpp b/lib/Analysis/LoopDepth.cpp
index ac73fda26f8..7518606c898 100644
--- a/lib/Analysis/LoopDepth.cpp
+++ b/lib/Analysis/LoopDepth.cpp
@@ -7,7 +7,7 @@
 
 #include "llvm/Analysis/LoopDepth.h"
 #include "llvm/Analysis/IntervalPartition.h"
-#include "llvm/Tools/STLExtras.h"
+#include "llvm/Support/STLExtras.h"
 #include <algorithm>
 
 inline void LoopDepthCalculator::AddBB(const BasicBlock *BB) {
diff --git a/lib/Analysis/ModuleAnalyzer.cpp b/lib/Analysis/ModuleAnalyzer.cpp
index 7f509855d94..45637c9c0a9 100644
--- a/lib/Analysis/ModuleAnalyzer.cpp
+++ b/lib/Analysis/ModuleAnalyzer.cpp
@@ -13,7 +13,7 @@
 #include "llvm/BasicBlock.h"
 #include "llvm/DerivedTypes.h"
 #include "llvm/ConstPoolVals.h"
-#include "llvm/Tools/STLExtras.h"
+#include "llvm/Support/STLExtras.h"
 #include <map>
 
 // processModule - Driver function to call all of my subclasses virtual methods.
diff --git a/lib/Analysis/PostDominators.cpp b/lib/Analysis/PostDominators.cpp
index 14ed6c8b81e..707b5334a5d 100644
--- a/lib/Analysis/PostDominators.cpp
+++ b/lib/Analysis/PostDominators.cpp
@@ -7,7 +7,7 @@
 #include "llvm/Analysis/Dominators.h"
 #include "llvm/Analysis/SimplifyCFG.h"   // To get cfg::UnifyAllExitNodes
 #include "llvm/CFG.h"
-#include "llvm/Tools/STLExtras.h"
+#include "llvm/Support/STLExtras.h"
 #include <algorithm>
 
 //===----------------------------------------------------------------------===//
diff --git a/lib/AsmParser/ParserInternals.h b/lib/AsmParser/ParserInternals.h
index 5d97bc605d5..ae446026149 100644
--- a/lib/AsmParser/ParserInternals.h
+++ b/lib/AsmParser/ParserInternals.h
@@ -18,7 +18,7 @@
 #include "llvm/Method.h"
 #include "llvm/Type.h"
 #include "llvm/Assembly/Parser.h"
-#include "llvm/Tools/StringExtras.h"
+#include "llvm/Support/StringExtras.h"
 
 class Module;
 
diff --git a/lib/Bytecode/Writer/InstructionWriter.cpp b/lib/Bytecode/Writer/InstructionWriter.cpp
index 73969e65df7..a9b5e8d3041 100644
--- a/lib/Bytecode/Writer/InstructionWriter.cpp
+++ b/lib/Bytecode/Writer/InstructionWriter.cpp
@@ -15,7 +15,6 @@
 #include "llvm/BasicBlock.h"
 #include "llvm/Instruction.h"
 #include "llvm/DerivedTypes.h"
-#include "llvm/Tools/DataTypes.h"
 #include <algorithm>
 
 typedef unsigned char uchar;
diff --git a/lib/Bytecode/Writer/WriterInternals.h b/lib/Bytecode/Writer/WriterInternals.h
index be9ccf96672..41f0b4de753 100644
--- a/lib/Bytecode/Writer/WriterInternals.h
+++ b/lib/Bytecode/Writer/WriterInternals.h
@@ -16,7 +16,7 @@
 #include "llvm/Bytecode/Format.h"
 #include "llvm/Bytecode/Primitives.h"
 #include "llvm/Analysis/SlotCalculator.h"
-#include "llvm/Tools/DataTypes.h"
+#include "llvm/Support/DataTypes.h"
 #include "llvm/Instruction.h"
 
 class BytecodeWriter : public ModuleAnalyzer {
diff --git a/lib/CodeGen/InstrSelection/InstrSelection.cpp b/lib/CodeGen/InstrSelection/InstrSelection.cpp
index 0526dda40e8..bfeec4412e6 100644
--- a/lib/CodeGen/InstrSelection/InstrSelection.cpp
+++ b/lib/CodeGen/InstrSelection/InstrSelection.cpp
@@ -17,7 +17,7 @@
 #include "llvm/iMemory.h"
 #include "llvm/Instruction.h"
 #include "llvm/CodeGen/MachineInstr.h"
-#include "llvm/Tools/CommandLine.h"
+#include "llvm/Support/CommandLine.h"
 
 enum DebugLev {
   NoDebugInfo,
diff --git a/lib/Support/CommandLine.cpp b/lib/Support/CommandLine.cpp
index 013c22fe922..7c3f29305e9 100644
--- a/lib/Support/CommandLine.cpp
+++ b/lib/Support/CommandLine.cpp
@@ -6,8 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/Tools/CommandLine.h"
-#include "llvm/Tools/STLExtras.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/STLExtras.h"
 #include <vector>
 #include <algorithm>
 #include <map>
diff --git a/lib/Target/SparcV9/InstrSelection/InstrSelection.cpp b/lib/Target/SparcV9/InstrSelection/InstrSelection.cpp
index 0526dda40e8..bfeec4412e6 100644
--- a/lib/Target/SparcV9/InstrSelection/InstrSelection.cpp
+++ b/lib/Target/SparcV9/InstrSelection/InstrSelection.cpp
@@ -17,7 +17,7 @@
 #include "llvm/iMemory.h"
 #include "llvm/Instruction.h"
 #include "llvm/CodeGen/MachineInstr.h"
-#include "llvm/Tools/CommandLine.h"
+#include "llvm/Support/CommandLine.h"
 
 enum DebugLev {
   NoDebugInfo,
diff --git a/lib/Transforms/Scalar/ADCE.cpp b/lib/Transforms/Scalar/ADCE.cpp
index cb4de3c8ef9..f9b9ee36400 100644
--- a/lib/Transforms/Scalar/ADCE.cpp
+++ b/lib/Transforms/Scalar/ADCE.cpp
@@ -10,7 +10,7 @@
 #include "llvm/Instruction.h"
 #include "llvm/Type.h"
 #include "llvm/Analysis/Dominators.h"
-#include "llvm/Tools/STLExtras.h"
+#include "llvm/Support/STLExtras.h"
 #include "llvm/Analysis/Writer.h"
 #include <set>
 #include <algorithm>
diff --git a/lib/Transforms/Scalar/DCE.cpp b/lib/Transforms/Scalar/DCE.cpp
index 56a6d1e822d..515fd00f81a 100644
--- a/lib/Transforms/Scalar/DCE.cpp
+++ b/lib/Transforms/Scalar/DCE.cpp
@@ -23,7 +23,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Optimizations/DCE.h"
-#include "llvm/Tools/STLExtras.h"
+#include "llvm/Support/STLExtras.h"
 #include "llvm/Module.h"
 #include "llvm/Method.h"
 #include "llvm/BasicBlock.h"
diff --git a/lib/Transforms/Scalar/InductionVars.cpp b/lib/Transforms/Scalar/InductionVars.cpp
index 4f88685fc1f..42397e0a3a1 100644
--- a/lib/Transforms/Scalar/InductionVars.cpp
+++ b/lib/Transforms/Scalar/InductionVars.cpp
@@ -23,7 +23,7 @@
 #include "llvm/ConstPoolVals.h"
 #include "llvm/Analysis/IntervalPartition.h"
 #include "llvm/Assembly/Writer.h"
-#include "llvm/Tools/STLExtras.h"
+#include "llvm/Support/STLExtras.h"
 #include "llvm/SymbolTable.h"
 #include "llvm/iOther.h"
 #include "llvm/CFG.h"
diff --git a/lib/Transforms/Scalar/SCCP.cpp b/lib/Transforms/Scalar/SCCP.cpp
index a28155260ee..f1f8d77d7d3 100644
--- a/lib/Transforms/Scalar/SCCP.cpp
+++ b/lib/Transforms/Scalar/SCCP.cpp
@@ -25,7 +25,7 @@
 #include "llvm/iOther.h"
 #include "llvm/iMemory.h"
 #include "llvm/iTerminators.h"
-#include "llvm/Tools/STLExtras.h"
+#include "llvm/Support/STLExtras.h"
 #include "llvm/Assembly/Writer.h"
 #include <algorithm>
 #include <map>
diff --git a/lib/VMCore/ConstantPool.cpp b/lib/VMCore/ConstantPool.cpp
index 092ca61ff1d..caa79bb53ed 100644
--- a/lib/VMCore/ConstantPool.cpp
+++ b/lib/VMCore/ConstantPool.cpp
@@ -7,7 +7,7 @@
 #define __STDC_LIMIT_MACROS           // Get defs for INT64_MAX and friends...
 #include "llvm/ConstPoolVals.h"
 #include "llvm/ConstantPool.h"
-#include "llvm/Tools/StringExtras.h"  // itostr
+#include "llvm/Support/StringExtras.h"  // itostr
 #include "llvm/DerivedTypes.h"
 #include "llvm/SymbolTable.h"
 #include <algorithm>
diff --git a/lib/VMCore/Dominators.cpp b/lib/VMCore/Dominators.cpp
index 14ed6c8b81e..707b5334a5d 100644
--- a/lib/VMCore/Dominators.cpp
+++ b/lib/VMCore/Dominators.cpp
@@ -7,7 +7,7 @@
 #include "llvm/Analysis/Dominators.h"
 #include "llvm/Analysis/SimplifyCFG.h"   // To get cfg::UnifyAllExitNodes
 #include "llvm/CFG.h"
-#include "llvm/Tools/STLExtras.h"
+#include "llvm/Support/STLExtras.h"
 #include <algorithm>
 
 //===----------------------------------------------------------------------===//
diff --git a/lib/VMCore/Module.cpp b/lib/VMCore/Module.cpp
index 9d0015f7696..618e27b873d 100644
--- a/lib/VMCore/Module.cpp
+++ b/lib/VMCore/Module.cpp
@@ -9,7 +9,7 @@
 #include "llvm/BasicBlock.h"
 #include "llvm/InstrTypes.h"
 #include "llvm/ValueHolderImpl.h"
-#include "llvm/Tools/STLExtras.h"
+#include "llvm/Support/STLExtras.h"
 
 // Instantiate Templates - This ugliness is the price we have to pay
 // for having a DefHolderImpl.h file seperate from DefHolder.h!  :(
diff --git a/lib/VMCore/SymbolTable.cpp b/lib/VMCore/SymbolTable.cpp
index 07e4b87f020..e054b8850c9 100644
--- a/lib/VMCore/SymbolTable.cpp
+++ b/lib/VMCore/SymbolTable.cpp
@@ -6,7 +6,7 @@
 
 #include "llvm/SymbolTable.h"
 #include "llvm/InstrTypes.h"
-#include "llvm/Tools/StringExtras.h"
+#include "llvm/Support/StringExtras.h"
 #ifndef NDEBUG
 #include "llvm/BasicBlock.h"   // Required for assertions to work.
 #include "llvm/Type.h"
diff --git a/lib/VMCore/Type.cpp b/lib/VMCore/Type.cpp
index e28c3d13917..2adba049bc7 100644
--- a/lib/VMCore/Type.cpp
+++ b/lib/VMCore/Type.cpp
@@ -5,7 +5,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DerivedTypes.h"
-#include "llvm/Tools/StringExtras.h"
+#include "llvm/Support/StringExtras.h"
 
 //===----------------------------------------------------------------------===//
 //                         Type Class Implementation
diff --git a/support/lib/Support/CommandLine.cpp b/support/lib/Support/CommandLine.cpp
index 013c22fe922..7c3f29305e9 100644
--- a/support/lib/Support/CommandLine.cpp
+++ b/support/lib/Support/CommandLine.cpp
@@ -6,8 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/Tools/CommandLine.h"
-#include "llvm/Tools/STLExtras.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/STLExtras.h"
 #include <vector>
 #include <algorithm>
 #include <map>
diff --git a/tools/analyze/analyze.cpp b/tools/analyze/analyze.cpp
index 4dc00b2c579..3adef161de7 100644
--- a/tools/analyze/analyze.cpp
+++ b/tools/analyze/analyze.cpp
@@ -16,7 +16,7 @@
 #include "llvm/Method.h"
 #include "llvm/Bytecode/Reader.h"
 #include "llvm/Assembly/Parser.h"
-#include "llvm/Tools/CommandLine.h"
+#include "llvm/Support/CommandLine.h"
 #include "llvm/Analysis/Writer.h"
 
 #include "llvm/Analysis/Dominators.h"
diff --git a/tools/as/as.cpp b/tools/as/as.cpp
index da05a36f7fc..8cb274798db 100644
--- a/tools/as/as.cpp
+++ b/tools/as/as.cpp
@@ -16,7 +16,7 @@
 #include "llvm/Assembly/Parser.h"
 #include "llvm/Assembly/Writer.h"
 #include "llvm/Bytecode/Writer.h"
-#include "llvm/Tools/CommandLine.h"
+#include "llvm/Support/CommandLine.h"
 
 cl::String InputFilename ("", "Parse <arg> file, compile to bytecode", 0, "-");
 cl::String OutputFilename("o", "Override output filename", 0, "");
diff --git a/tools/dis/dis.cpp b/tools/dis/dis.cpp
index d1f61d70b01..59594763eb1 100644
--- a/tools/dis/dis.cpp
+++ b/tools/dis/dis.cpp
@@ -21,7 +21,7 @@
 #include "llvm/Module.h"
 #include "llvm/Assembly/Writer.h"
 #include "llvm/Bytecode/Reader.h"
-#include "llvm/Tools/CommandLine.h"
+#include "llvm/Support/CommandLine.h"
 #include "llvm/Method.h"
 #include "llvm/CFG.h"
 
diff --git a/tools/llc/llc.cpp b/tools/llc/llc.cpp
index ab1f532b36b..c4370d9e842 100644
--- a/tools/llc/llc.cpp
+++ b/tools/llc/llc.cpp
@@ -17,7 +17,7 @@
 #include "llvm/Bytecode/Writer.h"
 #include "llvm/CodeGen/InstrSelection.h"
 #include "llvm/CodeGen/Sparc.h"
-#include "llvm/Tools/CommandLine.h"
+#include "llvm/Support/CommandLine.h"
 
 cl::String InputFilename ("", "Input filename", cl::NoFlags, "");
 cl::String OutputFilename("o", "Output filename", cl::NoFlags, "");
diff --git a/tools/llvm-as/as.cpp b/tools/llvm-as/as.cpp
index da05a36f7fc..8cb274798db 100644
--- a/tools/llvm-as/as.cpp
+++ b/tools/llvm-as/as.cpp
@@ -16,7 +16,7 @@
 #include "llvm/Assembly/Parser.h"
 #include "llvm/Assembly/Writer.h"
 #include "llvm/Bytecode/Writer.h"
-#include "llvm/Tools/CommandLine.h"
+#include "llvm/Support/CommandLine.h"
 
 cl::String InputFilename ("", "Parse <arg> file, compile to bytecode", 0, "-");
 cl::String OutputFilename("o", "Override output filename", 0, "");
diff --git a/tools/llvm-as/llvm-as.cpp b/tools/llvm-as/llvm-as.cpp
index da05a36f7fc..8cb274798db 100644
--- a/tools/llvm-as/llvm-as.cpp
+++ b/tools/llvm-as/llvm-as.cpp
@@ -16,7 +16,7 @@
 #include "llvm/Assembly/Parser.h"
 #include "llvm/Assembly/Writer.h"
 #include "llvm/Bytecode/Writer.h"
-#include "llvm/Tools/CommandLine.h"
+#include "llvm/Support/CommandLine.h"
 
 cl::String InputFilename ("", "Parse <arg> file, compile to bytecode", 0, "-");
 cl::String OutputFilename("o", "Override output filename", 0, "");
diff --git a/tools/llvm-dis/dis.cpp b/tools/llvm-dis/dis.cpp
index d1f61d70b01..59594763eb1 100644
--- a/tools/llvm-dis/dis.cpp
+++ b/tools/llvm-dis/dis.cpp
@@ -21,7 +21,7 @@
 #include "llvm/Module.h"
 #include "llvm/Assembly/Writer.h"
 #include "llvm/Bytecode/Reader.h"
-#include "llvm/Tools/CommandLine.h"
+#include "llvm/Support/CommandLine.h"
 #include "llvm/Method.h"
 #include "llvm/CFG.h"
 
diff --git a/tools/llvm-dis/llvm-dis.cpp b/tools/llvm-dis/llvm-dis.cpp
index d1f61d70b01..59594763eb1 100644
--- a/tools/llvm-dis/llvm-dis.cpp
+++ b/tools/llvm-dis/llvm-dis.cpp
@@ -21,7 +21,7 @@
 #include "llvm/Module.h"
 #include "llvm/Assembly/Writer.h"
 #include "llvm/Bytecode/Reader.h"
-#include "llvm/Tools/CommandLine.h"
+#include "llvm/Support/CommandLine.h"
 #include "llvm/Method.h"
 #include "llvm/CFG.h"
 
diff --git a/tools/opt/opt.cpp b/tools/opt/opt.cpp
index 2b5b0691065..3dedd0b10c7 100644
--- a/tools/opt/opt.cpp
+++ b/tools/opt/opt.cpp
@@ -24,7 +24,7 @@
 #include "llvm/Module.h"
 #include "llvm/Bytecode/Reader.h"
 #include "llvm/Bytecode/Writer.h"
-#include "llvm/Tools/CommandLine.h"
+#include "llvm/Support/CommandLine.h"
 #include "llvm/Optimizations/AllOpts.h"
 
 using namespace opt;