Towards removing dependency from generic lowering on compilation info.

src/compiler/js-operator.h

 // Copyright 2013 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.
 
 #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"
@@ skipping 33 matching lines @@
   ContextualMode contextual_mode;
 };
 
 // Defines the arity and the call flags for a JavaScript function call. This is
 // used as a parameter by JSCall operators.
 struct CallParameters {
   int arity;
   CallFunctionFlags flags;
 };
 
+// Defines the property being stored to an object by a named store. This is
+// used as a parameter by JSStoreNamed operators.
+struct StoreNamedParameters {
+  StrictMode strict_mode;
+  PrintableUnique<Name> name;
+};
+
 // Interface for building JavaScript-level operators, e.g. directly from the
 // AST. Most operators have no parameters, thus can be globally shared for all
 // graphs.
 class JSOperatorBuilder {
  public:
   explicit JSOperatorBuilder(Zone* zone) : zone_(zone) {}
 
 #define SIMPLE(name, properties, inputs, outputs) \
   return new (zone_)                              \
       SimpleOperator(IrOpcode::k##name, properties, inputs, outputs, #name);
@@ skipping 53 matching lines @@
   }
 
   Operator* LoadProperty() { BINOP(JSLoadProperty); }
   Operator* LoadNamed(PrintableUnique<Name> name,
                       ContextualMode contextual_mode = NOT_CONTEXTUAL) {
     LoadNamedParameters parameters = {name, contextual_mode};
     OP1(JSLoadNamed, LoadNamedParameters, parameters, Operator::kNoProperties,
         1, 1);
   }
 
-  Operator* StoreProperty() { NOPROPS(JSStoreProperty, 3, 0); }
-  Operator* StoreNamed(PrintableUnique<Name> name) {
-    OP1(JSStoreNamed, PrintableUnique<Name>, name, Operator::kNoProperties, 2,
+  Operator* StoreProperty(StrictMode strict_mode) {
+    OP1(JSStoreProperty, StrictMode, strict_mode, Operator::kNoProperties, 3,
         0);
   }
 
+  Operator* StoreNamed(StrictMode strict_mode, PrintableUnique<Name> name) {
+    StoreNamedParameters parameters = {strict_mode, name};
+    OP1(JSStoreNamed, StoreNamedParameters, parameters, Operator::kNoProperties,
+        2, 0);
+  }
+
   Operator* DeleteProperty(StrictMode strict_mode) {
     OP1(JSDeleteProperty, StrictMode, strict_mode, Operator::kNoProperties, 2,
         1);
   }
 
   Operator* HasProperty() { NOPROPS(JSHasProperty, 2, 1); }
 
   Operator* LoadContext(uint16_t depth, uint32_t index, bool immutable) {
     ContextAccess access(depth, index, immutable);
     OP1(JSLoadContext, ContextAccess, access,
@@ skipping 62 matching lines @@
   static int HashCode(Runtime::FunctionId val) { return static_cast<int>(val); }
   static bool Equals(Runtime::FunctionId a, Runtime::FunctionId b) {
     return a == b;
   }
 };
 }
 }
 }  // namespace v8::internal::compiler
 
 #endif  // V8_COMPILER_JS_OPERATOR_H_