Create a new #include "Support/..." directory structure to move things

from "llvm/Support/..." that are not llvm dependant.

Move files and fix #includes


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

21 files changed, 455 insertions, 80 deletions

diff --git a/include/llvm/Support/DepthFirstIterator.h b/include/llvm/ADT/DepthFirstIterator.h
index 73017067b3..a2d5a9df68 100644
--- a/include/llvm/Support/DepthFirstIterator.h
+++ b/include/llvm/ADT/DepthFirstIterator.h
@@ -1,4 +1,4 @@
-//===- llvm/Support/DepthFirstIterator.h - Depth First iterators -*- C++ -*--=//
+//===- Support/DepthFirstIterator.h - Depth First iterator -------*- C++ -*--=//
 //
 // This file builds on the Support/GraphTraits.h file to build generic depth
 // first graph iterator.
@@ -8,7 +8,7 @@
 #ifndef LLVM_SUPPORT_DEPTH_FIRST_ITERATOR_H
 #define LLVM_SUPPORT_DEPTH_FIRST_ITERATOR_H
 
-#include "llvm/Support/GraphTraits.h"
+#include "Support/GraphTraits.h"
 #include <iterator>
 #include <stack>
 #include <set>
diff --git a/include/llvm/Support/GraphTraits.h b/include/llvm/ADT/GraphTraits.h
index 67fe7c9360..00973d59fa 100644
--- a/include/llvm/Support/GraphTraits.h
+++ b/include/llvm/ADT/GraphTraits.h
@@ -1,4 +1,4 @@
-//===-- llvm/Support/GraphTraits.h - Graph traits template -------*- C++ -*--=//
+//===-- Support/GraphTraits.h - Graph traits template ------------*- C++ -*--=//
 //
 // This file defines the little GraphTraits<X> template class that should be 
 // specialized by classes that want to be iteratable by generic graph iterators.
diff --git a/include/llvm/Support/HashExtras.h b/include/llvm/ADT/HashExtras.h
index 6ea831e78f..6ea831e78f 100644
--- a/include/llvm/Support/HashExtras.h
+++ b/include/llvm/ADT/HashExtras.h
diff --git a/include/llvm/Support/PostOrderIterator.h b/include/llvm/ADT/PostOrderIterator.h
index fa135f8785..89a9b4db86 100644
--- a/include/llvm/Support/PostOrderIterator.h
+++ b/include/llvm/ADT/PostOrderIterator.h
@@ -1,4 +1,4 @@
-//===-- llvm/Support/PostOrderIterator.h - Generic PO iterator ---*- C++ -*--=//
+//===-- Support/PostOrderIterator.h - Generic PostOrder iterator -*- C++ -*--=//
 //
 // This file builds on the Support/GraphTraits.h file to build a generic graph
 // post order iterator.  This should work over any graph type that has a
@@ -9,7 +9,7 @@
 #ifndef LLVM_SUPPORT_POSTORDER_ITERATOR_H
 #define LLVM_SUPPORT_POSTORDER_ITERATOR_H
 
-#include "llvm/Support/GraphTraits.h"
+#include "Support/GraphTraits.h"
 #include <iterator>
 #include <stack>
 #include <set>
diff --git a/include/llvm/Support/STLExtras.h b/include/llvm/ADT/STLExtras.h
index 44d789dcf2..44d789dcf2 100644
--- a/include/llvm/Support/STLExtras.h
+++ b/include/llvm/ADT/STLExtras.h
diff --git a/include/llvm/Support/StringExtras.h b/include/llvm/ADT/StringExtras.h
index aaae8577ef..e67e25ced5 100644
--- a/include/llvm/Support/StringExtras.h
+++ b/include/llvm/ADT/StringExtras.h
@@ -1,17 +1,15 @@
-//===-- StringExtras.h - Useful string functions -----------------*- C++ -*--=//
+//===-- Support/StringExtras.h - Useful string functions ---------*- C++ -*--=//
 //
 // This file contains some functions that are useful when dealing with strings.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_TOOLS_STRING_EXTRAS_H
-#define LLVM_TOOLS_STRING_EXTRAS_H
+#ifndef SUPPORT_STRING_EXTRAS_H
+#define SUPPORT_STRING_EXTRAS_H
 
