Add static analysis to AST expressions that records whether a negative zero w...

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 202 matching lines @@
 }
 
 
 void AstOptimizer::VisitFunctionBoilerplateLiteral(
     FunctionBoilerplateLiteral* node) {
   USE(node);
 }
 
 
 void AstOptimizer::VisitConditional(Conditional* node) {
+  node->condition()->set_no_negative_zero(true);
   Visit(node->condition());
   Visit(node->then_expression());
   Visit(node->else_expression());
 }
 
 
 void AstOptimizer::VisitSlot(Slot* node) {
   USE(node);
 }
 
@@ skipping 79 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_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 54 matching lines @@
   }
 }
 
 
 void AstOptimizer::VisitThrow(Throw* node) {
   Visit(node->exception());
 }
 
 
 void AstOptimizer::VisitProperty(Property* node) {
+  node->key()->set_no_negative_zero(true);
   Visit(node->obj());
   Visit(node->key());
 }
 
 
 void AstOptimizer::VisitCall(Call* node) {
   Visit(node->expression());
   OptimizeArguments(node->arguments());
 }
 
 
 void AstOptimizer::VisitCallNew(CallNew* node) {
   Visit(node->expression());
   OptimizeArguments(node->arguments());
 }
 
 
 void AstOptimizer::VisitCallRuntime(CallRuntime* node) {
   ScopedFuncNameInferrer scoped_fni(&func_name_inferrer_);
   if (Factory::InitializeVarGlobal_symbol()->Equals(*node->name()) &&
       node->arguments()->length() >= 2 &&
       node->arguments()->at(1)->AsFunctionLiteral() != NULL) {
       scoped_fni.Enter();
   }
   OptimizeArguments(node->arguments());
 }
 
 
 void AstOptimizer::VisitUnaryOperation(UnaryOperation* node) {
+  if (node->op() == Token::ADD || node->op() == Token::SUB) {
+    node->expression()->set_no_negative_zero(node->no_negative_zero());
+  } else {
+    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::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->expression()->set_no_negative_zero(node->is_prefix() ?
+                                           true :
+                                           node->no_negative_zero());
   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:
+      node->left()->set_no_negative_zero(true);
+      node->right()->set_no_negative_zero(node->no_negative_zero());
+      break;
     case Token::AND:
+      node->left()->set_no_negative_zero(node->no_negative_zero());
+      node->right()->set_no_negative_zero(node->no_negative_zero());
       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);
+      node->left()->set_no_negative_zero(true);
+      node->right()->set_no_negative_zero(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();
       }
+      node->left()->set_no_negative_zero(node->no_negative_zero());
+      node->right()->set_no_negative_zero(node->no_negative_zero());
+      if (node->op() == Token::DIV) {
+        node->right()->set_no_negative_zero(false);
+      } else if (node->op() == Token::MOD) {
+        node->right()->set_no_negative_zero(true);
+      }
       break;
     default:
       UNREACHABLE();
       break;
   }
 
   Visit(node->left());
   Visit(node->right());
 
   // After visiting the operand nodes we have to check if this node's type
@@ skipping 47 matching lines @@
 }
 
 
 void AstOptimizer::VisitCompareOperation(CompareOperation* node) {
   if (node->type()->IsKnown()) {
     // Propagate useful information down towards the leafs.
     node->left()->type()->SetAsLikelySmiIfUnknown();
     node->right()->type()->SetAsLikelySmiIfUnknown();
   }
 
+  node->left()->set_no_negative_zero(true);
+  // Only [[HasInstance]] has the right argument passed unchanged to it.
+  node->right()->set_no_negative_zero(true);
+
   Visit(node->left());
   Visit(node->right());
 
   // After visiting the operand nodes we have to check if this node's type
   // can be updated. If it does, then we can push that information down
   // towards the leafs again if the new information is an upgrade over the
   // previous type of the operand nodes.
   if (node->type()->IsUnknown()) {
     if (node->left()->type()->IsLikelySmi() ||
         node->right()->type()->IsLikelySmi()) {
@@ skipping 340 matching lines @@
     optimizer.Optimize(body);
     if (optimizer.HasStackOverflow()) {
       return false;
     }
   }
   return true;
 }
 
 
 } }  // namespace v8::internal