[Ignition] Use binary operation feedback from Ignition to Crankshaft.

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 173 matching lines @@
 
 Handle<AllocationSite> TypeFeedbackOracle::GetCallNewAllocationSite(
     FeedbackVectorSlot slot) {
   Handle<Object> info = GetInfo(slot);
   if (info->IsAllocationSite()) {
     return Handle<AllocationSite>::cast(info);
   }
   return Handle<AllocationSite>::null();
 }
 
-void TypeFeedbackOracle::CompareType(TypeFeedbackId id, AstType** left_type,
-                                     AstType** right_type,
-                                     AstType** combined_type) {
+namespace {
+
+AstType* CompareOpHintToType(CompareOperationHint hint) {

[mythria, 2016/09/22 14:09:42]

I actually wanted to move it to the CompareICNexus implementation, but I wasn't
sure, because type-feedback-vector does not know AstType. If that is not a
problem, I will move it to CompareICNexus.

+  switch (hint) {
+    case CompareOperationHint::kNone:
+      return AstType::None();
+    case CompareOperationHint::kSignedSmall:
+      return AstType::SignedSmall();
+    case CompareOperationHint::kNumberOrOddball:
+      return AstType::Number();
+    case CompareOperationHint::kAny:
+    default:
+      return AstType::Any();
+  }
+  UNREACHABLE();
+  return AstType::None();
+}
+
+AstType* BinaryOpHintToType(BinaryOperationHint hint) {
+  switch (hint) {
+    case BinaryOperationHint::kNone:
+      return AstType::None();
+    case BinaryOperationHint::kSignedSmall:
+      return AstType::SignedSmall();
+    case BinaryOperationHint::kNumberOrOddball:
+      return AstType::Number();
+    case BinaryOperationHint::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,
+                                     AstType** combined_type,
+                                     bool feedback_from_ignition) {
   Handle<Object> info = GetInfo(id);
   if (!info->IsCode()) {
     // For some comparisons we don't have ICs, e.g. LiteralCompareTypeof.
     *left_type = *right_type = *combined_type = AstType::None();
     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.
+  if (feedback_from_ignition) {
+    DCHECK(!slot.IsInvalid());
+    CompareICNexus nexus(feedback_vector_, slot);
+    *left_type = *right_type = *combined_type =
+        CompareOpHintToType(nexus.GetCompareOperationFeedback());
+    return;
+  }
+
+  // Feedback from IC.
   Handle<Code> code = Handle<Code>::cast(info);
-
   Handle<Map> map;
   Map* raw_map = code->FindFirstMap();
   if (raw_map != NULL) Map::TryUpdate(handle(raw_map)).ToHandle(&map);
 
   if (code->is_compare_ic_stub()) {
     CompareICStub stub(code->stub_key(), isolate());
     *left_type = CompareICState::StateToType(zone(), stub.left());
     *right_type = CompareICState::StateToType(zone(), stub.right());
     *combined_type = CompareICState::StateToType(zone(), stub.state(), map);
+  } else {
+    *left_type = *right_type = *combined_type = AstType::None();
   }
 }
 
-void TypeFeedbackOracle::BinaryType(TypeFeedbackId id, AstType** left,
-                                    AstType** right, AstType** result,
+void TypeFeedbackOracle::BinaryType(TypeFeedbackId id, FeedbackVectorSlot slot,
+                                    AstType** left, AstType** right,
+                                    AstType** result,
                                     Maybe<int>* fixed_right_arg,
                                     Handle<AllocationSite>* allocation_site,
-                                    Token::Value op) {
+                                    Token::Value op,
+                                    bool feedback_from_ignition) {
   Handle<Object> object = GetInfo(id);
   if (!object->IsCode()) {
-    // For some binary ops we don't have ICs, e.g. Token::COMMA, but for the
-    // operations covered by the BinaryOpIC we should always have them.
+    // For some binary ops we don't have ICs or feedback slots,
+    // e.g. Token::COMMA, but for the operations covered by the BinaryOpIC we
+    // should always have them.
+    DCHECK(slot.IsInvalid());
     DCHECK(op < BinaryOpICState::FIRST_TOKEN ||
            op > BinaryOpICState::LAST_TOKEN);
     *left = *right = *result = AstType::None();
     *fixed_right_arg = Nothing<int>();
     *allocation_site = Handle<AllocationSite>::null();
     return;
   }
+
+  // Feedback from Ignition.
+  if (feedback_from_ignition) {
+    DCHECK(!slot.IsInvalid());
+    BinaryOpICNexus nexus(feedback_vector_, slot);
+    *left = *right = *result =
+        BinaryOpHintToType(nexus.GetBinaryOperationFeedback());
+    *fixed_right_arg = Nothing<int>();
+    *allocation_site = Handle<AllocationSite>::null();
+    return;
+  }
+
+  // Feedback from IC.
   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());
 
   *left = state.GetLeftType();
   *right = state.GetRightType();
   *result = state.GetResultType();
   *fixed_right_arg = state.fixed_right_arg();
 
   AllocationSite* first_allocation_site = code->FindFirstAllocationSite();
   if (first_allocation_site != NULL) {
     *allocation_site = handle(first_allocation_site);
   } else {
     *allocation_site = Handle<AllocationSite>::null();
   }
 }
 
-AstType* TypeFeedbackOracle::CountType(TypeFeedbackId id) {
+AstType* TypeFeedbackOracle::CountType(TypeFeedbackId id,
+                                       FeedbackVectorSlot slot,
+                                       bool feedback_from_ignition) {
   Handle<Object> object = GetInfo(id);
-  if (!object->IsCode()) return AstType::None();
+  if (!object->IsCode()) {
+    DCHECK(slot.IsInvalid());
+    return AstType::None();
+  }
+
+  if (feedback_from_ignition) {
+    DCHECK(!slot.IsInvalid());
+    BinaryOpICNexus nexus(feedback_vector_, slot);
+    return BinaryOpHintToType(nexus.GetBinaryOperationFeedback());
+  }
+
+  // Feedback from IC.
   Handle<Code> code = Handle<Code>::cast(object);
   DCHECK_EQ(Code::BINARY_OP_IC, code->kind());
   BinaryOpICState state(isolate(), code->extra_ic_state());
   return state.GetLeftType();
 }
 
 
 bool TypeFeedbackOracle::HasOnlyStringMaps(SmallMapList* receiver_types) {
   bool all_strings = receiver_types->length() > 0;
   for (int i = 0; i < receiver_types->length(); i++) {
@@ skipping 194 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