Fix issue 265 by handling extra statement state on the frame based on...

src/jump-target.cc

 // Copyright 2009 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 19 matching lines @@
 #include "codegen.h"
 #include "jump-target.h"
 
 namespace v8 { namespace internal {
 
 // -------------------------------------------------------------------------
 // JumpTarget implementation.
 
 JumpTarget::JumpTarget(CodeGenerator* cgen, Directionality direction)
     : cgen_(cgen),
-      masm_(cgen == NULL ? NULL : cgen->masm()),
       direction_(direction),
       reaching_frames_(0),
       merge_labels_(0),
       entry_frame_(NULL),
       is_bound_(false),
       is_linked_(false) {
+  ASSERT(cgen != NULL);
+  Initialize(cgen, direction);
+}
+
+
+JumpTarget::JumpTarget()
+    : cgen_(NULL),
+      masm_(NULL),
+      direction_(FORWARD_ONLY),
+      reaching_frames_(0),
+      merge_labels_(0),
+      entry_frame_(NULL),
+      is_bound_(false),
+      is_linked_(false) {
 }
 
 
-void JumpTarget::Unuse() {
-  ASSERT(!is_linked());
-  entry_label_.Unuse();
-  delete entry_frame_;
-  entry_frame_ = NULL;
-  is_bound_ = false;
-  is_linked_ = false;
+void JumpTarget::Initialize(CodeGenerator* cgen, Directionality direction) {
+  ASSERT(cgen != NULL);
+  ASSERT(cgen_ == NULL);
+  cgen_ = cgen;
+  masm_ = cgen->masm();
+  direction_ = direction;
 }
 
 
+void JumpTarget::Unuse() {
+  ASSERT(!is_linked());
+#ifdef DEBUG
+  for (int i = 0; i < reaching_frames_.length(); i++) {
+    ASSERT(reaching_frames_[i] == NULL);
+  }
+#endif
+  delete entry_frame_;
+
+  Reset();
+}
+
+
 void JumpTarget::Reset() {
   reaching_frames_.Clear();
   merge_labels_.Clear();
   entry_frame_ = NULL;
   entry_label_.Unuse();
   is_bound_ = false;
   is_linked_ = false;
 }
 
 
@@ skipping 424 matching lines @@
   ASSERT(reaching_frames_.length() == merge_labels_.length());
   Label fresh;
   merge_labels_.Add(fresh);
   reaching_frames_.Add(frame);
 }
 
 
 // -------------------------------------------------------------------------
 // BreakTarget implementation.
 
-BreakTarget::BreakTarget() : JumpTarget(NULL, FORWARD_ONLY) {
+void BreakTarget::Initialize(CodeGenerator* cgen, Directionality direction) {
+  JumpTarget::Initialize(cgen, direction);
+  ASSERT(cgen_->has_valid_frame());
+  expected_height_ = cgen_->frame()->height();
 }
 
 
-void BreakTarget::Initialize(CodeGenerator* cgen, Directionality direction) {
-  ASSERT(cgen != NULL);
-  ASSERT(cgen_ == NULL);
-  cgen_ = cgen;
-  masm_ = cgen->masm();
-  direction_ = direction;
-}
-
-
 void BreakTarget::CopyTo(BreakTarget* destination) {
   ASSERT(destination != NULL);
   destination->cgen_ = cgen_;
   destination->masm_ = masm_;
   destination->direction_ = direction_;
   destination->reaching_frames_.Clear();
   destination->merge_labels_.Clear();
   ASSERT(reaching_frames_.length() == merge_labels_.length());
   for (int i = 0; i < reaching_frames_.length(); i++) {
     destination->reaching_frames_.Add(reaching_frames_[i]);
     destination->merge_labels_.Add(merge_labels_[i]);
   }
   destination->entry_frame_ = entry_frame_;
   destination->entry_label_ = entry_label_;
   destination->is_bound_ = is_bound_;
   destination->is_linked_ = is_linked_;
+  destination->expected_height_ = expected_height_;
+}
+
+
+void BreakTarget::Jump() {
+  ASSERT(cgen_ != NULL);
+  ASSERT(cgen_->has_valid_frame());
+
+  // This is a break target so drop leftover statement state from the
+  // frame before merging.
+  cgen_->frame()->ForgetElements(cgen_->frame()->height() - expected_height_);
+  JumpTarget::Jump();
+}
+
+
+void BreakTarget::Branch(Condition cc, Hint hint) {
+  ASSERT(cgen_ != NULL);
+  ASSERT(cgen_->has_valid_frame());
+
+  int count = cgen_->frame()->height() - expected_height_;
+  if (count > 0) {
+    // We negate and branch here rather than using
+    // JumpTarget::Branch's negate and branch.  This gives us a hook
+    // to remove statement state from the frame.
+    JumpTarget fall_through(cgen_);
+    // Branch to fall through will not negate, because it is a
+    // forward-only target.
+    fall_through.Branch(NegateCondition(cc), NegateHint(hint));
+    Jump();  // May emit merge code here.
+    fall_through.Bind();
+  } else {
+    JumpTarget::Branch(cc, hint);
+  }
+}
+
+
+void BreakTarget::Bind(int mergable_elements) {
+#ifdef DEBUG
+  ASSERT(mergable_elements == kAllElements);
+  ASSERT(cgen_ != NULL);
+  for (int i = 0; i < reaching_frames_.length(); i++) {
+    ASSERT(reaching_frames_[i]->height() == expected_height_);
+  }
+#endif
+
+  // This is a break target so drop leftover statement state from the
+  // frame before merging.
+  if (cgen_->has_valid_frame()) {
+    int count = cgen_->frame()->height() - expected_height_;
+    cgen_->frame()->ForgetElements(count);
+  }
+  JumpTarget::Bind(mergable_elements);
 }
 
 
 // -------------------------------------------------------------------------
 // ShadowTarget implementation.
 
 ShadowTarget::ShadowTarget(BreakTarget* shadowed) {
   ASSERT(shadowed != NULL);
   other_target_ = shadowed;
 
 #ifdef DEBUG
   is_shadowing_ = true;
 #endif
   // While shadowing this shadow target saves the state of the original.
   shadowed->CopyTo(this);
 
+  // The original's state is reset.  We do not Unuse it because that
+  // would delete the expected frame and assert that the target is not
+  // linked.
+  shadowed->Reset();
+  ASSERT(cgen_ != NULL);
+  ASSERT(cgen_->has_valid_frame());
+  shadowed->set_expected_height(cgen_->frame()->height());
+
   // Setting the code generator to null prevents the shadow target from
   // being used until shadowing stops.
   cgen_ = NULL;
   masm_ = NULL;
 
-  // The original's state is reset.  We do not Unuse it because that
-  // would delete the expected frame and assert that the target is not
-  // linked.
-  shadowed->Reset();
 }
 
 
 void ShadowTarget::StopShadowing() {
   ASSERT(is_shadowing_);
 
   // This target does not have a valid code generator yet.
   cgen_ = other_target_->code_generator();
   ASSERT(cgen_ != NULL);
   masm_ = cgen_->masm();
 
   // The states of this target, which was shadowed, and the original
   // target, which was shadowing, are swapped.
   BreakTarget temp;
   other_target_->CopyTo(&temp);
   CopyTo(other_target_);
   temp.CopyTo(this);
   temp.Reset();  // So the destructor does not deallocate virtual frames.
 
 #ifdef DEBUG
   is_shadowing_ = false;
 #endif
 }
 
 
 } }  // namespace v8::internal