[llvm-exegesis][NFC] Move CodeTemplate to it's own file.

[gchatelet]

Summary

This is is preparation of exploring value ranges.

[gchatelet]

• Add missing header in cpp file

llvm/trunk/tools/llvm-exegesis/lib/CMakeLists.txt

 
 add_library(LLVMExegesis
   STATIC
   Analysis.cpp
   Assembler.cpp
   BenchmarkResult.cpp
   BenchmarkRunner.cpp
   Clustering.cpp
+  CodeTemplate.cpp
   Latency.cpp
   LlvmState.cpp
   MCInstrDescView.cpp
   PerfHelper.cpp
   RegisterAliasing.cpp
   SnippetGenerator.cpp
   RegisterValue.cpp
   Target.cpp

llvm/trunk/tools/llvm-exegesis/lib/CodeTemplate.h

+//===-- CodeTemplate.h ------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// A CodeTemplate is a set of InstructionBuilders that may not be fully
+/// specified (i.e. some variables are not yet set). This allows the
+/// BenchmarkRunner to instantiate it many times with specific values to study
+/// their impact on instruction's performance.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TOOLS_LLVM_EXEGESIS_CODETEMPLATE_H
+#define LLVM_TOOLS_LLVM_EXEGESIS_CODETEMPLATE_H
+
+#include "MCInstrDescView.h"
+
+namespace exegesis {
+
+struct CodeTemplate {
+  CodeTemplate() = default;
+
+  CodeTemplate(CodeTemplate &&);            // default
+  CodeTemplate &operator=(CodeTemplate &&); // default
+  CodeTemplate(const CodeTemplate &) = delete;
+  CodeTemplate &operator=(const CodeTemplate &) = delete;
+
+  // Some information about how this template has been created.
+  std::string Info;
+  // The list of the instructions for this template.
+  std::vector<InstructionBuilder> Instructions;
+  // If the template uses the provided scratch memory, the register in which
+  // the pointer to this memory is passed in to the function.
+  unsigned ScratchSpacePointerInReg = 0;
+};
+
+} // namespace exegesis
+
+#endif // LLVM_TOOLS_LLVM_EXEGESIS_CODETEMPLATE_H

llvm/trunk/tools/llvm-exegesis/lib/CodeTemplate.cpp

+//===-- CodeTemplate.cpp ----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "CodeTemplate.h"
+
+namespace exegesis {
+
+CodeTemplate::CodeTemplate(CodeTemplate &&) = default;
+
+CodeTemplate &CodeTemplate::operator=(CodeTemplate &&) = default;
+
+} // namespace exegesis

llvm/trunk/tools/llvm-exegesis/lib/MCInstrDescView.h

struct InstructionBuilder {
   // the corresponding variable values.
   // Precondition: All VariableValues must be set.
   llvm::MCInst build() const;
 
   Instruction Instr;
   llvm::SmallVector<llvm::MCOperand, 4> VariableValues;
 };
 
-// A CodeTemplate is a set of InstructionBuilders that may not be fully
-// specified (i.e. some variables are not yet set).
-// This allows the BenchmarkRunner to instantiate it many times with specific
-// values to study their impact on instruction's performance.
-struct CodeTemplate {
-  CodeTemplate() = default;
-
-  CodeTemplate(CodeTemplate &&);            // default
-  CodeTemplate &operator=(CodeTemplate &&); // default
-  CodeTemplate(const CodeTemplate &) = delete;
-  CodeTemplate &operator=(const CodeTemplate &) = delete;
-
-  // Some information about how this template has been created.
-  std::string Info;
-  // The list of the instructions for this template.
-  std::vector<InstructionBuilder> Instructions;
-  // If the template uses the provided scratch memory, the register in which
-  // the pointer to this memory is passed in to the function.
-  unsigned ScratchSpacePointerInReg = 0;
-};
-
 // Represents the assignment of a Register to an Operand.
 struct RegisterOperandAssignment {
   RegisterOperandAssignment(const Operand *Operand, llvm::MCPhysReg Reg)
       : Op(Operand), Reg(Reg) {}
 
   const Operand *Op; // Pointer to an Explicit Register Operand.
   llvm::MCPhysReg Reg;
 

llvm/trunk/tools/llvm-exegesis/lib/MCInstrDescView.cpp

llvm::MCInst InstructionBuilder::build() const {
   llvm::MCInst Result;
   Result.setOpcode(Instr.Description->Opcode);
   for (const auto &Op : Instr.Operands)
     if (Op.IsExplicit)
       Result.addOperand(getValueFor(Op));
   return Result;
 }
 
-CodeTemplate::CodeTemplate(CodeTemplate &&) = default;
-
-CodeTemplate &CodeTemplate::operator=(CodeTemplate &&) = default;
-
 bool RegisterOperandAssignment::
 operator==(const RegisterOperandAssignment &Other) const {
   return std::tie(Op, Reg) == std::tie(Other.Op, Other.Reg);
 }
 
 bool AliasingRegisterOperands::
 operator==(const AliasingRegisterOperands &Other) const {
   return std::tie(Defs, Uses) == std::tie(Other.Defs, Other.Uses);

llvm/trunk/tools/llvm-exegesis/lib/SnippetGenerator.h

 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_EXEGESIS_SNIPPETGENERATOR_H
 #define LLVM_TOOLS_LLVM_EXEGESIS_SNIPPETGENERATOR_H
 
 #include "Assembler.h"
 #include "BenchmarkCode.h"
+#include "CodeTemplate.h"
 #include "LlvmState.h"
 #include "MCInstrDescView.h"
 #include "RegisterAliasing.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/Support/Error.h"
 #include <cstdlib>
 #include <memory>
 #include <vector>