[tools] Forward declare classes & remove includes

[clemenswasser]

Summary

llvm/Support/Error.h and llvm/ADT/ArrayRef.h were identified as quiet heavy by clang build analyzer.
Removing includes and forward declaring the relevant classes saves compilation time

[clemenswasser]

Rebase patch

[clemenswasser]

Fix Patch

[clemenswasser]

Update Patch. I reformatted but diffed the wrong commit hash, sorry :(

[JDevlieghere]

The dsymutil part LGTM

[MaskRay]

LGTM.

[MaskRay]

llvm/tools/llvm-reduce/TestRunner.h

12

This needs to be retained. I'll fix it.

llvm/tools/dsymutil/Reproducer.h

 //===- tools/dsymutil/Reproducer.h ------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_DSYMUTIL_REPRODUCER_H
 #define LLVM_TOOLS_DSYMUTIL_REPRODUCER_H
 
-#include "llvm/Support/Error.h"
 #include "llvm/Support/FileCollector.h"
 #include "llvm/Support/VirtualFileSystem.h"
 
 namespace llvm {
 namespace dsymutil {
 
 /// The reproducer mode.
 enum class ReproducerMode {

llvm/tools/llvm-exegesis/lib/PerfHelper.h

 //===-- PerfHelper.h ------------------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// Helpers for measuring perf events.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_EXEGESIS_PERFHELPER_H
 #define LLVM_TOOLS_LLVM_EXEGESIS_PERFHELPER_H
 
-#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Config/config.h"
 #include "llvm/Support/Error.h"
 
 #include <cstdint>
 #include <functional>
 #include <memory>

llvm/tools/llvm-ifs/ErrorCollector.h

 /// delete the ErrorCollector when some Errors have not been retrieved via
 /// makeError().
 ///
 //===-----------------------------------------------------------------------===/
 
 #ifndef LLVM_TOOLS_LLVM_IFS_ERRORCOLLECTOR_H
 #define LLVM_TOOLS_LLVM_IFS_ERRORCOLLECTOR_H
 
-#include "llvm/Support/Error.h"
+#include "llvm/Support/raw_ostream.h"
 #include <vector>
 
 namespace llvm {
+
+class Error;
+
 namespace ifs {
 
 class ErrorCollector {
 public:
   /// Upon destruction, an ErrorCollector will crash if UseFatalErrors=true and
   /// there are remaining errors that haven't been fetched by makeError().
   ErrorCollector(bool UseFatalErrors = true) : ErrorsAreFatal(UseFatalErrors) {}
   // Don't allow copying.

llvm/tools/llvm-mca/Views/InstructionView.h

 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_MCA_INSTRUCTIONVIEW_H
 #define LLVM_TOOLS_LLVM_MCA_INSTRUCTIONVIEW_H
 
 #include "llvm/MCA/View.h"
 #include "llvm/Support/JSON.h"
-#include "llvm/Support/raw_ostream.h"
 
 namespace llvm {
+class MCInstPrinter;
+
 namespace mca {
 
 // The base class for views that deal with individual machine instructions.
 class InstructionView : public View {
   const llvm::MCSubtargetInfo &STI;
   llvm::MCInstPrinter &MCIP;
   llvm::ArrayRef<llvm::MCInst> Source;
 

llvm/tools/llvm-pdbutil/LinePrinter.h

 //===- LinePrinter.h ------------------------------------------ *- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVMPDBDUMP_LINEPRINTER_H
 #define LLVM_TOOLS_LLVMPDBDUMP_LINEPRINTER_H
 
-#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/BinaryStreamRef.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/Regex.h"
 #include "llvm/Support/raw_ostream.h"
 
 #include <list>

llvm/tools/llvm-pdbutil/OutputStyle.h

 //===- OutputStyle.h ------------------------------------------ *- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVMPDBDUMP_OUTPUTSTYLE_H
 #define LLVM_TOOLS_LLVMPDBDUMP_OUTPUTSTYLE_H
 
-#include "llvm/Support/Error.h"
-
 namespace llvm {
+
+class Error;
+
 namespace pdb {
 
 class OutputStyle {
 public:
   virtual ~OutputStyle() {}
 
   virtual Error dump() = 0;
 };
 }
 }
 
 #endif

llvm/tools/llvm-reduce/DeltaManager.cpp

 //===- DeltaManager.cpp - Runs Delta Passes to reduce Input ---------------===//
 //
 // 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 calls each specialized Delta pass in order to reduce the input IR
 // file.
 //
 //===----------------------------------------------------------------------===//
 
 #include "DeltaManager.h"
+#include "ReducerWorkItem.h"
 #include "TestRunner.h"
 #include "deltas/Delta.h"
 #include "deltas/ReduceAliases.h"
 #include "deltas/ReduceArguments.h"
 #include "deltas/ReduceAttributes.h"
 #include "deltas/ReduceBasicBlocks.h"
 #include "deltas/ReduceFunctionBodies.h"
 #include "deltas/ReduceFunctions.h"

llvm/tools/llvm-reduce/ReducerWorkItem.h

 //===- ReducerWorkItem.h - Wrapper for Module and MachineFunction ---------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_REDUCE_REDUCERWORKITEM_H
 #define LLVM_TOOLS_LLVM_REDUCE_REDUCERWORKITEM_H
 
-#include "llvm/CodeGen/MachineFunction.h"
-#include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/IR/Module.h"
 
+namespace llvm {
+class MachineFunction;
+class MachineModuleInfo;
+} // namespace llvm
+
 using namespace llvm;
 
 class ReducerWorkItem {
 public:
   std::shared_ptr<Module> M;
   std::unique_ptr<MachineFunction> MF;
   void print(raw_ostream &ROS, void *p = nullptr) const;
   bool isMIR() { return MF != nullptr; }

llvm/tools/llvm-reduce/ReducerWorkItem.cpp

 //===- ReducerWorkItem.cpp - Wrapper for Module and MachineFunction -------===//
 //
 // 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 "ReducerWorkItem.h"
 #include "llvm/CodeGen/MIRParser/MIRParser.h"
 #include "llvm/CodeGen/MIRPrinter.h"
 #include "llvm/CodeGen/MachineDominators.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
+#include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/CodeGen/MachineRegisterInfo.h"
 #include "llvm/CodeGen/TargetInstrInfo.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/IRReader/IRReader.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Transforms/Utils/Cloning.h"
 
 static std::unique_ptr<MachineFunction> cloneMF(MachineFunction *SrcMF) {

llvm/tools/llvm-reduce/TestRunner.h

 //===-- tools/llvm-reduce/TestRunner.h ---------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_REDUCE_TESTRUNNER_H
 #define LLVM_TOOLS_LLVM_REDUCE_TESTRUNNER_H
 
-#include "ReducerWorkItem.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Program.h"
 #include <vector>
 
+class ReducerWorkItem;
+
 namespace llvm {
 
 // This class contains all the info necessary for running the provided
 // interesting-ness test, as well as the most reduced module and its
 // respective filename.
 class TestRunner {
 public:
   TestRunner(StringRef TestName, const std::vector<std::string> &TestArgs,
              std::unique_ptr<ReducerWorkItem> Program);
 
   /// Runs the interesting-ness test for the specified file
   /// @returns 0 if test was successful, 1 if otherwise
   int run(StringRef Filename);
 
   /// Returns the most reduced version of the original testcase
   ReducerWorkItem &getProgram() const { return *Program; }
 
-  void setProgram(std::unique_ptr<ReducerWorkItem> P) {
-    assert(P && "Setting null program?");
-    Program = std::move(P);
-  }
+  void setProgram(std::unique_ptr<ReducerWorkItem> P);
 
 private:
   StringRef TestName;
   const std::vector<std::string> &TestArgs;
   std::unique_ptr<ReducerWorkItem> Program;
 };
 
 } // namespace llvm
 
 #endif

llvm/tools/llvm-reduce/TestRunner.cpp

 //===-- TestRunner.cpp ----------------------------------------------------===//
 //
 // 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 "TestRunner.h"
+#include "ReducerWorkItem.h"
+#include "llvm/CodeGen/MachineFunction.h"
 
 using namespace llvm;
 
 TestRunner::TestRunner(StringRef TestName,
                        const std::vector<std::string> &TestArgs,
                        std::unique_ptr<ReducerWorkItem> Program)
     : TestName(TestName), TestArgs(TestArgs), Program(std::move(Program)) {
   assert(this->Program && "Initialized with null program?");
Error E = make_error<StringError>("Error running interesting-ness test: " +
                                           ErrMsg,
                                       inconvertibleErrorCode());
     errs() << toString(std::move(E));
     exit(1);
   }
 
   return !Result;
 }
+
+void TestRunner::setProgram(std::unique_ptr<ReducerWorkItem> P) {
+  assert(P && "Setting null program?");
+  Program = std::move(P);
+}

llvm/tools/llvm-reduce/deltas/Delta.h

 #include "TestRunner.h"
 #include "llvm/ADT/ScopeExit.h"
 #include <functional>
 #include <utility>
 #include <vector>
 
 namespace llvm {
 
+class MachineFunction;
+
 struct Chunk {
   int Begin;
   int End;
 
   /// Helper function to verify if a given Target-index is inside the Chunk
   bool contains(int Index) const { return Index >= Begin && Index <= End; }
 
   void print() const {

llvm/tools/llvm-reduce/deltas/Delta.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "Delta.h"
 #include "ReducerWorkItem.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Bitcode/BitcodeReader.h"
 #include "llvm/Bitcode/BitcodeWriter.h"
+#include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ThreadPool.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include <fstream>
 #include <set>
 
 using namespace llvm;

llvm/tools/llvm-reduce/deltas/ReduceInstructionsMIR.cpp

 //===- ReduceInstructionsMIR.cpp - Specialized Delta Pass -----------------===//
 //
 // 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 implements a function which calls the Generic Delta pass in order
 // to reduce uninteresting MachineInstr from the MachineFunction.
 //
 //===----------------------------------------------------------------------===//
 
 #include "ReduceInstructionsMIR.h"
 
+#include "llvm/ADT/SetVector.h"
 #include "llvm/CodeGen/MachineDominators.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
 #include "llvm/CodeGen/MachineRegisterInfo.h"
 #include "llvm/CodeGen/TargetInstrInfo.h"
 
 using namespace llvm;
 

llvm/tools/llvm-reduce/llvm-reduce.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "DeltaManager.h"
 #include "ReducerWorkItem.h"
 #include "TestRunner.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/CodeGen/CommandFlags.h"
+#include "llvm/CodeGen/MachineFunction.h"
+#include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/IRReader/IRReader.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/TargetSelect.h"
-#include "llvm/Support/raw_ostream.h"
 #include "llvm/Support/WithColor.h"
+#include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetMachine.h"
 #include <system_error>
 #include <vector>
 
 using namespace llvm;
 
 cl::OptionCategory LLVMReduceOptions("llvm-reduce options");
 

llvm/tools/opt/NewPMDriver.h

 /// file. Eventually all of the routines here will get folded back into
 /// opt.cpp.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_OPT_NEWPMDRIVER_H
 #define LLVM_TOOLS_OPT_NEWPMDRIVER_H
 
-#include "llvm/ADT/ArrayRef.h"
 #include "llvm/Support/CommandLine.h"
 
 namespace llvm {
 class StringRef;
 class Module;
 class TargetMachine;
 class ToolOutputFile;
 class TargetLibraryInfoImpl;