[Interpreter] Collect feedback about Oddballs in Subtract Stub.

src/type-info.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/type-info.h"
 
 #include "src/ast/ast.h"
 #include "src/code-stubs.h"
 #include "src/ic/ic.h"
 #include "src/ic/stub-cache.h"
@@ skipping 175 matching lines @@
     FeedbackVectorSlot slot) {
   Handle<Object> info = GetInfo(slot);
   if (info->IsAllocationSite()) {
     return Handle<AllocationSite>::cast(info);
   }
   return Handle<AllocationSite>::null();
 }
 
 namespace {
 
 AstType* CompareOpHintToType(CompareOperationHint hint) {

[Leszek Swirski, 2016/10/10 11:57:22]

Should this have a similar change to below?

[mythria, 2016/10/10 13:26:00]

Yes, I think so. I was planning to do with along with changes for compare
bytecode handler.

   switch (hint) {
     case CompareOperationHint::kNone:
       return AstType::None();
     case CompareOperationHint::kSignedSmall:
       return AstType::SignedSmall();
     case CompareOperationHint::kNumber:
       return AstType::Number();
     case CompareOperationHint::kNumberOrOddball:
       return AstType::NumberOrOddball();
     case CompareOperationHint::kAny:
       return AstType::Any();
   }
   UNREACHABLE();
   return AstType::None();
 }
 
-AstType* BinaryOpHintToType(BinaryOperationHint hint) {
+AstType* BinaryOpFeedbackToType(int hint) {
   switch (hint) {
-    case BinaryOperationHint::kNone:
+    case BinaryOperationFeedback::kNone:
       return AstType::None();
-    case BinaryOperationHint::kSignedSmall:
+    case BinaryOperationFeedback::kSignedSmall:
       return AstType::SignedSmall();
-    case BinaryOperationHint::kSigned32:
-      return AstType::Signed32();
-    case BinaryOperationHint::kNumberOrOddball:
+    case BinaryOperationFeedback::kNumber:
       return AstType::Number();
-    case BinaryOperationHint::kString:
+    case BinaryOperationFeedback::kString:
       return AstType::String();
-    case BinaryOperationHint::kAny:
+    // TODO(mythria): Merge Number and NumberOrOddball feedback, after
+    // fixing crankshaft to handle Oddballs along with Numbers.
+    case BinaryOperationFeedback::kNumberOrOddball:
+    case BinaryOperationFeedback::kAny:
+    default:
       return AstType::Any();
   }
   UNREACHABLE();
   return AstType::None();
 }
 
 }  // end anonymous namespace
 
 void TypeFeedbackOracle::CompareType(TypeFeedbackId id, FeedbackVectorSlot slot,
                                      AstType** left_type, AstType** right_type,
@@ skipping 56 matching lines @@
     *allocation_site = Handle<AllocationSite>::null();
     return;
   }
 
   // Feedback from Ignition. The feedback slot will be allocated and initialized
   // to AstType::None() even when ignition is not enabled. So it is safe to get
   // feedback from the type feedback vector.
   DCHECK(!slot.IsInvalid());
   BinaryOpICNexus nexus(feedback_vector_, slot);
   *left = *right = *result =
-      BinaryOpHintToType(nexus.GetBinaryOperationFeedback());
+      BinaryOpFeedbackToType(Smi::cast(nexus.GetFeedback())->value());
   *fixed_right_arg = Nothing<int>();
   *allocation_site = Handle<AllocationSite>::null();
 
   if (!object->IsCode()) return;
 
   // Merge the feedback from full-codegen if available.
   Handle<Code> code = Handle<Code>::cast(object);
   DCHECK_EQ(Code::BINARY_OP_IC, code->kind());
   BinaryOpICState state(isolate(), code->extra_ic_state());
   DCHECK_EQ(op, state.op());
@@ skipping 14 matching lines @@
 AstType* TypeFeedbackOracle::CountType(TypeFeedbackId id,
                                        FeedbackVectorSlot slot) {
   Handle<Object> object = GetInfo(id);
   if (slot.IsInvalid()) {
     DCHECK(!object->IsCode());
     return AstType::None();
   }
 
   DCHECK(!slot.IsInvalid());
   BinaryOpICNexus nexus(feedback_vector_, slot);
-  AstType* type = BinaryOpHintToType(nexus.GetBinaryOperationFeedback());
+  AstType* type =
+      BinaryOpFeedbackToType(Smi::cast(nexus.GetFeedback())->value());
 
   if (!object->IsCode()) return type;
 
   Handle<Code> code = Handle<Code>::cast(object);
   DCHECK_EQ(Code::BINARY_OP_IC, code->kind());
   BinaryOpICState state(isolate(), code->extra_ic_state());
   return AstType::Union(type, state.GetLeftType(), zone());
 }
 
 
@@ skipping 197 matching lines @@
   // Dictionary has been allocated with sufficient size for all elements.
   DisallowHeapAllocation no_need_to_resize_dictionary;
   HandleScope scope(isolate());
   USE(UnseededNumberDictionary::AtNumberPut(
       dictionary_, IdToKey(ast_id), handle(target, isolate())));
 }
 
 
 }  // namespace internal
 }  // namespace v8