Cleanup llvm/utils/TableGen headers

[serge-sans-paille]

Summary

Based on the output of include-what-you-use.
It's an utility directory, so no much impact on other code areas.

clang++ -E -Iinclude -I../llvm/include ../llvm/utils/TableGen/*.cpp -std=c++14 -fno-rtti -fno-exceptions | wc -l
before: 4327274
after: 4316190

Related discourse thread: https://llvm.discourse.group/t/include-what-you-use-include-cleanup

llvm/utils/TableGen/CompressInstEmitter.cpp

 // format aliases is favored.
 
 //===----------------------------------------------------------------------===//
 
 #include "CodeGenInstruction.h"
 #include "CodeGenTarget.h"
 #include "llvm/ADT/IndexedMap.h"
 #include "llvm/ADT/SmallVector.h"
-#include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Record.h"
 #include "llvm/TableGen/TableGenBackend.h"
 #include <set>
 #include <vector>

llvm/utils/TableGen/GICombinerEmitter.cpp

 #include "GlobalISel/GIMatchDagPredicate.h"
 #include "GlobalISel/GIMatchTree.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ScopedPrinter.h"
-#include "llvm/Support/Timer.h"
 #include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/StringMatcher.h"
 #include "llvm/TableGen/TableGenBackend.h"
 #include <cstdint>
 
 using namespace llvm;
 
 #define DEBUG_TYPE "gicombiner-emitter"

llvm/utils/TableGen/GlobalISelEmitter.cpp

 /// FIXME: We'll probably want to eventually define a base
 /// "TargetGenInstructionSelector" class.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "CodeGenDAGPatterns.h"
 #include "SubtargetFeatureInfo.h"
 #include "llvm/ADT/Optional.h"
-#include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Support/CodeGenCoverage.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/LowLevelTypeImpl.h"
 #include "llvm/Support/MachineValueType.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include "llvm/TableGen/Error.h"
MatchTable &operator<<(MatchTable &Table, const MatchTableRecord &Value) {
   return Table;
 }
 
 //===- Matchers -----------------------------------------------------------===//
 
 class OperandMatcher;
 class MatchAction;
 class PredicateMatcher;
-class RuleMatcher;
 
 class Matcher {
 public:
   virtual ~Matcher() = default;
   virtual void optimize() {}
   virtual void emit(MatchTable &Table) = 0;
 
   virtual bool hasFirstCondition() const = 0;

llvm/utils/TableGen/InfoByHwMode.h

 #define LLVM_UTILS_TABLEGEN_INFOBYHWMODE_H
 
 #include "CodeGenHwModes.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/Support/MachineValueType.h"
 
 #include <map>
 #include <string>
-#include <vector>
 
 namespace llvm {
 
-struct CodeGenHwModes;
 class Record;
 class raw_ostream;
 
 template <typename InfoT> struct InfoByHwMode;
 
 std::string getModeName(unsigned Mode);
 
 enum : unsigned {

llvm/utils/TableGen/InfoByHwMode.cpp

 
 #include "CodeGenTarget.h"
 #include "InfoByHwMode.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 
-#include <set>
 #include <string>
 
 using namespace llvm;
 
 std::string llvm::getModeName(unsigned Mode) {
   if (Mode == DefaultMode)
     return "*";
   return (Twine('m') + Twine(Mode)).str();

llvm/utils/TableGen/IntrinsicEmitter.cpp

 #include "CodeGenIntrinsics.h"
 #include "CodeGenTarget.h"
 #include "SequenceToOffsetTable.h"
 #include "TableGenBackends.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Record.h"
-#include "llvm/TableGen/StringMatcher.h"
 #include "llvm/TableGen/StringToOffsetTable.h"
 #include "llvm/TableGen/TableGenBackend.h"
 #include <algorithm>
 using namespace llvm;
 
 cl::OptionCategory GenIntrinsicCat("Options for -gen-intrinsic-enums");
 cl::opt<std::string>
     IntrinsicPrefix("intrinsic-prefix",

llvm/utils/TableGen/OptParserEmitter.cpp

 //===- OptParserEmitter.cpp - Table Driven Command Line Parsing -----------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "OptEmitter.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/TableGen/Record.h"
 #include "llvm/TableGen/TableGenBackend.h"
-#include <cctype>
 #include <cstring>
 #include <map>
 #include <memory>
 
 using namespace llvm;
 
 static std::string getOptionName(const Record &R) {
   // Use the record name unless EnumName is defined.

llvm/utils/TableGen/OptRSTEmitter.cpp

 //===- OptParserEmitter.cpp - Table Driven Command Line Parsing -----------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "OptEmitter.h"
 #include "llvm/ADT/STLExtras.h"
-#include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringMap.h"
-#include "llvm/ADT/Twine.h"
-#include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Record.h"
-#include "llvm/TableGen/TableGenBackend.h"
-#include <cctype>
-#include <cstring>
-#include <map>
 
 using namespace llvm;
 
 /// OptParserEmitter - This tablegen backend takes an input .td file
 /// describing a list of options and emits a RST man page.
 namespace llvm {
 void EmitOptRST(RecordKeeper &Records, raw_ostream &OS) {
   llvm::StringMap<std::vector<Record *>> OptionsByGroup;

llvm/utils/TableGen/PredicateExpander.h

 /// of all the supported MCInstPredicate classes.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_UTILS_TABLEGEN_PREDICATEEXPANDER_H
 #define LLVM_UTILS_TABLEGEN_PREDICATEEXPANDER_H
 
 #include "llvm/ADT/StringRef.h"
-#include "llvm/Support/raw_ostream.h"
-#include "llvm/TableGen/Record.h"
+#include <vector>
 
 namespace llvm {
 
 class raw_ostream;
+class Record;
 
 class PredicateExpander {
   bool EmitCallsByRef;
   bool NegatePredicate;
   bool ExpandForMC;
   unsigned IndentLevel;
   StringRef TargetName;
 

llvm/utils/TableGen/RegisterBankEmitter.cpp

 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/BitVector.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Record.h"
 #include "llvm/TableGen/TableGenBackend.h"
 
-#include "CodeGenHwModes.h"
 #include "CodeGenRegisters.h"
 #include "CodeGenTarget.h"
 
 #define DEBUG_TYPE "register-bank-emitter"
 
 using namespace llvm;
 
 namespace {

llvm/utils/TableGen/SearchableTableEmitter.cpp

 // currently).
 //
 //===----------------------------------------------------------------------===//
 
 #include "CodeGenIntrinsics.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/StringExtras.h"
-#include "llvm/Support/Format.h"
-#include "llvm/Support/MemoryBuffer.h"
-#include "llvm/Support/SourceMgr.h"
 #include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Record.h"
 #include <algorithm>
 #include <set>
 #include <string>
 #include <vector>
 
 using namespace llvm;
 
 #define DEBUG_TYPE "searchable-table-emitter"
 
 namespace {
 
-struct GenericTable;
-
 int getAsInt(Init *B) {
   return cast<IntInit>(B->convertInitializerTo(IntRecTy::get()))->getValue();
 }
 int getInt(Record *R, StringRef Field) {
   return getAsInt(R->getValueInit(Field));
 }
 
 struct GenericEnum {

llvm/utils/TableGen/WebAssemblyDisassemblerEmitter.h

 //===- WebAssemblyDisassemblerEmitter.h - Disassembler tables ---*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is part of the WebAssembly Disassembler Emitter.
 // It contains the interface of the disassembler tables.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_UTILS_TABLEGEN_WEBASSEMBLYDISASSEMBLEREMITTER_H
 #define LLVM_UTILS_TABLEGEN_WEBASSEMBLYDISASSEMBLEREMITTER_H
 
-#include "CodeGenInstruction.h"
 #include "llvm/ADT/ArrayRef.h"
-#include "llvm/Support/raw_ostream.h"
 
 namespace llvm {
 
+class CodeGenInstruction;
+class raw_ostream;
+
 void emitWebAssemblyDisassemblerTables(
     raw_ostream &OS,
     const ArrayRef<const CodeGenInstruction *> &NumberedInstructions);
 
 } // namespace llvm
 
 #endif

llvm/utils/TableGen/WebAssemblyDisassemblerEmitter.cpp

 //===- WebAssemblyDisassemblerEmitter.cpp - Disassembler tables -*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is part of the WebAssembly Disassembler Emitter.
 // It contains the implementation of the disassembler tables.
 // Documentation for the disassembler emitter in general can be found in
 // WebAssemblyDisassemblerEmitter.h.
 //
 //===----------------------------------------------------------------------===//
 
 #include "WebAssemblyDisassemblerEmitter.h"
+#include "CodeGenInstruction.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/Support/raw_ostream.h"
 #include "llvm/TableGen/Record.h"
 
 namespace llvm {
 
 static constexpr int WebAssemblyInstructionTableSize = 256;
 
 void emitWebAssemblyDisassemblerTables(
     raw_ostream &OS,

llvm/utils/TableGen/X86DisassemblerTables.h

 //  X86DisassemblerEmitter.h.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_UTILS_TABLEGEN_X86DISASSEMBLERTABLES_H
 #define LLVM_UTILS_TABLEGEN_X86DISASSEMBLERTABLES_H
 
 #include "X86DisassemblerShared.h"
-#include "X86ModRMFilters.h"
-#include "llvm/Support/raw_ostream.h"
+#include "llvm/Support/X86DisassemblerDecoderCommon.h"
 #include <map>
+#include <memory>
 #include <vector>
 
 namespace llvm {
+class raw_ostream;
 
 namespace X86Disassembler {
 
+class ModRMFilter;
+
 /// DisassemblerTables - Encapsulates all the decode tables being generated by
 ///   the table emitter.  Contains functions to populate the tables as well as
 ///   to emit them as hierarchical C structures suitable for consumption by the
 ///   runtime.
 class DisassemblerTables {
 private:
   /// The decoder tables.  There is one for each opcode type:
   /// [0] one-byte opcodes

llvm/utils/TableGen/X86DisassemblerTables.cpp

 // It contains the implementation of the disassembler tables.
 // Documentation for the disassembler emitter in general can be found in
 //  X86DisassemblerEmitter.h.
 //
 //===----------------------------------------------------------------------===//
 
 #include "X86DisassemblerTables.h"
 #include "X86DisassemblerShared.h"
-#include "llvm/ADT/STLExtras.h"
+#include "X86ModRMFilters.h"
+#include "llvm/ADT/STLArrayExtras.h"
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Format.h"
+#include "llvm/Support/raw_ostream.h"
 #include <map>
 
 using namespace llvm;
 using namespace X86Disassembler;
 
 /// stringForContext - Returns a string containing the name of a particular
 ///   InstructionContext, usually for diagnostic purposes.
 ///

llvm/utils/TableGen/X86FoldTablesEmitter.cpp

struct ManualMapEntry {
   const char *MemInstStr;
   UnfoldStrategy Strategy;
 
   ManualMapEntry(const char *RegInstStr, const char *MemInstStr,
                  UnfoldStrategy Strategy = NO_STRATEGY)
       : RegInstStr(RegInstStr), MemInstStr(MemInstStr), Strategy(Strategy) {}
 };
 
-class IsMatch;
-
 // List of instructions requiring explicitly aligned memory.
 const char *ExplicitAlign[] = {"MOVDQA",  "MOVAPS",  "MOVAPD",  "MOVNTPS",
                                "MOVNTPD", "MOVNTDQ", "MOVNTDQA"};
 
 // List of instructions NOT requiring explicit memory alignment.
 const char *ExplicitUnalign[] = {"MOVDQU", "MOVUPS", "MOVUPD",
                                  "PCMPESTRM", "PCMPESTRI",
                                  "PCMPISTRM", "PCMPISTRI" };

llvm/utils/TableGen/X86RecognizableInstr.h

 // Documentation for the disassembler emitter in general can be found in
 //  X86DisassemblerEmitter.h.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_UTILS_TABLEGEN_X86RECOGNIZABLEINSTR_H
 #define LLVM_UTILS_TABLEGEN_X86RECOGNIZABLEINSTR_H
 
-#include "CodeGenTarget.h"
-#include "X86DisassemblerTables.h"
+#include "CodeGenInstruction.h"
 #include "llvm/Support/DataTypes.h"
-#include "llvm/TableGen/Record.h"
+#include "llvm/Support/X86DisassemblerDecoderCommon.h"
+
+struct InstructionSpecifier;
 
 namespace llvm {
 
+class Record;
+
 #define X86_INSTR_MRM_MAPPING     \
   MAP(C0, 64)                     \
   MAP(C1, 65)                     \
   MAP(C2, 66)                     \
   MAP(C3, 67)                     \
   MAP(C4, 68)                     \
   MAP(C5, 69)                     \
   MAP(C6, 70)                     \
#undef MAP
 
   enum {
     AdSize16 = 1, AdSize32 = 2, AdSize64 = 3
   };
 }
 
 namespace X86Disassembler {
 
+class DisassemblerTables;
+
 /// RecognizableInstr - Encapsulates all information required to decode a single
 ///   instruction, as extracted from the LLVM instruction tables.  Has methods
 ///   to interpret the information available in the LLVM tables, and to emit the
 ///   instruction into DisassemblerTables.
 class RecognizableInstr {
 private:
   /// The opcode of the instruction, as used in an MCInst
   InstrUID UID;

llvm/utils/TableGen/X86RecognizableInstr.cpp

 // It contains the implementation of a single recognizable instruction.
 // Documentation for the disassembler emitter in general can be found in
 //  X86DisassemblerEmitter.h.
 //
 //===----------------------------------------------------------------------===//
 
 #include "X86RecognizableInstr.h"
 #include "X86DisassemblerShared.h"
+#include "X86DisassemblerTables.h"
 #include "X86ModRMFilters.h"
 #include "llvm/Support/ErrorHandling.h"
+#include "llvm/TableGen/Record.h"
 #include <string>
 
 using namespace llvm;
 using namespace X86Disassembler;
 
 /// byteFromBitsInit - Extracts a value at most 8 bits in width from a BitsInit.
 ///   Useful for switch statements and the like.
 ///