Remove some unneeded headers and replace some headers with forward class declarations

[kevgs]

Summary

NFC. Hope this will speed up compilation a bit.

[kevgs]

After applying this patch clang file include/clang/Lex/LiteralSupport.h needs to be added a "llvm/ADT/ArrayRef.h" header to it to fix a broken build.

[mehdi_amini]

LGTM, Thanks.

include/llvm/ADT/APFloat.h

29

You can still include APFloat without including SmallVector right?

[kevgs]

Thanks for your review. I have no commit rights.

include/llvm/ADT/APFloat.h

29

Yes, unless you're using SmallVector in your code.

[mehdi_amini]

Thanks! r266524

include/llvm/ADT/APFloat.h

 #include "llvm/ADT/APInt.h"
 
 namespace llvm {
 
 struct fltSemantics;
 class APSInt;
 class StringRef;
 
+template <typename T> class SmallVectorImpl;
+
 /// Enum that represents what fraction of the LSB truncated bits of an fp number
 /// represent.
 ///
 /// This essentially combines the roles of guard and sticky bits.
 enum lostFraction { // Example of truncated bits:
   lfExactlyZero,    // 000000
   lfLessThanHalf,   // 0xxxxx  x's not all zero
   lfExactlyHalf,    // 100000

include/llvm/ADT/APInt.h

 /// \brief This file implements a class to represent arbitrary precision
 /// integral constant values and operations on them.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ADT_APINT_H
 #define LLVM_ADT_APINT_H
 
-#include "llvm/ADT/ArrayRef.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/MathExtras.h"
 #include <cassert>
 #include <climits>
 #include <cstring>
 #include <string>
 
 namespace llvm {
 class FoldingSetNodeID;
 class StringRef;
 class hash_code;
 class raw_ostream;
 
 template <typename T> class SmallVectorImpl;
+template <typename T> class ArrayRef;
 
 // An unsigned host type used as a single part of a multi-part
 // bignum.
 typedef uint64_t integerPart;
 
 const unsigned int host_char_bit = 8;
 const unsigned int integerPartWidth =
     host_char_bit * static_cast<unsigned int>(sizeof(integerPart));

include/llvm/ADT/FoldingSet.h

 // SelectionDAGCSEMap, but was isolated to provide use across the llvm code set.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ADT_FOLDINGSET_H
 #define LLVM_ADT_FOLDINGSET_H
 
 #include "llvm/ADT/SmallVector.h"
-#include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/iterator.h"
 #include "llvm/Support/Allocator.h"
-#include "llvm/Support/DataTypes.h"
 
 namespace llvm {
 /// This folding set used for two purposes:
 ///   1. Given information about a node we want to create, look up the unique
 ///      instance of the node in the set.  If the node already exists, return
 ///      it, otherwise return the bucket it should be inserted into.
 ///   2. Given a node that has already been created, remove it from the set.
 ///

 ///
 /// 4) Finally, if you want to remove a node from the folding set call;
 ///
 ///    bool WasRemoved = RemoveNode(N);
 ///
 /// The result indicates whether the node existed in the folding set.
 
 class FoldingSetNodeID;
+class StringRef;
 
 //===----------------------------------------------------------------------===//
 /// FoldingSetImpl - Implements the folding set functionality.  The main
 /// structure is an array of buckets.  Each bucket is indexed by the hash of
 /// the nodes it contains.  The bucket itself points to the nodes contained
 /// in the bucket via a singly linked list.  The last node in the list points
 /// back to the bucket to facilitate node removal.
 ///

include/llvm/ADT/SmallBitVector.h

 // This file implements the SmallBitVector class.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ADT_SMALLBITVECTOR_H
 #define LLVM_ADT_SMALLBITVECTOR_H
 
 #include "llvm/ADT/BitVector.h"
-#include "llvm/Support/Compiler.h"
 #include "llvm/Support/MathExtras.h"
 #include <cassert>
 
 namespace llvm {
 
 /// This is a 'bitvector' (really, a variable-sized bit array), optimized for
 /// the case when the array is small. It contains one pointer-sized field, which
 /// is directly used as a plain collection of bits when possible, or as a

include/llvm/ADT/StringMap.h

 // This file defines the StringMap class.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ADT_STRINGMAP_H
 #define LLVM_ADT_STRINGMAP_H
 
 #include "llvm/ADT/StringRef.h"
-#include "llvm/ADT/Twine.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/PointerLikeTypeTraits.h"
 #include <cstring>
 #include <utility>
 
 namespace llvm {
   template<typename ValueT>
   class StringMapConstIterator;

include/llvm/IR/Comdat.h

 /// This file contains the declaration of the Comdat class, which represents a
 /// single COMDAT in LLVM.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_IR_COMDAT_H
 #define LLVM_IR_COMDAT_H
 
-#include "llvm/ADT/StringRef.h"
-#include "llvm/Support/Compiler.h"
-
 namespace llvm {
 
 class raw_ostream;
+class StringRef;
 template <typename ValueTy> class StringMapEntry;
 
 // This is a Name X SelectionKind pair. The reason for having this be an
 // independent object instead of just adding the name and the SelectionKind
 // to a GlobalObject is that it is invalid to have two Comdats with the same
 // name but different SelectionKind. This structure makes that unrepresentable.
 class Comdat {
 public:

include/llvm/IR/DIBuilder.h

 // This file defines a DIBuilder that is useful for creating debugging
 // information entries in LLVM IR form.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_IR_DIBUILDER_H
 #define LLVM_IR_DIBUILDER_H
 
-#include "llvm/ADT/ArrayRef.h"
-#include "llvm/ADT/StringRef.h"
 #include "llvm/IR/DebugInfo.h"
 #include "llvm/IR/TrackingMDRef.h"
 #include "llvm/IR/ValueHandle.h"
 #include "llvm/Support/DataTypes.h"
 
 namespace llvm {
   class BasicBlock;
   class Instruction;
   class Function;
   class Module;
   class Value;
   class Constant;
   class LLVMContext;
   class StringRef;
+  template <typename T> class ArrayRef;
 
   class DIBuilder {
     Module &M;
     LLVMContext &VMContext;
 
     DICompileUnit *CUNode;   ///< The one compile unit created by this DIBuiler.
     Function *DeclareFn;     ///< llvm.dbg.declare
     Function *ValueFn;       ///< llvm.dbg.value

include/llvm/IR/DataLayout.h

 // correct and then passed around by const&.  None of the members functions
 // require modification to the object.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_IR_DATALAYOUT_H
 #define LLVM_IR_DATALAYOUT_H
 
-#include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Type.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/DataTypes.h"
 
 // This needs to be outside of the namespace, to avoid conflict with llvm-c
 // decl.
 typedef struct LLVMOpaqueTargetData *LLVMTargetDataRef;
 
 namespace llvm {
 
 class Value;
-class Type;
-class IntegerType;
 class StructType;
 class StructLayout;
 class Triple;
 class GlobalVariable;
 class LLVMContext;
 template<typename T>
 class ArrayRef;
 

include/llvm/IR/DebugInfo.h

 // the information in the global variables that's needed when constructing the
 // DWARF information.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_IR_DEBUGINFO_H
 #define LLVM_IR_DEBUGINFO_H
 
-#include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
-#include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Dwarf.h"
 #include "llvm/Support/ErrorHandling.h"
 #include <iterator>
 
 namespace llvm {
 class Module;
 class DbgDeclareInst;
 class DbgValueInst;
+template <typename K, typename V, typename KeyInfoT, typename BucketT>
+class DenseMap;
 
 /// \brief Maps from type identifier to the actual MDNode.
 typedef DenseMap<const MDString *, DIType *> DITypeIdentifierMap;
 
 /// \brief Find subprogram that is enclosing this scope.
 DISubprogram *getDISubprogram(const MDNode *Scope);
 
 /// \brief Generate map by visiting all retained types.

include/llvm/IR/DebugInfoMetadata.h

 //===- llvm/IR/DebugInfoMetadata.h - Debug info metadata --------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Declarations for metadata specific to debug info.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_IR_DEBUGINFOMETADATA_H
 #define LLVM_IR_DEBUGINFOMETADATA_H
 
-#include "llvm/ADT/Optional.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/Support/Dwarf.h"
 
 // Helper macros for defining get() overrides.
 #define DEFINE_MDNODE_GET_UNPACK_IMPL(...) __VA_ARGS__
 #define DEFINE_MDNODE_GET_UNPACK(ARGS) DEFINE_MDNODE_GET_UNPACK_IMPL ARGS
 #define DEFINE_MDNODE_GET_DISTINCT_TEMPORARY(CLASS, FORMAL, ARGS)              \
   static CLASS *getDistinct(LLVMContext &Context,                              \
static CLASS *getIfExists(LLVMContext &Context,                              \
                             DEFINE_MDNODE_GET_UNPACK(FORMAL)) {                \
     return getImpl(Context, DEFINE_MDNODE_GET_UNPACK(ARGS), Uniqued,           \
                    /* ShouldCreate */ false);                                  \
   }                                                                            \
   DEFINE_MDNODE_GET_DISTINCT_TEMPORARY(CLASS, FORMAL, ARGS)
 
 namespace llvm {
 
+template <typename T> class Optional;
+
 /// \brief Pointer union between a subclass of DINode and MDString.
 ///
 /// \a DICompositeType can be referenced via an \a MDString unique identifier.
 /// This class allows some type safety in the face of that, requiring either a
 /// node of a particular type or an \a MDString.
 template <class T> class TypedDINodeRef {
   const Metadata *MD = nullptr;
 

include/llvm/IR/DiagnosticInfo.h

 // This file declares the different classes involved in low level diagnostics.
 //
 // Diagnostics reporting is still done as part of the LLVMContext.
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_IR_DIAGNOSTICINFO_H
 #define LLVM_IR_DIAGNOSTICINFO_H
 
-#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/IR/DebugLoc.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/Casting.h"
 #include <functional>
 
 namespace llvm {
 

include/llvm/IR/Dominators.h

 // This file defines the DominatorTree class, which provides fast and efficient
 // dominance queries.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_IR_DOMINATORS_H
 #define LLVM_IR_DOMINATORS_H
 
-#include "llvm/ADT/DenseMap.h"
-#include "llvm/ADT/DepthFirstIterator.h"
 #include "llvm/ADT/GraphTraits.h"
 #include "llvm/ADT/SmallPtrSet.h"
-#include "llvm/ADT/SmallVector.h"
-#include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/CFG.h"
-#include "llvm/IR/Function.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/Pass.h"
-#include "llvm/Support/Compiler.h"
 #include "llvm/Support/GenericDomTree.h"
-#include "llvm/Support/raw_ostream.h"
-#include <algorithm>
 
 namespace llvm {
 
+class Function;
+class BasicBlock;
+class raw_ostream;
+
 extern template class DomTreeNodeBase<BasicBlock>;
 extern template class DominatorTreeBase<BasicBlock>;
 
 extern template void Calculate<Function, BasicBlock *>(
     DominatorTreeBase<GraphTraits<BasicBlock *>::NodeType> &DT, Function &F);
 extern template void Calculate<Function, Inverse<BasicBlock *>>(
     DominatorTreeBase<GraphTraits<Inverse<BasicBlock *>>::NodeType> &DT,
     Function &F);

include/llvm/IR/Function.h

 // and a symbol table.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_IR_FUNCTION_H
 #define LLVM_IR_FUNCTION_H
 
 #include "llvm/ADT/iterator_range.h"
-#include "llvm/ADT/Optional.h"
 #include "llvm/IR/Argument.h"
 #include "llvm/IR/Attributes.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/CallingConv.h"
 #include "llvm/IR/GlobalObject.h"
 #include "llvm/IR/OperandTraits.h"
 #include "llvm/Support/Compiler.h"
 
 namespace llvm {
 
+template <typename T> class Optional;
 class FunctionType;
 class LLVMContext;
 class DISubprogram;
 
 template <>
 struct SymbolTableListSentinelTraits<Argument>
     : public ilist_half_embedded_sentinel_traits<Argument> {};
 

include/llvm/IR/GlobalAlias.h

 // This file contains the declaration of the GlobalAlias class, which
 // represents a single function or variable alias in the IR.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_IR_GLOBALALIAS_H
 #define LLVM_IR_GLOBALALIAS_H
 
-#include "llvm/ADT/Twine.h"
 #include "llvm/ADT/ilist_node.h"
 #include "llvm/IR/GlobalIndirectSymbol.h"
 
 namespace llvm {
 
+class Twine;
 class Module;
 template <typename ValueSubClass> class SymbolTableListTraits;
 
 class GlobalAlias : public GlobalIndirectSymbol,
                     public ilist_node<GlobalAlias> {
   friend class SymbolTableListTraits<GlobalAlias>;
   void operator=(const GlobalAlias &) = delete;
   GlobalAlias(const GlobalAlias &) = delete;

include/llvm/IR/GlobalIFunc.h

 /// ELF symbol type extension to mark that the address of a declaration should
 /// be resolved at runtime by calling a resolver function.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_IR_GLOBALIFUNC_H
 #define LLVM_IR_GLOBALIFUNC_H
 
-#include "llvm/ADT/Twine.h"
 #include "llvm/ADT/ilist_node.h"
 #include "llvm/IR/GlobalIndirectSymbol.h"
 
 namespace llvm {
 
+class Twine;
 class Module;
 
 // Traits class for using GlobalIFunc in symbol table in Module.
 template <typename ValueSubClass> class SymbolTableListTraits;
 
 class GlobalIFunc final : public GlobalIndirectSymbol,
                           public ilist_node<GlobalIFunc> {
   friend class SymbolTableListTraits<GlobalIFunc>;

include/llvm/IR/GlobalObject.h

 // This represents an independent object. That is, a function or a global
 // variable, but not an alias.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_IR_GLOBALOBJECT_H
 #define LLVM_IR_GLOBALOBJECT_H
 
-#include "llvm/IR/Constant.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/GlobalValue.h"
 
 namespace llvm {
 class Comdat;
 class Module;
 
 class GlobalObject : public GlobalValue {

include/llvm/IR/Intrinsics.h

 // Function::getIntrinsicID.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_IR_INTRINSICS_H
 #define LLVM_IR_INTRINSICS_H
 
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/None.h"
 #include <string>
 
 namespace llvm {
 
 class Type;
 class FunctionType;
 class Function;
 class LLVMContext;

include/llvm/IR/LLVMContext.h

 // as the global type and constant uniquing tables.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_IR_LLVMCONTEXT_H
 #define LLVM_IR_LLVMCONTEXT_H
 
 #include "llvm/Support/CBindingWrapping.h"
-#include "llvm/Support/Compiler.h"
 #include "llvm/Support/Options.h"
 
 namespace llvm {
 
 class LLVMContextImpl;
 class StringRef;
 class Twine;
 class Instruction;

include/llvm/IR/LegacyPassManagers.h

 //===- LegacyPassManagers.h - Legacy Pass Infrastructure --------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares the LLVM Pass Manager infrastructure.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_IR_LEGACYPASSMANAGERS_H
 #define LLVM_IR_LEGACYPASSMANAGERS_H
 
-#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/FoldingSet.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Pass.h"
 #include <map>
 #include <vector>
 

 //
 // PassManagerImpl is a top level pass manager responsible for managing
 // MPPassManagers.
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/PrettyStackTrace.h"
 
 namespace llvm {
-  class Module;
-  class Pass;
-  class StringRef;
-  class Value;
-  class Timer;
-  class PMDataManager;
+template <typename T> class ArrayRef;
 
 // enums for debugging strings
 enum PassDebuggingString {
   EXECUTION_MSG, // "Executing Pass '" + PassName
   MODIFICATION_MSG, // "Made Modification '" + PassName
   FREEING_MSG, // " Freeing Pass '" + PassName
   ON_BASICBLOCK_MSG, // "' on BasicBlock '" + InstructionName + "'...\n"
   ON_FUNCTION_MSG, // "' on Function '" + FunctionName + "'...\n"

include/llvm/IR/Mangler.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_IR_MANGLER_H
 #define LLVM_IR_MANGLER_H
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/IR/GlobalValue.h"
-#include "llvm/Support/raw_ostream.h"
 
 namespace llvm {
 
 class DataLayout;
 template <typename T> class SmallVectorImpl;
 class Twine;
+class raw_ostream;
 
 class Mangler {
   /// We need to give global values the same name every time they are mangled.
   /// This keeps track of the number we give to anonymous ones.
   mutable DenseMap<const GlobalValue*, unsigned> AnonGlobalIDs;
 
   /// This simple counter is used to unique value names.
   mutable unsigned NextAnonGlobalID;

include/llvm/IR/Module.h

 /// @file
 /// Module.h This file contains the declarations for the Module class.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_IR_MODULE_H
 #define LLVM_IR_MODULE_H
 
-#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/IR/Comdat.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GlobalAlias.h"
 #include "llvm/IR/GlobalIFunc.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/Support/CBindingWrapping.h"
 #include "llvm/Support/CodeGen.h"
 #include "llvm/Support/DataTypes.h"
 #include <system_error>
 
 namespace llvm {
+template <typename T> class Optional;
 class FunctionType;
 class GVMaterializer;
 class LLVMContext;
 class RandomNumberGenerator;
 class StructType;
 
 template<> struct ilist_traits<NamedMDNode>
   : public ilist_default_traits<NamedMDNode> {

include/llvm/IR/ModuleSummaryIndex.h

 #define LLVM_IR_MODULESUMMARYINDEX_H
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringMap.h"
-#include "llvm/IR/Function.h"
 #include "llvm/IR/Module.h"
-#include "llvm/Support/MemoryBuffer.h"
-#include "llvm/Support/raw_ostream.h"
 
 #include <array>
 
 namespace llvm {
 
 /// \brief Class to accumulate and hold information about a callee.
 struct CalleeInfo {
   /// The static number of callsites calling corresponding function.

include/llvm/IR/PassManager.h

 #define LLVM_IR_PASSMANAGER_H
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/PassManagerInternal.h"
-#include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/TypeName.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Support/type_traits.h"
 #include <list>
 #include <memory>
 #include <vector>
 
 namespace llvm {
 
-class Module;
-class Function;
-
 /// \brief An abstract set of preserved analyses following a transformation pass
 /// run.
 ///
 /// When a transformation pass is run, it can return a set of analyses whose
 /// results were preserved by that transformation. The default set is "none",
 /// and preserving analyses must be done explicitly.
 ///
 /// There is also an explicit all state which can be used (for example) when

include/llvm/IR/TrackingMDRef.h

 // References to metadata that track RAUW.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_IR_TRACKINGMDREF_H
 #define LLVM_IR_TRACKINGMDREF_H
 
 #include "llvm/IR/Metadata.h"
-#include "llvm/Support/Casting.h"
 
 namespace llvm {
 
 /// \brief Tracking metadata reference.
 ///
 /// This class behaves like \a TrackingVH, but for metadata.
 class TrackingMDRef {
   Metadata *MD;

include/llvm/IR/Type.h

 // stuff, look in DerivedTypes.h.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_IR_TYPE_H
 #define LLVM_IR_TYPE_H
 
 #include "llvm/ADT/APFloat.h"
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/Support/CBindingWrapping.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/DataTypes.h"
 #include "llvm/Support/ErrorHandling.h"
 
 namespace llvm {
 

include/llvm/IR/Use.h

 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_IR_USE_H
 #define LLVM_IR_USE_H
 
 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/Support/CBindingWrapping.h"
-#include "llvm/Support/Compiler.h"
 #include <cstddef>
 #include <iterator>
 
 namespace llvm {
 
 class Value;
 class User;
 class Use;

include/llvm/IR/UseListOrder.h

 // This file has structures and command-line options for preserving use-list
 // order.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_IR_USELISTORDER_H
 #define LLVM_IR_USELISTORDER_H
 
-#include "llvm/ADT/ArrayRef.h"
-#include "llvm/ADT/SmallVector.h"
 #include <vector>
 
 namespace llvm {
 
 class Module;
 class Function;
 class Value;
 

include/llvm/IR/User.h

 //  * Instructions are the largest class of Users.
 //  * Constants may be users of other constants (think arrays and stuff)
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_IR_USER_H
 #define LLVM_IR_USER_H
 
-#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/iterator.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/IR/Value.h"
 #include "llvm/Support/AlignOf.h"
 #include "llvm/Support/ErrorHandling.h"
 
 namespace llvm {
 
+template <typename T> class ArrayRef;
+template <typename T> class MutableArrayRef;
+
 /// \brief Compile-time customization of User operands.
 ///
 /// Customizes operand-related allocators and accessors.
 template <class>
 struct OperandTraits;
 
 class User : public Value {
   User(const User &) = delete;

include/llvm/IR/Value.h

 
 #ifndef LLVM_IR_VALUE_H
 #define LLVM_IR_VALUE_H
 
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/IR/Use.h"
 #include "llvm/Support/CBindingWrapping.h"
 #include "llvm/Support/Casting.h"
-#include "llvm/Support/Compiler.h"
 
 namespace llvm {
 
 class APInt;
 class Argument;
 class AssemblyAnnotationWriter;
 class BasicBlock;
 class Constant;

include/llvm/IR/ValueSymbolTable.h

 //===-- llvm/ValueSymbolTable.h - Implement a Value Symtab ------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the name/Value symbol table for LLVM.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_IR_VALUESYMBOLTABLE_H
 #define LLVM_IR_VALUESYMBOLTABLE_H
 
-#include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/IR/Value.h"
 #include "llvm/Support/DataTypes.h"
 
 namespace llvm {
   template <typename ValueSubClass> class SymbolTableListTraits;
+  template <unsigned InternalLen> class SmallString;
   class BasicBlock;
   class Function;
   class NamedMDNode;
   class Module;
   class StringRef;
 
 /// This class provides a symbol table of name/value pairs. It is essentially
 /// a std::map<std::string,Value*> but has a controlled interface provided by

include/llvm/IR/Verifier.h

 //
 // To see what specifically is checked, look at the top of Verifier.cpp
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_IR_VERIFIER_H
 #define LLVM_IR_VERIFIER_H
 
-#include "llvm/ADT/StringRef.h"
 #include "llvm/IR/PassManager.h"
-#include <string>
 
 namespace llvm {
 
 class Function;
 class FunctionPass;
 class ModulePass;
 class Module;
 class raw_ostream;

include/llvm/MC/MCParser/MCAsmLexer.h

 //===-- llvm/MC/MCAsmLexer.h - Abstract Asm Lexer Interface -----*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_MC_MCPARSER_MCASMLEXER_H
 #define LLVM_MC_MCPARSER_MCASMLEXER_H
 
 #include "llvm/ADT/APInt.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/DataTypes.h"
 #include "llvm/Support/SMLoc.h"
 
 namespace llvm {
 
 /// Target independent representation for an assembler token.

lib/CodeGen/MIRParser/MILexer.cpp

 //===- MILexer.cpp - Machine instructions lexer implementation ----------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the lexing of machine instructions.
 //
 //===----------------------------------------------------------------------===//
 
 #include "MILexer.h"
+#include "llvm/ADT/None.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/Twine.h"
 #include <cctype>
 
 using namespace llvm;
 
 namespace {

lib/CodeGen/RegAllocFast.cpp

 //===-- RegAllocFast.cpp - A fast register allocator for debug code -------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This register allocator allocates registers to a basic block at a time,
 // attempting to keep values in registers and reusing registers as appropriate.
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/CodeGen/Passes.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/IndexedMap.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/SparseSet.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/CodeGen/MachineFrameInfo.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
 #include "llvm/CodeGen/MachineInstr.h"
 #include "llvm/CodeGen/MachineInstrBuilder.h"
 #include "llvm/CodeGen/MachineRegisterInfo.h"
+#include "llvm/CodeGen/Passes.h"
 #include "llvm/CodeGen/RegAllocRegistry.h"
 #include "llvm/CodeGen/RegisterClassInfo.h"
-#include "llvm/IR/BasicBlock.h"
-#include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
-#include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetInstrInfo.h"
 #include "llvm/Target/TargetSubtargetInfo.h"
 #include <algorithm>
 using namespace llvm;
 
 #define DEBUG_TYPE "regalloc"
 
 STATISTIC(NumStores, "Number of stores added");

lib/Support/APFloat.cpp

 //===-- APFloat.cpp - Implement APFloat class -----------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements a class to represent arbitrary precision floating
 // point values and provide a variety of arithmetic operations on them.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/APSInt.h"
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/FoldingSet.h"
 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
 #include <cstring>
 #include <limits.h>

lib/Support/APInt.cpp

 //===-- APInt.cpp - Implement APInt class ---------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements a class to represent arbitrary precision integer
 // constant values and provide a variety of arithmetic operations on them.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/APInt.h"
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/FoldingSet.h"
 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/raw_ostream.h"

lib/Support/APSInt.cpp

 //===-- llvm/ADT/APSInt.cpp - Arbitrary Precision Signed Int ---*- C++ -*--===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the APSInt class, which is a simple class that
 // represents an arbitrary sized integer that knows its signedness.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/APSInt.h"
 #include "llvm/ADT/FoldingSet.h"
+#include "llvm/ADT/StringRef.h"
 
 using namespace llvm;
 
 APSInt::APSInt(StringRef Str) {
   assert(!Str.empty() && "Invalid string length");
 
   // (Over-)estimate the required number of bits.
   unsigned NumBits = ((Str.size() * 64) / 19) + 2;

lib/Support/ScaledNumber.cpp

 //==- lib/Support/ScaledNumber.cpp - Support for scaled numbers -*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Implementation of some scaled number algorithms.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/ScaledNumber.h"
 #include "llvm/ADT/APFloat.h"
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 using namespace llvm::ScaledNumbers;
 
 std::pair<uint64_t, int16_t> ScaledNumbers::multiply64(uint64_t LHS,
                                                        uint64_t RHS) {

unittests/ADT/APIntTest.cpp

 //===- llvm/unittest/ADT/APInt.cpp - APInt unit tests ---------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/APInt.h"
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallString.h"
 #include "gtest/gtest.h"
 #include <array>
-#include <ostream>
 
 using namespace llvm;
 
 namespace {
 
 TEST(APIntTest, ValueInit) {
   APInt Zero = APInt();
   EXPECT_TRUE(!Zero);

unittests/ADT/StringMapTest.cpp

 //===- llvm/unittest/ADT/StringMapMap.cpp - StringMap unit tests ----------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#include "gtest/gtest.h"
 #include "llvm/ADT/StringMap.h"
+#include "llvm/ADT/Twine.h"
 #include "llvm/Support/DataTypes.h"
+#include "gtest/gtest.h"
 #include <tuple>
 using namespace llvm;
 
 namespace {
 
 // Test fixture
 class StringMapTest : public testing::Test {
 protected: