From: jacob.bramley Date: Tue, 24 Mar 2015 09:51:30 +0000 (-0700) Subject: Revert "ARM64: use jssp for stack slots" X-Git-Tag: upstream/4.7.83~3647 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=a5ce9994a52cfeb915b785beb0eda1f5b64f9b6b;p=platform%2Fupstream%2Fv8.git Revert "ARM64: use jssp for stack slots" This reverts r21101. r21101 appears to be at fault for the ARM64 failures here: https://codereview.chromium.org/1023103003 BUG= Review URL: https://codereview.chromium.org/1019393003 Cr-Commit-Position: refs/heads/master@{#27393} --- diff --git a/src/arm64/lithium-codegen-arm64.cc b/src/arm64/lithium-codegen-arm64.cc index 47aeed9..cd331db 100644 --- a/src/arm64/lithium-codegen-arm64.cc +++ b/src/arm64/lithium-codegen-arm64.cc @@ -435,7 +435,6 @@ void LCodeGen::DoCallFunction(LCallFunction* instr) { CallFunctionStub stub(isolate(), arity, flags); CallCode(stub.GetCode(), RelocInfo::CODE_TARGET, instr); } - after_push_argument_ = false; } @@ -450,7 +449,6 @@ void LCodeGen::DoCallNew(LCallNew* instr) { CallConstructStub stub(isolate(), NO_CALL_CONSTRUCTOR_FLAGS); CallCode(stub.GetCode(), RelocInfo::CONSTRUCT_CALL, instr); - after_push_argument_ = false; DCHECK(ToRegister(instr->result()).is(x0)); } @@ -498,7 +496,6 @@ void LCodeGen::DoCallNewArray(LCallNewArray* instr) { ArrayNArgumentsConstructorStub stub(isolate(), kind, override_mode); CallCode(stub.GetCode(), RelocInfo::CONSTRUCT_CALL, instr); } - after_push_argument_ = false; DCHECK(ToRegister(instr->result()).is(x0)); } @@ -520,7 +517,7 @@ void LCodeGen::LoadContextFromDeferred(LOperand* context) { if (context->IsRegister()) { __ Mov(cp, ToRegister(context)); } else if (context->IsStackSlot()) { - __ Ldr(cp, ToMemOperand(context, kMustUseFramePointer)); + __ Ldr(cp, ToMemOperand(context)); } else if (context->IsConstantOperand()) { HConstant* constant = chunk_->LookupConstant(LConstantOperand::cast(context)); @@ -1275,38 +1272,13 @@ static int64_t ArgumentsOffsetWithoutFrame(int index) { } -MemOperand LCodeGen::ToMemOperand(LOperand* op, StackMode stack_mode) const { +MemOperand LCodeGen::ToMemOperand(LOperand* op) const { DCHECK(op != NULL); DCHECK(!op->IsRegister()); DCHECK(!op->IsDoubleRegister()); DCHECK(op->IsStackSlot() || op->IsDoubleStackSlot()); if (NeedsEagerFrame()) { - int fp_offset = StackSlotOffset(op->index()); - if (op->index() >= 0) { - // Loads and stores have a bigger reach in positive offset than negative. - // When the load or the store can't be done in one instruction via fp - // (too big negative offset), we try to access via jssp (positive offset). - // We can reference a stack slot from jssp only if jssp references the end - // of the stack slots. It's not the case when: - // - stack_mode != kCanUseStackPointer: this is the case when a deferred - // code saved the registers. - // - after_push_argument_: arguments has been pushed for a call. - // - inlined_arguments_: inlined arguments have been pushed once. All the - // remainder of the function cannot trust jssp any longer. - // - saves_caller_doubles: some double registers have been pushed, jssp - // references the end of the double registers and not the end of the - // stack slots. - // Also, if the offset from fp is small enough to make a load/store in - // one instruction, we use a fp access. - if ((stack_mode == kCanUseStackPointer) && !after_push_argument_ && - !inlined_arguments_ && !is_int9(fp_offset) && - !info()->saves_caller_doubles()) { - int jssp_offset = - (GetStackSlotCount() - op->index() - 1) * kPointerSize; - return MemOperand(masm()->StackPointer(), jssp_offset); - } - } - return MemOperand(fp, fp_offset); + return MemOperand(fp, StackSlotOffset(op->index())); } else { // Retrieve parameter without eager stack-frame relative to the // stack-pointer. @@ -1710,10 +1682,6 @@ void LCodeGen::DoApplyArguments(LApplyArguments* instr) { void LCodeGen::DoArgumentsElements(LArgumentsElements* instr) { - // We push some arguments and they will be pop in an other block. We can't - // trust that jssp references the end of the stack slots until the end of - // the function. - inlined_arguments_ = true; Register result = ToRegister(instr->result()); if (instr->hydrogen()->from_inlined()) { @@ -2130,8 +2098,6 @@ void LCodeGen::DoCallWithDescriptor(LCallWithDescriptor* instr) { } generator.AfterCall(); } - - after_push_argument_ = false; } @@ -2151,13 +2117,11 @@ void LCodeGen::DoCallJSFunction(LCallJSFunction* instr) { __ Call(x10); RecordSafepointWithLazyDeopt(instr, RECORD_SIMPLE_SAFEPOINT); - after_push_argument_ = false; } void LCodeGen::DoCallRuntime(LCallRuntime* instr) { CallRuntime(instr->function(), instr->arity(), instr); - after_push_argument_ = false; } @@ -2183,7 +2147,6 @@ void LCodeGen::DoCallStub(LCallStub* instr) { default: UNREACHABLE(); } - after_push_argument_ = false; } @@ -3239,7 +3202,6 @@ void LCodeGen::DoInvokeFunction(LInvokeFunction* instr) { instr->hydrogen()->formal_parameter_count(), instr->arity(), instr); } - after_push_argument_ = false; } @@ -4781,8 +4743,6 @@ void LCodeGen::DoPushArguments(LPushArguments* instr) { // The preamble was done by LPreparePushArguments. args.PushQueued(MacroAssembler::PushPopQueue::SKIP_PREAMBLE); - - after_push_argument_ = true; } diff --git a/src/arm64/lithium-codegen-arm64.h b/src/arm64/lithium-codegen-arm64.h index fe16a4e..d94262e 100644 --- a/src/arm64/lithium-codegen-arm64.h +++ b/src/arm64/lithium-codegen-arm64.h @@ -37,16 +37,10 @@ class LCodeGen: public LCodeGenBase { frame_is_built_(false), safepoints_(info->zone()), resolver_(this), - expected_safepoint_kind_(Safepoint::kSimple), - after_push_argument_(false), - inlined_arguments_(false) { + expected_safepoint_kind_(Safepoint::kSimple) { PopulateDeoptimizationLiteralsWithInlinedFunctions(); } - ~LCodeGen() { - DCHECK(!after_push_argument_ || inlined_arguments_); - } - // Simple accessors. Scope* scope() const { return scope_; } @@ -87,9 +81,7 @@ class LCodeGen: public LCodeGenBase { Register ToRegister32(LOperand* op) const; Operand ToOperand(LOperand* op); Operand ToOperand32(LOperand* op); - enum StackMode { kMustUseFramePointer, kCanUseStackPointer }; - MemOperand ToMemOperand(LOperand* op, - StackMode stack_mode = kCanUseStackPointer) const; + MemOperand ToMemOperand(LOperand* op) const; Handle ToHandle(LConstantOperand* op) const; template @@ -366,15 +358,6 @@ class LCodeGen: public LCodeGenBase { Safepoint::Kind expected_safepoint_kind_; - // This flag is true when we are after a push (but before a call). - // In this situation, jssp no longer references the end of the stack slots so, - // we can only reference a stack slot via fp. - bool after_push_argument_; - // If we have inlined arguments, we are no longer able to use jssp because - // jssp is modified and we never know if we are in a block after or before - // the pop of the arguments (which restores jssp). - bool inlined_arguments_; - int old_position_; class PushSafepointRegistersScope BASE_EMBEDDED {