| Index: src/arm/jump-target-arm.cc
|
| ===================================================================
|
| --- src/arm/jump-target-arm.cc (revision 1967)
|
| +++ src/arm/jump-target-arm.cc (working copy)
|
| @@ -28,6 +28,7 @@
|
| #include "v8.h"
|
|
|
| #include "codegen-inl.h"
|
| +#include "jump-target-inl.h"
|
| #include "register-allocator-inl.h"
|
|
|
| namespace v8 { namespace internal {
|
| @@ -35,21 +36,20 @@
|
| // -------------------------------------------------------------------------
|
| // JumpTarget implementation.
|
|
|
| -#define __ ACCESS_MASM(masm_)
|
| +#define __ ACCESS_MASM(cgen()->masm())
|
|
|
| void JumpTarget::DoJump() {
|
| - ASSERT(cgen_ != NULL);
|
| - ASSERT(cgen_->has_valid_frame());
|
| + 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());
|
| + ASSERT(cgen()->HasValidEntryRegisters());
|
|
|
| if (is_bound()) {
|
| // Backward jump. There is an expected frame to merge to.
|
| ASSERT(direction_ == BIDIRECTIONAL);
|
| - cgen_->frame()->MergeTo(entry_frame_);
|
| - cgen_->DeleteFrame();
|
| + cgen()->frame()->MergeTo(entry_frame_);
|
| + cgen()->DeleteFrame();
|
| __ jmp(&entry_label_);
|
| } else {
|
| // Preconfigured entry frame is not used on ARM.
|
| @@ -57,17 +57,16 @@
|
| // 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());
|
| + AddReachingFrame(cgen()->frame());
|
| RegisterFile empty;
|
| - cgen_->SetFrame(NULL, &empty);
|
| + cgen()->SetFrame(NULL, &empty);
|
| __ jmp(&merge_labels_.last());
|
| }
|
| }
|
|
|
|
|
| void JumpTarget::DoBranch(Condition cc, Hint ignored) {
|
| - ASSERT(cgen_ != NULL);
|
| - ASSERT(cgen_->has_valid_frame());
|
| + ASSERT(cgen()->has_valid_frame());
|
|
|
| if (is_bound()) {
|
| ASSERT(direction_ == BIDIRECTIONAL);
|
| @@ -77,29 +76,29 @@
|
| // Swap the current frame for a copy (we do the swapping to get
|
| // the off-frame registers off the fall through) to use for the
|
| // branch.
|
| - VirtualFrame* fall_through_frame = cgen_->frame();
|
| + VirtualFrame* fall_through_frame = cgen()->frame();
|
| VirtualFrame* branch_frame = new VirtualFrame(fall_through_frame);
|
| RegisterFile non_frame_registers = RegisterAllocator::Reserved();
|
| - cgen_->SetFrame(branch_frame, &non_frame_registers);
|
| + cgen()->SetFrame(branch_frame, &non_frame_registers);
|
|
|
| // Check if we can avoid merge code.
|
| - cgen_->frame()->PrepareMergeTo(entry_frame_);
|
| - if (cgen_->frame()->Equals(entry_frame_)) {
|
| + cgen()->frame()->PrepareMergeTo(entry_frame_);
|
| + if (cgen()->frame()->Equals(entry_frame_)) {
|
| // Branch right in to the block.
|
| - cgen_->DeleteFrame();
|
| + cgen()->DeleteFrame();
|
| __ b(cc, &entry_label_);
|
| - cgen_->SetFrame(fall_through_frame, &non_frame_registers);
|
| + cgen()->SetFrame(fall_through_frame, &non_frame_registers);
|
| return;
|
| }
|
|
|
| // Check if we can reuse existing merge code.
|
| for (int i = 0; i < reaching_frames_.length(); i++) {
|
| if (reaching_frames_[i] != NULL &&
|
| - cgen_->frame()->Equals(reaching_frames_[i])) {
|
| + cgen()->frame()->Equals(reaching_frames_[i])) {
|
| // Branch to the merge code.
|
| - cgen_->DeleteFrame();
|
| + cgen()->DeleteFrame();
|
| __ b(cc, &merge_labels_[i]);
|
| - cgen_->SetFrame(fall_through_frame, &non_frame_registers);
|
| + cgen()->SetFrame(fall_through_frame, &non_frame_registers);
|
| return;
|
| }
|
| }
|
| @@ -108,10 +107,10 @@
|
| // around the merge code on the fall through path.
|
| Label original_fall_through;
|
| __ b(NegateCondition(cc), &original_fall_through);
|
| - cgen_->frame()->MergeTo(entry_frame_);
|
| - cgen_->DeleteFrame();
|
| + cgen()->frame()->MergeTo(entry_frame_);
|
| + cgen()->DeleteFrame();
|
| __ b(&entry_label_);
|
| - cgen_->SetFrame(fall_through_frame, &non_frame_registers);
|
| + cgen()->SetFrame(fall_through_frame, &non_frame_registers);
|
| __ bind(&original_fall_through);
|
|
|
| } else {
|
| @@ -120,7 +119,7 @@
|
| // 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()));
|
| + AddReachingFrame(new VirtualFrame(cgen()->frame()));
|
| __ b(cc, &merge_labels_.last());
|
| }
|
| }
|
| @@ -133,14 +132,13 @@
|
| // 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());
|
| + ASSERT(cgen()->has_valid_frame());
|
| // There are no non-frame references across the call.
|
| - ASSERT(cgen_->HasValidEntryRegisters());
|
| + ASSERT(cgen()->HasValidEntryRegisters());
|
| ASSERT(!is_linked());
|
|
|
| - cgen_->frame()->SpillAll();
|
| - VirtualFrame* target_frame = new VirtualFrame(cgen_->frame());
|
| + 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);
|
| @@ -150,20 +148,19 @@
|
|
|
|
|
| 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());
|
| + 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();
|
| + ASSERT(cgen()->has_valid_frame());
|
| + VirtualFrame* frame = cgen()->frame();
|
| int difference =
|
| frame->stack_pointer_ - (frame->elements_.length() - 1);
|
| if (difference > 0) {
|
| @@ -176,12 +173,12 @@
|
|
|
| // Another simple case: no fall through, a single forward jump,
|
| // and no possible backward jumps.
|
| - if (!cgen_->has_valid_frame() && reaching_frames_.length() == 1) {
|
| + 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);
|
| + cgen()->SetFrame(frame, &reserved);
|
| reaching_frames_[0] = NULL;
|
| __ bind(&merge_labels_[0]);
|
|
|
| @@ -201,11 +198,11 @@
|
| // 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()) {
|
| + if (cgen()->has_valid_frame()) {
|
| had_fall_through = true;
|
| - AddReachingFrame(cgen_->frame()); // Return value ignored.
|
| + AddReachingFrame(cgen()->frame()); // Return value ignored.
|
| RegisterFile empty;
|
| - cgen_->SetFrame(NULL, &empty);
|
| + cgen()->SetFrame(NULL, &empty);
|
| }
|
|
|
| // Compute the frame to use for entry to the block.
|
| @@ -242,17 +239,17 @@
|
| // binding site or as the fall through from a previous merge
|
| // code block. Jump around the code we are about to
|
| // generate.
|
| - if (cgen_->has_valid_frame()) {
|
| - cgen_->DeleteFrame();
|
| + if (cgen()->has_valid_frame()) {
|
| + cgen()->DeleteFrame();
|
| __ b(&entry_label_);
|
| }
|
| // Pick up the frame for this block. Assume ownership if
|
| // there cannot be backward jumps.
|
| RegisterFile reserved = RegisterAllocator::Reserved();
|
| if (direction_ == BIDIRECTIONAL) {
|
| - cgen_->SetFrame(new VirtualFrame(frame), &reserved);
|
| + cgen()->SetFrame(new VirtualFrame(frame), &reserved);
|
| } else {
|
| - cgen_->SetFrame(frame, &reserved);
|
| + cgen()->SetFrame(frame, &reserved);
|
| reaching_frames_[i] = NULL;
|
| }
|
| __ bind(&merge_labels_[i]);
|
| @@ -261,7 +258,7 @@
|
| // looking for any that can share merge code with this one.
|
| for (int j = 0; j < i; j++) {
|
| VirtualFrame* other = reaching_frames_[j];
|
| - if (other != NULL && other->Equals(cgen_->frame())) {
|
| + if (other != NULL && other->Equals(cgen()->frame())) {
|
| // Set the reaching frame element to null to avoid
|
| // processing it later, and then bind its entry label.
|
| reaching_frames_[j] = NULL;
|
| @@ -270,13 +267,13 @@
|
| }
|
|
|
| // Emit the merge code.
|
| - cgen_->frame()->MergeTo(entry_frame_);
|
| + cgen()->frame()->MergeTo(entry_frame_);
|
| } else if (i == reaching_frames_.length() - 1 && had_fall_through) {
|
| // If this is the fall through, and it didn't need merge
|
| // code, we need to pick up the frame so we can jump around
|
| // subsequent merge blocks if necessary.
|
| RegisterFile reserved = RegisterAllocator::Reserved();
|
| - cgen_->SetFrame(frame, &reserved);
|
| + cgen()->SetFrame(frame, &reserved);
|
| reaching_frames_[i] = NULL;
|
| }
|
| }
|
| @@ -285,9 +282,9 @@
|
| // 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()) {
|
| + if (!cgen()->has_valid_frame()) {
|
| RegisterFile reserved_registers = RegisterAllocator::Reserved();
|
| - cgen_->SetFrame(new VirtualFrame(entry_frame_), &reserved_registers);
|
| + cgen()->SetFrame(new VirtualFrame(entry_frame_), &reserved_registers);
|
| }
|
|
|
| // There may be unprocessed reaching frames that did not need
|
| @@ -313,9 +310,9 @@
|
| // 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);
|
| + cgen()->SetFrame(new VirtualFrame(reaching_frames_[0]), &reserved);
|
| __ bind(&merge_labels_[0]);
|
| - cgen_->frame()->MergeTo(entry_frame_);
|
| + cgen()->frame()->MergeTo(entry_frame_);
|
| }
|
|
|
| __ bind(&entry_label_);
|
|
|