[turbofan] Make MachineType a pair of enums.

test/cctest/compiler/test-run-native-calls.cc

 // Copyright 2015 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.
 
 #include "src/assembler.h"
 #include "src/codegen.h"
 #include "src/compiler/linkage.h"
 #include "src/compiler/raw-machine-assembler.h"
 #include "src/machine-type.h"
 #include "src/register-configuration.h"
@@ skipping 115 matching lines @@
   int gp_offset;
   int* gp_regs;
 
   int fp_count;
   int fp_offset;
   int* fp_regs;
 
   int stack_offset;
 
   LinkageLocation Next(MachineType type) {
-    if (IsFloatingPoint(type)) {
+    if (IsFloatingPoint(type.representation())) {
       // Allocate a floating point register/stack location.
       if (fp_offset < fp_count) {
         return LinkageLocation::ForRegister(fp_regs[fp_offset++]);
       } else {
         int offset = -1 - stack_offset;
         stack_offset += StackWords(type);
         return LinkageLocation::ForCallerFrameSlot(offset);
       }
     } else {
       // Allocate a general purpose register/stack location.
       if (gp_offset < gp_count) {
         return LinkageLocation::ForRegister(gp_regs[gp_offset++]);
       } else {
         int offset = -1 - stack_offset;
         stack_offset += StackWords(type);
         return LinkageLocation::ForCallerFrameSlot(offset);
       }
     }
   }
-  bool IsFloatingPoint(MachineType type) {
-    return RepresentationOf(type) == kRepFloat32 ||
-           RepresentationOf(type) == kRepFloat64;
-  }
   int StackWords(MachineType type) {
     // TODO(titzer): hack. float32 occupies 8 bytes on stack.
-    int size = (RepresentationOf(type) == kRepFloat32 ||
-                RepresentationOf(type) == kRepFloat64)
+    int size = IsFloatingPoint(type.representation())
                    ? kDoubleSize
-                   : ElementSizeOf(type);
+                   : (1 << ElementSizeLog2Of(type.representation()));
     return size <= kPointerSize ? 1 : size / kPointerSize;
   }
   void Reset() {
     fp_offset = 0;
     gp_offset = 0;
     stack_offset = 0;
   }
 };
 
 
@@ skipping 15 matching lines @@
 
     // Add register and/or stack parameter(s).
     const int parameter_count = static_cast<int>(msig->parameter_count());
     for (int i = 0; i < parameter_count; i++) {
       locations.AddParam(params.Next(msig->GetParam(i)));
     }
 
     const RegList kCalleeSaveRegisters = 0;
     const RegList kCalleeSaveFPRegisters = 0;
 
