Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(128)

Side by Side Diff: src/mips64/full-codegen-mips64.cc

Issue 538573002: MIPS: Make concrete classes for individual call descriptors. - internal (Closed) Base URL: https://v8.googlecode.com/svn/branches/bleeding_edge
Patch Set: mips64 port added. Created 6 years, 3 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
« no previous file with comments | « src/mips64/debug-mips64.cc ('k') | src/mips64/interface-descriptors-mips64.cc » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
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_MIPS64 7 #if V8_TARGET_ARCH_MIPS64
8 8
9 // Note on Mips implementation: 9 // Note on Mips implementation:
10 // 10 //
(...skipping 1363 matching lines...) Expand 10 before | Expand all | Expand 10 after
1374 __ Branch(&fast, eq, temp, Operand(a4)); 1374 __ Branch(&fast, eq, temp, Operand(a4));
1375 // Check that extension is NULL. 1375 // Check that extension is NULL.
1376 __ ld(temp, ContextOperand(next, Context::EXTENSION_INDEX)); 1376 __ ld(temp, ContextOperand(next, Context::EXTENSION_INDEX));
1377 __ Branch(slow, ne, temp, Operand(zero_reg)); 1377 __ Branch(slow, ne, temp, Operand(zero_reg));
1378 // Load next context in chain. 1378 // Load next context in chain.
1379 __ ld(next, ContextOperand(next, Context::PREVIOUS_INDEX)); 1379 __ ld(next, ContextOperand(next, Context::PREVIOUS_INDEX));
1380 __ Branch(&loop); 1380 __ Branch(&loop);
1381 __ bind(&fast); 1381 __ bind(&fast);
1382 } 1382 }
1383 1383
1384 __ ld(LoadConvention::ReceiverRegister(), GlobalObjectOperand()); 1384 __ ld(LoadDescriptor::ReceiverRegister(), GlobalObjectOperand());
1385 __ li(LoadConvention::NameRegister(), Operand(proxy->var()->name())); 1385 __ li(LoadDescriptor::NameRegister(), Operand(proxy->var()->name()));
1386 if (FLAG_vector_ics) { 1386 if (FLAG_vector_ics) {
1387 __ li(VectorLoadConvention::SlotRegister(), 1387 __ li(VectorLoadICDescriptor::SlotRegister(),
1388 Operand(Smi::FromInt(proxy->VariableFeedbackSlot()))); 1388 Operand(Smi::FromInt(proxy->VariableFeedbackSlot())));
1389 } 1389 }
1390 1390
1391 ContextualMode mode = (typeof_state == INSIDE_TYPEOF) 1391 ContextualMode mode = (typeof_state == INSIDE_TYPEOF)
1392 ? NOT_CONTEXTUAL 1392 ? NOT_CONTEXTUAL
1393 : CONTEXTUAL; 1393 : CONTEXTUAL;
1394 CallLoadIC(mode); 1394 CallLoadIC(mode);
1395 } 1395 }
1396 1396
1397 1397
(...skipping 67 matching lines...) Expand 10 before | Expand all | Expand 10 after
1465 SetSourcePosition(proxy->position()); 1465 SetSourcePosition(proxy->position());
1466 Variable* var = proxy->var(); 1466 Variable* var = proxy->var();
1467 1467
1468 // Three cases: global variables, lookup variables, and all other types of 1468 // Three cases: global variables, lookup variables, and all other types of
1469 // variables. 1469 // variables.
1470 switch (var->location()) { 1470 switch (var->location()) {
1471 case Variable::UNALLOCATED: { 1471 case Variable::UNALLOCATED: {
1472 Comment cmnt(masm_, "[ Global variable"); 1472 Comment cmnt(masm_, "[ Global variable");
1473 // Use inline caching. Variable name is passed in a2 and the global 1473 // Use inline caching. Variable name is passed in a2 and the global
1474 // object (receiver) in a0. 1474 // object (receiver) in a0.
1475 __ ld(LoadConvention::ReceiverRegister(), GlobalObjectOperand()); 1475 __ ld(LoadDescriptor::ReceiverRegister(), GlobalObjectOperand());
1476 __ li(LoadConvention::NameRegister(), Operand(var->name())); 1476 __ li(LoadDescriptor::NameRegister(), Operand(var->name()));
1477 if (FLAG_vector_ics) { 1477 if (FLAG_vector_ics) {
1478 __ li(VectorLoadConvention::SlotRegister(), 1478 __ li(VectorLoadICDescriptor::SlotRegister(),
1479 Operand(Smi::FromInt(proxy->VariableFeedbackSlot()))); 1479 Operand(Smi::FromInt(proxy->VariableFeedbackSlot())));
1480 } 1480 }
1481 CallLoadIC(CONTEXTUAL); 1481 CallLoadIC(CONTEXTUAL);
1482 context()->Plug(v0); 1482 context()->Plug(v0);
1483 break; 1483 break;
1484 } 1484 }
1485 1485
1486 case Variable::PARAMETER: 1486 case Variable::PARAMETER:
1487 case Variable::LOCAL: 1487 case Variable::LOCAL:
1488 case Variable::CONTEXT: { 1488 case Variable::CONTEXT: {
(...skipping 189 matching lines...) Expand 10 before | Expand all | Expand 10 after
1678 switch (property->kind()) { 1678 switch (property->kind()) {
1679 case ObjectLiteral::Property::CONSTANT: 1679 case ObjectLiteral::Property::CONSTANT:
1680 UNREACHABLE(); 1680 UNREACHABLE();
1681 case ObjectLiteral::Property::MATERIALIZED_LITERAL: 1681 case ObjectLiteral::Property::MATERIALIZED_LITERAL:
1682 DCHECK(!CompileTimeValue::IsCompileTimeValue(property->value())); 1682 DCHECK(!CompileTimeValue::IsCompileTimeValue(property->value()));
1683 // Fall through. 1683 // Fall through.
1684 case ObjectLiteral::Property::COMPUTED: 1684 case ObjectLiteral::Property::COMPUTED:
1685 if (key->value()->IsInternalizedString()) { 1685 if (key->value()->IsInternalizedString()) {
1686 if (property->emit_store()) { 1686 if (property->emit_store()) {
1687 VisitForAccumulatorValue(value); 1687 VisitForAccumulatorValue(value);
1688 __ mov(StoreConvention::ValueRegister(), result_register()); 1688 __ mov(StoreDescriptor::ValueRegister(), result_register());
1689 DCHECK(StoreConvention::ValueRegister().is(a0)); 1689 DCHECK(StoreDescriptor::ValueRegister().is(a0));
1690 __ li(StoreConvention::NameRegister(), Operand(key->value())); 1690 __ li(StoreDescriptor::NameRegister(), Operand(key->value()));
1691 __ ld(StoreConvention::ReceiverRegister(), MemOperand(sp)); 1691 __ ld(StoreDescriptor::ReceiverRegister(), MemOperand(sp));
1692 CallStoreIC(key->LiteralFeedbackId()); 1692 CallStoreIC(key->LiteralFeedbackId());
1693 PrepareForBailoutForId(key->id(), NO_REGISTERS); 1693 PrepareForBailoutForId(key->id(), NO_REGISTERS);
1694 } else { 1694 } else {
1695 VisitForEffect(value); 1695 VisitForEffect(value);
1696 } 1696 }
1697 break; 1697 break;
1698 } 1698 }
1699 // Duplicate receiver on stack. 1699 // Duplicate receiver on stack.
1700 __ ld(a0, MemOperand(sp)); 1700 __ ld(a0, MemOperand(sp));
1701 __ push(a0); 1701 __ push(a0);
(...skipping 161 matching lines...) Expand 10 before | Expand all | Expand 10 after
1863 1863
1864 // Evaluate LHS expression. 1864 // Evaluate LHS expression.
1865 switch (assign_type) { 1865 switch (assign_type) {
1866 case VARIABLE: 1866 case VARIABLE:
1867 // Nothing to do here. 1867 // Nothing to do here.
1868 break; 1868 break;
1869 case NAMED_PROPERTY: 1869 case NAMED_PROPERTY:
1870 if (expr->is_compound()) { 1870 if (expr->is_compound()) {
1871 // We need the receiver both on the stack and in the register. 1871 // We need the receiver both on the stack and in the register.
1872 VisitForStackValue(property->obj()); 1872 VisitForStackValue(property->obj());
1873 __ ld(LoadConvention::ReceiverRegister(), MemOperand(sp, 0)); 1873 __ ld(LoadDescriptor::ReceiverRegister(), MemOperand(sp, 0));
1874 } else { 1874 } else {
1875 VisitForStackValue(property->obj()); 1875 VisitForStackValue(property->obj());
1876 } 1876 }
1877 break; 1877 break;
1878 case KEYED_PROPERTY: 1878 case KEYED_PROPERTY:
1879 // We need the key and receiver on both the stack and in v0 and a1. 1879 // We need the key and receiver on both the stack and in v0 and a1.
1880 if (expr->is_compound()) { 1880 if (expr->is_compound()) {
1881 VisitForStackValue(property->obj()); 1881 VisitForStackValue(property->obj());
1882 VisitForStackValue(property->key()); 1882 VisitForStackValue(property->key());
1883 __ ld(LoadConvention::ReceiverRegister(), 1883 __ ld(LoadDescriptor::ReceiverRegister(),
1884 MemOperand(sp, 1 * kPointerSize)); 1884 MemOperand(sp, 1 * kPointerSize));
1885 __ ld(LoadConvention::NameRegister(), MemOperand(sp, 0)); 1885 __ ld(LoadDescriptor::NameRegister(), MemOperand(sp, 0));
1886 } else { 1886 } else {
1887 VisitForStackValue(property->obj()); 1887 VisitForStackValue(property->obj());
1888 VisitForStackValue(property->key()); 1888 VisitForStackValue(property->key());
1889 } 1889 }
1890 break; 1890 break;
1891 } 1891 }
1892 1892
1893 // For compound assignments we need another deoptimization point after the 1893 // For compound assignments we need another deoptimization point after the
1894 // variable/property load. 1894 // variable/property load.
1895 if (expr->is_compound()) { 1895 if (expr->is_compound()) {
(...skipping 117 matching lines...) Expand 10 before | Expand all | Expand 10 after
2013 2013
2014 case Yield::kDelegating: { 2014 case Yield::kDelegating: {
2015 VisitForStackValue(expr->generator_object()); 2015 VisitForStackValue(expr->generator_object());
2016 2016
2017 // Initial stack layout is as follows: 2017 // Initial stack layout is as follows:
2018 // [sp + 1 * kPointerSize] iter 2018 // [sp + 1 * kPointerSize] iter
2019 // [sp + 0 * kPointerSize] g 2019 // [sp + 0 * kPointerSize] g
2020 2020
2021 Label l_catch, l_try, l_suspend, l_continuation, l_resume; 2021 Label l_catch, l_try, l_suspend, l_continuation, l_resume;
2022 Label l_next, l_call; 2022 Label l_next, l_call;
2023 Register load_receiver = LoadConvention::ReceiverRegister(); 2023 Register load_receiver = LoadDescriptor::ReceiverRegister();
2024 Register load_name = LoadConvention::NameRegister(); 2024 Register load_name = LoadDescriptor::NameRegister();
2025 // Initial send value is undefined. 2025 // Initial send value is undefined.
2026 __ LoadRoot(a0, Heap::kUndefinedValueRootIndex); 2026 __ LoadRoot(a0, Heap::kUndefinedValueRootIndex);
2027 __ Branch(&l_next); 2027 __ Branch(&l_next);
2028 2028
2029 // catch (e) { receiver = iter; f = 'throw'; arg = e; goto l_call; } 2029 // catch (e) { receiver = iter; f = 'throw'; arg = e; goto l_call; }
2030 __ bind(&l_catch); 2030 __ bind(&l_catch);
2031 __ mov(a0, v0); 2031 __ mov(a0, v0);
2032 handler_table()->set(expr->index(), Smi::FromInt(l_catch.pos())); 2032 handler_table()->set(expr->index(), Smi::FromInt(l_catch.pos()));
2033 __ LoadRoot(a2, Heap::kthrow_stringRootIndex); // "throw" 2033 __ LoadRoot(a2, Heap::kthrow_stringRootIndex); // "throw"
2034 __ ld(a3, MemOperand(sp, 1 * kPointerSize)); // iter 2034 __ ld(a3, MemOperand(sp, 1 * kPointerSize)); // iter
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after
2070 __ bind(&l_next); 2070 __ bind(&l_next);
2071 __ LoadRoot(load_name, Heap::knext_stringRootIndex); // "next" 2071 __ LoadRoot(load_name, Heap::knext_stringRootIndex); // "next"
2072 __ ld(a3, MemOperand(sp, 1 * kPointerSize)); // iter 2072 __ ld(a3, MemOperand(sp, 1 * kPointerSize)); // iter
2073 __ Push(load_name, a3, a0); // "next", iter, received 2073 __ Push(load_name, a3, a0); // "next", iter, received
2074 2074
2075 // result = receiver[f](arg); 2075 // result = receiver[f](arg);
2076 __ bind(&l_call); 2076 __ bind(&l_call);
2077 __ ld(load_receiver, MemOperand(sp, kPointerSize)); 2077 __ ld(load_receiver, MemOperand(sp, kPointerSize));
2078 __ ld(load_name, MemOperand(sp, 2 * kPointerSize)); 2078 __ ld(load_name, MemOperand(sp, 2 * kPointerSize));
2079 if (FLAG_vector_ics) { 2079 if (FLAG_vector_ics) {
2080 __ li(VectorLoadConvention::SlotRegister(), 2080 __ li(VectorLoadICDescriptor::SlotRegister(),
2081 Operand(Smi::FromInt(expr->KeyedLoadFeedbackSlot()))); 2081 Operand(Smi::FromInt(expr->KeyedLoadFeedbackSlot())));
2082 } 2082 }
2083 Handle<Code> ic = isolate()->builtins()->KeyedLoadIC_Initialize(); 2083 Handle<Code> ic = isolate()->builtins()->KeyedLoadIC_Initialize();
2084 CallIC(ic, TypeFeedbackId::None()); 2084 CallIC(ic, TypeFeedbackId::None());
2085 __ mov(a0, v0); 2085 __ mov(a0, v0);
2086 __ mov(a1, a0); 2086 __ mov(a1, a0);
2087 __ sd(a1, MemOperand(sp, 2 * kPointerSize)); 2087 __ sd(a1, MemOperand(sp, 2 * kPointerSize));
2088 CallFunctionStub stub(isolate(), 1, CALL_AS_METHOD); 2088 CallFunctionStub stub(isolate(), 1, CALL_AS_METHOD);
2089 __ CallStub(&stub); 2089 __ CallStub(&stub);
2090 2090
2091 __ ld(cp, MemOperand(fp, StandardFrameConstants::kContextOffset)); 2091 __ ld(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
2092 __ Drop(1); // The function is still on the stack; drop it. 2092 __ Drop(1); // The function is still on the stack; drop it.
2093 2093
2094 // if (!result.done) goto l_try; 2094 // if (!result.done) goto l_try;
2095 __ Move(load_receiver, v0); 2095 __ Move(load_receiver, v0);
2096 2096
2097 __ push(load_receiver); // save result 2097 __ push(load_receiver); // save result
2098 __ LoadRoot(load_name, Heap::kdone_stringRootIndex); // "done" 2098 __ LoadRoot(load_name, Heap::kdone_stringRootIndex); // "done"
2099 if (FLAG_vector_ics) { 2099 if (FLAG_vector_ics) {
2100 __ li(VectorLoadConvention::SlotRegister(), 2100 __ li(VectorLoadICDescriptor::SlotRegister(),
2101 Operand(Smi::FromInt(expr->DoneFeedbackSlot()))); 2101 Operand(Smi::FromInt(expr->DoneFeedbackSlot())));
2102 } 2102 }
2103 CallLoadIC(NOT_CONTEXTUAL); // v0=result.done 2103 CallLoadIC(NOT_CONTEXTUAL); // v0=result.done
2104 __ mov(a0, v0); 2104 __ mov(a0, v0);
2105 Handle<Code> bool_ic = ToBooleanStub::GetUninitialized(isolate()); 2105 Handle<Code> bool_ic = ToBooleanStub::GetUninitialized(isolate());
2106 CallIC(bool_ic); 2106 CallIC(bool_ic);
2107 __ Branch(&l_try, eq, v0, Operand(zero_reg)); 2107 __ Branch(&l_try, eq, v0, Operand(zero_reg));
2108 2108
2109 // result.value 2109 // result.value
2110 __ pop(load_receiver); // result 2110 __ pop(load_receiver); // result
2111 __ LoadRoot(load_name, Heap::kvalue_stringRootIndex); // "value" 2111 __ LoadRoot(load_name, Heap::kvalue_stringRootIndex); // "value"
2112 if (FLAG_vector_ics) { 2112 if (FLAG_vector_ics) {
2113 __ li(VectorLoadConvention::SlotRegister(), 2113 __ li(VectorLoadICDescriptor::SlotRegister(),
2114 Operand(Smi::FromInt(expr->ValueFeedbackSlot()))); 2114 Operand(Smi::FromInt(expr->ValueFeedbackSlot())));
2115 } 2115 }
2116 CallLoadIC(NOT_CONTEXTUAL); // v0=result.value 2116 CallLoadIC(NOT_CONTEXTUAL); // v0=result.value
2117 context()->DropAndPlug(2, v0); // drop iter and g 2117 context()->DropAndPlug(2, v0); // drop iter and g
2118 break; 2118 break;
2119 } 2119 }
2120 } 2120 }
2121 } 2121 }
2122 2122
2123 2123
(...skipping 146 matching lines...) Expand 10 before | Expand all | Expand 10 after
2270 // Only the value field needs a write barrier, as the other values are in the 2270 // Only the value field needs a write barrier, as the other values are in the
2271 // root set. 2271 // root set.
2272 __ RecordWriteField(v0, JSGeneratorObject::kResultValuePropertyOffset, 2272 __ RecordWriteField(v0, JSGeneratorObject::kResultValuePropertyOffset,
2273 a2, a3, kRAHasBeenSaved, kDontSaveFPRegs); 2273 a2, a3, kRAHasBeenSaved, kDontSaveFPRegs);
2274 } 2274 }
2275 2275
2276 2276
2277 void FullCodeGenerator::EmitNamedPropertyLoad(Property* prop) { 2277 void FullCodeGenerator::EmitNamedPropertyLoad(Property* prop) {
2278 SetSourcePosition(prop->position()); 2278 SetSourcePosition(prop->position());
2279 Literal* key = prop->key()->AsLiteral(); 2279 Literal* key = prop->key()->AsLiteral();
2280 __ li(LoadConvention::NameRegister(), Operand(key->value())); 2280 __ li(LoadDescriptor::NameRegister(), Operand(key->value()));
2281 if (FLAG_vector_ics) { 2281 if (FLAG_vector_ics) {
2282 __ li(VectorLoadConvention::SlotRegister(), 2282 __ li(VectorLoadICDescriptor::SlotRegister(),
2283 Operand(Smi::FromInt(prop->PropertyFeedbackSlot()))); 2283 Operand(Smi::FromInt(prop->PropertyFeedbackSlot())));
2284 CallLoadIC(NOT_CONTEXTUAL); 2284 CallLoadIC(NOT_CONTEXTUAL);
2285 } else { 2285 } else {
2286 CallLoadIC(NOT_CONTEXTUAL, prop->PropertyFeedbackId()); 2286 CallLoadIC(NOT_CONTEXTUAL, prop->PropertyFeedbackId());
2287 } 2287 }
2288 } 2288 }
2289 2289
2290 2290
2291 void FullCodeGenerator::EmitKeyedPropertyLoad(Property* prop) { 2291 void FullCodeGenerator::EmitKeyedPropertyLoad(Property* prop) {
2292 SetSourcePosition(prop->position()); 2292 SetSourcePosition(prop->position());
2293 // Call keyed load IC. It has register arguments receiver and key. 2293 // Call keyed load IC. It has register arguments receiver and key.
2294 Handle<Code> ic = isolate()->builtins()->KeyedLoadIC_Initialize(); 2294 Handle<Code> ic = isolate()->builtins()->KeyedLoadIC_Initialize();
2295 if (FLAG_vector_ics) { 2295 if (FLAG_vector_ics) {
2296 __ li(VectorLoadConvention::SlotRegister(), 2296 __ li(VectorLoadICDescriptor::SlotRegister(),
2297 Operand(Smi::FromInt(prop->PropertyFeedbackSlot()))); 2297 Operand(Smi::FromInt(prop->PropertyFeedbackSlot())));
2298 CallIC(ic); 2298 CallIC(ic);
2299 } else { 2299 } else {
2300 CallIC(ic, prop->PropertyFeedbackId()); 2300 CallIC(ic, prop->PropertyFeedbackId());
2301 } 2301 }
2302 } 2302 }
2303 2303
2304 2304
2305 void FullCodeGenerator::EmitInlineSmiBinaryOp(BinaryOperation* expr, 2305 void FullCodeGenerator::EmitInlineSmiBinaryOp(BinaryOperation* expr,
2306 Token::Value op, 2306 Token::Value op,
(...skipping 117 matching lines...) Expand 10 before | Expand all | Expand 10 after
2424 switch (assign_type) { 2424 switch (assign_type) {
2425 case VARIABLE: { 2425 case VARIABLE: {
2426 Variable* var = expr->AsVariableProxy()->var(); 2426 Variable* var = expr->AsVariableProxy()->var();
2427 EffectContext context(this); 2427 EffectContext context(this);
2428 EmitVariableAssignment(var, Token::ASSIGN); 2428 EmitVariableAssignment(var, Token::ASSIGN);
2429 break; 2429 break;
2430 } 2430 }
2431 case NAMED_PROPERTY: { 2431 case NAMED_PROPERTY: {
2432 __ push(result_register()); // Preserve value. 2432 __ push(result_register()); // Preserve value.
2433 VisitForAccumulatorValue(prop->obj()); 2433 VisitForAccumulatorValue(prop->obj());
2434 __ mov(StoreConvention::ReceiverRegister(), result_register()); 2434 __ mov(StoreDescriptor::ReceiverRegister(), result_register());
2435 __ pop(StoreConvention::ValueRegister()); // Restore value. 2435 __ pop(StoreDescriptor::ValueRegister()); // Restore value.
2436 __ li(StoreConvention::NameRegister(), 2436 __ li(StoreDescriptor::NameRegister(),
2437 Operand(prop->key()->AsLiteral()->value())); 2437 Operand(prop->key()->AsLiteral()->value()));
2438 CallStoreIC(); 2438 CallStoreIC();
2439 break; 2439 break;
2440 } 2440 }
2441 case KEYED_PROPERTY: { 2441 case KEYED_PROPERTY: {
2442 __ push(result_register()); // Preserve value. 2442 __ push(result_register()); // Preserve value.
2443 VisitForStackValue(prop->obj()); 2443 VisitForStackValue(prop->obj());
2444 VisitForAccumulatorValue(prop->key()); 2444 VisitForAccumulatorValue(prop->key());
2445 __ Move(StoreConvention::NameRegister(), result_register()); 2445 __ Move(StoreDescriptor::NameRegister(), result_register());
2446 __ Pop(StoreConvention::ValueRegister(), 2446 __ Pop(StoreDescriptor::ValueRegister(),
2447 StoreConvention::ReceiverRegister()); 2447 StoreDescriptor::ReceiverRegister());
2448 Handle<Code> ic = strict_mode() == SLOPPY 2448 Handle<Code> ic = strict_mode() == SLOPPY
2449 ? isolate()->builtins()->KeyedStoreIC_Initialize() 2449 ? isolate()->builtins()->KeyedStoreIC_Initialize()
2450 : isolate()->builtins()->KeyedStoreIC_Initialize_Strict(); 2450 : isolate()->builtins()->KeyedStoreIC_Initialize_Strict();
2451 CallIC(ic); 2451 CallIC(ic);
2452 break; 2452 break;
2453 } 2453 }
2454 } 2454 }
2455 context()->Plug(v0); 2455 context()->Plug(v0);
2456 } 2456 }
2457 2457
2458 2458
2459 void FullCodeGenerator::EmitStoreToStackLocalOrContextSlot( 2459 void FullCodeGenerator::EmitStoreToStackLocalOrContextSlot(
2460 Variable* var, MemOperand location) { 2460 Variable* var, MemOperand location) {
2461 __ sd(result_register(), location); 2461 __ sd(result_register(), location);
2462 if (var->IsContextSlot()) { 2462 if (var->IsContextSlot()) {
2463 // RecordWrite may destroy all its register arguments. 2463 // RecordWrite may destroy all its register arguments.
2464 __ Move(a3, result_register()); 2464 __ Move(a3, result_register());
2465 int offset = Context::SlotOffset(var->index()); 2465 int offset = Context::SlotOffset(var->index());
2466 __ RecordWriteContextSlot( 2466 __ RecordWriteContextSlot(
2467 a1, offset, a3, a2, kRAHasBeenSaved, kDontSaveFPRegs); 2467 a1, offset, a3, a2, kRAHasBeenSaved, kDontSaveFPRegs);
2468 } 2468 }
2469 } 2469 }
2470 2470
2471 2471
2472 void FullCodeGenerator::EmitVariableAssignment(Variable* var, Token::Value op) { 2472 void FullCodeGenerator::EmitVariableAssignment(Variable* var, Token::Value op) {
2473 if (var->IsUnallocated()) { 2473 if (var->IsUnallocated()) {
2474 // Global var, const, or let. 2474 // Global var, const, or let.
2475 __ mov(StoreConvention::ValueRegister(), result_register()); 2475 __ mov(StoreDescriptor::ValueRegister(), result_register());
2476 __ li(StoreConvention::NameRegister(), Operand(var->name())); 2476 __ li(StoreDescriptor::NameRegister(), Operand(var->name()));
2477 __ ld(StoreConvention::ReceiverRegister(), GlobalObjectOperand()); 2477 __ ld(StoreDescriptor::ReceiverRegister(), GlobalObjectOperand());
2478 CallStoreIC(); 2478 CallStoreIC();
2479 } else if (op == Token::INIT_CONST_LEGACY) { 2479 } else if (op == Token::INIT_CONST_LEGACY) {
2480 // Const initializers need a write barrier. 2480 // Const initializers need a write barrier.
2481 DCHECK(!var->IsParameter()); // No const parameters. 2481 DCHECK(!var->IsParameter()); // No const parameters.
2482 if (var->IsLookupSlot()) { 2482 if (var->IsLookupSlot()) {
2483 __ li(a0, Operand(var->name())); 2483 __ li(a0, Operand(var->name()));
2484 __ Push(v0, cp, a0); // Context and name. 2484 __ Push(v0, cp, a0); // Context and name.
2485 __ CallRuntime(Runtime::kInitializeLegacyConstLookupSlot, 3); 2485 __ CallRuntime(Runtime::kInitializeLegacyConstLookupSlot, 3);
2486 } else { 2486 } else {
2487 DCHECK(var->IsStackAllocated() || var->IsContextSlot()); 2487 DCHECK(var->IsStackAllocated() || var->IsContextSlot());
(...skipping 52 matching lines...) Expand 10 before | Expand all | Expand 10 after
2540 2540
2541 2541
2542 void FullCodeGenerator::EmitNamedPropertyAssignment(Assignment* expr) { 2542 void FullCodeGenerator::EmitNamedPropertyAssignment(Assignment* expr) {
2543 // Assignment to a property, using a named store IC. 2543 // Assignment to a property, using a named store IC.
2544 Property* prop = expr->target()->AsProperty(); 2544 Property* prop = expr->target()->AsProperty();
2545 DCHECK(prop != NULL); 2545 DCHECK(prop != NULL);
2546 DCHECK(prop->key()->IsLiteral()); 2546 DCHECK(prop->key()->IsLiteral());
2547 2547
2548 // Record source code position before IC call. 2548 // Record source code position before IC call.
2549 SetSourcePosition(expr->position()); 2549 SetSourcePosition(expr->position());
2550 __ mov(StoreConvention::ValueRegister(), result_register()); 2550 __ mov(StoreDescriptor::ValueRegister(), result_register());
2551 __ li(StoreConvention::NameRegister(), 2551 __ li(StoreDescriptor::NameRegister(),
2552 Operand(prop->key()->AsLiteral()->value())); 2552 Operand(prop->key()->AsLiteral()->value()));
2553 __ pop(StoreConvention::ReceiverRegister()); 2553 __ pop(StoreDescriptor::ReceiverRegister());
2554 CallStoreIC(expr->AssignmentFeedbackId()); 2554 CallStoreIC(expr->AssignmentFeedbackId());
2555 2555
2556 PrepareForBailoutForId(expr->AssignmentId(), TOS_REG); 2556 PrepareForBailoutForId(expr->AssignmentId(), TOS_REG);
2557 context()->Plug(v0); 2557 context()->Plug(v0);
2558 } 2558 }
2559 2559
2560 2560
2561 void FullCodeGenerator::EmitKeyedPropertyAssignment(Assignment* expr) { 2561 void FullCodeGenerator::EmitKeyedPropertyAssignment(Assignment* expr) {
2562 // Assignment to a property, using a keyed store IC. 2562 // Assignment to a property, using a keyed store IC.
2563 2563
2564 // Record source code position before IC call. 2564 // Record source code position before IC call.
2565 SetSourcePosition(expr->position()); 2565 SetSourcePosition(expr->position());
2566 // Call keyed store IC. 2566 // Call keyed store IC.
2567 // The arguments are: 2567 // The arguments are:
2568 // - a0 is the value, 2568 // - a0 is the value,
2569 // - a1 is the key, 2569 // - a1 is the key,
2570 // - a2 is the receiver. 2570 // - a2 is the receiver.
2571 __ mov(StoreConvention::ValueRegister(), result_register()); 2571 __ mov(StoreDescriptor::ValueRegister(), result_register());
2572 __ Pop(StoreConvention::ReceiverRegister(), StoreConvention::NameRegister()); 2572 __ Pop(StoreDescriptor::ReceiverRegister(), StoreDescriptor::NameRegister());
2573 DCHECK(StoreConvention::ValueRegister().is(a0)); 2573 DCHECK(StoreDescriptor::ValueRegister().is(a0));
2574 2574
2575 Handle<Code> ic = strict_mode() == SLOPPY 2575 Handle<Code> ic = strict_mode() == SLOPPY
2576 ? isolate()->builtins()->KeyedStoreIC_Initialize() 2576 ? isolate()->builtins()->KeyedStoreIC_Initialize()
2577 : isolate()->builtins()->KeyedStoreIC_Initialize_Strict(); 2577 : isolate()->builtins()->KeyedStoreIC_Initialize_Strict();
2578 CallIC(ic, expr->AssignmentFeedbackId()); 2578 CallIC(ic, expr->AssignmentFeedbackId());
2579 2579
2580 PrepareForBailoutForId(expr->AssignmentId(), TOS_REG); 2580 PrepareForBailoutForId(expr->AssignmentId(), TOS_REG);
2581 context()->Plug(v0); 2581 context()->Plug(v0);
2582 } 2582 }
2583 2583
2584 2584
2585 void FullCodeGenerator::VisitProperty(Property* expr) { 2585 void FullCodeGenerator::VisitProperty(Property* expr) {
2586 Comment cmnt(masm_, "[ Property"); 2586 Comment cmnt(masm_, "[ Property");
2587 Expression* key = expr->key(); 2587 Expression* key = expr->key();
2588 2588
2589 if (key->IsPropertyName()) { 2589 if (key->IsPropertyName()) {
2590 VisitForAccumulatorValue(expr->obj()); 2590 VisitForAccumulatorValue(expr->obj());
2591 __ Move(LoadConvention::ReceiverRegister(), v0); 2591 __ Move(LoadDescriptor::ReceiverRegister(), v0);
2592 EmitNamedPropertyLoad(expr); 2592 EmitNamedPropertyLoad(expr);
2593 PrepareForBailoutForId(expr->LoadId(), TOS_REG); 2593 PrepareForBailoutForId(expr->LoadId(), TOS_REG);
2594 context()->Plug(v0); 2594 context()->Plug(v0);
2595 } else { 2595 } else {
2596 VisitForStackValue(expr->obj()); 2596 VisitForStackValue(expr->obj());
2597 VisitForAccumulatorValue(expr->key()); 2597 VisitForAccumulatorValue(expr->key());
2598 __ Move(LoadConvention::NameRegister(), v0); 2598 __ Move(LoadDescriptor::NameRegister(), v0);
2599 __ pop(LoadConvention::ReceiverRegister()); 2599 __ pop(LoadDescriptor::ReceiverRegister());
2600 EmitKeyedPropertyLoad(expr); 2600 EmitKeyedPropertyLoad(expr);
2601 context()->Plug(v0); 2601 context()->Plug(v0);
2602 } 2602 }
2603 } 2603 }
2604 2604
2605 2605
2606 void FullCodeGenerator::CallIC(Handle<Code> code, 2606 void FullCodeGenerator::CallIC(Handle<Code> code,
2607 TypeFeedbackId id) { 2607 TypeFeedbackId id) {
2608 ic_total_count_++; 2608 ic_total_count_++;
2609 __ Call(code, RelocInfo::CODE_TARGET, id); 2609 __ Call(code, RelocInfo::CODE_TARGET, id);
(...skipping 13 matching lines...) Expand all
2623 { StackValueContext context(this); 2623 { StackValueContext context(this);
2624 EmitVariableLoad(callee->AsVariableProxy()); 2624 EmitVariableLoad(callee->AsVariableProxy());
2625 PrepareForBailout(callee, NO_REGISTERS); 2625 PrepareForBailout(callee, NO_REGISTERS);
2626 } 2626 }
2627 // Push undefined as receiver. This is patched in the method prologue if it 2627 // Push undefined as receiver. This is patched in the method prologue if it
2628 // is a sloppy mode method. 2628 // is a sloppy mode method.
2629 __ Push(isolate()->factory()->undefined_value()); 2629 __ Push(isolate()->factory()->undefined_value());
2630 } else { 2630 } else {
2631 // Load the function from the receiver. 2631 // Load the function from the receiver.
2632 DCHECK(callee->IsProperty()); 2632 DCHECK(callee->IsProperty());
2633 __ ld(LoadConvention::ReceiverRegister(), MemOperand(sp, 0)); 2633 __ ld(LoadDescriptor::ReceiverRegister(), MemOperand(sp, 0));
2634 EmitNamedPropertyLoad(callee->AsProperty()); 2634 EmitNamedPropertyLoad(callee->AsProperty());
2635 PrepareForBailoutForId(callee->AsProperty()->LoadId(), TOS_REG); 2635 PrepareForBailoutForId(callee->AsProperty()->LoadId(), TOS_REG);
2636 // Push the target function under the receiver. 2636 // Push the target function under the receiver.
2637 __ ld(at, MemOperand(sp, 0)); 2637 __ ld(at, MemOperand(sp, 0));
2638 __ push(at); 2638 __ push(at);
2639 __ sd(v0, MemOperand(sp, kPointerSize)); 2639 __ sd(v0, MemOperand(sp, kPointerSize));
2640 } 2640 }
2641 2641
2642 EmitCall(expr, call_type); 2642 EmitCall(expr, call_type);
2643 } 2643 }
2644 2644
2645 2645
2646 // Code common for calls using the IC. 2646 // Code common for calls using the IC.
2647 void FullCodeGenerator::EmitKeyedCallWithLoadIC(Call* expr, 2647 void FullCodeGenerator::EmitKeyedCallWithLoadIC(Call* expr,
2648 Expression* key) { 2648 Expression* key) {
2649 // Load the key. 2649 // Load the key.
2650 VisitForAccumulatorValue(key); 2650 VisitForAccumulatorValue(key);
2651 2651
2652 Expression* callee = expr->expression(); 2652 Expression* callee = expr->expression();
2653 2653
2654 // Load the function from the receiver. 2654 // Load the function from the receiver.
2655 DCHECK(callee->IsProperty()); 2655 DCHECK(callee->IsProperty());
2656 __ ld(LoadConvention::ReceiverRegister(), MemOperand(sp, 0)); 2656 __ ld(LoadDescriptor::ReceiverRegister(), MemOperand(sp, 0));
2657 __ Move(LoadConvention::NameRegister(), v0); 2657 __ Move(LoadDescriptor::NameRegister(), v0);
2658 EmitKeyedPropertyLoad(callee->AsProperty()); 2658 EmitKeyedPropertyLoad(callee->AsProperty());
2659 PrepareForBailoutForId(callee->AsProperty()->LoadId(), TOS_REG); 2659 PrepareForBailoutForId(callee->AsProperty()->LoadId(), TOS_REG);
2660 2660
2661 // Push the target function under the receiver. 2661 // Push the target function under the receiver.
2662 __ ld(at, MemOperand(sp, 0)); 2662 __ ld(at, MemOperand(sp, 0));
2663 __ push(at); 2663 __ push(at);
2664 __ sd(v0, MemOperand(sp, kPointerSize)); 2664 __ sd(v0, MemOperand(sp, kPointerSize));
2665 2665
2666 EmitCall(expr, CallIC::METHOD); 2666 EmitCall(expr, CallIC::METHOD);
2667 } 2667 }
(...skipping 1423 matching lines...) Expand 10 before | Expand all | Expand 10 after
4091 EmitInlineRuntimeCall(expr); 4091 EmitInlineRuntimeCall(expr);
4092 return; 4092 return;
4093 } 4093 }
4094 4094
4095 Comment cmnt(masm_, "[ CallRuntime"); 4095 Comment cmnt(masm_, "[ CallRuntime");
4096 ZoneList<Expression*>* args = expr->arguments(); 4096 ZoneList<Expression*>* args = expr->arguments();
4097 int arg_count = args->length(); 4097 int arg_count = args->length();
4098 4098
4099 if (expr->is_jsruntime()) { 4099 if (expr->is_jsruntime()) {
4100 // Push the builtins object as the receiver. 4100 // Push the builtins object as the receiver.
4101 Register receiver = LoadConvention::ReceiverRegister(); 4101 Register receiver = LoadDescriptor::ReceiverRegister();
4102 __ ld(receiver, GlobalObjectOperand()); 4102 __ ld(receiver, GlobalObjectOperand());
4103 __ ld(receiver, FieldMemOperand(receiver, GlobalObject::kBuiltinsOffset)); 4103 __ ld(receiver, FieldMemOperand(receiver, GlobalObject::kBuiltinsOffset));
4104 __ push(receiver); 4104 __ push(receiver);
4105 4105
4106 // Load the function from the receiver. 4106 // Load the function from the receiver.
4107 __ li(LoadConvention::NameRegister(), Operand(expr->name())); 4107 __ li(LoadDescriptor::NameRegister(), Operand(expr->name()));
4108 if (FLAG_vector_ics) { 4108 if (FLAG_vector_ics) {
4109 __ li(VectorLoadConvention::SlotRegister(), 4109 __ li(VectorLoadICDescriptor::SlotRegister(),
4110 Operand(Smi::FromInt(expr->CallRuntimeFeedbackSlot()))); 4110 Operand(Smi::FromInt(expr->CallRuntimeFeedbackSlot())));
4111 CallLoadIC(NOT_CONTEXTUAL); 4111 CallLoadIC(NOT_CONTEXTUAL);
4112 } else { 4112 } else {
4113 CallLoadIC(NOT_CONTEXTUAL, expr->CallRuntimeFeedbackId()); 4113 CallLoadIC(NOT_CONTEXTUAL, expr->CallRuntimeFeedbackId());
4114 } 4114 }
4115 4115
4116 // Push the target function under the receiver. 4116 // Push the target function under the receiver.
4117 __ ld(at, MemOperand(sp, 0)); 4117 __ ld(at, MemOperand(sp, 0));
4118 __ push(at); 4118 __ push(at);
4119 __ sd(v0, MemOperand(sp, kPointerSize)); 4119 __ sd(v0, MemOperand(sp, kPointerSize));
(...skipping 162 matching lines...) Expand 10 before | Expand all | Expand 10 after
4282 EmitVariableLoad(expr->expression()->AsVariableProxy()); 4282 EmitVariableLoad(expr->expression()->AsVariableProxy());
4283 } else { 4283 } else {
4284 // Reserve space for result of postfix operation. 4284 // Reserve space for result of postfix operation.
4285 if (expr->is_postfix() && !context()->IsEffect()) { 4285 if (expr->is_postfix() && !context()->IsEffect()) {
4286 __ li(at, Operand(Smi::FromInt(0))); 4286 __ li(at, Operand(Smi::FromInt(0)));
4287 __ push(at); 4287 __ push(at);
4288 } 4288 }
4289 if (assign_type == NAMED_PROPERTY) { 4289 if (assign_type == NAMED_PROPERTY) {
4290 // Put the object both on the stack and in the register. 4290 // Put the object both on the stack and in the register.
4291 VisitForStackValue(prop->obj()); 4291 VisitForStackValue(prop->obj());
4292 __ ld(LoadConvention::ReceiverRegister(), MemOperand(sp, 0)); 4292 __ ld(LoadDescriptor::ReceiverRegister(), MemOperand(sp, 0));
4293 EmitNamedPropertyLoad(prop); 4293 EmitNamedPropertyLoad(prop);
4294 } else { 4294 } else {
4295 VisitForStackValue(prop->obj()); 4295 VisitForStackValue(prop->obj());
4296 VisitForStackValue(prop->key()); 4296 VisitForStackValue(prop->key());
4297 __ ld(LoadConvention::ReceiverRegister(), 4297 __ ld(LoadDescriptor::ReceiverRegister(),
4298 MemOperand(sp, 1 * kPointerSize)); 4298 MemOperand(sp, 1 * kPointerSize));
4299 __ ld(LoadConvention::NameRegister(), MemOperand(sp, 0)); 4299 __ ld(LoadDescriptor::NameRegister(), MemOperand(sp, 0));
4300 EmitKeyedPropertyLoad(prop); 4300 EmitKeyedPropertyLoad(prop);
4301 } 4301 }
4302 } 4302 }
4303 4303
4304 // We need a second deoptimization point after loading the value 4304 // We need a second deoptimization point after loading the value
4305 // in case evaluating the property load my have a side effect. 4305 // in case evaluating the property load my have a side effect.
4306 if (assign_type == VARIABLE) { 4306 if (assign_type == VARIABLE) {
4307 PrepareForBailout(expr->expression(), TOS_REG); 4307 PrepareForBailout(expr->expression(), TOS_REG);
4308 } else { 4308 } else {
4309 PrepareForBailoutForId(prop->LoadId(), TOS_REG); 4309 PrepareForBailoutForId(prop->LoadId(), TOS_REG);
(...skipping 90 matching lines...) Expand 10 before | Expand all | Expand 10 after
4400 context()->PlugTOS(); 4400 context()->PlugTOS();
4401 } 4401 }
4402 } else { 4402 } else {
4403 EmitVariableAssignment(expr->expression()->AsVariableProxy()->var(), 4403 EmitVariableAssignment(expr->expression()->AsVariableProxy()->var(),
4404 Token::ASSIGN); 4404 Token::ASSIGN);
4405 PrepareForBailoutForId(expr->AssignmentId(), TOS_REG); 4405 PrepareForBailoutForId(expr->AssignmentId(), TOS_REG);
4406 context()->Plug(v0); 4406 context()->Plug(v0);
4407 } 4407 }
4408 break; 4408 break;
4409 case NAMED_PROPERTY: { 4409 case NAMED_PROPERTY: {
4410 __ mov(StoreConvention::ValueRegister(), result_register()); 4410 __ mov(StoreDescriptor::ValueRegister(), result_register());
4411 __ li(StoreConvention::NameRegister(), 4411 __ li(StoreDescriptor::NameRegister(),
4412 Operand(prop->key()->AsLiteral()->value())); 4412 Operand(prop->key()->AsLiteral()->value()));
4413 __ pop(StoreConvention::ReceiverRegister()); 4413 __ pop(StoreDescriptor::ReceiverRegister());
4414 CallStoreIC(expr->CountStoreFeedbackId()); 4414 CallStoreIC(expr->CountStoreFeedbackId());
4415 PrepareForBailoutForId(expr->AssignmentId(), TOS_REG); 4415 PrepareForBailoutForId(expr->AssignmentId(), TOS_REG);
4416 if (expr->is_postfix()) { 4416 if (expr->is_postfix()) {
4417 if (!context()->IsEffect()) { 4417 if (!context()->IsEffect()) {
4418 context()->PlugTOS(); 4418 context()->PlugTOS();
4419 } 4419 }
4420 } else { 4420 } else {
4421 context()->Plug(v0); 4421 context()->Plug(v0);
4422 } 4422 }
4423 break; 4423 break;
4424 } 4424 }
4425 case KEYED_PROPERTY: { 4425 case KEYED_PROPERTY: {
4426 __ mov(StoreConvention::ValueRegister(), result_register()); 4426 __ mov(StoreDescriptor::ValueRegister(), result_register());
4427 __ Pop(StoreConvention::ReceiverRegister(), 4427 __ Pop(StoreDescriptor::ReceiverRegister(),
4428 StoreConvention::NameRegister()); 4428 StoreDescriptor::NameRegister());
4429 Handle<Code> ic = strict_mode() == SLOPPY 4429 Handle<Code> ic = strict_mode() == SLOPPY
4430 ? isolate()->builtins()->KeyedStoreIC_Initialize() 4430 ? isolate()->builtins()->KeyedStoreIC_Initialize()
4431 : isolate()->builtins()->KeyedStoreIC_Initialize_Strict(); 4431 : isolate()->builtins()->KeyedStoreIC_Initialize_Strict();
4432 CallIC(ic, expr->CountStoreFeedbackId()); 4432 CallIC(ic, expr->CountStoreFeedbackId());
4433 PrepareForBailoutForId(expr->AssignmentId(), TOS_REG); 4433 PrepareForBailoutForId(expr->AssignmentId(), TOS_REG);
4434 if (expr->is_postfix()) { 4434 if (expr->is_postfix()) {
4435 if (!context()->IsEffect()) { 4435 if (!context()->IsEffect()) {
4436 context()->PlugTOS(); 4436 context()->PlugTOS();
4437 } 4437 }
4438 } else { 4438 } else {
4439 context()->Plug(v0); 4439 context()->Plug(v0);
4440 } 4440 }
4441 break; 4441 break;
4442 } 4442 }
4443 } 4443 }
4444 } 4444 }
4445 4445
4446 4446
4447 void FullCodeGenerator::VisitForTypeofValue(Expression* expr) { 4447 void FullCodeGenerator::VisitForTypeofValue(Expression* expr) {
4448 DCHECK(!context()->IsEffect()); 4448 DCHECK(!context()->IsEffect());
4449 DCHECK(!context()->IsTest()); 4449 DCHECK(!context()->IsTest());
4450 VariableProxy* proxy = expr->AsVariableProxy(); 4450 VariableProxy* proxy = expr->AsVariableProxy();
4451 if (proxy != NULL && proxy->var()->IsUnallocated()) { 4451 if (proxy != NULL && proxy->var()->IsUnallocated()) {
4452 Comment cmnt(masm_, "[ Global variable"); 4452 Comment cmnt(masm_, "[ Global variable");
4453 __ ld(LoadConvention::ReceiverRegister(), GlobalObjectOperand()); 4453 __ ld(LoadDescriptor::ReceiverRegister(), GlobalObjectOperand());
4454 __ li(LoadConvention::NameRegister(), Operand(proxy->name())); 4454 __ li(LoadDescriptor::NameRegister(), Operand(proxy->name()));
4455 if (FLAG_vector_ics) { 4455 if (FLAG_vector_ics) {
4456 __ li(VectorLoadConvention::SlotRegister(), 4456 __ li(VectorLoadICDescriptor::SlotRegister(),
4457 Operand(Smi::FromInt(proxy->VariableFeedbackSlot()))); 4457 Operand(Smi::FromInt(proxy->VariableFeedbackSlot())));
4458 } 4458 }
4459 // Use a regular load, not a contextual load, to avoid a reference 4459 // Use a regular load, not a contextual load, to avoid a reference
4460 // error. 4460 // error.
4461 CallLoadIC(NOT_CONTEXTUAL); 4461 CallLoadIC(NOT_CONTEXTUAL);
4462 PrepareForBailout(expr, TOS_REG); 4462 PrepareForBailout(expr, TOS_REG);
4463 context()->Plug(v0); 4463 context()->Plug(v0);
4464 } else if (proxy != NULL && proxy->var()->IsLookupSlot()) { 4464 } else if (proxy != NULL && proxy->var()->IsLookupSlot()) {
4465 Comment cmnt(masm_, "[ Lookup slot"); 4465 Comment cmnt(masm_, "[ Lookup slot");
4466 Label done, slow; 4466 Label done, slow;
(...skipping 416 matching lines...) Expand 10 before | Expand all | Expand 10 after
4883 Assembler::target_address_at(pc_immediate_load_address)) == 4883 Assembler::target_address_at(pc_immediate_load_address)) ==
4884 reinterpret_cast<uint64_t>( 4884 reinterpret_cast<uint64_t>(
4885 isolate->builtins()->OsrAfterStackCheck()->entry())); 4885 isolate->builtins()->OsrAfterStackCheck()->entry()));
4886 return OSR_AFTER_STACK_CHECK; 4886 return OSR_AFTER_STACK_CHECK;
4887 } 4887 }
4888 4888
4889 4889
4890 } } // namespace v8::internal 4890 } } // namespace v8::internal
4891 4891
4892 #endif // V8_TARGET_ARCH_MIPS64 4892 #endif // V8_TARGET_ARCH_MIPS64
OLDNEW
« no previous file with comments | « src/mips64/debug-mips64.cc ('k') | src/mips64/interface-descriptors-mips64.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698