d07a2eb806
This way we don't clash with the ASSERT* macros defined by GoogleTest, and we are one step closer to being able to replace our homegrown base/ with base/ from Chrome. R=jochen@chromium.org, svenpanne@chromium.org Review URL: https://codereview.chromium.org/430503007 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22812 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
937 lines
31 KiB
C++
937 lines
31 KiB
C++
// Copyright 2012 the V8 project authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file.
|
|
|
|
#include "src/v8.h"
|
|
|
|
#if V8_TARGET_ARCH_ARM
|
|
|
|
#include "src/arm/simulator-arm.h"
|
|
#include "src/codegen.h"
|
|
#include "src/macro-assembler.h"
|
|
|
|
namespace v8 {
|
|
namespace internal {
|
|
|
|
|
|
#define __ masm.
|
|
|
|
|
|
#if defined(USE_SIMULATOR)
|
|
byte* fast_exp_arm_machine_code = NULL;
|
|
double fast_exp_simulator(double x) {
|
|
return Simulator::current(Isolate::Current())->CallFPReturnsDouble(
|
|
fast_exp_arm_machine_code, x, 0);
|
|
}
|
|
#endif
|
|
|
|
|
|
UnaryMathFunction CreateExpFunction() {
|
|
if (!FLAG_fast_math) return &std::exp;
|
|
size_t actual_size;
|
|
byte* buffer =
|
|
static_cast<byte*>(base::OS::Allocate(1 * KB, &actual_size, true));
|
|
if (buffer == NULL) return &std::exp;
|
|
ExternalReference::InitializeMathExpData();
|
|
|
|
MacroAssembler masm(NULL, buffer, static_cast<int>(actual_size));
|
|
|
|
{
|
|
DwVfpRegister input = d0;
|
|
DwVfpRegister result = d1;
|
|
DwVfpRegister double_scratch1 = d2;
|
|
DwVfpRegister double_scratch2 = d3;
|
|
Register temp1 = r4;
|
|
Register temp2 = r5;
|
|
Register temp3 = r6;
|
|
|
|
if (masm.use_eabi_hardfloat()) {
|
|
// Input value is in d0 anyway, nothing to do.
|
|
} else {
|
|
__ vmov(input, r0, r1);
|
|
}
|
|
__ Push(temp3, temp2, temp1);
|
|
MathExpGenerator::EmitMathExp(
|
|
&masm, input, result, double_scratch1, double_scratch2,
|
|
temp1, temp2, temp3);
|
|
__ Pop(temp3, temp2, temp1);
|
|
if (masm.use_eabi_hardfloat()) {
|
|
__ vmov(d0, result);
|
|
} else {
|
|
__ vmov(r0, r1, result);
|
|
}
|
|
__ Ret();
|
|
}
|
|
|
|
CodeDesc desc;
|
|
masm.GetCode(&desc);
|
|
DCHECK(!RelocInfo::RequiresRelocation(desc));
|
|
|
|
CpuFeatures::FlushICache(buffer, actual_size);
|
|
base::OS::ProtectCode(buffer, actual_size);
|
|
|
|
#if !defined(USE_SIMULATOR)
|
|
return FUNCTION_CAST<UnaryMathFunction>(buffer);
|
|
#else
|
|
fast_exp_arm_machine_code = buffer;
|
|
return &fast_exp_simulator;
|
|
#endif
|
|
}
|
|
|
|
#if defined(V8_HOST_ARCH_ARM)
|
|
MemCopyUint8Function CreateMemCopyUint8Function(MemCopyUint8Function stub) {
|
|
#if defined(USE_SIMULATOR)
|
|
return stub;
|
|
#else
|
|
if (!CpuFeatures::IsSupported(UNALIGNED_ACCESSES)) return stub;
|
|
size_t actual_size;
|
|
byte* buffer =
|
|
static_cast<byte*>(base::OS::Allocate(1 * KB, &actual_size, true));
|
|
if (buffer == NULL) return stub;
|
|
|
|
MacroAssembler masm(NULL, buffer, static_cast<int>(actual_size));
|
|
|
|
Register dest = r0;
|
|
Register src = r1;
|
|
Register chars = r2;
|
|
Register temp1 = r3;
|
|
Label less_4;
|
|
|
|
if (CpuFeatures::IsSupported(NEON)) {
|
|
Label loop, less_256, less_128, less_64, less_32, _16_or_less, _8_or_less;
|
|
Label size_less_than_8;
|
|
__ pld(MemOperand(src, 0));
|
|
|
|
__ cmp(chars, Operand(8));
|
|
__ b(lt, &size_less_than_8);
|
|
__ cmp(chars, Operand(32));
|
|
__ b(lt, &less_32);
|
|
if (CpuFeatures::cache_line_size() == 32) {
|
|
__ pld(MemOperand(src, 32));
|
|
}
|
|
__ cmp(chars, Operand(64));
|
|
__ b(lt, &less_64);
|
|
__ pld(MemOperand(src, 64));
|
|
if (CpuFeatures::cache_line_size() == 32) {
|
|
__ pld(MemOperand(src, 96));
|
|
}
|
|
__ cmp(chars, Operand(128));
|
|
__ b(lt, &less_128);
|
|
__ pld(MemOperand(src, 128));
|
|
if (CpuFeatures::cache_line_size() == 32) {
|
|
__ pld(MemOperand(src, 160));
|
|
}
|
|
__ pld(MemOperand(src, 192));
|
|
if (CpuFeatures::cache_line_size() == 32) {
|
|
__ pld(MemOperand(src, 224));
|
|
}
|
|
__ cmp(chars, Operand(256));
|
|
__ b(lt, &less_256);
|
|
__ sub(chars, chars, Operand(256));
|
|
|
|
__ bind(&loop);
|
|
__ pld(MemOperand(src, 256));
|
|
__ vld1(Neon8, NeonListOperand(d0, 4), NeonMemOperand(src, PostIndex));
|
|
if (CpuFeatures::cache_line_size() == 32) {
|
|
__ pld(MemOperand(src, 256));
|
|
}
|
|
__ vld1(Neon8, NeonListOperand(d4, 4), NeonMemOperand(src, PostIndex));
|
|
__ sub(chars, chars, Operand(64), SetCC);
|
|
__ vst1(Neon8, NeonListOperand(d0, 4), NeonMemOperand(dest, PostIndex));
|
|
__ vst1(Neon8, NeonListOperand(d4, 4), NeonMemOperand(dest, PostIndex));
|
|
__ b(ge, &loop);
|
|
__ add(chars, chars, Operand(256));
|
|
|
|
__ bind(&less_256);
|
|
__ vld1(Neon8, NeonListOperand(d0, 4), NeonMemOperand(src, PostIndex));
|
|
__ vld1(Neon8, NeonListOperand(d4, 4), NeonMemOperand(src, PostIndex));
|
|
__ sub(chars, chars, Operand(128));
|
|
__ vst1(Neon8, NeonListOperand(d0, 4), NeonMemOperand(dest, PostIndex));
|
|
__ vst1(Neon8, NeonListOperand(d4, 4), NeonMemOperand(dest, PostIndex));
|
|
__ vld1(Neon8, NeonListOperand(d0, 4), NeonMemOperand(src, PostIndex));
|
|
__ vld1(Neon8, NeonListOperand(d4, 4), NeonMemOperand(src, PostIndex));
|
|
__ vst1(Neon8, NeonListOperand(d0, 4), NeonMemOperand(dest, PostIndex));
|
|
__ vst1(Neon8, NeonListOperand(d4, 4), NeonMemOperand(dest, PostIndex));
|
|
__ cmp(chars, Operand(64));
|
|
__ b(lt, &less_64);
|
|
|
|
__ bind(&less_128);
|
|
__ vld1(Neon8, NeonListOperand(d0, 4), NeonMemOperand(src, PostIndex));
|
|
__ vld1(Neon8, NeonListOperand(d4, 4), NeonMemOperand(src, PostIndex));
|
|
__ sub(chars, chars, Operand(64));
|
|
__ vst1(Neon8, NeonListOperand(d0, 4), NeonMemOperand(dest, PostIndex));
|
|
__ vst1(Neon8, NeonListOperand(d4, 4), NeonMemOperand(dest, PostIndex));
|
|
|
|
__ bind(&less_64);
|
|
__ cmp(chars, Operand(32));
|
|
__ b(lt, &less_32);
|
|
__ vld1(Neon8, NeonListOperand(d0, 4), NeonMemOperand(src, PostIndex));
|
|
__ vst1(Neon8, NeonListOperand(d0, 4), NeonMemOperand(dest, PostIndex));
|
|
__ sub(chars, chars, Operand(32));
|
|
|
|
__ bind(&less_32);
|
|
__ cmp(chars, Operand(16));
|
|
__ b(le, &_16_or_less);
|
|
__ vld1(Neon8, NeonListOperand(d0, 2), NeonMemOperand(src, PostIndex));
|
|
__ vst1(Neon8, NeonListOperand(d0, 2), NeonMemOperand(dest, PostIndex));
|
|
__ sub(chars, chars, Operand(16));
|
|
|
|
__ bind(&_16_or_less);
|
|
__ cmp(chars, Operand(8));
|
|
__ b(le, &_8_or_less);
|
|
__ vld1(Neon8, NeonListOperand(d0), NeonMemOperand(src, PostIndex));
|
|
__ vst1(Neon8, NeonListOperand(d0), NeonMemOperand(dest, PostIndex));
|
|
__ sub(chars, chars, Operand(8));
|
|
|
|
// Do a last copy which may overlap with the previous copy (up to 8 bytes).
|
|
__ bind(&_8_or_less);
|
|
__ rsb(chars, chars, Operand(8));
|
|
__ sub(src, src, Operand(chars));
|
|
__ sub(dest, dest, Operand(chars));
|
|
__ vld1(Neon8, NeonListOperand(d0), NeonMemOperand(src));
|
|
__ vst1(Neon8, NeonListOperand(d0), NeonMemOperand(dest));
|
|
|
|
__ Ret();
|
|
|
|
__ bind(&size_less_than_8);
|
|
|
|
__ bic(temp1, chars, Operand(0x3), SetCC);
|
|
__ b(&less_4, eq);
|
|
__ ldr(temp1, MemOperand(src, 4, PostIndex));
|
|
__ str(temp1, MemOperand(dest, 4, PostIndex));
|
|
} else {
|
|
Register temp2 = ip;
|
|
Label loop;
|
|
|
|
__ bic(temp2, chars, Operand(0x3), SetCC);
|
|
__ b(&less_4, eq);
|
|
__ add(temp2, dest, temp2);
|
|
|
|
__ bind(&loop);
|
|
__ ldr(temp1, MemOperand(src, 4, PostIndex));
|
|
__ str(temp1, MemOperand(dest, 4, PostIndex));
|
|
__ cmp(dest, temp2);
|
|
__ b(&loop, ne);
|
|
}
|
|
|
|
__ bind(&less_4);
|
|
__ mov(chars, Operand(chars, LSL, 31), SetCC);
|
|
// bit0 => Z (ne), bit1 => C (cs)
|
|
__ ldrh(temp1, MemOperand(src, 2, PostIndex), cs);
|
|
__ strh(temp1, MemOperand(dest, 2, PostIndex), cs);
|
|
__ ldrb(temp1, MemOperand(src), ne);
|
|
__ strb(temp1, MemOperand(dest), ne);
|
|
__ Ret();
|
|
|
|
CodeDesc desc;
|
|
masm.GetCode(&desc);
|
|
DCHECK(!RelocInfo::RequiresRelocation(desc));
|
|
|
|
CpuFeatures::FlushICache(buffer, actual_size);
|
|
base::OS::ProtectCode(buffer, actual_size);
|
|
return FUNCTION_CAST<MemCopyUint8Function>(buffer);
|
|
#endif
|
|
}
|
|
|
|
|
|
// Convert 8 to 16. The number of character to copy must be at least 8.
|
|
MemCopyUint16Uint8Function CreateMemCopyUint16Uint8Function(
|
|
MemCopyUint16Uint8Function stub) {
|
|
#if defined(USE_SIMULATOR)
|
|
return stub;
|
|
#else
|
|
if (!CpuFeatures::IsSupported(UNALIGNED_ACCESSES)) return stub;
|
|
size_t actual_size;
|
|
byte* buffer =
|
|
static_cast<byte*>(base::OS::Allocate(1 * KB, &actual_size, true));
|
|
if (buffer == NULL) return stub;
|
|
|
|
MacroAssembler masm(NULL, buffer, static_cast<int>(actual_size));
|
|
|
|
Register dest = r0;
|
|
Register src = r1;
|
|
Register chars = r2;
|
|
if (CpuFeatures::IsSupported(NEON)) {
|
|
Register temp = r3;
|
|
Label loop;
|
|
|
|
__ bic(temp, chars, Operand(0x7));
|
|
__ sub(chars, chars, Operand(temp));
|
|
__ add(temp, dest, Operand(temp, LSL, 1));
|
|
|
|
__ bind(&loop);
|
|
__ vld1(Neon8, NeonListOperand(d0), NeonMemOperand(src, PostIndex));
|
|
__ vmovl(NeonU8, q0, d0);
|
|
__ vst1(Neon16, NeonListOperand(d0, 2), NeonMemOperand(dest, PostIndex));
|
|
__ cmp(dest, temp);
|
|
__ b(&loop, ne);
|
|
|
|
// Do a last copy which will overlap with the previous copy (1 to 8 bytes).
|
|
__ rsb(chars, chars, Operand(8));
|
|
__ sub(src, src, Operand(chars));
|
|
__ sub(dest, dest, Operand(chars, LSL, 1));
|
|
__ vld1(Neon8, NeonListOperand(d0), NeonMemOperand(src));
|
|
__ vmovl(NeonU8, q0, d0);
|
|
__ vst1(Neon16, NeonListOperand(d0, 2), NeonMemOperand(dest));
|
|
__ Ret();
|
|
} else {
|
|
Register temp1 = r3;
|
|
Register temp2 = ip;
|
|
Register temp3 = lr;
|
|
Register temp4 = r4;
|
|
Label loop;
|
|
Label not_two;
|
|
|
|
__ Push(lr, r4);
|
|
__ bic(temp2, chars, Operand(0x3));
|
|
__ add(temp2, dest, Operand(temp2, LSL, 1));
|
|
|
|
__ bind(&loop);
|
|
__ ldr(temp1, MemOperand(src, 4, PostIndex));
|
|
__ uxtb16(temp3, Operand(temp1, ROR, 0));
|
|
__ uxtb16(temp4, Operand(temp1, ROR, 8));
|
|
__ pkhbt(temp1, temp3, Operand(temp4, LSL, 16));
|
|
__ str(temp1, MemOperand(dest));
|
|
__ pkhtb(temp1, temp4, Operand(temp3, ASR, 16));
|
|
__ str(temp1, MemOperand(dest, 4));
|
|
__ add(dest, dest, Operand(8));
|
|
__ cmp(dest, temp2);
|
|
__ b(&loop, ne);
|
|
|
|
__ mov(chars, Operand(chars, LSL, 31), SetCC); // bit0 => ne, bit1 => cs
|
|
__ b(¬_two, cc);
|
|
__ ldrh(temp1, MemOperand(src, 2, PostIndex));
|
|
__ uxtb(temp3, Operand(temp1, ROR, 8));
|
|
__ mov(temp3, Operand(temp3, LSL, 16));
|
|
__ uxtab(temp3, temp3, Operand(temp1, ROR, 0));
|
|
__ str(temp3, MemOperand(dest, 4, PostIndex));
|
|
__ bind(¬_two);
|
|
__ ldrb(temp1, MemOperand(src), ne);
|
|
__ strh(temp1, MemOperand(dest), ne);
|
|
__ Pop(pc, r4);
|
|
}
|
|
|
|
CodeDesc desc;
|
|
masm.GetCode(&desc);
|
|
|
|
CpuFeatures::FlushICache(buffer, actual_size);
|
|
base::OS::ProtectCode(buffer, actual_size);
|
|
|
|
return FUNCTION_CAST<MemCopyUint16Uint8Function>(buffer);
|
|
#endif
|
|
}
|
|
#endif
|
|
|
|
UnaryMathFunction CreateSqrtFunction() {
|
|
#if defined(USE_SIMULATOR)
|
|
return &std::sqrt;
|
|
#else
|
|
size_t actual_size;
|
|
byte* buffer =
|
|
static_cast<byte*>(base::OS::Allocate(1 * KB, &actual_size, true));
|
|
if (buffer == NULL) return &std::sqrt;
|
|
|
|
MacroAssembler masm(NULL, buffer, static_cast<int>(actual_size));
|
|
|
|
__ MovFromFloatParameter(d0);
|
|
__ vsqrt(d0, d0);
|
|
__ MovToFloatResult(d0);
|
|
__ Ret();
|
|
|
|
CodeDesc desc;
|
|
masm.GetCode(&desc);
|
|
DCHECK(!RelocInfo::RequiresRelocation(desc));
|
|
|
|
CpuFeatures::FlushICache(buffer, actual_size);
|
|
base::OS::ProtectCode(buffer, actual_size);
|
|
return FUNCTION_CAST<UnaryMathFunction>(buffer);
|
|
#endif
|
|
}
|
|
|
|
#undef __
|
|
|
|
|
|
// -------------------------------------------------------------------------
|
|
// Platform-specific RuntimeCallHelper functions.
|
|
|
|
void StubRuntimeCallHelper::BeforeCall(MacroAssembler* masm) const {
|
|
masm->EnterFrame(StackFrame::INTERNAL);
|
|
DCHECK(!masm->has_frame());
|
|
masm->set_has_frame(true);
|
|
}
|
|
|
|
|
|
void StubRuntimeCallHelper::AfterCall(MacroAssembler* masm) const {
|
|
masm->LeaveFrame(StackFrame::INTERNAL);
|
|
DCHECK(masm->has_frame());
|
|
masm->set_has_frame(false);
|
|
}
|
|
|
|
|
|
// -------------------------------------------------------------------------
|
|
// Code generators
|
|
|
|
#define __ ACCESS_MASM(masm)
|
|
|
|
void ElementsTransitionGenerator::GenerateMapChangeElementsTransition(
|
|
MacroAssembler* masm,
|
|
Register receiver,
|
|
Register key,
|
|
Register value,
|
|
Register target_map,
|
|
AllocationSiteMode mode,
|
|
Label* allocation_memento_found) {
|
|
Register scratch_elements = r4;
|
|
DCHECK(!AreAliased(receiver, key, value, target_map,
|
|
scratch_elements));
|
|
|
|
if (mode == TRACK_ALLOCATION_SITE) {
|
|
DCHECK(allocation_memento_found != NULL);
|
|
__ JumpIfJSArrayHasAllocationMemento(
|
|
receiver, scratch_elements, allocation_memento_found);
|
|
}
|
|
|
|
// Set transitioned map.
|
|
__ str(target_map, FieldMemOperand(receiver, HeapObject::kMapOffset));
|
|
__ RecordWriteField(receiver,
|
|
HeapObject::kMapOffset,
|
|
target_map,
|
|
r9,
|
|
kLRHasNotBeenSaved,
|
|
kDontSaveFPRegs,
|
|
EMIT_REMEMBERED_SET,
|
|
OMIT_SMI_CHECK);
|
|
}
|
|
|
|
|
|
void ElementsTransitionGenerator::GenerateSmiToDouble(
|
|
MacroAssembler* masm,
|
|
Register receiver,
|
|
Register key,
|
|
Register value,
|
|
Register target_map,
|
|
AllocationSiteMode mode,
|
|
Label* fail) {
|
|
// Register lr contains the return address.
|
|
Label loop, entry, convert_hole, gc_required, only_change_map, done;
|
|
Register elements = r4;
|
|
Register length = r5;
|
|
Register array = r6;
|
|
Register array_end = array;
|
|
|
|
// target_map parameter can be clobbered.
|
|
Register scratch1 = target_map;
|
|
Register scratch2 = r9;
|
|
|
|
// Verify input registers don't conflict with locals.
|
|
DCHECK(!AreAliased(receiver, key, value, target_map,
|
|
elements, length, array, scratch2));
|
|
|
|
if (mode == TRACK_ALLOCATION_SITE) {
|
|
__ JumpIfJSArrayHasAllocationMemento(receiver, elements, fail);
|
|
}
|
|
|
|
// Check for empty arrays, which only require a map transition and no changes
|
|
// to the backing store.
|
|
__ ldr(elements, FieldMemOperand(receiver, JSObject::kElementsOffset));
|
|
__ CompareRoot(elements, Heap::kEmptyFixedArrayRootIndex);
|
|
__ b(eq, &only_change_map);
|
|
|
|
__ push(lr);
|
|
__ ldr(length, FieldMemOperand(elements, FixedArray::kLengthOffset));
|
|
// length: number of elements (smi-tagged)
|
|
|
|
// Allocate new FixedDoubleArray.
|
|
// Use lr as a temporary register.
|
|
__ mov(lr, Operand(length, LSL, 2));
|
|
__ add(lr, lr, Operand(FixedDoubleArray::kHeaderSize));
|
|
__ Allocate(lr, array, elements, scratch2, &gc_required, DOUBLE_ALIGNMENT);
|
|
// array: destination FixedDoubleArray, not tagged as heap object.
|
|
__ ldr(elements, FieldMemOperand(receiver, JSObject::kElementsOffset));
|
|
// r4: source FixedArray.
|
|
|
|
// Set destination FixedDoubleArray's length and map.
|
|
__ LoadRoot(scratch2, Heap::kFixedDoubleArrayMapRootIndex);
|
|
__ str(length, MemOperand(array, FixedDoubleArray::kLengthOffset));
|
|
// Update receiver's map.
|
|
__ str(scratch2, MemOperand(array, HeapObject::kMapOffset));
|
|
|
|
__ str(target_map, FieldMemOperand(receiver, HeapObject::kMapOffset));
|
|
__ RecordWriteField(receiver,
|
|
HeapObject::kMapOffset,
|
|
target_map,
|
|
scratch2,
|
|
kLRHasBeenSaved,
|
|
kDontSaveFPRegs,
|
|
OMIT_REMEMBERED_SET,
|
|
OMIT_SMI_CHECK);
|
|
// Replace receiver's backing store with newly created FixedDoubleArray.
|
|
__ add(scratch1, array, Operand(kHeapObjectTag));
|
|
__ str(scratch1, FieldMemOperand(receiver, JSObject::kElementsOffset));
|
|
__ RecordWriteField(receiver,
|
|
JSObject::kElementsOffset,
|
|
scratch1,
|
|
scratch2,
|
|
kLRHasBeenSaved,
|
|
kDontSaveFPRegs,
|
|
EMIT_REMEMBERED_SET,
|
|
OMIT_SMI_CHECK);
|
|
|
|
// Prepare for conversion loop.
|
|
__ add(scratch1, elements, Operand(FixedArray::kHeaderSize - kHeapObjectTag));
|
|
__ add(scratch2, array, Operand(FixedDoubleArray::kHeaderSize));
|
|
__ add(array_end, scratch2, Operand(length, LSL, 2));
|
|
|
|
// Repurpose registers no longer in use.
|
|
Register hole_lower = elements;
|
|
Register hole_upper = length;
|
|
|
|
__ mov(hole_lower, Operand(kHoleNanLower32));
|
|
__ mov(hole_upper, Operand(kHoleNanUpper32));
|
|
// scratch1: begin of source FixedArray element fields, not tagged
|
|
// hole_lower: kHoleNanLower32
|
|
// hole_upper: kHoleNanUpper32
|
|
// array_end: end of destination FixedDoubleArray, not tagged
|
|
// scratch2: begin of FixedDoubleArray element fields, not tagged
|
|
|
|
__ b(&entry);
|
|
|
|
__ bind(&only_change_map);
|
|
__ str(target_map, FieldMemOperand(receiver, HeapObject::kMapOffset));
|
|
__ RecordWriteField(receiver,
|
|
HeapObject::kMapOffset,
|
|
target_map,
|
|
scratch2,
|
|
kLRHasNotBeenSaved,
|
|
kDontSaveFPRegs,
|
|
OMIT_REMEMBERED_SET,
|
|
OMIT_SMI_CHECK);
|
|
__ b(&done);
|
|
|
|
// Call into runtime if GC is required.
|
|
__ bind(&gc_required);
|
|
__ pop(lr);
|
|
__ b(fail);
|
|
|
|
// Convert and copy elements.
|
|
__ bind(&loop);
|
|
__ ldr(lr, MemOperand(scratch1, 4, PostIndex));
|
|
// lr: current element
|
|
__ UntagAndJumpIfNotSmi(lr, lr, &convert_hole);
|
|
|
|
// Normal smi, convert to double and store.
|
|
__ vmov(s0, lr);
|
|
__ vcvt_f64_s32(d0, s0);
|
|
__ vstr(d0, scratch2, 0);
|
|
__ add(scratch2, scratch2, Operand(8));
|
|
__ b(&entry);
|
|
|
|
// Hole found, store the-hole NaN.
|
|
__ bind(&convert_hole);
|
|
if (FLAG_debug_code) {
|
|
// Restore a "smi-untagged" heap object.
|
|
__ SmiTag(lr);
|
|
__ orr(lr, lr, Operand(1));
|
|
__ CompareRoot(lr, Heap::kTheHoleValueRootIndex);
|
|
__ Assert(eq, kObjectFoundInSmiOnlyArray);
|
|
}
|
|
__ Strd(hole_lower, hole_upper, MemOperand(scratch2, 8, PostIndex));
|
|
|
|
__ bind(&entry);
|
|
__ cmp(scratch2, array_end);
|
|
__ b(lt, &loop);
|
|
|
|
__ pop(lr);
|
|
__ bind(&done);
|
|
}
|
|
|
|
|
|
void ElementsTransitionGenerator::GenerateDoubleToObject(
|
|
MacroAssembler* masm,
|
|
Register receiver,
|
|
Register key,
|
|
Register value,
|
|
Register target_map,
|
|
AllocationSiteMode mode,
|
|
Label* fail) {
|
|
// Register lr contains the return address.
|
|
Label entry, loop, convert_hole, gc_required, only_change_map;
|
|
Register elements = r4;
|
|
Register array = r6;
|
|
Register length = r5;
|
|
Register scratch = r9;
|
|
|
|
// Verify input registers don't conflict with locals.
|
|
DCHECK(!AreAliased(receiver, key, value, target_map,
|
|
elements, array, length, scratch));
|
|
|
|
if (mode == TRACK_ALLOCATION_SITE) {
|
|
__ JumpIfJSArrayHasAllocationMemento(receiver, elements, fail);
|
|
}
|
|
|
|
// Check for empty arrays, which only require a map transition and no changes
|
|
// to the backing store.
|
|
__ ldr(elements, FieldMemOperand(receiver, JSObject::kElementsOffset));
|
|
__ CompareRoot(elements, Heap::kEmptyFixedArrayRootIndex);
|
|
__ b(eq, &only_change_map);
|
|
|
|
__ push(lr);
|
|
__ Push(target_map, receiver, key, value);
|
|
__ ldr(length, FieldMemOperand(elements, FixedArray::kLengthOffset));
|
|
// elements: source FixedDoubleArray
|
|
// length: number of elements (smi-tagged)
|
|
|
|
// Allocate new FixedArray.
|
|
// Re-use value and target_map registers, as they have been saved on the
|
|
// stack.
|
|
Register array_size = value;
|
|
Register allocate_scratch = target_map;
|
|
__ mov(array_size, Operand(FixedDoubleArray::kHeaderSize));
|
|
__ add(array_size, array_size, Operand(length, LSL, 1));
|
|
__ Allocate(array_size, array, allocate_scratch, scratch, &gc_required,
|
|
NO_ALLOCATION_FLAGS);
|
|
// array: destination FixedArray, not tagged as heap object
|
|
// Set destination FixedDoubleArray's length and map.
|
|
__ LoadRoot(scratch, Heap::kFixedArrayMapRootIndex);
|
|
__ str(length, MemOperand(array, FixedDoubleArray::kLengthOffset));
|
|
__ str(scratch, MemOperand(array, HeapObject::kMapOffset));
|
|
|
|
// Prepare for conversion loop.
|
|
Register src_elements = elements;
|
|
Register dst_elements = target_map;
|
|
Register dst_end = length;
|
|
Register heap_number_map = scratch;
|
|
__ add(src_elements, elements,
|
|
Operand(FixedDoubleArray::kHeaderSize - kHeapObjectTag + 4));
|
|
__ add(dst_elements, array, Operand(FixedArray::kHeaderSize));
|
|
__ add(array, array, Operand(kHeapObjectTag));
|
|
__ add(dst_end, dst_elements, Operand(length, LSL, 1));
|
|
__ LoadRoot(heap_number_map, Heap::kHeapNumberMapRootIndex);
|
|
// Using offsetted addresses in src_elements to fully take advantage of
|
|
// post-indexing.
|
|
// dst_elements: begin of destination FixedArray element fields, not tagged
|
|
// src_elements: begin of source FixedDoubleArray element fields,
|
|
// not tagged, +4
|
|
// dst_end: end of destination FixedArray, not tagged
|
|
// array: destination FixedArray
|
|
// heap_number_map: heap number map
|
|
__ b(&entry);
|
|
|
|
// Call into runtime if GC is required.
|
|
__ bind(&gc_required);
|
|
__ Pop(target_map, receiver, key, value);
|
|
__ pop(lr);
|
|
__ b(fail);
|
|
|
|
__ bind(&loop);
|
|
Register upper_bits = key;
|
|
__ ldr(upper_bits, MemOperand(src_elements, 8, PostIndex));
|
|
// upper_bits: current element's upper 32 bit
|
|
// src_elements: address of next element's upper 32 bit
|
|
__ cmp(upper_bits, Operand(kHoleNanUpper32));
|
|
__ b(eq, &convert_hole);
|
|
|
|
// Non-hole double, copy value into a heap number.
|
|
Register heap_number = receiver;
|
|
Register scratch2 = value;
|
|
__ AllocateHeapNumber(heap_number, scratch2, lr, heap_number_map,
|
|
&gc_required);
|
|
// heap_number: new heap number
|
|
__ ldr(scratch2, MemOperand(src_elements, 12, NegOffset));
|
|
__ Strd(scratch2, upper_bits,
|
|
FieldMemOperand(heap_number, HeapNumber::kValueOffset));
|
|
__ mov(scratch2, dst_elements);
|
|
__ str(heap_number, MemOperand(dst_elements, 4, PostIndex));
|
|
__ RecordWrite(array,
|
|
scratch2,
|
|
heap_number,
|
|
kLRHasBeenSaved,
|
|
kDontSaveFPRegs,
|
|
EMIT_REMEMBERED_SET,
|
|
OMIT_SMI_CHECK);
|
|
__ b(&entry);
|
|
|
|
// Replace the-hole NaN with the-hole pointer.
|
|
__ bind(&convert_hole);
|
|
__ LoadRoot(scratch2, Heap::kTheHoleValueRootIndex);
|
|
__ str(scratch2, MemOperand(dst_elements, 4, PostIndex));
|
|
|
|
__ bind(&entry);
|
|
__ cmp(dst_elements, dst_end);
|
|
__ b(lt, &loop);
|
|
|
|
__ Pop(target_map, receiver, key, value);
|
|
// Replace receiver's backing store with newly created and filled FixedArray.
|
|
__ str(array, FieldMemOperand(receiver, JSObject::kElementsOffset));
|
|
__ RecordWriteField(receiver,
|
|
JSObject::kElementsOffset,
|
|
array,
|
|
scratch,
|
|
kLRHasBeenSaved,
|
|
kDontSaveFPRegs,
|
|
EMIT_REMEMBERED_SET,
|
|
OMIT_SMI_CHECK);
|
|
__ pop(lr);
|
|
|
|
__ bind(&only_change_map);
|
|
// Update receiver's map.
|
|
__ str(target_map, FieldMemOperand(receiver, HeapObject::kMapOffset));
|
|
__ RecordWriteField(receiver,
|
|
HeapObject::kMapOffset,
|
|
target_map,
|
|
scratch,
|
|
kLRHasNotBeenSaved,
|
|
kDontSaveFPRegs,
|
|
OMIT_REMEMBERED_SET,
|
|
OMIT_SMI_CHECK);
|
|
}
|
|
|
|
|
|
void StringCharLoadGenerator::Generate(MacroAssembler* masm,
|
|
Register string,
|
|
Register index,
|
|
Register result,
|
|
Label* call_runtime) {
|
|
// Fetch the instance type of the receiver into result register.
|
|
__ ldr(result, FieldMemOperand(string, HeapObject::kMapOffset));
|
|
__ ldrb(result, FieldMemOperand(result, Map::kInstanceTypeOffset));
|
|
|
|
// We need special handling for indirect strings.
|
|
Label check_sequential;
|
|
__ tst(result, Operand(kIsIndirectStringMask));
|
|
__ b(eq, &check_sequential);
|
|
|
|
// Dispatch on the indirect string shape: slice or cons.
|
|
Label cons_string;
|
|
__ tst(result, Operand(kSlicedNotConsMask));
|
|
__ b(eq, &cons_string);
|
|
|
|
// Handle slices.
|
|
Label indirect_string_loaded;
|
|
__ ldr(result, FieldMemOperand(string, SlicedString::kOffsetOffset));
|
|
__ ldr(string, FieldMemOperand(string, SlicedString::kParentOffset));
|
|
__ add(index, index, Operand::SmiUntag(result));
|
|
__ jmp(&indirect_string_loaded);
|
|
|
|
// Handle cons strings.
|
|
// Check whether the right hand side is the empty string (i.e. if
|
|
// this is really a flat string in a cons string). If that is not
|
|
// the case we would rather go to the runtime system now to flatten
|
|
// the string.
|
|
__ bind(&cons_string);
|
|
__ ldr(result, FieldMemOperand(string, ConsString::kSecondOffset));
|
|
__ CompareRoot(result, Heap::kempty_stringRootIndex);
|
|
__ b(ne, call_runtime);
|
|
// Get the first of the two strings and load its instance type.
|
|
__ ldr(string, FieldMemOperand(string, ConsString::kFirstOffset));
|
|
|
|
__ bind(&indirect_string_loaded);
|
|
__ ldr(result, FieldMemOperand(string, HeapObject::kMapOffset));
|
|
__ ldrb(result, FieldMemOperand(result, Map::kInstanceTypeOffset));
|
|
|
|
// Distinguish sequential and external strings. Only these two string
|
|
// representations can reach here (slices and flat cons strings have been
|
|
// reduced to the underlying sequential or external string).
|
|
Label external_string, check_encoding;
|
|
__ bind(&check_sequential);
|
|
STATIC_ASSERT(kSeqStringTag == 0);
|
|
__ tst(result, Operand(kStringRepresentationMask));
|
|
__ b(ne, &external_string);
|
|
|
|
// Prepare sequential strings
|
|
STATIC_ASSERT(SeqTwoByteString::kHeaderSize == SeqOneByteString::kHeaderSize);
|
|
__ add(string,
|
|
string,
|
|
Operand(SeqTwoByteString::kHeaderSize - kHeapObjectTag));
|
|
__ jmp(&check_encoding);
|
|
|
|
// Handle external strings.
|
|
__ bind(&external_string);
|
|
if (FLAG_debug_code) {
|
|
// Assert that we do not have a cons or slice (indirect strings) here.
|
|
// Sequential strings have already been ruled out.
|
|
__ tst(result, Operand(kIsIndirectStringMask));
|
|
__ Assert(eq, kExternalStringExpectedButNotFound);
|
|
}
|
|
// Rule out short external strings.
|
|
STATIC_ASSERT(kShortExternalStringTag != 0);
|
|
__ tst(result, Operand(kShortExternalStringMask));
|
|
__ b(ne, call_runtime);
|
|
__ ldr(string, FieldMemOperand(string, ExternalString::kResourceDataOffset));
|
|
|
|
Label ascii, done;
|
|
__ bind(&check_encoding);
|
|
STATIC_ASSERT(kTwoByteStringTag == 0);
|
|
__ tst(result, Operand(kStringEncodingMask));
|
|
__ b(ne, &ascii);
|
|
// Two-byte string.
|
|
__ ldrh(result, MemOperand(string, index, LSL, 1));
|
|
__ jmp(&done);
|
|
__ bind(&ascii);
|
|
// Ascii string.
|
|
__ ldrb(result, MemOperand(string, index));
|
|
__ bind(&done);
|
|
}
|
|
|
|
|
|
static MemOperand ExpConstant(int index, Register base) {
|
|
return MemOperand(base, index * kDoubleSize);
|
|
}
|
|
|
|
|
|
void MathExpGenerator::EmitMathExp(MacroAssembler* masm,
|
|
DwVfpRegister input,
|
|
DwVfpRegister result,
|
|
DwVfpRegister double_scratch1,
|
|
DwVfpRegister double_scratch2,
|
|
Register temp1,
|
|
Register temp2,
|
|
Register temp3) {
|
|
DCHECK(!input.is(result));
|
|
DCHECK(!input.is(double_scratch1));
|
|
DCHECK(!input.is(double_scratch2));
|
|
DCHECK(!result.is(double_scratch1));
|
|
DCHECK(!result.is(double_scratch2));
|
|
DCHECK(!double_scratch1.is(double_scratch2));
|
|
DCHECK(!temp1.is(temp2));
|
|
DCHECK(!temp1.is(temp3));
|
|
DCHECK(!temp2.is(temp3));
|
|
DCHECK(ExternalReference::math_exp_constants(0).address() != NULL);
|
|
|
|
Label zero, infinity, done;
|
|
|
|
__ mov(temp3, Operand(ExternalReference::math_exp_constants(0)));
|
|
|
|
__ vldr(double_scratch1, ExpConstant(0, temp3));
|
|
__ VFPCompareAndSetFlags(double_scratch1, input);
|
|
__ b(ge, &zero);
|
|
|
|
__ vldr(double_scratch2, ExpConstant(1, temp3));
|
|
__ VFPCompareAndSetFlags(input, double_scratch2);
|
|
__ b(ge, &infinity);
|
|
|
|
__ vldr(double_scratch1, ExpConstant(3, temp3));
|
|
__ vldr(result, ExpConstant(4, temp3));
|
|
__ vmul(double_scratch1, double_scratch1, input);
|
|
__ vadd(double_scratch1, double_scratch1, result);
|
|
__ VmovLow(temp2, double_scratch1);
|
|
__ vsub(double_scratch1, double_scratch1, result);
|
|
__ vldr(result, ExpConstant(6, temp3));
|
|
__ vldr(double_scratch2, ExpConstant(5, temp3));
|
|
__ vmul(double_scratch1, double_scratch1, double_scratch2);
|
|
__ vsub(double_scratch1, double_scratch1, input);
|
|
__ vsub(result, result, double_scratch1);
|
|
__ vmul(double_scratch2, double_scratch1, double_scratch1);
|
|
__ vmul(result, result, double_scratch2);
|
|
__ vldr(double_scratch2, ExpConstant(7, temp3));
|
|
__ vmul(result, result, double_scratch2);
|
|
__ vsub(result, result, double_scratch1);
|
|
// Mov 1 in double_scratch2 as math_exp_constants_array[8] == 1.
|
|
DCHECK(*reinterpret_cast<double*>
|
|
(ExternalReference::math_exp_constants(8).address()) == 1);
|
|
__ vmov(double_scratch2, 1);
|
|
__ vadd(result, result, double_scratch2);
|
|
__ mov(temp1, Operand(temp2, LSR, 11));
|
|
__ Ubfx(temp2, temp2, 0, 11);
|
|
__ add(temp1, temp1, Operand(0x3ff));
|
|
|
|
// Must not call ExpConstant() after overwriting temp3!
|
|
__ mov(temp3, Operand(ExternalReference::math_exp_log_table()));
|
|
__ add(temp3, temp3, Operand(temp2, LSL, 3));
|
|
__ ldm(ia, temp3, temp2.bit() | temp3.bit());
|
|
// The first word is loaded is the lower number register.
|
|
if (temp2.code() < temp3.code()) {
|
|
__ orr(temp1, temp3, Operand(temp1, LSL, 20));
|
|
__ vmov(double_scratch1, temp2, temp1);
|
|
} else {
|
|
__ orr(temp1, temp2, Operand(temp1, LSL, 20));
|
|
__ vmov(double_scratch1, temp3, temp1);
|
|
}
|
|
__ vmul(result, result, double_scratch1);
|
|
__ b(&done);
|
|
|
|
__ bind(&zero);
|
|
__ vmov(result, kDoubleRegZero);
|
|
__ b(&done);
|
|
|
|
__ bind(&infinity);
|
|
__ vldr(result, ExpConstant(2, temp3));
|
|
|
|
__ bind(&done);
|
|
}
|
|
|
|
#undef __
|
|
|
|
#ifdef DEBUG
|
|
// add(r0, pc, Operand(-8))
|
|
static const uint32_t kCodeAgePatchFirstInstruction = 0xe24f0008;
|
|
#endif
|
|
|
|
CodeAgingHelper::CodeAgingHelper() {
|
|
DCHECK(young_sequence_.length() == kNoCodeAgeSequenceLength);
|
|
// Since patcher is a large object, allocate it dynamically when needed,
|
|
// to avoid overloading the stack in stress conditions.
|
|
// DONT_FLUSH is used because the CodeAgingHelper is initialized early in
|
|
// the process, before ARM simulator ICache is setup.
|
|
SmartPointer<CodePatcher> patcher(
|
|
new CodePatcher(young_sequence_.start(),
|
|
young_sequence_.length() / Assembler::kInstrSize,
|
|
CodePatcher::DONT_FLUSH));
|
|
PredictableCodeSizeScope scope(patcher->masm(), young_sequence_.length());
|
|
patcher->masm()->PushFixedFrame(r1);
|
|
patcher->masm()->nop(ip.code());
|
|
patcher->masm()->add(
|
|
fp, sp, Operand(StandardFrameConstants::kFixedFrameSizeFromFp));
|
|
}
|
|
|
|
|
|
#ifdef DEBUG
|
|
bool CodeAgingHelper::IsOld(byte* candidate) const {
|
|
return Memory::uint32_at(candidate) == kCodeAgePatchFirstInstruction;
|
|
}
|
|
#endif
|
|
|
|
|
|
bool Code::IsYoungSequence(Isolate* isolate, byte* sequence) {
|
|
bool result = isolate->code_aging_helper()->IsYoung(sequence);
|
|
DCHECK(result || isolate->code_aging_helper()->IsOld(sequence));
|
|
return result;
|
|
}
|
|
|
|
|
|
void Code::GetCodeAgeAndParity(Isolate* isolate, byte* sequence, Age* age,
|
|
MarkingParity* parity) {
|
|
if (IsYoungSequence(isolate, sequence)) {
|
|
*age = kNoAgeCodeAge;
|
|
*parity = NO_MARKING_PARITY;
|
|
} else {
|
|
Address target_address = Memory::Address_at(
|
|
sequence + (kNoCodeAgeSequenceLength - Assembler::kInstrSize));
|
|
Code* stub = GetCodeFromTargetAddress(target_address);
|
|
GetCodeAgeAndParity(stub, age, parity);
|
|
}
|
|
}
|
|
|
|
|
|
void Code::PatchPlatformCodeAge(Isolate* isolate,
|
|
byte* sequence,
|
|
Code::Age age,
|
|
MarkingParity parity) {
|
|
uint32_t young_length = isolate->code_aging_helper()->young_sequence_length();
|
|
if (age == kNoAgeCodeAge) {
|
|
isolate->code_aging_helper()->CopyYoungSequenceTo(sequence);
|
|
CpuFeatures::FlushICache(sequence, young_length);
|
|
} else {
|
|
Code* stub = GetCodeAgeStub(isolate, age, parity);
|
|
CodePatcher patcher(sequence, young_length / Assembler::kInstrSize);
|
|
patcher.masm()->add(r0, pc, Operand(-8));
|
|
patcher.masm()->ldr(pc, MemOperand(pc, -4));
|
|
patcher.masm()->emit_code_stub_address(stub);
|
|
}
|
|
}
|
|
|
|
|
|
} } // namespace v8::internal
|
|
|
|
#endif // V8_TARGET_ARCH_ARM
|