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

src/crankshaft/typing.cc

 // Copyright 2013 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/crankshaft/typing.h"
 
 #include "src/ast/compile-time-value.h"
 #include "src/ast/scopes.h"
 #include "src/ast/variables.h"
 #include "src/frames-inl.h"
 #include "src/frames.h"
 #include "src/ostreams.h"
 #include "src/splay-tree-inl.h"
 
 namespace v8 {
 namespace internal {
 
 AstTyper::AstTyper(Isolate* isolate, Zone* zone, Handle<JSFunction> closure,
                    DeclarationScope* scope, BailoutId osr_ast_id,
-                   FunctionLiteral* root, AstTypeBounds* bounds)
+                   FunctionLiteral* root, AstTypeBounds* bounds,
+                   bool ignition_feedback)
     : isolate_(isolate),
       zone_(zone),
       closure_(closure),
       scope_(scope),
       osr_ast_id_(osr_ast_id),
       root_(root),
       oracle_(isolate, zone, handle(closure->shared()->code()),
               handle(closure->feedback_vector()),
               handle(closure->context()->native_context())),
       store_(zone),
-      bounds_(bounds) {
+      bounds_(bounds),
+      ignition_feedback_(ignition_feedback) {
   InitializeAstVisitor(isolate);
 }
 
 
 #ifdef OBJECT_PRINT
 static void PrintObserved(Variable* var, Object* value, AstType* type) {
   OFStream os(stdout);
   os << "  observed " << (var->IsParameter() ? "param" : "local") << "  ";
   var->name()->Print(os);
   os << " : " << Brief(value) << " -> ";
@@ skipping 162 matching lines @@
 
     Effects clause_effects = EnterEffects();
 
     if (!clause->is_default()) {
       Expression* label = clause->label();
       // Collect type feedback.
       AstType* tag_type;
       AstType* label_type;
       AstType* combined_type;
       oracle()->CompareType(clause->CompareId(),
-                            &tag_type, &label_type, &combined_type);
+                            clause->CompareOperationFeedbackSlot(), &tag_type,
+                            &label_type, &combined_type, ignition_feedback_);
       NarrowLowerType(stmt->tag(), tag_type);
       NarrowLowerType(label, label_type);
       clause->set_compare_type(combined_type);
 
       RECURSE(Visit(label));
       if (!clause_effects.IsEmpty()) complex_effects = true;
     }
 
     ZoneList<Statement*>* stmts = clause->statements();
     RECURSE(VisitStatements(stmts));
@@ skipping 382 matching lines @@
 
 void AstTyper::VisitCountOperation(CountOperation* expr) {
   // Collect type feedback.
   FeedbackVectorSlot slot = expr->CountSlot();
   KeyedAccessStoreMode store_mode;
   IcCheckType key_type;
   oracle()->GetStoreModeAndKeyType(slot, &store_mode, &key_type);
   oracle()->CountReceiverTypes(slot, expr->GetReceiverTypes());
   expr->set_store_mode(store_mode);
   expr->set_key_type(key_type);
-  expr->set_type(oracle()->CountType(expr->CountBinOpFeedbackId()));
+  expr->set_type(oracle()->CountType(expr->CountBinOpFeedbackId(),
+                                     expr->CountBinaryOpFeedbackSlot(),
+                                     ignition_feedback_));
   // TODO(rossberg): merge the count type with the generic expression type.
 
   RECURSE(Visit(expr->expression()));
 
   NarrowType(expr, AstBounds(AstType::SignedSmall(), AstType::Number()));
 
   VariableProxy* proxy = expr->expression()->AsVariableProxy();
   if (proxy != NULL && proxy->var()->IsStackAllocated()) {
     store_.Seq(variable_index(proxy->var()), Effect(bounds_->get(expr)));
   }
 }
 
-
 void AstTyper::VisitBinaryOperation(BinaryOperation* expr) {
   // Collect type feedback.
   AstType* type;
   AstType* left_type;
   AstType* right_type;
   Maybe<int> fixed_right_arg = Nothing<int>();
   Handle<AllocationSite> allocation_site;
   oracle()->BinaryType(expr->BinaryOperationFeedbackId(),
-      &left_type, &right_type, &type, &fixed_right_arg,
-      &allocation_site, expr->op());
+                       expr->BinaryOperationFeedbackSlot(), &left_type,
+                       &right_type, &type, &fixed_right_arg, &allocation_site,
+                       expr->op(), ignition_feedback_);
+
   NarrowLowerType(expr, type);
   NarrowLowerType(expr->left(), left_type);
   NarrowLowerType(expr->right(), right_type);
   expr->set_allocation_site(allocation_site);
   expr->set_fixed_right_arg(fixed_right_arg);
   if (expr->op() == Token::OR || expr->op() == Token::AND) {
     expr->left()->RecordToBooleanTypeFeedback(oracle());
   }
 
   switch (expr->op()) {
@@ skipping 81 matching lines @@
   }
 }
 
 
 void AstTyper::VisitCompareOperation(CompareOperation* expr) {
   // Collect type feedback.
   AstType* left_type;
   AstType* right_type;
   AstType* combined_type;
   oracle()->CompareType(expr->CompareOperationFeedbackId(),
-      &left_type, &right_type, &combined_type);
+                        expr->CompareOperationFeedbackSlot(), &left_type,
+                        &right_type, &combined_type, ignition_feedback_);
   NarrowLowerType(expr->left(), left_type);
   NarrowLowerType(expr->right(), right_type);
   expr->set_combined_type(combined_type);
 
   RECURSE(Visit(expr->left()));
   RECURSE(Visit(expr->right()));
 
   NarrowType(expr, AstBounds(AstType::Boolean()));
 }
 
@@ skipping 40 matching lines @@
 }
 
 
 void AstTyper::VisitFunctionDeclaration(FunctionDeclaration* declaration) {
   RECURSE(Visit(declaration->fun()));
 }
 
 
 }  // namespace internal
 }  // namespace v8