Use AST's type field and merge types for unary, binary & compare ICs

src/typing.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 386 matching lines @@
     Expression* arg = args->at(i);
     CHECK_ALIVE(Visit(arg));
   }
 }
 
 
 void AstTyper::VisitUnaryOperation(UnaryOperation* expr) {
   ASSERT(!HasStackOverflow());
   CHECK_ALIVE(Visit(expr->expression()));
 
-  expr->RecordTypeFeedback(oracle());
+  // Collect type feedback.
+  Handle<Type> op_type = oracle()->UnaryType(expr->UnaryOperationFeedbackId());
+  MergeLowerType(expr->expression(), op_type);
   if (expr->op() == Token::NOT) {
     // TODO(rossberg): only do in test or value context.
     expr->expression()->RecordToBooleanTypeFeedback(oracle());
   }
 }
 
 
 void AstTyper::VisitCountOperation(CountOperation* expr) {
   ASSERT(!HasStackOverflow());
   CHECK_ALIVE(Visit(expr->expression()));
 
   expr->RecordTypeFeedback(oracle(), zone());
   Property* prop = expr->expression()->AsProperty();
   if (prop != NULL) {
     prop->RecordTypeFeedback(oracle(), zone());
   }
 }
 
 
 void AstTyper::VisitBinaryOperation(BinaryOperation* expr) {
   ASSERT(!HasStackOverflow());
   CHECK_ALIVE(Visit(expr->left()));
   CHECK_ALIVE(Visit(expr->right()));
 
-  expr->RecordTypeFeedback(oracle());
+  // Collect type feedback.
+  Handle<Type> left_type, right_type, result_type;
+  Maybe<int> fixed_right_arg;
+  oracle()->BinaryType(expr->BinaryOperationFeedbackId(),
+      &left_type, &right_type, &result_type, &fixed_right_arg);
+  MergeLowerType(expr->left(), left_type);
+  MergeLowerType(expr->right(), right_type);
+  expr->set_result_type(result_type);
+  expr->set_fixed_right_arg(fixed_right_arg);
   if (expr->op() == Token::OR || expr->op() == Token::AND) {
     expr->left()->RecordToBooleanTypeFeedback(oracle());
   }
 }
 
 
 void AstTyper::VisitCompareOperation(CompareOperation* expr) {
   ASSERT(!HasStackOverflow());
   CHECK_ALIVE(Visit(expr->left()));
   CHECK_ALIVE(Visit(expr->right()));
 
-  expr->RecordTypeFeedback(oracle());
+  // Collect type feedback.
+  Handle<Type> left_type, right_type, combined_type;
+  oracle()->CompareType(expr->CompareOperationFeedbackId(),
+      &left_type, &right_type, &combined_type);
+  MergeLowerType(expr->left(), left_type);
+  MergeLowerType(expr->right(), right_type);
+  expr->set_combined_type(combined_type);
 }
 
 
 void AstTyper::VisitThisFunction(ThisFunction* expr) {
   ASSERT(!HasStackOverflow());
 }
 
 
 void AstTyper::VisitDeclarations(ZoneList<Declaration*>* decls) {
   ASSERT(!HasStackOverflow());
@@ skipping 54 matching lines @@
 }
 
 
 void AstTyper::VisitModuleStatement(ModuleStatement* stmt) {
   ASSERT(!HasStackOverflow());
   CHECK_ALIVE(Visit(stmt->body()));
 }
 
 
 } }  // namespace v8::internal