OLD | NEW |
1 // Copyright 2013 the V8 project authors. All rights reserved. | 1 // Copyright 2013 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_ARM64 | 7 #if V8_TARGET_ARCH_ARM64 |
8 | 8 |
9 #include "src/code-factory.h" | 9 #include "src/code-factory.h" |
10 #include "src/code-stubs.h" | 10 #include "src/code-stubs.h" |
(...skipping 1339 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1350 __ Mov(StoreDescriptor::NameRegister(), | 1350 __ Mov(StoreDescriptor::NameRegister(), |
1351 Operand(isolate()->factory()->home_object_symbol())); | 1351 Operand(isolate()->factory()->home_object_symbol())); |
1352 __ Peek(StoreDescriptor::ValueRegister(), offset * kPointerSize); | 1352 __ Peek(StoreDescriptor::ValueRegister(), offset * kPointerSize); |
1353 if (FLAG_vector_stores) EmitLoadStoreICSlot(slot); | 1353 if (FLAG_vector_stores) EmitLoadStoreICSlot(slot); |
1354 CallStoreIC(); | 1354 CallStoreIC(); |
1355 } | 1355 } |
1356 } | 1356 } |
1357 | 1357 |
1358 | 1358 |
1359 void FullCodeGenerator::EmitLoadGlobalCheckExtensions(VariableProxy* proxy, | 1359 void FullCodeGenerator::EmitLoadGlobalCheckExtensions(VariableProxy* proxy, |
1360 TypeofState typeof_state, | 1360 TypeofMode typeof_mode, |
1361 Label* slow) { | 1361 Label* slow) { |
1362 Register current = cp; | 1362 Register current = cp; |
1363 Register next = x10; | 1363 Register next = x10; |
1364 Register temp = x11; | 1364 Register temp = x11; |
1365 | 1365 |
1366 Scope* s = scope(); | 1366 Scope* s = scope(); |
1367 while (s != NULL) { | 1367 while (s != NULL) { |
1368 if (s->num_heap_slots() > 0) { | 1368 if (s->num_heap_slots() > 0) { |
1369 if (s->calls_sloppy_eval()) { | 1369 if (s->calls_sloppy_eval()) { |
1370 // Check that extension is NULL. | 1370 // Check that extension is NULL. |
(...skipping 23 matching lines...) Expand all Loading... |
1394 __ Ldr(temp, ContextMemOperand(next, Context::EXTENSION_INDEX)); | 1394 __ Ldr(temp, ContextMemOperand(next, Context::EXTENSION_INDEX)); |
1395 __ Cbnz(temp, slow); | 1395 __ Cbnz(temp, slow); |
1396 // Load next context in chain. | 1396 // Load next context in chain. |
1397 __ Ldr(next, ContextMemOperand(next, Context::PREVIOUS_INDEX)); | 1397 __ Ldr(next, ContextMemOperand(next, Context::PREVIOUS_INDEX)); |
1398 __ B(&loop); | 1398 __ B(&loop); |
1399 __ Bind(&fast); | 1399 __ Bind(&fast); |
1400 } | 1400 } |
1401 | 1401 |
1402 // All extension objects were empty and it is safe to use a normal global | 1402 // All extension objects were empty and it is safe to use a normal global |
1403 // load machinery. | 1403 // load machinery. |
1404 EmitGlobalVariableLoad(proxy, typeof_state); | 1404 EmitGlobalVariableLoad(proxy, typeof_mode); |
1405 } | 1405 } |
1406 | 1406 |
1407 | 1407 |
1408 MemOperand FullCodeGenerator::ContextSlotOperandCheckExtensions(Variable* var, | 1408 MemOperand FullCodeGenerator::ContextSlotOperandCheckExtensions(Variable* var, |
1409 Label* slow) { | 1409 Label* slow) { |
1410 DCHECK(var->IsContextSlot()); | 1410 DCHECK(var->IsContextSlot()); |
1411 Register context = cp; | 1411 Register context = cp; |
1412 Register next = x10; | 1412 Register next = x10; |
1413 Register temp = x11; | 1413 Register temp = x11; |
1414 | 1414 |
(...skipping 14 matching lines...) Expand all Loading... |
1429 __ Cbnz(temp, slow); | 1429 __ Cbnz(temp, slow); |
1430 | 1430 |
1431 // This function is used only for loads, not stores, so it's safe to | 1431 // This function is used only for loads, not stores, so it's safe to |
1432 // return an cp-based operand (the write barrier cannot be allowed to | 1432 // return an cp-based operand (the write barrier cannot be allowed to |
1433 // destroy the cp register). | 1433 // destroy the cp register). |
1434 return ContextMemOperand(context, var->index()); | 1434 return ContextMemOperand(context, var->index()); |
1435 } | 1435 } |
1436 | 1436 |
1437 | 1437 |
1438 void FullCodeGenerator::EmitDynamicLookupFastCase(VariableProxy* proxy, | 1438 void FullCodeGenerator::EmitDynamicLookupFastCase(VariableProxy* proxy, |
1439 TypeofState typeof_state, | 1439 TypeofMode typeof_mode, |
1440 Label* slow, | 1440 Label* slow, Label* done) { |
1441 Label* done) { | |
1442 // Generate fast-case code for variables that might be shadowed by | 1441 // Generate fast-case code for variables that might be shadowed by |
1443 // eval-introduced variables. Eval is used a lot without | 1442 // eval-introduced variables. Eval is used a lot without |
1444 // introducing variables. In those cases, we do not want to | 1443 // introducing variables. In those cases, we do not want to |
1445 // perform a runtime call for all variables in the scope | 1444 // perform a runtime call for all variables in the scope |
1446 // containing the eval. | 1445 // containing the eval. |
1447 Variable* var = proxy->var(); | 1446 Variable* var = proxy->var(); |
1448 if (var->mode() == DYNAMIC_GLOBAL) { | 1447 if (var->mode() == DYNAMIC_GLOBAL) { |
1449 EmitLoadGlobalCheckExtensions(proxy, typeof_state, slow); | 1448 EmitLoadGlobalCheckExtensions(proxy, typeof_mode, slow); |
1450 __ B(done); | 1449 __ B(done); |
1451 } else if (var->mode() == DYNAMIC_LOCAL) { | 1450 } else if (var->mode() == DYNAMIC_LOCAL) { |
1452 Variable* local = var->local_if_not_shadowed(); | 1451 Variable* local = var->local_if_not_shadowed(); |
1453 __ Ldr(x0, ContextSlotOperandCheckExtensions(local, slow)); | 1452 __ Ldr(x0, ContextSlotOperandCheckExtensions(local, slow)); |
1454 if (local->mode() == LET || local->mode() == CONST || | 1453 if (local->mode() == LET || local->mode() == CONST || |
1455 local->mode() == CONST_LEGACY) { | 1454 local->mode() == CONST_LEGACY) { |
1456 __ JumpIfNotRoot(x0, Heap::kTheHoleValueRootIndex, done); | 1455 __ JumpIfNotRoot(x0, Heap::kTheHoleValueRootIndex, done); |
1457 if (local->mode() == CONST_LEGACY) { | 1456 if (local->mode() == CONST_LEGACY) { |
1458 __ LoadRoot(x0, Heap::kUndefinedValueRootIndex); | 1457 __ LoadRoot(x0, Heap::kUndefinedValueRootIndex); |
1459 } else { // LET || CONST | 1458 } else { // LET || CONST |
1460 __ Mov(x0, Operand(var->name())); | 1459 __ Mov(x0, Operand(var->name())); |
1461 __ Push(x0); | 1460 __ Push(x0); |
1462 __ CallRuntime(Runtime::kThrowReferenceError, 1); | 1461 __ CallRuntime(Runtime::kThrowReferenceError, 1); |
1463 } | 1462 } |
1464 } | 1463 } |
1465 __ B(done); | 1464 __ B(done); |
1466 } | 1465 } |
1467 } | 1466 } |
1468 | 1467 |
1469 | 1468 |
1470 void FullCodeGenerator::EmitGlobalVariableLoad(VariableProxy* proxy, | 1469 void FullCodeGenerator::EmitGlobalVariableLoad(VariableProxy* proxy, |
1471 TypeofState typeof_state) { | 1470 TypeofMode typeof_mode) { |
1472 Variable* var = proxy->var(); | 1471 Variable* var = proxy->var(); |
1473 DCHECK(var->IsUnallocatedOrGlobalSlot() || | 1472 DCHECK(var->IsUnallocatedOrGlobalSlot() || |
1474 (var->IsLookupSlot() && var->mode() == DYNAMIC_GLOBAL)); | 1473 (var->IsLookupSlot() && var->mode() == DYNAMIC_GLOBAL)); |
1475 if (var->IsGlobalSlot()) { | 1474 if (var->IsGlobalSlot()) { |
1476 DCHECK(var->index() > 0); | 1475 DCHECK(var->index() > 0); |
1477 DCHECK(var->IsStaticGlobalObjectProperty()); | 1476 DCHECK(var->IsStaticGlobalObjectProperty()); |
1478 // Each var occupies two slots in the context: for reads and writes. | 1477 // Each var occupies two slots in the context: for reads and writes. |
1479 int slot_index = var->index(); | 1478 int slot_index = var->index(); |
1480 int depth = scope()->ContextChainLength(var->scope()); | 1479 int depth = scope()->ContextChainLength(var->scope()); |
1481 __ Mov(LoadGlobalViaContextDescriptor::DepthRegister(), | 1480 __ Mov(LoadGlobalViaContextDescriptor::DepthRegister(), |
1482 Operand(Smi::FromInt(depth))); | 1481 Operand(Smi::FromInt(depth))); |
1483 __ Mov(LoadGlobalViaContextDescriptor::SlotRegister(), | 1482 __ Mov(LoadGlobalViaContextDescriptor::SlotRegister(), |
1484 Operand(Smi::FromInt(slot_index))); | 1483 Operand(Smi::FromInt(slot_index))); |
1485 __ Mov(LoadGlobalViaContextDescriptor::NameRegister(), | 1484 __ Mov(LoadGlobalViaContextDescriptor::NameRegister(), |
1486 Operand(var->name())); | 1485 Operand(var->name())); |
1487 LoadGlobalViaContextStub stub(isolate(), depth); | 1486 LoadGlobalViaContextStub stub(isolate(), depth); |
1488 __ CallStub(&stub); | 1487 __ CallStub(&stub); |
1489 | 1488 |
1490 } else { | 1489 } else { |
1491 __ Ldr(LoadDescriptor::ReceiverRegister(), GlobalObjectMemOperand()); | 1490 __ Ldr(LoadDescriptor::ReceiverRegister(), GlobalObjectMemOperand()); |
1492 __ Mov(LoadDescriptor::NameRegister(), Operand(var->name())); | 1491 __ Mov(LoadDescriptor::NameRegister(), Operand(var->name())); |
1493 __ Mov(LoadDescriptor::SlotRegister(), | 1492 __ Mov(LoadDescriptor::SlotRegister(), |
1494 SmiFromSlot(proxy->VariableFeedbackSlot())); | 1493 SmiFromSlot(proxy->VariableFeedbackSlot())); |
1495 // Inside typeof use a regular load, not a contextual load, to avoid | 1494 CallLoadIC(typeof_mode); |
1496 // a reference error. | |
1497 CallLoadIC(typeof_state == NOT_INSIDE_TYPEOF ? CONTEXTUAL : NOT_CONTEXTUAL); | |
1498 } | 1495 } |
1499 } | 1496 } |
1500 | 1497 |
1501 | 1498 |
1502 void FullCodeGenerator::EmitVariableLoad(VariableProxy* proxy, | 1499 void FullCodeGenerator::EmitVariableLoad(VariableProxy* proxy, |
1503 TypeofState typeof_state) { | 1500 TypeofMode typeof_mode) { |
1504 // Record position before possible IC call. | 1501 // Record position before possible IC call. |
1505 SetExpressionPosition(proxy); | 1502 SetExpressionPosition(proxy); |
1506 PrepareForBailoutForId(proxy->BeforeId(), NO_REGISTERS); | 1503 PrepareForBailoutForId(proxy->BeforeId(), NO_REGISTERS); |
1507 Variable* var = proxy->var(); | 1504 Variable* var = proxy->var(); |
1508 | 1505 |
1509 // Three cases: global variables, lookup variables, and all other types of | 1506 // Three cases: global variables, lookup variables, and all other types of |
1510 // variables. | 1507 // variables. |
1511 switch (var->location()) { | 1508 switch (var->location()) { |
1512 case VariableLocation::GLOBAL: | 1509 case VariableLocation::GLOBAL: |
1513 case VariableLocation::UNALLOCATED: { | 1510 case VariableLocation::UNALLOCATED: { |
1514 Comment cmnt(masm_, "Global variable"); | 1511 Comment cmnt(masm_, "Global variable"); |
1515 EmitGlobalVariableLoad(proxy, typeof_state); | 1512 EmitGlobalVariableLoad(proxy, typeof_mode); |
1516 context()->Plug(x0); | 1513 context()->Plug(x0); |
1517 break; | 1514 break; |
1518 } | 1515 } |
1519 | 1516 |
1520 case VariableLocation::PARAMETER: | 1517 case VariableLocation::PARAMETER: |
1521 case VariableLocation::LOCAL: | 1518 case VariableLocation::LOCAL: |
1522 case VariableLocation::CONTEXT: { | 1519 case VariableLocation::CONTEXT: { |
1523 DCHECK_EQ(NOT_INSIDE_TYPEOF, typeof_state); | 1520 DCHECK_EQ(NOT_INSIDE_TYPEOF, typeof_mode); |
1524 Comment cmnt(masm_, var->IsContextSlot() | 1521 Comment cmnt(masm_, var->IsContextSlot() |
1525 ? "Context variable" | 1522 ? "Context variable" |
1526 : "Stack variable"); | 1523 : "Stack variable"); |
1527 if (var->binding_needs_init()) { | 1524 if (var->binding_needs_init()) { |
1528 // var->scope() may be NULL when the proxy is located in eval code and | 1525 // var->scope() may be NULL when the proxy is located in eval code and |
1529 // refers to a potential outside binding. Currently those bindings are | 1526 // refers to a potential outside binding. Currently those bindings are |
1530 // always looked up dynamically, i.e. in that case | 1527 // always looked up dynamically, i.e. in that case |
1531 // var->location() == LOOKUP. | 1528 // var->location() == LOOKUP. |
1532 // always holds. | 1529 // always holds. |
1533 DCHECK(var->scope() != NULL); | 1530 DCHECK(var->scope() != NULL); |
(...skipping 53 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1587 } | 1584 } |
1588 } | 1585 } |
1589 context()->Plug(var); | 1586 context()->Plug(var); |
1590 break; | 1587 break; |
1591 } | 1588 } |
1592 | 1589 |
1593 case VariableLocation::LOOKUP: { | 1590 case VariableLocation::LOOKUP: { |
1594 Label done, slow; | 1591 Label done, slow; |
1595 // Generate code for loading from variables potentially shadowed by | 1592 // Generate code for loading from variables potentially shadowed by |
1596 // eval-introduced variables. | 1593 // eval-introduced variables. |
1597 EmitDynamicLookupFastCase(proxy, typeof_state, &slow, &done); | 1594 EmitDynamicLookupFastCase(proxy, typeof_mode, &slow, &done); |
1598 __ Bind(&slow); | 1595 __ Bind(&slow); |
1599 Comment cmnt(masm_, "Lookup variable"); | 1596 Comment cmnt(masm_, "Lookup variable"); |
1600 __ Mov(x1, Operand(var->name())); | 1597 __ Mov(x1, Operand(var->name())); |
1601 __ Push(cp, x1); // Context and name. | 1598 __ Push(cp, x1); // Context and name. |
1602 Runtime::FunctionId function_id = | 1599 Runtime::FunctionId function_id = |
1603 typeof_state == NOT_INSIDE_TYPEOF | 1600 typeof_mode == NOT_INSIDE_TYPEOF |
1604 ? Runtime::kLoadLookupSlot | 1601 ? Runtime::kLoadLookupSlot |
1605 : Runtime::kLoadLookupSlotNoReferenceError; | 1602 : Runtime::kLoadLookupSlotNoReferenceError; |
1606 __ CallRuntime(function_id, 2); | 1603 __ CallRuntime(function_id, 2); |
1607 __ Bind(&done); | 1604 __ Bind(&done); |
1608 context()->Plug(x0); | 1605 context()->Plug(x0); |
1609 break; | 1606 break; |
1610 } | 1607 } |
1611 } | 1608 } |
1612 } | 1609 } |
1613 | 1610 |
(...skipping 516 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2130 | 2127 |
2131 | 2128 |
2132 void FullCodeGenerator::EmitNamedPropertyLoad(Property* prop) { | 2129 void FullCodeGenerator::EmitNamedPropertyLoad(Property* prop) { |
2133 SetExpressionPosition(prop); | 2130 SetExpressionPosition(prop); |
2134 Literal* key = prop->key()->AsLiteral(); | 2131 Literal* key = prop->key()->AsLiteral(); |
2135 DCHECK(!prop->IsSuperAccess()); | 2132 DCHECK(!prop->IsSuperAccess()); |
2136 | 2133 |
2137 __ Mov(LoadDescriptor::NameRegister(), Operand(key->value())); | 2134 __ Mov(LoadDescriptor::NameRegister(), Operand(key->value())); |
2138 __ Mov(LoadDescriptor::SlotRegister(), | 2135 __ Mov(LoadDescriptor::SlotRegister(), |
2139 SmiFromSlot(prop->PropertyFeedbackSlot())); | 2136 SmiFromSlot(prop->PropertyFeedbackSlot())); |
2140 CallLoadIC(NOT_CONTEXTUAL, language_mode()); | 2137 CallLoadIC(NOT_INSIDE_TYPEOF, language_mode()); |
2141 } | 2138 } |
2142 | 2139 |
2143 | 2140 |
2144 void FullCodeGenerator::EmitNamedSuperPropertyLoad(Property* prop) { | 2141 void FullCodeGenerator::EmitNamedSuperPropertyLoad(Property* prop) { |
2145 // Stack: receiver, home_object. | 2142 // Stack: receiver, home_object. |
2146 SetExpressionPosition(prop); | 2143 SetExpressionPosition(prop); |
2147 Literal* key = prop->key()->AsLiteral(); | 2144 Literal* key = prop->key()->AsLiteral(); |
2148 DCHECK(!key->value()->IsSmi()); | 2145 DCHECK(!key->value()->IsSmi()); |
2149 DCHECK(prop->IsSuperAccess()); | 2146 DCHECK(prop->IsSuperAccess()); |
2150 | 2147 |
(...skipping 2293 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4444 __ Ldr(x10, GlobalObjectMemOperand()); | 4441 __ Ldr(x10, GlobalObjectMemOperand()); |
4445 __ Ldr(LoadDescriptor::ReceiverRegister(), | 4442 __ Ldr(LoadDescriptor::ReceiverRegister(), |
4446 FieldMemOperand(x10, GlobalObject::kBuiltinsOffset)); | 4443 FieldMemOperand(x10, GlobalObject::kBuiltinsOffset)); |
4447 __ Push(LoadDescriptor::ReceiverRegister()); | 4444 __ Push(LoadDescriptor::ReceiverRegister()); |
4448 | 4445 |
4449 // Load the function from the receiver. | 4446 // Load the function from the receiver. |
4450 Handle<String> name = expr->name(); | 4447 Handle<String> name = expr->name(); |
4451 __ Mov(LoadDescriptor::NameRegister(), Operand(name)); | 4448 __ Mov(LoadDescriptor::NameRegister(), Operand(name)); |
4452 __ Mov(LoadDescriptor::SlotRegister(), | 4449 __ Mov(LoadDescriptor::SlotRegister(), |
4453 SmiFromSlot(expr->CallRuntimeFeedbackSlot())); | 4450 SmiFromSlot(expr->CallRuntimeFeedbackSlot())); |
4454 CallLoadIC(NOT_CONTEXTUAL); | 4451 CallLoadIC(NOT_INSIDE_TYPEOF); |
4455 } | 4452 } |
4456 | 4453 |
4457 | 4454 |
4458 void FullCodeGenerator::EmitCallJSRuntimeFunction(CallRuntime* expr) { | 4455 void FullCodeGenerator::EmitCallJSRuntimeFunction(CallRuntime* expr) { |
4459 ZoneList<Expression*>* args = expr->arguments(); | 4456 ZoneList<Expression*>* args = expr->arguments(); |
4460 int arg_count = args->length(); | 4457 int arg_count = args->length(); |
4461 | 4458 |
4462 SetCallPosition(expr, arg_count); | 4459 SetCallPosition(expr, arg_count); |
4463 CallFunctionStub stub(isolate(), arg_count, NO_CALL_FUNCTION_FLAGS); | 4460 CallFunctionStub stub(isolate(), arg_count, NO_CALL_FUNCTION_FLAGS); |
4464 __ Peek(x1, (arg_count + 1) * kPointerSize); | 4461 __ Peek(x1, (arg_count + 1) * kPointerSize); |
(...skipping 764 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5229 __ Drop(1); // The function is still on the stack; drop it. | 5226 __ Drop(1); // The function is still on the stack; drop it. |
5230 | 5227 |
5231 // if (!result.done) goto l_try; | 5228 // if (!result.done) goto l_try; |
5232 __ Bind(&l_loop); | 5229 __ Bind(&l_loop); |
5233 __ Move(load_receiver, x0); | 5230 __ Move(load_receiver, x0); |
5234 | 5231 |
5235 __ Push(load_receiver); // save result | 5232 __ Push(load_receiver); // save result |
5236 __ LoadRoot(load_name, Heap::kdone_stringRootIndex); // "done" | 5233 __ LoadRoot(load_name, Heap::kdone_stringRootIndex); // "done" |
5237 __ Mov(LoadDescriptor::SlotRegister(), | 5234 __ Mov(LoadDescriptor::SlotRegister(), |
5238 SmiFromSlot(expr->DoneFeedbackSlot())); | 5235 SmiFromSlot(expr->DoneFeedbackSlot())); |
5239 CallLoadIC(NOT_CONTEXTUAL); // x0=result.done | 5236 CallLoadIC(NOT_INSIDE_TYPEOF); // x0=result.done |
5240 // The ToBooleanStub argument (result.done) is in x0. | 5237 // The ToBooleanStub argument (result.done) is in x0. |
5241 Handle<Code> bool_ic = ToBooleanStub::GetUninitialized(isolate()); | 5238 Handle<Code> bool_ic = ToBooleanStub::GetUninitialized(isolate()); |
5242 CallIC(bool_ic); | 5239 CallIC(bool_ic); |
5243 __ Cbz(x0, &l_try); | 5240 __ Cbz(x0, &l_try); |
5244 | 5241 |
5245 // result.value | 5242 // result.value |
5246 __ Pop(load_receiver); // result | 5243 __ Pop(load_receiver); // result |
5247 __ LoadRoot(load_name, Heap::kvalue_stringRootIndex); // "value" | 5244 __ LoadRoot(load_name, Heap::kvalue_stringRootIndex); // "value" |
5248 __ Mov(LoadDescriptor::SlotRegister(), | 5245 __ Mov(LoadDescriptor::SlotRegister(), |
5249 SmiFromSlot(expr->ValueFeedbackSlot())); | 5246 SmiFromSlot(expr->ValueFeedbackSlot())); |
5250 CallLoadIC(NOT_CONTEXTUAL); // x0=result.value | 5247 CallLoadIC(NOT_INSIDE_TYPEOF); // x0=result.value |
5251 context()->DropAndPlug(2, x0); // drop iter and g | 5248 context()->DropAndPlug(2, x0); // drop iter and g |
5252 break; | 5249 break; |
5253 } | 5250 } |
5254 } | 5251 } |
5255 } | 5252 } |
5256 | 5253 |
5257 | 5254 |
5258 void FullCodeGenerator::EmitGeneratorResume(Expression *generator, | 5255 void FullCodeGenerator::EmitGeneratorResume(Expression *generator, |
5259 Expression *value, | 5256 Expression *value, |
5260 JSGeneratorObject::ResumeMode resume_mode) { | 5257 JSGeneratorObject::ResumeMode resume_mode) { |
(...skipping 344 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5605 } | 5602 } |
5606 | 5603 |
5607 return INTERRUPT; | 5604 return INTERRUPT; |
5608 } | 5605 } |
5609 | 5606 |
5610 | 5607 |
5611 } // namespace internal | 5608 } // namespace internal |
5612 } // namespace v8 | 5609 } // namespace v8 |
5613 | 5610 |
5614 #endif // V8_TARGET_ARCH_ARM64 | 5611 #endif // V8_TARGET_ARCH_ARM64 |
OLD | NEW |