1 // Copyright 2013 the V8 project authors. All rights reserved. 2 // Rrdistribution and use in source and binary forms, with or without 3 // modification, are permitted provided that the following conditions are 4 // met: 5 // 6 // * Rrdistributions of source code must retain the above copyright 7 // notice, this list of conditions and the following disclaimer. 8 // * Rrdistributions in binary form must reproduce the above 9 // copyright notice, this list of conditions and the following 10 // disclaimer in the documentation and/or other materials provided 11 // with the distribution. 12 // * Neither the name of Google Inc. nor the names of its 13 // contributors may be used to endorse or promote products derived 14 // from this software without specific prior written permission. 15 // 16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 28 #include <stdlib.h> 29 30 #include "src/v8.h" 31 32 #include "src/code-stubs.h" 33 #include "src/factory.h" 34 #include "src/macro-assembler.h" 35 #include "src/platform.h" 36 #include "src/simulator.h" 37 #include "test/cctest/cctest.h" 38 #include "test/cctest/test-code-stubs.h" 39 40 using namespace v8::internal; 41 42 #define __ masm. 43 44 ConvertDToIFunc MakeConvertDToIFuncTrampoline(Isolate* isolate, 45 Register source_reg, 46 Register destination_reg, 47 bool inline_fastpath) { 48 // Allocate an executable page of memory. 49 size_t actual_size; 50 byte* buffer = static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize, 51 &actual_size, 52 true)); 53 CHECK(buffer); 54 HandleScope handles(isolate); 55 MacroAssembler masm(isolate, buffer, static_cast<int>(actual_size)); 56 DoubleToIStub stub(isolate, source_reg, destination_reg, 0, true, 57 inline_fastpath); 58 59 byte* start = stub.GetCode()->instruction_start(); 60 Label done; 61 62 // Save callee save registers. 63 __ Push(r7, r6, r5, r4); 64 __ Push(lr); 65 66 // For softfp, move the input value into d0. 67 if (!masm.use_eabi_hardfloat()) { 68 __ vmov(d0, r0, r1); 69 } 70 // Push the double argument. 71 __ sub(sp, sp, Operand(kDoubleSize)); 72 __ vstr(d0, sp, 0); 73 if (!source_reg.is(sp)) { 74 __ mov(source_reg, sp); 75 } 76 77 // Save registers make sure they don't get clobbered. 78 int source_reg_offset = kDoubleSize; 79 int reg_num = 0; 80 for (;reg_num < Register::NumAllocatableRegisters(); ++reg_num) { 81 Register reg = Register::from_code(reg_num); 82 if (!reg.is(destination_reg)) { 83 __ push(reg); 84 source_reg_offset += kPointerSize; 85 } 86 } 87 88 // Re-push the double argument. 89 __ sub(sp, sp, Operand(kDoubleSize)); 90 __ vstr(d0, sp, 0); 91 92 // Call through to the actual stub 93 if (inline_fastpath) { 94 __ vldr(d0, MemOperand(source_reg)); 95 __ TryInlineTruncateDoubleToI(destination_reg, d0, &done); 96 if (destination_reg.is(source_reg) && !source_reg.is(sp)) { 97 // Restore clobbered source_reg. 98 __ add(source_reg, sp, Operand(source_reg_offset)); 99 } 100 } 101 __ Call(start, RelocInfo::EXTERNAL_REFERENCE); 102 __ bind(&done); 103 104 __ add(sp, sp, Operand(kDoubleSize)); 105 106 // Make sure no registers have been unexpectedly clobbered 107 for (--reg_num; reg_num >= 0; --reg_num) { 108 Register reg = Register::from_code(reg_num); 109 if (!reg.is(destination_reg)) { 110 __ ldr(ip, MemOperand(sp, 0)); 111 __ cmp(reg, ip); 112 __ Assert(eq, kRegisterWasClobbered); 113 __ add(sp, sp, Operand(kPointerSize)); 114 } 115 } 116 117 __ add(sp, sp, Operand(kDoubleSize)); 118 119 if (!destination_reg.is(r0)) 120 __ mov(r0, destination_reg); 121 122 // Restore callee save registers. 123 __ Pop(lr); 124 __ Pop(r7, r6, r5, r4); 125 126 __ Ret(0); 127 128 CodeDesc desc; 129 masm.GetCode(&desc); 130 CPU::FlushICache(buffer, actual_size); 131 return (reinterpret_cast<ConvertDToIFunc>( 132 reinterpret_cast<intptr_t>(buffer))); 133 } 134 135 #undef __ 136 137 138 static Isolate* GetIsolateFrom(LocalContext* context) { 139 return reinterpret_cast<Isolate*>((*context)->GetIsolate()); 140 } 141 142 143 int32_t RunGeneratedCodeCallWrapper(ConvertDToIFunc func, 144 double from) { 145 #ifdef USE_SIMULATOR 146 return CALL_GENERATED_FP_INT(func, from, 0); 147 #else 148 return (*func)(from); 149 #endif 150 } 151 152 153 TEST(ConvertDToI) { 154 CcTest::InitializeVM(); 155 LocalContext context; 156 Isolate* isolate = GetIsolateFrom(&context); 157 HandleScope scope(isolate); 158 159 #if DEBUG 160 // Verify that the tests actually work with the C version. In the release 161 // code, the compiler optimizes it away because it's all constant, but does it 162 // wrong, triggering an assert on gcc. 163 RunAllTruncationTests(&ConvertDToICVersion); 164 #endif 165 166 Register source_registers[] = {sp, r0, r1, r2, r3, r4, r5, r6, r7}; 167 Register dest_registers[] = {r0, r1, r2, r3, r4, r5, r6, r7}; 168 169 for (size_t s = 0; s < sizeof(source_registers) / sizeof(Register); s++) { 170 for (size_t d = 0; d < sizeof(dest_registers) / sizeof(Register); d++) { 171 RunAllTruncationTests( 172 RunGeneratedCodeCallWrapper, 173 MakeConvertDToIFuncTrampoline(isolate, 174 source_registers[s], 175 dest_registers[d], 176 false)); 177 RunAllTruncationTests( 178 RunGeneratedCodeCallWrapper, 179 MakeConvertDToIFuncTrampoline(isolate, 180 source_registers[s], 181 dest_registers[d], 182 true)); 183 } 184 } 185 } 186