Home | History | Annotate | Download | only in cctest 
      1 // Copyright 2013 the V8 project authors. All rights reserved.
      2 // Redistribution and use in source and binary forms, with or without
      3 // modification, are permitted provided that the following conditions are
      4 // met:
      5 //
      6 //     * Redistributions of source code must retain the above copyright
      7 //       notice, this list of conditions and the following disclaimer.
      8 //     * Redistributions 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 <limits>
     31 
     32 #include "src/v8.h"
     33 
     34 #include "src/base/platform/platform.h"
     35 #include "src/code-stubs.h"
     36 #include "src/factory.h"
     37 #include "src/macro-assembler.h"
     38 #include "test/cctest/cctest.h"
     39 #include "test/cctest/test-code-stubs.h"
     40 
     41 using namespace v8::internal;
     42 
     43 #define __ assm.
     44 
     45 ConvertDToIFunc MakeConvertDToIFuncTrampoline(Isolate* isolate,
     46                                               Register source_reg,
     47                                               Register destination_reg) {
     48   // Allocate an executable page of memory.
     49   size_t actual_size;
     50   byte* buffer = static_cast<byte*>(v8::base::OS::Allocate(
     51       Assembler::kMinimalBufferSize, &actual_size, true));
     52   CHECK(buffer);
     53   HandleScope handles(isolate);
     54   MacroAssembler assm(isolate, buffer, static_cast<int>(actual_size));
     55   int offset =
     56     source_reg.is(esp) ? 0 : (HeapNumber::kValueOffset - kSmiTagSize);
     57   DoubleToIStub stub(isolate, source_reg, destination_reg, offset, true);
     58   byte* start = stub.GetCode()->instruction_start();
     59 
     60   __ push(ebx);
     61   __ push(ecx);
     62   __ push(edx);
     63   __ push(esi);
     64   __ push(edi);
     65 
     66   if (!source_reg.is(esp)) {
     67     __ lea(source_reg, MemOperand(esp, 6 * kPointerSize - offset));
     68   }
     69 
     70   int param_offset = 7 * kPointerSize;
     71   // Save registers make sure they don't get clobbered.
     72   int reg_num = 0;
     73   for (;reg_num < Register::NumAllocatableRegisters(); ++reg_num) {
     74     Register reg = Register::FromAllocationIndex(reg_num);
     75     if (!reg.is(esp) && !reg.is(ebp) && !reg.is(destination_reg)) {
     76       __ push(reg);
     77       param_offset += kPointerSize;
     78     }
     79   }
     80 
     81   // Re-push the double argument
     82   __ push(MemOperand(esp, param_offset));
     83   __ push(MemOperand(esp, param_offset));
     84 
     85   // Call through to the actual stub
     86   __ call(start, RelocInfo::EXTERNAL_REFERENCE);
     87 
     88   __ add(esp, Immediate(kDoubleSize));
     89 
     90   // Make sure no registers have been unexpectedly clobbered
     91   for (--reg_num; reg_num >= 0; --reg_num) {
     92     Register reg = Register::FromAllocationIndex(reg_num);
     93     if (!reg.is(esp) && !reg.is(ebp) && !reg.is(destination_reg)) {
     94       __ cmp(reg, MemOperand(esp, 0));
     95       __ Assert(equal, kRegisterWasClobbered);
     96       __ add(esp, Immediate(kPointerSize));
     97     }
     98   }
     99 
    100   __ mov(eax, destination_reg);
    101 
    102   __ pop(edi);
    103   __ pop(esi);
    104   __ pop(edx);
    105   __ pop(ecx);
    106   __ pop(ebx);
    107 
    108   __ ret(kDoubleSize);
    109 
    110   CodeDesc desc;
    111   assm.GetCode(&desc);
    112   return reinterpret_cast<ConvertDToIFunc>(
    113       reinterpret_cast<intptr_t>(buffer));
    114 }
    115 
    116 #undef __
    117 
    118 
    119 static Isolate* GetIsolateFrom(LocalContext* context) {
    120   return reinterpret_cast<Isolate*>((*context)->GetIsolate());
    121 }
    122 
    123 
    124 TEST(ConvertDToI) {
    125   CcTest::InitializeVM();
    126   LocalContext context;
    127   Isolate* isolate = GetIsolateFrom(&context);
    128   HandleScope scope(isolate);
    129 
    130 #if DEBUG
    131   // Verify that the tests actually work with the C version. In the release
    132   // code, the compiler optimizes it away because it's all constant, but does it
    133   // wrong, triggering an assert on gcc.
    134   RunAllTruncationTests(&ConvertDToICVersion);
    135 #endif
    136 
    137   Register source_registers[] = {esp, eax, ebx, ecx, edx, edi, esi};
    138   Register dest_registers[] = {eax, ebx, ecx, edx, edi, esi};
    139 
    140   for (size_t s = 0; s < sizeof(source_registers) / sizeof(Register); s++) {
    141     for (size_t d = 0; d < sizeof(dest_registers) / sizeof(Register); d++) {
    142       RunAllTruncationTests(
    143           MakeConvertDToIFuncTrampoline(isolate,
    144                                         source_registers[s],
    145                                         dest_registers[d]));
    146     }
    147   }
    148 }
    149