[strong] Disallow implicit conversions for binary arithmetic operations

src/ic/ic.cc

 // Copyright 2012 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/accessors.h"
 #include "src/api.h"
 #include "src/arguments.h"
 #include "src/base/bits.h"
@@ skipping 2550 matching lines @@
 }
 
 
 MaybeHandle<Object> BinaryOpIC::Transition(
     Handle<AllocationSite> allocation_site, Handle<Object> left,
     Handle<Object> right) {
   BinaryOpICState state(isolate(), target()->extra_ic_state());
 
   // Compute the actual result using the builtin for the binary operation.
   Object* builtin = isolate()->js_builtins_object()->javascript_builtin(
-      TokenToJSBuiltin(state.op()));
+      TokenToJSBuiltin(state.op(), state.language_mode()));
   Handle<JSFunction> function = handle(JSFunction::cast(builtin), isolate());
   Handle<Object> result;
   ASSIGN_RETURN_ON_EXCEPTION(
       isolate(), result, Execution::Call(isolate(), function, left, 1, &right),
       Object);
 
   // Do not try to update the target if the code was marked for lazy
   // deoptimization. (Since we do not relocate addresses in these
   // code objects, an attempt to access the target could fail.)
   if (AddressIsDeoptimizedCode()) {
@@ skipping 216 matching lines @@
 }
 
 
 RUNTIME_FUNCTION(Unreachable) {
   UNREACHABLE();
   CHECK(false);
   return isolate->heap()->undefined_value();
 }
 
 
-Builtins::JavaScript BinaryOpIC::TokenToJSBuiltin(Token::Value op) {
+Builtins::JavaScript BinaryOpIC::TokenToJSBuiltin(Token::Value op,
+                                                  LanguageMode language_mode) {
   switch (op) {
     default:
       UNREACHABLE();
     case Token::ADD:
       return Builtins::ADD;
       break;
     case Token::SUB:
-      return Builtins::SUB;
+      return is_strong(language_mode) ? Builtins::SUB_STRONG : Builtins::SUB;

[rossberg, 2015/04/23 13:29:37]

Nit: considering that you'll have to add the same to every case eventually, it
seems better to transpose the switch and conditional.

Btw, all the breaks in this switch can be removed.

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

Done.

       break;
     case Token::MUL:
-      return Builtins::MUL;
+      return is_strong(language_mode) ? Builtins::MUL_STRONG : Builtins::MUL;
       break;
     case Token::DIV:
-      return Builtins::DIV;
+      return is_strong(language_mode) ? Builtins::DIV_STRONG : Builtins::DIV;
       break;
     case Token::MOD:
-      return Builtins::MOD;
+      return is_strong(language_mode) ? Builtins::MOD_STRONG : Builtins::MOD;
       break;
     case Token::BIT_OR:
       return Builtins::BIT_OR;
       break;
     case Token::BIT_AND:
       return Builtins::BIT_AND;
       break;
     case Token::BIT_XOR:
       return Builtins::BIT_XOR;
       break;
@@ skipping 209 matching lines @@
 static const Address IC_utilities[] = {
 #define ADDR(name) FUNCTION_ADDR(name),
     IC_UTIL_LIST(ADDR) NULL
 #undef ADDR
 };
 
 
 Address IC::AddressFromUtilityId(IC::UtilityId id) { return IC_utilities[id]; }
 }
 }  // namespace v8::internal