Cleanup and simplify TurboFan generic lowering.

src/compiler/js-generic-lowering.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/code-factory.h"
 #include "src/code-stubs.h"
 #include "src/compiler/common-operator.h"
 #include "src/compiler/graph-inl.h"
 #include "src/compiler/js-generic-lowering.h"
 #include "src/compiler/machine-operator.h"
 #include "src/compiler/node-aux-data-inl.h"
 #include "src/compiler/node-properties-inl.h"
 #include "src/unique.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
-JSGenericLowering::JSGenericLowering(CompilationInfo* info, JSGraph* jsgraph,
-                                     MachineOperatorBuilder* machine)
+JSGenericLowering::JSGenericLowering(CompilationInfo* info, JSGraph* jsgraph)
     : info_(info),
       jsgraph_(jsgraph),
-      linkage_(new (jsgraph->zone()) Linkage(info)),
-      machine_(machine) {}
+      linkage_(new (jsgraph->zone()) Linkage(info)) {}
 
 
 void JSGenericLowering::PatchOperator(Node* node, const Operator* op) {
   node->set_op(op);
 }
 
 
 void JSGenericLowering::PatchInsertInput(Node* node, int index, Node* input) {
   node->InsertInput(zone(), index, input);
 }
@@ skipping 18 matching lines @@
   return jsgraph()->HeapConstant(function);
 }
 
 
 Node* JSGenericLowering::ExternalConstant(ExternalReference ref) {
   return jsgraph()->ExternalConstant(ref);
 }
 
 
 Reduction JSGenericLowering::Reduce(Node* node) {
-  Node* replacement = NULL;
-  // Dispatch according to the opcode.
   switch (node->opcode()) {
-#define DECLARE_CASE(x)           \
-  case IrOpcode::k##x:            \
-    replacement = Lower##x(node); \
+#define DECLARE_CASE(x) \
+  case IrOpcode::k##x:  \
+    Lower##x(node);     \
     break;
     DECLARE_CASE(Branch)
     JS_OP_LIST(DECLARE_CASE)
 #undef DECLARE_CASE
     default:
       // Nothing to see.
       return NoChange();
   }
-  DCHECK_EQ(node, replacement);
-  return Changed(replacement);
+  return Changed(node);
 }
 
 
 #define REPLACE_BINARY_OP_IC_CALL(op, token)                             \
-  Node* JSGenericLowering::Lower##op(Node* node) {                       \
+  void JSGenericLowering::Lower##op(Node* node) {                        \
     ReplaceWithStubCall(node, CodeFactory::BinaryOpIC(isolate(), token), \
                         CallDescriptor::kPatchableCallSiteWithNop);      \
-    return node;                                                         \
   }
 REPLACE_BINARY_OP_IC_CALL(JSBitwiseOr, Token::BIT_OR)
 REPLACE_BINARY_OP_IC_CALL(JSBitwiseXor, Token::BIT_XOR)
 REPLACE_BINARY_OP_IC_CALL(JSBitwiseAnd, Token::BIT_AND)
 REPLACE_BINARY_OP_IC_CALL(JSShiftLeft, Token::SHL)
 REPLACE_BINARY_OP_IC_CALL(JSShiftRight, Token::SAR)
 REPLACE_BINARY_OP_IC_CALL(JSShiftRightLogical, Token::SHR)
 REPLACE_BINARY_OP_IC_CALL(JSAdd, Token::ADD)
 REPLACE_BINARY_OP_IC_CALL(JSSubtract, Token::SUB)
 REPLACE_BINARY_OP_IC_CALL(JSMultiply, Token::MUL)
 REPLACE_BINARY_OP_IC_CALL(JSDivide, Token::DIV)
 REPLACE_BINARY_OP_IC_CALL(JSModulus, Token::MOD)
 #undef REPLACE_BINARY_OP_IC_CALL
 
 
