[turbofan] First step of Operator refactoring.

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/base/flags.h"
 #include "src/code-stubs.h"
 #include "src/compiler/frame.h"
@@ skipping 36 matching lines @@
     kNoFlags = 0u,
     kNeedsFrameState = 1u << 0,
     kPatchableCallSite = 1u << 1,
     kNeedsNopAfterCall = 1u << 2,
     kPatchableCallSiteWithNop = kPatchableCallSite | kNeedsNopAfterCall
   };
   typedef base::Flags<Flag> Flags;
 
   CallDescriptor(Kind kind, int8_t return_count, int16_t parameter_count,
                  int16_t input_count, LinkageLocation* locations,
-                 Operator::Property properties, RegList callee_saved_registers,
-                 Flags flags, const char* debug_name = "")
+                 Operator::Properties properties,
+                 RegList callee_saved_registers, Flags flags,
+                 const char* debug_name = "")
       : kind_(kind),
         return_count_(return_count),
         parameter_count_(parameter_count),
         input_count_(input_count),
         locations_(locations),
         properties_(properties),
         callee_saved_registers_(callee_saved_registers),
         flags_(flags),
         debug_name_(debug_name) {}
   // Returns the kind of this call.
@@ skipping 21 matching lines @@
     DCHECK(index < return_count_);
     return locations_[0 + index];  // return locations start at 0.
   }
 
   LinkageLocation GetInputLocation(int index) {
     DCHECK(index < input_count_ + 1);  // input_count + 1 is the context.
     return locations_[return_count_ + index];  // inputs start after returns.
   }
 
   // Operator properties describe how this call can be optimized, if at all.
-  Operator::Property properties() const { return properties_; }
+  Operator::Properties properties() const { return properties_; }
 
   // Get the callee-saved registers, if any, across this call.
   RegList CalleeSavedRegisters() { return callee_saved_registers_; }
 
   const char* debug_name() const { return debug_name_; }
 
  private:
   friend class Linkage;
 
   Kind kind_;
   int8_t return_count_;
   int16_t parameter_count_;
   int16_t input_count_;
   LinkageLocation* locations_;
-  Operator::Property properties_;
+  Operator::Properties properties_;
   RegList callee_saved_registers_;
   Flags flags_;
   const char* debug_name_;
 };
 
 DEFINE_OPERATORS_FOR_FLAGS(CallDescriptor::Flags)
 
 OStream& operator<<(OStream& os, const CallDescriptor& d);
 OStream& operator<<(OStream& os, const CallDescriptor::Kind& k);
 
@@ skipping 16 matching lines @@
   explicit Linkage(CompilationInfo* info, CallDescriptor* incoming)
       : info_(info), incoming_(incoming) {}
 
   // The call descriptor for this compilation unit describes the locations
   // of incoming parameters and the outgoing return value(s).
   CallDescriptor* GetIncomingDescriptor() { return incoming_; }
   CallDescriptor* GetJSCallDescriptor(int parameter_count);
   static CallDescriptor* GetJSCallDescriptor(int parameter_count, Zone* zone);
   CallDescriptor* GetRuntimeCallDescriptor(Runtime::FunctionId function,
                                            int parameter_count,
-                                           Operator::Property properties);
-  static CallDescriptor* GetRuntimeCallDescriptor(Runtime::FunctionId function,
-                                                  int parameter_count,
-                                                  Operator::Property properties,
-                                                  Zone* zone);
+                                           Operator::Properties properties);
+  static CallDescriptor* GetRuntimeCallDescriptor(
+      Runtime::FunctionId function, int parameter_count,
+      Operator::Properties properties, Zone* zone);
 
   CallDescriptor* GetStubCallDescriptor(
       CodeStubInterfaceDescriptor* descriptor, int stack_parameter_count = 0,
       CallDescriptor::Flags flags = CallDescriptor::kNoFlags);
   static CallDescriptor* GetStubCallDescriptor(
       CodeStubInterfaceDescriptor* descriptor, int stack_parameter_count,
       CallDescriptor::Flags flags, Zone* zone);
 
   // Creates a call descriptor for simplified C calls that is appropriate
   // for the host platform. This simplified calling convention only supports
@@ skipping 27 matching lines @@
  private:
   CompilationInfo* info_;
   CallDescriptor* incoming_;
 };
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_LINKAGE_H_