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

src/compiler/linkage.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_H_
 #define V8_COMPILER_LINKAGE_H_
 
 #include "src/v8.h"
 
 #include "src/code-stubs.h"
 #include "src/compiler/frame.h"
 #include "src/compiler/machine-operator.h"
 #include "src/compiler/node.h"
 #include "src/compiler/operator.h"
 #include "src/zone.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 // Describes the location for a parameter or a return value to a call.
 // TODO(titzer): replace with Radium locations when they are ready.
 class LinkageLocation {
  public:
-  LinkageLocation(MachineRepresentation rep, int location)
+  LinkageLocation(MachineType rep, int location)
       : rep_(rep), location_(location) {}
 
-  inline MachineRepresentation representation() const { return rep_; }
+  inline MachineType representation() const { return rep_; }
 
   static const int16_t ANY_REGISTER = 32767;
 
  private:
   friend class CallDescriptor;
   friend class OperandGenerator;
-  MachineRepresentation rep_;
+  MachineType rep_;
   int16_t location_;  // >= 0 implies register, otherwise stack slot.
 };
 
 
 class CallDescriptor : public ZoneObject {
  public:
   // Describes whether the first parameter is a code object, a JSFunction,
   // or an address--all of which require different machine sequences to call.
   enum Kind { kCallCodeObject, kCallJSFunction, kCallAddress };
 
@@ skipping 107 matching lines @@
           CallDescriptor::kCannotDeoptimize);
   static CallDescriptor* GetStubCallDescriptor(
       CodeStubInterfaceDescriptor* descriptor, int stack_parameter_count,
       CallDescriptor::DeoptimizationSupport can_deoptimize, Zone* zone);
 
   // Creates a call descriptor for simplified C calls that is appropriate
   // for the host platform. This simplified calling convention only supports
   // integers and pointers of one word size each, i.e. no floating point,
   // structs, pointers to members, etc.
   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);
 
   // Get the location of an (incoming) parameter to this function.
   LinkageLocation GetParameterLocation(int index) {
     return incoming_->GetInputLocation(index + 1);
   }
 
   // Get the location where this function should place its return value.
   LinkageLocation GetReturnLocation() {
     return incoming_->GetReturnLocation(0);
   }
 
   // Get the frame offset for a given spill slot. The location depends on the
   // calling convention and the specific frame layout, and may thus be
   // architecture-specific. Negative spill slots indicate arguments on the
   // caller's frame. The {extra} parameter indicates an additional offset from
   // the frame offset, e.g. to index into part of a double slot.
   FrameOffset GetFrameOffset(int spill_slot, Frame* frame, int extra = 0);
 
   CompilationInfo* info() const { return info_; }
 
  private:
   CompilationInfo* info_;
   CallDescriptor* incoming_;
 };
 }
 }
 }  // namespace v8::internal::compiler
 
 #endif  // V8_COMPILER_LINKAGE_H_