Remove the redundant flags is_bound_ and is_linked_ from the...

src/arm/jump-target-arm.cc

 // Copyright 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 44 matching lines @@
     // Preconfigured entry frame is not used on ARM.
     ASSERT(entry_frame_ == NULL);
     // Forward jump.  The current frame is added to the end of the list
     // of frames reaching the target block and a jump to the merge code
     // is emitted.
     AddReachingFrame(cgen_->frame());
     RegisterFile empty;
     cgen_->SetFrame(NULL, &empty);
     __ jmp(&merge_labels_.last());
   }
-
-  is_linked_ = !is_bound_;
 }
 
 
 void JumpTarget::DoBranch(Condition cc, Hint ignored) {
   ASSERT(cgen_ != NULL);
   ASSERT(cgen_->has_valid_frame());
 
   if (is_bound()) {
     ASSERT(direction_ == BIDIRECTIONAL);
     // Backward branch.  We have an expected frame to merge to on the
@@ skipping 40 matching lines @@
     __ bind(&original_fall_through);
 
   } else {
     // Preconfigured entry frame is not used on ARM.
     ASSERT(entry_frame_ == NULL);
     // Forward branch.  A copy of the current frame is added to the end
     // of the list of frames reaching the target block and a branch to
     // the merge code is emitted.
     AddReachingFrame(new VirtualFrame(cgen_->frame()));
     __ b(cc, &merge_labels_.last());
-    is_linked_ = true;
   }
 }
 
 
 void JumpTarget::Call() {
   // Call is used to push the address of the catch block on the stack as
   // a return address when compiling try/catch and try/finally.  We
   // fully spill the frame before making the call.  The expected frame
   // at the label (which should be the only one) is the spilled current
   // frame plus an in-memory return address.  The "fall-through" frame
   // at the return site is the spilled current frame.
   ASSERT(cgen_ != NULL);
   ASSERT(cgen_->has_valid_frame());
   // There are no non-frame references across the call.
   ASSERT(cgen_->HasValidEntryRegisters());
   ASSERT(!is_linked());
 
   cgen_->frame()->SpillAll();
   VirtualFrame* target_frame = new VirtualFrame(cgen_->frame());
   target_frame->Adjust(1);
   // We do not expect a call with a preconfigured entry frame.
   ASSERT(entry_frame_ == NULL);
   AddReachingFrame(target_frame);
   __ bl(&merge_labels_.last());
-
-  is_linked_ = !is_bound_;
 }
 
 
 void JumpTarget::DoBind(int mergable_elements) {
   ASSERT(cgen_ != NULL);
   ASSERT(!is_bound());
 
   // Live non-frame registers are not allowed at the start of a basic
   // block.
   ASSERT(!cgen_->has_valid_frame() || cgen_->HasValidEntryRegisters());
 
   if (direction_ == FORWARD_ONLY) {
     // A simple case: no forward jumps and no possible backward jumps.
     if (!is_linked()) {
       // The stack pointer can be floating above the top of the
       // virtual frame before the bind.  Afterward, it should not.
       ASSERT(cgen_->has_valid_frame());
       VirtualFrame* frame = cgen_->frame();
       int difference =
           frame->stack_pointer_ - (frame->elements_.length() - 1);
       if (difference > 0) {
         frame->stack_pointer_ -= difference;
         __ add(sp, sp, Operand(difference * kPointerSize));
       }
-
-      is_bound_ = true;
+      __ bind(&entry_label_);
       return;
     }
 
     // Another simple case: no fall through, a single forward jump,
     // and no possible backward jumps.
     if (!cgen_->has_valid_frame() && reaching_frames_.length() == 1) {
       // Pick up the only reaching frame, take ownership of it, and
       // use it for the block about to be emitted.
       VirtualFrame* frame = reaching_frames_[0];
       RegisterFile reserved = RegisterAllocator::Reserved();
       cgen_->SetFrame(frame, &reserved);
       reaching_frames_[0] = NULL;
       __ bind(&merge_labels_[0]);
 
       // The stack pointer can be floating above the top of the
       // virtual frame before the bind.  Afterward, it should not.
       int difference =
           frame->stack_pointer_ - (frame->elements_.length() - 1);
       if (difference > 0) {
         frame->stack_pointer_ -= difference;
         __ add(sp, sp, Operand(difference * kPointerSize));
       }
-
-      is_linked_ = false;
-      is_bound_ = true;
+      __ bind(&entry_label_);
       return;
     }
   }
 
   // If there is a current frame, record it as the fall-through.  It
   // is owned by the reaching frames for now.
   bool had_fall_through = false;
   if (cgen_->has_valid_frame()) {
     had_fall_through = true;
     AddReachingFrame(cgen_->frame());  // Return value ignored.
@@ skipping 76 matching lines @@
     }
 
     // The code generator may not have a current frame if there was no
     // fall through and none of the reaching frames needed merging.
     // In that case, clone the entry frame as the current frame.
     if (!cgen_->has_valid_frame()) {
       RegisterFile reserved_registers = RegisterAllocator::Reserved();
       cgen_->SetFrame(new VirtualFrame(entry_frame_), &reserved_registers);
     }
 
-    // There is certainly a current frame equal to the entry frame.
-    // Bind the entry frame label.
-    __ bind(&entry_label_);
-
     // There may be unprocessed reaching frames that did not need
     // merge code.  They will have unbound merge labels.  Bind their
     // merge labels to be the same as the entry label and deallocate
     // them.
     for (int i = 0; i < reaching_frames_.length(); i++) {
       if (!merge_labels_[i].is_bound()) {
         reaching_frames_[i] = NULL;
         __ bind(&merge_labels_[i]);
       }
     }
 
     // There are non-NULL reaching frames with bound labels for each
     // merge block, but only on backward targets.
   } else {
     // There were no forward jumps.  There must be a current frame and
     // this must be a bidirectional target.
     ASSERT(reaching_frames_.length() == 1);
     ASSERT(reaching_frames_[0] != NULL);
     ASSERT(direction_ == BIDIRECTIONAL);
 
     // Use a copy of the reaching frame so the original can be saved
     // for possible reuse as a backward merge block.
     RegisterFile reserved = RegisterAllocator::Reserved();
     cgen_->SetFrame(new VirtualFrame(reaching_frames_[0]), &reserved);
     __ bind(&merge_labels_[0]);
     cgen_->frame()->MergeTo(entry_frame_);
-    __ bind(&entry_label_);
   }
 
-  is_linked_ = false;
-  is_bound_ = true;
+  __ bind(&entry_label_);
 }
 
 #undef __
 
 
 } }  // namespace v8::internal