-#define REPLACE_FACTORY_CALL(op, FactoryDeclaration)               \
-  Node* JSGenericLowering::Lower##op(Node* node) {                 \
-    Callable callable = FactoryDeclaration;                        \
-    ReplaceWithStubCall(node, callable, CallDescriptor::kNoFlags); \
-    return node;                                                   \
-  }
-REPLACE_FACTORY_CALL(JSToNumber, CodeFactory::ToNumber(isolate()))
-#undef REPLACE_FACTORY_CALL
-
-
-#define REPLACE_COMPARE_IC_CALL(op, token, pure)   \
-  Node* JSGenericLowering::Lower##op(Node* node) { \
-    ReplaceWithCompareIC(node, token, pure);       \
-    return node;                                   \
+#define REPLACE_COMPARE_IC_CALL(op, token, pure)  \
+  void JSGenericLowering::Lower##op(Node* node) { \
+    ReplaceWithCompareIC(node, token, pure);      \
   }
 REPLACE_COMPARE_IC_CALL(JSEqual, Token::EQ, false)
 REPLACE_COMPARE_IC_CALL(JSNotEqual, Token::NE, false)
 REPLACE_COMPARE_IC_CALL(JSStrictEqual, Token::EQ_STRICT, true)
 REPLACE_COMPARE_IC_CALL(JSStrictNotEqual, Token::NE_STRICT, true)
 REPLACE_COMPARE_IC_CALL(JSLessThan, Token::LT, false)
 REPLACE_COMPARE_IC_CALL(JSGreaterThan, Token::GT, false)
 REPLACE_COMPARE_IC_CALL(JSLessThanOrEqual, Token::LTE, false)
 REPLACE_COMPARE_IC_CALL(JSGreaterThanOrEqual, Token::GTE, false)
 #undef REPLACE_COMPARE_IC_CALL
 
 
-#define REPLACE_RUNTIME_CALL(op, fun)              \
-  Node* JSGenericLowering::Lower##op(Node* node) { \
-    ReplaceWithRuntimeCall(node, fun);             \
-    return node;                                   \
+#define REPLACE_RUNTIME_CALL(op, fun)             \
+  void JSGenericLowering::Lower##op(Node* node) { \
+    ReplaceWithRuntimeCall(node, fun);            \
   }
 REPLACE_RUNTIME_CALL(JSTypeOf, Runtime::kTypeof)
 REPLACE_RUNTIME_CALL(JSCreate, Runtime::kAbort)
 REPLACE_RUNTIME_CALL(JSCreateFunctionContext, Runtime::kNewFunctionContext)
 REPLACE_RUNTIME_CALL(JSCreateCatchContext, Runtime::kPushCatchContext)
 REPLACE_RUNTIME_CALL(JSCreateWithContext, Runtime::kPushWithContext)
 REPLACE_RUNTIME_CALL(JSCreateBlockContext, Runtime::kPushBlockContext)
 REPLACE_RUNTIME_CALL(JSCreateModuleContext, Runtime::kPushModuleContext)
 REPLACE_RUNTIME_CALL(JSCreateGlobalContext, Runtime::kAbort)
 #undef REPLACE_RUNTIME
 
 
