Verify that no-side-effects scope does not add unsafe phis and does not change push-pop balance of …

src/hydrogen.cc

 // Copyright 2012 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 734 matching lines @@
     HBasicBlock* split_edge =
         builder_->CreateBasicBlock(env->Copy());
     if (did_or_) {
       compare->SetSuccessorAt(0, split_edge);
       compare->SetSuccessorAt(1, first_false_block_);
     } else {
       compare->SetSuccessorAt(0, first_true_block_);
       compare->SetSuccessorAt(1, split_edge);
     }
     split_edge->GotoNoSimulate(split_edge_merge_block_);
+    ASSERT(builder_->SafeToAddPhiInNoSideEffectsScope());
   } else {
     compare->SetSuccessorAt(0, first_true_block_);
     compare->SetSuccessorAt(1, first_false_block_);
   }
   builder_->current_block()->Finish(compare);
   needs_compare_ = false;
 }
 
 
 void HGraphBuilder::IfBuilder::Or() {
   ASSERT(!did_and_);
   did_or_ = true;
   HEnvironment* env = first_false_block_->last_environment();
   if (split_edge_merge_block_ == NULL) {
     split_edge_merge_block_ =
         builder_->CreateBasicBlock(env->Copy());
     first_true_block_->GotoNoSimulate(split_edge_merge_block_);
+    ASSERT(builder_->SafeToAddPhiInNoSideEffectsScope());
     first_true_block_ = split_edge_merge_block_;
   }
   builder_->set_current_block(first_false_block_);
   first_false_block_ = builder_->CreateBasicBlock(env->Copy());
 }
 
 
 void HGraphBuilder::IfBuilder::And() {
   ASSERT(!did_or_);
   did_and_ = true;
   HEnvironment* env = first_false_block_->last_environment();
   if (split_edge_merge_block_ == NULL) {
     split_edge_merge_block_ = builder_->CreateBasicBlock(env->Copy());
     first_false_block_->GotoNoSimulate(split_edge_merge_block_);
+    ASSERT(builder_->SafeToAddPhiInNoSideEffectsScope());
     first_false_block_ = split_edge_merge_block_;
   }
   builder_->set_current_block(first_true_block_);
   first_true_block_ = builder_->CreateBasicBlock(env->Copy());
 }
 
 
 void HGraphBuilder::IfBuilder::CaptureContinuation(
     HIfContinuation* continuation) {
   ASSERT(!finished_);
@@ skipping 11 matching lines @@
 
 
 void HGraphBuilder::IfBuilder::Then() {
   ASSERT(!captured_);
   ASSERT(!finished_);
   did_then_ = true;
   if (needs_compare_) {
     // Handle if's without any expressions, they jump directly to the "else"
     // branch.
     builder_->current_block()->GotoNoSimulate(first_false_block_);
+    ASSERT(builder_->SafeToAddPhiInNoSideEffectsScope());
     first_true_block_ = NULL;
   }
   builder_->set_current_block(first_true_block_);
 }
 
 
 void HGraphBuilder::IfBuilder::Else() {
   ASSERT(did_then_);
   ASSERT(!captured_);
   ASSERT(!finished_);
@@ skipping 42 matching lines @@
     } else {
       HEnvironment* merge_env = last_true_block_->last_environment()->Copy();
       merge_block_ = builder_->CreateBasicBlock(merge_env);
       ASSERT(!finished_);
       if (!did_else_) Else();
       ASSERT(!last_true_block_->IsFinished());
       HBasicBlock* last_false_block = builder_->current_block();
       ASSERT(!last_false_block->IsFinished());
       last_true_block_->GotoNoSimulate(merge_block_);
       last_false_block->GotoNoSimulate(merge_block_);
+      ASSERT(builder_->SafeToAddPhiInNoSideEffectsScope());
       builder_->set_current_block(merge_block_);
     }
   }
   finished_ = true;
 }
 
 
 HGraphBuilder::LoopBuilder::LoopBuilder(HGraphBuilder* builder,
                                         HValue* context,
                                         LoopBuilder::Direction direction)