-    MachineType target_type = kMachAnyTagged;
+    MachineType target_type = MachineType::AnyTagged();
     LinkageLocation target_loc = LinkageLocation::ForAnyRegister();
     int stack_param_count = params.stack_offset;
     return new (zone) CallDescriptor(       // --
         CallDescriptor::kCallCodeObject,    // kind
         target_type,                        // target MachineType
         target_loc,                         // target location
         msig,                               // machine_sig
         locations.Build(),                  // location_sig
         stack_param_count,                  // stack_parameter_count
         compiler::Operator::kNoProperties,  // properties
         kCalleeSaveRegisters,               // callee-saved registers
         kCalleeSaveFPRegisters,             // callee-saved fp regs
         CallDescriptor::kUseNativeStack,    // flags
         "c-call");
   }
 
  private:
   Allocator& params;
   Allocator& rets;
 };
 
 const int kMaxParamCount = 64;
 
 MachineType kIntTypes[kMaxParamCount + 1] = {
-    kMachInt32, kMachInt32, kMachInt32, kMachInt32, kMachInt32, kMachInt32,
-    kMachInt32, kMachInt32, kMachInt32, kMachInt32, kMachInt32, kMachInt32,
-    kMachInt32, kMachInt32, kMachInt32, kMachInt32, kMachInt32, kMachInt32,
-    kMachInt32, kMachInt32, kMachInt32, kMachInt32, kMachInt32, kMachInt32,
-    kMachInt32, kMachInt32, kMachInt32, kMachInt32, kMachInt32, kMachInt32,
-    kMachInt32, kMachInt32, kMachInt32, kMachInt32, kMachInt32, kMachInt32,
-    kMachInt32, kMachInt32, kMachInt32, kMachInt32, kMachInt32, kMachInt32,
-    kMachInt32, kMachInt32, kMachInt32, kMachInt32, kMachInt32, kMachInt32,
-    kMachInt32, kMachInt32, kMachInt32, kMachInt32, kMachInt32, kMachInt32,
-    kMachInt32, kMachInt32, kMachInt32, kMachInt32, kMachInt32, kMachInt32,
-    kMachInt32, kMachInt32, kMachInt32, kMachInt32, kMachInt32};
+    MachineType::Int32(), MachineType::Int32(), MachineType::Int32(),
+    MachineType::Int32(), MachineType::Int32(), MachineType::Int32(),
+    MachineType::Int32(), MachineType::Int32(), MachineType::Int32(),
+    MachineType::Int32(), MachineType::Int32(), MachineType::Int32(),
+    MachineType::Int32(), MachineType::Int32(), MachineType::Int32(),
+    MachineType::Int32(), MachineType::Int32(), MachineType::Int32(),
+    MachineType::Int32(), MachineType::Int32(), MachineType::Int32(),
+    MachineType::Int32(), MachineType::Int32(), MachineType::Int32(),
+    MachineType::Int32(), MachineType::Int32(), MachineType::Int32(),
+    MachineType::Int32(), MachineType::Int32(), MachineType::Int32(),
+    MachineType::Int32(), MachineType::Int32(), MachineType::Int32(),
+    MachineType::Int32(), MachineType::Int32(), MachineType::Int32(),
+    MachineType::Int32(), MachineType::Int32(), MachineType::Int32(),
+    MachineType::Int32(), MachineType::Int32(), MachineType::Int32(),
+    MachineType::Int32(), MachineType::Int32(), MachineType::Int32(),
+    MachineType::Int32(), MachineType::Int32(), MachineType::Int32(),
+    MachineType::Int32(), MachineType::Int32(), MachineType::Int32(),
+    MachineType::Int32(), MachineType::Int32(), MachineType::Int32(),
+    MachineType::Int32(), MachineType::Int32(), MachineType::Int32(),
+    MachineType::Int32(), MachineType::Int32(), MachineType::Int32(),
+    MachineType::Int32(), MachineType::Int32(), MachineType::Int32(),
+    MachineType::Int32(), MachineType::Int32()};
 
 
 // For making uniform int32 signatures shorter.
 class Int32Signature : public MachineSignature {
  public:
   explicit Int32Signature(int param_count)
       : MachineSignature(1, param_count, kIntTypes) {
     CHECK(param_count <= kMaxParamCount);
   }
 };
@@ skipping 309 matching lines @@
   HandleScope scope(isolate);
   Handle<Code> inner = Handle<Code>::null();
   {
     // Writes all parameters into the output buffer.
     Zone zone;
     Graph graph(&zone);
     RawMachineAssembler raw(isolate, &graph, desc);
     Node* base = raw.PointerConstant(output);
     for (int i = 0; i < kNumParams; i++) {
       Node* offset = raw.Int32Constant(i * sizeof(int32_t));
-      raw.Store(kMachInt32, base, offset, raw.Parameter(i), kNoWriteBarrier);
+      raw.Store(MachineType::Int32(), base, offset, raw.Parameter(i),
+                kNoWriteBarrier);
     }
     raw.Return(raw.Int32Constant(42));
     inner = CompileGraph("CopyTwentyInt32", desc, &graph, raw.Export());
   }
 
   CSignature0<int32_t> csig;
   Handle<Code> wrapper = Handle<Code>::null();
   {
     // Loads parameters from the input buffer and calls the above code.
     Zone zone;
     Graph graph(&zone);
     CallDescriptor* cdesc = Linkage::GetSimplifiedCDescriptor(&zone, &csig);
     RawMachineAssembler raw(isolate, &graph, cdesc);
     Node* base = raw.PointerConstant(input);
     Node* target = raw.HeapConstant(inner);
     Node** args = zone.NewArray<Node*>(kNumParams);
     for (int i = 0; i < kNumParams; i++) {
       Node* offset = raw.Int32Constant(i * sizeof(int32_t));
-      args[i] = raw.Load(kMachInt32, base, offset);
+      args[i] = raw.Load(MachineType::Int32(), base, offset);
     }
 
     Node* call = raw.CallN(desc, target, args);
     raw.Return(call);
     wrapper =
         CompileGraph("CopyTwentyInt32-wrapper", cdesc, &graph, raw.Export());
   }
 
   CodeRunner<int32_t> runnable(isolate, wrapper, &csig);
 
