[turbofan] Add control input to Load and LoadElements.

src/compiler/common-operator.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/compiler/common-operator.h"
 
 #include "src/assembler.h"
 #include "src/base/lazy-instance.h"
 #include "src/compiler/linkage.h"
 #include "src/unique.h"
@@ skipping 57 matching lines @@
 struct CommonOperatorBuilderImpl FINAL {
 #define SHARED(Name, properties, value_input_count, control_input_count)       \
   struct Name##Operator FINAL : public ControlOperator {                       \
     Name##Operator()                                                           \
         : ControlOperator(IrOpcode::k##Name, properties, value_input_count, 0, \
                           control_input_count, #Name) {}                       \
   };                                                                           \
   Name##Operator k##Name##Operator;
   SHARED_OP_LIST(SHARED)
 #undef SHARED
-
-  struct ControlEffectOperator FINAL : public SimpleOperator {
-    ControlEffectOperator()
-        : SimpleOperator(IrOpcode::kControlEffect, Operator::kPure, 0, 0,
-                         "ControlEffect") {}
-  };
-  ControlEffectOperator kControlEffectOperator;
 };
 
 
 static base::LazyInstance<CommonOperatorBuilderImpl>::type kImpl =
     LAZY_INSTANCE_INITIALIZER;
 
 
 CommonOperatorBuilder::CommonOperatorBuilder(Zone* zone)
     : impl_(kImpl.Get()), zone_(zone) {}
 
@@ skipping 87 matching lines @@
 }
 
 
 const Operator* CommonOperatorBuilder::EffectPhi(int arguments) {
   DCHECK(arguments > 0);  // Disallow empty phis.
   return new (zone()) Operator1<int>(IrOpcode::kEffectPhi, Operator::kPure, 0,
                                      0, "EffectPhi", arguments);
 }
 
 
-const Operator* CommonOperatorBuilder::ControlEffect() {
-  return &impl_.kControlEffectOperator;
-}
-
-
 const Operator* CommonOperatorBuilder::ValueEffect(int arguments) {
   DCHECK(arguments > 0);  // Disallow empty value effects.
   return new (zone()) SimpleOperator(IrOpcode::kValueEffect, Operator::kPure,
                                      arguments, 0, "ValueEffect");
 }
 
 
 const Operator* CommonOperatorBuilder::Finish(int arguments) {
   DCHECK(arguments > 0);  // Disallow empty finishes.
   return new (zone()) Operator1<int>(IrOpcode::kFinish, Operator::kPure, 1, 1,
@@ skipping 82 matching lines @@
 }
 
 
 bool OutputFrameStateCombine::IsOutputIgnored() {
   return kind() == kPushOutput && GetPushCount() == 0;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8