// Copyright 2011 the V8 project authors. All rights reserved. // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are // met: // // * Redistributions of source code must retain the above copyright // notice, this list of conditions and the following disclaimer. // * Redistributions 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> #include "src/assembler-inl.h" #include "src/code-stubs.h" #include "src/factory.h" #include "src/macro-assembler-inl.h" #include "src/macro-assembler.h" #include "src/objects-inl.h" #include "src/v8.h" #include "test/cctest/cctest.h" #ifdef USE_SIMULATOR #include "src/simulator.h" #endif using namespace v8::internal; typedef uint32_t (*HASH_FUNCTION)(); #define __ masm-> void generate(MacroAssembler* masm, uint32_t key) { #if V8_TARGET_ARCH_IA32 || V8_TARGET_ARCH_X87 __ push(ebx); __ mov(eax, Immediate(key)); __ GetNumberHash(eax, ebx); __ pop(ebx); __ Ret(); #elif V8_TARGET_ARCH_X64 __ pushq(kRootRegister); __ InitializeRootRegister(); __ pushq(rbx); __ movp(rax, Immediate(key)); __ GetNumberHash(rax, rbx); __ popq(rbx); __ popq(kRootRegister); __ Ret(); #elif V8_TARGET_ARCH_ARM __ push(kRootRegister); __ InitializeRootRegister(); __ mov(r0, Operand(key)); __ GetNumberHash(r0, ip); __ pop(kRootRegister); __ mov(pc, Operand(lr)); #elif V8_TARGET_ARCH_ARM64 // The ARM64 assembler usually uses jssp (x28) as a stack pointer, but only // csp is initialized by the calling (C++) code. Register old_stack_pointer = __ StackPointer(); __ SetStackPointer(csp); __ Push(root, xzr); __ InitializeRootRegister(); __ Mov(x0, key); __ GetNumberHash(x0, x10); __ Pop(xzr, root); __ Ret(); __ SetStackPointer(old_stack_pointer); #elif V8_TARGET_ARCH_MIPS || V8_TARGET_ARCH_MIPS64 __ push(kRootRegister); __ InitializeRootRegister(); __ li(v0, Operand(key)); __ GetNumberHash(v0, t1); __ pop(kRootRegister); __ jr(ra); __ nop(); #elif V8_TARGET_ARCH_S390 __ push(kRootRegister); __ push(ip); __ InitializeRootRegister(); __ lhi(r2, Operand(key)); __ GetNumberHash(r2, ip); __ pop(ip); __ pop(kRootRegister); __ Ret(); #elif V8_TARGET_ARCH_PPC __ function_descriptor(); __ push(kRootRegister); __ InitializeRootRegister(); __ li(r3, Operand(key)); __ GetNumberHash(r3, ip); __ pop(kRootRegister); __ blr(); #else #error Unsupported architecture. #endif } void check(uint32_t key) { Isolate* isolate = CcTest::i_isolate(); Factory* factory = isolate->factory(); HandleScope scope(isolate); v8::internal::byte buffer[2048]; MacroAssembler masm(CcTest::i_isolate(), buffer, sizeof(buffer), v8::internal::CodeObjectRequired::kYes); generate(&masm, key); CodeDesc desc; masm.GetCode(&desc); Handle<Object> undefined(isolate->heap()->undefined_value(), isolate); Handle<Code> code = factory->NewCode(desc, Code::ComputeFlags(Code::STUB), undefined); CHECK(code->IsCode()); HASH_FUNCTION hash = FUNCTION_CAST<HASH_FUNCTION>(code->entry()); #ifdef USE_SIMULATOR uint32_t codegen_hash = static_cast<uint32_t>(reinterpret_cast<uintptr_t>( CALL_GENERATED_CODE(isolate, hash, 0, 0, 0, 0, 0))); #else uint32_t codegen_hash = hash(); #endif uint32_t runtime_hash = ComputeIntegerHash(key, isolate->heap()->HashSeed()); CHECK_EQ(runtime_hash, codegen_hash); } static uint32_t PseudoRandom(uint32_t i, uint32_t j) { return ~(~((i * 781) ^ (j * 329))); } TEST(NumberHash) { v8::Isolate* isolate = CcTest::isolate(); v8::HandleScope handle_scope(isolate); v8::Context::Scope context_scope(v8::Context::New(isolate)); // Some specific numbers for (uint32_t key = 0; key < 42; key += 7) { check(key); } // Some pseudo-random numbers static const uint32_t kLimit = 1000; for (uint32_t i = 0; i < 5; i++) { for (uint32_t j = 0; j < 5; j++) { check(PseudoRandom(i, j) % kLimit); } } } #undef __