[llvm-exegesis] Move namespace exegesis inside llvm::

[MaskRay]

Summary

This allows simplifying references of llvm::foo with foo when the needs
come in the future.

[gchatelet]

Nice ! Thx a lot :)

llvm/trunk/tools/llvm-exegesis/lib/AArch64/Target.cpp

 //===-- Target.cpp ----------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 #include "../Target.h"
 #include "../Latency.h"
 #include "AArch64.h"
 #include "AArch64RegisterInfo.h"
 
+namespace llvm {
 namespace exegesis {
 
 namespace {
 
 class AArch64LatencyBenchmarkRunner : public LatencyBenchmarkRunner {
 public:
   AArch64LatencyBenchmarkRunner(const LLVMState &State)
       : LatencyBenchmarkRunner(State) {}
static ExegesisTarget *getTheExegesisAArch64Target() {
   return &Target;
 }
 
 void InitializeAArch64ExegesisTarget() {
   ExegesisTarget::registerTarget(getTheExegesisAArch64Target());
 }
 
 } // namespace exegesis
+} // namespace llvm

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

 #include "llvm/Support/Error.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/raw_ostream.h"
 #include <memory>
 #include <set>
 #include <string>
 #include <unordered_map>
 
+namespace llvm {
 namespace exegesis {
 
 // A helper class to analyze benchmark results for a target.
 class Analysis {
 public:
   Analysis(const llvm::Target &Target,
            const InstructionBenchmarkClustering &Clustering);
 

 // Computes the idealized ProcRes Unit pressure. This is the expected
 // distribution if the CPU scheduler can distribute the load as evenly as
 // possible.
 std::vector<std::pair<uint16_t, float>> computeIdealizedProcResPressure(
     const llvm::MCSchedModel &SM,
     llvm::SmallVector<llvm::MCWriteProcResEntry, 8> WPRS);
 
 } // namespace exegesis
+} // namespace llvm
 
 #endif // LLVM_TOOLS_LLVM_EXEGESIS_CLUSTERING_H

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

 #include "Analysis.h"
 #include "BenchmarkResult.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/Support/FormatVariadic.h"
 #include <unordered_set>
 #include <vector>
 
+namespace llvm {
 namespace exegesis {
 
 static const char kCsvSep = ',';
 
 static unsigned resolveSchedClassId(const llvm::MCSubtargetInfo &STI,
                                     unsigned SchedClassId,
                                     const llvm::MCInst &MCI) {
   const auto &SM = STI.getSchedModel();
std::vector<std::pair<uint16_t, float>> computeIdealizedProcResPressure(
   for (unsigned I = 0, E = SM.getNumProcResourceKinds(); I < E; ++I) {
     if (DensePressure[I] > 0.0f)
       Pressure.emplace_back(I, DensePressure[I]);
   }
   return Pressure;
 }
 
 } // namespace exegesis
+} // namespace llvm

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

 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/Object/Binary.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetMachine.h"
 
+namespace llvm {
 namespace exegesis {
 
 class ExegesisTarget;
 
 // Gather the set of reserved registers (depends on function's calling
 // convention and target machine).
 llvm::BitVector getFunctionReservedRegs(const llvm::TargetMachine &TM);
 
struct ExecutableFunction {
   }
 
   std::unique_ptr<llvm::LLVMContext> Context;
   std::unique_ptr<llvm::ExecutionEngine> ExecEngine;
   llvm::StringRef FunctionBytes;
 };
 
 } // namespace exegesis
+} // namespace llvm
 
 #endif // LLVM_TOOLS_LLVM_EXEGESIS_ASSEMBLER_H

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

 #include "llvm/CodeGen/TargetInstrInfo.h"
 #include "llvm/CodeGen/TargetPassConfig.h"
 #include "llvm/CodeGen/TargetSubtargetInfo.h"
 #include "llvm/ExecutionEngine/SectionMemoryManager.h"
 #include "llvm/IR/LegacyPassManager.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/Support/MemoryBuffer.h"
 
+namespace llvm {
 namespace exegesis {
 
 static constexpr const char ModuleID[] = "ExegesisInfoTest";
 static constexpr const char FunctionID[] = "foo";
 
 static std::vector<llvm::MCInst>
 generateSnippetSetupCode(const ExegesisTarget &ET,
                          const llvm::MCSubtargetInfo *const MSI,
ExecutableFunction::ExecutableFunction(
   // Fetching function bytes.
   FunctionBytes =
       llvm::StringRef(reinterpret_cast<const char *>(
                           ExecEngine->getFunctionAddress(FunctionID)),
                       CodeSize);
 }
 
 } // namespace exegesis
+} // namespace llvm

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

 #ifndef LLVM_TOOLS_LLVM_EXEGESIS_BENCHMARKCODE_H
 #define LLVM_TOOLS_LLVM_EXEGESIS_BENCHMARKCODE_H
 
 #include "RegisterValue.h"
 #include "llvm/MC/MCInst.h"
 #include <string>
 #include <vector>
 
+namespace llvm {
 namespace exegesis {
 
 // A collection of instructions that are to be assembled, executed and measured.
 struct BenchmarkCode {
   // The sequence of instructions that are to be repeated.
   std::vector<llvm::MCInst> Instructions;
 
   // Before the code is executed some instructions are added to setup the
   // registers initial values.
   std::vector<RegisterValue> RegisterInitialValues;
 
   // We also need to provide the registers that are live on entry for the
   // assembler to generate proper prologue/epilogue.
   std::vector<unsigned> LiveIns;
 
   // Informations about how this configuration was built.
   std::string Info;
 };
 
 } // namespace exegesis
+} // namespace llvm
 
 #endif // LLVM_TOOLS_LLVM_EXEGESIS_BENCHMARKCODE_H

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

 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCInstBuilder.h"
 #include "llvm/Support/YAMLTraits.h"
 #include <limits>
 #include <string>
 #include <unordered_map>
 #include <vector>
 
+namespace llvm {
 namespace exegesis {
 
 struct InstructionBenchmarkKey {
   // The LLVM opcode name.
   std::vector<llvm::MCInst> Instructions;
   // The initial values of the registers.
   std::vector<RegisterValue> RegisterInitialValues;
   // An opaque configuration, that can be used to separate several benchmarks of
private:
   std::string Key;
   double SumValues = 0.0;
   int NumValues = 0;
   double MaxValue = std::numeric_limits<double>::min();
   double MinValue = std::numeric_limits<double>::max();
 };
 
 } // namespace exegesis
+} // namespace llvm
 
 #endif // LLVM_TOOLS_LLVM_EXEGESIS_BENCHMARKRESULT_H

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

 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
 
 static constexpr const char kIntegerPrefix[] = "i_0x";
 static constexpr const char kDoublePrefix[] = "f_";
 static constexpr const char kInvalidOperand[] = "INVALID";
 
+namespace llvm {
+
+namespace {
+
 // A mutable struct holding an LLVMState that can be passed through the
 // serialization process to encode/decode registers and instructions.
 struct YamlContext {
   YamlContext(const exegesis::LLVMState &State)
       : State(&State), ErrorStream(LastError) {}
 
   void serializeMCInst(const llvm::MCInst &MCInst, llvm::raw_ostream &OS) {
     OS << getInstrName(MCInst.getOpcode());
unsigned getInstrOpcode(llvm::StringRef InstrName) {
     const llvm::MCInstrInfo &InstrInfo = State->getInstrInfo();
     for (unsigned E = InstrInfo.getNumOpcodes(), I = 0; I < E; ++I)
       if (InstrInfo.getName(I) == InstrName)
         return I;
     ErrorStream << "No opcode with name " << InstrName;
     return 0;
   }
 
-  const exegesis::LLVMState *State;
+  const llvm::exegesis::LLVMState *State;
   std::string LastError;
   llvm::raw_string_ostream ErrorStream;
 };
+} // namespace
 
 // Defining YAML traits for IO.
-namespace llvm {
 namespace yaml {
 
 static YamlContext &getTypedContext(void *Ctx) {
   return *reinterpret_cast<YamlContext *>(Ctx);
 }
 
 // std::vector<llvm::MCInst> will be rendered as a list.
 template <> struct SequenceElementTraits<llvm::MCInst> {
static void mapping(IO &Io, exegesis::InstructionBenchmark &Obj,
     // AssembledSnippet
     MappingNormalization<NormalizedBinary, std::vector<uint8_t>> BinaryString(
         Io, Obj.AssembledSnippet);
     Io.mapOptional("assembled_snippet", BinaryString->Binary);
   }
 };
 
 } // namespace yaml
-} // namespace llvm
 
 namespace exegesis {
 
 llvm::Expected<InstructionBenchmark>
 InstructionBenchmark::readYaml(const LLVMState &State,
                                llvm::StringRef Filename) {
   if (auto ExpectedMemoryBuffer =
           llvm::errorOrToExpected(llvm::MemoryBuffer::getFile(Filename))) {
void PerInstructionStats::push(const BenchmarkMeasure &BM) {
   assert(Key == BM.Key);
   ++NumValues;
   SumValues += BM.PerInstructionValue;
   MaxValue = std::max(MaxValue, BM.PerInstructionValue);
   MinValue = std::min(MinValue, BM.PerInstructionValue);
 }
 
 } // namespace exegesis
+} // namespace llvm

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

 #include "LlvmState.h"
 #include "MCInstrDescView.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/Support/Error.h"
 #include <cstdlib>
 #include <memory>
 #include <vector>
 
+namespace llvm {
 namespace exegesis {
 
 // A class representing failures that happened during Benchmark, they are used
 // to report informations to the user.
 class BenchmarkFailure : public llvm::StringError {
 public:
   BenchmarkFailure(const llvm::Twine &S);
 };
writeObjectFile(const BenchmarkCode &Configuration,
                   llvm::ArrayRef<llvm::MCInst> Code) const;
 
   const InstructionBenchmark::ModeE Mode;
 
   const std::unique_ptr<ScratchSpace> Scratch;
 };
 
 } // namespace exegesis
+} // namespace llvm
 
 #endif // LLVM_TOOLS_LLVM_EXEGESIS_BENCHMARKRUNNER_H

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

 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/CrashRecoveryContext.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Program.h"
 
+namespace llvm {
 namespace exegesis {
 
 BenchmarkFailure::BenchmarkFailure(const llvm::Twine &S)
     : llvm::StringError(S, llvm::inconvertibleErrorCode()) {}
 
 BenchmarkRunner::BenchmarkRunner(const LLVMState &State,
                                  InstructionBenchmark::ModeE Mode)
     : State(State), Mode(Mode), Scratch(llvm::make_unique<ScratchSpace>()) {}
BenchmarkRunner::writeObjectFile(const BenchmarkCode &BC,
   assembleToStream(State.getExegesisTarget(), State.createTargetMachine(),
                    BC.LiveIns, BC.RegisterInitialValues, Code, OFS);
   return ResultPath.str();
 }
 
 BenchmarkRunner::FunctionExecutor::~FunctionExecutor() {}
 
 } // namespace exegesis
+} // namespace llvm

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

 
 #ifndef LLVM_TOOLS_LLVM_EXEGESIS_CLUSTERING_H
 #define LLVM_TOOLS_LLVM_EXEGESIS_CLUSTERING_H
 
 #include "BenchmarkResult.h"
 #include "llvm/Support/Error.h"
 #include <vector>
 
+namespace llvm {
 namespace exegesis {
 
 class InstructionBenchmarkClustering {
 public:
   // Clusters `Points` using DBSCAN with the given parameters. See the cc file
   // for more explanations on the algorithm.
   static llvm::Expected<InstructionBenchmarkClustering>
   create(const std::vector<InstructionBenchmark> &Points, size_t MinPts,
private:
   // ClusterForPoint_[P] is the cluster id for Points[P].
   std::vector<ClusterId> ClusterIdForPoint_;
   std::vector<Cluster> Clusters_;
   Cluster NoiseCluster_;
   Cluster ErrorCluster_;
 };
 
 } // namespace exegesis
+} // namespace llvm
 
 #endif // LLVM_TOOLS_LLVM_EXEGESIS_CLUSTERING_H

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

 //===-- Clustering.cpp ------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Clustering.h"
 #include <string>
 #include <unordered_set>
 
+namespace llvm {
 namespace exegesis {
 
 // The clustering problem has the following characteristics:
 //  (A) - Low dimension (dimensions are typically proc resource units,
 //    typically < 10).
 //  (B) - Number of points : ~thousands (points are measurements of an MCInst)
 //  (C) - Number of clusters: ~tens.
 //  (D) - The number of clusters is not known /a priory/.
if (Clustering.ErrorCluster_.PointIndices.size() == Points.size()) {
     return Clustering; // Nothing to cluster.
   }
 
   Clustering.dbScan(MinPts);
   return Clustering;
 }
 
 } // namespace exegesis
+} // namespace llvm

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

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_EXEGESIS_CODETEMPLATE_H
 #define LLVM_TOOLS_LLVM_EXEGESIS_CODETEMPLATE_H
 
 #include "MCInstrDescView.h"
 #include "llvm/ADT/BitmaskEnum.h"
 
+namespace llvm {
 namespace exegesis {
 
 // A template for an Instruction holding values for each of its Variables.
 struct InstructionTemplate {
   InstructionTemplate(const Instruction &Instr);
 
   InstructionTemplate(const InstructionTemplate &);            // default
   InstructionTemplate &operator=(const InstructionTemplate &); // default
struct CodeTemplate {
   // The list of the instructions for this template.
   std::vector<InstructionTemplate> 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
+} // namespace llvm
 
 #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 llvm {
 namespace exegesis {
 
 CodeTemplate::CodeTemplate(CodeTemplate &&) = default;
 
 CodeTemplate &CodeTemplate::operator=(CodeTemplate &&) = default;
 
 InstructionTemplate::InstructionTemplate(const Instruction &Instr)
     : Instr(Instr), VariableValues(Instr.Variables.size()) {}
getExecutionModeBits(ExecutionMode Execution) {
   llvm::SmallVector<ExecutionMode, 4> Result;
   for (const auto Bit : getAllExecutionBits())
     if ((Execution & Bit) == Bit)
       Result.push_back(Bit);
   return Result;
 }
 
 } // namespace exegesis
+} // namespace llvm

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

 
 #ifndef LLVM_TOOLS_LLVM_EXEGESIS_LATENCY_H
 #define LLVM_TOOLS_LLVM_EXEGESIS_LATENCY_H
 
 #include "BenchmarkRunner.h"
 #include "MCInstrDescView.h"
 #include "SnippetGenerator.h"
 
+namespace llvm {
 namespace exegesis {
 
 class LatencySnippetGenerator : public SnippetGenerator {
 public:
   LatencySnippetGenerator(const LLVMState &State) : SnippetGenerator(State) {}
   ~LatencySnippetGenerator() override;
 
   llvm::Expected<std::vector<CodeTemplate>>
   generateCodeTemplates(const Instruction &Instr) const override;
 };
 
 class LatencyBenchmarkRunner : public BenchmarkRunner {
 public:
   LatencyBenchmarkRunner(const LLVMState &State)
       : BenchmarkRunner(State, InstructionBenchmark::Latency) {}
   ~LatencyBenchmarkRunner() override;
 
 private:
   llvm::Expected<std::vector<BenchmarkMeasure>>
   runMeasurements(const FunctionExecutor &Executor) const override;
 
   virtual const char *getCounterName() const;
 };
 } // namespace exegesis
+} // namespace llvm
 
 #endif // LLVM_TOOLS_LLVM_EXEGESIS_LATENCY_H

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

 #include "Assembler.h"
 #include "BenchmarkRunner.h"
 #include "MCInstrDescView.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCInstBuilder.h"
 #include "llvm/Support/FormatVariadic.h"
 
+namespace llvm {
 namespace exegesis {
 
 struct ExecutionClass {
   ExecutionMode Mask;
   const char *Description;
 } static const kExecutionClasses[] = {
     {ExecutionMode::ALWAYS_SERIAL_IMPLICIT_REGS_ALIAS |
          ExecutionMode::ALWAYS_SERIAL_TIED_REGS_ALIAS,
if (*ExpectedCounterValue < MinValue)
       MinValue = *ExpectedCounterValue;
   }
   std::vector<BenchmarkMeasure> Result = {
       BenchmarkMeasure::Create("latency", MinValue)};
   return std::move(Result);
 }
 
 } // namespace exegesis
+} // namespace llvm

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

 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/Target/TargetMachine.h"
 #include <memory>
 #include <string>
 
+namespace llvm {
 namespace exegesis {
 
 class ExegesisTarget;
 
 // An object to initialize LLVM and prepare objects needed to run the
 // measurements.
 class LLVMState {
 public:

 
 private:
   const ExegesisTarget *TheExegesisTarget;
   std::unique_ptr<const llvm::TargetMachine> TargetMachine;
   std::unique_ptr<const RegisterAliasingTrackerCache> RATC;
 };
 
 } // namespace exegesis
+} // namespace llvm
 
 #endif // LLVM_TOOLS_LLVM_EXEGESIS_LLVMSTATE_H

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

 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCFixup.h"
 #include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Target/TargetOptions.h"
 
+namespace llvm {
 namespace exegesis {
 
 LLVMState::LLVMState(const std::string &Triple, const std::string &CpuName) {
   std::string Error;
   const llvm::Target *const TheTarget =
       llvm::TargetRegistry::lookupTarget(Triple, Error);
   assert(TheTarget && "unknown target for host");
   const llvm::TargetOptions Options;
bool LLVMState::canAssemble(const llvm::MCInst &Inst) const {
   llvm::raw_svector_ostream OS(Tmp);
   llvm::SmallVector<llvm::MCFixup, 4> Fixups;
   CodeEmitter->encodeInstruction(Inst, OS, Fixups,
                                  *TargetMachine->getMCSubtargetInfo());
   return Tmp.size() > 0;
 }
 
 } // namespace exegesis
+} // namespace llvm

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

 #include "LlvmState.h"
 #include "RegisterAliasing.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCInstrDesc.h"
 #include "llvm/MC/MCInstrInfo.h"
 
+namespace llvm {
 namespace exegesis {
 
 // A variable represents the value associated to an Operand or a set of Operands
 // if they are tied together.
 struct Variable {
   // Returns the index of this Variable inside Instruction's Variable.
   unsigned getIndex() const;
 

 // Writes MCInst to OS.
 // This is not assembly but the internal LLVM's name for instructions and
 // registers.
 void DumpMCInst(const llvm::MCRegisterInfo &MCRegisterInfo,
                 const llvm::MCInstrInfo &MCInstrInfo,
                 const llvm::MCInst &MCInst, llvm::raw_ostream &OS);
 
 } // namespace exegesis
+} // namespace llvm
 
 #endif // LLVM_TOOLS_LLVM_EXEGESIS_MCINSTRDESCVIEW_H

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

 #include "MCInstrDescView.h"
 
 #include <iterator>
 #include <map>
 #include <tuple>
 
 #include "llvm/ADT/STLExtras.h"
 
+namespace llvm {
 namespace exegesis {
 
 unsigned Variable::getIndex() const {
   assert(Index >= 0 && "Index must be set");
   return Index;
 }
 
 unsigned Variable::getPrimaryOperandIndex() const {
for (unsigned I = 0, E = MCInst.getNumOperands(); I < E; ++I) {
     if (I > 0)
       OS << ',';
     OS << ' ';
     DumpMCOperand(MCRegisterInfo, MCInst.getOperand(I), OS);
   }
 }
 
 } // namespace exegesis
+} // namespace llvm

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

 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Config/config.h"
 #include <functional>
 #include <memory>
 
 struct perf_event_attr;
 
+namespace llvm {
 namespace exegesis {
 namespace pfm {
 
 // Returns true on error.
 bool pfmInitialize();
 void pfmTerminate();
 
 // Retrieves the encoding for the event described by pfm_event_string.
for (const auto &Event : Events) {
     Fn();
     Cnt.stop();
     Callback(Event, Cnt.read());
   }
 }
 
 } // namespace pfm
 } // namespace exegesis
+} // namespace llvm
 
 #endif // LLVM_TOOLS_LLVM_EXEGESIS_PERFHELPER_H

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

 #include "llvm/Support/raw_ostream.h"
 #ifdef HAVE_LIBPFM
 #include "perfmon/perf_event.h"
 #include "perfmon/pfmlib.h"
 #include "perfmon/pfmlib_perf_event.h"
 #endif
 #include <cassert>
 
+namespace llvm {
 namespace exegesis {
 namespace pfm {
 
 #ifdef HAVE_LIBPFM
 static bool isPfmError(int Code) { return Code != PFM_SUCCESS; }
 #endif
 
 bool pfmInitialize() {

 void Counter::stop() {}
 
 int64_t Counter::read() const { return 42; }
 
 #endif
 
 } // namespace pfm
 } // namespace exegesis
+} // namespace llvm

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

 
 #include <memory>
 #include <unordered_map>
 
 #include "llvm/ADT/BitVector.h"
 #include "llvm/ADT/PackedVector.h"
 #include "llvm/MC/MCRegisterInfo.h"
 
+namespace llvm {
 namespace exegesis {
 
 // Returns the registers that are aliased by the ones set in SourceBits.
 llvm::BitVector getAliasedBits(const llvm::MCRegisterInfo &RegInfo,
                                const llvm::BitVector &SourceBits);
 
 // Keeps track of a mapping from one register (or a register class) to its
 // aliased registers.
private:
   const llvm::BitVector EmptyRegisters;
   mutable std::unordered_map<unsigned, std::unique_ptr<RegisterAliasingTracker>>
       Registers;
   mutable std::unordered_map<unsigned, std::unique_ptr<RegisterAliasingTracker>>
       RegisterClasses;
 };
 
 } // namespace exegesis
+} // namespace llvm
 
 #endif // LLVM_TOOLS_LLVM_EXEGESIS_ALIASINGTRACKER_H

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

 //===-- RegisterAliasingTracker.cpp -----------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "RegisterAliasing.h"
 
+namespace llvm {
 namespace exegesis {
 
 llvm::BitVector getAliasedBits(const llvm::MCRegisterInfo &RegInfo,
                                const llvm::BitVector &SourceBits) {
   llvm::BitVector AliasedBits(RegInfo.getNumRegs());
   for (const size_t PhysReg : SourceBits.set_bits()) {
     using RegAliasItr = llvm::MCRegAliasIterator;
     for (auto Itr = RegAliasItr(PhysReg, &RegInfo, true); Itr.isValid();
RegisterAliasingTrackerCache::getRegisterClass(unsigned RegClassIndex) const {
   auto &Found = RegisterClasses[RegClassIndex];
   const auto &RegClass = RegInfo.getRegClass(RegClassIndex);
   if (!Found)
     Found.reset(new RegisterAliasingTracker(RegInfo, ReservedReg, RegClass));
   return *Found;
 }
 
 } // namespace exegesis
+} // namespace llvm

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

 /// Defines a Target independent value for a Register. This is useful to explore
 /// the influence of the instruction input values on its execution time.
 ///
 //===----------------------------------------------------------------------===//
 
 #include <llvm/ADT/APFloat.h>
 #include <llvm/ADT/APInt.h>
 
+namespace llvm {
 namespace exegesis {
 
 // A simple object storing the value for a particular register.
 struct RegisterValue {
   unsigned Register;
   llvm::APInt Value;
 };
 
enum class PredefinedValues {
   LARGEST,        // The maximum normal number
   ONE_PLUS_ULP,   // The value just after 1.0
 };
 
 llvm::APInt bitcastFloatValue(const llvm::fltSemantics &FltSemantics,
                               PredefinedValues Value);
 
 } // namespace exegesis
+} // namespace llvm

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

 //===-- RegisterValue.cpp ---------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "RegisterValue.h"
 #include "llvm/ADT/APFloat.h"
 
+namespace llvm {
 namespace exegesis {
 
 static llvm::APFloat getFloatValue(const llvm::fltSemantics &FltSemantics,
                                    PredefinedValues Value) {
   switch (Value) {
   case PredefinedValues::POS_ZERO:
     return llvm::APFloat::getZero(FltSemantics);
   case PredefinedValues::NEG_ZERO:

 }
 
 llvm::APInt bitcastFloatValue(const llvm::fltSemantics &FltSemantics,
                               PredefinedValues Value) {
   return getFloatValue(FltSemantics, Value).bitcastToAPInt();
 }
 
 } // namespace exegesis
+} // namespace llvm

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

 #include "MCInstrDescView.h"
 #include "RegisterAliasing.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/Support/Error.h"
 #include <cstdlib>
 #include <memory>
 #include <vector>
 
+namespace llvm {
 namespace exegesis {
 
 std::vector<CodeTemplate> getSingleton(CodeTemplate &&CT);
 
 // Generates code templates that has a self-dependency.
 llvm::Expected<std::vector<CodeTemplate>>
 generateSelfAliasingCodeTemplates(const Instruction &Instr);
 
void setRandomAliasing(const AliasingConfigurations &AliasingConfigurations,
                        InstructionTemplate &DefIB, InstructionTemplate &UseIB);
 
 // Assigns a Random Value to all Variables in IT that are still Invalid.
 // Do not use any of the registers in `ForbiddenRegs`.
 void randomizeUnsetVariables(const llvm::BitVector &ForbiddenRegs,
                              InstructionTemplate &IT);
 
 } // namespace exegesis
+} // namespace llvm
 
 #endif // LLVM_TOOLS_LLVM_EXEGESIS_SNIPPETGENERATOR_H

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

 #include "SnippetGenerator.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/Program.h"
 
+namespace llvm {
 namespace exegesis {
 
 std::vector<CodeTemplate> getSingleton(CodeTemplate &&CT) {
   std::vector<CodeTemplate> Result;
   Result.push_back(std::move(CT));
   return Result;
 }
 
void randomizeUnsetVariables(const llvm::BitVector &ForbiddenRegs,
   for (const Variable &Var : IT.Instr.Variables) {
     llvm::MCOperand &AssignedValue = IT.getValueFor(Var);
     if (!AssignedValue.isValid())
       randomize(IT.Instr, Var, AssignedValue, ForbiddenRegs);
   }
 }
 
 } // namespace exegesis
+} // namespace llvm

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

 #include "SnippetGenerator.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/CodeGen/TargetPassConfig.h"
 #include "llvm/IR/CallingConv.h"
 #include "llvm/IR/LegacyPassManager.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCRegisterInfo.h"
 
+namespace llvm {
 namespace exegesis {
 
 class ExegesisTarget {
 public:
   // Targets can use this to add target-specific passes in assembleToStream();
   virtual void addTargetSpecificPasses(llvm::PassManagerBase &PM) const {}
 
   // Generates code to move a constant into a the given register.
std::unique_ptr<BenchmarkRunner> virtual createLatencyBenchmarkRunner(
       const LLVMState &State) const;
   std::unique_ptr<BenchmarkRunner> virtual createUopsBenchmarkRunner(
       const LLVMState &State) const;
 
   const ExegesisTarget *Next = nullptr;
 };
 
 } // namespace exegesis
+} // namespace llvm
 
 #endif // LLVM_TOOLS_LLVM_EXEGESIS_TARGET_H

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

 //===-- Target.cpp ----------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 #include "Target.h"
 
 #include "Latency.h"
 #include "Uops.h"
 
+namespace llvm {
 namespace exegesis {
 
 ExegesisTarget::~ExegesisTarget() {} // anchor.
 
 static ExegesisTarget *FirstTarget = nullptr;
 
 const ExegesisTarget *ExegesisTarget::lookup(llvm::Triple TT) {
   for (const ExegesisTarget *T = FirstTarget; T != nullptr; T = T->Next) {

 } // namespace
 
 const ExegesisTarget &ExegesisTarget::getDefault() {
   static ExegesisDefaultTarget Target;
   return Target;
 }
 
 } // namespace exegesis
+} // namespace llvm

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

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_EXEGESIS_UOPS_H
 #define LLVM_TOOLS_LLVM_EXEGESIS_UOPS_H
 
 #include "BenchmarkRunner.h"
 #include "SnippetGenerator.h"
 
+namespace llvm {
 namespace exegesis {
 
 class UopsSnippetGenerator : public SnippetGenerator {
 public:
   UopsSnippetGenerator(const LLVMState &State) : SnippetGenerator(State) {}
   ~UopsSnippetGenerator() override;
 
   llvm::Expected<std::vector<CodeTemplate>>
public:
   static constexpr const size_t kMinNumDifferentAddresses = 6;
 
 private:
   llvm::Expected<std::vector<BenchmarkMeasure>>
   runMeasurements(const FunctionExecutor &Executor) const override;
 };
 
 } // namespace exegesis
+} // namespace llvm
 
 #endif // LLVM_TOOLS_LLVM_EXEGESIS_UOPS_H

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

 //    imul r8,  rbx
 //
 // Some instruction even make the above static renaming impossible because
 // they implicitly read and write from the same operand, e.g. ADC16rr reads
 // and writes from EFLAGS.
 // In that case we just use a greedy register assignment and hope for the
 // best.
 
+namespace llvm {
 namespace exegesis {
 
 static llvm::SmallVector<const Variable *, 8>
 getVariablesWithTiedOperands(const Instruction &Instr) {
   llvm::SmallVector<const Variable *, 8> Result;
   for (const auto &Var : Instr.Variables)
     if (Var.hasTiedOperands())
       Result.push_back(&Var);
Result.push_back(
         BenchmarkMeasure::Create("NumMicroOps", *ExpectedCounterValue));
   }
   return std::move(Result);
 }
 
 constexpr const size_t UopsSnippetGenerator::kMinNumDifferentAddresses;
 
 } // namespace exegesis
+} // namespace llvm

llvm/trunk/tools/llvm-exegesis/lib/X86/Target.cpp

 #include "../Uops.h"
 #include "MCTargetDesc/X86BaseInfo.h"
 #include "MCTargetDesc/X86MCTargetDesc.h"
 #include "X86.h"
 #include "X86RegisterInfo.h"
 #include "X86Subtarget.h"
 #include "llvm/MC/MCInstBuilder.h"
 
+namespace llvm {
 namespace exegesis {
 
 namespace {
 
 // A chunk of instruction's operands that represents a single memory access.
 struct MemoryOperandRange {
   MemoryOperandRange(llvm::ArrayRef<Operand> Operands) : Ops(Operands) {}
 
static ExegesisTarget *getTheExegesisX86Target() {
   return &Target;
 }
 
 void InitializeX86ExegesisTarget() {
   ExegesisTarget::registerTarget(getTheExegesisX86Target());
 }
 
 } // namespace exegesis
+} // namespace llvm

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

 #include "llvm/Support/Format.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/TargetSelect.h"
 #include <algorithm>
 #include <string>
 
-static llvm::cl::opt<int>
-    OpcodeIndex("opcode-index", llvm::cl::desc("opcode to measure, by index"),
-                llvm::cl::init(0));
-
-static llvm::cl::opt<std::string> OpcodeNames(
-    "opcode-name",
-    llvm::cl::desc("comma-separated list of opcodes to measure, by name"),
-    llvm::cl::init(""));
-
-static llvm::cl::opt<std::string>
-    SnippetsFile("snippets-file", llvm::cl::desc("code snippets to measure"),
-                 llvm::cl::init(""));
-
-static llvm::cl::opt<std::string>
-    BenchmarkFile("benchmarks-file", llvm::cl::desc(""), llvm::cl::init(""));
-
-static llvm::cl::opt<exegesis::InstructionBenchmark::ModeE> BenchmarkMode(
-    "mode", llvm::cl::desc("the mode to run"),
-    llvm::cl::values(clEnumValN(exegesis::InstructionBenchmark::Latency,
+namespace llvm {
+namespace exegesis {
+
+static cl::opt<int> OpcodeIndex("opcode-index",
+                                cl::desc("opcode to measure, by index"),
+                                cl::init(0));
+
+static cl::opt<std::string>
+    OpcodeNames("opcode-name",
+                cl::desc("comma-separated list of opcodes to measure, by name"),
+                cl::init(""));
+
+static cl::opt<std::string> SnippetsFile("snippets-file",
+                                         cl::desc("code snippets to measure"),
+                                         cl::init(""));
+
+static cl::opt<std::string> BenchmarkFile("benchmarks-file", cl::desc(""),
+                                          cl::init(""));
+
+static cl::opt<exegesis::InstructionBenchmark::ModeE>
+    BenchmarkMode("mode", cl::desc("the mode to run"),
+                  cl::values(clEnumValN(exegesis::InstructionBenchmark::Latency,
                                         "latency", "Instruction Latency"),
-                     clEnumValN(exegesis::InstructionBenchmark::Uops, "uops",
-                                "Uop Decomposition"),
-                     // When not asking for a specific benchmark mode, we'll
-                     // analyse the results.
+                             clEnumValN(exegesis::InstructionBenchmark::Uops,
+                                        "uops", "Uop Decomposition"),
+                             // When not asking for a specific benchmark mode,
+                             // we'll analyse the results.
                              clEnumValN(exegesis::InstructionBenchmark::Unknown,
                                         "analysis", "Analysis")));
 
-static llvm::cl::opt<unsigned>
+static cl::opt<unsigned>
     NumRepetitions("num-repetitions",
-                   llvm::cl::desc("number of time to repeat the asm snippet"),
-                   llvm::cl::init(10000));
+                   cl::desc("number of time to repeat the asm snippet"),
+                   cl::init(10000));
 
-static llvm::cl::opt<bool> IgnoreInvalidSchedClass(
+static cl::opt<bool> IgnoreInvalidSchedClass(
     "ignore-invalid-sched-class",
-    llvm::cl::desc("ignore instructions that do not define a sched class"),
-    llvm::cl::init(false));
+    cl::desc("ignore instructions that do not define a sched class"),
+    cl::init(false));
 
-static llvm::cl::opt<unsigned> AnalysisNumPoints(
+static cl::opt<unsigned> AnalysisNumPoints(
     "analysis-numpoints",
-    llvm::cl::desc("minimum number of points in an analysis cluster"),
-    llvm::cl::init(3));
+    cl::desc("minimum number of points in an analysis cluster"), cl::init(3));
 
-static llvm::cl::opt<float>
+static cl::opt<float>
     AnalysisEpsilon("analysis-epsilon",
-                    llvm::cl::desc("dbscan epsilon for analysis clustering"),
-                    llvm::cl::init(0.1));
+                    cl::desc("dbscan epsilon for analysis clustering"),
+                    cl::init(0.1));
 
-static llvm::cl::opt<std::string>
-    AnalysisClustersOutputFile("analysis-clusters-output-file",
-                               llvm::cl::desc(""), llvm::cl::init("-"));
-static llvm::cl::opt<std::string>
+static cl::opt<std::string>
+    AnalysisClustersOutputFile("analysis-clusters-output-file", cl::desc(""),
+                               cl::init("-"));
+static cl::opt<std::string>
     AnalysisInconsistenciesOutputFile("analysis-inconsistencies-output-file",
-                                      llvm::cl::desc(""), llvm::cl::init("-"));
-
-namespace exegesis {
+                                      cl::desc(""), cl::init("-"));
 
-static llvm::ExitOnError ExitOnErr;
+static ExitOnError ExitOnErr;
 
 #ifdef LLVM_EXEGESIS_INITIALIZE_NATIVE_TARGET
 void LLVM_EXEGESIS_INITIALIZE_NATIVE_TARGET();
 #endif
 
 // Checks that only one of OpcodeNames, OpcodeIndex or SnippetsFile is provided,
 // and returns the opcode indices or {} if snippets should be read from
 // `SnippetsFile`.
static void analysisMain() {
   maybeRunAnalysis<Analysis::PrintClusters>(Analyzer, "analysis clusters",
                                             AnalysisClustersOutputFile);
   maybeRunAnalysis<Analysis::PrintSchedClassInconsistencies>(
       Analyzer, "sched class consistency analysis",
       AnalysisInconsistenciesOutputFile);
 }
 
 } // namespace exegesis
+} // namespace llvm
 
 int main(int Argc, char **Argv) {
-  llvm::cl::ParseCommandLineOptions(Argc, Argv, "");
+  using namespace llvm;
+  cl::ParseCommandLineOptions(Argc, Argv, "");
 
   exegesis::ExitOnErr.setExitCodeMapper([](const llvm::Error &Err) {
     if (Err.isA<llvm::StringError>())
       return EXIT_SUCCESS;
     return EXIT_FAILURE;
   });
 
-  if (BenchmarkMode == exegesis::InstructionBenchmark::Unknown) {
+  if (exegesis::BenchmarkMode == exegesis::InstructionBenchmark::Unknown) {
     exegesis::analysisMain();
   } else {
     exegesis::benchmarkMain();
   }
   return EXIT_SUCCESS;
 }

llvm/trunk/unittests/tools/llvm-exegesis/AArch64/TargetTest.cpp

 #include "Target.h"
 
 #include <cassert>
 #include <memory>
 
 #include "MCTargetDesc/AArch64MCTargetDesc.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/TargetSelect.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
+namespace llvm {
 namespace exegesis {
 
 void InitializeAArch64ExegesisTarget();
 
 namespace {
 
 using llvm::APInt;
 using llvm::MCInst;

 TEST_F(AArch64TargetTest, SetRegToConstant) {
   // The AArch64 target currently doesn't know how to set register values.
   const auto Insts = setRegTo(llvm::AArch64::X0, llvm::APInt());
   EXPECT_THAT(Insts, Not(IsEmpty()));
 }
 
 } // namespace
 } // namespace exegesis
+} // namespace llvm

llvm/trunk/unittests/tools/llvm-exegesis/ARM/AssemblerTest.cpp

 //===-- AssemblerTest.cpp ---------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "../Common/AssemblerUtils.h"
 #include "ARMInstrInfo.h"
 
+namespace llvm {
 namespace exegesis {
 namespace {
 
 using llvm::MCInstBuilder;
 
 class ARMMachineFunctionGeneratorTest
     : public MachineFunctionGeneratorBaseTest {
 protected:
Check({{llvm::ARM::R0, llvm::APInt()}},
             .addImm(llvm::ARMCC::AL)
             .addReg(0)
             .addReg(0),
         0x00, 0x00, 0x80, 0xe0, 0x1e, 0xff, 0x2f, 0xe1);
 }
 
 } // namespace
 } // namespace exegesis
+} // namespace llvm

llvm/trunk/unittests/tools/llvm-exegesis/BenchmarkRunnerTest.cpp

 //===-- BenchmarkRunnerTest.cpp ---------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "BenchmarkRunner.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
+namespace llvm {
 namespace exegesis {
 
 namespace {
 
 TEST(ScratchSpaceTest, Works) {
   BenchmarkRunner::ScratchSpace Space;
   EXPECT_EQ(reinterpret_cast<intptr_t>(Space.ptr()) %
                 BenchmarkRunner::ScratchSpace::kAlignment,
             0u);
   Space.ptr()[0] = 42;
   Space.ptr()[BenchmarkRunner::ScratchSpace::kSize - 1] = 43;
   Space.clear();
   EXPECT_EQ(Space.ptr()[0], 0);
   EXPECT_EQ(Space.ptr()[BenchmarkRunner::ScratchSpace::kSize - 1], 0);
 }
 
 } // namespace
 } // namespace exegesis
+} // namespace llvm

llvm/trunk/unittests/tools/llvm-exegesis/ClusteringTest.cpp

 //===-- ClusteringTest.cpp --------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Clustering.h"
 #include "BenchmarkResult.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/raw_ostream.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
+namespace llvm {
 namespace exegesis {
 
 namespace {
 
 using testing::Field;
 using testing::UnorderedElementsAre;
 using testing::UnorderedElementsAreArray;
 
ASSERT_LT(InstructionBenchmarkClustering::ClusterId::makeValid(2),
             InstructionBenchmarkClustering::ClusterId::error());
 
   ASSERT_LT(InstructionBenchmarkClustering::ClusterId::noise(),
             InstructionBenchmarkClustering::ClusterId::error());
 }
 
 } // namespace
 } // namespace exegesis
+} // namespace llvm

llvm/trunk/unittests/tools/llvm-exegesis/Common/AssemblerUtils.h

 #include "llvm/CodeGen/TargetSubtargetInfo.h"
 #include "llvm/MC/MCInstBuilder.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/TargetSelect.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
+namespace llvm {
 namespace exegesis {
 
 class MachineFunctionGeneratorBaseTest : public ::testing::Test {
 protected:
   MachineFunctionGeneratorBaseTest(const std::string &TT,
                                    const std::string &CpuName)
       : TT(TT), CpuName(CpuName),
         CanExecute(llvm::Triple(TT).getArch() ==
private:
 
   const std::string TT;
   const std::string CpuName;
   const bool CanExecute;
   const ExegesisTarget *const ET;
 };
 
 } // namespace exegesis
+} // namespace llvm
 
 #endif

llvm/trunk/unittests/tools/llvm-exegesis/PerfHelperTest.cpp

 //===-- PerfHelperTest.cpp --------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "PerfHelper.h"
 #include "llvm/Config/config.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
+namespace llvm {
 namespace exegesis {
 namespace pfm {
 namespace {
 
 using ::testing::IsEmpty;
 using ::testing::Not;
 
 TEST(PerfHelperTest, FunctionalTest) {

 #else
   ASSERT_TRUE(pfmInitialize());
 #endif
 }
 
 } // namespace
 } // namespace pfm
 } // namespace exegesis
+} // namespace llvm

llvm/trunk/unittests/tools/llvm-exegesis/RegisterValueTest.cpp

 //===-- RegisterValueTest.cpp -----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "RegisterValue.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
+namespace llvm {
 namespace exegesis {
 
 namespace {
 
 #define CHECK(EXPECTED, ACTUAL)                                                \
   EXPECT_EQ(llvm::APInt(SizeInBits, EXPECTED, 16),                             \
             bitcastFloatValue(Semantic, PredefinedValues::ACTUAL))
 
TEST(RegisterValueTest, Double) {
   CHECK("0010000000000000", SMALLEST_NORM);
   CHECK("0000000000000001", SMALLEST);
   CHECK("0000000000000001", ULP);
   CHECK("3FF0000000000001", ONE_PLUS_ULP);
 }
 
 } // namespace
 } // namespace exegesis
+} // namespace llvm

llvm/trunk/unittests/tools/llvm-exegesis/X86/AnalysisTest.cpp

 #include "Analysis.h"
 
 #include <cassert>
 #include <memory>
 
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/TargetSelect.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
+namespace llvm {
 namespace exegesis {
 namespace {
 
 using testing::Pair;
 using testing::UnorderedElementsAre;
 
 class AnalysisTest : public ::testing::Test {
 protected:
const auto Pressure = computeIdealizedProcResPressure(
       STI->getSchedModel(), {{P1Idx, 1}, {P05Idx, 1}, {P0156Idx, 2}});
   EXPECT_THAT(Pressure,
               UnorderedElementsAre(Pair(P0Idx, 1.0), Pair(P1Idx, 1.0),
                                    Pair(P5Idx, 1.0), Pair(P6Idx, 1.0)));
 }
 
 } // namespace
 } // namespace exegesis
+} // namespace llvm

llvm/trunk/unittests/tools/llvm-exegesis/X86/AssemblerTest.cpp

 //===-- AssemblerTest.cpp ---------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "../Common/AssemblerUtils.h"
 #include "X86InstrInfo.h"
 
+namespace llvm {
 namespace exegesis {
 
 void InitializeX86ExegesisTarget();
 
 namespace {
 
 using llvm::MCInstBuilder;
 using llvm::X86::EAX;

 
 TEST_F(X86MachineFunctionGeneratorTest, DISABLED_JitFunctionMOV32ri) {
   Check({}, MCInstBuilder(MOV32ri).addReg(EAX).addImm(42), 0xb8, 0x2a, 0x00,
         0x00, 0x00, 0xc3);
 }
 
 } // namespace
 } // namespace exegesis
+} // namespace llvm

llvm/trunk/unittests/tools/llvm-exegesis/X86/BenchmarkResultTest.cpp

 #include "gtest/gtest.h"
 
 using ::testing::AllOf;
 using ::testing::Eq;
 using ::testing::get;
 using ::testing::Pointwise;
 using ::testing::Property;
 
+namespace llvm {
 namespace exegesis {
 
 bool operator==(const BenchmarkMeasure &A, const BenchmarkMeasure &B) {
   return std::tie(A.Key, A.PerInstructionValue, A.PerSnippetValue) ==
          std::tie(B.Key, B.PerInstructionValue, B.PerSnippetValue);
 }
 
 static std::string Dump(const llvm::MCInst &McInst) {
TEST(BenchmarkResultTest, PerInstructionStats) {
   Stats.push(BenchmarkMeasure{"a", -1.0, 0.0});
   Stats.push(BenchmarkMeasure{"a", 0.0, 0.0});
   EXPECT_EQ(Stats.min(), -1.0);
   EXPECT_EQ(Stats.max(), 1.5);
   EXPECT_EQ(Stats.avg(), 0.25); // (0.5+1.5-1.0+0.0) / 4
 }
 } // namespace
 } // namespace exegesis
+} // namespace llvm

llvm/trunk/unittests/tools/llvm-exegesis/X86/RegisterAliasingTest.cpp

 #include "RegisterAliasing.h"
 
 #include <cassert>
 #include <memory>
 
 #include "X86InstrInfo.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/TargetSelect.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
+namespace llvm {
 namespace exegesis {
 namespace {
 
 class RegisterAliasingTest : public ::testing::Test {
 protected:
   RegisterAliasingTest() {
     const std::string TT = "x86_64-unknown-linux";
     std::string error;
ASSERT_THAT(&Cache.getRegister(llvm::X86::AX),
               &Cache.getRegister(llvm::X86::AX));
 
   ASSERT_THAT(&Cache.getRegisterClass(llvm::X86::GR8_ABCD_LRegClassID),
               &Cache.getRegisterClass(llvm::X86::GR8_ABCD_LRegClassID));
 }
 
 } // namespace
 } // namespace exegesis
+} // namespace llvm

llvm/trunk/unittests/tools/llvm-exegesis/X86/SnippetGeneratorTest.cpp

 #include "LlvmState.h"
 #include "MCInstrDescView.h"
 #include "RegisterAliasing.h"
 #include "Uops.h"
 #include "X86InstrInfo.h"
 
 #include <unordered_set>
 
+namespace llvm {
 namespace exegesis {
 
 void InitializeX86ExegesisTarget();
 
 namespace {
 
 using testing::AnyOf;
 using testing::ElementsAre;
TEST_F(FakeSnippetGeneratorTest, ComputeRegisterInitialValuesAdd64rr) {
   }
 
   const auto RIV = Generator.computeRegisterInitialValues(Snippet);
   EXPECT_THAT(RIV, ElementsAre(IsRegisterValue(llvm::X86::RBX, llvm::APInt())));
 }
 
 } // namespace
 } // namespace exegesis
+} // namespace llvm

llvm/trunk/unittests/tools/llvm-exegesis/X86/TargetTest.cpp

for (unsigned I = 0; I < a.getNumOperands(); ++I) {
     if (!(a.getOperand(I) == b.getOperand(I)))
       return false;
   }
   return true;
 }
 
 } // namespace llvm
 
+namespace llvm {
 namespace exegesis {
 
 void InitializeX86ExegesisTarget();
 
 namespace {
 
 using testing::AllOf;
 using testing::ElementsAre;
EXPECT_THAT(
                   IsMovValueToStack(llvm::X86::MOV32mi, 0x00000000UL, 4),
                   IsMovValueToStack(llvm::X86::MOV16mi, 0x0000UL, 8),
                   OpcodeIs(llvm::X86::LD_Fp80m),
                   IsStackDeallocate(10)));
 }
 
 } // namespace
 } // namespace exegesis
+} // namespace llvm