OLD | NEW |
1 // Copyright 2011 the V8 project authors. All rights reserved. | 1 // Copyright 2011 the V8 project authors. All rights reserved. |
2 // Redistribution and use in source and binary forms, with or without | 2 // Redistribution and use in source and binary forms, with or without |
3 // modification, are permitted provided that the following conditions are | 3 // modification, are permitted provided that the following conditions are |
4 // met: | 4 // met: |
5 // | 5 // |
6 // * Redistributions of source code must retain the above copyright | 6 // * Redistributions of source code must retain the above copyright |
7 // notice, this list of conditions and the following disclaimer. | 7 // notice, this list of conditions and the following disclaimer. |
8 // * Redistributions in binary form must reproduce the above | 8 // * Redistributions in binary form must reproduce the above |
9 // copyright notice, this list of conditions and the following | 9 // copyright notice, this list of conditions and the following |
10 // disclaimer in the documentation and/or other materials provided | 10 // disclaimer in the documentation and/or other materials provided |
(...skipping 28 matching lines...) Expand all Loading... |
39 #include "simulator.h" | 39 #include "simulator.h" |
40 #endif | 40 #endif |
41 | 41 |
42 using namespace v8::internal; | 42 using namespace v8::internal; |
43 | 43 |
44 | 44 |
45 typedef uint32_t (*HASH_FUNCTION)(); | 45 typedef uint32_t (*HASH_FUNCTION)(); |
46 | 46 |
47 static v8::Persistent<v8::Context> env; | 47 static v8::Persistent<v8::Context> env; |
48 | 48 |
49 #define __ assm-> | 49 #define __ masm-> |
50 | 50 |
51 | 51 |
52 void generate(MacroAssembler* assm, i::Vector<const char> string) { | 52 void generate(MacroAssembler* masm, i::Vector<const char> string) { |
| 53 // GenerateHashInit takes the first character as an argument so it can't |
| 54 // handle the zero length string. |
| 55 ASSERT(string.length() > 0); |
53 #ifdef V8_TARGET_ARCH_IA32 | 56 #ifdef V8_TARGET_ARCH_IA32 |
54 __ push(ebx); | 57 __ push(ebx); |
55 __ push(ecx); | 58 __ push(ecx); |
56 __ mov(eax, Immediate(0)); | 59 __ mov(eax, Immediate(0)); |
57 if (string.length() > 0) { | 60 __ mov(ebx, Immediate(string.at(0))); |
58 __ mov(ebx, Immediate(string.at(0))); | 61 StringHelper::GenerateHashInit(masm, eax, ebx, ecx); |
59 StringHelper::GenerateHashInit(assm, eax, ebx, ecx); | |
60 } | |
61 for (int i = 1; i < string.length(); i++) { | 62 for (int i = 1; i < string.length(); i++) { |
62 __ mov(ebx, Immediate(string.at(i))); | 63 __ mov(ebx, Immediate(string.at(i))); |
63 StringHelper::GenerateHashAddCharacter(assm, eax, ebx, ecx); | 64 StringHelper::GenerateHashAddCharacter(masm, eax, ebx, ecx); |
64 } | 65 } |
65 StringHelper::GenerateHashGetHash(assm, eax, ecx); | 66 StringHelper::GenerateHashGetHash(masm, eax, ecx); |
66 __ pop(ecx); | 67 __ pop(ecx); |
67 __ pop(ebx); | 68 __ pop(ebx); |
68 __ Ret(); | 69 __ Ret(); |
69 #elif V8_TARGET_ARCH_X64 | 70 #elif V8_TARGET_ARCH_X64 |
| 71 __ push(kRootRegister); |
| 72 __ InitializeRootRegister(); |
70 __ push(rbx); | 73 __ push(rbx); |
71 __ push(rcx); | 74 __ push(rcx); |
72 __ movq(rax, Immediate(0)); | 75 __ movq(rax, Immediate(0)); |
73 if (string.length() > 0) { | 76 __ movq(rbx, Immediate(string.at(0))); |
74 __ movq(rbx, Immediate(string.at(0))); | 77 StringHelper::GenerateHashInit(masm, rax, rbx, rcx); |
75 StringHelper::GenerateHashInit(assm, rax, rbx, rcx); | |
76 } | |
77 for (int i = 1; i < string.length(); i++) { | 78 for (int i = 1; i < string.length(); i++) { |
78 __ movq(rbx, Immediate(string.at(i))); | 79 __ movq(rbx, Immediate(string.at(i))); |
79 StringHelper::GenerateHashAddCharacter(assm, rax, rbx, rcx); | 80 StringHelper::GenerateHashAddCharacter(masm, rax, rbx, rcx); |
80 } | 81 } |
81 StringHelper::GenerateHashGetHash(assm, rax, rcx); | 82 StringHelper::GenerateHashGetHash(masm, rax, rcx); |
82 __ pop(rcx); | 83 __ pop(rcx); |
83 __ pop(rbx); | 84 __ pop(rbx); |
| 85 __ pop(kRootRegister); |
84 __ Ret(); | 86 __ Ret(); |
85 #elif V8_TARGET_ARCH_ARM | 87 #elif V8_TARGET_ARCH_ARM |
| 88 __ push(kRootRegister); |
| 89 __ InitializeRootRegister(); |
| 90 |
86 __ mov(r0, Operand(0)); | 91 __ mov(r0, Operand(0)); |
87 if (string.length() > 0) { | 92 __ mov(ip, Operand(string.at(0))); |
88 __ mov(ip, Operand(string.at(0))); | 93 StringHelper::GenerateHashInit(masm, r0, ip); |
89 StringHelper::GenerateHashInit(assm, r0, ip); | |
90 } | |
91 for (int i = 1; i < string.length(); i++) { | 94 for (int i = 1; i < string.length(); i++) { |
92 __ mov(ip, Operand(string.at(i))); | 95 __ mov(ip, Operand(string.at(i))); |
93 StringHelper::GenerateHashAddCharacter(assm, r0, ip); | 96 StringHelper::GenerateHashAddCharacter(masm, r0, ip); |
94 } | 97 } |
95 StringHelper::GenerateHashGetHash(assm, r0); | 98 StringHelper::GenerateHashGetHash(masm, r0); |
| 99 __ pop(kRootRegister); |
96 __ mov(pc, Operand(lr)); | 100 __ mov(pc, Operand(lr)); |
97 #elif V8_TARGET_ARCH_MIPS | 101 #elif V8_TARGET_ARCH_MIPS |
| 102 __ push(kRootRegister); |
| 103 __ InitializeRootRegister(); |
| 104 |
98 __ li(v0, Operand(0)); | 105 __ li(v0, Operand(0)); |
99 if (string.length() > 0) { | 106 __ li(t1, Operand(string.at(0))); |
100 __ li(t1, Operand(string.at(0))); | 107 StringHelper::GenerateHashInit(masm, v0, t1); |
101 StringHelper::GenerateHashInit(assm, v0, t1); | |
102 } | |
103 for (int i = 1; i < string.length(); i++) { | 108 for (int i = 1; i < string.length(); i++) { |
104 __ li(t1, Operand(string.at(i))); | 109 __ li(t1, Operand(string.at(i))); |
105 StringHelper::GenerateHashAddCharacter(assm, v0, t1); | 110 StringHelper::GenerateHashAddCharacter(masm, v0, t1); |
106 } | 111 } |
107 StringHelper::GenerateHashGetHash(assm, v0); | 112 StringHelper::GenerateHashGetHash(masm, v0); |
| 113 __ pop(kRootRegister); |
| 114 __ jr(ra); |
| 115 __ nop(); |
| 116 #endif |
| 117 } |
| 118 |
| 119 |
| 120 void generate(MacroAssembler* masm, uint32_t key) { |
| 121 #ifdef V8_TARGET_ARCH_IA32 |
| 122 __ push(ebx); |
| 123 __ mov(eax, Immediate(key)); |
| 124 __ GetNumberHash(eax, ebx); |
| 125 __ pop(ebx); |
| 126 __ Ret(); |
| 127 #elif V8_TARGET_ARCH_X64 |
| 128 __ push(kRootRegister); |
| 129 __ InitializeRootRegister(); |
| 130 __ push(rbx); |
| 131 __ movq(rax, Immediate(key)); |
| 132 __ GetNumberHash(rax, rbx); |
| 133 __ pop(rbx); |
| 134 __ pop(kRootRegister); |
| 135 __ Ret(); |
| 136 #elif V8_TARGET_ARCH_ARM |
| 137 __ push(kRootRegister); |
| 138 __ InitializeRootRegister(); |
| 139 __ mov(r0, Operand(key)); |
| 140 __ GetNumberHash(r0, ip); |
| 141 __ pop(kRootRegister); |
| 142 __ mov(pc, Operand(lr)); |
| 143 #elif V8_TARGET_ARCH_MIPS |
| 144 __ push(kRootRegister); |
| 145 __ InitializeRootRegister(); |
| 146 __ li(v0, Operand(key)); |
| 147 __ GetNumberHash(v0, t1); |
| 148 __ pop(kRootRegister); |
108 __ jr(ra); | 149 __ jr(ra); |
109 __ nop(); | 150 __ nop(); |
110 #endif | 151 #endif |
111 } | 152 } |
112 | 153 |
113 | 154 |
114 void check(i::Vector<const char> string) { | 155 void check(i::Vector<const char> string) { |
115 v8::HandleScope scope; | 156 v8::HandleScope scope; |
116 v8::internal::byte buffer[2048]; | 157 v8::internal::byte buffer[2048]; |
117 MacroAssembler assm(Isolate::Current(), buffer, sizeof buffer); | 158 MacroAssembler masm(Isolate::Current(), buffer, sizeof buffer); |
118 | 159 |
119 generate(&assm, string); | 160 generate(&masm, string); |
120 | 161 |
121 CodeDesc desc; | 162 CodeDesc desc; |
122 assm.GetCode(&desc); | 163 masm.GetCode(&desc); |
123 Code* code = Code::cast(HEAP->CreateCode( | 164 Code* code = Code::cast(HEAP->CreateCode( |
124 desc, | 165 desc, |
125 Code::ComputeFlags(Code::STUB), | 166 Code::ComputeFlags(Code::STUB), |
126 Handle<Object>(HEAP->undefined_value()))->ToObjectChecked()); | 167 Handle<Object>(HEAP->undefined_value()))->ToObjectChecked()); |
127 CHECK(code->IsCode()); | 168 CHECK(code->IsCode()); |
128 | 169 |
129 HASH_FUNCTION hash = FUNCTION_CAST<HASH_FUNCTION>(code->entry()); | 170 HASH_FUNCTION hash = FUNCTION_CAST<HASH_FUNCTION>(code->entry()); |
130 Handle<String> v8_string = FACTORY->NewStringFromAscii(string); | 171 Handle<String> v8_string = FACTORY->NewStringFromAscii(string); |
131 v8_string->set_hash_field(String::kEmptyHashField); | 172 v8_string->set_hash_field(String::kEmptyHashField); |
132 #ifdef USE_SIMULATOR | 173 #ifdef USE_SIMULATOR |
133 uint32_t codegen_hash = | 174 uint32_t codegen_hash = |
134 reinterpret_cast<uint32_t>(CALL_GENERATED_CODE(hash, 0, 0, 0, 0, 0)); | 175 reinterpret_cast<uint32_t>(CALL_GENERATED_CODE(hash, 0, 0, 0, 0, 0)); |
135 #else | 176 #else |
136 uint32_t codegen_hash = hash(); | 177 uint32_t codegen_hash = hash(); |
137 #endif | 178 #endif |
138 uint32_t runtime_hash = v8_string->Hash(); | 179 uint32_t runtime_hash = v8_string->Hash(); |
139 CHECK(runtime_hash == codegen_hash); | 180 CHECK(runtime_hash == codegen_hash); |
140 } | 181 } |
141 | 182 |
142 | 183 |
| 184 void check(uint32_t key) { |
| 185 v8::HandleScope scope; |
| 186 v8::internal::byte buffer[2048]; |
| 187 MacroAssembler masm(Isolate::Current(), buffer, sizeof buffer); |
| 188 |
| 189 generate(&masm, key); |
| 190 |
| 191 CodeDesc desc; |
| 192 masm.GetCode(&desc); |
| 193 Code* code = Code::cast(HEAP->CreateCode( |
| 194 desc, |
| 195 Code::ComputeFlags(Code::STUB), |
| 196 Handle<Object>(HEAP->undefined_value()))->ToObjectChecked()); |
| 197 CHECK(code->IsCode()); |
| 198 |
| 199 HASH_FUNCTION hash = FUNCTION_CAST<HASH_FUNCTION>(code->entry()); |
| 200 #ifdef USE_SIMULATOR |
| 201 uint32_t codegen_hash = |
| 202 reinterpret_cast<uint32_t>(CALL_GENERATED_CODE(hash, 0, 0, 0, 0, 0)); |
| 203 #else |
| 204 uint32_t codegen_hash = hash(); |
| 205 #endif |
| 206 |
| 207 uint32_t runtime_hash = ComputeIntegerHash( |
| 208 key, |
| 209 Isolate::Current()->heap()->HashSeed()); |
| 210 CHECK(runtime_hash == codegen_hash); |
| 211 } |
| 212 |
| 213 |
143 void check_twochars(char a, char b) { | 214 void check_twochars(char a, char b) { |
144 char ab[2] = {a, b}; | 215 char ab[2] = {a, b}; |
145 check(i::Vector<const char>(ab, 2)); | 216 check(i::Vector<const char>(ab, 2)); |
146 } | 217 } |
147 | 218 |
148 | 219 |
| 220 static uint32_t PseudoRandom(uint32_t i, uint32_t j) { |
| 221 return ~(~((i * 781) ^ (j * 329))); |
| 222 } |
| 223 |
| 224 |
149 TEST(StringHash) { | 225 TEST(StringHash) { |
150 if (env.IsEmpty()) env = v8::Context::New(); | 226 if (env.IsEmpty()) env = v8::Context::New(); |
151 for (int a = 0; a < String::kMaxAsciiCharCode; a++) { | 227 for (int a = 0; a < String::kMaxAsciiCharCode; a++) { |
152 // Numbers are hashed differently. | 228 // Numbers are hashed differently. |
153 if (a >= '0' && a <= '9') continue; | 229 if (a >= '0' && a <= '9') continue; |
154 for (int b = 0; b < String::kMaxAsciiCharCode; b++) { | 230 for (int b = 0; b < String::kMaxAsciiCharCode; b++) { |
155 if (b >= '0' && b <= '9') continue; | 231 if (b >= '0' && b <= '9') continue; |
156 check_twochars(static_cast<char>(a), static_cast<char>(b)); | 232 check_twochars(static_cast<char>(a), static_cast<char>(b)); |
157 } | 233 } |
158 } | 234 } |
159 check(i::Vector<const char>("", 0)); | |
160 check(i::Vector<const char>("*", 1)); | 235 check(i::Vector<const char>("*", 1)); |
161 check(i::Vector<const char>(".zZ", 3)); | 236 check(i::Vector<const char>(".zZ", 3)); |
162 check(i::Vector<const char>("muc", 3)); | 237 check(i::Vector<const char>("muc", 3)); |
163 check(i::Vector<const char>("(>'_')>", 7)); | 238 check(i::Vector<const char>("(>'_')>", 7)); |
164 check(i::Vector<const char>("-=[ vee eight ftw ]=-", 21)); | 239 check(i::Vector<const char>("-=[ vee eight ftw ]=-", 21)); |
165 } | 240 } |
166 | 241 |
| 242 |
| 243 TEST(NumberHash) { |
| 244 if (env.IsEmpty()) env = v8::Context::New(); |
| 245 |
| 246 // Some specific numbers |
| 247 for (uint32_t key = 0; key < 42; key += 7) { |
| 248 check(key); |
| 249 } |
| 250 |
| 251 // Some pseudo-random numbers |
| 252 static const uint32_t kLimit = 1000; |
| 253 for (uint32_t i = 0; i < 5; i++) { |
| 254 for (uint32_t j = 0; j < 5; j++) { |
| 255 check(PseudoRandom(i, j) % kLimit); |
| 256 } |
| 257 } |
| 258 } |
| 259 |
167 #undef __ | 260 #undef __ |
OLD | NEW |