+#include "Support/DataTypes.h"
 #include <string>
 #include <stdio.h>
-#include "Support/DataTypes.h"
-
-class ConstPoolArray;
 
 static inline string utostr(uint64_t X, bool isNeg = false) {
   char Buffer[40];
@@ -68,21 +66,4 @@ static inline string ftostr(double V) {
   return Buffer;
 }
 
-static inline void
-printIndent(unsigned int indent, ostream& os=cout, const char* const istr="  ")
-{
-  for (unsigned i=0; i < indent; i++)
-    os << istr;
-}
-
-// Can we treat the specified array as a string?  Only if it is an array of
-// ubytes or non-negative sbytes.
-//
-bool isStringCompatible(ConstPoolArray *CPA);
-
-// getAsCString - Return the specified array as a C compatible string, only if
-// the predicate isStringCompatible is true.
-//
-string getAsCString(ConstPoolArray *CPA);
-
 #endif
diff --git a/include/llvm/Support/Tree.h b/include/llvm/ADT/Tree.h
index 679b6dfd83..33b0bb7b03 100644
--- a/include/llvm/Support/Tree.h
+++ b/include/llvm/ADT/Tree.h
@@ -1,4 +1,4 @@
-//===- llvm/Support/Tree.h - Generic n-way tree structure --------*- C++ -*--=//
+//===- Support/Tree.h - Generic n-way tree structure -------------*- C++ -*--=//
 //
 // This class defines a generic N way tree node structure.  The tree structure
 // is immutable after creation, but the payload contained within it is not.
diff --git a/include/llvm/Analysis/CallGraph.h b/include/llvm/Analysis/CallGraph.h
index 62b1846952..8365a4f397 100644
--- a/include/llvm/Analysis/CallGraph.h
+++ b/include/llvm/Analysis/CallGraph.h
@@ -16,7 +16,7 @@
 #ifndef LLVM_ANALYSIS_CALLGRAPH_H
 #define LLVM_ANALYSIS_CALLGRAPH_H
 
-#include "llvm/Support/GraphTraits.h"
+#include "Support/GraphTraits.h"
 #include <map>
 #include <vector>
 class Method;
diff --git a/include/llvm/Analysis/InstForest.h b/include/llvm/Analysis/InstForest.h
index 967ed45ec9..497bb46188 100644
--- a/include/llvm/Analysis/InstForest.h
+++ b/include/llvm/Analysis/InstForest.h
@@ -14,8 +14,8 @@
 #ifndef LLVM_ANALYSIS_INSTFOREST_H
 #define LLVM_ANALYSIS_INSTFOREST_H
 
-#include "llvm/Support/Tree.h"
 #include "llvm/Instruction.h"
+#include "Support/Tree.h"
 #include <map>
 
 namespace analysis {
diff --git a/include/llvm/BasicBlock.h b/include/llvm/BasicBlock.h
index cf29cbd00e..df9447fb09 100644
--- a/include/llvm/BasicBlock.h
+++ b/include/llvm/BasicBlock.h
@@ -24,8 +24,8 @@
 
 #include "llvm/Value.h"
 #include "llvm/ValueHolder.h"
-#include "llvm/Support/GraphTraits.h"
 #include "llvm/InstrTypes.h"
+#include "Support/GraphTraits.h"
 #include <iterator>
 
 class Instruction;
diff --git a/include/llvm/CodeGen/InstrForest.h b/include/llvm/CodeGen/InstrForest.h
index 1b9af714b9..e7bd3ad145 100644
--- a/include/llvm/CodeGen/InstrForest.h
+++ b/include/llvm/CodeGen/InstrForest.h
@@ -24,9 +24,9 @@
 #ifndef LLVM_CODEGEN_INSTRFOREST_H
 #define LLVM_CODEGEN_INSTRFOREST_H
 
-#include "llvm/Support/NonCopyable.h"
-#include "llvm/Support/HashExtras.h"
 #include "llvm/Instruction.h"
+#include "Support/NonCopyable.h"
+#include "Support/HashExtras.h"
 #include <hash_map>
 #include <hash_set>
 
diff --git a/include/llvm/CodeGen/InstrScheduling.h b/include/llvm/CodeGen/InstrScheduling.h
index 8f88a61590..69390fae96 100644
--- a/include/llvm/CodeGen/InstrScheduling.h
+++ b/include/llvm/CodeGen/InstrScheduling.h
@@ -12,8 +12,8 @@
 #ifndef LLVM_CODEGEN_INSTR_SCHEDULING_H
 #define LLVM_CODEGEN_INSTR_SCHEDULING_H
 
-#include "llvm/Support/CommandLine.h"
 #include "llvm/CodeGen/MachineInstr.h"
+#include "Support/CommandLine.h"
 
 class Method;
 class SchedulingManager;
diff --git a/include/llvm/CodeGen/MachineInstr.h b/include/llvm/CodeGen/MachineInstr.h
index 91ae9def7f..a20431848e 100644
--- a/include/llvm/CodeGen/MachineInstr.h
+++ b/include/llvm/CodeGen/MachineInstr.h
@@ -15,13 +15,13 @@
 #ifndef LLVM_CODEGEN_MACHINEINSTR_H
 #define LLVM_CODEGEN_MACHINEINSTR_H
 
-#include <iterator>
-#include "llvm/CodeGen/InstrForest.h"
 #include "Support/DataTypes.h"
-#include "llvm/Support/NonCopyable.h"
+#include "Support/NonCopyable.h"
+#include "llvm/CodeGen/InstrForest.h"
 #include "llvm/Target/MachineInstrInfo.h"
 #include "llvm/Annotation.h"
 #include "llvm/Method.h"
+#include <iterator>
 #include <hash_map>
 #include <hash_set>
 #include <values.h>
diff --git a/include/llvm/CodeGen/RegAllocCommon.h b/include/llvm/CodeGen/RegAllocCommon.h
index 5fa51c034f..02b3331132 100644
--- a/include/llvm/CodeGen/RegAllocCommon.h
+++ b/include/llvm/CodeGen/RegAllocCommon.h
@@ -1,5 +1,5 @@
 
-#include "llvm/Support/CommandLine.h"
+#include "Support/CommandLine.h"
 
 #ifndef REG_ALLOC_COMMON_H
 #define  REG_ALLOC_COMMON_H
diff --git a/include/llvm/Support/CommandLine.h b/include/llvm/Support/CommandLine.h
new file mode 100644
index 0000000000..84a3bc9b59
--- /dev/null
+++ b/include/llvm/Support/CommandLine.h
@@ -0,0 +1,399 @@
+//===- Support/CommandLine.h - Flexible Command line parser ------*- 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.
+//
+// Note that rather than trying to figure out what this code does, you could try
+// reading the library documentation located in docs/CommandLine.html
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_COMMANDLINE_H
+#define LLVM_SUPPORT_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,
+				 int Flags = 0);
+
+// ParserOptions - This set of option is use to control global behavior of the
+// command line processor.
+//
+enum ParserOptions {
+  // DisableSingleLetterArgGrouping - With this option enabled, multiple letter
+  // options are allowed to bunch together with only a single hyphen for the
+  // whole group.  This allows emulation of the behavior that ls uses for
+  // example:  ls -la === ls -l -a    Providing this option, disables this.
+  //
+  DisableSingleLetterArgGrouping = 0x0001,
+
+  // EnableSingleLetterArgValue - This option allows arguments that are
+  // otherwise unrecognized to match single letter flags that take a value. 
+  // This is useful for cases like a linker, where options are typically of the
+  // form '-lfoo' or '-L../../include' where -l or -L are the actual flags.
+  //
+  EnableSingleLetterArgValue     = 0x0002,
+};
+
+
+//===----------------------------------------------------------------------===//
+// Global flags permitted to be passed to command line arguments
+
+enum FlagsOptions {
+  NoFlags         = 0x00,      // Marker to make explicit that we have no flags
+  Default         = 0x00,      // Equally, marker to use the default flags
+
+  GlobalsMask     = 0x80, 
+};
+
+enum NumOccurances {           // Flags for the number of occurances allowed...
+  Optional        = 0x01,      // Zero or One occurance
+  ZeroOrMore      = 0x02,      // Zero or more occurances allowed
+  Required        = 0x03,      // One occurance required
+  OneOrMore       = 0x04,      // One or more occurances required
+
+  // ConsumeAfter - Marker for a null ("") flag that can be used to indicate
+  // that anything that matches the null marker starts a sequence of options
+  // that all get sent to the null marker.  Thus, for example, all arguments
+  // to LLI are processed until a filename is found.  Once a filename is found,
+  // all of the succeeding arguments are passed, unprocessed, to the null flag.
+  //
+  ConsumeAfter    = 0x05,
+
+  OccurancesMask  = 0x07,
+};
+
+enum ValueExpected {           // Is a value required for the option?
+  ValueOptional   = 0x08,      // The value can oppear... or not
+  ValueRequired   = 0x10,      // The value is required to appear!
+  ValueDisallowed = 0x18,      // A value may not be specified (for flags)
+  ValueMask       = 0x18,
+};
+
+enum OptionHidden {            // Control whether -help shows this option
+  NotHidden       = 0x20,      // Option included in --help & --help-hidden
+  Hidden          = 0x40,      // -help doesn't, but --help-hidden does
+  ReallyHidden    = 0x60,      // Neither --help nor --help-hidden show this arg
+  HiddenMask      = 0x60,
+};
+
+
+//===----------------------------------------------------------------------===//
+// Option Base class
+//
+class Alias;
+class Option {
+  friend void cl::ParseCommandLineOptions(int &, char **, const char *, int);
+  friend class Alias;
+
+  // 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;
+
+  virtual enum NumOccurances getNumOccurancesFlagDefault() const { 
+    return Optional;
+  }
+  virtual enum ValueExpected getValueExpectedFlagDefault() const {
+    return ValueOptional; 
+  }
+  virtual enum OptionHidden getOptionHiddenFlagDefault() const {
+    return NotHidden;
+  }
+
+  int NumOccurances;          // The number of times specified
+  const int Flags;            // Flags for the argument
+public:
+  const char * const ArgStr;  // The argument string itself (ex: "help", "o")
+  const char * const HelpStr; // The descriptive text message for --help
+
+  inline enum NumOccurances getNumOccurancesFlag() const {
+    int NO = Flags & OccurancesMask;
+    return NO ? (enum NumOccurances)NO : getNumOccurancesFlagDefault();
+  }
+  inline enum ValueExpected getValueExpectedFlag() const {
+    int VE = Flags & ValueMask;
+    return VE ? (enum ValueExpected)VE : getValueExpectedFlagDefault();
+  }
+  inline enum OptionHidden getOptionHiddenFlag() const {
+    int OH = Flags & HiddenMask;
+    return OH ? (enum OptionHidden)OH : getOptionHiddenFlagDefault();
+  }
+
+protected:
+  Option(const char *ArgStr, const char *Message, int Flags);
+  Option(int flags) : NumOccurances(0), Flags(flags), ArgStr(""), HelpStr("") {}
+
+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;
+
+  // addOccurance - Wrapper around handleOccurance that enforces Flags
+  //
+  bool addOccurance(const char *ArgName, const string &Value);
+
+  // Prints option name followed by message.  Always returns true.
+  bool error(string Message, const char *ArgName = 0);
+
+public:
+  inline int getNumOccurances() const { return NumOccurances; }
+  virtual ~Option() {}
+};
+
+
+//===----------------------------------------------------------------------===//
+// Aliased command line option (alias this name to a preexisting name)
+//
+class Alias : public Option {
+  Option &AliasFor;
+  virtual bool handleOccurance(const char *ArgName, const string &Arg) {
+    return AliasFor.handleOccurance(AliasFor.ArgStr, Arg);
+  }
+  virtual enum OptionHidden getOptionHiddenFlagDefault() const {return Hidden;}
+public:
+  inline Alias(const char *ArgStr, const char *Message, int Flags,
+	       Option &aliasFor) : Option(ArgStr, Message, Flags), 
+				   AliasFor(aliasFor) {}
+};
+
+//===----------------------------------------------------------------------===//
+// 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 const bool() const { return Value; }
+  inline bool operator=(bool Val) { Value = Val; return Val; }
+};
+
+
+
+//===----------------------------------------------------------------------===//
+// Integer valued command line option
+//
+class Int : public Option {
+  int Value;
+  virtual bool handleOccurance(const char *ArgName, const string &Arg);
+  virtual enum ValueExpected getValueExpectedFlagDefault() const {
+    return ValueRequired; 
+  }
+public:
+  inline Int(const char *ArgStr, const char *Help, int Flags = 0,
+	     int DefaultVal = 0) : Option(ArgStr, Help, Flags),
+				   Value(DefaultVal) {}
+  inline operator int() const { return Value; }
+  inline int operator=(int Val) { Value = Val; return Val; }
+};
+
+
+//===----------------------------------------------------------------------===//
+// String valued command line option
+//
+class String : public Option, public string {
+  virtual bool handleOccurance(const char *ArgName, const string &Arg);
+  virtual enum ValueExpected getValueExpectedFlagDefault() const {
+    return ValueRequired; 
+  }
+public:
+  inline String(const char *ArgStr, const char *Help, int Flags = 0, 
+		const char *DefaultVal = "") 
+    : Option(ArgStr, Help, Flags), string(DefaultVal) {}
+
+  inline const string &operator=(const string &Val) { 
+    return string::operator=(Val);
+  }
+};
+
+
+//===----------------------------------------------------------------------===//
+// String list command line option
+//
+class StringList : public Option, public vector<string> {
+
+  virtual enum NumOccurances getNumOccurancesFlagDefault() const { 
+    return ZeroOrMore;
+  }
+  virtual enum ValueExpected getValueExpectedFlagDefault() const {
+    return ValueRequired;
+  }
+  virtual bool handleOccurance(const char *ArgName, const string &Arg);
+
+public:
+  inline StringList(const char *ArgStr, const char *Help, int Flags = 0)
+    : Option(ArgStr, Help, Flags) {}
+};
+
+
+//===----------------------------------------------------------------------===//
+// 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 {
+  virtual enum ValueExpected getValueExpectedFlagDefault() const {
+    return ValueRequired;
+  }
+public:
+  inline Enum(const char *ArgStr, int Flags, const char *Help, ...)
+    : EnumValueBase(ArgStr, Help, Flags) {
+    va_list Values;
+    va_start(Values, Help);
+    processValues(Values);
+    va_end(Values);
+    Value = ValueMap.front().second.first; // Grab default value
+  }
+
+  inline operator E() const { return (E)Value; }
+  inline E operator=(E Val) { Value = Val; return Val; }
+};
+
+
+//===----------------------------------------------------------------------===//
+// Enum flags command line option
+//
+class EnumFlagsBase : public EnumValueBase {
+  virtual enum ValueExpected getValueExpectedFlagDefault() const {
+    return ValueDisallowed;
+  }
+protected:
+  virtual bool handleOccurance(const char *ArgName, const string &Arg);
+  inline EnumFlagsBase(int Flags) : EnumValueBase(Flags) {}
+
+  // 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 operator E() const { return (E)Value; }
+  inline E operator=(E Val) { Value = Val; return Val; }
+};
+
+
+//===----------------------------------------------------------------------===//
+// Enum list command line option
+//
+class EnumListBase : public EnumBase {
+  virtual enum NumOccurances getNumOccurancesFlagDefault() const { 
+    return ZeroOrMore;
+  }
+  virtual enum ValueExpected getValueExpectedFlagDefault() const {
+    return ValueDisallowed;
+  }
+protected:
+  vector<int> Values;  // The options specified so far.
+
+  inline EnumListBase(int Flags) 
+    : EnumBase(Flags) {}
+  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  operator[](unsigned i) const { return (E)Values[i]; }
+  inline E &operator[](unsigned i)       { return (E&)Values[i]; }
+};
+
+} // End namespace cl
+
+#endif
diff --git a/include/llvm/Support/MathExtras.h b/include/llvm/Support/MathExtras.h
new file mode 100644
index 0000000000..f3dc3de17b
--- /dev/null
+++ b/include/llvm/Support/MathExtras.h
@@ -0,0 +1,32 @@
+// $Id$ -*-c++-*-
+//***************************************************************************
+// File:
+//	MathExtras.h
+// 
+// Purpose:
+//	
+// History:
+//	8/25/01	 -  Vikram Adve  -  Created
+//**************************************************************************/
+
+#ifndef LLVM_SUPPORT_MATH_EXTRAS_H
+#define LLVM_SUPPORT_MATH_EXTRAS_H
+
+#include <sys/types.h>
+
+inline bool	IsPowerOf2	(int64_t C, unsigned& getPow);
+
+inline
+bool IsPowerOf2(int64_t C, unsigned& getPow)
+{
+  if (C < 0)
+    C = -C;
+  bool isBool = C > 0 && (C == (C & ~(C - 1)));
+  if (isBool)
+    for (getPow = 0; C > 1; getPow++)
+      C = C >> 1;
+  
+  return isBool;
+}
+
+#endif /*LLVM_SUPPORT_MATH_EXTRAS_H*/
diff --git a/include/llvm/Support/NonCopyable.h b/include/llvm/Support/NonCopyable.h
deleted file mode 100644
index f4fc26805a..0000000000
--- a/include/llvm/Support/NonCopyable.h
+++ /dev/null
@@ -1,37 +0,0 @@
-//===-- NonCopyable.h - Disable copy ctor and op= in subclasses --*- C++ -*--=//
-//
-// This file defines the NonCopyable and NonCopyableV classes.  These mixin
-// classes may be used to mark a class not being copyable.  You should derive
-// from NonCopyable if you don't want to have a virtual dtor, or NonCopyableV
-// if you do want polymorphic behavior in your class.
-//
-// No library is required when using these functinons.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_SUPPORT_NONCOPYABLE_H
-#define LLVM_SUPPORT_NONCOPYABLE_H
-
-class NonCopyable {
-  // Disable the copy constructor and the assignment operator
-  // by making them both private:
-  // 
-  NonCopyable(const NonCopyable &);            // DO NOT IMPLEMENT
-  NonCopyable &operator=(const NonCopyable &); // DO NOT IMPLEMENT
-protected:
-  inline NonCopyable() {}
-  inline ~NonCopyable() {}
-};
-
-class NonCopyableV {
-  // Disable the copy constructor and the assignment operator
-  // by making them both private:
-  // 
-  NonCopyableV(const NonCopyableV &);            // DO NOT IMPLEMENT
-  NonCopyableV &operator=(const NonCopyableV &); // DO NOT IMPLEMENT
-protected:
-  inline NonCopyableV() {}
-  virtual ~NonCopyableV() {}
-};
-
-#endif
diff --git a/include/llvm/Target/TargetFrameInfo.h b/include/llvm/Target/TargetFrameInfo.h
index 4f19cc95c3..df16c730b2 100644
--- a/include/llvm/Target/TargetFrameInfo.h
+++ b/include/llvm/Target/TargetFrameInfo.h
@@ -13,7 +13,7 @@
 #ifndef LLVM_CODEGEN_FRAMEINFO_H
 #define LLVM_CODEGEN_FRAMEINFO_H
 