-#define REPLACE_UNIMPLEMENTED(op)                  \
-  Node* JSGenericLowering::Lower##op(Node* node) { \
-    UNIMPLEMENTED();                               \
-    return node;                                   \
-  }
+#define REPLACE_UNIMPLEMENTED(op) \
+  void JSGenericLowering::Lower##op(Node* node) { UNIMPLEMENTED(); }
 REPLACE_UNIMPLEMENTED(JSToName)
 REPLACE_UNIMPLEMENTED(JSYield)
 REPLACE_UNIMPLEMENTED(JSDebugger)
 #undef REPLACE_UNIMPLEMENTED
 
 
 static CallDescriptor::Flags FlagsForNode(Node* node) {
   CallDescriptor::Flags result = CallDescriptor::kNoFlags;
   if (OperatorProperties::HasFrameStateInput(node->op())) {
     result |= CallDescriptor::kNeedsFrameState;
@@ skipping 94 matching lines @@
   if (!centrystub_constant_.is_set()) {
     centrystub_constant_.set(CodeConstant(CEntryStub(isolate(), 1).GetCode()));
   }
   PatchInsertInput(node, 0, centrystub_constant_.get());
   PatchInsertInput(node, nargs + 1, ref);
   PatchInsertInput(node, nargs + 2, arity);
   PatchOperator(node, common()->Call(desc));
 }
 
 
-Node* JSGenericLowering::LowerBranch(Node* node) {
+void JSGenericLowering::LowerBranch(Node* node) {
   if (!info()->is_typing_enabled()) {
     // TODO(mstarzinger): If typing is enabled then simplified lowering will
     // have inserted the correct ChangeBoolToBit, otherwise we need to perform
     // poor-man's representation inference here and insert manual change.
     Node* test = graph()->NewNode(machine()->WordEqual(), node->InputAt(0),
                                   jsgraph()->TrueConstant());
     node->ReplaceInput(0, test);
   }
-  return node;
 }
 
 
-Node* JSGenericLowering::LowerJSUnaryNot(Node* node) {
+void JSGenericLowering::LowerJSUnaryNot(Node* node) {
   Callable callable = CodeFactory::ToBoolean(
       isolate(), ToBooleanStub::RESULT_AS_INVERSE_ODDBALL);
   ReplaceWithStubCall(node, callable, CallDescriptor::kPatchableCallSite);
-  return node;
 }
 
 
-Node* JSGenericLowering::LowerJSToBoolean(Node* node) {
+void JSGenericLowering::LowerJSToBoolean(Node* node) {
   Callable callable =
       CodeFactory::ToBoolean(isolate(), ToBooleanStub::RESULT_AS_ODDBALL);
   ReplaceWithStubCall(node, callable, CallDescriptor::kPatchableCallSite);
-  return node;
 }
 
 
-Node* JSGenericLowering::LowerJSToString(Node* node) {
-  ReplaceWithBuiltinCall(node, Builtins::TO_STRING, 1);
-  return node;
+void JSGenericLowering::LowerJSToNumber(Node* node) {
+  Callable callable = CodeFactory::ToNumber(isolate());
+  ReplaceWithStubCall(node, callable, CallDescriptor::kNoFlags);
 }
 
 
-Node* JSGenericLowering::LowerJSToObject(Node* node) {
-  ReplaceWithBuiltinCall(node, Builtins::TO_OBJECT, 1);
-  return node;
+void JSGenericLowering::LowerJSToString(Node* node) {
+  ReplaceWithBuiltinCall(node, Builtins::TO_STRING, 1);
 }
 
 
-Node* JSGenericLowering::LowerJSLoadProperty(Node* node) {
-  Callable callable = CodeFactory::KeyedLoadIC(isolate());
-  ReplaceWithStubCall(node, callable, CallDescriptor::kPatchableCallSite);
-  return node;
+void JSGenericLowering::LowerJSToObject(Node* node) {
+  ReplaceWithBuiltinCall(node, Builtins::TO_OBJECT, 1);
 }
 
 
-Node* JSGenericLowering::LowerJSLoadNamed(Node* node) {
-  LoadNamedParameters p = OpParameter<LoadNamedParameters>(node);
-  PatchInsertInput(node, 1, jsgraph()->HeapConstant(p.name));
-  Callable callable = CodeFactory::LoadIC(isolate(), p.contextual_mode);
+void JSGenericLowering::LowerJSLoadProperty(Node* node) {
+  Callable callable = CodeFactory::KeyedLoadIC(isolate());
   ReplaceWithStubCall(node, callable, CallDescriptor::kPatchableCallSite);
-  return node;
 }
 
 
-Node* JSGenericLowering::LowerJSStoreProperty(Node* node) {
+void JSGenericLowering::LowerJSLoadNamed(Node* node) {
+  LoadNamedParameters p = OpParameter<LoadNamedParameters>(node);
+  Callable callable = CodeFactory::LoadIC(isolate(), p.contextual_mode);
+  PatchInsertInput(node, 1, jsgraph()->HeapConstant(p.name));
+  ReplaceWithStubCall(node, callable, CallDescriptor::kPatchableCallSite);
+}
+
+
+void JSGenericLowering::LowerJSStoreProperty(Node* node) {
   StrictMode strict_mode = OpParameter<StrictMode>(node);
   Callable callable = CodeFactory::KeyedStoreIC(isolate(), strict_mode);
   ReplaceWithStubCall(node, callable, CallDescriptor::kPatchableCallSite);
-  return node;
 }
 
 
-Node* JSGenericLowering::LowerJSStoreNamed(Node* node) {
+void JSGenericLowering::LowerJSStoreNamed(Node* node) {
   StoreNamedParameters params = OpParameter<StoreNamedParameters>(node);
   Callable callable = CodeFactory::StoreIC(isolate(), params.strict_mode);
   PatchInsertInput(node, 1, jsgraph()->HeapConstant(params.name));
   ReplaceWithStubCall(node, callable, CallDescriptor::kPatchableCallSite);
-  return node;
 }
 
 
-Node* JSGenericLowering::LowerJSDeleteProperty(Node* node) {
+void JSGenericLowering::LowerJSDeleteProperty(Node* node) {
   StrictMode strict_mode = OpParameter<StrictMode>(node);
   PatchInsertInput(node, 2, SmiConstant(strict_mode));
   ReplaceWithBuiltinCall(node, Builtins::DELETE, 3);
-  return node;
 }
 
 
-Node* JSGenericLowering::LowerJSHasProperty(Node* node) {
+void JSGenericLowering::LowerJSHasProperty(Node* node) {
   ReplaceWithBuiltinCall(node, Builtins::IN, 2);
-  return node;
 }
 
 
-Node* JSGenericLowering::LowerJSInstanceOf(Node* node) {
+void JSGenericLowering::LowerJSInstanceOf(Node* node) {
   InstanceofStub::Flags flags = static_cast<InstanceofStub::Flags>(
       InstanceofStub::kReturnTrueFalseObject |
       InstanceofStub::kArgsInRegisters);
   InstanceofStub stub(isolate(), flags);
   CallInterfaceDescriptor d = stub.GetCallInterfaceDescriptor();
   CallDescriptor* desc = linkage()->GetStubCallDescriptor(d, 0);
   Node* stub_code = CodeConstant(stub.GetCode());
   PatchInsertInput(node, 0, stub_code);
   PatchOperator(node, common()->Call(desc));
-  return node;
 }
 
 
-Node* JSGenericLowering::LowerJSLoadContext(Node* node) {
+void JSGenericLowering::LowerJSLoadContext(Node* node) {
   ContextAccess access = OpParameter<ContextAccess>(node);
   // TODO(mstarzinger): Use simplified operators instead of machine operators
   // here so that load/store optimization can be applied afterwards.
   for (int i = 0; i < access.depth(); ++i) {
     node->ReplaceInput(
         0, graph()->NewNode(
                machine()->Load(kMachAnyTagged),
                NodeProperties::GetValueInput(node, 0),
                Int32Constant(Context::SlotOffset(Context::PREVIOUS_INDEX)),
                NodeProperties::GetEffectInput(node)));
   }
   node->ReplaceInput(1, Int32Constant(Context::SlotOffset(access.index())));
   PatchOperator(node, machine()->Load(kMachAnyTagged));
-  return node;
 }
 
 
-Node* JSGenericLowering::LowerJSStoreContext(Node* node) {
+void JSGenericLowering::LowerJSStoreContext(Node* node) {
   ContextAccess access = OpParameter<ContextAccess>(node);
   // TODO(mstarzinger): Use simplified operators instead of machine operators
   // here so that load/store optimization can be applied afterwards.
   for (int i = 0; i < access.depth(); ++i) {
     node->ReplaceInput(
         0, graph()->NewNode(
                machine()->Load(kMachAnyTagged),
                NodeProperties::GetValueInput(node, 0),
                Int32Constant(Context::SlotOffset(Context::PREVIOUS_INDEX)),
                NodeProperties::GetEffectInput(node)));
   }
   node->ReplaceInput(2, NodeProperties::GetValueInput(node, 1));
   node->ReplaceInput(1, Int32Constant(Context::SlotOffset(access.index())));
   PatchOperator(node, machine()->Store(StoreRepresentation(kMachAnyTagged,
                                                            kFullWriteBarrier)));
-  return node;
 }
 
 
-Node* JSGenericLowering::LowerJSCallConstruct(Node* node) {
+void JSGenericLowering::LowerJSCallConstruct(Node* node) {
   int arity = OpParameter<int>(node);
   CallConstructStub stub(isolate(), NO_CALL_CONSTRUCTOR_FLAGS);
   CallInterfaceDescriptor d = stub.GetCallInterfaceDescriptor();
   CallDescriptor* desc =
       linkage()->GetStubCallDescriptor(d, arity, FlagsForNode(node));
   Node* stub_code = CodeConstant(stub.GetCode());
   Node* construct = NodeProperties::GetValueInput(node, 0);
   PatchInsertInput(node, 0, stub_code);
   PatchInsertInput(node, 1, Int32Constant(arity - 1));
   PatchInsertInput(node, 2, construct);
   PatchInsertInput(node, 3, jsgraph()->UndefinedConstant());
   PatchOperator(node, common()->Call(desc));
-  return node;
 }
 
 
-Node* JSGenericLowering::LowerJSCallFunction(Node* node) {
+void JSGenericLowering::LowerJSCallFunction(Node* node) {
   CallParameters p = OpParameter<CallParameters>(node);
   CallFunctionStub stub(isolate(), p.arity - 2, p.flags);
   CallInterfaceDescriptor d = stub.GetCallInterfaceDescriptor();
   CallDescriptor* desc =
       linkage()->GetStubCallDescriptor(d, p.arity - 1, FlagsForNode(node));
   Node* stub_code = CodeConstant(stub.GetCode());
   PatchInsertInput(node, 0, stub_code);
   PatchOperator(node, common()->Call(desc));
-  return node;
 }
 
 
-Node* JSGenericLowering::LowerJSCallRuntime(Node* node) {
+void JSGenericLowering::LowerJSCallRuntime(Node* node) {
   Runtime::FunctionId function = OpParameter<Runtime::FunctionId>(node);
   int arity = OperatorProperties::GetValueInputCount(node->op());
   ReplaceWithRuntimeCall(node, function, arity);
-  return node;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8