OLD | NEW |
1 // Copyright 2012 the V8 project authors. All rights reserved. | 1 // Copyright 2012 the V8 project authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "src/v8.h" | 5 #include "src/v8.h" |
6 | 6 |
7 #if V8_TARGET_ARCH_MIPS | 7 #if V8_TARGET_ARCH_MIPS |
8 | 8 |
9 // Note on Mips implementation: | 9 // Note on Mips implementation: |
10 // | 10 // |
(...skipping 1346 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1357 Operand(isolate()->factory()->home_object_symbol())); | 1357 Operand(isolate()->factory()->home_object_symbol())); |
1358 __ lw(StoreDescriptor::ValueRegister(), | 1358 __ lw(StoreDescriptor::ValueRegister(), |
1359 MemOperand(sp, offset * kPointerSize)); | 1359 MemOperand(sp, offset * kPointerSize)); |
1360 if (FLAG_vector_stores) EmitLoadStoreICSlot(slot); | 1360 if (FLAG_vector_stores) EmitLoadStoreICSlot(slot); |
1361 CallStoreIC(); | 1361 CallStoreIC(); |
1362 } | 1362 } |
1363 } | 1363 } |
1364 | 1364 |
1365 | 1365 |
1366 void FullCodeGenerator::EmitLoadGlobalCheckExtensions(VariableProxy* proxy, | 1366 void FullCodeGenerator::EmitLoadGlobalCheckExtensions(VariableProxy* proxy, |
1367 TypeofState typeof_state, | 1367 TypeofMode typeof_mode, |
1368 Label* slow) { | 1368 Label* slow) { |
1369 Register current = cp; | 1369 Register current = cp; |
1370 Register next = a1; | 1370 Register next = a1; |
1371 Register temp = a2; | 1371 Register temp = a2; |
1372 | 1372 |
1373 Scope* s = scope(); | 1373 Scope* s = scope(); |
1374 while (s != NULL) { | 1374 while (s != NULL) { |
1375 if (s->num_heap_slots() > 0) { | 1375 if (s->num_heap_slots() > 0) { |
1376 if (s->calls_sloppy_eval()) { | 1376 if (s->calls_sloppy_eval()) { |
1377 // Check that extension is NULL. | 1377 // Check that extension is NULL. |
(...skipping 25 matching lines...) Expand all Loading... |
1403 __ lw(temp, ContextOperand(next, Context::EXTENSION_INDEX)); | 1403 __ lw(temp, ContextOperand(next, Context::EXTENSION_INDEX)); |
1404 __ Branch(slow, ne, temp, Operand(zero_reg)); | 1404 __ Branch(slow, ne, temp, Operand(zero_reg)); |
1405 // Load next context in chain. | 1405 // Load next context in chain. |
1406 __ lw(next, ContextOperand(next, Context::PREVIOUS_INDEX)); | 1406 __ lw(next, ContextOperand(next, Context::PREVIOUS_INDEX)); |
1407 __ Branch(&loop); | 1407 __ Branch(&loop); |
1408 __ bind(&fast); | 1408 __ bind(&fast); |
1409 } | 1409 } |
1410 | 1410 |
1411 // All extension objects were empty and it is safe to use a normal global | 1411 // All extension objects were empty and it is safe to use a normal global |
1412 // load machinery. | 1412 // load machinery. |
1413 EmitGlobalVariableLoad(proxy, typeof_state); | 1413 EmitGlobalVariableLoad(proxy, typeof_mode); |
1414 } | 1414 } |
1415 | 1415 |
1416 | 1416 |
1417 MemOperand FullCodeGenerator::ContextSlotOperandCheckExtensions(Variable* var, | 1417 MemOperand FullCodeGenerator::ContextSlotOperandCheckExtensions(Variable* var, |
1418 Label* slow) { | 1418 Label* slow) { |
1419 DCHECK(var->IsContextSlot()); | 1419 DCHECK(var->IsContextSlot()); |
1420 Register context = cp; | 1420 Register context = cp; |
1421 Register next = a3; | 1421 Register next = a3; |
1422 Register temp = t0; | 1422 Register temp = t0; |
1423 | 1423 |
(...skipping 14 matching lines...) Expand all Loading... |
1438 __ Branch(slow, ne, temp, Operand(zero_reg)); | 1438 __ Branch(slow, ne, temp, Operand(zero_reg)); |
1439 | 1439 |
1440 // This function is used only for loads, not stores, so it's safe to | 1440 // This function is used only for loads, not stores, so it's safe to |
1441 // return an cp-based operand (the write barrier cannot be allowed to | 1441 // return an cp-based operand (the write barrier cannot be allowed to |
1442 // destroy the cp register). | 1442 // destroy the cp register). |
1443 return ContextOperand(context, var->index()); | 1443 return ContextOperand(context, var->index()); |
1444 } | 1444 } |
1445 | 1445 |
1446 | 1446 |
1447 void FullCodeGenerator::EmitDynamicLookupFastCase(VariableProxy* proxy, | 1447 void FullCodeGenerator::EmitDynamicLookupFastCase(VariableProxy* proxy, |
1448 TypeofState typeof_state, | 1448 TypeofMode typeof_mode, |
1449 Label* slow, | 1449 Label* slow, Label* done) { |
1450 Label* done) { | |
1451 // Generate fast-case code for variables that might be shadowed by | 1450 // Generate fast-case code for variables that might be shadowed by |
1452 // eval-introduced variables. Eval is used a lot without | 1451 // eval-introduced variables. Eval is used a lot without |
1453 // introducing variables. In those cases, we do not want to | 1452 // introducing variables. In those cases, we do not want to |
1454 // perform a runtime call for all variables in the scope | 1453 // perform a runtime call for all variables in the scope |
1455 // containing the eval. | 1454 // containing the eval. |
1456 Variable* var = proxy->var(); | 1455 Variable* var = proxy->var(); |
1457 if (var->mode() == DYNAMIC_GLOBAL) { | 1456 if (var->mode() == DYNAMIC_GLOBAL) { |
1458 EmitLoadGlobalCheckExtensions(proxy, typeof_state, slow); | 1457 EmitLoadGlobalCheckExtensions(proxy, typeof_mode, slow); |
1459 __ Branch(done); | 1458 __ Branch(done); |
1460 } else if (var->mode() == DYNAMIC_LOCAL) { | 1459 } else if (var->mode() == DYNAMIC_LOCAL) { |
1461 Variable* local = var->local_if_not_shadowed(); | 1460 Variable* local = var->local_if_not_shadowed(); |
1462 __ lw(v0, ContextSlotOperandCheckExtensions(local, slow)); | 1461 __ lw(v0, ContextSlotOperandCheckExtensions(local, slow)); |
1463 if (local->mode() == LET || local->mode() == CONST || | 1462 if (local->mode() == LET || local->mode() == CONST || |
1464 local->mode() == CONST_LEGACY) { | 1463 local->mode() == CONST_LEGACY) { |
1465 __ LoadRoot(at, Heap::kTheHoleValueRootIndex); | 1464 __ LoadRoot(at, Heap::kTheHoleValueRootIndex); |
1466 __ subu(at, v0, at); // Sub as compare: at == 0 on eq. | 1465 __ subu(at, v0, at); // Sub as compare: at == 0 on eq. |
1467 if (local->mode() == CONST_LEGACY) { | 1466 if (local->mode() == CONST_LEGACY) { |
1468 __ LoadRoot(a0, Heap::kUndefinedValueRootIndex); | 1467 __ LoadRoot(a0, Heap::kUndefinedValueRootIndex); |
1469 __ Movz(v0, a0, at); // Conditional move: return Undefined if TheHole. | 1468 __ Movz(v0, a0, at); // Conditional move: return Undefined if TheHole. |
1470 } else { // LET || CONST | 1469 } else { // LET || CONST |
1471 __ Branch(done, ne, at, Operand(zero_reg)); | 1470 __ Branch(done, ne, at, Operand(zero_reg)); |
1472 __ li(a0, Operand(var->name())); | 1471 __ li(a0, Operand(var->name())); |
1473 __ push(a0); | 1472 __ push(a0); |
1474 __ CallRuntime(Runtime::kThrowReferenceError, 1); | 1473 __ CallRuntime(Runtime::kThrowReferenceError, 1); |
1475 } | 1474 } |
1476 } | 1475 } |
1477 __ Branch(done); | 1476 __ Branch(done); |
1478 } | 1477 } |
1479 } | 1478 } |
1480 | 1479 |
1481 | 1480 |
1482 void FullCodeGenerator::EmitGlobalVariableLoad(VariableProxy* proxy, | 1481 void FullCodeGenerator::EmitGlobalVariableLoad(VariableProxy* proxy, |
1483 TypeofState typeof_state) { | 1482 TypeofMode typeof_mode) { |
1484 Variable* var = proxy->var(); | 1483 Variable* var = proxy->var(); |
1485 DCHECK(var->IsUnallocatedOrGlobalSlot() || | 1484 DCHECK(var->IsUnallocatedOrGlobalSlot() || |
1486 (var->IsLookupSlot() && var->mode() == DYNAMIC_GLOBAL)); | 1485 (var->IsLookupSlot() && var->mode() == DYNAMIC_GLOBAL)); |
1487 if (var->IsGlobalSlot()) { | 1486 if (var->IsGlobalSlot()) { |
1488 DCHECK(var->index() > 0); | 1487 DCHECK(var->index() > 0); |
1489 DCHECK(var->IsStaticGlobalObjectProperty()); | 1488 DCHECK(var->IsStaticGlobalObjectProperty()); |
1490 // Each var occupies two slots in the context: for reads and writes. | 1489 // Each var occupies two slots in the context: for reads and writes. |
1491 int slot_index = var->index(); | 1490 int slot_index = var->index(); |
1492 int depth = scope()->ContextChainLength(var->scope()); | 1491 int depth = scope()->ContextChainLength(var->scope()); |
1493 __ li(LoadGlobalViaContextDescriptor::DepthRegister(), | 1492 __ li(LoadGlobalViaContextDescriptor::DepthRegister(), |
1494 Operand(Smi::FromInt(depth))); | 1493 Operand(Smi::FromInt(depth))); |
1495 __ li(LoadGlobalViaContextDescriptor::SlotRegister(), | 1494 __ li(LoadGlobalViaContextDescriptor::SlotRegister(), |
1496 Operand(Smi::FromInt(slot_index))); | 1495 Operand(Smi::FromInt(slot_index))); |
1497 __ li(LoadGlobalViaContextDescriptor::NameRegister(), Operand(var->name())); | 1496 __ li(LoadGlobalViaContextDescriptor::NameRegister(), Operand(var->name())); |
1498 LoadGlobalViaContextStub stub(isolate(), depth); | 1497 LoadGlobalViaContextStub stub(isolate(), depth); |
1499 __ CallStub(&stub); | 1498 __ CallStub(&stub); |
1500 | 1499 |
1501 } else { | 1500 } else { |
1502 __ lw(LoadDescriptor::ReceiverRegister(), GlobalObjectOperand()); | 1501 __ lw(LoadDescriptor::ReceiverRegister(), GlobalObjectOperand()); |
1503 __ li(LoadDescriptor::NameRegister(), Operand(var->name())); | 1502 __ li(LoadDescriptor::NameRegister(), Operand(var->name())); |
1504 __ li(LoadDescriptor::SlotRegister(), | 1503 __ li(LoadDescriptor::SlotRegister(), |
1505 Operand(SmiFromSlot(proxy->VariableFeedbackSlot()))); | 1504 Operand(SmiFromSlot(proxy->VariableFeedbackSlot()))); |
1506 // Inside typeof use a regular load, not a contextual load, to avoid | 1505 CallLoadIC(typeof_mode); |
1507 // a reference error. | |
1508 CallLoadIC(typeof_state == NOT_INSIDE_TYPEOF ? CONTEXTUAL : NOT_CONTEXTUAL); | |
1509 } | 1506 } |
1510 } | 1507 } |
1511 | 1508 |
1512 | 1509 |
1513 void FullCodeGenerator::EmitVariableLoad(VariableProxy* proxy, | 1510 void FullCodeGenerator::EmitVariableLoad(VariableProxy* proxy, |
1514 TypeofState typeof_state) { | 1511 TypeofMode typeof_mode) { |
1515 // Record position before possible IC call. | 1512 // Record position before possible IC call. |
1516 SetExpressionPosition(proxy); | 1513 SetExpressionPosition(proxy); |
1517 PrepareForBailoutForId(proxy->BeforeId(), NO_REGISTERS); | 1514 PrepareForBailoutForId(proxy->BeforeId(), NO_REGISTERS); |
1518 Variable* var = proxy->var(); | 1515 Variable* var = proxy->var(); |
1519 | 1516 |
1520 // Three cases: global variables, lookup variables, and all other types of | 1517 // Three cases: global variables, lookup variables, and all other types of |
1521 // variables. | 1518 // variables. |
1522 switch (var->location()) { | 1519 switch (var->location()) { |
1523 case VariableLocation::GLOBAL: | 1520 case VariableLocation::GLOBAL: |
1524 case VariableLocation::UNALLOCATED: { | 1521 case VariableLocation::UNALLOCATED: { |
1525 Comment cmnt(masm_, "[ Global variable"); | 1522 Comment cmnt(masm_, "[ Global variable"); |
1526 EmitGlobalVariableLoad(proxy, typeof_state); | 1523 EmitGlobalVariableLoad(proxy, typeof_mode); |
1527 context()->Plug(v0); | 1524 context()->Plug(v0); |
1528 break; | 1525 break; |
1529 } | 1526 } |
1530 | 1527 |
1531 case VariableLocation::PARAMETER: | 1528 case VariableLocation::PARAMETER: |
1532 case VariableLocation::LOCAL: | 1529 case VariableLocation::LOCAL: |
1533 case VariableLocation::CONTEXT: { | 1530 case VariableLocation::CONTEXT: { |
1534 DCHECK_EQ(NOT_INSIDE_TYPEOF, typeof_state); | 1531 DCHECK_EQ(NOT_INSIDE_TYPEOF, typeof_mode); |
1535 Comment cmnt(masm_, var->IsContextSlot() ? "[ Context variable" | 1532 Comment cmnt(masm_, var->IsContextSlot() ? "[ Context variable" |
1536 : "[ Stack variable"); | 1533 : "[ Stack variable"); |
1537 if (var->binding_needs_init()) { | 1534 if (var->binding_needs_init()) { |
1538 // var->scope() may be NULL when the proxy is located in eval code and | 1535 // var->scope() may be NULL when the proxy is located in eval code and |
1539 // refers to a potential outside binding. Currently those bindings are | 1536 // refers to a potential outside binding. Currently those bindings are |
1540 // always looked up dynamically, i.e. in that case | 1537 // always looked up dynamically, i.e. in that case |
1541 // var->location() == LOOKUP. | 1538 // var->location() == LOOKUP. |
1542 // always holds. | 1539 // always holds. |
1543 DCHECK(var->scope() != NULL); | 1540 DCHECK(var->scope() != NULL); |
1544 | 1541 |
(...skipping 55 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1600 } | 1597 } |
1601 context()->Plug(var); | 1598 context()->Plug(var); |
1602 break; | 1599 break; |
1603 } | 1600 } |
1604 | 1601 |
1605 case VariableLocation::LOOKUP: { | 1602 case VariableLocation::LOOKUP: { |
1606 Comment cmnt(masm_, "[ Lookup variable"); | 1603 Comment cmnt(masm_, "[ Lookup variable"); |
1607 Label done, slow; | 1604 Label done, slow; |
1608 // Generate code for loading from variables potentially shadowed | 1605 // Generate code for loading from variables potentially shadowed |
1609 // by eval-introduced variables. | 1606 // by eval-introduced variables. |
1610 EmitDynamicLookupFastCase(proxy, typeof_state, &slow, &done); | 1607 EmitDynamicLookupFastCase(proxy, typeof_mode, &slow, &done); |
1611 __ bind(&slow); | 1608 __ bind(&slow); |
1612 __ li(a1, Operand(var->name())); | 1609 __ li(a1, Operand(var->name())); |
1613 __ Push(cp, a1); // Context and name. | 1610 __ Push(cp, a1); // Context and name. |
1614 Runtime::FunctionId function_id = | 1611 Runtime::FunctionId function_id = |
1615 typeof_state == NOT_INSIDE_TYPEOF | 1612 typeof_mode == NOT_INSIDE_TYPEOF |
1616 ? Runtime::kLoadLookupSlot | 1613 ? Runtime::kLoadLookupSlot |
1617 : Runtime::kLoadLookupSlotNoReferenceError; | 1614 : Runtime::kLoadLookupSlotNoReferenceError; |
1618 __ CallRuntime(function_id, 2); | 1615 __ CallRuntime(function_id, 2); |
1619 __ bind(&done); | 1616 __ bind(&done); |
1620 context()->Plug(v0); | 1617 context()->Plug(v0); |
1621 } | 1618 } |
1622 } | 1619 } |
1623 } | 1620 } |
1624 | 1621 |
1625 | 1622 |
(...skipping 663 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2289 __ lw(cp, MemOperand(fp, StandardFrameConstants::kContextOffset)); | 2286 __ lw(cp, MemOperand(fp, StandardFrameConstants::kContextOffset)); |
2290 __ Drop(1); // The function is still on the stack; drop it. | 2287 __ Drop(1); // The function is still on the stack; drop it. |
2291 | 2288 |
2292 // if (!result.done) goto l_try; | 2289 // if (!result.done) goto l_try; |
2293 __ Move(load_receiver, v0); | 2290 __ Move(load_receiver, v0); |
2294 | 2291 |
2295 __ push(load_receiver); // save result | 2292 __ push(load_receiver); // save result |
2296 __ LoadRoot(load_name, Heap::kdone_stringRootIndex); // "done" | 2293 __ LoadRoot(load_name, Heap::kdone_stringRootIndex); // "done" |
2297 __ li(LoadDescriptor::SlotRegister(), | 2294 __ li(LoadDescriptor::SlotRegister(), |
2298 Operand(SmiFromSlot(expr->DoneFeedbackSlot()))); | 2295 Operand(SmiFromSlot(expr->DoneFeedbackSlot()))); |
2299 CallLoadIC(NOT_CONTEXTUAL); // v0=result.done | 2296 CallLoadIC(NOT_INSIDE_TYPEOF); // v0=result.done |
2300 __ mov(a0, v0); | 2297 __ mov(a0, v0); |
2301 Handle<Code> bool_ic = ToBooleanStub::GetUninitialized(isolate()); | 2298 Handle<Code> bool_ic = ToBooleanStub::GetUninitialized(isolate()); |
2302 CallIC(bool_ic); | 2299 CallIC(bool_ic); |
2303 __ Branch(&l_try, eq, v0, Operand(zero_reg)); | 2300 __ Branch(&l_try, eq, v0, Operand(zero_reg)); |
2304 | 2301 |
2305 // result.value | 2302 // result.value |
2306 __ pop(load_receiver); // result | 2303 __ pop(load_receiver); // result |
2307 __ LoadRoot(load_name, Heap::kvalue_stringRootIndex); // "value" | 2304 __ LoadRoot(load_name, Heap::kvalue_stringRootIndex); // "value" |
2308 __ li(LoadDescriptor::SlotRegister(), | 2305 __ li(LoadDescriptor::SlotRegister(), |
2309 Operand(SmiFromSlot(expr->ValueFeedbackSlot()))); | 2306 Operand(SmiFromSlot(expr->ValueFeedbackSlot()))); |
2310 CallLoadIC(NOT_CONTEXTUAL); // v0=result.value | 2307 CallLoadIC(NOT_INSIDE_TYPEOF); // v0=result.value |
2311 context()->DropAndPlug(2, v0); // drop iter and g | 2308 context()->DropAndPlug(2, v0); // drop iter and g |
2312 break; | 2309 break; |
2313 } | 2310 } |
2314 } | 2311 } |
2315 } | 2312 } |
2316 | 2313 |
2317 | 2314 |
2318 void FullCodeGenerator::EmitGeneratorResume(Expression *generator, | 2315 void FullCodeGenerator::EmitGeneratorResume(Expression *generator, |
2319 Expression *value, | 2316 Expression *value, |
2320 JSGeneratorObject::ResumeMode resume_mode) { | 2317 JSGeneratorObject::ResumeMode resume_mode) { |
(...skipping 121 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2442 | 2439 |
2443 | 2440 |
2444 void FullCodeGenerator::EmitNamedPropertyLoad(Property* prop) { | 2441 void FullCodeGenerator::EmitNamedPropertyLoad(Property* prop) { |
2445 SetExpressionPosition(prop); | 2442 SetExpressionPosition(prop); |
2446 Literal* key = prop->key()->AsLiteral(); | 2443 Literal* key = prop->key()->AsLiteral(); |
2447 DCHECK(!prop->IsSuperAccess()); | 2444 DCHECK(!prop->IsSuperAccess()); |
2448 | 2445 |
2449 __ li(LoadDescriptor::NameRegister(), Operand(key->value())); | 2446 __ li(LoadDescriptor::NameRegister(), Operand(key->value())); |
2450 __ li(LoadDescriptor::SlotRegister(), | 2447 __ li(LoadDescriptor::SlotRegister(), |
2451 Operand(SmiFromSlot(prop->PropertyFeedbackSlot()))); | 2448 Operand(SmiFromSlot(prop->PropertyFeedbackSlot()))); |
2452 CallLoadIC(NOT_CONTEXTUAL, language_mode()); | 2449 CallLoadIC(NOT_INSIDE_TYPEOF, language_mode()); |
2453 } | 2450 } |
2454 | 2451 |
2455 | 2452 |
2456 void FullCodeGenerator::EmitNamedSuperPropertyLoad(Property* prop) { | 2453 void FullCodeGenerator::EmitNamedSuperPropertyLoad(Property* prop) { |
2457 // Stack: receiver, home_object. | 2454 // Stack: receiver, home_object. |
2458 SetExpressionPosition(prop); | 2455 SetExpressionPosition(prop); |
2459 | 2456 |
2460 Literal* key = prop->key()->AsLiteral(); | 2457 Literal* key = prop->key()->AsLiteral(); |
2461 DCHECK(!key->value()->IsSmi()); | 2458 DCHECK(!key->value()->IsSmi()); |
2462 DCHECK(prop->IsSuperAccess()); | 2459 DCHECK(prop->IsSuperAccess()); |
(...skipping 2307 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4770 // Push the builtins object as the receiver. | 4767 // Push the builtins object as the receiver. |
4771 Register receiver = LoadDescriptor::ReceiverRegister(); | 4768 Register receiver = LoadDescriptor::ReceiverRegister(); |
4772 __ lw(receiver, GlobalObjectOperand()); | 4769 __ lw(receiver, GlobalObjectOperand()); |
4773 __ lw(receiver, FieldMemOperand(receiver, GlobalObject::kBuiltinsOffset)); | 4770 __ lw(receiver, FieldMemOperand(receiver, GlobalObject::kBuiltinsOffset)); |
4774 __ push(receiver); | 4771 __ push(receiver); |
4775 | 4772 |
4776 // Load the function from the receiver. | 4773 // Load the function from the receiver. |
4777 __ li(LoadDescriptor::NameRegister(), Operand(expr->name())); | 4774 __ li(LoadDescriptor::NameRegister(), Operand(expr->name())); |
4778 __ li(LoadDescriptor::SlotRegister(), | 4775 __ li(LoadDescriptor::SlotRegister(), |
4779 Operand(SmiFromSlot(expr->CallRuntimeFeedbackSlot()))); | 4776 Operand(SmiFromSlot(expr->CallRuntimeFeedbackSlot()))); |
4780 CallLoadIC(NOT_CONTEXTUAL); | 4777 CallLoadIC(NOT_INSIDE_TYPEOF); |
4781 } | 4778 } |
4782 | 4779 |
4783 | 4780 |
4784 void FullCodeGenerator::EmitCallJSRuntimeFunction(CallRuntime* expr) { | 4781 void FullCodeGenerator::EmitCallJSRuntimeFunction(CallRuntime* expr) { |
4785 ZoneList<Expression*>* args = expr->arguments(); | 4782 ZoneList<Expression*>* args = expr->arguments(); |
4786 int arg_count = args->length(); | 4783 int arg_count = args->length(); |
4787 | 4784 |
4788 SetCallPosition(expr, arg_count); | 4785 SetCallPosition(expr, arg_count); |
4789 CallFunctionStub stub(isolate(), arg_count, NO_CALL_FUNCTION_FLAGS); | 4786 CallFunctionStub stub(isolate(), arg_count, NO_CALL_FUNCTION_FLAGS); |
4790 __ lw(a1, MemOperand(sp, (arg_count + 1) * kPointerSize)); | 4787 __ lw(a1, MemOperand(sp, (arg_count + 1) * kPointerSize)); |
(...skipping 793 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5584 reinterpret_cast<uint32_t>( | 5581 reinterpret_cast<uint32_t>( |
5585 isolate->builtins()->OsrAfterStackCheck()->entry())); | 5582 isolate->builtins()->OsrAfterStackCheck()->entry())); |
5586 return OSR_AFTER_STACK_CHECK; | 5583 return OSR_AFTER_STACK_CHECK; |
5587 } | 5584 } |
5588 | 5585 |
5589 | 5586 |
5590 } // namespace internal | 5587 } // namespace internal |
5591 } // namespace v8 | 5588 } // namespace v8 |
5592 | 5589 |
5593 #endif // V8_TARGET_ARCH_MIPS | 5590 #endif // V8_TARGET_ARCH_MIPS |
OLD | NEW |