1 // Copyright 2011 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 "src/v8.h"
31
32 #include "src/code-stubs.h"
33 #include "src/factory.h"
34 #include "src/macro-assembler.h"
35 #include "src/objects.h"
36 #include "test/cctest/cctest.h"
37
38 #ifdef USE_SIMULATOR
39 #include "src/simulator.h"
40 #endif
41
42 using namespace v8::internal;
43
44
45 typedef uint32_t (*HASH_FUNCTION)();
46
47 #define __ masm->
48
49
generate(MacroAssembler * masm,uint32_t key)50 void generate(MacroAssembler* masm, uint32_t key) {
51 #if V8_TARGET_ARCH_IA32 || V8_TARGET_ARCH_X87
52 __ push(ebx);
53 __ mov(eax, Immediate(key));
54 __ GetNumberHash(eax, ebx);
55 __ pop(ebx);
56 __ Ret();
57 #elif V8_TARGET_ARCH_X64
58 __ pushq(kRootRegister);
59 __ InitializeRootRegister();
60 __ pushq(rbx);
61 __ movp(rax, Immediate(key));
62 __ GetNumberHash(rax, rbx);
63 __ popq(rbx);
64 __ popq(kRootRegister);
65 __ Ret();
66 #elif V8_TARGET_ARCH_ARM
67 __ push(kRootRegister);
68 __ InitializeRootRegister();
69 __ mov(r0, Operand(key));
70 __ GetNumberHash(r0, ip);
71 __ pop(kRootRegister);
72 __ mov(pc, Operand(lr));
73 #elif V8_TARGET_ARCH_ARM64
74 // The ARM64 assembler usually uses jssp (x28) as a stack pointer, but only
75 // csp is initialized by the calling (C++) code.
76 Register old_stack_pointer = __ StackPointer();
77 __ SetStackPointer(csp);
78 __ Push(root, xzr);
79 __ InitializeRootRegister();
80 __ Mov(x0, key);
81 __ GetNumberHash(x0, x10);
82 __ Pop(xzr, root);
83 __ Ret();
84 __ SetStackPointer(old_stack_pointer);
85 #elif V8_TARGET_ARCH_MIPS || V8_TARGET_ARCH_MIPS64
86 __ push(kRootRegister);
87 __ InitializeRootRegister();
88 __ li(v0, Operand(key));
89 __ GetNumberHash(v0, t1);
90 __ pop(kRootRegister);
91 __ jr(ra);
92 __ nop();
93 #elif V8_TARGET_ARCH_S390
94 __ push(kRootRegister);
95 __ push(ip);
96 __ InitializeRootRegister();
97 __ lhi(r2, Operand(key));
98 __ GetNumberHash(r2, ip);
99 __ pop(ip);
100 __ pop(kRootRegister);
101 __ Ret();
102 #elif V8_TARGET_ARCH_PPC
103 __ function_descriptor();
104 __ push(kRootRegister);
105 __ InitializeRootRegister();
106 __ li(r3, Operand(key));
107 __ GetNumberHash(r3, ip);
108 __ pop(kRootRegister);
109 __ blr();
110 #else
111 #error Unsupported architecture.
112 #endif
113 }
114
115
check(uint32_t key)116 void check(uint32_t key) {
117 Isolate* isolate = CcTest::i_isolate();
118 Factory* factory = isolate->factory();
119 HandleScope scope(isolate);
120
121 v8::internal::byte buffer[2048];
122 MacroAssembler masm(CcTest::i_isolate(), buffer, sizeof(buffer),
123 v8::internal::CodeObjectRequired::kYes);
124
125 generate(&masm, key);
126
127 CodeDesc desc;
128 masm.GetCode(&desc);
129 Handle<Object> undefined(isolate->heap()->undefined_value(), isolate);
130 Handle<Code> code = factory->NewCode(desc,
131 Code::ComputeFlags(Code::STUB),
132 undefined);
133 CHECK(code->IsCode());
134
135 HASH_FUNCTION hash = FUNCTION_CAST<HASH_FUNCTION>(code->entry());
136 #ifdef USE_SIMULATOR
137 uint32_t codegen_hash = static_cast<uint32_t>(reinterpret_cast<uintptr_t>(
138 CALL_GENERATED_CODE(isolate, hash, 0, 0, 0, 0, 0)));
139 #else
140 uint32_t codegen_hash = hash();
141 #endif
142
143 uint32_t runtime_hash = ComputeIntegerHash(key, isolate->heap()->HashSeed());
144 CHECK_EQ(runtime_hash, codegen_hash);
145 }
146
147
PseudoRandom(uint32_t i,uint32_t j)148 static uint32_t PseudoRandom(uint32_t i, uint32_t j) {
149 return ~(~((i * 781) ^ (j * 329)));
150 }
151
152
TEST(NumberHash)153 TEST(NumberHash) {
154 v8::Isolate* isolate = CcTest::isolate();
155 v8::HandleScope handle_scope(isolate);
156 v8::Context::Scope context_scope(v8::Context::New(isolate));
157
158 // Some specific numbers
159 for (uint32_t key = 0; key < 42; key += 7) {
160 check(key);
161 }
162
163 // Some pseudo-random numbers
164 static const uint32_t kLimit = 1000;
165 for (uint32_t i = 0; i < 5; i++) {
166 for (uint32_t j = 0; j < 5; j++) {
167 check(PseudoRandom(i, j) % kLimit);
168 }
169 }
170 }
171
172 #undef __
173