@@ skipping 413 matching lines @@
 
 
 void MixedParamTest(int start) {
   if (RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
           ->num_double_registers() < 2)
     return;
 
 // TODO(titzer): mix in 64-bit types on all platforms when supported.
 #if V8_TARGET_ARCH_32_BIT
   static MachineType types[] = {
-      kMachInt32,   kMachFloat32, kMachFloat64, kMachInt32,   kMachFloat64,
-      kMachFloat32, kMachFloat32, kMachFloat64, kMachInt32,   kMachFloat32,
-      kMachInt32,   kMachFloat64, kMachFloat64, kMachFloat32, kMachInt32,
-      kMachFloat64, kMachInt32,   kMachFloat32};
+      MachineType::Int32(),   MachineType::Float32(), MachineType::Float64(),
+      MachineType::Int32(),   MachineType::Float64(), MachineType::Float32(),
+      MachineType::Float32(), MachineType::Float64(), MachineType::Int32(),
+      MachineType::Float32(), MachineType::Int32(),   MachineType::Float64(),
+      MachineType::Float64(), MachineType::Float32(), MachineType::Int32(),
+      MachineType::Float64(), MachineType::Int32(),   MachineType::Float32()};
 #else
   static MachineType types[] = {
-      kMachInt32,   kMachInt64,   kMachFloat32, kMachFloat64, kMachInt32,
-      kMachFloat64, kMachFloat32, kMachInt64,   kMachInt64,   kMachFloat32,
-      kMachFloat32, kMachInt32,   kMachFloat64, kMachFloat64, kMachInt64,
-      kMachInt32,   kMachFloat64, kMachInt32,   kMachFloat32};
+      MachineType::Int32(),   MachineType::Int64(),   MachineType::Float32(),
+      MachineType::Float64(), MachineType::Int32(),   MachineType::Float64(),
+      MachineType::Float32(), MachineType::Int64(),   MachineType::Int64(),
+      MachineType::Float32(), MachineType::Float32(), MachineType::Int32(),
+      MachineType::Float64(), MachineType::Float64(), MachineType::Int64(),
+      MachineType::Int32(),   MachineType::Float64(), MachineType::Int32(),
+      MachineType::Float32()};
 #endif
 
   Isolate* isolate = CcTest::InitIsolateOnce();
 
   // Build machine signature
   MachineType* params = &types[start];
   const int num_params = static_cast<int>(arraysize(types) - start);
 
   // Build call descriptor
   int parray_gp[] = {
@@ skipping 48 matching lines @@
         Zone zone;
         Graph graph(&zone);
         CallDescriptor* cdesc = Linkage::GetSimplifiedCDescriptor(&zone, &csig);
         RawMachineAssembler raw(isolate, &graph, cdesc);
         Node* target = raw.HeapConstant(select);
         Node** args = zone.NewArray<Node*>(num_params);
         int64_t constant = 0x0102030405060708;
         for (int i = 0; i < num_params; i++) {
           MachineType param_type = sig->GetParam(i);
           Node* konst = nullptr;
-          if (param_type == kMachInt32) {
+          if (param_type == MachineType::Int32()) {
             int32_t value[] = {static_cast<int32_t>(constant)};
             konst = raw.Int32Constant(value[0]);
             if (i == which) memcpy(bytes, value, expected_size = 4);
           }
-          if (param_type == kMachInt64) {
+          if (param_type == MachineType::Int64()) {
             int64_t value[] = {static_cast<int64_t>(constant)};
             konst = raw.Int64Constant(value[0]);
             if (i == which) memcpy(bytes, value, expected_size = 8);
           }
-          if (param_type == kMachFloat32) {
+          if (param_type == MachineType::Float32()) {
             float32 value[] = {static_cast<float32>(constant)};
             konst = raw.Float32Constant(value[0]);
             if (i == which) memcpy(bytes, value, expected_size = 4);
           }
-          if (param_type == kMachFloat64) {
+          if (param_type == MachineType::Float64()) {
             float64 value[] = {static_cast<float64>(constant)};
             konst = raw.Float64Constant(value[0]);
             if (i == which) memcpy(bytes, value, expected_size = 8);
           }
           CHECK_NOT_NULL(konst);
 
           args[i] = konst;
           constant += 0x1010101010101010;
         }
 
@@ skipping 17 matching lines @@
 
 
 TEST(MixedParams_0) { MixedParamTest(0); }
 TEST(MixedParams_1) { MixedParamTest(1); }
 TEST(MixedParams_2) { MixedParamTest(2); }
 TEST(MixedParams_3) { MixedParamTest(3); }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8