[turbofan] Add type to the allocation operator.

src/compiler/simplified-operator.cc

 // Copyright 2012 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/simplified-operator.h"
 
 #include "src/base/lazy-instance.h"
 #include "src/compiler/opcodes.h"
 #include "src/compiler/operator.h"
 #include "src/compiler/types.h"
@@ skipping 370 matching lines @@
          op->opcode() == IrOpcode::kSpeculativeNumberShiftRightLogical ||
          op->opcode() == IrOpcode::kSpeculativeNumberBitwiseAnd ||
          op->opcode() == IrOpcode::kSpeculativeNumberBitwiseOr ||
          op->opcode() == IrOpcode::kSpeculativeNumberBitwiseXor ||
          op->opcode() == IrOpcode::kSpeculativeNumberEqual ||
          op->opcode() == IrOpcode::kSpeculativeNumberLessThan ||
          op->opcode() == IrOpcode::kSpeculativeNumberLessThanOrEqual);
   return OpParameter<NumberOperationHint>(op);
 }
 
+size_t hash_value(AllocateParameters info) {
+  return base::hash_combine(info.type(), info.pretenure());
+}
+
+V8_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
+                                           AllocateParameters info) {
+  info.type()->PrintTo(os);
+  return os << ", " << info.pretenure();
+}
+
+bool operator==(AllocateParameters const& lhs, AllocateParameters const& rhs) {
+  return lhs.pretenure() == rhs.pretenure() && lhs.type() == rhs.type();
+}
+
+bool operator!=(AllocateParameters const& lhs, AllocateParameters const& rhs) {
+  return !(lhs == rhs);
+}
+
 PretenureFlag PretenureFlagOf(const Operator* op) {
   DCHECK_EQ(IrOpcode::kAllocate, op->opcode());
-  return OpParameter<PretenureFlag>(op);
+  return OpParameter<AllocateParameters>(op).pretenure();
+}
+
+Type* AllocateTypeOf(const Operator* op) {
+  DCHECK_EQ(IrOpcode::kAllocate, op->opcode());
+  return OpParameter<AllocateParameters>(op).type();
 }
 
 UnicodeEncoding UnicodeEncodingOf(const Operator* op) {
   DCHECK(op->opcode() == IrOpcode::kStringFromCodePoint);
   return OpParameter<UnicodeEncoding>(op);
 }
 
 #define PURE_OP_LIST(V)                                          \
   V(BooleanNot, Operator::kNoProperties, 1, 0)                   \
   V(NumberEqual, Operator::kCommutative, 2, 0)                   \
@@ skipping 235 matching lines @@
         : Operator1<CheckFloat64HoleMode>(
               IrOpcode::kCheckFloat64Hole,
               Operator::kFoldable | Operator::kNoThrow, "CheckFloat64Hole", 1,
               1, 1, 1, 1, 0, kMode) {}
   };
   CheckFloat64HoleNaNOperator<CheckFloat64HoleMode::kAllowReturnHole>
       kCheckFloat64HoleAllowReturnHoleOperator;
   CheckFloat64HoleNaNOperator<CheckFloat64HoleMode::kNeverReturnHole>
       kCheckFloat64HoleNeverReturnHoleOperator;
 
-  template <PretenureFlag kPretenure>
-  struct AllocateOperator final : public Operator1<PretenureFlag> {
-    AllocateOperator()
-        : Operator1<PretenureFlag>(
-              IrOpcode::kAllocate,
-              Operator::kNoDeopt | Operator::kNoThrow | Operator::kNoWrite,
-              "Allocate", 1, 1, 1, 1, 1, 0, kPretenure) {}
-  };
-  AllocateOperator<NOT_TENURED> kAllocateNotTenuredOperator;
-  AllocateOperator<TENURED> kAllocateTenuredOperator;
-
   struct EnsureWritableFastElementsOperator final : public Operator {
     EnsureWritableFastElementsOperator()
         : Operator(                                     // --
               IrOpcode::kEnsureWritableFastElements,    // opcode
               Operator::kNoDeopt | Operator::kNoThrow,  // flags
               "EnsureWritableFastElements",             // name
               2, 1, 1, 1, 1, 0) {}                      // counts
   };
   EnsureWritableFastElementsOperator kEnsureWritableFastElements;
 
@@ skipping 187 matching lines @@
 int FormalParameterCountOf(const Operator* op) {
   DCHECK(op->opcode() == IrOpcode::kArgumentsLength);
   return OpParameter<ArgumentsLengthParameters>(op).formal_parameter_count;
 }
 
 bool IsRestLengthOf(const Operator* op) {
   DCHECK(op->opcode() == IrOpcode::kArgumentsLength);
   return OpParameter<ArgumentsLengthParameters>(op).is_rest_length;
 }
 
-const Operator* SimplifiedOperatorBuilder::Allocate(PretenureFlag pretenure) {
-  switch (pretenure) {
-    case NOT_TENURED:
-      return &cache_.kAllocateNotTenuredOperator;
-    case TENURED:
-      return &cache_.kAllocateTenuredOperator;
-  }
-  UNREACHABLE();
-  return nullptr;
+const Operator* SimplifiedOperatorBuilder::Allocate(Type* type,
+                                                    PretenureFlag pretenure) {
+  return new (zone()) Operator1<AllocateParameters>(
+      IrOpcode::kAllocate,
+      Operator::kNoDeopt | Operator::kNoThrow | Operator::kNoWrite, "Allocate",
+      1, 1, 1, 1, 1, 0, AllocateParameters(type, pretenure));
 }
 
 
 const Operator* SimplifiedOperatorBuilder::LoadBuffer(BufferAccess access) {
   switch (access.external_array_type()) {
 #define LOAD_BUFFER(Type, type, TYPE, ctype, size) \
   case kExternal##Type##Array:                     \
     return &cache_.kLoadBuffer##Type;
     TYPED_ARRAYS(LOAD_BUFFER)
 #undef LOAD_BUFFER
@@ skipping 61 matching lines @@
                         Operator::kNoDeopt | Operator::kNoThrow | properties,  \
                         #Name, value_input_count, 1, control_input_count,      \
                         output_count, 1, 0, access);                           \
   }
 ACCESS_OP_LIST(ACCESS)
 #undef ACCESS
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8