Revision f230a1cf deps/v8/src/stub-cache.cc
| deps/v8/src/stub-cache.cc | ||
|---|---|---|
| 99 | 99 |
} |
| 100 | 100 |
|
| 101 | 101 |
|
| 102 |
Handle<JSObject> StubCache::StubHolder(Handle<JSObject> receiver, |
|
| 103 |
Handle<JSObject> holder) {
|
|
| 104 |
InlineCacheHolderFlag cache_holder = |
|
| 105 |
IC::GetCodeCacheForObject(*receiver, *holder); |
|
| 106 |
return Handle<JSObject>(IC::GetCodeCacheHolder( |
|
| 107 |
isolate_, *receiver, cache_holder)); |
|
| 108 |
} |
|
| 109 |
|
|
| 110 |
|
|
| 111 | 102 |
Handle<Code> StubCache::FindIC(Handle<Name> name, |
| 112 | 103 |
Handle<Map> stub_holder_map, |
| 113 | 104 |
Code::Kind kind, |
| 114 |
Code::StubType type, |
|
| 115 | 105 |
Code::ExtraICState extra_state) {
|
| 116 |
Code::Flags flags = Code::ComputeMonomorphicFlags(kind, extra_state, type);
|
|
| 106 |
Code::Flags flags = Code::ComputeMonomorphicFlags(kind, extra_state); |
|
| 117 | 107 |
Handle<Object> probe(stub_holder_map->FindInCodeCache(*name, flags), |
| 118 | 108 |
isolate_); |
| 119 | 109 |
if (probe->IsCode()) return Handle<Code>::cast(probe); |
| ... | ... | |
| 124 | 114 |
Handle<Code> StubCache::FindIC(Handle<Name> name, |
| 125 | 115 |
Handle<JSObject> stub_holder, |
| 126 | 116 |
Code::Kind kind, |
| 127 |
Code::StubType type, |
|
| 128 | 117 |
Code::ExtraICState extra_ic_state) {
|
| 129 |
return FindIC(name, Handle<Map>(stub_holder->map()), kind, |
|
| 130 |
type, extra_ic_state); |
|
| 118 |
return FindIC(name, Handle<Map>(stub_holder->map()), kind, extra_ic_state); |
|
| 131 | 119 |
} |
| 132 | 120 |
|
| 133 | 121 |
|
| 134 |
Handle<Code> StubCache::FindLoadHandler(Handle<Name> name, |
|
| 135 |
Handle<JSObject> receiver, |
|
| 136 |
Handle<JSObject> stub_holder, |
|
| 137 |
Code::Kind kind, |
|
| 138 |
Code::StubType type) {
|
|
| 139 |
Code::ExtraICState extra_ic_state = Code::ComputeExtraICState( |
|
| 140 |
receiver.is_identical_to(stub_holder) ? Code::OWN_STUB |
|
| 141 |
: Code::PROTOTYPE_STUB); |
|
| 142 |
ASSERT(type != Code::NORMAL); |
|
| 143 |
Code::Flags flags = Code::ComputeMonomorphicFlags( |
|
| 144 |
Code::STUB, extra_ic_state, type, kind); |
|
| 145 |
Handle<Object> probe(stub_holder->map()->FindInCodeCache(*name, flags), |
|
| 146 |
isolate_); |
|
| 147 |
if (probe->IsCode()) return Handle<Code>::cast(probe); |
|
| 148 |
return Handle<Code>::null(); |
|
| 149 |
} |
|
| 150 |
|
|
| 151 |
|
|
| 152 |
Handle<Code> StubCache::FindStoreHandler(Handle<Name> name, |
|
| 153 |
Handle<JSObject> receiver, |
|
| 154 |
Code::Kind kind, |
|
| 155 |
Code::StubType type, |
|
| 156 |
StrictModeFlag strict_mode) {
|
|
| 157 |
Code::ExtraICState extra_ic_state = Code::ComputeExtraICState( |
|
| 158 |
STANDARD_STORE, strict_mode); |
|
| 159 |
ASSERT(type != Code::NORMAL); |
|
| 122 |
Handle<Code> StubCache::FindHandler(Handle<Name> name, |
|
| 123 |
Handle<JSObject> receiver, |
|
| 124 |
Code::Kind kind, |
|
| 125 |
StrictModeFlag strict_mode) {
|
|
| 126 |
Code::ExtraICState extra_ic_state = Code::kNoExtraICState; |
|
| 127 |
if (kind == Code::STORE_IC || kind == Code::KEYED_STORE_IC) {
|
|
| 128 |
extra_ic_state = Code::ComputeExtraICState( |
|
| 129 |
STANDARD_STORE, strict_mode); |
|
| 130 |
} |
|
| 160 | 131 |
Code::Flags flags = Code::ComputeMonomorphicFlags( |
| 161 |
Code::STUB, extra_ic_state, type, kind);
|
|
| 132 |
Code::HANDLER, extra_ic_state, Code::NORMAL, kind);
|
|
| 162 | 133 |
Handle<Object> probe(receiver->map()->FindInCodeCache(*name, flags), |
| 163 | 134 |
isolate_); |
| 164 | 135 |
if (probe->IsCode()) return Handle<Code>::cast(probe); |
| ... | ... | |
| 166 | 137 |
} |
| 167 | 138 |
|
| 168 | 139 |
|
| 169 |
Handle<Code> StubCache::ComputeMonomorphicLoadIC(Handle<HeapObject> receiver, |
|
| 170 |
Handle<Code> handler, |
|
| 171 |
Handle<Name> name) {
|
|
| 140 |
Handle<Code> StubCache::ComputeMonomorphicIC(Handle<HeapObject> receiver, |
|
| 141 |
Handle<Code> handler, |
|
| 142 |
Handle<Name> name, |
|
| 143 |
StrictModeFlag strict_mode) {
|
|
| 144 |
Code::Kind kind = handler->handler_kind(); |
|
| 172 | 145 |
Handle<Map> map(receiver->map()); |
| 173 |
Handle<Code> ic = FindIC(name, map, Code::LOAD_IC, handler->type());
|
|
| 146 |
Handle<Code> ic = FindIC(name, map, kind, strict_mode);
|
|
| 174 | 147 |
if (!ic.is_null()) return ic; |
| 175 | 148 |
|
| 176 |
LoadStubCompiler ic_compiler(isolate()); |
|
| 177 |
ic = ic_compiler.CompileMonomorphicIC(map, handler, name); |
|
| 178 |
|
|
| 179 |
HeapObject::UpdateMapCodeCache(receiver, name, ic); |
|
| 180 |
return ic; |
|
| 181 |
} |
|
| 182 |
|
|
| 183 |
|
|
| 184 |
Handle<Code> StubCache::ComputeMonomorphicKeyedLoadIC( |
|
| 185 |
Handle<HeapObject> receiver, |
|
| 186 |
Handle<Code> handler, |
|
| 187 |
Handle<Name> name) {
|
|
| 188 |
Handle<Map> map(receiver->map()); |
|
| 189 |
Handle<Code> ic = FindIC(name, map, Code::KEYED_LOAD_IC, handler->type()); |
|
| 190 |
if (!ic.is_null()) return ic; |
|
| 191 |
|
|
| 192 |
KeyedLoadStubCompiler ic_compiler(isolate()); |
|
| 193 |
ic = ic_compiler.CompileMonomorphicIC(map, handler, name); |
|
| 194 |
|
|
| 195 |
HeapObject::UpdateMapCodeCache(receiver, name, ic); |
|
| 196 |
return ic; |
|
| 197 |
} |
|
| 198 |
|
|
| 199 |
|
|
| 200 |
Handle<Code> StubCache::ComputeMonomorphicStoreIC(Handle<HeapObject> receiver, |
|
| 201 |
Handle<Code> handler, |
|
| 202 |
Handle<Name> name, |
|
| 203 |
StrictModeFlag strict_mode) {
|
|
| 204 |
Handle<Map> map(receiver->map()); |
|
| 205 |
Handle<Code> ic = FindIC( |
|
| 206 |
name, map, Code::STORE_IC, handler->type(), strict_mode); |
|
| 207 |
if (!ic.is_null()) return ic; |
|
| 208 |
|
|
| 209 |
StoreStubCompiler ic_compiler(isolate(), strict_mode); |
|
| 210 |
ic = ic_compiler.CompileMonomorphicIC(map, handler, name); |
|
| 211 |
|
|
| 212 |
HeapObject::UpdateMapCodeCache(receiver, name, ic); |
|
| 213 |
return ic; |
|
| 214 |
} |
|
| 215 |
|
|
| 216 |
|
|
| 217 |
Handle<Code> StubCache::ComputeMonomorphicKeyedStoreIC( |
|
| 218 |
Handle<HeapObject> receiver, |
|
| 219 |
Handle<Code> handler, |
|
| 220 |
Handle<Name> name, |
|
| 221 |
StrictModeFlag strict_mode) {
|
|
| 222 |
Handle<Map> map(receiver->map()); |
|
| 223 |
Handle<Code> ic = FindIC( |
|
| 224 |
name, map, Code::KEYED_STORE_IC, handler->type(), strict_mode); |
|
| 225 |
if (!ic.is_null()) return ic; |
|
| 226 |
|
|
| 227 |
KeyedStoreStubCompiler ic_compiler(isolate(), strict_mode, STANDARD_STORE); |
|
| 228 |
ic = ic_compiler.CompileMonomorphicIC(map, handler, name); |
|
| 149 |
if (kind == Code::LOAD_IC) {
|
|
| 150 |
LoadStubCompiler ic_compiler(isolate()); |
|
| 151 |
ic = ic_compiler.CompileMonomorphicIC(map, handler, name); |
|
| 152 |
} else if (kind == Code::KEYED_LOAD_IC) {
|
|
| 153 |
KeyedLoadStubCompiler ic_compiler(isolate()); |
|
| 154 |
ic = ic_compiler.CompileMonomorphicIC(map, handler, name); |
|
| 155 |
} else if (kind == Code::STORE_IC) {
|
|
| 156 |
StoreStubCompiler ic_compiler(isolate(), strict_mode); |
|
| 157 |
ic = ic_compiler.CompileMonomorphicIC(map, handler, name); |
|
| 158 |
} else {
|
|
| 159 |
ASSERT(kind == Code::KEYED_STORE_IC); |
|
| 160 |
KeyedStoreStubCompiler ic_compiler(isolate(), strict_mode, STANDARD_STORE); |
|
| 161 |
ic = ic_compiler.CompileMonomorphicIC(map, handler, name); |
|
| 162 |
} |
|
| 229 | 163 |
|
| 230 | 164 |
HeapObject::UpdateMapCodeCache(receiver, name, ic); |
| 231 | 165 |
return ic; |
| ... | ... | |
| 257 | 191 |
|
| 258 | 192 |
// Compile the stub that is either shared for all names or |
| 259 | 193 |
// name specific if there are global objects involved. |
| 260 |
Handle<Code> handler = FindLoadHandler( |
|
| 261 |
cache_name, receiver, receiver, Code::LOAD_IC, Code::NONEXISTENT); |
|
| 194 |
Handle<Code> handler = FindHandler(cache_name, receiver, Code::LOAD_IC); |
|
| 262 | 195 |
if (!handler.is_null()) return handler; |
| 263 | 196 |
|
| 264 | 197 |
LoadStubCompiler compiler(isolate_); |
| ... | ... | |
| 269 | 202 |
} |
| 270 | 203 |
|
| 271 | 204 |
|
| 272 |
Handle<Code> StubCache::ComputeLoadField(Handle<Name> name, |
|
| 273 |
Handle<JSObject> receiver, |
|
| 274 |
Handle<JSObject> holder, |
|
| 275 |
PropertyIndex field, |
|
| 276 |
Representation representation) {
|
|
| 277 |
if (receiver.is_identical_to(holder)) {
|
|
| 278 |
LoadFieldStub stub(field.is_inobject(holder), |
|
| 279 |
field.translate(holder), |
|
| 280 |
representation); |
|
| 281 |
return stub.GetCode(isolate()); |
|
| 282 |
} |
|
| 283 |
|
|
| 284 |
Handle<JSObject> stub_holder = StubHolder(receiver, holder); |
|
| 285 |
Handle<Code> stub = FindLoadHandler( |
|
| 286 |
name, receiver, stub_holder, Code::LOAD_IC, Code::FIELD); |
|
| 287 |
if (!stub.is_null()) return stub; |
|
| 288 |
|
|
| 289 |
LoadStubCompiler compiler(isolate_); |
|
| 290 |
Handle<Code> handler = |
|
| 291 |
compiler.CompileLoadField(receiver, holder, name, field, representation); |
|
| 292 |
HeapObject::UpdateMapCodeCache(stub_holder, name, handler); |
|
| 293 |
return handler; |
|
| 294 |
} |
|
| 295 |
|
|
| 296 |
|
|
| 297 |
Handle<Code> StubCache::ComputeLoadCallback( |
|
| 298 |
Handle<Name> name, |
|
| 299 |
Handle<JSObject> receiver, |
|
| 300 |
Handle<JSObject> holder, |
|
| 301 |
Handle<ExecutableAccessorInfo> callback) {
|
|
| 302 |
ASSERT(v8::ToCData<Address>(callback->getter()) != 0); |
|
| 303 |
Handle<JSObject> stub_holder = StubHolder(receiver, holder); |
|
| 304 |
Handle<Code> stub = FindLoadHandler( |
|
| 305 |
name, receiver, stub_holder, Code::LOAD_IC, Code::CALLBACKS); |
|
| 306 |
if (!stub.is_null()) return stub; |
|
| 307 |
|
|
| 308 |
LoadStubCompiler compiler(isolate_); |
|
| 309 |
Handle<Code> handler = |
|
| 310 |
compiler.CompileLoadCallback(receiver, holder, name, callback); |
|
| 311 |
HeapObject::UpdateMapCodeCache(stub_holder, name, handler); |
|
| 312 |
return handler; |
|
| 313 |
} |
|
| 314 |
|
|
| 315 |
|
|
| 316 |
Handle<Code> StubCache::ComputeLoadCallback( |
|
| 317 |
Handle<Name> name, |
|
| 318 |
Handle<JSObject> receiver, |
|
| 319 |
Handle<JSObject> holder, |
|
| 320 |
const CallOptimization& call_optimization) {
|
|
| 321 |
Handle<JSObject> stub_holder = StubHolder(receiver, holder); |
|
| 322 |
Handle<Code> stub = FindLoadHandler( |
|
| 323 |
name, receiver, stub_holder, Code::LOAD_IC, Code::CALLBACKS); |
|
| 324 |
if (!stub.is_null()) return stub; |
|
| 325 |
|
|
| 326 |
LoadStubCompiler compiler(isolate_); |
|
| 327 |
Handle<Code> handler = |
|
| 328 |
compiler.CompileLoadCallback(receiver, holder, name, call_optimization); |
|
| 329 |
HeapObject::UpdateMapCodeCache(stub_holder, name, handler); |
|
| 330 |
return handler; |
|
| 331 |
} |
|
| 332 |
|
|
| 333 |
|
|
| 334 |
Handle<Code> StubCache::ComputeLoadViaGetter(Handle<Name> name, |
|
| 335 |
Handle<JSObject> receiver, |
|
| 336 |
Handle<JSObject> holder, |
|
| 337 |
Handle<JSFunction> getter) {
|
|
| 338 |
Handle<JSObject> stub_holder = StubHolder(receiver, holder); |
|
| 339 |
Handle<Code> stub = FindLoadHandler( |
|
| 340 |
name, receiver, stub_holder, Code::LOAD_IC, Code::CALLBACKS); |
|
| 341 |
if (!stub.is_null()) return stub; |
|
| 342 |
|
|
| 343 |
LoadStubCompiler compiler(isolate_); |
|
| 344 |
Handle<Code> handler = |
|
| 345 |
compiler.CompileLoadViaGetter(receiver, holder, name, getter); |
|
| 346 |
HeapObject::UpdateMapCodeCache(stub_holder, name, handler); |
|
| 347 |
return handler; |
|
| 348 |
} |
|
| 349 |
|
|
| 350 |
|
|
| 351 |
Handle<Code> StubCache::ComputeLoadConstant(Handle<Name> name, |
|
| 352 |
Handle<JSObject> receiver, |
|
| 353 |
Handle<JSObject> holder, |
|
| 354 |
Handle<Object> value) {
|
|
| 355 |
Handle<JSObject> stub_holder = StubHolder(receiver, holder); |
|
| 356 |
Handle<Code> handler = FindLoadHandler( |
|
| 357 |
name, receiver, stub_holder, Code::LOAD_IC, Code::CONSTANT); |
|
| 358 |
if (!handler.is_null()) return handler; |
|
| 359 |
|
|
| 360 |
LoadStubCompiler compiler(isolate_); |
|
| 361 |
handler = compiler.CompileLoadConstant(receiver, holder, name, value); |
|
| 362 |
HeapObject::UpdateMapCodeCache(stub_holder, name, handler); |
|
| 363 |
|
|
| 364 |
return handler; |
|
| 365 |
} |
|
| 366 |
|
|
| 367 |
|
|
| 368 |
Handle<Code> StubCache::ComputeLoadInterceptor(Handle<Name> name, |
|
| 369 |
Handle<JSObject> receiver, |
|
| 370 |
Handle<JSObject> holder) {
|
|
| 371 |
Handle<JSObject> stub_holder = StubHolder(receiver, holder); |
|
| 372 |
Handle<Code> stub = FindLoadHandler( |
|
| 373 |
name, receiver, stub_holder, Code::LOAD_IC, Code::INTERCEPTOR); |
|
| 374 |
if (!stub.is_null()) return stub; |
|
| 375 |
|
|
| 376 |
LoadStubCompiler compiler(isolate_); |
|
| 377 |
Handle<Code> handler = |
|
| 378 |
compiler.CompileLoadInterceptor(receiver, holder, name); |
|
| 379 |
HeapObject::UpdateMapCodeCache(stub_holder, name, handler); |
|
| 380 |
return handler; |
|
| 381 |
} |
|
| 382 |
|
|
| 383 |
|
|
| 384 |
Handle<Code> StubCache::ComputeLoadNormal(Handle<Name> name, |
|
| 385 |
Handle<JSObject> receiver) {
|
|
| 386 |
return isolate_->builtins()->LoadIC_Normal(); |
|
| 387 |
} |
|
| 388 |
|
|
| 389 |
|
|
| 390 | 205 |
Handle<Code> StubCache::ComputeLoadGlobal(Handle<Name> name, |
| 391 | 206 |
Handle<JSObject> receiver, |
| 392 | 207 |
Handle<GlobalObject> holder, |
| 393 | 208 |
Handle<PropertyCell> cell, |
| 394 | 209 |
bool is_dont_delete) {
|
| 395 |
Handle<JSObject> stub_holder = StubHolder(receiver, holder); |
|
| 396 |
Handle<Code> stub = FindIC(name, stub_holder, Code::LOAD_IC, Code::NORMAL); |
|
| 210 |
Handle<Code> stub = FindIC(name, receiver, Code::LOAD_IC); |
|
| 397 | 211 |
if (!stub.is_null()) return stub; |
| 398 | 212 |
|
| 399 | 213 |
LoadStubCompiler compiler(isolate_); |
| 400 | 214 |
Handle<Code> ic = |
| 401 | 215 |
compiler.CompileLoadGlobal(receiver, holder, cell, name, is_dont_delete); |
| 402 |
HeapObject::UpdateMapCodeCache(stub_holder, name, ic);
|
|
| 216 |
HeapObject::UpdateMapCodeCache(receiver, name, ic);
|
|
| 403 | 217 |
return ic; |
| 404 | 218 |
} |
| 405 | 219 |
|
| 406 | 220 |
|
| 407 |
Handle<Code> StubCache::ComputeKeyedLoadField(Handle<Name> name, |
|
| 408 |
Handle<JSObject> receiver, |
|
| 409 |
Handle<JSObject> holder, |
|
| 410 |
PropertyIndex field, |
|
| 411 |
Representation representation) {
|
|
| 412 |
if (receiver.is_identical_to(holder)) {
|
|
| 413 |
// TODO(titzer): this should use an HObjectAccess |
|
| 414 |
KeyedLoadFieldStub stub(field.is_inobject(holder), |
|
| 415 |
field.translate(holder), |
|
| 416 |
representation); |
|
| 417 |
return stub.GetCode(isolate()); |
|
| 418 |
} |
|
| 419 |
|
|
| 420 |
Handle<JSObject> stub_holder = StubHolder(receiver, holder); |
|
| 421 |
Handle<Code> stub = FindLoadHandler( |
|
| 422 |
name, receiver, stub_holder, Code::KEYED_LOAD_IC, Code::FIELD); |
|
| 423 |
if (!stub.is_null()) return stub; |
|
| 424 |
|
|
| 425 |
KeyedLoadStubCompiler compiler(isolate_); |
|
| 426 |
Handle<Code> handler = |
|
| 427 |
compiler.CompileLoadField(receiver, holder, name, field, representation); |
|
| 428 |
HeapObject::UpdateMapCodeCache(stub_holder, name, handler); |
|
| 429 |
return handler; |
|
| 430 |
} |
|
| 431 |
|
|
| 432 |
|
|
| 433 |
Handle<Code> StubCache::ComputeKeyedLoadConstant(Handle<Name> name, |
|
| 434 |
Handle<JSObject> receiver, |
|
| 435 |
Handle<JSObject> holder, |
|
| 436 |
Handle<Object> value) {
|
|
| 437 |
Handle<JSObject> stub_holder = StubHolder(receiver, holder); |
|
| 438 |
Handle<Code> handler = FindLoadHandler( |
|
| 439 |
name, receiver, stub_holder, Code::KEYED_LOAD_IC, |
|
| 440 |
Code::CONSTANT); |
|
| 441 |
if (!handler.is_null()) return handler; |
|
| 442 |
|
|
| 443 |
KeyedLoadStubCompiler compiler(isolate_); |
|
| 444 |
handler = compiler.CompileLoadConstant(receiver, holder, name, value); |
|
| 445 |
HeapObject::UpdateMapCodeCache(stub_holder, name, handler); |
|
| 446 |
return handler; |
|
| 447 |
} |
|
| 448 |
|
|
| 449 |
|
|
| 450 |
Handle<Code> StubCache::ComputeKeyedLoadInterceptor(Handle<Name> name, |
|
| 451 |
Handle<JSObject> receiver, |
|
| 452 |
Handle<JSObject> holder) {
|
|
| 453 |
Handle<JSObject> stub_holder = StubHolder(receiver, holder); |
|
| 454 |
Handle<Code> stub = FindLoadHandler( |
|
| 455 |
name, receiver, stub_holder, Code::KEYED_LOAD_IC, Code::INTERCEPTOR); |
|
| 456 |
if (!stub.is_null()) return stub; |
|
| 457 |
|
|
| 458 |
KeyedLoadStubCompiler compiler(isolate_); |
|
| 459 |
Handle<Code> handler = |
|
| 460 |
compiler.CompileLoadInterceptor(receiver, holder, name); |
|
| 461 |
HeapObject::UpdateMapCodeCache(stub_holder, name, handler); |
|
| 462 |
return handler; |
|
| 463 |
} |
|
| 464 |
|
|
| 465 |
|
|
| 466 |
Handle<Code> StubCache::ComputeKeyedLoadCallback( |
|
| 467 |
Handle<Name> name, |
|
| 468 |
Handle<JSObject> receiver, |
|
| 469 |
Handle<JSObject> holder, |
|
| 470 |
Handle<ExecutableAccessorInfo> callback) {
|
|
| 471 |
Handle<JSObject> stub_holder = StubHolder(receiver, holder); |
|
| 472 |
Handle<Code> stub = FindLoadHandler( |
|
| 473 |
name, receiver, stub_holder, Code::KEYED_LOAD_IC, Code::CALLBACKS); |
|
| 474 |
if (!stub.is_null()) return stub; |
|
| 475 |
|
|
| 476 |
KeyedLoadStubCompiler compiler(isolate_); |
|
| 477 |
Handle<Code> handler = |
|
| 478 |
compiler.CompileLoadCallback(receiver, holder, name, callback); |
|
| 479 |
HeapObject::UpdateMapCodeCache(stub_holder, name, handler); |
|
| 480 |
return handler; |
|
| 481 |
} |
|
| 482 |
|
|
| 483 |
|
|
| 484 |
Handle<Code> StubCache::ComputeKeyedLoadCallback( |
|
| 485 |
Handle<Name> name, |
|
| 486 |
Handle<JSObject> receiver, |
|
| 487 |
Handle<JSObject> holder, |
|
| 488 |
const CallOptimization& call_optimization) {
|
|
| 489 |
Handle<JSObject> stub_holder = StubHolder(receiver, holder); |
|
| 490 |
Handle<Code> stub = FindLoadHandler( |
|
| 491 |
name, receiver, stub_holder, Code::KEYED_LOAD_IC, Code::CALLBACKS); |
|
| 492 |
if (!stub.is_null()) return stub; |
|
| 493 |
|
|
| 494 |
KeyedLoadStubCompiler compiler(isolate_); |
|
| 495 |
Handle<Code> handler = |
|
| 496 |
compiler.CompileLoadCallback(receiver, holder, name, call_optimization); |
|
| 497 |
HeapObject::UpdateMapCodeCache(stub_holder, name, handler); |
|
| 498 |
return handler; |
|
| 499 |
} |
|
| 500 |
|
|
| 501 |
|
|
| 502 |
Handle<Code> StubCache::ComputeStoreField(Handle<Name> name, |
|
| 503 |
Handle<JSObject> receiver, |
|
| 504 |
LookupResult* lookup, |
|
| 505 |
StrictModeFlag strict_mode) {
|
|
| 506 |
Handle<Code> stub = FindStoreHandler( |
|
| 507 |
name, receiver, Code::STORE_IC, Code::FIELD, strict_mode); |
|
| 508 |
if (!stub.is_null()) return stub; |
|
| 509 |
|
|
| 510 |
StoreStubCompiler compiler(isolate_, strict_mode); |
|
| 511 |
Handle<Code> handler = compiler.CompileStoreField(receiver, lookup, name); |
|
| 512 |
HeapObject::UpdateMapCodeCache(receiver, name, handler); |
|
| 513 |
return handler; |
|
| 514 |
} |
|
| 515 |
|
|
| 516 |
|
|
| 517 |
Handle<Code> StubCache::ComputeStoreTransition(Handle<Name> name, |
|
| 518 |
Handle<JSObject> receiver, |
|
| 519 |
LookupResult* lookup, |
|
| 520 |
Handle<Map> transition, |
|
| 521 |
StrictModeFlag strict_mode) {
|
|
| 522 |
Handle<Code> stub = FindStoreHandler( |
|
| 523 |
name, receiver, Code::STORE_IC, Code::MAP_TRANSITION, strict_mode); |
|
| 524 |
if (!stub.is_null()) return stub; |
|
| 525 |
|
|
| 526 |
StoreStubCompiler compiler(isolate_, strict_mode); |
|
| 527 |
Handle<Code> handler = |
|
| 528 |
compiler.CompileStoreTransition(receiver, lookup, transition, name); |
|
| 529 |
HeapObject::UpdateMapCodeCache(receiver, name, handler); |
|
| 530 |
return handler; |
|
| 531 |
} |
|
| 532 |
|
|
| 533 |
|
|
| 534 | 221 |
Handle<Code> StubCache::ComputeKeyedLoadElement(Handle<Map> receiver_map) {
|
| 535 | 222 |
Code::Flags flags = Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC); |
| 536 | 223 |
Handle<Name> name = |
| ... | ... | |
| 575 | 262 |
} |
| 576 | 263 |
|
| 577 | 264 |
|
| 578 |
Handle<Code> StubCache::ComputeStoreNormal(StrictModeFlag strict_mode) {
|
|
| 579 |
return (strict_mode == kStrictMode) |
|
| 580 |
? isolate_->builtins()->Builtins::StoreIC_Normal_Strict() |
|
| 581 |
: isolate_->builtins()->Builtins::StoreIC_Normal(); |
|
| 582 |
} |
|
| 583 |
|
|
| 584 |
|
|
| 585 | 265 |
Handle<Code> StubCache::ComputeStoreGlobal(Handle<Name> name, |
| 586 | 266 |
Handle<GlobalObject> receiver, |
| 587 | 267 |
Handle<PropertyCell> cell, |
| 588 | 268 |
Handle<Object> value, |
| 589 | 269 |
StrictModeFlag strict_mode) {
|
| 590 |
Isolate* isolate = cell->GetIsolate(); |
|
| 591 |
Handle<Type> union_type(PropertyCell::UpdateType(cell, value), isolate); |
|
| 270 |
Handle<Type> union_type = PropertyCell::UpdatedType(cell, value); |
|
| 592 | 271 |
bool is_constant = union_type->IsConstant(); |
| 593 | 272 |
StoreGlobalStub stub(strict_mode, is_constant); |
| 594 | 273 |
|
| 595 | 274 |
Handle<Code> code = FindIC( |
| 596 | 275 |
name, Handle<JSObject>::cast(receiver), |
| 597 |
Code::STORE_IC, Code::NORMAL, stub.GetExtraICState());
|
|
| 276 |
Code::STORE_IC, stub.GetExtraICState()); |
|
| 598 | 277 |
if (!code.is_null()) return code; |
| 599 | 278 |
|
| 600 | 279 |
// Replace the placeholder cell and global object map with the actual global |
| ... | ... | |
| 612 | 291 |
} |
| 613 | 292 |
|
| 614 | 293 |
|
| 615 |
Handle<Code> StubCache::ComputeStoreCallback( |
|
| 616 |
Handle<Name> name, |
|
| 617 |
Handle<JSObject> receiver, |
|
| 618 |
Handle<JSObject> holder, |
|
| 619 |
Handle<ExecutableAccessorInfo> callback, |
|
| 620 |
StrictModeFlag strict_mode) {
|
|
| 621 |
ASSERT(v8::ToCData<Address>(callback->setter()) != 0); |
|
| 622 |
Handle<Code> stub = FindStoreHandler( |
|
| 623 |
name, receiver, Code::STORE_IC, Code::CALLBACKS, strict_mode); |
|
| 624 |
if (!stub.is_null()) return stub; |
|
| 625 |
|
|
| 626 |
StoreStubCompiler compiler(isolate_, strict_mode); |
|
| 627 |
Handle<Code> handler = compiler.CompileStoreCallback( |
|
| 628 |
receiver, holder, name, callback); |
|
| 629 |
HeapObject::UpdateMapCodeCache(receiver, name, handler); |
|
| 630 |
return handler; |
|
| 631 |
} |
|
| 632 |
|
|
| 633 |
|
|
| 634 |
Handle<Code> StubCache::ComputeStoreCallback( |
|
| 635 |
Handle<Name> name, |
|
| 636 |
Handle<JSObject> receiver, |
|
| 637 |
Handle<JSObject> holder, |
|
| 638 |
const CallOptimization& call_optimization, |
|
| 639 |
StrictModeFlag strict_mode) {
|
|
| 640 |
Handle<Code> stub = FindStoreHandler( |
|
| 641 |
name, receiver, Code::STORE_IC, Code::CALLBACKS, strict_mode); |
|
| 642 |
if (!stub.is_null()) return stub; |
|
| 643 |
|
|
| 644 |
StoreStubCompiler compiler(isolate_, strict_mode); |
|
| 645 |
Handle<Code> handler = compiler.CompileStoreCallback( |
|
| 646 |
receiver, holder, name, call_optimization); |
|
| 647 |
HeapObject::UpdateMapCodeCache(receiver, name, handler); |
|
| 648 |
return handler; |
|
| 649 |
} |
|
| 650 |
|
|
| 651 |
|
|
| 652 |
Handle<Code> StubCache::ComputeStoreViaSetter(Handle<Name> name, |
|
| 653 |
Handle<JSObject> receiver, |
|
| 654 |
Handle<JSObject> holder, |
|
| 655 |
Handle<JSFunction> setter, |
|
| 656 |
StrictModeFlag strict_mode) {
|
|
| 657 |
Handle<Code> stub = FindStoreHandler( |
|
| 658 |
name, receiver, Code::STORE_IC, Code::CALLBACKS, strict_mode); |
|
| 659 |
if (!stub.is_null()) return stub; |
|
| 660 |
|
|
| 661 |
StoreStubCompiler compiler(isolate_, strict_mode); |
|
| 662 |
Handle<Code> handler = compiler.CompileStoreViaSetter( |
|
| 663 |
receiver, holder, name, setter); |
|
| 664 |
HeapObject::UpdateMapCodeCache(receiver, name, handler); |
|
| 665 |
return handler; |
|
| 666 |
} |
|
| 667 |
|
|
| 668 |
|
|
| 669 |
Handle<Code> StubCache::ComputeStoreInterceptor(Handle<Name> name, |
|
| 670 |
Handle<JSObject> receiver, |
|
| 671 |
StrictModeFlag strict_mode) {
|
|
| 672 |
Handle<Code> stub = FindStoreHandler( |
|
| 673 |
name, receiver, Code::STORE_IC, Code::INTERCEPTOR, strict_mode); |
|
| 674 |
if (!stub.is_null()) return stub; |
|
| 675 |
|
|
| 676 |
StoreStubCompiler compiler(isolate_, strict_mode); |
|
| 677 |
Handle<Code> handler = compiler.CompileStoreInterceptor(receiver, name); |
|
| 678 |
HeapObject::UpdateMapCodeCache(receiver, name, handler); |
|
| 679 |
return handler; |
|
| 680 |
} |
|
| 681 |
|
|
| 682 |
|
|
| 683 |
Handle<Code> StubCache::ComputeKeyedStoreField(Handle<Name> name, |
|
| 684 |
Handle<JSObject> receiver, |
|
| 685 |
LookupResult* lookup, |
|
| 686 |
StrictModeFlag strict_mode) {
|
|
| 687 |
Handle<Code> stub = FindStoreHandler( |
|
| 688 |
name, receiver, Code::KEYED_STORE_IC, Code::FIELD, strict_mode); |
|
| 689 |
if (!stub.is_null()) return stub; |
|
| 690 |
|
|
| 691 |
KeyedStoreStubCompiler compiler(isolate(), strict_mode, STANDARD_STORE); |
|
| 692 |
Handle<Code> handler = compiler.CompileStoreField(receiver, lookup, name); |
|
| 693 |
HeapObject::UpdateMapCodeCache(receiver, name, handler); |
|
| 694 |
return handler; |
|
| 695 |
} |
|
| 696 |
|
|
| 697 |
|
|
| 698 |
Handle<Code> StubCache::ComputeKeyedStoreTransition( |
|
| 699 |
Handle<Name> name, |
|
| 700 |
Handle<JSObject> receiver, |
|
| 701 |
LookupResult* lookup, |
|
| 702 |
Handle<Map> transition, |
|
| 703 |
StrictModeFlag strict_mode) {
|
|
| 704 |
Handle<Code> stub = FindStoreHandler( |
|
| 705 |
name, receiver, Code::KEYED_STORE_IC, Code::MAP_TRANSITION, strict_mode); |
|
| 706 |
if (!stub.is_null()) return stub; |
|
| 707 |
|
|
| 708 |
KeyedStoreStubCompiler compiler(isolate(), strict_mode, STANDARD_STORE); |
|
| 709 |
Handle<Code> handler = |
|
| 710 |
compiler.CompileStoreTransition(receiver, lookup, transition, name); |
|
| 711 |
HeapObject::UpdateMapCodeCache(receiver, name, handler); |
|
| 712 |
return handler; |
|
| 713 |
} |
|
| 714 |
|
|
| 715 |
|
|
| 716 | 294 |
#define CALL_LOGGER_TAG(kind, type) \ |
| 717 | 295 |
(kind == Code::CALL_IC ? Logger::type : Logger::KEYED_##type) |
| 718 | 296 |
|
| ... | ... | |
| 858 | 436 |
Handle<GlobalObject> holder, |
| 859 | 437 |
Handle<PropertyCell> cell, |
| 860 | 438 |
Handle<JSFunction> function) {
|
| 861 |
InlineCacheHolderFlag cache_holder = |
|
| 862 |
IC::GetCodeCacheForObject(*receiver, *holder); |
|
| 863 |
Handle<JSObject> stub_holder(IC::GetCodeCacheHolder( |
|
| 864 |
isolate_, *receiver, cache_holder)); |
|
| 865 | 439 |
Code::Flags flags = Code::ComputeMonomorphicFlags( |
| 866 |
kind, extra_state, Code::NORMAL, argc, cache_holder);
|
|
| 867 |
Handle<Object> probe(stub_holder->map()->FindInCodeCache(*name, flags),
|
|
| 440 |
kind, extra_state, Code::NORMAL, argc); |
|
| 441 |
Handle<Object> probe(receiver->map()->FindInCodeCache(*name, flags),
|
|
| 868 | 442 |
isolate_); |
| 869 | 443 |
if (probe->IsCode()) return Handle<Code>::cast(probe); |
| 870 | 444 |
|
| 871 |
CallStubCompiler compiler(isolate(), argc, kind, extra_state, cache_holder);
|
|
| 445 |
CallStubCompiler compiler(isolate(), argc, kind, extra_state); |
|
| 872 | 446 |
Handle<Code> code = |
| 873 | 447 |
compiler.CompileCallGlobal(receiver, holder, cell, function, name); |
| 874 | 448 |
ASSERT(flags == code->flags()); |
| ... | ... | |
| 876 | 450 |
CodeCreateEvent(CALL_LOGGER_TAG(kind, CALL_IC_TAG), *code, *name)); |
| 877 | 451 |
GDBJIT(AddCode(GDBJITInterface::CALL_IC, *name, *code)); |
| 878 | 452 |
if (CallStubCompiler::CanBeCached(function)) {
|
| 879 |
HeapObject::UpdateMapCodeCache(stub_holder, name, code);
|
|
| 453 |
HeapObject::UpdateMapCodeCache(receiver, name, code);
|
|
| 880 | 454 |
} |
| 881 | 455 |
return code; |
| 882 | 456 |
} |
| ... | ... | |
| 1036 | 610 |
Handle<String> name(isolate_->heap()->empty_string()); |
| 1037 | 611 |
if (!receiver_map->is_shared()) {
|
| 1038 | 612 |
Handle<Code> cached_ic = FindIC(name, receiver_map, Code::COMPARE_NIL_IC, |
| 1039 |
Code::NORMAL, stub.GetExtraICState());
|
|
| 613 |
stub.GetExtraICState()); |
|
| 1040 | 614 |
if (!cached_ic.is_null()) return cached_ic; |
| 1041 | 615 |
} |
| 1042 | 616 |
|
| ... | ... | |
| 1073 | 647 |
} |
| 1074 | 648 |
|
| 1075 | 649 |
|
| 1076 |
Handle<Code> StubCache::ComputePolymorphicLoadIC(MapHandleList* receiver_maps, |
|
| 1077 |
CodeHandleList* handlers, |
|
| 1078 |
int number_of_valid_maps, |
|
| 1079 |
Handle<Name> name) {
|
|
| 1080 |
LoadStubCompiler ic_compiler(isolate_); |
|
| 1081 |
Code::StubType type = number_of_valid_maps == 1 ? handlers->at(0)->type() |
|
| 1082 |
: Code::NORMAL; |
|
| 1083 |
Handle<Code> ic = ic_compiler.CompilePolymorphicIC( |
|
| 1084 |
receiver_maps, handlers, name, type, PROPERTY); |
|
| 1085 |
return ic; |
|
| 1086 |
} |
|
| 1087 |
|
|
| 1088 |
|
|
| 1089 |
Handle<Code> StubCache::ComputePolymorphicStoreIC(MapHandleList* receiver_maps, |
|
| 1090 |
CodeHandleList* handlers, |
|
| 1091 |
int number_of_valid_maps, |
|
| 1092 |
Handle<Name> name, |
|
| 1093 |
StrictModeFlag strict_mode) {
|
|
| 1094 |
StoreStubCompiler ic_compiler(isolate_, strict_mode); |
|
| 1095 |
Code::StubType type = number_of_valid_maps == 1 ? handlers->at(0)->type() |
|
| 650 |
Handle<Code> StubCache::ComputePolymorphicIC(MapHandleList* receiver_maps, |
|
| 651 |
CodeHandleList* handlers, |
|
| 652 |
int number_of_valid_maps, |
|
| 653 |
Handle<Name> name, |
|
| 654 |
StrictModeFlag strict_mode) {
|
|
| 655 |
Handle<Code> handler = handlers->at(0); |
|
| 656 |
Code::Kind kind = handler->handler_kind(); |
|
| 657 |
Code::StubType type = number_of_valid_maps == 1 ? handler->type() |
|
| 1096 | 658 |
: Code::NORMAL; |
| 1097 |
Handle<Code> ic = ic_compiler.CompilePolymorphicIC( |
|
| 1098 |
receiver_maps, handlers, name, type, PROPERTY); |
|
| 1099 |
return ic; |
|
| 659 |
if (kind == Code::LOAD_IC) {
|
|
| 660 |
LoadStubCompiler ic_compiler(isolate_); |
|
| 661 |
return ic_compiler.CompilePolymorphicIC( |
|
| 662 |
receiver_maps, handlers, name, type, PROPERTY); |
|
| 663 |
} else {
|
|
| 664 |
ASSERT(kind == Code::STORE_IC); |
|
| 665 |
StoreStubCompiler ic_compiler(isolate_, strict_mode); |
|
| 666 |
return ic_compiler.CompilePolymorphicIC( |
|
| 667 |
receiver_maps, handlers, name, type, PROPERTY); |
|
| 668 |
} |
|
| 1100 | 669 |
} |
| 1101 | 670 |
|
| 1102 | 671 |
|
| ... | ... | |
| 1300 | 869 |
// If the load is non-contextual, just return the undefined result. |
| 1301 | 870 |
// Note that both keyed and non-keyed loads may end up here, so we |
| 1302 | 871 |
// can't use either LoadIC or KeyedLoadIC constructors. |
| 872 |
HandleScope scope(isolate); |
|
| 1303 | 873 |
IC ic(IC::NO_EXTRA_FRAME, isolate); |
| 1304 | 874 |
ASSERT(ic.target()->is_load_stub() || ic.target()->is_keyed_load_stub()); |
| 1305 | 875 |
if (!ic.SlowIsUndeclaredGlobal()) return isolate->heap()->undefined_value(); |
| 1306 | 876 |
|
| 1307 | 877 |
// Throw a reference error. |
| 1308 |
HandleScope scope(isolate); |
|
| 1309 | 878 |
Handle<Name> name_handle(name); |
| 1310 | 879 |
Handle<Object> error = |
| 1311 | 880 |
isolate->factory()->NewReferenceError("not_defined",
|
| ... | ... | |
| 1314 | 883 |
} |
| 1315 | 884 |
|
| 1316 | 885 |
|
| 1317 |
static MaybeObject* LoadWithInterceptor(Arguments* args,
|
|
| 1318 |
PropertyAttributes* attrs) {
|
|
| 886 |
static Handle<Object> LoadWithInterceptor(Arguments* args,
|
|
| 887 |
PropertyAttributes* attrs) {
|
|
| 1319 | 888 |
ASSERT(args->length() == StubCache::kInterceptorArgsLength); |
| 1320 | 889 |
Handle<Name> name_handle = |
| 1321 | 890 |
args->at<Name>(StubCache::kInterceptorArgsNameIndex); |
| ... | ... | |
| 1329 | 898 |
Isolate* isolate = receiver_handle->GetIsolate(); |
| 1330 | 899 |
|
| 1331 | 900 |
// TODO(rossberg): Support symbols in the API. |
| 1332 |
if (name_handle->IsSymbol()) |
|
| 1333 |
return holder_handle->GetPropertyPostInterceptor( |
|
| 1334 |
*receiver_handle, *name_handle, attrs); |
|
| 901 |
if (name_handle->IsSymbol()) {
|
|
| 902 |
return JSObject::GetPropertyPostInterceptor( |
|
| 903 |
holder_handle, receiver_handle, name_handle, attrs); |
|
| 904 |
} |
|
| 1335 | 905 |
Handle<String> name = Handle<String>::cast(name_handle); |
| 1336 | 906 |
|
| 1337 | 907 |
Address getter_address = v8::ToCData<Address>(interceptor_info->getter()); |
| ... | ... | |
| 1344 | 914 |
*receiver_handle, |
| 1345 | 915 |
*holder_handle); |
| 1346 | 916 |
{
|
| 1347 |
// Use the interceptor getter. |
|
| 1348 | 917 |
HandleScope scope(isolate); |
| 918 |
// Use the interceptor getter. |
|
| 1349 | 919 |
v8::Handle<v8::Value> r = |
| 1350 | 920 |
callback_args.Call(getter, v8::Utils::ToLocal(name)); |
| 1351 |
RETURN_IF_SCHEDULED_EXCEPTION(isolate);
|
|
| 921 |
RETURN_HANDLE_IF_SCHEDULED_EXCEPTION(isolate, Object);
|
|
| 1352 | 922 |
if (!r.IsEmpty()) {
|
| 1353 | 923 |
*attrs = NONE; |
| 1354 | 924 |
Handle<Object> result = v8::Utils::OpenHandle(*r); |
| 1355 | 925 |
result->VerifyApiCallResultType(); |
| 1356 |
return *result;
|
|
| 926 |
return scope.CloseAndEscape(result);
|
|
| 1357 | 927 |
} |
| 1358 | 928 |
} |
| 1359 | 929 |
|
| 1360 |
MaybeObject* result = holder_handle->GetPropertyPostInterceptor( |
|
| 1361 |
*receiver_handle, |
|
| 1362 |
*name_handle, |
|
| 1363 |
attrs); |
|
| 1364 |
RETURN_IF_SCHEDULED_EXCEPTION(isolate); |
|
| 930 |
Handle<Object> result = JSObject::GetPropertyPostInterceptor( |
|
| 931 |
holder_handle, receiver_handle, name_handle, attrs); |
|
| 1365 | 932 |
return result; |
| 1366 | 933 |
} |
| 1367 | 934 |
|
| ... | ... | |
| 1372 | 939 |
*/ |
| 1373 | 940 |
RUNTIME_FUNCTION(MaybeObject*, LoadPropertyWithInterceptorForLoad) {
|
| 1374 | 941 |
PropertyAttributes attr = NONE; |
| 1375 |
Object* result; |
|
| 1376 |
{ MaybeObject* maybe_result = LoadWithInterceptor(&args, &attr);
|
|
| 1377 |
if (!maybe_result->ToObject(&result)) return maybe_result; |
|
| 1378 |
} |
|
| 942 |
HandleScope scope(isolate); |
|
| 943 |
Handle<Object> result = LoadWithInterceptor(&args, &attr); |
|
| 944 |
RETURN_IF_EMPTY_HANDLE(isolate, result); |
|
| 1379 | 945 |
|
| 1380 | 946 |
// If the property is present, return it. |
| 1381 |
if (attr != ABSENT) return result; |
|
| 947 |
if (attr != ABSENT) return *result;
|
|
| 1382 | 948 |
return ThrowReferenceError(isolate, Name::cast(args[0])); |
| 1383 | 949 |
} |
| 1384 | 950 |
|
| 1385 | 951 |
|
| 1386 | 952 |
RUNTIME_FUNCTION(MaybeObject*, LoadPropertyWithInterceptorForCall) {
|
| 1387 | 953 |
PropertyAttributes attr; |
| 1388 |
MaybeObject* result = LoadWithInterceptor(&args, &attr); |
|
| 1389 |
RETURN_IF_SCHEDULED_EXCEPTION(isolate); |
|
| 954 |
HandleScope scope(isolate); |
|
| 955 |
Handle<Object> result = LoadWithInterceptor(&args, &attr); |
|
| 956 |
RETURN_IF_EMPTY_HANDLE(isolate, result); |
|
| 1390 | 957 |
// This is call IC. In this case, we simply return the undefined result which |
| 1391 | 958 |
// will lead to an exception when trying to invoke the result as a |
| 1392 | 959 |
// function. |
| 1393 |
return result; |
|
| 960 |
return *result;
|
|
| 1394 | 961 |
} |
| 1395 | 962 |
|
| 1396 | 963 |
|
| 1397 | 964 |
RUNTIME_FUNCTION(MaybeObject*, StoreInterceptorProperty) {
|
| 965 |
HandleScope scope(isolate); |
|
| 1398 | 966 |
ASSERT(args.length() == 4); |
| 1399 |
JSObject* recv = JSObject::cast(args[0]);
|
|
| 1400 |
Name* name = Name::cast(args[1]);
|
|
| 1401 |
Object* value = args[2];
|
|
| 967 |
Handle<JSObject> recv(JSObject::cast(args[0]));
|
|
| 968 |
Handle<Name> name(Name::cast(args[1]));
|
|
| 969 |
Handle<Object> value(args[2], isolate);
|
|
| 1402 | 970 |
ASSERT(args.smi_at(3) == kStrictMode || args.smi_at(3) == kNonStrictMode); |
| 1403 | 971 |
StrictModeFlag strict_mode = static_cast<StrictModeFlag>(args.smi_at(3)); |
| 1404 | 972 |
ASSERT(recv->HasNamedInterceptor()); |
| 1405 | 973 |
PropertyAttributes attr = NONE; |
| 1406 |
MaybeObject* result = recv->SetPropertyWithInterceptor( |
|
| 1407 |
name, value, attr, strict_mode); |
|
| 1408 |
return result; |
|
| 974 |
Handle<Object> result = JSObject::SetPropertyWithInterceptor( |
|
| 975 |
recv, name, value, attr, strict_mode); |
|
| 976 |
RETURN_IF_EMPTY_HANDLE(isolate, result); |
|
| 977 |
return *result; |
|
| 1409 | 978 |
} |
| 1410 | 979 |
|
| 1411 | 980 |
|
| ... | ... | |
| 1599 | 1168 |
#define __ ACCESS_MASM(masm()) |
| 1600 | 1169 |
|
| 1601 | 1170 |
|
| 1602 |
Register BaseLoadStubCompiler::HandlerFrontendHeader(
|
|
| 1171 |
Register LoadStubCompiler::HandlerFrontendHeader( |
|
| 1603 | 1172 |
Handle<JSObject> object, |
| 1604 | 1173 |
Register object_reg, |
| 1605 | 1174 |
Handle<JSObject> holder, |
| ... | ... | |
| 1613 | 1182 |
|
| 1614 | 1183 |
// HandlerFrontend for store uses the name register. It has to be restored |
| 1615 | 1184 |
// before a miss. |
| 1616 |
Register BaseStoreStubCompiler::HandlerFrontendHeader(
|
|
| 1185 |
Register StoreStubCompiler::HandlerFrontendHeader( |
|
| 1617 | 1186 |
Handle<JSObject> object, |
| 1618 | 1187 |
Register object_reg, |
| 1619 | 1188 |
Handle<JSObject> holder, |
| ... | ... | |
| 1639 | 1208 |
} |
| 1640 | 1209 |
|
| 1641 | 1210 |
|
| 1642 |
Handle<Code> BaseLoadStubCompiler::CompileLoadField(
|
|
| 1211 |
Handle<Code> LoadStubCompiler::CompileLoadField( |
|
| 1643 | 1212 |
Handle<JSObject> object, |
| 1644 | 1213 |
Handle<JSObject> holder, |
| 1645 | 1214 |
Handle<Name> name, |
| ... | ... | |
| 1659 | 1228 |
} |
| 1660 | 1229 |
|
| 1661 | 1230 |
|
| 1662 |
Handle<Code> BaseLoadStubCompiler::CompileLoadConstant(
|
|
| 1231 |
Handle<Code> LoadStubCompiler::CompileLoadConstant( |
|
| 1663 | 1232 |
Handle<JSObject> object, |
| 1664 | 1233 |
Handle<JSObject> holder, |
| 1665 | 1234 |
Handle<Name> name, |
| ... | ... | |
| 1674 | 1243 |
} |
| 1675 | 1244 |
|
| 1676 | 1245 |
|
| 1677 |
Handle<Code> BaseLoadStubCompiler::CompileLoadCallback(
|
|
| 1246 |
Handle<Code> LoadStubCompiler::CompileLoadCallback( |
|
| 1678 | 1247 |
Handle<JSObject> object, |
| 1679 | 1248 |
Handle<JSObject> holder, |
| 1680 | 1249 |
Handle<Name> name, |
| ... | ... | |
| 1691 | 1260 |
} |
| 1692 | 1261 |
|
| 1693 | 1262 |
|
| 1694 |
Handle<Code> BaseLoadStubCompiler::CompileLoadCallback(
|
|
| 1263 |
Handle<Code> LoadStubCompiler::CompileLoadCallback( |
|
| 1695 | 1264 |
Handle<JSObject> object, |
| 1696 | 1265 |
Handle<JSObject> holder, |
| 1697 | 1266 |
Handle<Name> name, |
| ... | ... | |
| 1710 | 1279 |
} |
| 1711 | 1280 |
|
| 1712 | 1281 |
|
| 1713 |
Handle<Code> BaseLoadStubCompiler::CompileLoadInterceptor(
|
|
| 1282 |
Handle<Code> LoadStubCompiler::CompileLoadInterceptor( |
|
| 1714 | 1283 |
Handle<JSObject> object, |
| 1715 | 1284 |
Handle<JSObject> holder, |
| 1716 | 1285 |
Handle<Name> name) {
|
| ... | ... | |
| 1730 | 1299 |
} |
| 1731 | 1300 |
|
| 1732 | 1301 |
|
| 1733 |
void BaseLoadStubCompiler::GenerateLoadPostInterceptor(
|
|
| 1302 |
void LoadStubCompiler::GenerateLoadPostInterceptor( |
|
| 1734 | 1303 |
Register interceptor_reg, |
| 1735 | 1304 |
Handle<JSObject> interceptor_holder, |
| 1736 | 1305 |
Handle<Name> name, |
| ... | ... | |
| 1789 | 1358 |
HandlerFrontend(object, receiver(), holder, name, &success); |
| 1790 | 1359 |
|
| 1791 | 1360 |
__ bind(&success); |
| 1792 |
GenerateLoadViaGetter(masm(), getter); |
|
| 1361 |
GenerateLoadViaGetter(masm(), receiver(), getter);
|
|
| 1793 | 1362 |
|
| 1794 | 1363 |
// Return the generated code. |
| 1795 | 1364 |
return GetCode(kind(), Code::CALLBACKS, name); |
| 1796 | 1365 |
} |
| 1797 | 1366 |
|
| 1798 | 1367 |
|
| 1799 |
Handle<Code> BaseStoreStubCompiler::CompileStoreTransition(
|
|
| 1368 |
Handle<Code> StoreStubCompiler::CompileStoreTransition( |
|
| 1800 | 1369 |
Handle<JSObject> object, |
| 1801 | 1370 |
LookupResult* lookup, |
| 1802 | 1371 |
Handle<Map> transition, |
| ... | ... | |
| 1849 | 1418 |
TailCallBuiltin(masm(), SlowBuiltin(kind())); |
| 1850 | 1419 |
|
| 1851 | 1420 |
// Return the generated code. |
| 1852 |
return GetCode(kind(), Code::MAP_TRANSITION, name);
|
|
| 1421 |
return GetCode(kind(), Code::TRANSITION, name); |
|
| 1853 | 1422 |
} |
| 1854 | 1423 |
|
| 1855 | 1424 |
|
| 1856 |
Handle<Code> BaseStoreStubCompiler::CompileStoreField(Handle<JSObject> object,
|
|
| 1857 |
LookupResult* lookup,
|
|
| 1858 |
Handle<Name> name) {
|
|
| 1425 |
Handle<Code> StoreStubCompiler::CompileStoreField(Handle<JSObject> object, |
|
| 1426 |
LookupResult* lookup, |
|
| 1427 |
Handle<Name> name) {
|
|
| 1859 | 1428 |
Label miss; |
| 1860 | 1429 |
|
| 1861 | 1430 |
HandlerFrontendHeader(object, receiver(), object, name, &miss); |
| ... | ... | |
| 1948 | 1517 |
} |
| 1949 | 1518 |
|
| 1950 | 1519 |
|
| 1951 |
void LoadStubCompiler::JitEvent(Handle<Name> name, Handle<Code> code) {
|
|
| 1952 |
GDBJIT(AddCode(GDBJITInterface::LOAD_IC, *name, *code)); |
|
| 1953 |
} |
|
| 1954 |
|
|
| 1955 |
|
|
| 1956 |
void KeyedLoadStubCompiler::JitEvent(Handle<Name> name, Handle<Code> code) {
|
|
| 1957 |
GDBJIT(AddCode(GDBJITInterface::KEYED_LOAD_IC, *name, *code)); |
|
| 1958 |
} |
|
| 1959 |
|
|
| 1960 |
|
|
| 1961 |
void StoreStubCompiler::JitEvent(Handle<Name> name, Handle<Code> code) {
|
|
| 1962 |
GDBJIT(AddCode(GDBJITInterface::STORE_IC, *name, *code)); |
|
| 1520 |
void BaseLoadStoreStubCompiler::JitEvent(Handle<Name> name, Handle<Code> code) {
|
|
| 1521 |
#ifdef ENABLE_GDB_JIT_INTERFACE |
|
| 1522 |
GDBJITInterface::CodeTag tag; |
|
| 1523 |
if (kind_ == Code::LOAD_IC) {
|
|
| 1524 |
tag = GDBJITInterface::LOAD_IC; |
|
| 1525 |
} else if (kind_ == Code::KEYED_LOAD_IC) {
|
|
| 1526 |
tag = GDBJITInterface::KEYED_LOAD_IC; |
|
| 1527 |
} else if (kind_ == Code::STORE_IC) {
|
|
| 1528 |
tag = GDBJITInterface::STORE_IC; |
|
| 1529 |
} else {
|
|
| 1530 |
tag = GDBJITInterface::KEYED_STORE_IC; |
|
| 1531 |
} |
|
| 1532 |
GDBJIT(AddCode(tag, *name, *code)); |
|
| 1533 |
#endif |
|
| 1963 | 1534 |
} |
| 1964 | 1535 |
|
| 1965 | 1536 |
|
| 1966 |
void KeyedStoreStubCompiler::JitEvent(Handle<Name> name, Handle<Code> code) {
|
|
| 1967 |
GDBJIT(AddCode(GDBJITInterface::KEYED_STORE_IC, *name, *code)); |
|
| 1537 |
void BaseLoadStoreStubCompiler::InitializeRegisters() {
|
|
| 1538 |
if (kind_ == Code::LOAD_IC) {
|
|
| 1539 |
registers_ = LoadStubCompiler::registers(); |
|
| 1540 |
} else if (kind_ == Code::KEYED_LOAD_IC) {
|
|
| 1541 |
registers_ = KeyedLoadStubCompiler::registers(); |
|
| 1542 |
} else if (kind_ == Code::STORE_IC) {
|
|
| 1543 |
registers_ = StoreStubCompiler::registers(); |
|
| 1544 |
} else {
|
|
| 1545 |
registers_ = KeyedStoreStubCompiler::registers(); |
|
| 1546 |
} |
|
| 1968 | 1547 |
} |
| 1969 | 1548 |
|
| 1970 | 1549 |
|
| ... | ... | |
| 1972 | 1551 |
Code::StubType type, |
| 1973 | 1552 |
Handle<Name> name, |
| 1974 | 1553 |
InlineCacheState state) {
|
| 1975 |
Code::Flags flags = Code::ComputeFlags( |
|
| 1976 |
kind, state, extra_state(), type); |
|
| 1977 |
Handle<Code> code = GetCodeWithFlags(flags, name); |
|
| 1978 |
PROFILE(isolate(), CodeCreateEvent(log_kind(code), *code, *name)); |
|
| 1979 |
JitEvent(name, code); |
|
| 1980 |
return code; |
|
| 1981 |
} |
|
| 1982 |
|
|
| 1983 |
|
|
| 1984 |
Handle<Code> BaseLoadStubCompiler::GetCode(Code::Kind kind, |
|
| 1985 |
Code::StubType type, |
|
| 1986 |
Handle<Name> name) {
|
|
| 1987 |
ASSERT(type != Code::NORMAL); |
|
| 1988 |
Code::Flags flags = Code::ComputeFlags( |
|
| 1989 |
Code::STUB, MONOMORPHIC, Code::kNoExtraICState, type, kind); |
|
| 1554 |
Code::Flags flags = Code::ComputeFlags(kind, state, extra_state(), type); |
|
| 1990 | 1555 |
Handle<Code> code = GetCodeWithFlags(flags, name); |
| 1991 | 1556 |
PROFILE(isolate(), CodeCreateEvent(log_kind(code), *code, *name)); |
| 1992 | 1557 |
JitEvent(name, code); |
| ... | ... | |
| 1994 | 1559 |
} |
| 1995 | 1560 |
|
| 1996 | 1561 |
|
| 1997 |
Handle<Code> BaseStoreStubCompiler::GetCode(Code::Kind kind, |
|
| 1998 |
Code::StubType type, |
|
| 1999 |
Handle<Name> name) {
|
|
| 1562 |
Handle<Code> BaseLoadStoreStubCompiler::GetCode(Code::Kind kind,
|
|
| 1563 |
Code::StubType type,
|
|
| 1564 |
Handle<Name> name) {
|
|
| 2000 | 1565 |
ASSERT(type != Code::NORMAL); |
| 2001 | 1566 |
Code::Flags flags = Code::ComputeFlags( |
| 2002 |
Code::STUB, MONOMORPHIC, extra_state(), type, kind);
|
|
| 1567 |
Code::HANDLER, MONOMORPHIC, extra_state(), type, kind);
|
|
| 2003 | 1568 |
Handle<Code> code = GetCodeWithFlags(flags, name); |
| 2004 | 1569 |
PROFILE(isolate(), CodeCreateEvent(log_kind(code), *code, *name)); |
| 2005 | 1570 |
JitEvent(name, code); |
Also available in: Unified diff