Remove the obsolete OverwriteMode optimization.

src/ic/ic-state.h

 // 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.
 
 #ifndef V8_IC_STATE_H_
 #define V8_IC_STATE_H_
 
 #include "src/macro-assembler.h"
 
 namespace v8 {
@@ skipping 36 matching lines @@
   class CallTypeBits : public BitField<CallType, Code::kArgumentsBits, 1> {};
 
   const int argc_;
   const CallType call_type_;
 };
 
 
 std::ostream& operator<<(std::ostream& os, const CallICState& s);
 
 
-// Mode to overwrite BinaryExpression values.
-enum OverwriteMode { NO_OVERWRITE, OVERWRITE_LEFT, OVERWRITE_RIGHT };
-
 class BinaryOpICState FINAL BASE_EMBEDDED {
  public:
   BinaryOpICState(Isolate* isolate, ExtraICState extra_ic_state);
 
-  BinaryOpICState(Isolate* isolate, Token::Value op, OverwriteMode mode)
+  BinaryOpICState(Isolate* isolate, Token::Value op)
       : op_(op),
-        mode_(mode),
         left_kind_(NONE),
         right_kind_(NONE),
         result_kind_(NONE),
         isolate_(isolate) {
     DCHECK_LE(FIRST_TOKEN, op);
     DCHECK_LE(op, LAST_TOKEN);
   }
 
   InlineCacheState GetICState() const {
     if (Max(left_kind_, right_kind_) == NONE) {
       return ::v8::internal::UNINITIALIZED;
     }
     if (Max(left_kind_, right_kind_) == GENERIC) {
       return ::v8::internal::MEGAMORPHIC;
     }
     if (Min(left_kind_, right_kind_) == GENERIC) {
       return ::v8::internal::GENERIC;
     }
     return ::v8::internal::MONOMORPHIC;
   }
 
   ExtraICState GetExtraICState() const;
 
   static void GenerateAheadOfTime(Isolate*,
                                   void (*Generate)(Isolate*,
                                                    const BinaryOpICState&));
 
-  bool CanReuseDoubleBox() const {
-    return (result_kind_ > SMI && result_kind_ <= NUMBER) &&
-           ((mode_ == OVERWRITE_LEFT && left_kind_ > SMI &&
-             left_kind_ <= NUMBER) ||
-            (mode_ == OVERWRITE_RIGHT && right_kind_ > SMI &&
-             right_kind_ <= NUMBER));
-  }
-
   // Returns true if the IC _could_ create allocation mementos.
   bool CouldCreateAllocationMementos() const {
     if (left_kind_ == STRING || right_kind_ == STRING) {
       DCHECK_EQ(Token::ADD, op_);
       return true;
     }
     return false;
   }
 
   // Returns true if the IC _should_ create allocation mementos.
   bool ShouldCreateAllocationMementos() const {
     return FLAG_allocation_site_pretenuring && CouldCreateAllocationMementos();
   }
 
   bool HasSideEffects() const {
     return Max(left_kind_, right_kind_) == GENERIC;
   }
 
   // Returns true if the IC should enable the inline smi code (i.e. if either
   // parameter may be a smi).
   bool UseInlinedSmiCode() const {
     return KindMaybeSmi(left_kind_) || KindMaybeSmi(right_kind_);
   }
 
   static const int FIRST_TOKEN = Token::BIT_OR;
   static const int LAST_TOKEN = Token::MOD;
 
   Token::Value op() const { return op_; }
-  OverwriteMode mode() const { return mode_; }
   Maybe<int> fixed_right_arg() const { return fixed_right_arg_; }
 
   Type* GetLeftType(Zone* zone) const { return KindToType(left_kind_, zone); }
   Type* GetRightType(Zone* zone) const { return KindToType(right_kind_, zone); }
   Type* GetResultType(Zone* zone) const;
 
   void Update(Handle<Object> left, Handle<Object> right, Handle<Object> result);
 
   Isolate* isolate() const { return isolate_; }
 
  private:
   friend std::ostream& operator<<(std::ostream& os, const BinaryOpICState& s);
 
   enum Kind { NONE, SMI, INT32, NUMBER, STRING, GENERIC };
 
   Kind UpdateKind(Handle<Object> object, Kind kind) const;
 
   static const char* KindToString(Kind kind);
   static Type* KindToType(Kind kind, Zone* zone);
   static bool KindMaybeSmi(Kind kind) {
     return (kind >= SMI && kind <= NUMBER) || kind == GENERIC;
   }
 
   // We truncate the last bit of the token.
   STATIC_ASSERT(LAST_TOKEN - FIRST_TOKEN < (1 << 4));
   class OpField : public BitField<int, 0, 4> {};
-  class OverwriteModeField : public BitField<OverwriteMode, 4, 2> {};
-  class ResultKindField : public BitField<Kind, 6, 3> {};
-  class LeftKindField : public BitField<Kind, 9, 3> {};
+  class ResultKindField : public BitField<Kind, 4, 3> {};
+  class LeftKindField : public BitField<Kind, 7, 3> {};
   // When fixed right arg is set, we don't need to store the right kind.
   // Thus the two fields can overlap.
-  class HasFixedRightArgField : public BitField<bool, 12, 1> {};
-  class FixedRightArgValueField : public BitField<int, 13, 4> {};
-  class RightKindField : public BitField<Kind, 13, 3> {};
+  class HasFixedRightArgField : public BitField<bool, 10, 1> {};
+  class FixedRightArgValueField : public BitField<int, 11, 4> {};
+  class RightKindField : public BitField<Kind, 11, 3> {};
 
   Token::Value op_;
-  OverwriteMode mode_;
   Kind left_kind_;
   Kind right_kind_;
   Kind result_kind_;
   Maybe<int> fixed_right_arg_;
   Isolate* isolate_;
 };
 
 
 std::ostream& operator<<(std::ostream& os, const BinaryOpICState& s);
 
@@ skipping 51 matching lines @@
  private:
   class ContextualModeBits : public BitField<ContextualMode, 0, 1> {};
   STATIC_ASSERT(static_cast<int>(NOT_CONTEXTUAL) == 0);
 
   const ExtraICState state_;
 };
 }
 }
 
 #endif  // V8_IC_STATE_H_