[turbofan] Sanitize language mode for javascript operators.

src/compiler/js-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/js-operator.h"
 
 #include <limits>
 
 #include "src/base/lazy-instance.h"
 #include "src/compiler/opcodes.h"
@@ skipping 247 matching lines @@
                    value_input_count, Operator::ZeroIfPure(properties),  \
                    Operator::ZeroIfEliminatable(properties),             \
                    value_output_count, Operator::ZeroIfPure(properties), \
                    Operator::ZeroIfNoThrow(properties)) {}               \
   };                                                                     \
   Name##Operator k##Name##Operator;
   CACHED_OP_LIST(CACHED)
 #undef CACHED
 
 
-#define CACHED_WITH_STRONG(Name, properties, value_input_count,                \
-                           value_output_count)                                 \
-  template <LanguageMode kLanguageMode>                                        \
-  struct Name##Operator final : public Operator1<LanguageMode> {               \
-    Name##Operator()                                                           \
-        : Operator1<LanguageMode>(IrOpcode::kJS##Name, properties, "JS" #Name, \
-                   value_input_count, Operator::ZeroIfPure(properties),        \
-                   Operator::ZeroIfEliminatable(properties),                   \
-                   value_output_count, Operator::ZeroIfPure(properties),       \
-                   Operator::ZeroIfNoThrow(properties), kLanguageMode) {}      \
-  };                                                                           \
-  Name##Operator<SLOPPY> k##Name##SloppyOperator;                              \
+#define CACHED_WITH_LANGUAGE_MODE(Name, properties, value_input_count,        \
+                                  value_output_count)                         \
+  template <LanguageMode kLanguageMode>                                       \
+  struct Name##Operator final : public Operator1<LanguageMode> {              \
+    Name##Operator()                                                          \
+        : Operator1<LanguageMode>(                                            \
+              IrOpcode::kJS##Name, properties, "JS" #Name, value_input_count, \
+              Operator::ZeroIfPure(properties),                               \
+              Operator::ZeroIfEliminatable(properties), value_output_count,   \
+              Operator::ZeroIfPure(properties),                               \
+              Operator::ZeroIfNoThrow(properties), kLanguageMode) {}          \
+  };                                                                          \
+  Name##Operator<SLOPPY> k##Name##SloppyOperator;                             \
+  Name##Operator<STRICT> k##Name##StrictOperator;                             \

[conradw, 2015/04/27 10:23:52]

This change means that operators which behave identically in sloppy and strict
mode have separate cached versions for the two modes. This seems odd, especially
since Store only caches sloppy and strict versions. Also, as it stands
currently, none of the strict cached operators here are ever used by any code.

   Name##Operator<STRONG> k##Name##StrongOperator;
-  CACHED_OP_LIST_WITH_LANGUAGE_MODE(CACHED_WITH_STRONG)
-#undef CACHED_WITH_STRONG
+  CACHED_OP_LIST_WITH_LANGUAGE_MODE(CACHED_WITH_LANGUAGE_MODE)
+#undef CACHED_WITH_LANGUAGE_MODE
 
 
   template <LanguageMode kLanguageMode>
   struct StorePropertyOperator final : public Operator1<LanguageMode> {
     StorePropertyOperator()
         : Operator1<LanguageMode>(IrOpcode::kJSStoreProperty,
                                   Operator::kNoProperties, "JSStoreProperty", 3,
                                   1, 1, 0, 1, 2, kLanguageMode) {}
   };
   StorePropertyOperator<SLOPPY> kStorePropertySloppyOperator;
@@ skipping 10 matching lines @@
 
 
 #define CACHED(Name, properties, value_input_count, value_output_count) \
   const Operator* JSOperatorBuilder::Name() {                           \
     return &cache_.k##Name##Operator;                                   \
   }
 CACHED_OP_LIST(CACHED)
 #undef CACHED
 
 
-#define CACHED_WITH_STRONG(Name, properties, value_input_count,         \
-                           value_output_count)                          \
+#define CACHED_WITH_LANGUAGE_MODE(Name, properties, value_input_count,  \
+                                  value_output_count)                   \
   const Operator* JSOperatorBuilder::Name(LanguageMode language_mode) { \
-    if (is_strong(language_mode)) {                                     \
-      return &cache_.k##Name##StrongOperator;                           \
-    } else {                                                            \
-      return &cache_.k##Name##SloppyOperator;                           \
+    switch (language_mode) {                                            \
+      case SLOPPY:                                                      \
+        return &cache_.k##Name##SloppyOperator;                         \
+      case STRICT:                                                      \
+        return &cache_.k##Name##StrictOperator;                         \
+      case STRONG:                                                      \
+        return &cache_.k##Name##StrongOperator;                         \
+      case STRONG_BIT:                                                  \
+        break; /* %*!%^$#@ */                                           \
     }                                                                   \
     UNREACHABLE();                                                      \
     return nullptr;                                                     \
   }
-CACHED_OP_LIST_WITH_LANGUAGE_MODE(CACHED_WITH_STRONG)
-#undef CACHED_WITH_STRONG
+CACHED_OP_LIST_WITH_LANGUAGE_MODE(CACHED_WITH_LANGUAGE_MODE)
+#undef CACHED_WITH_LANGUAGE_MODE
 
 
 const Operator* JSOperatorBuilder::CallFunction(size_t arity,
                                                 CallFunctionFlags flags) {
   CallFunctionParameters parameters(arity, flags);
   return new (zone()) Operator1<CallFunctionParameters>(   // --
       IrOpcode::kJSCallFunction, Operator::kNoProperties,  // opcode
       "JSCallFunction",                                    // name
       parameters.arity(), 1, 1, 1, 1, 2,                   // inputs/outputs
       parameters);                                         // parameter
@@ skipping 106 matching lines @@
   return new (zone()) Operator1<Unique<String>>(                 // --
       IrOpcode::kJSCreateCatchContext, Operator::kNoProperties,  // opcode
       "JSCreateCatchContext",                                    // name
       2, 1, 1, 1, 1, 2,                                          // counts
       name);                                                     // parameter
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8