[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(AllocationParameters info) {
+  return base::hash_combine(info.type, info.pretenure);
+}
+
+V8_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
+                                           AllocationParameters info) {
+  info.type->PrintTo(os);
+  return os << ", " << info.pretenure;
+}
+
+bool operator==(AllocationParameters const& lhs,
+                AllocationParameters const& rhs) {
+  return lhs.pretenure == rhs.pretenure && lhs.type == rhs.type;
+}
+
+bool operator!=(AllocationParameters const& lhs,
+                AllocationParameters const& rhs) {
+  return !(lhs == rhs);
+}
+
 PretenureFlag PretenureFlagOf(const Operator* op) {
   DCHECK_EQ(IrOpcode::kAllocate, op->opcode());
-  return OpParameter<PretenureFlag>(op);
+  return OpParameter<AllocationParameters>(op).pretenure;
+}
+
+Type* AllocateTypeOf(const Operator* op) {
+  DCHECK_EQ(IrOpcode::kAllocate, op->opcode());
+  return OpParameter<AllocationParameters>(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>(
+  struct AllocateOperator : public Operator1<AllocationParameters> {
+    AllocateOperator(Type* type, PretenureFlag pretenure)
+        : Operator1<AllocationParameters>(
               IrOpcode::kAllocate,
               Operator::kNoDeopt | Operator::kNoThrow | Operator::kNoWrite,
-              "Allocate", 1, 1, 1, 1, 1, 0, kPretenure) {}
+              "Allocate", 1, 1, 1, 1, 1, 0,
+              AllocationParameters(type, pretenure)) {}
   };
-  AllocateOperator<NOT_TENURED> kAllocateNotTenuredOperator;
-  AllocateOperator<TENURED> kAllocateTenuredOperator;
+
+  template <PretenureFlag kPretenure>
+  struct AllocateTypeAnyOperator final : public AllocateOperator {
+    AllocateTypeAnyOperator() : AllocateOperator(Type::Any(), kPretenure) {}
+  };
+
+  AllocateTypeAnyOperator<NOT_TENURED> kAllocateNotTenuredTypeAnyOperator;
+  AllocateTypeAnyOperator<TENURED> kAllocateTenuredTypeAnyOperator;
 
   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 188 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;
+const Operator* SimplifiedOperatorBuilder::Allocate(Type* type,
+                                                    PretenureFlag pretenure) {
+  if (Type::Any()->Is(type)) {

[Benedikt Meurer, 2017/04/06 12:08:05]

I'd rather remove the caching completely. We don't allocate a lot of Allocator
operators usually.

[Jarin, 2017/04/06 15:11:29]

Done.

+    switch (pretenure) {
+      case NOT_TENURED:
+        return &cache_.kAllocateNotTenuredTypeAnyOperator;
+      case TENURED:
+        return &cache_.kAllocateTenuredTypeAnyOperator;
+    }
+    UNREACHABLE();
   }
-  UNREACHABLE();
-  return nullptr;
+  return new (zone())
+      SimplifiedOperatorGlobalCache::AllocateOperator(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