Clean up return statements in the code generator by explicitly...

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 280 matching lines @@
   // the expression stack.
   int stack_pointer = length - 1;
   while (stack_pointer >= entry_frame_->expression_base_index() &&
          !entry_frame_->elements_[stack_pointer].is_synced()) {
     stack_pointer--;
   }
   entry_frame_->stack_pointer_ = stack_pointer;
 }
 
 
+void JumpTarget::Jump() {
+  DoJump();
+}
+
+
 void JumpTarget::Jump(Result* arg) {
   ASSERT(cgen_ != NULL);
   ASSERT(cgen_->has_valid_frame());
 
   cgen_->frame()->Push(arg);
-  Jump();
+  DoJump();
 }
 
 
 void JumpTarget::Jump(Result* arg0, Result* arg1) {
   ASSERT(cgen_ != NULL);
   ASSERT(cgen_->has_valid_frame());
 
   cgen_->frame()->Push(arg0);
   cgen_->frame()->Push(arg1);
-  Jump();
+  DoJump();
 }
 
 
 void JumpTarget::Jump(Result* arg0, Result* arg1, Result* arg2) {
   ASSERT(cgen_ != NULL);
   ASSERT(cgen_->has_valid_frame());
 
   cgen_->frame()->Push(arg0);
   cgen_->frame()->Push(arg1);
   cgen_->frame()->Push(arg2);
-  Jump();
+  DoJump();
+}
+
+
+void JumpTarget::Branch(Condition cc, Hint hint) {
+  DoBranch(cc, hint);
 }
 
 
 #ifdef DEBUG
 #define DECLARE_ARGCHECK_VARS(name)                                \
   Result::Type name##_type = name->type();                         \
   Register name##_reg = name->is_register() ? name->reg() : no_reg
 
 #define ASSERT_ARGCHECK(name)                                \
   ASSERT(name->type() == name##_type);                       \
   ASSERT(!name->is_register() || name->reg().is(name##_reg))
 
 #else
 #define DECLARE_ARGCHECK_VARS(name) do {} while (false)
 
 #define ASSERT_ARGCHECK(name) do {} while (false)
 #endif
 
 void JumpTarget::Branch(Condition cc, Result* arg, Hint hint) {
   ASSERT(cgen_ != NULL);
   ASSERT(cgen_->has_valid_frame());
 
   // We want to check that non-frame registers at the call site stay in
   // the same registers on the fall-through branch.
   DECLARE_ARGCHECK_VARS(arg);
 
   cgen_->frame()->Push(arg);
-  Branch(cc, hint);
+  DoBranch(cc, hint);
   *arg = cgen_->frame()->Pop();
 
   ASSERT_ARGCHECK(arg);
 }
 
 
 void JumpTarget::Branch(Condition cc, Result* arg0, Result* arg1, Hint hint) {
   ASSERT(cgen_ != NULL);
   ASSERT(cgen_->frame() != NULL);
 
   // We want to check that non-frame registers at the call site stay in
   // the same registers on the fall-through branch.
   DECLARE_ARGCHECK_VARS(arg0);
   DECLARE_ARGCHECK_VARS(arg1);
 
   cgen_->frame()->Push(arg0);
   cgen_->frame()->Push(arg1);
-  Branch(cc, hint);
+  DoBranch(cc, hint);
   *arg1 = cgen_->frame()->Pop();
   *arg0 = cgen_->frame()->Pop();
 
   ASSERT_ARGCHECK(arg0);
   ASSERT_ARGCHECK(arg1);
 }
 
 
 void JumpTarget::Branch(Condition cc,
                         Result* arg0,
                         Result* arg1,
                         Result* arg2,
                         Hint hint) {
   ASSERT(cgen_ != NULL);
   ASSERT(cgen_->frame() != NULL);
 
   // We want to check that non-frame registers at the call site stay in
   // the same registers on the fall-through branch.
   DECLARE_ARGCHECK_VARS(arg0);
   DECLARE_ARGCHECK_VARS(arg1);
   DECLARE_ARGCHECK_VARS(arg2);
 
   cgen_->frame()->Push(arg0);
   cgen_->frame()->Push(arg1);
   cgen_->frame()->Push(arg2);
-  Branch(cc, hint);
+  DoBranch(cc, hint);
   *arg2 = cgen_->frame()->Pop();
   *arg1 = cgen_->frame()->Pop();
   *arg0 = cgen_->frame()->Pop();
 
   ASSERT_ARGCHECK(arg0);
   ASSERT_ARGCHECK(arg1);
   ASSERT_ARGCHECK(arg2);
 }
 
 
@@ skipping 10 matching lines @@
   // the same registers on the fall-through branch.
   DECLARE_ARGCHECK_VARS(arg0);
   DECLARE_ARGCHECK_VARS(arg1);
   DECLARE_ARGCHECK_VARS(arg2);
   DECLARE_ARGCHECK_VARS(arg3);
 
   cgen_->frame()->Push(arg0);
   cgen_->frame()->Push(arg1);
   cgen_->frame()->Push(arg2);
   cgen_->frame()->Push(arg3);
-  Branch(cc, hint);
+  DoBranch(cc, hint);
   *arg3 = cgen_->frame()->Pop();
   *arg2 = cgen_->frame()->Pop();
   *arg1 = cgen_->frame()->Pop();
   *arg0 = cgen_->frame()->Pop();
 
   ASSERT_ARGCHECK(arg0);
   ASSERT_ARGCHECK(arg1);
   ASSERT_ARGCHECK(arg2);
   ASSERT_ARGCHECK(arg3);
 }
 
+
+void BreakTarget::Branch(Condition cc, Result* arg, 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 DoBranch'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(arg);  // May emit merge code here.
+    fall_through.Bind();
+  } else {
+    DECLARE_ARGCHECK_VARS(arg);
+    cgen_->frame()->Push(arg);
+    DoBranch(cc, hint);
+    *arg = cgen_->frame()->Pop();
+    ASSERT_ARGCHECK(arg);
+  }
+}
+
 #undef DECLARE_ARGCHECK_VARS
 #undef ASSERT_ARGCHECK
 
 
+void JumpTarget::Bind(int mergable_elements) {
+  DoBind(mergable_elements);
+}
+
+
 void JumpTarget::Bind(Result* arg, int mergable_elements) {
   ASSERT(cgen_ != NULL);
 
   if (cgen_->has_valid_frame()) {
     cgen_->frame()->Push(arg);
   }
-  Bind(mergable_elements);
+  DoBind(mergable_elements);
   *arg = cgen_->frame()->Pop();
 }
 
 
 void JumpTarget::Bind(Result* arg0, Result* arg1, int mergable_elements) {
   ASSERT(cgen_ != NULL);
 
   if (cgen_->has_valid_frame()) {
     cgen_->frame()->Push(arg0);
     cgen_->frame()->Push(arg1);
   }
-  Bind(mergable_elements);
+  DoBind(mergable_elements);
   *arg1 = cgen_->frame()->Pop();
   *arg0 = cgen_->frame()->Pop();
 }
 
 
 void JumpTarget::Bind(Result* arg0,
                       Result* arg1,
                       Result* arg2,
                       int mergable_elements) {
   ASSERT(cgen_ != NULL);
 
   if (cgen_->has_valid_frame()) {
     cgen_->frame()->Push(arg0);
     cgen_->frame()->Push(arg1);
     cgen_->frame()->Push(arg2);
   }
-  Bind(mergable_elements);
+  DoBind(mergable_elements);
   *arg2 = cgen_->frame()->Pop();
   *arg1 = cgen_->frame()->Pop();
   *arg0 = cgen_->frame()->Pop();
 }
 
 
 void JumpTarget::Bind(Result* arg0,
                       Result* arg1,
                       Result* arg2,
                       Result* arg3,
                       int mergable_elements) {
   ASSERT(cgen_ != NULL);
 
   if (cgen_->has_valid_frame()) {
     cgen_->frame()->Push(arg0);
     cgen_->frame()->Push(arg1);
     cgen_->frame()->Push(arg2);
     cgen_->frame()->Push(arg3);
   }
-  Bind(mergable_elements);
+  DoBind(mergable_elements);
   *arg3 = cgen_->frame()->Pop();
   *arg2 = cgen_->frame()->Pop();
   *arg1 = cgen_->frame()->Pop();
   *arg0 = cgen_->frame()->Pop();
 }
 
 
 void JumpTarget::AddReachingFrame(VirtualFrame* frame) {
   ASSERT(reaching_frames_.length() == merge_labels_.length());
   Label fresh;
@@ skipping 29 matching lines @@
   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.
+  // Drop leftover statement state from the frame before merging.
   cgen_->frame()->ForgetElements(cgen_->frame()->height() - expected_height_);
-  JumpTarget::Jump();
+  DoJump();
+}
+
+
+void BreakTarget::Jump(Result* arg) {
+  ASSERT(cgen_ != NULL);
+  ASSERT(cgen_->has_valid_frame());
+
+  // Drop leftover statement state from the frame before merging.
+  cgen_->frame()->ForgetElements(cgen_->frame()->height() - expected_height_);
+  cgen_->frame()->Push(arg);
+  DoJump();
 }
 
 
 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.
+    // We negate and branch here rather than using DoBranch'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);
+    DoBranch(cc, hint);
   }
 }
 
 
 void BreakTarget::Bind(int mergable_elements) {
 #ifdef DEBUG
-  ASSERT(mergable_elements == kAllElements);
   ASSERT(cgen_ != NULL);
   // All the forward-reaching frames should have been adjusted at the
   // jumps to this target.
   for (int i = 0; i < reaching_frames_.length(); i++) {
     ASSERT(reaching_frames_[i] == NULL ||
            reaching_frames_[i]->height() == expected_height_);
   }
 #endif
-  // This is a break target so we drop leftover statement state from
-  // the frame before merging, even on the fall through.  This is
-  // because we can bind the return target with state on the frame.
+  // Drop leftover statement state from the frame before merging, even
+  // on the fall through.  This is so we can bind the return target
+  // with state on the frame.
   if (cgen_->has_valid_frame()) {
     cgen_->frame()->ForgetElements(cgen_->frame()->height() - expected_height_);
   }
-  JumpTarget::Bind(mergable_elements);
+  DoBind(mergable_elements);
+}
+
+
+void BreakTarget::Bind(Result* arg, int mergable_elements) {
+#ifdef DEBUG
+  ASSERT(cgen_ != NULL);
+  // All the forward-reaching frames should have been adjusted at the
+  // jumps to this target.
+  for (int i = 0; i < reaching_frames_.length(); i++) {
+    ASSERT(reaching_frames_[i] == NULL ||
+           reaching_frames_[i]->height() == expected_height_ + 1);
+  }
+#endif
+  // Drop leftover statement state from the frame before merging, even
+  // on the fall through.  This is so we can bind the return target
+  // with state on the frame.
+  if (cgen_->has_valid_frame()) {
+    cgen_->frame()->ForgetElements(cgen_->frame()->height() - expected_height_);
+    cgen_->frame()->Push(arg);
+  }
+  DoBind(mergable_elements);
+  *arg = cgen_->frame()->Pop();
 }
 
 
 // -------------------------------------------------------------------------
 // ShadowTarget implementation.
 
 ShadowTarget::ShadowTarget(BreakTarget* shadowed) {
   ASSERT(shadowed != NULL);
   other_target_ = shadowed;
 
@@ skipping 34 matching lines @@
   temp.CopyTo(this);
   temp.Reset();  // So the destructor does not deallocate virtual frames.
 
 #ifdef DEBUG
   is_shadowing_ = false;
 #endif
 }
 
 
 } }  // namespace v8::internal