From e1deee4181a0f443eb3bb607080eadbbcceae65d Mon Sep 17 00:00:00 2001 From: "jarin@chromium.org" Date: Mon, 11 Aug 2014 07:33:58 +0000 Subject: [PATCH] Revert "Initial shot at deoptimizing JSCallFunction in Turbofan." This reverts commit r23020. BUG= TBR=bmeurer@chromium.org Review URL: https://codereview.chromium.org/453363003 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23022 ce2b1a6d-e550-0410-aec6-3dcde31c8c00 --- src/compiler/arm/linkage-arm.cc | 5 +- src/compiler/arm64/linkage-arm64.cc | 5 +- src/compiler/ast-graph-builder.cc | 17 ++----- src/compiler/code-generator.cc | 4 +- src/compiler/ia32/linkage-ia32.cc | 5 +- src/compiler/js-generic-lowering.cc | 19 +++----- src/compiler/js-operator.h | 9 +--- src/compiler/linkage-impl.h | 6 +-- src/compiler/linkage.cc | 11 +---- src/compiler/linkage.h | 9 +--- src/compiler/operator-properties-inl.h | 14 ------ src/compiler/register-allocator.cc | 66 -------------------------- src/compiler/register-allocator.h | 1 - src/compiler/x64/linkage-x64.cc | 5 +- src/objects.cc | 8 ++-- test/cctest/cctest.status | 3 ++ test/cctest/compiler/test-scheduler.cc | 2 - test/cctest/test-deoptimization.cc | 6 --- 18 files changed, 34 insertions(+), 161 deletions(-) diff --git a/src/compiler/arm/linkage-arm.cc b/src/compiler/arm/linkage-arm.cc index 6bea210ec..489a0c612 100644 --- a/src/compiler/arm/linkage-arm.cc +++ b/src/compiler/arm/linkage-arm.cc @@ -49,10 +49,9 @@ CallDescriptor* Linkage::GetRuntimeCallDescriptor( CallDescriptor* Linkage::GetStubCallDescriptor( - CodeStubInterfaceDescriptor* descriptor, int stack_parameter_count, - CallDescriptor::DeoptimizationSupport can_deoptimize, Zone* zone) { + CodeStubInterfaceDescriptor* descriptor, int stack_parameter_count) { return LinkageHelper::GetStubCallDescriptor( - zone, descriptor, stack_parameter_count, can_deoptimize); + this->info_->zone(), descriptor, stack_parameter_count); } diff --git a/src/compiler/arm64/linkage-arm64.cc b/src/compiler/arm64/linkage-arm64.cc index e44c5d86f..240cef1e3 100644 --- a/src/compiler/arm64/linkage-arm64.cc +++ b/src/compiler/arm64/linkage-arm64.cc @@ -49,10 +49,9 @@ CallDescriptor* Linkage::GetRuntimeCallDescriptor( CallDescriptor* Linkage::GetStubCallDescriptor( - CodeStubInterfaceDescriptor* descriptor, int stack_parameter_count, - CallDescriptor::DeoptimizationSupport can_deoptimize, Zone* zone) { + CodeStubInterfaceDescriptor* descriptor, int stack_parameter_count) { return LinkageHelper::GetStubCallDescriptor( - zone, descriptor, stack_parameter_count, can_deoptimize); + this->info_->zone(), descriptor, stack_parameter_count); } diff --git a/src/compiler/ast-graph-builder.cc b/src/compiler/ast-graph-builder.cc index 21f92b1d8..2c242cbe1 100644 --- a/src/compiler/ast-graph-builder.cc +++ b/src/compiler/ast-graph-builder.cc @@ -722,13 +722,8 @@ void AstGraphBuilder::VisitForInStatement(ForInStatement* stmt) { environment()->Push(value); // result is either the string key or Smi(0) indicating the property // is gone. - // TODO(jarin) Insert lazy deoptimization support here - the call - // actually - // can deoptimize. Node* res = ProcessArguments( - javascript()->Call(3, NO_CALL_FUNCTION_FLAGS, - CallDescriptor::kCannotDeoptimize), - 3); + javascript()->Call(3, NO_CALL_FUNCTION_FLAGS), 3); Node* property_missing = NewNode(javascript()->StrictEqual(), res, jsgraph()->ZeroConstant()); { @@ -1251,12 +1246,9 @@ void AstGraphBuilder::VisitCall(Call* expr) { } // Create node to perform the function call. - Operator* call = javascript()->Call(args->length() + 2, flags, - CallDescriptor::kCanDeoptimize); + Operator* call = javascript()->Call(args->length() + 2, flags); Node* value = ProcessArguments(call, args->length() + 2); ast_context()->ProduceValue(value); - - BuildLazyBailout(value, expr->id()); } @@ -1291,12 +1283,9 @@ void AstGraphBuilder::VisitCallJSRuntime(CallRuntime* expr) { VisitForValues(args); // Create node to perform the JS runtime call. - Operator* call = javascript()->Call(args->length() + 2, flags, - CallDescriptor::kCanDeoptimize); + Operator* call = javascript()->Call(args->length() + 2, flags); Node* value = ProcessArguments(call, args->length() + 2); ast_context()->ProduceValue(value); - - BuildLazyBailout(value, expr->id()); } diff --git a/src/compiler/code-generator.cc b/src/compiler/code-generator.cc index 878ace3be..5c831eb6d 100644 --- a/src/compiler/code-generator.cc +++ b/src/compiler/code-generator.cc @@ -215,9 +215,7 @@ void CodeGenerator::PopulateDeoptimizationData(Handle code_object) { for (int i = 0; i < deopt_count; i++) { FrameStateDescriptor* descriptor = code()->GetDeoptimizationEntry(i); data->SetAstId(i, descriptor->bailout_id()); - CHECK_NE(NULL, deoptimization_states_[i]); - data->SetTranslationIndex( - i, Smi::FromInt(deoptimization_states_[i]->translation_id_)); + data->SetTranslationIndex(i, Smi::FromInt(0)); data->SetArgumentsStackHeight(i, Smi::FromInt(0)); data->SetPc(i, Smi::FromInt(-1)); } diff --git a/src/compiler/ia32/linkage-ia32.cc b/src/compiler/ia32/linkage-ia32.cc index 6ace8befa..803d3f69f 100644 --- a/src/compiler/ia32/linkage-ia32.cc +++ b/src/compiler/ia32/linkage-ia32.cc @@ -45,10 +45,9 @@ CallDescriptor* Linkage::GetRuntimeCallDescriptor( CallDescriptor* Linkage::GetStubCallDescriptor( - CodeStubInterfaceDescriptor* descriptor, int stack_parameter_count, - CallDescriptor::DeoptimizationSupport can_deoptimize, Zone* zone) { + CodeStubInterfaceDescriptor* descriptor, int stack_parameter_count) { return LinkageHelper::GetStubCallDescriptor( - zone, descriptor, stack_parameter_count, can_deoptimize); + this->info_->zone(), descriptor, stack_parameter_count); } diff --git a/src/compiler/js-generic-lowering.cc b/src/compiler/js-generic-lowering.cc index d777081d7..699f7dd60 100644 --- a/src/compiler/js-generic-lowering.cc +++ b/src/compiler/js-generic-lowering.cc @@ -349,22 +349,18 @@ void JSGenericLowering::ReplaceWithBuiltinCall(Node* node, } -static CallDescriptor::DeoptimizationSupport DeoptimizationSupportForNode( - Node* node) { - return OperatorProperties::CanLazilyDeoptimize(node->op()) - ? CallDescriptor::kCanDeoptimize - : CallDescriptor::kCannotDeoptimize; -} - - void JSGenericLowering::ReplaceWithRuntimeCall(Node* node, Runtime::FunctionId f, int nargs_override) { Operator::Property props = node->op()->properties(); const Runtime::Function* fun = Runtime::FunctionForId(f); int nargs = (nargs_override < 0) ? fun->nargs : nargs_override; - CallDescriptor* desc = linkage()->GetRuntimeCallDescriptor( - f, nargs, props, DeoptimizationSupportForNode(node)); + CallDescriptor::DeoptimizationSupport deopt = + OperatorProperties::CanLazilyDeoptimize(node->op()) + ? CallDescriptor::kCanDeoptimize + : CallDescriptor::kCannotDeoptimize; + CallDescriptor* desc = + linkage()->GetRuntimeCallDescriptor(f, nargs, props, deopt); Node* ref = ExternalConstant(ExternalReference(f, isolate())); Node* arity = Int32Constant(nargs); if (!centrystub_constant_.is_set()) { @@ -528,8 +524,7 @@ Node* JSGenericLowering::LowerJSCallFunction(Node* node) { CallParameters p = OpParameter(node); CallFunctionStub stub(isolate(), p.arity - 2, p.flags); CodeStubInterfaceDescriptor* d = GetInterfaceDescriptor(isolate(), &stub); - CallDescriptor* desc = linkage()->GetStubCallDescriptor( - d, p.arity - 1, DeoptimizationSupportForNode(node)); + CallDescriptor* desc = linkage()->GetStubCallDescriptor(d, p.arity - 1); Node* stub_code = CodeConstant(stub.GetCode()); PatchInsertInput(node, 0, stub_code); PatchOperator(node, common()->Call(desc)); diff --git a/src/compiler/js-operator.h b/src/compiler/js-operator.h index 500db9d12..d32eb5a39 100644 --- a/src/compiler/js-operator.h +++ b/src/compiler/js-operator.h @@ -5,7 +5,6 @@ #ifndef V8_COMPILER_JS_OPERATOR_H_ #define V8_COMPILER_JS_OPERATOR_H_ -#include "src/compiler/linkage.h" #include "src/compiler/opcodes.h" #include "src/compiler/operator.h" #include "src/unique.h" @@ -49,9 +48,6 @@ struct LoadNamedParameters { struct CallParameters { int arity; CallFunctionFlags flags; - // TODO(jarin) Remove the deopt flag once we can deoptimize all JavaScript - // calls (specifically the FILTER_KEY call in ForInStatement). - CallDescriptor::DeoptimizationSupport can_deoptimize; }; // Interface for building JavaScript-level operators, e.g. directly from the @@ -107,9 +103,8 @@ class JSOperatorBuilder { Operator* Create() { SIMPLE(JSCreate, Operator::kEliminatable, 0, 1); } - Operator* Call(int arguments, CallFunctionFlags flags, - CallDescriptor::DeoptimizationSupport can_deoptimize) { - CallParameters parameters = {arguments, flags, can_deoptimize}; + Operator* Call(int arguments, CallFunctionFlags flags) { + CallParameters parameters = {arguments, flags}; OP1(JSCallFunction, CallParameters, parameters, Operator::kNoProperties, arguments, 1); } diff --git a/src/compiler/linkage-impl.h b/src/compiler/linkage-impl.h index 36939cc6c..212a622ac 100644 --- a/src/compiler/linkage-impl.h +++ b/src/compiler/linkage-impl.h @@ -128,8 +128,7 @@ class LinkageHelper { template static CallDescriptor* GetStubCallDescriptor( Zone* zone, CodeStubInterfaceDescriptor* descriptor, - int stack_parameter_count, - CallDescriptor::DeoptimizationSupport can_deoptimize) { + int stack_parameter_count) { int register_parameter_count = descriptor->GetEnvironmentParameterCount(); int parameter_count = register_parameter_count + stack_parameter_count; const int code_count = 1; @@ -166,8 +165,9 @@ class LinkageHelper { locations, // locations Operator::kNoProperties, // properties kNoCalleeSaved, // callee-saved registers - can_deoptimize, // deoptimization + CallDescriptor::kCannotDeoptimize, // deoptimization CodeStub::MajorName(descriptor->MajorKey(), false)); + // TODO(jarin) should deoptimize! } diff --git a/src/compiler/linkage.cc b/src/compiler/linkage.cc index 7c3a9fb24..466f65c8b 100644 --- a/src/compiler/linkage.cc +++ b/src/compiler/linkage.cc @@ -102,14 +102,6 @@ CallDescriptor* Linkage::GetRuntimeCallDescriptor( } -CallDescriptor* Linkage::GetStubCallDescriptor( - CodeStubInterfaceDescriptor* descriptor, int stack_parameter_count, - CallDescriptor::DeoptimizationSupport can_deoptimize) { - return GetStubCallDescriptor(descriptor, stack_parameter_count, - can_deoptimize, this->info_->zone()); -} - - //============================================================================== // Provide unimplemented methods on unsupported architectures, to at least link. //============================================================================== @@ -130,8 +122,7 @@ CallDescriptor* Linkage::GetRuntimeCallDescriptor( CallDescriptor* Linkage::GetStubCallDescriptor( - CodeStubInterfaceDescriptor* descriptor, int stack_parameter_count, - CallDescriptor::DeoptimizationSupport can_deoptimize, Zone* zone) { + CodeStubInterfaceDescriptor* descriptor, int stack_parameter_count) { UNIMPLEMENTED(); return NULL; } diff --git a/src/compiler/linkage.h b/src/compiler/linkage.h index 7b19303fb..310a87a9c 100644 --- a/src/compiler/linkage.h +++ b/src/compiler/linkage.h @@ -147,13 +147,8 @@ class Linkage : public ZoneObject { Operator::Property properties, CallDescriptor::DeoptimizationSupport can_deoptimize, Zone* zone); - CallDescriptor* GetStubCallDescriptor( - CodeStubInterfaceDescriptor* descriptor, int stack_parameter_count = 0, - CallDescriptor::DeoptimizationSupport can_deoptimize = - CallDescriptor::kCannotDeoptimize); - static CallDescriptor* GetStubCallDescriptor( - CodeStubInterfaceDescriptor* descriptor, int stack_parameter_count, - CallDescriptor::DeoptimizationSupport can_deoptimize, Zone* zone); + CallDescriptor* GetStubCallDescriptor(CodeStubInterfaceDescriptor* descriptor, + int stack_parameter_count = 0); // Creates a call descriptor for simplified C calls that is appropriate // for the host platform. This simplified calling convention only supports diff --git a/src/compiler/operator-properties-inl.h b/src/compiler/operator-properties-inl.h index 28d52e3cc..fc9149ded 100644 --- a/src/compiler/operator-properties-inl.h +++ b/src/compiler/operator-properties-inl.h @@ -7,7 +7,6 @@ #include "src/v8.h" -#include "src/compiler/js-operator.h" #include "src/compiler/opcodes.h" #include "src/compiler/operator-properties.h" @@ -131,14 +130,6 @@ inline bool OperatorProperties::IsScheduleRoot(Operator* op) { } inline bool OperatorProperties::CanLazilyDeoptimize(Operator* op) { - // TODO(jarin) This function allows turning on lazy deoptimization - // incrementally. It will change as we turn on lazy deopt for - // more nodes. - - if (!FLAG_turbo_deoptimization) { - return false; - } - if (op->opcode() == IrOpcode::kCall) { CallOperator* call_op = reinterpret_cast(op); CallDescriptor* descriptor = call_op->parameter(); @@ -151,11 +142,6 @@ inline bool OperatorProperties::CanLazilyDeoptimize(Operator* op) { reinterpret_cast*>(op)->parameter(); return function == Runtime::kDeoptimizeFunction; } - if (op->opcode() == IrOpcode::kJSCallFunction) { - CallParameters p = - reinterpret_cast*>(op)->parameter(); - return p.can_deoptimize == CallDescriptor::kCanDeoptimize; - } return false; } } diff --git a/src/compiler/register-allocator.cc b/src/compiler/register-allocator.cc index 972a90450..46446aa56 100644 --- a/src/compiler/register-allocator.cc +++ b/src/compiler/register-allocator.cc @@ -744,70 +744,6 @@ void RegisterAllocator::MeetRegisterConstraints(BasicBlock* block) { if (!AllocationOk()) return; } } - - // Meet register constraints for the instruction in the end. - if (!code()->IsGapAt(end)) { - MeetRegisterConstraintsForLastInstructionInBlock(block); - } -} - - -void RegisterAllocator::MeetRegisterConstraintsForLastInstructionInBlock( - BasicBlock* block) { - int end = block->last_instruction_index(); - Instruction* last_instruction = InstructionAt(end); - for (size_t i = 0; i < last_instruction->OutputCount(); i++) { - InstructionOperand* output_operand = last_instruction->OutputAt(i); - DCHECK(!output_operand->IsConstant()); - UnallocatedOperand* output = UnallocatedOperand::cast(output_operand); - int output_vreg = output->virtual_register(); - LiveRange* range = LiveRangeFor(output_vreg); - bool assigned = false; - if (output->HasFixedPolicy()) { - AllocateFixed(output, -1, false); - // This value is produced on the stack, we never need to spill it. - if (output->IsStackSlot()) { - range->SetSpillOperand(output); - range->SetSpillStartIndex(end); - assigned = true; - } - - BasicBlock::Successors successors = block->successors(); - for (BasicBlock::Successors::iterator succ = successors.begin(); - succ != successors.end(); ++succ) { - DCHECK((*succ)->PredecessorCount() == 1); - int gap_index = (*succ)->first_instruction_index() + 1; - DCHECK(code()->IsGapAt(gap_index)); - - // Create an unconstrained operand for the same virtual register - // and insert a gap move from the fixed output to the operand. - UnallocatedOperand* output_copy = - new (code_zone()) UnallocatedOperand(UnallocatedOperand::ANY); - output_copy->set_virtual_register(output_vreg); - - code()->AddGapMove(gap_index, output, output_copy); - } - } - - if (!assigned) { - BasicBlock::Successors successors = block->successors(); - for (BasicBlock::Successors::iterator succ = successors.begin(); - succ != successors.end(); ++succ) { - DCHECK((*succ)->PredecessorCount() == 1); - int gap_index = (*succ)->first_instruction_index() + 1; - range->SetSpillStartIndex(gap_index); - - // This move to spill operand is not a real use. Liveness analysis - // and splitting of live ranges do not account for it. - // Thus it should be inserted to a lifetime position corresponding to - // the instruction end. - GapInstruction* gap = code()->GapAt(gap_index); - ParallelMove* move = - gap->GetOrCreateParallelMove(GapInstruction::BEFORE, code_zone()); - move->AddMove(output, range->GetSpillOperand(), code_zone()); - } - } - } } @@ -850,8 +786,6 @@ void RegisterAllocator::MeetConstraintsBetween(Instruction* first, code()->AddGapMove(gap_index, first_output, output_copy); } - // Make sure we add a gap move for spilling (if we have not done - // so already). if (!assigned) { range->SetSpillStartIndex(gap_index); diff --git a/src/compiler/register-allocator.h b/src/compiler/register-allocator.h index 881ce37f7..8a99e6f63 100644 --- a/src/compiler/register-allocator.h +++ b/src/compiler/register-allocator.h @@ -391,7 +391,6 @@ class RegisterAllocator BASE_EMBEDDED { void MeetRegisterConstraints(BasicBlock* block); void MeetConstraintsBetween(Instruction* first, Instruction* second, int gap_index); - void MeetRegisterConstraintsForLastInstructionInBlock(BasicBlock* block); void ResolvePhis(BasicBlock* block); // Helper methods for building intervals. diff --git a/src/compiler/x64/linkage-x64.cc b/src/compiler/x64/linkage-x64.cc index 9c8b9d044..30808e042 100644 --- a/src/compiler/x64/linkage-x64.cc +++ b/src/compiler/x64/linkage-x64.cc @@ -64,10 +64,9 @@ CallDescriptor* Linkage::GetRuntimeCallDescriptor( CallDescriptor* Linkage::GetStubCallDescriptor( - CodeStubInterfaceDescriptor* descriptor, int stack_parameter_count, - CallDescriptor::DeoptimizationSupport can_deoptimize, Zone* zone) { + CodeStubInterfaceDescriptor* descriptor, int stack_parameter_count) { return LinkageHelper::GetStubCallDescriptor( - zone, descriptor, stack_parameter_count, can_deoptimize); + this->info_->zone(), descriptor, stack_parameter_count); } diff --git a/src/objects.cc b/src/objects.cc index 7cd79048d..645bb4a74 100644 --- a/src/objects.cc +++ b/src/objects.cc @@ -11128,7 +11128,7 @@ void DeoptimizationInputData::DeoptimizationInputDataPrint( os << "Deoptimization Input Data (deopt points = " << deopt_count << ")\n"; if (0 != deopt_count) { os << " index ast id argc pc"; - if (FLAG_print_code_verbose) os << " commands"; + if (FLAG_print_code_verbose) os << "commands"; os << "\n"; } for (int i = 0; i < deopt_count; i++) { @@ -11158,7 +11158,7 @@ void DeoptimizationInputData::DeoptimizationInputDataPrint( Translation::BEGIN != (opcode = static_cast(iterator.Next()))) { Vector buf2 = Vector::New(128); - SNPrintF(buf2, "%27s %s ", "", Translation::StringFor(opcode)); + SNPrintF(buf2, "%24s %s ", "", Translation::StringFor(opcode)); os << buf2.start(); switch (opcode) { @@ -11284,11 +11284,11 @@ void DeoptimizationInputData::DeoptimizationInputDataPrint( if (return_address_patch_count != 0) { os << "Return address patch data (count = " << return_address_patch_count << ")\n"; - os << " index pc patched_pc\n"; + os << "index pc patched_pc\n"; } for (int i = 0; i < return_address_patch_count; i++) { Vector buf = Vector::New(128); - SNPrintF(buf, "%6d %6d %12d\n", i, ReturnAddressPc(i)->value(), + SNPrintF(buf, "%6d %6d %10d", i, ReturnAddressPc(i)->value(), PatchedAddressPc(i)->value()); os << buf.start(); } diff --git a/test/cctest/cctest.status b/test/cctest/cctest.status index 7b9d1cc57..56616341f 100644 --- a/test/cctest/cctest.status +++ b/test/cctest/cctest.status @@ -107,6 +107,9 @@ 'test-debug/DebugBreakLoop': [PASS, NO_VARIANTS], # Support for lazy deoptimization is missing. + 'test-deoptimization/DeoptimizeSimple': [PASS, NO_VARIANTS], + 'test-deoptimization/DeoptimizeSimpleNested': [PASS, NO_VARIANTS], + 'test-deoptimization/DeoptimizeSimpleWithArguments': [PASS, NO_VARIANTS], 'test-deoptimization/DeoptimizeBinaryOperation*': [PASS, NO_VARIANTS], 'test-deoptimization/DeoptimizeCompare': [PASS, NO_VARIANTS], 'test-deoptimization/DeoptimizeLoadICStoreIC': [PASS, NO_VARIANTS], diff --git a/test/cctest/compiler/test-scheduler.cc b/test/cctest/compiler/test-scheduler.cc index 43c8ae646..757f83a71 100644 --- a/test/cctest/compiler/test-scheduler.cc +++ b/test/cctest/compiler/test-scheduler.cc @@ -1713,8 +1713,6 @@ static Handle Compile(const char* source) { TEST(BuildScheduleTrivialLazyDeoptCall) { - FLAG_turbo_deoptimization = true; - HandleAndZoneScope scope; Isolate* isolate = scope.main_isolate(); Graph graph(scope.main_zone()); diff --git a/test/cctest/test-deoptimization.cc b/test/cctest/test-deoptimization.cc index 9192d87e8..a663007e9 100644 --- a/test/cctest/test-deoptimization.cc +++ b/test/cctest/test-deoptimization.cc @@ -113,8 +113,6 @@ static Handle GetJSFunction(v8::Handle obj, TEST(DeoptimizeSimple) { - i::FLAG_turbo_deoptimization = true; - LocalContext env; v8::HandleScope scope(env->GetIsolate()); @@ -153,8 +151,6 @@ TEST(DeoptimizeSimple) { TEST(DeoptimizeSimpleWithArguments) { - i::FLAG_turbo_deoptimization = true; - LocalContext env; v8::HandleScope scope(env->GetIsolate()); @@ -194,8 +190,6 @@ TEST(DeoptimizeSimpleWithArguments) { TEST(DeoptimizeSimpleNested) { - i::FLAG_turbo_deoptimization = true; - LocalContext env; v8::HandleScope scope(env->GetIsolate()); -- 2.34.1