@@ skipping 12 matching lines @@
     HValue* terminating,
     Token::Value token,
     Representation input_representation) {
   HEnvironment* env = builder_->environment();
   phi_ = new(zone()) HPhi(env->values()->length(), zone());
   header_block_->AddPhi(phi_);
   phi_->AddInput(initial);
   phi_->ChangeRepresentation(Representation::Integer32());
   env->Push(initial);
   builder_->current_block()->GotoNoSimulate(header_block_);
+  ASSERT(builder_->SafeToAddPhiInNoSideEffectsScope());
 
   HEnvironment* body_env = env->Copy();
   HEnvironment* exit_env = env->Copy();
   body_block_ = builder_->CreateBasicBlock(body_env);
   exit_block_ = builder_->CreateBasicBlock(exit_env);
   // Remove the phi from the expression stack
   body_env->Pop();
 
   builder_->set_current_block(header_block_);
   HCompareIDAndBranch* compare =
@@ skipping 34 matching lines @@
       increment_ = HSub::New(zone(), context_, phi_, one);
     }
     increment_->ClearFlag(HValue::kCanOverflow);
     increment_->ChangeRepresentation(Representation::Integer32());
     builder_->AddInstruction(increment_);
   }
 
   // Push the new increment value on the expression stack to merge into the phi.
   builder_->environment()->Push(increment_);
   builder_->current_block()->GotoNoSimulate(header_block_);
+  ASSERT(builder_->SafeToAddPhiInNoSideEffectsScope());
   header_block_->loop_information()->RegisterBackEdge(body_block_);
 
   builder_->set_current_block(exit_block_);
   // Pop the phi from the expression stack
   builder_->environment()->Pop();
   finished_ = true;
 }
 
 
 HGraph* HGraphBuilder::CreateGraph() {
@@ skipping 7194 matching lines @@
           Push(access);
         }
 
         *has_side_effects |= access->HasObservableSideEffects();
         // The caller will use has_side_effects and add correct Simulate.
         access->SetFlag(HValue::kHasNoObservableSideEffects);
         if (position != -1) {
           access->set_position(position);
         }
         if_jsarray->GotoNoSimulate(join);
+        ASSERT(SafeToAddPhiInNoSideEffectsScope());
 
         set_current_block(if_fastobject);
         length = AddInstruction(new(zone()) HFixedArrayBaseLength(elements));
         checked_key = AddBoundsCheck(key, length, ALLOW_SMI_KEY);
         access = AddInstruction(BuildFastElementAccess(
             elements, checked_key, val, elements_kind_branch,
             elements_kind, is_store, STANDARD_STORE));
       } else if (elements_kind == DICTIONARY_ELEMENTS) {
         if (is_store) {
           access = AddInstruction(BuildStoreKeyedGeneric(object, key, val));
         } else {
           access = AddInstruction(BuildLoadKeyedGeneric(object, key));
         }
       } else {  // External array elements.
         access = AddInstruction(BuildExternalArrayElementAccess(
             external_elements, checked_key, val,
             elements_kind_branch, elements_kind, is_store));
       }
       *has_side_effects |= access->HasObservableSideEffects();
       // The caller will use has_side_effects and add correct Simulate.
       access->SetFlag(HValue::kHasNoObservableSideEffects);
       if (position != RelocInfo::kNoPosition) access->set_position(position);
       if (!is_store) {
         Push(access);
       }
       current_block()->GotoNoSimulate(join);
+      ASSERT(SafeToAddPhiInNoSideEffectsScope());
       set_current_block(if_false);
     }
   }
 
   // Deopt if none of the cases matched.
   current_block()->FinishExitWithDeoptimization(HDeoptimize::kNoUses);
   set_current_block(join);
   return is_store ? NULL : Pop();
 }
 
@@ skipping 4151 matching lines @@
     }
   }
 
 #ifdef DEBUG
   if (graph_ != NULL) graph_->Verify(false);  // No full verify.
   if (allocator_ != NULL) allocator_->Verify();
 #endif
 }
 
 } }  // namespace v8::internal