-#include "llvm/Support/NonCopyable.h"
+#include "Support/NonCopyable.h"
 #include <vector>
 
 
diff --git a/include/llvm/Target/TargetMachine.h b/include/llvm/Target/TargetMachine.h
index 4f0b934bb9..ad1f105958 100644
--- a/include/llvm/Target/TargetMachine.h
+++ b/include/llvm/Target/TargetMachine.h
@@ -8,7 +8,7 @@
 #define LLVM_TARGET_TARGETMACHINE_H
 
 #include "llvm/Target/TargetData.h"
-#include "llvm/Support/NonCopyable.h"
+#include "Support/NonCopyable.h"
 
 class TargetMachine;
 class MachineInstrInfo;
diff --git a/include/llvm/Target/TargetRegInfo.h b/include/llvm/Target/TargetRegInfo.h
index 8f7fad5711..4bd2319d02 100644
--- a/include/llvm/Target/TargetRegInfo.h
+++ b/include/llvm/Target/TargetRegInfo.h
@@ -8,7 +8,7 @@
 #ifndef LLVM_TARGET_MACHINEREGINFO_H
 #define LLVM_TARGET_MACHINEREGINFO_H
 
-#include "llvm/Support/NonCopyable.h"
+#include "Support/NonCopyable.h"
 #include <hash_map>
 #include <string>
 
diff --git a/include/llvm/Type.h b/include/llvm/Type.h
index 04780e9e3c..905aa2d11f 100644
--- a/include/llvm/Type.h
+++ b/include/llvm/Type.h
@@ -27,7 +27,7 @@
 #define LLVM_TYPE_H
 
 #include "llvm/Value.h"
-#include "llvm/Support/GraphTraits.h"
+#include "Support/GraphTraits.h"
 
 class DerivedType;
 class MethodType;