Use untagged int32 values in evaluation of side-effect free expressions.

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 248 matching lines @@
   Handle<Object> literal = node->handle();
   if (literal->IsSmi()) {
     node->type()->SetAsLikelySmi();
     node->set_side_effect_free(true);
   } 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);
+    if (node->to_int32()) {
+      // Any HeapNumber has an int32 value if it is the input to a bit op.
+      node->set_side_effect_free(true);
+    } else {
+      double double_value = HeapNumber::cast(*literal)->value();
+      int32_t int32_value = DoubleToInt32(double_value);
+      node->set_side_effect_free(double_value == int32_value);
+    }
   }
 }
 
 
 void AstOptimizer::VisitRegExpLiteral(RegExpLiteral* node) {
   USE(node);
 }
 
 
 void AstOptimizer::VisitArrayLiteral(ArrayLiteral* node) {
@@ skipping 33 matching lines @@
       break;
     case Token::ASSIGN_BIT_OR:
     case Token::ASSIGN_BIT_XOR:
     case Token::ASSIGN_BIT_AND:
     case Token::ASSIGN_SHL:
     case Token::ASSIGN_SAR:
     case Token::ASSIGN_SHR:
       node->type()->SetAsLikelySmiIfUnknown();
       node->target()->type()->SetAsLikelySmiIfUnknown();
       node->value()->type()->SetAsLikelySmiIfUnknown();
+      node->value()->set_to_int32(true);
       node->value()->set_no_negative_zero(true);
       break;
     case Token::ASSIGN_ADD:
     case Token::ASSIGN_SUB:
     case Token::ASSIGN_MUL:
     case Token::ASSIGN_DIV:
     case Token::ASSIGN_MOD:
       if (node->type()->IsLikelySmi()) {
         node->target()->type()->SetAsLikelySmiIfUnknown();
         node->value()->type()->SetAsLikelySmiIfUnknown();
@@ skipping 98 matching lines @@
     node->expression()->set_no_negative_zero(true);
   }
   Visit(node->expression());
   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::NOT:
       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);
@@ skipping 92 matching lines @@
       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:
+        // Add one to the number of bit operations in this expression.
+        node->set_num_bit_ops(1);
+        // Fall through.
       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());
+        node->set_num_bit_ops(node->num_bit_ops() +
+                                  node->left()->num_bit_ops() +
+                                  node->right()->num_bit_ops());
+        if (!node->no_negative_zero() && node->op() == Token::MUL) {
+          node->set_side_effect_free(false);
+        }
         break;
       default:
         UNREACHABLE();
         break;
     }
   }
 }
 
 
 void AstOptimizer::VisitCompareOperation(CompareOperation* node) {
@@ skipping 360 matching lines @@
     optimizer.Optimize(body);
     if (optimizer.HasStackOverflow()) {
       return false;
     }
   }
   return true;
 }
 
 
 } }  // namespace v8::internal