[strong] Disallow implicit conversions for binary arithmetic operations

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 195 matching lines @@
   DCHECK_EQ(IrOpcode::kJSStoreNamed, op->opcode());
   return OpParameter<StoreNamedParameters>(op);
 }
 
 
 #define CACHED_OP_LIST(V)                                 \
   V(Equal, Operator::kNoProperties, 2, 1)                 \
   V(NotEqual, Operator::kNoProperties, 2, 1)              \
   V(StrictEqual, Operator::kPure, 2, 1)                   \
   V(StrictNotEqual, Operator::kPure, 2, 1)                \
-  V(LessThan, Operator::kNoProperties, 2, 1)              \
-  V(GreaterThan, Operator::kNoProperties, 2, 1)           \
-  V(LessThanOrEqual, Operator::kNoProperties, 2, 1)       \
-  V(GreaterThanOrEqual, Operator::kNoProperties, 2, 1)    \
-  V(BitwiseOr, Operator::kNoProperties, 2, 1)             \
-  V(BitwiseXor, Operator::kNoProperties, 2, 1)            \
-  V(BitwiseAnd, Operator::kNoProperties, 2, 1)            \
-  V(ShiftLeft, Operator::kNoProperties, 2, 1)             \
-  V(ShiftRight, Operator::kNoProperties, 2, 1)            \
-  V(ShiftRightLogical, Operator::kNoProperties, 2, 1)     \
-  V(Add, Operator::kNoProperties, 2, 1)                   \
-  V(Subtract, Operator::kNoProperties, 2, 1)              \
-  V(Multiply, Operator::kNoProperties, 2, 1)              \
-  V(Divide, Operator::kNoProperties, 2, 1)                \
-  V(Modulus, Operator::kNoProperties, 2, 1)               \
-  V(UnaryNot, Operator::kPure, 1, 1)                      \
   V(ToBoolean, Operator::kPure, 1, 1)                     \
   V(ToNumber, Operator::kNoProperties, 1, 1)              \
   V(ToString, Operator::kNoProperties, 1, 1)              \
   V(ToName, Operator::kNoProperties, 1, 1)                \
   V(ToObject, Operator::kNoProperties, 1, 1)              \
   V(Yield, Operator::kNoProperties, 1, 1)                 \
   V(Create, Operator::kEliminatable, 0, 1)                \
   V(HasProperty, Operator::kNoProperties, 2, 1)           \
   V(TypeOf, Operator::kPure, 1, 1)                        \
   V(InstanceOf, Operator::kNoProperties, 2, 1)            \
   V(StackCheck, Operator::kNoProperties, 0, 0)            \
   V(CreateFunctionContext, Operator::kNoProperties, 1, 1) \
   V(CreateWithContext, Operator::kNoProperties, 2, 1)     \
   V(CreateBlockContext, Operator::kNoProperties, 2, 1)    \
   V(CreateModuleContext, Operator::kNoProperties, 2, 1)   \
   V(CreateScriptContext, Operator::kNoProperties, 2, 1)
 
+#define CACHED_OP_LIST_WITH_STRONG(V)                     \

[Michael Starzinger, 2015/04/23 13:47:51]

nit: s/WITH_STRONG/WITH_LANGUAGE_MODE/

[conradw, 2015/04/23 14:51:54]

These operators are specifically associated with a macro which caches
exactly sloppy and strong versions. I wanted to avoid name oddness re.
other operators which might vary their semantics for different
combinations of language mode, and may in future get their own macros
(if StoreProperty were no longer the only operator to need a
sloppy/strict version, CACHED_OP_LIST_WITH_STRICT?)

[Michael Starzinger, 2015/04/23 15:20:53]

Yep, the implementation only provides caches for SLOPPY and STRONG, but the
interface is still providing the full language mode. As for the case that we
ever need another second order macro, we can revisit the naming then. I still
think CACHED_OP_LIST_WITH_LANGUAGE_MODE makes more sense because it best
describes the interface provided for those operators.

[conradw, 2015/04/23 16:08:02]

I'd like to keep something in the code drawing attention to the fact that it's
sloppy/strong. What do you think of the next change?

+  V(LessThan, Operator::kNoProperties, 2, 1)              \
+  V(GreaterThan, Operator::kNoProperties, 2, 1)           \
+  V(LessThanOrEqual, Operator::kNoProperties, 2, 1)       \
+  V(GreaterThanOrEqual, Operator::kNoProperties, 2, 1)    \
+  V(BitwiseOr, Operator::kNoProperties, 2, 1)             \
+  V(BitwiseXor, Operator::kNoProperties, 2, 1)            \
+  V(BitwiseAnd, Operator::kNoProperties, 2, 1)            \
+  V(ShiftLeft, Operator::kNoProperties, 2, 1)             \
+  V(ShiftRight, Operator::kNoProperties, 2, 1)            \
+  V(ShiftRightLogical, Operator::kNoProperties, 2, 1)     \
+  V(Add, Operator::kNoProperties, 2, 1)                   \
+  V(Subtract, Operator::kNoProperties, 2, 1)              \
+  V(Multiply, Operator::kNoProperties, 2, 1)              \
+  V(Divide, Operator::kNoProperties, 2, 1)                \
+  V(Modulus, Operator::kNoProperties, 2, 1)               \
+  V(UnaryNot, Operator::kPure, 1, 1)
+
 
 struct JSOperatorGlobalCache final {
 #define CACHED(Name, properties, value_input_count, value_output_count)  \
   struct Name##Operator final : public Operator {                        \
     Name##Operator()                                                     \
         : Operator(IrOpcode::kJS##Name, properties, "JS" #Name,          \
                    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(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<STRONG> k##Name##StrongOperator;
+  CACHED_OP_LIST_WITH_STRONG(CACHED)
+#undef CACHED
+
   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;
   StorePropertyOperator<STRICT> kStorePropertyStrictOperator;
 };
 
 
 static base::LazyInstance<JSOperatorGlobalCache>::type kCache =
     LAZY_INSTANCE_INITIALIZER;
 
 
 JSOperatorBuilder::JSOperatorBuilder(Zone* zone)
     : cache_(kCache.Get()), zone_(zone) {}
 
 
 #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(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;                             \
+  }                                                                     \
+  UNREACHABLE();                                                        \
+  return nullptr;                                                       \
+}
+CACHED_OP_LIST_WITH_STRONG(CACHED)
+#undef CACHED
 
 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 105 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