[strong] Disallow implicit conversions for binary arithmetic operations

src/ic/ic-state.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/v8.h"
 
 #include "src/ic/ic.h"
 #include "src/ic/ic-state.h"
 
 namespace v8 {
@@ skipping 34 matching lines @@
 
 
 BinaryOpICState::BinaryOpICState(Isolate* isolate, ExtraICState extra_ic_state)
     : fixed_right_arg_(
           HasFixedRightArgField::decode(extra_ic_state)
               ? Just(1 << FixedRightArgValueField::decode(extra_ic_state))
               : Nothing<int>()),
       isolate_(isolate) {
   op_ =
       static_cast<Token::Value>(FIRST_TOKEN + OpField::decode(extra_ic_state));
+  strong_ = StrongField::decode(extra_ic_state);
   left_kind_ = LeftKindField::decode(extra_ic_state);
   right_kind_ = fixed_right_arg_.IsJust()
                     ? (Smi::IsValid(fixed_right_arg_.FromJust()) ? SMI : INT32)
                     : RightKindField::decode(extra_ic_state);
   result_kind_ = ResultKindField::decode(extra_ic_state);
   DCHECK_LE(FIRST_TOKEN, op_);
   DCHECK_LE(op_, LAST_TOKEN);
 }
 
 
 ExtraICState BinaryOpICState::GetExtraICState() const {
   ExtraICState extra_ic_state =
       OpField::encode(op_ - FIRST_TOKEN) | LeftKindField::encode(left_kind_) |
       ResultKindField::encode(result_kind_) |
+      StrongField::encode(strong_) |
       HasFixedRightArgField::encode(fixed_right_arg_.IsJust());
   if (fixed_right_arg_.IsJust()) {
     extra_ic_state = FixedRightArgValueField::update(
         extra_ic_state, WhichPowerOf2(fixed_right_arg_.FromJust()));
   } else {
     extra_ic_state = RightKindField::update(extra_ic_state, right_kind_);
   }
   return extra_ic_state;
 }
 
 
 // static
 void BinaryOpICState::GenerateAheadOfTime(
     Isolate* isolate, void (*Generate)(Isolate*, const BinaryOpICState&)) {
 // TODO(olivf) We should investigate why adding stubs to the snapshot is so
 // expensive at runtime. When solved we should be able to add most binops to
 // the snapshot instead of hand-picking them.
 // Generated list of commonly used stubs
-#define GENERATE(op, left_kind, right_kind, result_kind) \
-  do {                                                   \
-    BinaryOpICState state(isolate, op);                  \
-    state.left_kind_ = left_kind;                        \
-    state.fixed_right_arg_ = Nothing<int>();             \
-    state.right_kind_ = right_kind;                      \
-    state.result_kind_ = result_kind;                    \
-    Generate(isolate, state);                            \
+#define GENERATE(op, left_kind, right_kind, result_kind)      \
+  do {                                                        \
+    BinaryOpICState state(isolate, op, LanguageMode::SLOPPY); \
+    state.left_kind_ = left_kind;                             \
+    state.fixed_right_arg_ = Nothing<int>();                  \
+    state.right_kind_ = right_kind;                           \
+    state.result_kind_ = result_kind;                         \
+    Generate(isolate, state);                                 \
   } while (false)
   GENERATE(Token::ADD, INT32, INT32, INT32);
   GENERATE(Token::ADD, INT32, INT32, NUMBER);
   GENERATE(Token::ADD, INT32, NUMBER, NUMBER);
   GENERATE(Token::ADD, INT32, SMI, INT32);
   GENERATE(Token::ADD, NUMBER, INT32, NUMBER);
   GENERATE(Token::ADD, NUMBER, NUMBER, NUMBER);
   GENERATE(Token::ADD, NUMBER, SMI, NUMBER);
   GENERATE(Token::ADD, SMI, INT32, INT32);
   GENERATE(Token::ADD, SMI, INT32, NUMBER);
@@ skipping 76 matching lines @@
   GENERATE(Token::SUB, INT32, SMI, INT32);
   GENERATE(Token::SUB, NUMBER, INT32, NUMBER);
   GENERATE(Token::SUB, NUMBER, NUMBER, NUMBER);
   GENERATE(Token::SUB, NUMBER, SMI, NUMBER);
   GENERATE(Token::SUB, SMI, INT32, INT32);
   GENERATE(Token::SUB, SMI, NUMBER, NUMBER);
   GENERATE(Token::SUB, SMI, SMI, SMI);
 #undef GENERATE
 #define GENERATE(op, left_kind, fixed_right_arg_value, result_kind) \
   do {                                                              \
-    BinaryOpICState state(isolate, op);                             \
+    BinaryOpICState state(isolate, op, LanguageMode::SLOPPY);       \
     state.left_kind_ = left_kind;                                   \
     state.fixed_right_arg_ = Just(fixed_right_arg_value);           \
     state.right_kind_ = SMI;                                        \
     state.result_kind_ = result_kind;                               \
     Generate(isolate, state);                                       \
   } while (false)
   GENERATE(Token::MOD, SMI, 2, SMI);
   GENERATE(Token::MOD, SMI, 4, SMI);
   GENERATE(Token::MOD, SMI, 8, SMI);
   GENERATE(Token::MOD, SMI, 16, SMI);
@@ skipping 302 matching lines @@
     case UNIQUE_NAME:
     case OBJECT:
     case GENERIC:
       return GENERIC;
   }
   UNREACHABLE();
   return GENERIC;  // Make the compiler happy.
 }
 }
 }  // namespace v8::internal