Move MachineRepresentation to machine-type.h and rename to MachineType in preparation for merging i…

test/cctest/compiler/codegen-tester.h

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_CCTEST_COMPILER_CODEGEN_TESTER_H_
 #define V8_CCTEST_COMPILER_CODEGEN_TESTER_H_
 
 #include "src/v8.h"
 
 #include "src/compiler/pipeline.h"
 #include "src/compiler/raw-machine-assembler.h"
 #include "src/compiler/structured-machine-assembler.h"
 #include "src/simulator.h"
 #include "test/cctest/compiler/call-tester.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 template <typename MachineAssembler>
 class MachineAssemblerTester : public HandleAndZoneScope,
                                public CallHelper,
                                public MachineAssembler {
  public:
-  MachineAssemblerTester(MachineRepresentation return_type,
-                         MachineRepresentation p0, MachineRepresentation p1,
-                         MachineRepresentation p2, MachineRepresentation p3,
-                         MachineRepresentation p4)
+  MachineAssemblerTester(MachineType return_type, MachineType p0,
+                         MachineType p1, MachineType p2, MachineType p3,
+                         MachineType p4)
       : HandleAndZoneScope(),
         CallHelper(main_isolate()),
         MachineAssembler(new (main_zone()) Graph(main_zone()),
                          ToCallDescriptorBuilder(main_zone(), return_type, p0,
                                                  p1, p2, p3, p4),
                          MachineOperatorBuilder::pointer_rep()) {}
 
-  Node* LoadFromPointer(void* address, MachineRepresentation rep,
-                        int32_t offset = 0) {
+  Node* LoadFromPointer(void* address, MachineType rep, int32_t offset = 0) {
     return this->Load(rep, this->PointerConstant(address),
                       this->Int32Constant(offset));
   }
 
-  void StoreToPointer(void* address, MachineRepresentation rep, Node* node) {
+  void StoreToPointer(void* address, MachineType rep, Node* node) {
     this->Store(rep, this->PointerConstant(address), node);
   }
 
   Node* StringConstant(const char* string) {
     return this->HeapConstant(
         this->isolate()->factory()->InternalizeUtf8String(string));
   }
 
   void CheckNumber(double expected, Object* number) {
     CHECK(this->isolate()->factory()->NewNumber(expected)->SameValue(number));
   }
 
   void CheckString(const char* expected, Object* string) {
     CHECK(
         this->isolate()->factory()->InternalizeUtf8String(expected)->SameValue(
             string));
   }
 
   void GenerateCode() { Generate(); }
 
  protected:
   virtual void VerifyParameters(int parameter_count,
-                                MachineRepresentation* parameter_types) {
+                                MachineType* parameter_types) {
     CHECK_EQ(this->parameter_count(), parameter_count);
-    const MachineRepresentation* expected_types = this->parameter_types();
+    const MachineType* expected_types = this->parameter_types();
     for (int i = 0; i < parameter_count; i++) {
       CHECK_EQ(expected_types[i], parameter_types[i]);
     }
   }
 
   virtual byte* Generate() {
     if (code_.is_null()) {
       Schedule* schedule = this->Export();
       CallDescriptor* call_descriptor = this->call_descriptor();
       Graph* graph = this->graph();
       CompilationInfo info(graph->zone()->isolate(), graph->zone());
       Linkage linkage(&info, call_descriptor);
       Pipeline pipeline(&info);
       code_ = pipeline.GenerateCodeForMachineGraph(&linkage, graph, schedule);
     }
     return this->code_.ToHandleChecked()->entry();
   }
 
  private:
   MaybeHandle<Code> code_;
 };
 
 
 template <typename ReturnType>
 class RawMachineAssemblerTester
     : public MachineAssemblerTester<RawMachineAssembler>,
       public CallHelper2<ReturnType, RawMachineAssemblerTester<ReturnType> > {
  public:
-  RawMachineAssemblerTester(MachineRepresentation p0 = kMachineLast,
-                            MachineRepresentation p1 = kMachineLast,
-                            MachineRepresentation p2 = kMachineLast,
-                            MachineRepresentation p3 = kMachineLast,
-                            MachineRepresentation p4 = kMachineLast)
+  RawMachineAssemblerTester(MachineType p0 = kMachineLast,
+                            MachineType p1 = kMachineLast,
+                            MachineType p2 = kMachineLast,
+                            MachineType p3 = kMachineLast,
+                            MachineType p4 = kMachineLast)
       : MachineAssemblerTester<RawMachineAssembler>(
             ReturnValueTraits<ReturnType>::Representation(), p0, p1, p2, p3,
             p4) {}
 
   template <typename Ci, typename Fn>
   void Run(const Ci& ci, const Fn& fn) {
     typename Ci::const_iterator i;
     for (i = ci.begin(); i != ci.end(); ++i) {
       CHECK_EQ(fn(*i), this->Call(*i));
     }
@@ skipping 11 matching lines @@
   }
 };
 
 
 template <typename ReturnType>
 class StructuredMachineAssemblerTester
     : public MachineAssemblerTester<StructuredMachineAssembler>,
       public CallHelper2<ReturnType,
                          StructuredMachineAssemblerTester<ReturnType> > {
  public:
-  StructuredMachineAssemblerTester(MachineRepresentation p0 = kMachineLast,
-                                   MachineRepresentation p1 = kMachineLast,
-                                   MachineRepresentation p2 = kMachineLast,
-                                   MachineRepresentation p3 = kMachineLast,
-                                   MachineRepresentation p4 = kMachineLast)
+  StructuredMachineAssemblerTester(MachineType p0 = kMachineLast,
+                                   MachineType p1 = kMachineLast,
+                                   MachineType p2 = kMachineLast,
+                                   MachineType p3 = kMachineLast,
+                                   MachineType p4 = kMachineLast)
       : MachineAssemblerTester<StructuredMachineAssembler>(
             ReturnValueTraits<ReturnType>::Representation(), p0, p1, p2, p3,
             p4) {}
 };
 
 
 static const bool USE_RESULT_BUFFER = true;
 static const bool USE_RETURN_REGISTER = false;
 static const int32_t CHECK_VALUE = 0x99BEEDCE;
 
 
 // TODO(titzer): use the C-style calling convention, or any register-based
 // calling convention for binop tests.
-template <typename CType, MachineRepresentation rep, bool use_result_buffer>
+template <typename CType, MachineType rep, bool use_result_buffer>
 class BinopTester {
  public:
   explicit BinopTester(RawMachineAssemblerTester<int32_t>* tester)
       : T(tester),
         param0(T->LoadFromPointer(&p0, rep)),
         param1(T->LoadFromPointer(&p1, rep)),
         p0(static_cast<CType>(0)),
         p1(static_cast<CType>(0)),
         result(static_cast<CType>(0)) {}
 
@@ skipping 185 matching lines @@
 
   void Run(RawMachineAssemblerTester<int32_t>* m);
   void RunLeft(RawMachineAssemblerTester<int32_t>* m);
   void RunRight(RawMachineAssemblerTester<int32_t>* m);
 };
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_CCTEST_COMPILER_CODEGEN_TESTER_H_