Remove strong mode support from binary 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/ic/ic-state.h"
 
 #include "src/ic/ic.h"
 
 namespace v8 {
 namespace internal {
@@ skipping 19 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_ = StrengthField::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_) | StrengthField::encode(strong_) |
+      ResultKindField::encode(result_kind_) |
       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, Strength::WEAK);  \
+    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);                            \
   } 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);
@@ skipping 81 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, Strength::WEAK);             \
+    BinaryOpICState state(isolate, op);                             \
     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 13 matching lines @@
     return Type::Unsigned32();
   }
   DCHECK_NE(GENERIC, result_kind);
   return KindToType(result_kind);
 }
 
 
 std::ostream& operator<<(std::ostream& os, const BinaryOpICState& s) {
   os << "(" << Token::Name(s.op_);
   if (s.CouldCreateAllocationMementos()) os << "_CreateAllocationMementos";
-  if (is_strong(s.strength())) os << "_Strong";
   os << ":" << BinaryOpICState::KindToString(s.left_kind_) << "*";
   if (s.fixed_right_arg_.IsJust()) {
     os << s.fixed_right_arg_.FromJust();
   } else {
     os << BinaryOpICState::KindToString(s.right_kind_);
   }
   return os << "->" << BinaryOpICState::KindToString(s.result_kind_) << ")";
 }
 
 
@@ skipping 279 matching lines @@
     case RECEIVER:
     case GENERIC:
       return GENERIC;
   }
   UNREACHABLE();
   return GENERIC;  // Make the compiler happy.
 }
 
 }  // namespace internal
 }  // namespace v8