Upgrade V8 to version 4.9.385.28
https://chromium.googlesource.com/v8/v8/+/4.9.385.28
FPIIM-449
Change-Id: I4b2e74289d4bf3667f2f3dc8aa2e541f63e26eb4
diff --git a/src/ppc/codegen-ppc.cc b/src/ppc/codegen-ppc.cc
index 1074e87..2bf8b4e 100644
--- a/src/ppc/codegen-ppc.cc
+++ b/src/ppc/codegen-ppc.cc
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "src/v8.h"
+#include "src/ppc/codegen-ppc.h"
#if V8_TARGET_ARCH_PPC
@@ -18,23 +18,23 @@
#if defined(USE_SIMULATOR)
-byte* fast_exp_ppc_machine_code = NULL;
-double fast_exp_simulator(double x) {
- return Simulator::current(Isolate::Current())
+byte* fast_exp_ppc_machine_code = nullptr;
+double fast_exp_simulator(double x, Isolate* isolate) {
+ return Simulator::current(isolate)
->CallFPReturnsDouble(fast_exp_ppc_machine_code, x, 0);
}
#endif
-UnaryMathFunction CreateExpFunction() {
- if (!FLAG_fast_math) return &std::exp;
+UnaryMathFunctionWithIsolate CreateExpFunction(Isolate* isolate) {
size_t actual_size;
byte* buffer =
static_cast<byte*>(base::OS::Allocate(1 * KB, &actual_size, true));
- if (buffer == NULL) return &std::exp;
+ if (buffer == nullptr) return nullptr;
ExternalReference::InitializeMathExpData();
- MacroAssembler masm(NULL, buffer, static_cast<int>(actual_size));
+ MacroAssembler masm(isolate, buffer, static_cast<int>(actual_size),
+ CodeObjectRequired::kNo);
{
DoubleRegister input = d1;
@@ -46,9 +46,7 @@
Register temp3 = r9;
// Called from C
-#if ABI_USES_FUNCTION_DESCRIPTORS
__ function_descriptor();
-#endif
__ Push(temp3, temp2, temp1);
MathExpGenerator::EmitMathExp(&masm, input, result, double_scratch1,
@@ -64,11 +62,11 @@
DCHECK(!RelocInfo::RequiresRelocation(desc));
#endif
- CpuFeatures::FlushICache(buffer, actual_size);
+ Assembler::FlushICache(isolate, buffer, actual_size);
base::OS::ProtectCode(buffer, actual_size);
#if !defined(USE_SIMULATOR)
- return FUNCTION_CAST<UnaryMathFunction>(buffer);
+ return FUNCTION_CAST<UnaryMathFunctionWithIsolate>(buffer);
#else
fast_exp_ppc_machine_code = buffer;
return &fast_exp_simulator;
@@ -76,21 +74,20 @@
}
-UnaryMathFunction CreateSqrtFunction() {
+UnaryMathFunctionWithIsolate CreateSqrtFunction(Isolate* isolate) {
#if defined(USE_SIMULATOR)
- return &std::sqrt;
+ return nullptr;
#else
size_t actual_size;
byte* buffer =
static_cast<byte*>(base::OS::Allocate(1 * KB, &actual_size, true));
- if (buffer == NULL) return &std::sqrt;
+ if (buffer == nullptr) return nullptr;
- MacroAssembler masm(NULL, buffer, static_cast<int>(actual_size));
+ MacroAssembler masm(isolate, buffer, static_cast<int>(actual_size),
+ CodeObjectRequired::kNo);
// Called from C
-#if ABI_USES_FUNCTION_DESCRIPTORS
__ function_descriptor();
-#endif
__ MovFromFloatParameter(d1);
__ fsqrt(d1, d1);
@@ -103,9 +100,9 @@
DCHECK(!RelocInfo::RequiresRelocation(desc));
#endif
- CpuFeatures::FlushICache(buffer, actual_size);
+ Assembler::FlushICache(isolate, buffer, actual_size);
base::OS::ProtectCode(buffer, actual_size);
- return FUNCTION_CAST<UnaryMathFunction>(buffer);
+ return FUNCTION_CAST<UnaryMathFunctionWithIsolate>(buffer);
#endif
}
@@ -159,7 +156,7 @@
MacroAssembler* masm, Register receiver, Register key, Register value,
Register target_map, AllocationSiteMode mode, Label* fail) {
// lr contains the return address
- Label loop, entry, convert_hole, gc_required, only_change_map, done;
+ Label loop, entry, convert_hole, only_change_map, done;
Register elements = r7;
Register length = r8;
Register array = r9;
@@ -167,7 +164,9 @@
// target_map parameter can be clobbered.
Register scratch1 = target_map;
- Register scratch2 = r11;
+ Register scratch2 = r10;
+ Register scratch3 = r11;
+ Register scratch4 = r14;
// Verify input registers don't conflict with locals.
DCHECK(!AreAliased(receiver, key, value, target_map, elements, length, array,
@@ -183,17 +182,15 @@
__ CompareRoot(elements, Heap::kEmptyFixedArrayRootIndex);
__ beq(&only_change_map);
- // Preserve lr and use r17 as a temporary register.
- __ mflr(r0);
- __ Push(r0);
-
__ LoadP(length, FieldMemOperand(elements, FixedArray::kLengthOffset));
// length: number of elements (smi-tagged)
// Allocate new FixedDoubleArray.
- __ SmiToDoubleArrayOffset(r17, length);
- __ addi(r17, r17, Operand(FixedDoubleArray::kHeaderSize));
- __ Allocate(r17, array, r10, scratch2, &gc_required, DOUBLE_ALIGNMENT);
+ __ SmiToDoubleArrayOffset(scratch3, length);
+ __ addi(scratch3, scratch3, Operand(FixedDoubleArray::kHeaderSize));
+ __ Allocate(scratch3, array, scratch4, scratch2, fail, DOUBLE_ALIGNMENT);
+ // array: destination FixedDoubleArray, not tagged as heap object.
+ // elements: source FixedArray.
// Set destination FixedDoubleArray's length and map.
__ LoadRoot(scratch2, Heap::kFixedDoubleArrayMapRootIndex);
@@ -203,27 +200,30 @@
__ StoreP(target_map, FieldMemOperand(receiver, HeapObject::kMapOffset), r0);
__ RecordWriteField(receiver, HeapObject::kMapOffset, target_map, scratch2,
- kLRHasBeenSaved, kDontSaveFPRegs, OMIT_REMEMBERED_SET,
+ kLRHasNotBeenSaved, kDontSaveFPRegs, OMIT_REMEMBERED_SET,
OMIT_SMI_CHECK);
// Replace receiver's backing store with newly created FixedDoubleArray.
__ addi(scratch1, array, Operand(kHeapObjectTag));
__ StoreP(scratch1, FieldMemOperand(receiver, JSObject::kElementsOffset), r0);
__ RecordWriteField(receiver, JSObject::kElementsOffset, scratch1, scratch2,
- kLRHasBeenSaved, kDontSaveFPRegs, EMIT_REMEMBERED_SET,
+ kLRHasNotBeenSaved, kDontSaveFPRegs, EMIT_REMEMBERED_SET,
OMIT_SMI_CHECK);
// Prepare for conversion loop.
- __ addi(target_map, elements,
+ __ addi(scratch1, elements,
Operand(FixedArray::kHeaderSize - kHeapObjectTag));
- __ addi(r10, array, Operand(FixedDoubleArray::kHeaderSize));
- __ SmiToDoubleArrayOffset(array, length);
- __ add(array_end, r10, array);
+ __ addi(scratch2, array, Operand(FixedDoubleArray::kHeaderSize));
+ __ SmiToDoubleArrayOffset(array_end, length);
+ __ add(array_end, scratch2, array_end);
// Repurpose registers no longer in use.
#if V8_TARGET_ARCH_PPC64
Register hole_int64 = elements;
+ __ mov(hole_int64, Operand(kHoleNanInt64));
#else
Register hole_lower = elements;
Register hole_upper = length;
+ __ mov(hole_lower, Operand(kHoleNanLower32));
+ __ mov(hole_upper, Operand(kHoleNanUpper32));
#endif
// scratch1: begin of source FixedArray element fields, not tagged
// hole_lower: kHoleNanLower32 OR hol_int64
@@ -240,48 +240,38 @@
OMIT_SMI_CHECK);
__ b(&done);
- // Call into runtime if GC is required.
- __ bind(&gc_required);
- __ Pop(r0);
- __ mtlr(r0);
- __ b(fail);
-
// Convert and copy elements.
__ bind(&loop);
- __ LoadP(r11, MemOperand(scratch1));
+ __ LoadP(scratch3, MemOperand(scratch1));
__ addi(scratch1, scratch1, Operand(kPointerSize));
- // r11: current element
- __ UntagAndJumpIfNotSmi(r11, r11, &convert_hole);
+ // scratch3: current element
+ __ UntagAndJumpIfNotSmi(scratch3, scratch3, &convert_hole);
// Normal smi, convert to double and store.
- __ ConvertIntToDouble(r11, d0);
+ __ ConvertIntToDouble(scratch3, d0);
__ stfd(d0, MemOperand(scratch2, 0));
- __ addi(r10, r10, Operand(8));
-
+ __ addi(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.
- __ LoadP(r11, MemOperand(r6, -kPointerSize));
- __ CompareRoot(r11, Heap::kTheHoleValueRootIndex);
+ __ LoadP(scratch3, MemOperand(scratch1, -kPointerSize));
+ __ CompareRoot(scratch3, Heap::kTheHoleValueRootIndex);
__ Assert(eq, kObjectFoundInSmiOnlyArray);
}
#if V8_TARGET_ARCH_PPC64
- __ std(hole_int64, MemOperand(r10, 0));
+ __ std(hole_int64, MemOperand(scratch2, 0));
#else
- __ stw(hole_upper, MemOperand(r10, Register::kExponentOffset));
- __ stw(hole_lower, MemOperand(r10, Register::kMantissaOffset));
+ __ stw(hole_upper, MemOperand(scratch2, Register::kExponentOffset));
+ __ stw(hole_lower, MemOperand(scratch2, Register::kMantissaOffset));
#endif
- __ addi(r10, r10, Operand(8));
+ __ addi(scratch2, scratch2, Operand(8));
__ bind(&entry);
- __ cmp(r10, array_end);
+ __ cmp(scratch2, array_end);
__ blt(&loop);
- __ Pop(r0);
- __ mtlr(r0);
__ bind(&done);
}
@@ -290,11 +280,13 @@
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;
+ Label loop, convert_hole, gc_required, only_change_map;
Register elements = r7;
Register array = r9;
Register length = r8;
- Register scratch = r11;
+ Register scratch = r10;
+ Register scratch3 = r11;
+ Register hole_value = r14;
// Verify input registers don't conflict with locals.
DCHECK(!AreAliased(receiver, key, value, target_map, elements, array, length,
@@ -340,7 +332,7 @@
__ addi(src_elements, elements,
Operand(FixedDoubleArray::kHeaderSize - kHeapObjectTag));
__ SmiToPtrArrayOffset(length, length);
- __ LoadRoot(r10, Heap::kTheHoleValueRootIndex);
+ __ LoadRoot(hole_value, Heap::kTheHoleValueRootIndex);
Label initialization_loop, loop_done;
__ ShiftRightImm(r0, length, Operand(kPointerSizeLog2), SetRC);
@@ -353,7 +345,7 @@
__ addi(dst_elements, array,
Operand(FixedArray::kHeaderSize - kHeapObjectTag - kPointerSize));
__ bind(&initialization_loop);
- __ StorePU(r10, MemOperand(dst_elements, kPointerSize));
+ __ StorePU(hole_value, MemOperand(dst_elements, kPointerSize));
__ bdnz(&initialization_loop);
__ addi(dst_elements, array,
@@ -367,7 +359,7 @@
// not tagged, +4
// dst_end: end of destination FixedArray, not tagged
// array: destination FixedArray
- // r10: the-hole pointer
+ // hole_value: the-hole pointer
// heap_number_map: heap number map
__ b(&loop);
@@ -378,7 +370,7 @@
// Replace the-hole NaN with the-hole pointer.
__ bind(&convert_hole);
- __ StoreP(r10, MemOperand(dst_elements));
+ __ StoreP(hole_value, MemOperand(dst_elements));
__ addi(dst_elements, dst_elements, Operand(kPointerSize));
__ cmpl(dst_elements, dst_end);
__ bge(&loop_done);
@@ -395,7 +387,7 @@
// Non-hole double, copy value into a heap number.
Register heap_number = receiver;
Register scratch2 = value;
- __ AllocateHeapNumber(heap_number, scratch2, r11, heap_number_map,
+ __ AllocateHeapNumber(heap_number, scratch2, scratch3, heap_number_map,
&gc_required);
// heap_number: new heap number
#if V8_TARGET_ARCH_PPC64
@@ -416,14 +408,6 @@
__ addi(dst_elements, dst_elements, Operand(kPointerSize));
__ RecordWrite(array, scratch2, heap_number, kLRHasNotBeenSaved,
kDontSaveFPRegs, EMIT_REMEMBERED_SET, OMIT_SMI_CHECK);
- __ b(&entry);
-
- // Replace the-hole NaN with the-hole pointer.
- __ bind(&convert_hole);
- __ StoreP(r10, MemOperand(dst_elements));
- __ addi(dst_elements, dst_elements, Operand(kPointerSize));
-
- __ bind(&entry);
__ cmpl(dst_elements, dst_end);
__ blt(&loop);
__ bind(&loop_done);
@@ -624,15 +608,17 @@
#undef __
-CodeAgingHelper::CodeAgingHelper() {
+CodeAgingHelper::CodeAgingHelper(Isolate* isolate) {
+ USE(isolate);
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));
+ base::SmartPointer<CodePatcher> patcher(
+ new CodePatcher(isolate, young_sequence_.start(),
+ young_sequence_.length() / Assembler::kInstrSize,
+ CodePatcher::DONT_FLUSH));
PredictableCodeSizeScope scope(patcher->masm(), young_sequence_.length());
patcher->masm()->PushFixedFrame(r4);
patcher->masm()->addi(fp, sp,
@@ -663,9 +649,9 @@
*age = kNoAgeCodeAge;
*parity = NO_MARKING_PARITY;
} else {
- ConstantPoolArray* constant_pool = NULL;
- Address target_address = Assembler::target_address_at(
- sequence + kCodeAgingTargetDelta, constant_pool);
+ Code* code = NULL;
+ Address target_address =
+ Assembler::target_address_at(sequence + kCodeAgingTargetDelta, code);
Code* stub = GetCodeFromTargetAddress(target_address);
GetCodeAgeAndParity(stub, age, parity);
}
@@ -677,11 +663,12 @@
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);
+ Assembler::FlushICache(isolate, sequence, young_length);
} else {
// FIXED_SEQUENCE
Code* stub = GetCodeAgeStub(isolate, age, parity);
- CodePatcher patcher(sequence, young_length / Assembler::kInstrSize);
+ CodePatcher patcher(isolate, sequence,
+ young_length / Assembler::kInstrSize);
Assembler::BlockTrampolinePoolScope block_trampoline_pool(patcher.masm());
intptr_t target = reinterpret_cast<intptr_t>(stub->instruction_start());
// Don't use Call -- we need to preserve ip and lr.
@@ -694,7 +681,7 @@
}
}
}
-}
-} // namespace v8::internal
+} // namespace internal
+} // namespace v8
#endif // V8_TARGET_ARCH_PPC