Unify MachineType and RepType.

src/compiler/linkage-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_LINKAGE_IMPL_H_
 #define V8_COMPILER_LINKAGE_IMPL_H_
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 class LinkageHelper {
  public:
   static LinkageLocation TaggedStackSlot(int index) {
     DCHECK(index < 0);
-    return LinkageLocation(kMachineTagged, index);
+    return LinkageLocation(kMachAnyTagged, index);
   }
 
   static LinkageLocation TaggedRegisterLocation(Register reg) {
-    return LinkageLocation(kMachineTagged, Register::ToAllocationIndex(reg));
+    return LinkageLocation(kMachAnyTagged, Register::ToAllocationIndex(reg));
   }
 
   static inline LinkageLocation WordRegisterLocation(Register reg) {
     return LinkageLocation(MachineOperatorBuilder::pointer_rep(),
                            Register::ToAllocationIndex(reg));
   }
 
   static LinkageLocation UnconstrainedRegister(MachineType rep) {
     return LinkageLocation(rep, LinkageLocation::ANY_REGISTER);
   }
@@ skipping 60 matching lines @@
       locations[index++] =
           TaggedRegisterLocation(LinkageTraits::ReturnValueReg());
     }
     if (return_count > 1) {
       locations[index++] =
           TaggedRegisterLocation(LinkageTraits::ReturnValue2Reg());
     }
 
     DCHECK_LE(return_count, 2);
 
-    locations[index++] = UnconstrainedRegister(kMachineTagged);  // CEntryStub
+    locations[index++] = UnconstrainedRegister(kMachAnyTagged);  // CEntryStub
 
     for (int i = 0; i < parameter_count; i++) {
       // All parameters to runtime calls go on the stack.
       int spill_slot_index = i - parameter_count;
       locations[index++] = TaggedStackSlot(spill_slot_index);
     }
     locations[index++] =
         TaggedRegisterLocation(LinkageTraits::RuntimeCallFunctionReg());
     locations[index++] =
         WordRegisterLocation(LinkageTraits::RuntimeCallArgCountReg());
@@ skipping 24 matching lines @@
     const int context_count = 1;
     int input_count = code_count + parameter_count + context_count;
 
     const int return_count = 1;
     LinkageLocation* locations =
         zone->NewArray<LinkageLocation>(return_count + input_count);
 
     int index = 0;
     locations[index++] =
         TaggedRegisterLocation(LinkageTraits::ReturnValueReg());
-    locations[index++] = UnconstrainedRegister(kMachineTagged);  // code
+    locations[index++] = UnconstrainedRegister(kMachAnyTagged);  // code
     for (int i = 0; i < parameter_count; i++) {
       if (i < register_parameter_count) {
         // The first parameters to code stub calls go in registers.
         Register reg = descriptor->GetEnvironmentParameterRegister(i);
         locations[index++] = TaggedRegisterLocation(reg);
       } else {
         // The rest of the parameters go on the stack.
         int stack_slot = i - register_parameter_count - stack_parameter_count;
         locations[index++] = TaggedStackSlot(stack_slot);
       }
@@ skipping 40 matching lines @@
         CallDescriptor::kCallAddress, 1, num_params, num_params + 1, locations,
         Operator::kNoProperties, LinkageTraits::CCalleeSaveRegisters(),
         CallDescriptor::kCannotDeoptimize);  // TODO(jarin) should deoptimize!
   }
 };
 }
 }
 }  // namespace v8::internal::compiler
 
 #endif  // V8_COMPILER_LINKAGE_IMPL_H_