[turbofan] Make MachineType a pair of enums.

src/compiler/linkage.cc

 // 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.
 
 #include "src/ast/scopes.h"
 #include "src/code-stubs.h"
 #include "src/compiler.h"
 #include "src/compiler/common-operator.h"
 #include "src/compiler/frame.h"
 #include "src/compiler/linkage.h"
 #include "src/compiler/node.h"
 #include "src/compiler/osr.h"
 #include "src/compiler/pipeline.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 namespace {
 LinkageLocation regloc(Register reg) {
   return LinkageLocation::ForRegister(reg.code());
 }
 
 
 MachineType reptyp(Representation representation) {
   switch (representation.kind()) {
     case Representation::kInteger8:
-      return kMachInt8;
+      return MachineType::Int8();
     case Representation::kUInteger8:
-      return kMachUint8;
+      return MachineType::Uint8();
     case Representation::kInteger16:
-      return kMachInt16;
+      return MachineType::Int16();
     case Representation::kUInteger16:
-      return kMachUint16;
+      return MachineType::Uint16();
     case Representation::kInteger32:
-      return kMachInt32;
+      return MachineType::Int32();
     case Representation::kSmi:
     case Representation::kTagged:
     case Representation::kHeapObject:
-      return kMachAnyTagged;
+      return MachineType::AnyTagged();
     case Representation::kDouble:
-      return kMachFloat64;
+      return MachineType::Float64();
     case Representation::kExternal:
-      return kMachPtr;
+      return MachineType::Pointer();
     case Representation::kNone:
     case Representation::kNumRepresentations:
       break;
   }
   UNREACHABLE();
-  return kMachNone;
+  return MachineType::None();
 }
 }  // namespace
 
 
 std::ostream& operator<<(std::ostream& os, const CallDescriptor::Kind& k) {
   switch (k) {
     case CallDescriptor::kCallCodeObject:
       os << "Code";
       break;
     case CallDescriptor::kCallJSFunction:
@@ skipping 174 matching lines @@
   MachineSignature::Builder types(zone, return_count, parameter_count);
 
   // Add returns.
   if (locations.return_count_ > 0) {
     locations.AddReturn(regloc(kReturnRegister0));
   }
   if (locations.return_count_ > 1) {
     locations.AddReturn(regloc(kReturnRegister1));
   }
   for (size_t i = 0; i < return_count; i++) {
-    types.AddReturn(kMachAnyTagged);
+    types.AddReturn(MachineType::AnyTagged());
   }
 
   // All parameters to the runtime call go on the stack.
   for (int i = 0; i < js_parameter_count; i++) {
     locations.AddParam(
         LinkageLocation::ForCallerFrameSlot(i - js_parameter_count));
-    types.AddParam(kMachAnyTagged);
+    types.AddParam(MachineType::AnyTagged());
   }
   // Add runtime function itself.
   locations.AddParam(regloc(kRuntimeCallFunctionRegister));
-  types.AddParam(kMachAnyTagged);
+  types.AddParam(MachineType::AnyTagged());
 
   // Add runtime call argument count.
   locations.AddParam(regloc(kRuntimeCallArgCountRegister));
-  types.AddParam(kMachPtr);
+  types.AddParam(MachineType::Pointer());
 
   // Add context.
   locations.AddParam(regloc(kContextRegister));
-  types.AddParam(kMachAnyTagged);
+  types.AddParam(MachineType::AnyTagged());
 
   if (Linkage::FrameStateInputCount(function_id) == 0) {
     flags = static_cast<CallDescriptor::Flags>(
         flags & ~CallDescriptor::kNeedsFrameState);
   }
 
   // The target for runtime calls is a code object.
-  MachineType target_type = kMachAnyTagged;
+  MachineType target_type = MachineType::AnyTagged();
   LinkageLocation target_loc = LinkageLocation::ForAnyRegister();
   return new (zone) CallDescriptor(     // --
       CallDescriptor::kCallCodeObject,  // kind
       target_type,                      // target MachineType
       target_loc,                       // target location
       types.Build(),                    // machine_sig
       locations.Build(),                // location_sig
       js_parameter_count,               // stack_parameter_count
       properties,                       // properties
       kNoCalleeSaved,                   // callee-saved
       kNoCalleeSaved,                   // callee-saved fp
       flags,                            // flags
       function->name);                  // debug name
 }
 
 
 CallDescriptor* Linkage::GetLazyBailoutDescriptor(Zone* zone) {
   const size_t return_count = 0;
   const size_t parameter_count = 0;
 
   LocationSignature::Builder locations(zone, return_count, parameter_count);
   MachineSignature::Builder types(zone, return_count, parameter_count);
 
   // The target is ignored, but we need to give some values here.
-  MachineType target_type = kMachAnyTagged;
+  MachineType target_type = MachineType::AnyTagged();
   LinkageLocation target_loc = regloc(kJSFunctionRegister);
   return new (zone) CallDescriptor(      // --
       CallDescriptor::kLazyBailout,      // kind
       target_type,                       // target MachineType
       target_loc,                        // target location
       types.Build(),                     // machine_sig
       locations.Build(),                 // location_sig
       0,                                 // stack_parameter_count
       Operator::kNoThrow,                // properties
       kNoCalleeSaved,                    // callee-saved
@@ skipping 11 matching lines @@
   const size_t new_target_count = 1;
   const size_t num_args_count = 1;
   const size_t parameter_count =
       js_parameter_count + new_target_count + num_args_count + context_count;
 
   LocationSignature::Builder locations(zone, return_count, parameter_count);
   MachineSignature::Builder types(zone, return_count, parameter_count);
 
   // All JS calls have exactly one return value.
   locations.AddReturn(regloc(kReturnRegister0));
-  types.AddReturn(kMachAnyTagged);
+  types.AddReturn(MachineType::AnyTagged());
 
   // All parameters to JS calls go on the stack.
   for (int i = 0; i < js_parameter_count; i++) {
     int spill_slot_index = i - js_parameter_count;
     locations.AddParam(LinkageLocation::ForCallerFrameSlot(spill_slot_index));
-    types.AddParam(kMachAnyTagged);
+    types.AddParam(MachineType::AnyTagged());
   }
 
   // Add JavaScript call new target value.
   locations.AddParam(regloc(kJavaScriptCallNewTargetRegister));
-  types.AddParam(kMachAnyTagged);
+  types.AddParam(MachineType::AnyTagged());
 
   // Add JavaScript call argument count.
   locations.AddParam(regloc(kJavaScriptCallArgCountRegister));
-  types.AddParam(kMachInt32);
+  types.AddParam(MachineType::Int32());
 
   // Add context.
   locations.AddParam(regloc(kContextRegister));
-  types.AddParam(kMachAnyTagged);
+  types.AddParam(MachineType::AnyTagged());
 
   // The target for JS function calls is the JSFunction object.
-  MachineType target_type = kMachAnyTagged;
+  MachineType target_type = MachineType::AnyTagged();
   // TODO(titzer): When entering into an OSR function from unoptimized code,
   // the JSFunction is not in a register, but it is on the stack in an
   // unaddressable spill slot. We hack this in the OSR prologue. Fix.
   LinkageLocation target_loc = regloc(kJSFunctionRegister);
   return new (zone) CallDescriptor(     // --
       CallDescriptor::kCallJSFunction,  // kind
       target_type,                      // target MachineType
       target_loc,                       // target location
       types.Build(),                    // machine_sig
       locations.Build(),                // location_sig
       js_parameter_count,               // stack_parameter_count
       Operator::kNoProperties,          // properties
       kNoCalleeSaved,                   // callee-saved
       kNoCalleeSaved,                   // callee-saved fp
       CallDescriptor::kCanUseRoots |    // flags
           flags,                        // flags
       "js-call");
 }
 
 
 CallDescriptor* Linkage::GetInterpreterDispatchDescriptor(Zone* zone) {
   MachineSignature::Builder types(zone, 0, 6);
   LocationSignature::Builder locations(zone, 0, 6);
 
   // Add registers for fixed parameters passed via interpreter dispatch.
   STATIC_ASSERT(0 == Linkage::kInterpreterAccumulatorParameter);
-  types.AddParam(kMachAnyTagged);
+  types.AddParam(MachineType::AnyTagged());
   locations.AddParam(regloc(kInterpreterAccumulatorRegister));
 
   STATIC_ASSERT(1 == Linkage::kInterpreterRegisterFileParameter);
-  types.AddParam(kMachPtr);
+  types.AddParam(MachineType::Pointer());
   locations.AddParam(regloc(kInterpreterRegisterFileRegister));
 
   STATIC_ASSERT(2 == Linkage::kInterpreterBytecodeOffsetParameter);
-  types.AddParam(kMachIntPtr);
+  types.AddParam(MachineType::IntPtr());
   locations.AddParam(regloc(kInterpreterBytecodeOffsetRegister));
 
   STATIC_ASSERT(3 == Linkage::kInterpreterBytecodeArrayParameter);
-  types.AddParam(kMachAnyTagged);
+  types.AddParam(MachineType::AnyTagged());
   locations.AddParam(regloc(kInterpreterBytecodeArrayRegister));
 
   STATIC_ASSERT(4 == Linkage::kInterpreterDispatchTableParameter);
-  types.AddParam(kMachPtr);
+  types.AddParam(MachineType::Pointer());
 #if defined(V8_TARGET_ARCH_IA32) || defined(V8_TARGET_ARCH_X87)
   // TODO(rmcilroy): Make the context param the one spilled to the stack once
   // Turbofan supports modified stack arguments in tail calls.
   locations.AddParam(
       LinkageLocation::ForCallerFrameSlot(kInterpreterDispatchTableSpillSlot));
 #else
   locations.AddParam(regloc(kInterpreterDispatchTableRegister));
 #endif
 
   STATIC_ASSERT(5 == Linkage::kInterpreterContextParameter);
-  types.AddParam(kMachAnyTagged);
+  types.AddParam(MachineType::AnyTagged());
   locations.AddParam(regloc(kContextRegister));
 
   LinkageLocation target_loc = LinkageLocation::ForAnyRegister();
   return new (zone) CallDescriptor(         // --
       CallDescriptor::kCallCodeObject,      // kind
-      kMachNone,                            // target MachineType
+      MachineType::None(),                  // target MachineType
       target_loc,                           // target location
       types.Build(),                        // machine_sig
       locations.Build(),                    // location_sig
       0,                                    // stack_parameter_count
       Operator::kNoProperties,              // properties
       kNoCalleeSaved,                       // callee-saved registers
       kNoCalleeSaved,                       // callee-saved fp regs
       CallDescriptor::kSupportsTailCalls |  // flags
           CallDescriptor::kCanUseRoots,     // flags
       "interpreter-dispatch");
@@ skipping 28 matching lines @@
       // The first parameters go in registers.
       Register reg = descriptor.GetRegisterParameter(i);
       Representation rep =
           RepresentationFromType(descriptor.GetParameterType(i));
       locations.AddParam(regloc(reg));
       types.AddParam(reptyp(rep));
     } else {
       // The rest of the parameters go on the stack.
       int stack_slot = i - register_parameter_count - stack_parameter_count;
       locations.AddParam(LinkageLocation::ForCallerFrameSlot(stack_slot));
-      types.AddParam(kMachAnyTagged);
+      types.AddParam(MachineType::AnyTagged());
     }
   }
   // Add context.
   locations.AddParam(regloc(kContextRegister));
-  types.AddParam(kMachAnyTagged);
+  types.AddParam(MachineType::AnyTagged());
 
   // The target for stub calls is a code object.
-  MachineType target_type = kMachAnyTagged;
+  MachineType target_type = MachineType::AnyTagged();
   LinkageLocation target_loc = LinkageLocation::ForAnyRegister();
   return new (zone) CallDescriptor(     // --
       CallDescriptor::kCallCodeObject,  // kind
       target_type,                      // target MachineType
       target_loc,                       // target location
       types.Build(),                    // machine_sig
       locations.Build(),                // location_sig
       stack_parameter_count,            // stack_parameter_count
       properties,                       // properties
       kNoCalleeSaved,                   // callee-saved registers
@@ skipping 43 matching lines @@
   } else {
     DCHECK(loc == regloc(kContextRegister));
     return LinkageLocation::ForCalleeFrameSlot(Frame::kContextSlot);
   }
 }
 
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8