2014-02-17 15:09:46 +00:00
|
|
|
// Copyright 2013 the V8 project authors. All rights reserved.
|
|
|
|
// Rrdistribution and use in source and binary forms, with or without
|
|
|
|
// modification, are permitted provided that the following conditions are
|
|
|
|
// met:
|
|
|
|
//
|
|
|
|
// * Rrdistributions of source code must retain the above copyright
|
|
|
|
// notice, this list of conditions and the following disclaimer.
|
|
|
|
// * Rrdistributions in binary form must reproduce the above
|
|
|
|
// copyright notice, this list of conditions and the following
|
|
|
|
// disclaimer in the documentation and/or other materials provided
|
|
|
|
// with the distribution.
|
|
|
|
// * Neither the name of Google Inc. nor the names of its
|
|
|
|
// contributors may be used to endorse or promote products derived
|
|
|
|
// from this software without specific prior written permission.
|
|
|
|
//
|
|
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
|
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
|
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
|
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
|
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
|
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
|
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
|
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
|
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
|
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
|
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
|
|
|
|
#include <stdlib.h>
|
|
|
|
|
2014-06-03 08:12:43 +00:00
|
|
|
#include "src/v8.h"
|
2014-02-17 15:09:46 +00:00
|
|
|
|
2017-03-15 11:38:48 +00:00
|
|
|
#include "src/arm64/macro-assembler-arm64-inl.h"
|
2014-06-30 13:25:46 +00:00
|
|
|
#include "src/base/platform/platform.h"
|
2014-06-03 08:12:43 +00:00
|
|
|
#include "src/code-stubs.h"
|
|
|
|
#include "src/factory.h"
|
|
|
|
#include "src/macro-assembler.h"
|
|
|
|
#include "src/simulator.h"
|
|
|
|
#include "test/cctest/cctest.h"
|
|
|
|
#include "test/cctest/test-code-stubs.h"
|
2014-02-17 15:09:46 +00:00
|
|
|
|
|
|
|
using namespace v8::internal;
|
|
|
|
|
|
|
|
#define __ masm.
|
|
|
|
|
|
|
|
ConvertDToIFunc MakeConvertDToIFuncTrampoline(Isolate* isolate,
|
|
|
|
Register source_reg,
|
|
|
|
Register destination_reg,
|
|
|
|
bool inline_fastpath) {
|
|
|
|
// Allocate an executable page of memory.
|
2014-05-09 12:51:52 +00:00
|
|
|
size_t actual_size = 4 * Assembler::kMinimalBufferSize;
|
2014-06-30 13:25:46 +00:00
|
|
|
byte* buffer = static_cast<byte*>(
|
|
|
|
v8::base::OS::Allocate(actual_size, &actual_size, true));
|
2014-02-17 15:09:46 +00:00
|
|
|
CHECK(buffer);
|
|
|
|
HandleScope handles(isolate);
|
2015-11-25 14:23:37 +00:00
|
|
|
MacroAssembler masm(isolate, buffer, static_cast<int>(actual_size),
|
|
|
|
v8::internal::CodeObjectRequired::kYes);
|
2014-04-24 06:25:42 +00:00
|
|
|
DoubleToIStub stub(isolate, source_reg, destination_reg, 0, true,
|
|
|
|
inline_fastpath);
|
2014-02-17 15:09:46 +00:00
|
|
|
|
2014-04-24 12:07:40 +00:00
|
|
|
byte* start = stub.GetCode()->instruction_start();
|
2014-02-17 15:09:46 +00:00
|
|
|
Label done;
|
|
|
|
|
|
|
|
__ SetStackPointer(csp);
|
|
|
|
__ PushCalleeSavedRegisters();
|
|
|
|
__ Mov(jssp, csp);
|
|
|
|
__ SetStackPointer(jssp);
|
|
|
|
|
|
|
|
// Push the double argument.
|
|
|
|
__ Push(d0);
|
2014-02-19 09:43:45 +00:00
|
|
|
__ Mov(source_reg, jssp);
|
|
|
|
|
|
|
|
MacroAssembler::PushPopQueue queue(&masm);
|
2014-02-17 15:09:46 +00:00
|
|
|
|
|
|
|
// Save registers make sure they don't get clobbered.
|
|
|
|
int source_reg_offset = kDoubleSize;
|
|
|
|
int reg_num = 0;
|
2015-10-02 16:55:12 +00:00
|
|
|
for (; reg_num < Register::kNumRegisters; ++reg_num) {
|
2016-06-27 15:29:51 +00:00
|
|
|
if (RegisterConfiguration::Crankshaft()->IsAllocatableGeneralCode(
|
|
|
|
reg_num)) {
|
|
|
|
Register reg = Register::from_code(reg_num);
|
2015-10-02 16:55:12 +00:00
|
|
|
if (!reg.is(destination_reg)) {
|
|
|
|
queue.Queue(reg);
|
|
|
|
source_reg_offset += kPointerSize;
|
|
|
|
}
|
2014-02-17 15:09:46 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
// Re-push the double argument.
|
2014-02-19 09:43:45 +00:00
|
|
|
queue.Queue(d0);
|
|
|
|
|
|
|
|
queue.PushQueued();
|
2014-02-17 15:09:46 +00:00
|
|
|
|
|
|
|
// Call through to the actual stub
|
|
|
|
if (inline_fastpath) {
|
|
|
|
__ Ldr(d0, MemOperand(source_reg));
|
2014-02-21 11:36:04 +00:00
|
|
|
__ TryConvertDoubleToInt64(destination_reg, d0, &done);
|
2014-02-17 15:09:46 +00:00
|
|
|
if (destination_reg.is(source_reg)) {
|
|
|
|
// Restore clobbered source_reg.
|
|
|
|
__ add(source_reg, jssp, Operand(source_reg_offset));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
__ Call(start, RelocInfo::EXTERNAL_REFERENCE);
|
|
|
|
__ bind(&done);
|
|
|
|
|
|
|
|
__ Drop(1, kDoubleSize);
|
|
|
|
|
|
|
|
// // Make sure no registers have been unexpectedly clobbered
|
|
|
|
for (--reg_num; reg_num >= 0; --reg_num) {
|
2016-06-27 15:29:51 +00:00
|
|
|
if (RegisterConfiguration::Crankshaft()->IsAllocatableGeneralCode(
|
|
|
|
reg_num)) {
|
|
|
|
Register reg = Register::from_code(reg_num);
|
2015-10-02 16:55:12 +00:00
|
|
|
if (!reg.is(destination_reg)) {
|
|
|
|
__ Pop(ip0);
|
|
|
|
__ cmp(reg, ip0);
|
|
|
|
__ Assert(eq, kRegisterWasClobbered);
|
|
|
|
}
|
2014-02-17 15:09:46 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
__ Drop(1, kDoubleSize);
|
|
|
|
|
|
|
|
if (!destination_reg.is(x0))
|
|
|
|
__ Mov(x0, destination_reg);
|
|
|
|
|
|
|
|
// Restore callee save registers.
|
|
|
|
__ Mov(csp, jssp);
|
|
|
|
__ SetStackPointer(csp);
|
|
|
|
__ PopCalleeSavedRegisters();
|
|
|
|
|
|
|
|
__ Ret();
|
|
|
|
|
|
|
|
CodeDesc desc;
|
2017-05-31 14:00:11 +00:00
|
|
|
masm.GetCode(isolate, &desc);
|
2015-09-11 12:59:30 +00:00
|
|
|
Assembler::FlushICache(isolate, buffer, actual_size);
|
2014-02-17 15:09:46 +00:00
|
|
|
return (reinterpret_cast<ConvertDToIFunc>(
|
|
|
|
reinterpret_cast<intptr_t>(buffer)));
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef __
|
|
|
|
|
|
|
|
|
|
|
|
static Isolate* GetIsolateFrom(LocalContext* context) {
|
|
|
|
return reinterpret_cast<Isolate*>((*context)->GetIsolate());
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int32_t RunGeneratedCodeCallWrapper(ConvertDToIFunc func,
|
|
|
|
double from) {
|
|
|
|
#ifdef USE_SIMULATOR
|
2014-02-17 15:46:29 +00:00
|
|
|
Simulator::CallArgument args[] = {
|
|
|
|
Simulator::CallArgument(from),
|
|
|
|
Simulator::CallArgument::End()
|
|
|
|
};
|
2015-11-23 12:38:18 +00:00
|
|
|
return static_cast<int32_t>(Simulator::current(CcTest::i_isolate())
|
2015-05-15 05:13:15 +00:00
|
|
|
->CallInt64(FUNCTION_ADDR(func), args));
|
2014-02-17 15:09:46 +00:00
|
|
|
#else
|
|
|
|
return (*func)(from);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
TEST(ConvertDToI) {
|
|
|
|
CcTest::InitializeVM();
|
|
|
|
LocalContext context;
|
|
|
|
Isolate* isolate = GetIsolateFrom(&context);
|
|
|
|
HandleScope scope(isolate);
|
|
|
|
|
|
|
|
#if DEBUG
|
|
|
|
// Verify that the tests actually work with the C version. In the release
|
|
|
|
// code, the compiler optimizes it away because it's all constant, but does it
|
|
|
|
// wrong, triggering an assert on gcc.
|
|
|
|
RunAllTruncationTests(&ConvertDToICVersion);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
Register source_registers[] = {jssp, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9,
|
|
|
|
x10, x11, x12, x13, x14, x15, x18, x19, x20,
|
|
|
|
x21, x22, x23, x24};
|
|
|
|
Register dest_registers[] = {x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11,
|
|
|
|
x12, x13, x14, x15, x18, x19, x20, x21, x22, x23,
|
|
|
|
x24};
|
|
|
|
|
|
|
|
for (size_t s = 0; s < sizeof(source_registers) / sizeof(Register); s++) {
|
|
|
|
for (size_t d = 0; d < sizeof(dest_registers) / sizeof(Register); d++) {
|
|
|
|
RunAllTruncationTests(
|
|
|
|
RunGeneratedCodeCallWrapper,
|
|
|
|
MakeConvertDToIFuncTrampoline(isolate,
|
|
|
|
source_registers[s],
|
|
|
|
dest_registers[d],
|
|
|
|
false));
|
|
|
|
RunAllTruncationTests(
|
|
|
|
RunGeneratedCodeCallWrapper,
|
|
|
|
MakeConvertDToIFuncTrampoline(isolate,
|
|
|
|
source_registers[s],
|
|
|
|
dest_registers[d],
|
|
|
|
true));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|