[turbofan] Drop broken StaticParameterTraits.

src/compiler/js-operator.cc

 // 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.
 
 #include "src/compiler/js-operator.h"
 
 #include <limits>
 
 #include "src/base/lazy-instance.h"
 #include "src/compiler/opcodes.h"
 #include "src/compiler/operator.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
+bool operator==(CallFunctionParameters const& lhs,
+                CallFunctionParameters const& rhs) {
+  return lhs.arity() == rhs.arity() && lhs.flags() == rhs.flags();
+}
+
+
+bool operator!=(CallFunctionParameters const& lhs,
+                CallFunctionParameters const& rhs) {
+  return !(lhs == rhs);
+}
+
+
+size_t hash_value(CallFunctionParameters const& p) {
+  return base::hash_combine(p.arity(), p.flags());
+}
+
+
+std::ostream& operator<<(std::ostream& os, CallFunctionParameters const& p) {
+  return os << p.arity() << ", " << p.flags();
+}
+
+
 const CallFunctionParameters& CallFunctionParametersOf(const Operator* op) {
   DCHECK_EQ(IrOpcode::kJSCallFunction, op->opcode());
   return OpParameter<CallFunctionParameters>(op);
 }
 
 
+bool operator==(CallRuntimeParameters const& lhs,
+                CallRuntimeParameters const& rhs) {
+  return lhs.id() == rhs.id() && lhs.arity() == rhs.arity();
+}
+
+
+bool operator!=(CallRuntimeParameters const& lhs,
+                CallRuntimeParameters const& rhs) {
+  return !(lhs == rhs);
+}
+
+
+size_t hash_value(CallRuntimeParameters const& p) {
+  return base::hash_combine(p.id(), p.arity());
+}
+
+
+std::ostream& operator<<(std::ostream& os, CallRuntimeParameters const& p) {
+  return os << p.id() << ", " << p.arity();
+}
+
+
 const CallRuntimeParameters& CallRuntimeParametersOf(const Operator* op) {
   DCHECK_EQ(IrOpcode::kJSCallRuntime, op->opcode());
   return OpParameter<CallRuntimeParameters>(op);
 }
 
 
 ContextAccess::ContextAccess(size_t depth, size_t index, bool immutable)
     : immutable_(immutable),
       depth_(static_cast<uint16_t>(depth)),
       index_(static_cast<uint32_t>(index)) {
   DCHECK(depth <= std::numeric_limits<uint16_t>::max());
   DCHECK(index <= std::numeric_limits<uint32_t>::max());
 }
 
 
