Experimental: statically distinguish between named basic block entries...

src/jump-target-ia32.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 19 matching lines @@
 #include "codegen.h"
 #include "jump-target.h"
 
 namespace v8 { namespace internal {
 
 // -------------------------------------------------------------------------
 // JumpTarget implementation.
 
 #define __ masm_->
 
-JumpTarget::JumpTarget(CodeGenerator* cgen)
+JumpTarget::JumpTarget(CodeGenerator* cgen, Directionality direction)
     : cgen_(cgen),
+      direction_(direction),
       reaching_frames_(0),
       merge_labels_(0),
       expected_frame_(NULL) {
   ASSERT(cgen_ != NULL);
   masm_ = cgen_->masm();
 }
 
 
 JumpTarget::JumpTarget()
     : cgen_(NULL),
       masm_(NULL),
+      direction_(FORWARD_ONLY),
       reaching_frames_(0),
       merge_labels_(0),
       expected_frame_(NULL) {
 }
 
 
-void JumpTarget::set_code_generator(CodeGenerator* cgen) {
+void JumpTarget::Initialize(CodeGenerator* cgen, Directionality direction) {
   ASSERT(cgen != NULL);
   ASSERT(cgen_ == NULL);
   cgen_ = cgen;
   masm_ = cgen->masm();
+  direction_ = direction;
 }
 
 
 void JumpTarget::Jump() {
   ASSERT(cgen_ != NULL);
   ASSERT(cgen_->has_valid_frame());
   // Live non-frame registers are not allowed at unconditional jumps
   // because we have no way of invalidating the corresponding results
   // which are still live in the C++ code.
   ASSERT(cgen_->HasValidEntryRegisters());
 
   if (is_bound()) {
     // Backward jump.  There is an expected frame to merge to.
+    ASSERT(direction_ == BIDIRECTIONAL);
     cgen_->frame()->MergeTo(expected_frame_);
     cgen_->DeleteFrame();
     __ jmp(&entry_label_);
   } else {
     // 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);
@@ skipping 26 matching lines @@
   ASSERT(cgen_->has_valid_frame());
 
   if (is_bound()) {
     // Backward branch.  We have an expected frame to merge to on the
     // backward edge.  We negate the condition and emit the merge code
     // here.
     //
     // TODO(): we should try to avoid negating the condition in the case
     // where there is no merge code to emit.  Otherwise, we emit a
     // branch around an unconditional jump.
+    ASSERT(direction_ == BIDIRECTIONAL);
     Label original_fall_through;
     __ j(NegateCondition(cc), &original_fall_through, NegateHint(hint));
     // Swap the current frame for a copy of it, saving non-frame
     // register reference counts and invalidating all non-frame register
     // references except the reserved ones on the backward edge.
     VirtualFrame* original_frame = cgen_->frame();
     VirtualFrame* working_frame = new VirtualFrame(original_frame);
     RegisterFile non_frame_registers = RegisterAllocator::Reserved();
     cgen_->SetFrame(working_frame, &non_frame_registers);
 
@@ skipping 165 matching lines @@
   Bind();
   *arg1 = cgen_->frame()->Pop();
   *arg0 = cgen_->frame()->Pop();
 }
 
 
 void JumpTarget::CopyTo(JumpTarget* 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->expected_frame_ = expected_frame_;
   destination->entry_label_ = entry_label_;
 }
@@ skipping 28 matching lines @@
   // 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.
   JumpTarget temp;
-
   other_target_->CopyTo(&temp);
   CopyTo(other_target_);
   temp.CopyTo(this);
   temp.Reset();  // So the destructor does not deallocate virtual frames.
 
-  // The shadowing target does not have a valid code generator yet.
-  other_target_->set_code_generator(cgen_);
 #ifdef DEBUG
   is_shadowing_ = false;
 #endif
 }
 
 #undef __
 
 
 } }  // namespace v8::internal