[turbofan] Make MachineType a pair of enums.

src/compiler/instruction-selector-impl.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_COMPILER_INSTRUCTION_SELECTOR_IMPL_H_
 #define V8_COMPILER_INSTRUCTION_SELECTOR_IMPL_H_
 
 #include "src/compiler/instruction.h"
 #include "src/compiler/instruction-selector.h"
 #include "src/compiler/linkage.h"
@@ skipping 50 matching lines @@
   }
 
   InstructionOperand DefineAsConstant(Node* node) {
     selector()->MarkAsDefined(node);
     int virtual_register = GetVReg(node);
     sequence()->AddConstant(virtual_register, ToConstant(node));
     return ConstantOperand(virtual_register);
   }
 
   InstructionOperand DefineAsLocation(Node* node, LinkageLocation location,
-                                      MachineType type) {
-    return Define(node, ToUnallocatedOperand(location, type, GetVReg(node)));
+                                      MachineRepresentation rep) {
+    return Define(node, ToUnallocatedOperand(location, rep, GetVReg(node)));
   }
 
   InstructionOperand DefineAsDualLocation(Node* node,
                                           LinkageLocation primary_location,
                                           LinkageLocation secondary_location) {
     return Define(node,
                   ToDualLocationUnallocatedOperand(
                       primary_location, secondary_location, GetVReg(node)));
   }
 
@@ skipping 39 matching lines @@
                                         reg.code(), GetVReg(node)));
   }
 
   InstructionOperand UseFixed(Node* node, DoubleRegister reg) {
     return Use(node,
                UnallocatedOperand(UnallocatedOperand::FIXED_DOUBLE_REGISTER,
                                   reg.code(), GetVReg(node)));
   }
 
   InstructionOperand UseExplicit(LinkageLocation location) {
-    MachineType machine_type = InstructionSequence::DefaultRepresentation();
+    MachineRepresentation rep = InstructionSequence::DefaultRepresentation();
     if (location.IsRegister()) {
-      return ExplicitOperand(LocationOperand::REGISTER, machine_type,
+      return ExplicitOperand(LocationOperand::REGISTER, rep,
                              location.AsRegister());
     } else {
-      return ExplicitOperand(LocationOperand::STACK_SLOT, machine_type,
+      return ExplicitOperand(LocationOperand::STACK_SLOT, rep,
                              location.GetLocation());
     }
   }
 
   InstructionOperand UseImmediate(Node* node) {
     return sequence()->AddImmediate(ToConstant(node));
   }
 
   InstructionOperand UseLocation(Node* node, LinkageLocation location,
-                                 MachineType type) {
-    return Use(node, ToUnallocatedOperand(location, type, GetVReg(node)));
+                                 MachineRepresentation rep) {
+    return Use(node, ToUnallocatedOperand(location, rep, GetVReg(node)));
   }
 
   // Used to force gap moves from the from_location to the to_location
   // immediately before an instruction.
   InstructionOperand UsePointerLocation(LinkageLocation to_location,
                                         LinkageLocation from_location) {
-    MachineType type = static_cast<MachineType>(kTypeAny | kMachPtr);
+    MachineRepresentation rep = MachineType::PointerRepresentation();
     UnallocatedOperand casted_from_operand =
-        UnallocatedOperand::cast(TempLocation(from_location, type));
+        UnallocatedOperand::cast(TempLocation(from_location, rep));
     selector_->Emit(kArchNop, casted_from_operand);
-    return ToUnallocatedOperand(to_location, type,
+    return ToUnallocatedOperand(to_location, rep,
                                 casted_from_operand.virtual_register());
   }
 
   InstructionOperand TempRegister() {
     return UnallocatedOperand(UnallocatedOperand::MUST_HAVE_REGISTER,
                               UnallocatedOperand::USED_AT_START,
                               sequence()->NextVirtualRegister());
   }
 
   InstructionOperand TempDoubleRegister() {
     UnallocatedOperand op = UnallocatedOperand(
         UnallocatedOperand::MUST_HAVE_REGISTER,
         UnallocatedOperand::USED_AT_START, sequence()->NextVirtualRegister());
-    sequence()->MarkAsRepresentation(kRepFloat64, op.virtual_register());
+    sequence()->MarkAsRepresentation(MachineRepresentation::kFloat64,
+                                     op.virtual_register());
     return op;
   }
 
   InstructionOperand TempRegister(Register reg) {
     return UnallocatedOperand(UnallocatedOperand::FIXED_REGISTER, reg.code(),
                               InstructionOperand::kInvalidVirtualRegister);
   }
 
   InstructionOperand TempImmediate(int32_t imm) {
     return sequence()->AddImmediate(Constant(imm));
   }
 
-  InstructionOperand TempLocation(LinkageLocation location, MachineType type) {
-    return ToUnallocatedOperand(location, type,
+  InstructionOperand TempLocation(LinkageLocation location,
+                                  MachineRepresentation rep) {
+    return ToUnallocatedOperand(location, rep,
                                 sequence()->NextVirtualRegister());
   }
 
   InstructionOperand Label(BasicBlock* block) {
     return sequence()->AddImmediate(
         Constant(RpoNumber::FromInt(block->rpo_number())));
   }
 
  protected:
   InstructionSelector* selector() const { return selector_; }
@@ skipping 45 matching lines @@
     // We only support the primary location being a register and the secondary
     // one a slot.
     DCHECK(primary_location.IsRegister() &&
            secondary_location.IsCalleeFrameSlot());
     int reg_id = primary_location.AsRegister();
     int slot_id = secondary_location.AsCalleeFrameSlot();
     return UnallocatedOperand(reg_id, slot_id, virtual_register);
   }
 
   UnallocatedOperand ToUnallocatedOperand(LinkageLocation location,
-                                          MachineType type,
+                                          MachineRepresentation rep,
                                           int virtual_register) {
     if (location.IsAnyRegister()) {
       // any machine register.
       return UnallocatedOperand(UnallocatedOperand::MUST_HAVE_REGISTER,
                                 virtual_register);
     }
     if (location.IsCallerFrameSlot()) {
       // a location on the caller frame.
       return UnallocatedOperand(UnallocatedOperand::FIXED_SLOT,
                                 location.AsCallerFrameSlot(), virtual_register);
     }
     if (location.IsCalleeFrameSlot()) {
       // a spill location on this (callee) frame.
       return UnallocatedOperand(UnallocatedOperand::FIXED_SLOT,
                                 location.AsCalleeFrameSlot(), virtual_register);
     }
     // a fixed register.
-    MachineType rep = RepresentationOf(type);
-    if (rep == kRepFloat64 || rep == kRepFloat32) {
+    if (IsFloatingPoint(rep)) {
       return UnallocatedOperand(UnallocatedOperand::FIXED_DOUBLE_REGISTER,
                                 location.AsRegister(), virtual_register);
     }
     return UnallocatedOperand(UnallocatedOperand::FIXED_REGISTER,
                               location.AsRegister(), virtual_register);
   }
 
   InstructionSelector* selector_;
 };
 
@@ skipping 76 matching lines @@
   Node* result_;             // Only valid if mode_ == kFlags_set.
   BasicBlock* true_block_;   // Only valid if mode_ == kFlags_branch.
   BasicBlock* false_block_;  // Only valid if mode_ == kFlags_branch.
 };
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_INSTRUCTION_SELECTOR_IMPL_H_