[llvm-mca] Create subdirectories for various pieces of MCA. NFC.

[mattd]

Summary

The following patch introduces 4 subdirectories to store the logical bits of
MCA. The purpose is to reduce clutter in the root MCA directory, and to group
the sources representing the logical ideas behind MCA into their own
directories.

• Views - To store all of the views and views api.
• Stages - To store all of the stages and stages api.
• Components - To store all of the simulated hardware components.
• Utils - Other files that don't fit into the above categories.

I considered adding a statistics subdirectory, but since the various
*Statistics files can be thought of as extensions to the components they
account for, I figured I'd just keep them along side their associated
component.

tools/llvm-mca/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   AllTargetsAsmPrinters
   AllTargetsAsmParsers
   AllTargetsDescs
   AllTargetsDisassemblers
   AllTargetsInfos
   MC
+  MCAComponents
+  MCAStages
+  MCAUtils
+  MCAViews
   MCParser
   Support
   )
 
 add_llvm_tool(llvm-mca
-  Backend.cpp
-  BackendPrinter.cpp
-  CodeRegion.cpp
-  DispatchStage.cpp
-  DispatchStatistics.cpp
-  ExecuteStage.cpp
-  FetchStage.cpp
-  HWEventListener.cpp
-  InstrBuilder.cpp
-  Instruction.cpp
-  InstructionInfoView.cpp
-  InstructionTables.cpp
-  LSUnit.cpp
   llvm-mca.cpp
-  RegisterFile.cpp
-  RegisterFileStatistics.cpp
-  ResourcePressureView.cpp
-  RetireControlUnit.cpp
-  RetireControlUnitStatistics.cpp
-  RetireStage.cpp
-  Scheduler.cpp
-  SchedulerStatistics.cpp
-  Stage.cpp
-  Support.cpp
-  SummaryView.cpp
-  TimelineView.cpp
-  View.cpp
   )
+
+add_subdirectory(Components)
+add_subdirectory(Stages)
+add_subdirectory(Utils)
+add_subdirectory(Views)

tools/llvm-mca/Components/Backend.h

 ///
 /// This file implements an OoO backend for the llvm-mca tool.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_MCA_BACKEND_H
 #define LLVM_TOOLS_LLVM_MCA_BACKEND_H
 
