From: fschneider@chromium.org Date: Thu, 1 Dec 2011 16:57:54 +0000 (+0000) Subject: Revert r10118 from bleeding edge. X-Git-Tag: upstream/4.7.83~17804 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=8f7a1f7808130c5713e1c047bc167ce1cb255d84;p=platform%2Fupstream%2Fv8.git Revert r10118 from bleeding edge. It causes several test failures which I need to investigate. Review URL: http://codereview.chromium.org/8769008 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@10132 ce2b1a6d-e550-0410-aec6-3dcde31c8c00 --- diff --git a/src/arm/lithium-arm.cc b/src/arm/lithium-arm.cc index 6a9ebbc..2341774 100644 --- a/src/arm/lithium-arm.cc +++ b/src/arm/lithium-arm.cc @@ -2202,7 +2202,12 @@ LInstruction* LChunkBuilder::DoSimulate(HSimulate* instr) { LInstruction* LChunkBuilder::DoStackCheck(HStackCheck* instr) { - return AssignEnvironment(AssignPointerMap(new LStackCheck)); + if (instr->is_function_entry()) { + return MarkAsCall(new LStackCheck, instr); + } else { + ASSERT(instr->is_backwards_branch()); + return AssignEnvironment(AssignPointerMap(new LStackCheck)); + } } diff --git a/src/arm/lithium-codegen-arm.cc b/src/arm/lithium-codegen-arm.cc index 4600264..22a504f 100644 --- a/src/arm/lithium-codegen-arm.cc +++ b/src/arm/lithium-codegen-arm.cc @@ -4649,22 +4649,38 @@ void LCodeGen::DoStackCheck(LStackCheck* instr) { LStackCheck* instr_; }; - DeferredStackCheck* deferred_stack_check = - new DeferredStackCheck(this, instr); - __ LoadRoot(ip, Heap::kStackLimitRootIndex); - __ cmp(sp, Operand(ip)); - __ b(lo, deferred_stack_check->entry()); - EnsureSpaceForLazyDeopt(); - __ bind(instr->done_label()); - deferred_stack_check->SetExit(instr->done_label()); - // There is no LLazyBailout instruction for stack-checks. We have to - // prepare for lazy deoptimization explicitly here. ASSERT(instr->HasEnvironment()); LEnvironment* env = instr->environment(); - RegisterEnvironmentForDeoptimization(env, Safepoint::kLazyDeopt); - // Don't record a deoptimization index for the safepoint here. - // This will be done explicitly when emitting call and the safepoint in - // the deferred code. + // There is no LLazyBailout instruction for stack-checks. We have to + // prepare for lazy deoptimization explicitly here. + if (instr->hydrogen()->is_function_entry()) { + // Perform stack overflow check. + Label done; + __ LoadRoot(ip, Heap::kStackLimitRootIndex); + __ cmp(sp, Operand(ip)); + __ b(hs, &done); + StackCheckStub stub; + CallCode(stub.GetCode(), RelocInfo::CODE_TARGET, instr); + EnsureSpaceForLazyDeopt(); + __ bind(&done); + RegisterEnvironmentForDeoptimization(env, Safepoint::kLazyDeopt); + safepoints_.RecordLazyDeoptimizationIndex(env->deoptimization_index()); + } else { + ASSERT(instr->hydrogen()->is_backwards_branch()); + // Perform stack overflow check if this goto needs it before jumping. + DeferredStackCheck* deferred_stack_check = + new DeferredStackCheck(this, instr); + __ LoadRoot(ip, Heap::kStackLimitRootIndex); + __ cmp(sp, Operand(ip)); + __ b(lo, deferred_stack_check->entry()); + EnsureSpaceForLazyDeopt(); + __ bind(instr->done_label()); + deferred_stack_check->SetExit(instr->done_label()); + RegisterEnvironmentForDeoptimization(env, Safepoint::kLazyDeopt); + // Don't record a deoptimization index for the safepoint here. + // This will be done explicitly when emitting call and the safepoint in + // the deferred code. + } } diff --git a/src/hydrogen-instructions.h b/src/hydrogen-instructions.h index 953d417..52fed88 100644 --- a/src/hydrogen-instructions.h +++ b/src/hydrogen-instructions.h @@ -1271,7 +1271,12 @@ class HSimulate: public HInstruction { class HStackCheck: public HTemplateInstruction<1> { public: - explicit HStackCheck(HValue* context) { + enum Type { + kFunctionEntry, + kBackwardsBranch + }; + + HStackCheck(HValue* context, Type type) : type_(type) { SetOperandAt(0, context); } @@ -1289,7 +1294,13 @@ class HStackCheck: public HTemplateInstruction<1> { } } + bool is_function_entry() { return type_ == kFunctionEntry; } + bool is_backwards_branch() { return type_ == kBackwardsBranch; } + DECLARE_CONCRETE_INSTRUCTION(StackCheck) + + private: + Type type_; }; diff --git a/src/hydrogen.cc b/src/hydrogen.cc index c90d38c..5c0703b 100644 --- a/src/hydrogen.cc +++ b/src/hydrogen.cc @@ -2333,7 +2333,8 @@ HGraph* HGraphBuilder::CreateGraph() { AddSimulate(AstNode::kDeclarationsId); HValue* context = environment()->LookupContext(); - AddInstruction(new(zone()) HStackCheck(context)); + AddInstruction( + new(zone()) HStackCheck(context, HStackCheck::kFunctionEntry)); VisitStatements(info()->function()->body()); if (HasStackOverflow()) return NULL; @@ -2921,7 +2922,8 @@ void HGraphBuilder::VisitLoopBody(IterationStatement* stmt, BreakAndContinueScope push(break_info, this); AddSimulate(stmt->StackCheckId()); HValue* context = environment()->LookupContext(); - HStackCheck* stack_check = new(zone()) HStackCheck(context); + HStackCheck* stack_check = + new(zone()) HStackCheck(context, HStackCheck::kBackwardsBranch); AddInstruction(stack_check); ASSERT(loop_entry->IsLoopHeader()); loop_entry->loop_information()->set_stack_check(stack_check); diff --git a/src/ia32/lithium-codegen-ia32.cc b/src/ia32/lithium-codegen-ia32.cc index bd744c7..d5ef4d9 100644 --- a/src/ia32/lithium-codegen-ia32.cc +++ b/src/ia32/lithium-codegen-ia32.cc @@ -4554,23 +4554,43 @@ void LCodeGen::DoStackCheck(LStackCheck* instr) { LStackCheck* instr_; }; - DeferredStackCheck* deferred_stack_check = - new DeferredStackCheck(this, instr); - ExternalReference stack_limit = - ExternalReference::address_of_stack_limit(isolate()); - __ cmp(esp, Operand::StaticVariable(stack_limit)); - __ j(below, deferred_stack_check->entry()); - EnsureSpaceForLazyDeopt(); - __ bind(instr->done_label()); - deferred_stack_check->SetExit(instr->done_label()); - // There is no LLazyBailout instruction for stack-checks. We have to - // prepare for lazy deoptimization explicitly here. ASSERT(instr->HasEnvironment()); LEnvironment* env = instr->environment(); - RegisterEnvironmentForDeoptimization(env, Safepoint::kLazyDeopt); - // Don't record a deoptimization index for the safepoint here. - // This will be done explicitly when emitting call and the safepoint in - // the deferred code. + // There is no LLazyBailout instruction for stack-checks. We have to + // prepare for lazy deoptimization explicitly here. + if (instr->hydrogen()->is_function_entry()) { + // Perform stack overflow check. + Label done; + ExternalReference stack_limit = + ExternalReference::address_of_stack_limit(isolate()); + __ cmp(esp, Operand::StaticVariable(stack_limit)); + __ j(above_equal, &done, Label::kNear); + + ASSERT(instr->context()->IsRegister()); + ASSERT(ToRegister(instr->context()).is(esi)); + StackCheckStub stub; + CallCode(stub.GetCode(), RelocInfo::CODE_TARGET, instr); + EnsureSpaceForLazyDeopt(); + __ bind(&done); + RegisterEnvironmentForDeoptimization(env, Safepoint::kLazyDeopt); + safepoints_.RecordLazyDeoptimizationIndex(env->deoptimization_index()); + } else { + ASSERT(instr->hydrogen()->is_backwards_branch()); + // Perform stack overflow check if this goto needs it before jumping. + DeferredStackCheck* deferred_stack_check = + new DeferredStackCheck(this, instr); + ExternalReference stack_limit = + ExternalReference::address_of_stack_limit(isolate()); + __ cmp(esp, Operand::StaticVariable(stack_limit)); + __ j(below, deferred_stack_check->entry()); + EnsureSpaceForLazyDeopt(); + __ bind(instr->done_label()); + deferred_stack_check->SetExit(instr->done_label()); + RegisterEnvironmentForDeoptimization(env, Safepoint::kLazyDeopt); + // Don't record a deoptimization index for the safepoint here. + // This will be done explicitly when emitting call and the safepoint in + // the deferred code. + } } diff --git a/src/ia32/lithium-ia32.cc b/src/ia32/lithium-ia32.cc index a90e52a..4e5f278 100644 --- a/src/ia32/lithium-ia32.cc +++ b/src/ia32/lithium-ia32.cc @@ -2328,9 +2328,15 @@ LInstruction* LChunkBuilder::DoSimulate(HSimulate* instr) { LInstruction* LChunkBuilder::DoStackCheck(HStackCheck* instr) { - LOperand* context = UseAny(instr->context()); - return AssignEnvironment( - AssignPointerMap(new(zone()) LStackCheck(context))); + if (instr->is_function_entry()) { + LOperand* context = UseFixed(instr->context(), esi); + return MarkAsCall(new(zone()) LStackCheck(context), instr); + } else { + ASSERT(instr->is_backwards_branch()); + LOperand* context = UseAny(instr->context()); + return AssignEnvironment( + AssignPointerMap(new(zone()) LStackCheck(context))); + } } diff --git a/src/ia32/lithium-ia32.h b/src/ia32/lithium-ia32.h index 2127156..5170647 100644 --- a/src/ia32/lithium-ia32.h +++ b/src/ia32/lithium-ia32.h @@ -228,6 +228,7 @@ class LInstruction: public ZoneObject { LPointerMap* pointer_map() const { return pointer_map_.get(); } bool HasPointerMap() const { return pointer_map_.is_set(); } + void set_hydrogen_value(HValue* value) { hydrogen_value_ = value; } HValue* hydrogen_value() const { return hydrogen_value_; } diff --git a/src/x64/lithium-codegen-x64.cc b/src/x64/lithium-codegen-x64.cc index 02c36a3..25e1484 100644 --- a/src/x64/lithium-codegen-x64.cc +++ b/src/x64/lithium-codegen-x64.cc @@ -4263,21 +4263,38 @@ void LCodeGen::DoStackCheck(LStackCheck* instr) { LStackCheck* instr_; }; - DeferredStackCheck* deferred_stack_check = - new DeferredStackCheck(this, instr); - __ CompareRoot(rsp, Heap::kStackLimitRootIndex); - __ j(below, deferred_stack_check->entry()); - EnsureSpaceForLazyDeopt(Deoptimizer::patch_size()); - __ bind(instr->done_label()); - deferred_stack_check->SetExit(instr->done_label()); - // There is no LLazyBailout instruction for stack-checks. We have to - // prepare for lazy deoptimization explicitly here. ASSERT(instr->HasEnvironment()); LEnvironment* env = instr->environment(); - RegisterEnvironmentForDeoptimization(env, Safepoint::kLazyDeopt); - // Don't record a deoptimization index for the safepoint here. - // This will be done explicitly when emitting call and the safepoint in - // the deferred code. + // There is no LLazyBailout instruction for stack-checks. We have to + // prepare for lazy deoptimization explicitly here. + if (instr->hydrogen()->is_function_entry()) { + // Perform stack overflow check. + Label done; + __ CompareRoot(rsp, Heap::kStackLimitRootIndex); + __ j(above_equal, &done, Label::kNear); + StackCheckStub stub; + CallCode(stub.GetCode(), RelocInfo::CODE_TARGET, instr); + EnsureSpaceForLazyDeopt(Deoptimizer::patch_size()); + last_lazy_deopt_pc_ = masm()->pc_offset(); + __ bind(&done); + RegisterEnvironmentForDeoptimization(env, Safepoint::kLazyDeopt); + safepoints_.RecordLazyDeoptimizationIndex(env->deoptimization_index()); + } else { + ASSERT(instr->hydrogen()->is_backwards_branch()); + // Perform stack overflow check if this goto needs it before jumping. + DeferredStackCheck* deferred_stack_check = + new DeferredStackCheck(this, instr); + __ CompareRoot(rsp, Heap::kStackLimitRootIndex); + __ j(below, deferred_stack_check->entry()); + EnsureSpaceForLazyDeopt(Deoptimizer::patch_size()); + last_lazy_deopt_pc_ = masm()->pc_offset(); + __ bind(instr->done_label()); + deferred_stack_check->SetExit(instr->done_label()); + RegisterEnvironmentForDeoptimization(env, Safepoint::kLazyDeopt); + // Don't record a deoptimization index for the safepoint here. + // This will be done explicitly when emitting call and the safepoint in + // the deferred code. + } } diff --git a/src/x64/lithium-x64.cc b/src/x64/lithium-x64.cc index 512fe99..b486fae 100644 --- a/src/x64/lithium-x64.cc +++ b/src/x64/lithium-x64.cc @@ -2203,7 +2203,12 @@ LInstruction* LChunkBuilder::DoSimulate(HSimulate* instr) { LInstruction* LChunkBuilder::DoStackCheck(HStackCheck* instr) { - return AssignEnvironment(AssignPointerMap(new LStackCheck)); + if (instr->is_function_entry()) { + return MarkAsCall(new LStackCheck, instr); + } else { + ASSERT(instr->is_backwards_branch()); + return AssignEnvironment(AssignPointerMap(new LStackCheck)); + } }