Add AST analysis that flags expressions that will have ToInt32 applied to the...

src/rewriter.cc

 // Copyright 2006-2008 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 227 matching lines @@
       node->type()->CopyFrom(var->type());
     } else if (node->type()->IsLikelySmi()) {
       var->type()->SetAsLikelySmi();
     }
 
     if (!var->is_this() &&
         !Heap::result_symbol()->Equals(*var->name())) {
       func_name_inferrer_.PushName(var->name());
     }
 
-    if (var->slot() != NULL) {
+    if (FLAG_safe_int32_compiler) {
       Slot* slot = var->slot();
-      node->set_side_effect_free(
-          (slot->type() == Slot::LOCAL  && !slot->is_arguments()) ||
-          slot->type() == Slot::PARAMETER);
-      // stack_height and expression_size remain 0.
+      if (slot != NULL) {
+        node->set_side_effect_free(
+            (slot->type() == Slot::LOCAL  && !slot->is_arguments()) ||
+            slot->type() == Slot::PARAMETER);
+      }
     }
   }
 }
 
 
 void AstOptimizer::VisitLiteral(Literal* node) {
   Handle<Object> literal = node->handle();
   if (literal->IsSmi()) {
     node->type()->SetAsLikelySmi();
     node->set_side_effect_free(true);
-    // stack_height and expression_size remain 0.
   } else if (literal->IsString()) {
     Handle<String> lit_str(Handle<String>::cast(literal));
     if (!Heap::prototype_symbol()->Equals(*lit_str)) {
       func_name_inferrer_.PushName(lit_str);
     }
   } else if (literal->IsHeapNumber()) {
     node->set_side_effect_free(true);
-    // stack_height and expression_size remain 0.
   }
 }
 
 
 void AstOptimizer::VisitRegExpLiteral(RegExpLiteral* node) {
   USE(node);
 }
 
 
 void AstOptimizer::VisitArrayLiteral(ArrayLiteral* node) {
@@ skipping 137 matching lines @@
       node->arguments()->length() >= 2 &&
       node->arguments()->at(1)->AsFunctionLiteral() != NULL) {
       scoped_fni.Enter();
   }
   OptimizeArguments(node->arguments());
 }
 
 
 void AstOptimizer::VisitUnaryOperation(UnaryOperation* node) {
   Visit(node->expression());
-  switch (node->op()) {
-    case Token::ADD:
-    case Token::SUB:
-      node->set_side_effect_free(node->expression()->side_effect_free());
-      node->set_expression_size(node->expression()->expression_size() + 1);
-      node->set_stack_height(node->expression()->stack_height());
-      break;
-    case Token::DELETE:
-    case Token::TYPEOF:
-    case Token::VOID:
-    case Token::BIT_NOT:
-    case Token::NOT:
-      break;
-    default:
-      UNREACHABLE();
-      break;
+  if (FLAG_safe_int32_compiler) {
+    switch (node->op()) {
+      case Token::BIT_NOT:
+        node->expression()->set_to_int32(true);
+        // Fall through.
+      case Token::ADD:
+      case Token::SUB:
+      case Token::NOT:
+        node->set_side_effect_free(node->expression()->side_effect_free());
+        break;
+      case Token::DELETE:
+      case Token::TYPEOF:
+      case Token::VOID:
+        break;
+      default:
+        UNREACHABLE();
+        break;
+    }
+  } else if (node->op() == Token::BIT_NOT) {
+    node->expression()->set_to_int32(true);
   }
 }
 
 
 void AstOptimizer::VisitCountOperation(CountOperation* node) {
   // Count operations assume that they work on Smis.
   node->type()->SetAsLikelySmiIfUnknown();
   node->expression()->type()->SetAsLikelySmiIfUnknown();
   Visit(node->expression());
 }
 
 
 void AstOptimizer::VisitBinaryOperation(BinaryOperation* node) {
   // Depending on the operation we can propagate this node's type down the
   // AST nodes.
   switch (node->op()) {
     case Token::COMMA:
     case Token::OR:
     case Token::AND:
       break;
     case Token::BIT_OR:
     case Token::BIT_XOR:
     case Token::BIT_AND:
     case Token::SHL:
     case Token::SAR:
     case Token::SHR:
       node->type()->SetAsLikelySmiIfUnknown();
       node->left()->type()->SetAsLikelySmiIfUnknown();
       node->right()->type()->SetAsLikelySmiIfUnknown();
+      node->left()->set_to_int32(true);
+      node->right()->set_to_int32(true);
       break;
     case Token::ADD:
     case Token::SUB:
     case Token::MUL:
     case Token::DIV:
     case Token::MOD:
       if (node->type()->IsLikelySmi()) {
         node->left()->type()->SetAsLikelySmiIfUnknown();
         node->right()->type()->SetAsLikelySmiIfUnknown();
       }
@@ skipping 21 matching lines @@
       if (node->left()->type()->IsUnknown()) {
         node->left()->type()->SetAsLikelySmi();
         Visit(node->left());
       }
       if (node->right()->type()->IsUnknown()) {
         node->right()->type()->SetAsLikelySmi();
         Visit(node->right());
       }
     }
   }
-  switch (node->op()) {
-    case Token::COMMA:
-    case Token::OR:
-    case Token::AND:
-    case Token::BIT_OR:
-    case Token::BIT_XOR:
-    case Token::BIT_AND:
-    case Token::SHL:
-    case Token::SAR:
-    case Token::SHR:
-    case Token::MOD:
-      break;
-    case Token::ADD:
-    case Token::SUB:
-    case Token::MUL:
-    case Token::DIV:
-      node->set_side_effect_free(node->left()->side_effect_free() &&
-                                 node->right()->side_effect_free());
-      node->set_expression_size(node->left()->expression_size() +
-                                node->right()->expression_size() + 1);
-      node->set_stack_height(Max(node->left()->stack_height(),
-                                 node->right()->stack_height() + 1));
-      break;
-    default:
-      UNREACHABLE();
-      break;
+
+  if (FLAG_safe_int32_compiler) {
+    switch (node->op()) {
+      case Token::COMMA:
+      case Token::OR:
+      case Token::AND:
+        break;
+      case Token::BIT_OR:
+      case Token::BIT_XOR:
+      case Token::BIT_AND:
+      case Token::SHL:
+      case Token::SAR:
+      case Token::SHR:
+      case Token::ADD:
+      case Token::SUB:
+      case Token::MUL:
+      case Token::DIV:
+      case Token::MOD:
+        node->set_side_effect_free(node->left()->side_effect_free() &&
+                                   node->right()->side_effect_free());
+        break;
+      default:
+        UNREACHABLE();
+        break;
+    }
   }
 }
 
 
 void AstOptimizer::VisitCompareOperation(CompareOperation* node) {
   if (node->type()->IsKnown()) {
     // Propagate useful information down towards the leafs.
     node->left()->type()->SetAsLikelySmiIfUnknown();
     node->right()->type()->SetAsLikelySmiIfUnknown();
   }
@@ skipping 351 matching lines @@
     optimizer.Optimize(body);
     if (optimizer.HasStackOverflow()) {
       return false;
     }
   }
   return true;
 }
 
 
 } }  // namespace v8::internal