-#include "DispatchStage.h"
-#include "ExecuteStage.h"
-#include "FetchStage.h"
-#include "InstrBuilder.h"
-#include "RegisterFile.h"
-#include "RetireControlUnit.h"
-#include "RetireStage.h"
-#include "Scheduler.h"
+#include "Components/RegisterFile.h"
+#include "Components/RetireControlUnit.h"
+#include "Components/Scheduler.h"
+#include "Stages/DispatchStage.h"
+#include "Stages/ExecuteStage.h"
+#include "Stages/FetchStage.h"
+#include "Stages/RetireStage.h"
+#include "Utils/InstrBuilder.h"
 
 namespace mca {
 
 class HWEventListener;
 class HWInstructionEvent;
 class HWStallEvent;
 
 /// An out of order backend for a specific subtarget.

tools/llvm-mca/Components/Backend.cpp

 //===--------------------- Backend.cpp --------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 /// \file
 ///
 /// Implementation of class Backend which emulates an hardware OoO backend.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "Backend.h"
-#include "FetchStage.h"
-#include "HWEventListener.h"
+#include "Stages/FetchStage.h"
+#include "Utils/HWEventListener.h"
 #include "llvm/CodeGen/TargetSchedule.h"
 #include "llvm/Support/Debug.h"
 
 namespace mca {
 
 #define DEBUG_TYPE "llvm-mca"
 
 using namespace llvm;

tools/llvm-mca/Components/BackendPrinter.h

 /// BackendPrinter allows the customization of the performance report.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_MCA_BACKENDPRINTER_H
 #define LLVM_TOOLS_LLVM_MCA_BACKENDPRINTER_H
 
 #include "Backend.h"
-#include "View.h"
+#include "Views/View.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/raw_ostream.h"
 
 #define DEBUG_TYPE "llvm-mca"
 
 namespace mca {
 
 /// A printer class that knows how to collects statistics on the

tools/llvm-mca/Components/BackendPrinter.cpp

 //===--------------------- BackendPrinter.cpp -------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 /// \file
 ///
 /// This file implements the BackendPrinter interface.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "BackendPrinter.h"
-#include "View.h"
 #include "llvm/CodeGen/TargetSchedule.h"
 
 namespace mca {
 
 using namespace llvm;
 
 void BackendPrinter::printReport(llvm::raw_ostream &OS) const {
   for (const auto &V : Views)
     V->printView(OS);
 }
 } // namespace mca.

tools/llvm-mca/Components/CMakeLists.txt

+include_directories( ${CMAKE_CURRENT_SOURCE_DIR}/.. )
+
+add_llvm_library(LLVMMCAComponents
+  Backend.cpp
+  BackendPrinter.cpp
+  Instruction.cpp
+  InstructionTables.cpp
+  LSUnit.cpp
+  RegisterFile.cpp
+  RegisterFileStatistics.cpp
+  RetireControlUnit.cpp
+  RetireControlUnitStatistics.cpp
+  Scheduler.cpp
+  SchedulerStatistics.cpp
+  )

tools/llvm-mca/Components/InstructionTables.h

 /// See the description of command-line flag -instruction-tables in
 /// docs/CommandGuide/lvm-mca.rst
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_MCA_INSTRUCTIONTABLES_H
 #define LLVM_TOOLS_LLVM_MCA_INSTRUCTIONTABLES_H
 
-#include "View.h"
-#include "InstrBuilder.h"
-#include "SourceMgr.h"
+#include "Utils/InstrBuilder.h"
+#include "Utils/SourceMgr.h"
+#include "Views/View.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/MC/MCSchedule.h"
 
 namespace mca {
 
 class InstructionTables {
   const llvm::MCSchedModel &SM;
   InstrBuilder &IB;

tools/llvm-mca/Components/RegisterFileStatistics.h

 ///    Total number of mappings created: 6
 ///    Max number of mappings used:      3
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_MCA_REGISTERFILESTATISTICS_H
 #define LLVM_TOOLS_LLVM_MCA_REGISTERFILESTATISTICS_H
 
-#include "View.h"
+#include "Views/View.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 
 namespace mca {
 
 class RegisterFileStatistics : public View {
   const llvm::MCSubtargetInfo &STI;
 

tools/llvm-mca/Components/RetireControlUnit.cpp

 //===---------------------- RetireControlUnit.cpp ---------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 /// \file
 ///
 /// This file simulates the hardware responsible for retiring instructions.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "RetireControlUnit.h"
-#include "DispatchStage.h"
 #include "llvm/Support/Debug.h"
 
 using namespace llvm;
 
 #define DEBUG_TYPE "llvm-mca"
 
 namespace mca {
 

tools/llvm-mca/Components/RetireControlUnitStatistics.h

 ///  2,           1  (0.8%)
 ///  4,           3  (2.3%)
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_MCA_RETIRECONTROLUNITSTATISTICS_H
 #define LLVM_TOOLS_LLVM_MCA_RETIRECONTROLUNITSTATISTICS_H
 
-#include "View.h"
+#include "Views/View.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 
 namespace mca {
 
 class RetireControlUnitStatistics : public View {
   using Histogram = llvm::DenseMap<unsigned, unsigned>;
   Histogram RetiredPerCycle;

tools/llvm-mca/Components/Scheduler.h

 ///
 /// A scheduler for Processor Resource Units and Processor Resource Groups.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_MCA_SCHEDULER_H
 #define LLVM_TOOLS_LLVM_MCA_SCHEDULER_H
 
-#include "HWEventListener.h"
 #include "Instruction.h"
 #include "LSUnit.h"
 #include "RetireControlUnit.h"
+#include "Utils/HWEventListener.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include <map>
 
 namespace mca {
 

tools/llvm-mca/Components/Scheduler.cpp

 //===--------------------- Scheduler.cpp ------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // A scheduler for processor resource units and processor resource groups.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Scheduler.h"
 #include "Backend.h"
-#include "HWEventListener.h"
-#include "Support.h"
+#include "Utils/HWEventListener.h"
+#include "Utils/Support.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace mca {
 
 using namespace llvm;
 
 uint64_t ResourceState::selectNextInSequence() {
   assert(isReady());

tools/llvm-mca/Components/SchedulerStatistics.h

 /// JFPU01,  18/18
 /// JLSAGU,  0/12
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_MCA_SCHEDULERSTATISTICS_H
 #define LLVM_TOOLS_LLVM_MCA_SCHEDULERSTATISTICS_H
 
-#include "View.h"
-#include "llvm/ADT/SmallVector.h"
+#include "Views/View.h"
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 
 namespace mca {
 
 class SchedulerStatistics : public View {
   const llvm::MCSchedModel &SM;
 
   using Histogram = llvm::DenseMap<unsigned, unsigned>;

tools/llvm-mca/Stages/CMakeLists.txt

+include_directories( ${CMAKE_CURRENT_SOURCE_DIR}/.. )
+
+add_llvm_library(LLVMMCAStages
+  DispatchStage.cpp
+  DispatchStatistics.cpp
+  ExecuteStage.cpp
+  FetchStage.cpp
+  RetireStage.cpp
+  Stage.cpp
+  )

tools/llvm-mca/Stages/DispatchStage.h

 /// and communicating to the simulated instruction scheduler that an instruction
 /// is ready to be scheduled for execution.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_MCA_DISPATCH_STAGE_H
 #define LLVM_TOOLS_LLVM_MCA_DISPATCH_STAGE_H
 
-#include "Instruction.h"
-#include "RegisterFile.h"
-#include "RetireControlUnit.h"
+#include "Components/Instruction.h"
+#include "Components/RegisterFile.h"
+#include "Components/RetireControlUnit.h"
 #include "Stage.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 
 namespace mca {
 
 class WriteState;
 class Scheduler;

tools/llvm-mca/Stages/DispatchStage.cpp

 ///
 /// The DispatchStage is responsible for updating instruction dependencies
 /// and communicating to the simulated instruction scheduler that an instruction
 /// is ready to be scheduled for execution.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "DispatchStage.h"
-#include "Backend.h"
-#include "HWEventListener.h"
-#include "Scheduler.h"
+#include "Components/Backend.h"
+#include "Components/Scheduler.h"
+#include "Utils/HWEventListener.h"
 #include "llvm/Support/Debug.h"
 
 using namespace llvm;
 
 #define DEBUG_TYPE "llvm-mca"
 
 namespace mca {
 

tools/llvm-mca/Stages/DispatchStatistics.h

 ///  0,              15  (11.5%)
 ///  2,              4  (3.1%)
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_MCA_DISPATCHVIEW_H
 #define LLVM_TOOLS_LLVM_MCA_DISPATCHVIEW_H
 
-#include "View.h"
+#include "Views/View.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 
 namespace mca {
 
 class DispatchStatistics : public View {
   unsigned NumDispatched;

tools/llvm-mca/Stages/ExecuteStage.h

 /// The ExecuteStage is responsible for managing the hardware scheduler
 /// and issuing notifications that an instruction has been executed.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_MCA_EXECUTE_STAGE_H
 #define LLVM_TOOLS_LLVM_MCA_EXECUTE_STAGE_H
 
-#include "Instruction.h"
-#include "RetireControlUnit.h"
-#include "Scheduler.h"
+#include "Components/Instruction.h"
+#include "Components/RetireControlUnit.h"
+#include "Components/Scheduler.h"
 #include "Stage.h"
 #include "llvm/ADT/ArrayRef.h"
 
 namespace mca {
 
 class Backend;
 
 class ExecuteStage : public Stage {

tools/llvm-mca/Stages/ExecuteStage.cpp

 /// This file defines the execution stage of an instruction pipeline.
 ///
 /// The ExecuteStage is responsible for managing the hardware scheduler
 /// and issuing notifications that an instruction has been executed.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "ExecuteStage.h"
-#include "Backend.h"
-#include "Scheduler.h"
+#include "Components/Backend.h"
+#include "Components/Scheduler.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/Debug.h"
 
 #define DEBUG_TYPE "llvm-mca"
 
 namespace mca {
 
 using namespace llvm;

tools/llvm-mca/Stages/FetchStage.h

 /// This file defines the Fetch stage of an instruction pipeline.  Its sole
 /// purpose in life is to produce instructions for the rest of the pipeline.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_MCA_FETCH_STAGE_H
 #define LLVM_TOOLS_LLVM_MCA_FETCH_STAGE_H
 
-#include "InstrBuilder.h"
-#include "SourceMgr.h"
 #include "Stage.h"
+#include "Utils/InstrBuilder.h"
+#include "Utils/SourceMgr.h"
 #include <map>
 
 namespace mca {
 
 class FetchStage : public Stage {
   using InstMap = std::map<unsigned, std::unique_ptr<Instruction>>;
   InstMap Instructions;
   InstrBuilder &IB;

tools/llvm-mca/Stages/RetireStage.h

 /// The RetireStage represents the process logic that interacts with the
 /// simulated RetireControlUnit hardware.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_MCA_RETIRE_STAGE_H
 #define LLVM_TOOLS_LLVM_MCA_RETIRE_STAGE_H
 
-#include "RegisterFile.h"
-#include "RetireControlUnit.h"
+#include "Components/RegisterFile.h"
+#include "Components/RetireControlUnit.h"
 #include "Stage.h"
 
 namespace mca {
 
 class Backend;
 
 class RetireStage : public Stage {
   // Owner will go away when we move listeners/eventing to the stages.

tools/llvm-mca/Stages/RetireStage.cpp

 ///
 /// This file defines the retire stage of an instruction pipeline.
 /// The RetireStage represents the process logic that interacts with the
 /// simulated RetireControlUnit hardware.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "RetireStage.h"
-#include "Backend.h"
-#include "HWEventListener.h"
+#include "Components/Backend.h"
+#include "Utils/HWEventListener.h"
 #include "llvm/Support/Debug.h"
 
 using namespace llvm;
 
 #define DEBUG_TYPE "llvm-mca"
 
 namespace mca {
 

tools/llvm-mca/Utils/CMakeLists.txt

+include_directories( ${CMAKE_CURRENT_SOURCE_DIR}/.. )
+
+add_llvm_library(LLVMMCAUtils
+  CodeRegion.cpp
+  CodeRegion.h
+  HWEventListener.cpp
+  InstrBuilder.cpp
+  Support.cpp
+  )

tools/llvm-mca/Utils/HWEventListener.h

 ///
 /// This file defines the main interface for hardware event listeners.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_MCA_HWEVENTLISTENER_H
 #define LLVM_TOOLS_LLVM_MCA_HWEVENTLISTENER_H
 
-#include "Instruction.h"
+#include "Components/Instruction.h"
 #include "llvm/ADT/ArrayRef.h"
 #include <utility>
 
 namespace mca {
 
 // An HWInstructionEvent represents state changes of instructions that
 // listeners might be interested in. Listeners can choose to ignore any event
 // they are not interested in.

tools/llvm-mca/Utils/InstrBuilder.h

 ///
 /// A builder class for instructions that are statically analyzed by llvm-mca.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_MCA_INSTRBUILDER_H
 #define LLVM_TOOLS_LLVM_MCA_INSTRBUILDER_H
 
-#include "Instruction.h"
+#include "Components/Instruction.h"
 #include "Support.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 
 namespace mca {
 
 class DispatchUnit;
 

tools/llvm-mca/Views/CMakeLists.txt

+include_directories( ${CMAKE_CURRENT_SOURCE_DIR}/.. )
+
+add_llvm_library(LLVMMCAViews
+  InstructionInfoView.cpp
+  ResourcePressureView.cpp
+  SummaryView.cpp
+  TimelineView.cpp
+  View.cpp
+  )

tools/llvm-mca/Views/InstructionInfoView.h

 ///  1      3     1.00                      vhaddps %xmm2, %xmm2, %xmm3
 ///  1      3     1.00                      vhaddps %xmm3, %xmm3, %xmm4
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_MCA_INSTRUCTIONINFOVIEW_H
 #define LLVM_TOOLS_LLVM_MCA_INSTRUCTIONINFOVIEW_H
 
-#include "SourceMgr.h"
+#include "Utils/SourceMgr.h"
 #include "View.h"
 #include "llvm/MC/MCInstPrinter.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/Support/raw_ostream.h"
 
 #define DEBUG_TYPE "llvm-mca"
 

tools/llvm-mca/Views/ResourcePressureView.h

 /// per iteration. Consequently, the resource pressure on JFPU0 is of 2cy per
 /// iteration.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_MCA_RESOURCEPRESSUREVIEW_H
 #define LLVM_TOOLS_LLVM_MCA_RESOURCEPRESSUREVIEW_H
 
-#include "SourceMgr.h"
+#include "Utils/SourceMgr.h"
 #include "View.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/MC/MCInstPrinter.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include <map>
 
 namespace mca {
 

tools/llvm-mca/Views/SummaryView.h

 /// The summary view collects a few performance numbers. The two main
 /// performance indicators are 'Total Cycles' and IPC (Instructions Per Cycle).
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_MCA_SUMMARYVIEW_H
 #define LLVM_TOOLS_LLVM_MCA_SUMMARYVIEW_H
 
-#include "SourceMgr.h"
+#include "Utils/SourceMgr.h"
 #include "View.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/MC/MCSchedule.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace mca {
 
 /// A view that collects and prints a few performance numbers.

tools/llvm-mca/Views/SummaryView.cpp

 //===--------------------- SummaryView.cpp -------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 /// \file
 ///
 /// This file implements the functionalities used by the SummaryView to print
 /// the report information.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "SummaryView.h"
-#include "Support.h"
+#include "Utils/Support.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/Format.h"
 
 namespace mca {
 
 #define DEBUG_TYPE "llvm-mca"
 
 using namespace llvm;

tools/llvm-mca/Views/TimelineView.h

 /// That is expected because instruction 5 cannot transition to the "ready"
 /// state until %xmm4 is written by instruction 4.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_MCA_TIMELINEVIEW_H
 #define LLVM_TOOLS_LLVM_MCA_TIMELINEVIEW_H
 
-#include "SourceMgr.h"
+#include "Utils/SourceMgr.h"
 #include "View.h"
 #include "llvm/MC/MCInstPrinter.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/Support/FormattedStream.h"
 #include "llvm/Support/raw_ostream.h"
 #include <map>
 
 namespace mca {

tools/llvm-mca/Views/View.h

 /// This file defines the main interface for Views. Each view contributes a
 /// portion of the final report generated by the tool.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_MCA_VIEW_H
 #define LLVM_TOOLS_LLVM_MCA_VIEW_H
 
-#include "HWEventListener.h"
+#include "Utils/HWEventListener.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace mca {
 
 class View : public HWEventListener {
 public:
   virtual void printView(llvm::raw_ostream &OS) const = 0;
   virtual ~View() = default;
   void anchor() override;
 };
 } // namespace mca
 
 #endif

tools/llvm-mca/llvm-mca.cpp

 //      -o <file>
 //
 // The target defaults to the host target.
 // The cpu defaults to the 'native' host cpu.
 // The output defaults to standard output.
 //
 //===----------------------------------------------------------------------===//
 
-#include "BackendPrinter.h"
-#include "CodeRegion.h"
-#include "DispatchStatistics.h"
-#include "FetchStage.h"
-#include "InstructionInfoView.h"
-#include "InstructionTables.h"
-#include "RegisterFileStatistics.h"
-#include "ResourcePressureView.h"
-#include "RetireControlUnitStatistics.h"
-#include "SchedulerStatistics.h"
-#include "SummaryView.h"
-#include "TimelineView.h"
+#include "Components/BackendPrinter.h"
+#include "Components/InstructionTables.h"
+#include "Components/RegisterFileStatistics.h"
+#include "Components/RetireControlUnitStatistics.h"
+#include "Components/SchedulerStatistics.h"
+#include "Stages/DispatchStatistics.h"
+#include "Stages/FetchStage.h"
+#include "Utils/CodeRegion.h"
+#include "Views/InstructionInfoView.h"
+#include "Views/ResourcePressureView.h"
+#include "Views/SummaryView.h"
+#include "Views/TimelineView.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/MC/MCParser/MCTargetAsmParser.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ErrorOr.h"