Unify MachineType and RepType.

test/cctest/compiler/call-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_CALL_TESTER_H_
 #define V8_CCTEST_COMPILER_CALL_TESTER_H_
 
 #include "src/v8.h"
 
 #include "src/simulator.h"
 
 #if V8_TARGET_ARCH_IA32
 #if __GNUC__
 #define V8_CDECL __attribute__((cdecl))
 #else
 #define V8_CDECL __cdecl
 #endif
 #else
 #define V8_CDECL
 #endif
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
+// TODO(titzer): move MachineType selection for C types into machine-type.h
 template <typename R>
 struct ReturnValueTraits {
   static R Cast(uintptr_t r) { return reinterpret_cast<R>(r); }
   static MachineType Representation() {
     // TODO(dcarney): detect when R is of a subclass of Object* instead of this
     // type check.
     while (false) {
       *(static_cast<Object* volatile*>(0)) = static_cast<R>(0);
     }
-    return kMachineTagged;
+    return kMachAnyTagged;
   }
 };
 
 template <>
 struct ReturnValueTraits<int32_t*> {
   static int32_t* Cast(uintptr_t r) { return reinterpret_cast<int32_t*>(r); }
-  static MachineType Representation() {
-    return MachineOperatorBuilder::pointer_rep();
-  }
+  static MachineType Representation() { return kMachPtr; }
 };
 
 template <>
 struct ReturnValueTraits<void> {
   static void Cast(uintptr_t r) {}
-  static MachineType Representation() {
-    return MachineOperatorBuilder::pointer_rep();
-  }
+  static MachineType Representation() { return kMachPtr; }
 };
 
 template <>
 struct ReturnValueTraits<bool> {
   static bool Cast(uintptr_t r) { return static_cast<bool>(r); }
-  static MachineType Representation() {
-    return MachineOperatorBuilder::pointer_rep();
-  }
+  static MachineType Representation() { return kRepBit; }
 };
 
 template <>
 struct ReturnValueTraits<int32_t> {
   static int32_t Cast(uintptr_t r) { return static_cast<int32_t>(r); }
-  static MachineType Representation() { return kMachineWord32; }
+  static MachineType Representation() { return kMachInt32; }
 };
 
 template <>
 struct ReturnValueTraits<uint32_t> {
   static uint32_t Cast(uintptr_t r) { return static_cast<uint32_t>(r); }
-  static MachineType Representation() { return kMachineWord32; }
+  static MachineType Representation() { return kMachUint32; }
 };
 
 template <>
 struct ReturnValueTraits<int64_t> {
   static int64_t Cast(uintptr_t r) { return static_cast<int64_t>(r); }
-  static MachineType Representation() { return kMachineWord64; }
+  static MachineType Representation() { return kMachInt64; }
 };
 
 template <>
 struct ReturnValueTraits<uint64_t> {
   static uint64_t Cast(uintptr_t r) { return static_cast<uint64_t>(r); }
-  static MachineType Representation() { return kMachineWord64; }
+  static MachineType Representation() { return kMachUint64; }
 };
 
 template <>
 struct ReturnValueTraits<int16_t> {
   static int16_t Cast(uintptr_t r) { return static_cast<int16_t>(r); }
-  static MachineType Representation() {
-    return MachineOperatorBuilder::pointer_rep();
-  }
+  static MachineType Representation() { return kMachInt16; }
 };
 
 template <>
 struct ReturnValueTraits<int8_t> {
   static int8_t Cast(uintptr_t r) { return static_cast<int8_t>(r); }
-  static MachineType Representation() {
-    return MachineOperatorBuilder::pointer_rep();
-  }
+  static MachineType Representation() { return kMachInt8; }
 };
 
 template <>
 struct ReturnValueTraits<double> {
   static double Cast(uintptr_t r) {
     UNREACHABLE();
     return 0.0;
   }
-  static MachineType Representation() { return kMachineFloat64; }
+  static MachineType Representation() { return kMachFloat64; }
 };
 
 
 template <typename R>
 struct ParameterTraits {
   static uintptr_t Cast(R r) { return static_cast<uintptr_t>(r); }
 };
 
 template <>
 struct ParameterTraits<int*> {
   static uintptr_t Cast(int* r) { return reinterpret_cast<uintptr_t>(r); }
 };
 
 template <typename T>
 struct ParameterTraits<T*> {
   static uintptr_t Cast(void* r) { return reinterpret_cast<uintptr_t>(r); }
 };
 
 class CallHelper {
  public:
   explicit CallHelper(Isolate* isolate) : isolate_(isolate) { USE(isolate_); }
   virtual ~CallHelper() {}
 
   static MachineCallDescriptorBuilder* ToCallDescriptorBuilder(
-      Zone* zone, MachineType return_type, MachineType p0 = kMachineLast,
-      MachineType p1 = kMachineLast, MachineType p2 = kMachineLast,
-      MachineType p3 = kMachineLast, MachineType p4 = kMachineLast) {
+      Zone* zone, MachineType return_type, MachineType p0 = kMachNone,
+      MachineType p1 = kMachNone, MachineType p2 = kMachNone,
+      MachineType p3 = kMachNone, MachineType p4 = kMachNone) {
     const int kSize = 5;
     MachineType* params = zone->NewArray<MachineType>(kSize);
     params[0] = p0;
     params[1] = p1;
     params[2] = p2;
     params[3] = p3;
     params[4] = p4;
     int parameter_count = 0;
     for (int i = 0; i < kSize; ++i) {
-      if (params[i] == kMachineLast) {
+      if (params[i] == kMachNone) {
         break;
       }
       parameter_count++;
     }
     return new (zone)
         MachineCallDescriptorBuilder(return_type, parameter_count, params);
   }
 
  protected:
   virtual void VerifyParameters(int parameter_count,
@@ skipping 218 matching lines @@
 
  private:
   CallHelper* helper() { return static_cast<C*>(this); }
 };
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_CCTEST_COMPILER_CALL_TESTER_H_