diff options
Diffstat (limited to 'deps/v8/src/arm/builtins-arm.cc')
-rw-r--r-- | deps/v8/src/arm/builtins-arm.cc | 147 |
1 files changed, 46 insertions, 101 deletions
diff --git a/deps/v8/src/arm/builtins-arm.cc b/deps/v8/src/arm/builtins-arm.cc index a6bfdb128d..1fffcb67e5 100644 --- a/deps/v8/src/arm/builtins-arm.cc +++ b/deps/v8/src/arm/builtins-arm.cc @@ -531,6 +531,7 @@ static void Generate_JSConstructStubHelper(MacroAssembler* masm, // -- r1 : constructor function // -- r2 : allocation site or undefined // -- r3 : new target + // -- cp : context // -- lr : return address // -- sp[...]: constructor arguments // ----------------------------------- @@ -543,6 +544,7 @@ static void Generate_JSConstructStubHelper(MacroAssembler* masm, // Preserve the incoming parameters on the stack. __ AssertUndefinedOrAllocationSite(r2, r4); + __ Push(cp); __ SmiTag(r0); __ Push(r2, r0); @@ -622,7 +624,7 @@ static void Generate_JSConstructStubHelper(MacroAssembler* masm, // r0: result // sp[0]: receiver // sp[1]: number of arguments (smi-tagged) - __ ldr(cp, MemOperand(fp, StandardFrameConstants::kContextOffset)); + __ ldr(cp, MemOperand(fp, ConstructFrameConstants::kContextOffset)); if (create_implicit_receiver) { // If the result is an object (in the ECMA sense), we should get rid @@ -751,9 +753,6 @@ static void Generate_JSEntryTrampolineHelper(MacroAssembler* masm, // r5-r6, r8 (if !FLAG_enable_embedded_constant_pool) and cp may be clobbered ProfileEntryHookStub::MaybeCallEntryHook(masm); - // Clear the context before we push it when entering the internal frame. - __ mov(cp, Operand::Zero()); - // Enter an internal frame. { FrameScope scope(masm, StackFrame::INTERNAL); @@ -855,8 +854,7 @@ void Builtins::Generate_InterpreterEntryTrampoline(MacroAssembler* masm) { // MANUAL indicates that the scope shouldn't actually generate code to set up // the frame (that is done below). FrameScope frame_scope(masm, StackFrame::MANUAL); - __ PushFixedFrame(r1); - __ add(fp, sp, Operand(StandardFrameConstants::kFixedFrameSizeFromFp)); + __ PushStandardFrame(r1); // Get the bytecode array from the function object and load the pointer to the // first entry into kInterpreterBytecodeRegister. @@ -1192,8 +1190,7 @@ void Builtins::Generate_MarkCodeAsExecutedOnce(MacroAssembler* masm) { __ ldm(ia_w, sp, r0.bit() | r1.bit() | r3.bit() | fp.bit() | lr.bit()); // Perform prologue operations usually performed by the young code stub. - __ PushFixedFrame(r1); - __ add(fp, sp, Operand(StandardFrameConstants::kFixedFrameSizeFromFp)); + __ PushStandardFrame(r1); // Jump to point after the code-age stub. __ add(r0, r0, Operand(kNoCodeAgeSequenceLength)); @@ -1430,24 +1427,6 @@ void Builtins::Generate_OnStackReplacement(MacroAssembler* masm) { } -void Builtins::Generate_OsrAfterStackCheck(MacroAssembler* masm) { - // We check the stack limit as indicator that recompilation might be done. - Label ok; - __ LoadRoot(ip, Heap::kStackLimitRootIndex); - __ cmp(sp, Operand(ip)); - __ b(hs, &ok); - { - FrameAndConstantPoolScope scope(masm, StackFrame::INTERNAL); - __ CallRuntime(Runtime::kStackGuard); - } - __ Jump(masm->isolate()->builtins()->OnStackReplacement(), - RelocInfo::CODE_TARGET); - - __ bind(&ok); - __ Ret(); -} - - // static void Builtins::Generate_DatePrototype_GetField(MacroAssembler* masm, int field_index) { @@ -1494,6 +1473,27 @@ void Builtins::Generate_DatePrototype_GetField(MacroAssembler* masm, __ TailCallRuntime(Runtime::kThrowNotDateError); } +// static +void Builtins::Generate_FunctionHasInstance(MacroAssembler* masm) { + // ----------- S t a t e ------------- + // -- r0 : argc + // -- sp[0] : first argument (left-hand side) + // -- sp[4] : receiver (right-hand side) + // ----------------------------------- + + { + FrameScope scope(masm, StackFrame::INTERNAL); + __ ldr(InstanceOfDescriptor::LeftRegister(), + MemOperand(fp, 2 * kPointerSize)); // Load left-hand side. + __ ldr(InstanceOfDescriptor::RightRegister(), + MemOperand(fp, 3 * kPointerSize)); // Load right-hand side. + InstanceOfStub stub(masm->isolate(), true); + __ CallStub(&stub); + } + + // Pop the argument and the receiver. + __ Ret(2); +} // static void Builtins::Generate_FunctionPrototypeApply(MacroAssembler* masm) { @@ -1933,19 +1933,21 @@ void PrepareForTailCall(MacroAssembler* masm, Register args_reg, DCHECK(!AreAliased(args_reg, scratch1, scratch2, scratch3)); Comment cmnt(masm, "[ PrepareForTailCall"); - // Prepare for tail call only if the debugger is not active. + // Prepare for tail call only if ES2015 tail call elimination is enabled. Label done; - ExternalReference debug_is_active = - ExternalReference::debug_is_active_address(masm->isolate()); - __ mov(scratch1, Operand(debug_is_active)); + ExternalReference is_tail_call_elimination_enabled = + ExternalReference::is_tail_call_elimination_enabled_address( + masm->isolate()); + __ mov(scratch1, Operand(is_tail_call_elimination_enabled)); __ ldrb(scratch1, MemOperand(scratch1)); __ cmp(scratch1, Operand(0)); - __ b(ne, &done); + __ b(eq, &done); // Drop possible interpreter handler/stub frame. { Label no_interpreter_frame; - __ ldr(scratch3, MemOperand(fp, StandardFrameConstants::kMarkerOffset)); + __ ldr(scratch3, + MemOperand(fp, CommonFrameConstants::kContextOrFrameTypeOffset)); __ cmp(scratch3, Operand(Smi::FromInt(StackFrame::STUB))); __ b(ne, &no_interpreter_frame); __ ldr(fp, MemOperand(fp, StandardFrameConstants::kCallerFPOffset)); @@ -1953,73 +1955,37 @@ void PrepareForTailCall(MacroAssembler* masm, Register args_reg, } // Check if next frame is an arguments adaptor frame. + Register caller_args_count_reg = scratch1; Label no_arguments_adaptor, formal_parameter_count_loaded; __ ldr(scratch2, MemOperand(fp, StandardFrameConstants::kCallerFPOffset)); __ ldr(scratch3, - MemOperand(scratch2, StandardFrameConstants::kContextOffset)); + MemOperand(scratch2, CommonFrameConstants::kContextOrFrameTypeOffset)); __ cmp(scratch3, Operand(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR))); __ b(ne, &no_arguments_adaptor); - // Drop arguments adaptor frame and load arguments count. + // Drop current frame and load arguments count from arguments adaptor frame. __ mov(fp, scratch2); - __ ldr(scratch1, + __ ldr(caller_args_count_reg, MemOperand(fp, ArgumentsAdaptorFrameConstants::kLengthOffset)); - __ SmiUntag(scratch1); + __ SmiUntag(caller_args_count_reg); __ b(&formal_parameter_count_loaded); __ bind(&no_arguments_adaptor); // Load caller's formal parameter count - __ ldr(scratch1, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset)); __ ldr(scratch1, - FieldMemOperand(scratch1, JSFunction::kSharedFunctionInfoOffset)); + MemOperand(fp, ArgumentsAdaptorFrameConstants::kFunctionOffset)); __ ldr(scratch1, + FieldMemOperand(scratch1, JSFunction::kSharedFunctionInfoOffset)); + __ ldr(caller_args_count_reg, FieldMemOperand(scratch1, SharedFunctionInfo::kFormalParameterCountOffset)); - __ SmiUntag(scratch1); + __ SmiUntag(caller_args_count_reg); __ bind(&formal_parameter_count_loaded); - // Calculate the end of destination area where we will put the arguments - // after we drop current frame. We add kPointerSize to count the receiver - // argument which is not included into formal parameters count. - Register dst_reg = scratch2; - __ add(dst_reg, fp, Operand(scratch1, LSL, kPointerSizeLog2)); - __ add(dst_reg, dst_reg, - Operand(StandardFrameConstants::kCallerSPOffset + kPointerSize)); - - Register src_reg = scratch1; - __ add(src_reg, sp, Operand(args_reg, LSL, kPointerSizeLog2)); - // Count receiver argument as well (not included in args_reg). - __ add(src_reg, src_reg, Operand(kPointerSize)); - - if (FLAG_debug_code) { - __ cmp(src_reg, dst_reg); - __ Check(lo, kStackAccessBelowStackPointer); - } - - // Restore caller's frame pointer and return address now as they will be - // overwritten by the copying loop. - __ ldr(lr, MemOperand(fp, StandardFrameConstants::kCallerPCOffset)); - __ ldr(fp, MemOperand(fp, StandardFrameConstants::kCallerFPOffset)); - - // Now copy callee arguments to the caller frame going backwards to avoid - // callee arguments corruption (source and destination areas could overlap). - - // Both src_reg and dst_reg are pointing to the word after the one to copy, - // so they must be pre-decremented in the loop. - Register tmp_reg = scratch3; - Label loop, entry; - __ b(&entry); - __ bind(&loop); - __ ldr(tmp_reg, MemOperand(src_reg, -kPointerSize, PreIndex)); - __ str(tmp_reg, MemOperand(dst_reg, -kPointerSize, PreIndex)); - __ bind(&entry); - __ cmp(sp, src_reg); - __ b(ne, &loop); - - // Leave current frame. - __ mov(sp, dst_reg); - + ParameterCount callee_args_count(args_reg); + __ PrepareForTailCall(callee_args_count, caller_args_count_reg, scratch2, + scratch3); __ bind(&done); } } // namespace @@ -2473,27 +2439,6 @@ void Builtins::Generate_ArgumentsAdaptorTrampoline(MacroAssembler* masm) { { // Too few parameters: Actual < expected __ bind(&too_few); - - // If the function is strong we need to throw an error. - Label no_strong_error; - __ ldr(r4, FieldMemOperand(r1, JSFunction::kSharedFunctionInfoOffset)); - __ ldr(r5, FieldMemOperand(r4, SharedFunctionInfo::kCompilerHintsOffset)); - __ tst(r5, Operand(1 << (SharedFunctionInfo::kStrongModeFunction + - kSmiTagSize))); - __ b(eq, &no_strong_error); - - // What we really care about is the required number of arguments. - __ ldr(r4, FieldMemOperand(r4, SharedFunctionInfo::kLengthOffset)); - __ cmp(r0, Operand::SmiUntag(r4)); - __ b(ge, &no_strong_error); - - { - FrameScope frame(masm, StackFrame::MANUAL); - EnterArgumentsAdaptorFrame(masm); - __ CallRuntime(Runtime::kThrowStrongModeTooFewArguments); - } - - __ bind(&no_strong_error); EnterArgumentsAdaptorFrame(masm); ArgumentAdaptorStackCheck(masm, &stack_overflow); |