Checking for stack height equality between full codegen and hydrogen.

src/hydrogen.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "hydrogen.h"
 
 #include <algorithm>
 
 #include "v8.h"
 #include "allocation-site-scopes.h"
@@ skipping 139 matching lines @@
 HPhi* HBasicBlock::AddNewPhi(int merged_index) {
   if (graph()->IsInsideNoSideEffectsScope()) {
     merged_index = HPhi::kInvalidMergedIndex;
   }
   HPhi* phi = new(zone()) HPhi(merged_index, zone());
   AddPhi(phi);
   return phi;
 }
 
 
+HSimulate* HBasicBlock::AddNewSimulate(
+    BailoutId ast_id,
+    HSourcePosition position,
+    RemovableSimulate removable,
+    int arguments_offset) {
+  HSimulate* instr = CreateSimulate(ast_id, removable, arguments_offset);
+  AddInstruction(instr, position);
+  return instr;
+}
+
+
 HSimulate* HBasicBlock::CreateSimulate(BailoutId ast_id,
-                                       RemovableSimulate removable) {
+                                       RemovableSimulate removable,
+                                       int arguments_offset) {
   ASSERT(HasEnvironment());
   HEnvironment* environment = last_environment();
   ASSERT(ast_id.IsNone() ||
          ast_id == BailoutId::StubEntry() ||
          environment->closure()->shared()->VerifyBailoutId(ast_id));
 
   int push_count = environment->push_count();
   int pop_count = environment->pop_count();
 
   HSimulate* instr =
       new(zone()) HSimulate(ast_id, pop_count, zone(), removable);
 #ifdef DEBUG
   instr->set_closure(environment->closure());
 #endif
   // Order of pushed values: newest (top of stack) first. This allows
   // HSimulate::MergeWith() to easily append additional pushed values
   // that are older (from further down the stack).
   for (int i = 0; i < push_count; ++i) {
     instr->AddPushedValue(environment->ExpressionStackAt(i));
   }
   for (GrowableBitVector::Iterator it(environment->assigned_variables(),
                                       zone());
        !it.Done();
        it.Advance()) {
     int index = it.Current();
     instr->AddAssignedValue(index, environment->Lookup(index));
   }
   environment->ClearHistory();
+#if defined(COMPARE_OPT_STACK_HEIGHT)
+  environment->VerifyStackHeight(
+      ast_id, instr->id(), arguments_offset);
+#endif
   return instr;
 }
 
 
 void HBasicBlock::Finish(HControlInstruction* end, HSourcePosition position) {
   ASSERT(!IsFinished());
   AddInstruction(end, position);
   end_ = end;
   for (HSuccessorIterator it(end); !it.Done(); it.Advance()) {
     it.Current()->RegisterPredecessor(this);
@@ skipping 49 matching lines @@
   UpdateEnvironment(env);
 }
 
 
 void HBasicBlock::UpdateEnvironment(HEnvironment* env) {
   last_environment_ = env;
   graph()->update_maximum_environment_size(env->first_expression_index());
 }
 
 
-void HBasicBlock::SetJoinId(BailoutId ast_id) {
+void HBasicBlock::SetJoinId(BailoutId ast_id, int stack_check_offset) {
   int length = predecessors_.length();
   ASSERT(length > 0);
   for (int i = 0; i < length; i++) {
     HBasicBlock* predecessor = predecessors_[i];
     ASSERT(predecessor->end()->IsGoto());
     HSimulate* simulate = HSimulate::cast(predecessor->end()->previous());
     ASSERT(i != 0 ||
            (predecessor->last_environment()->closure().is_null() ||
             predecessor->last_environment()->closure()->shared()
               ->VerifyBailoutId(ast_id)));
     simulate->set_ast_id(ast_id);
+#if defined(COMPARE_OPT_STACK_HEIGHT)
+    predecessor->last_environment()->VerifyStackHeight(
+        ast_id, simulate->id(), stack_check_offset);
+#endif
     predecessor->last_environment()->set_ast_id(ast_id);
   }
 }
 
 
 bool HBasicBlock::Dominates(HBasicBlock* other) const {
   HBasicBlock* current = other->dominator();
   while (current != NULL) {
     if (current == this) return true;
     current = current->dominator();
@@ skipping 917 matching lines @@
         reference, static_cast<HValue*>(NULL), HObjectAccess::ForCounter());
     HValue* new_value = AddUncasted<HAdd>(old_value, graph()->GetConstant1());
     new_value->ClearFlag(HValue::kCanOverflow);  // Ignore counter overflow
     Add<HStoreNamedField>(reference, HObjectAccess::ForCounter(),
                           new_value, STORE_TO_INITIALIZED_ENTRY);
   }
 }
 
 
 void HGraphBuilder::AddSimulate(BailoutId id,
-                                RemovableSimulate removable) {
+                                RemovableSimulate removable,
+                                int arguments_offset) {
   ASSERT(current_block() != NULL);
   ASSERT(!graph()->IsInsideNoSideEffectsScope());
-  current_block()->AddNewSimulate(id, source_position(), removable);
+  current_block()->AddNewSimulate(
+      id, source_position(), removable, arguments_offset);
 }
 
 
 HBasicBlock* HGraphBuilder::CreateBasicBlock(HEnvironment* env) {
   HBasicBlock* b = graph()->CreateBasicBlock();
   b->SetInitialEnvironment(env);
   return b;
 }
 
 
@@ skipping 3181 matching lines @@
     Add<HReturn>(result);
   } else if (state->inlining_kind() == CONSTRUCT_CALL_RETURN) {
     // Return from an inlined construct call. In a test context the return value
     // will always evaluate to true, in a value context the return value needs
     // to be a JSObject.
     if (context->IsTest()) {
       TestContext* test = TestContext::cast(context);
       CHECK_ALIVE(VisitForEffect(stmt->expression()));
       Goto(test->if_true(), state);
     } else if (context->IsEffect()) {
-      CHECK_ALIVE(VisitForEffect(stmt->expression()));
+      CHECK_ALIVE(VisitForValue(stmt->expression()));
+      Drop(1);
       Goto(function_return(), state);
     } else {
       ASSERT(context->IsValue());
       CHECK_ALIVE(VisitForValue(stmt->expression()));
       HValue* return_value = Pop();
       HValue* receiver = environment()->arguments_environment()->Lookup(0);
       HHasInstanceTypeAndBranch* typecheck =
           New<HHasInstanceTypeAndBranch>(return_value,
                                          FIRST_SPEC_OBJECT_TYPE,
                                          LAST_SPEC_OBJECT_TYPE);
@@ skipping 3142 matching lines @@
     HEnterInlined* entry = function_state()->entry();
 
     // Pop the return test context from the expression context stack.
     ASSERT(ast_context() == inlined_test_context());
     ClearInlinedTestContext();
     delete target_state;
 
     // Forward to the real test context.
     if (if_true->HasPredecessor()) {
       entry->RegisterReturnTarget(if_true, zone());
-      if_true->SetJoinId(ast_id);
+      if_true->SetJoinId(ast_id, -1);
       HBasicBlock* true_target = TestContext::cast(ast_context())->if_true();
       Goto(if_true, true_target, function_state());
     }
     if (if_false->HasPredecessor()) {
       entry->RegisterReturnTarget(if_false, zone());
-      if_false->SetJoinId(ast_id);
+      if_false->SetJoinId(ast_id, -1);
       HBasicBlock* false_target = TestContext::cast(ast_context())->if_false();
       Goto(if_false, false_target, function_state());
     }
     set_current_block(NULL);
     return true;
 
   } else if (function_return()->HasPredecessor()) {
     function_state()->entry()->RegisterReturnTarget(function_return(), zone());
     function_return()->SetJoinId(ast_id);
     set_current_block(function_return());
@@ skipping 3254 matching lines @@
   ASSERT(call->arguments()->length() == 3);
   // We need to follow the evaluation order of full codegen.
   CHECK_ALIVE(VisitForValue(call->arguments()->at(1)));
   CHECK_ALIVE(VisitForValue(call->arguments()->at(2)));
   CHECK_ALIVE(VisitForValue(call->arguments()->at(0)));
   HValue* string = Pop();
   HValue* value = Pop();
   HValue* index = Pop();
   Add<HSeqStringSetChar>(String::ONE_BYTE_ENCODING, string,
                          index, value);
-  Add<HSimulate>(call->id(), FIXED_SIMULATE);
+  if (ast_context()->IsEffect()) {
+    Add<HSimulate>(call->id(), FIXED_SIMULATE);
+  } else {
+    Push(graph()->GetConstantUndefined());
+    Add<HSimulate>(call->id(), FIXED_SIMULATE);
+    Pop();
+  }
   return ast_context()->ReturnValue(graph()->GetConstantUndefined());
 }
 
 
 void HOptimizedGraphBuilder::GenerateTwoByteSeqStringSetChar(
     CallRuntime* call) {
   ASSERT(call->arguments()->length() == 3);
   // We need to follow the evaluation order of full codegen.
   CHECK_ALIVE(VisitForValue(call->arguments()->at(1)));
   CHECK_ALIVE(VisitForValue(call->arguments()->at(2)));
   CHECK_ALIVE(VisitForValue(call->arguments()->at(0)));
   HValue* string = Pop();
   HValue* value = Pop();
   HValue* index = Pop();
   Add<HSeqStringSetChar>(String::TWO_BYTE_ENCODING, string,
                          index, value);
-  Add<HSimulate>(call->id(), FIXED_SIMULATE);
+  if (ast_context()->IsEffect()) {
+    Add<HSimulate>(call->id(), FIXED_SIMULATE);
+  } else {
+    Push(graph()->GetConstantUndefined());
+    Add<HSimulate>(call->id(), FIXED_SIMULATE);
+    Pop();
+  }
   return ast_context()->ReturnValue(graph()->GetConstantUndefined());
 }
 
 
 void HOptimizedGraphBuilder::GenerateSetValueOf(CallRuntime* call) {
   ASSERT(call->arguments()->length() == 2);
   CHECK_ALIVE(VisitForValue(call->arguments()->at(0)));
   CHECK_ALIVE(VisitForValue(call->arguments()->at(1)));
   HValue* value = Pop();
   HValue* object = Pop();
@@ skipping 582 matching lines @@
 
 
 void HEnvironment::PrintToStd() {
   HeapStringAllocator string_allocator;
   StringStream trace(&string_allocator);
   PrintTo(&trace);
   PrintF("%s", trace.ToCString().get());
 }
 
 
+void HEnvironment::VerifyStackHeight(
+    BailoutId ast_id,
+    int hydrogen_id,
+    int stack_height_offset) {
+#if defined(COMPARE_OPT_STACK_HEIGHT)
+  if (!ast_id.IsNone() && ast_id != BailoutId::StubEntry()) {
+    int hydrogen_height = length() - specials_count() - parameter_count();
+    int expected_stack_height =
+      closure()->shared()->GetExpectedStackHeight(ast_id) +
+      stack_height_offset;
+
+    if (expected_stack_height != hydrogen_height) {
+      V8_Fatal(__FILE__, __LINE__,
+               "Stack height mismatch.\n"
+               "Hydrogen height    = %4i,  "
+               "unoptimized height = %4i,  AST id      = %i\n",
+               hydrogen_height, expected_stack_height, ast_id.ToInt());
+    }
+  }
+#endif
+}
+
+
 void HTracer::TraceCompilation(CompilationInfo* info) {
   Tag tag(this, "compilation");
   if (info->IsOptimizing()) {
     Handle<String> name = info->function()->debug_name();
     PrintStringProperty("name", name->ToCString().get());
     PrintIndent();
     trace_.Add("method \"%s:%d\"\n",
                name->ToCString().get(),
                info->optimization_id());
   } else {
@@ skipping 318 matching lines @@
   if (ShouldProduceTraceOutput()) {
     isolate()->GetHTracer()->TraceHydrogen(name(), graph_);
   }
 
 #ifdef DEBUG
   graph_->Verify(false);  // No full verify.
 #endif
 }
 
 } }  // namespace v8::internal