Move MachineRepresentation to machine-type.h and rename to MachineType in preparation for merging i…

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);
   }
 
   static LinkageLocation TaggedRegisterLocation(Register reg) {
     return LinkageLocation(kMachineTagged, Register::ToAllocationIndex(reg));
   }
 
   static inline LinkageLocation WordRegisterLocation(Register reg) {
     return LinkageLocation(MachineOperatorBuilder::pointer_rep(),
                            Register::ToAllocationIndex(reg));
   }
 
-  static LinkageLocation UnconstrainedRegister(MachineRepresentation rep) {
+  static LinkageLocation UnconstrainedRegister(MachineType rep) {
     return LinkageLocation(rep, LinkageLocation::ANY_REGISTER);
   }
 
   static const RegList kNoCalleeSaved = 0;
 
   // TODO(turbofan): cache call descriptors for JSFunction calls.
   template <typename LinkageTraits>
   static CallDescriptor* GetJSCallDescriptor(Zone* zone, int parameter_count) {
     const int jsfunction_count = 1;
     const int context_count = 1;
@@ skipping 127 matching lines @@
                        locations,                        // locations
                        Operator::kNoProperties,          // properties
                        kNoCalleeSaved,  // callee-saved registers
                        can_deoptimize,  // deoptimization
                        CodeStub::MajorName(descriptor->MajorKey(), false));
   }
 
 
   template <typename LinkageTraits>
   static CallDescriptor* GetSimplifiedCDescriptor(
-      Zone* zone, int num_params, MachineRepresentation return_type,
-      const MachineRepresentation* param_types) {
+      Zone* zone, int num_params, MachineType return_type,
+      const MachineType* param_types) {
     LinkageLocation* locations =
         zone->NewArray<LinkageLocation>(num_params + 2);
     int index = 0;
     locations[index++] =
         TaggedRegisterLocation(LinkageTraits::ReturnValueReg());
     locations[index++] = LinkageHelper::UnconstrainedRegister(
         MachineOperatorBuilder::pointer_rep());
     // TODO(dcarney): test with lots of parameters.
     int i = 0;
     for (; i < LinkageTraits::CRegisterParametersLength() && i < num_params;
          i++) {
       locations[index++] = LinkageLocation(
           param_types[i],
           Register::ToAllocationIndex(LinkageTraits::CRegisterParameter(i)));
     }
     for (; i < num_params; i++) {
       locations[index++] = LinkageLocation(param_types[i], -1 - i);
     }
     return new (zone) CallDescriptor(
         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_