-bool operator==(const ContextAccess& lhs, const ContextAccess& rhs) {
+bool operator==(ContextAccess const& lhs, ContextAccess const& rhs) {
   return lhs.depth() == rhs.depth() && lhs.index() == rhs.index() &&
          lhs.immutable() == rhs.immutable();
 }
 
 
-bool operator!=(const ContextAccess& lhs, const ContextAccess& rhs) {
+bool operator!=(ContextAccess const& lhs, ContextAccess const& rhs) {
   return !(lhs == rhs);
 }
 
 
-const ContextAccess& ContextAccessOf(const Operator* op) {
+size_t hash_value(ContextAccess const& access) {
+  return base::hash_combine(access.depth(), access.index(), access.immutable());
+}
+
+
+std::ostream& operator<<(std::ostream& os, ContextAccess const& access) {
+  return os << access.depth() << ", " << access.index() << ", "
+            << access.immutable();
+}
+
+
+ContextAccess const& ContextAccessOf(Operator const* op) {
   DCHECK(op->opcode() == IrOpcode::kJSLoadContext ||
          op->opcode() == IrOpcode::kJSStoreContext);
   return OpParameter<ContextAccess>(op);
 }
 
 
+bool operator==(LoadNamedParameters const& lhs,
+                LoadNamedParameters const& rhs) {
+  return lhs.name() == rhs.name() &&
+         lhs.contextual_mode() == rhs.contextual_mode();
+}
+
+
+bool operator!=(LoadNamedParameters const& lhs,
+                LoadNamedParameters const& rhs) {
+  return !(lhs == rhs);
+}
+
+
+size_t hash_value(LoadNamedParameters const& p) {
+  return base::hash_combine(p.name(), p.contextual_mode());
+}
+
+
+std::ostream& operator<<(std::ostream& os, LoadNamedParameters const& p) {
+  return os << Brief(*p.name().handle()) << ", " << p.contextual_mode();
+}
+
+
 const LoadNamedParameters& LoadNamedParametersOf(const Operator* op) {
   DCHECK_EQ(IrOpcode::kJSLoadNamed, op->opcode());
   return OpParameter<LoadNamedParameters>(op);
 }
 
 
+bool operator==(StoreNamedParameters const& lhs,
+                StoreNamedParameters const& rhs) {
+  return lhs.strict_mode() == rhs.strict_mode() && lhs.name() == rhs.name();
+}
+
+
+bool operator!=(StoreNamedParameters const& lhs,
+                StoreNamedParameters const& rhs) {
+  return !(lhs == rhs);
+}
+
+
+size_t hash_value(StoreNamedParameters const& p) {
+  return base::hash_combine(p.strict_mode(), p.name());
+}
+
+
+std::ostream& operator<<(std::ostream& os, StoreNamedParameters const& p) {
+  return os << p.strict_mode() << ", " << Brief(*p.name().handle());
+}
+
+
 const StoreNamedParameters& StoreNamedParametersOf(const Operator* op) {
   DCHECK_EQ(IrOpcode::kJSStoreNamed, op->opcode());
   return OpParameter<StoreNamedParameters>(op);
 }
 
 
-// Specialization for static parameters of type {ContextAccess}.
-template <>
-struct StaticParameterTraits<ContextAccess> {
-  static std::ostream& PrintTo(std::ostream& os, const ContextAccess& access) {
-    return os << access.depth() << "," << access.index()
-              << (access.immutable() ? ",imm" : "");
-  }
-  static int HashCode(const ContextAccess& access) {
-    return static_cast<int>((access.depth() << 16) | (access.index() & 0xffff));
-  }
-  static bool Equals(const ContextAccess& lhs, const ContextAccess& rhs) {
-    return lhs == rhs;
-  }
-};
-
-
-// Specialization for static parameters of type {Runtime::FunctionId}.
-template <>
-struct StaticParameterTraits<Runtime::FunctionId> {
-  static std::ostream& PrintTo(std::ostream& os, Runtime::FunctionId val) {
-    const Runtime::Function* f = Runtime::FunctionForId(val);
-    return os << (f->name ? f->name : "?Runtime?");
-  }
-  static int HashCode(Runtime::FunctionId val) { return static_cast<int>(val); }
-  static bool Equals(Runtime::FunctionId a, Runtime::FunctionId b) {
-    return a == b;
-  }
-};
-
-
 #define SHARED_OP_LIST(V)                                 \
   V(Equal, Operator::kNoProperties, 2, 1)                 \
   V(NotEqual, Operator::kNoProperties, 2, 1)              \
   V(StrictEqual, Operator::kPure, 2, 1)                   \
   V(StrictNotEqual, Operator::kPure, 2, 1)                \
   V(LessThan, Operator::kNoProperties, 2, 1)              \
   V(GreaterThan, Operator::kNoProperties, 2, 1)           \
   V(LessThanOrEqual, Operator::kNoProperties, 2, 1)       \
   V(GreaterThanOrEqual, Operator::kNoProperties, 2, 1)    \
   V(BitwiseOr, Operator::kNoProperties, 2, 1)             \
@@ skipping 126 matching lines @@
 const Operator* JSOperatorBuilder::StoreContext(size_t depth, size_t index) {
   ContextAccess access(depth, index, false);
   return new (zone()) Operator1<ContextAccess>(IrOpcode::kJSStoreContext,
                                                Operator::kNoProperties, 2, 0,
                                                "JSStoreContext", access);
 }
 
 
 const Operator* JSOperatorBuilder::CreateCatchContext(
     const Unique<String>& name) {
-  return new (zone()) Operator1<Unique<String> >(
-      IrOpcode::kJSCreateCatchContext, Operator::kNoProperties, 1, 1,
-      "JSCreateCatchContext", name);
+  return new (zone()) Operator1<Unique<String>>(IrOpcode::kJSCreateCatchContext,
+                                                Operator::kNoProperties, 1, 1,
+                                                "JSCreateCatchContext", name);
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8