Require SSE2 support for the ia32 port.

src/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 "v8.h"
 
 #include "accessors.h"
 #include "api.h"
 #include "arguments.h"
 #include "codegen.h"
@@ skipping 2089 matching lines @@
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
       isolate, result,
       Runtime::SetObjectProperty(
           isolate, object, key, value, NONE, strict_mode));
   return *result;
 }
 
 
 BinaryOpIC::State::State(Isolate* isolate, ExtraICState extra_ic_state)
     : isolate_(isolate) {
-  // We don't deserialize the SSE2 Field, since this is only used to be able
-  // to include SSE2 as well as non-SSE2 versions in the snapshot. For code
-  // generation we always want it to reflect the current state.
   op_ = static_cast<Token::Value>(
       FIRST_TOKEN + OpField::decode(extra_ic_state));
   mode_ = OverwriteModeField::decode(extra_ic_state);
   fixed_right_arg_ = Maybe<int>(
       HasFixedRightArgField::decode(extra_ic_state),
       1 << FixedRightArgValueField::decode(extra_ic_state));
   left_kind_ = LeftKindField::decode(extra_ic_state);
   if (fixed_right_arg_.has_value) {
     right_kind_ = Smi::IsValid(fixed_right_arg_.value) ? SMI : INT32;
   } else {
     right_kind_ = RightKindField::decode(extra_ic_state);
   }
   result_kind_ = ResultKindField::decode(extra_ic_state);
   ASSERT_LE(FIRST_TOKEN, op_);
   ASSERT_LE(op_, LAST_TOKEN);
 }
 
 
 ExtraICState BinaryOpIC::State::GetExtraICState() const {
-  bool sse2 = (Max(result_kind_, Max(left_kind_, right_kind_)) > SMI &&
-               CpuFeatures::IsSafeForSnapshot(isolate(), SSE2));
   ExtraICState extra_ic_state =
-      SSE2Field::encode(sse2) |
       OpField::encode(op_ - FIRST_TOKEN) |
       OverwriteModeField::encode(mode_) |
       LeftKindField::encode(left_kind_) |
       ResultKindField::encode(result_kind_) |
       HasFixedRightArgField::encode(fixed_right_arg_.has_value);
   if (fixed_right_arg_.has_value) {
     extra_ic_state = FixedRightArgValueField::update(
         extra_ic_state, WhichPowerOf2(fixed_right_arg_.value));
   } else {
     extra_ic_state = RightKindField::update(extra_ic_state, right_kind_);
@@ skipping 300 matching lines @@
   if ((mode_ == OVERWRITE_LEFT && left_kind_ > NUMBER) ||
       (mode_ == OVERWRITE_RIGHT && right_kind_ > NUMBER) ||
       result_kind_ > NUMBER) {
     mode_ = NO_OVERWRITE;
   }
 
   if (old_extra_ic_state == GetExtraICState()) {
     // Tagged operations can lead to non-truncating HChanges
     if (left->IsUndefined() || left->IsBoolean()) {
       left_kind_ = GENERIC;
-    } else if (right->IsUndefined() || right->IsBoolean()) {
+    } else {
+      ASSERT(right->IsUndefined() || right->IsBoolean());
       right_kind_ = GENERIC;
-    } else {
-      // Since the X87 is too precise, we might bail out on numbers which
-      // actually would truncate with 64 bit precision.
-      ASSERT(!CpuFeatures::IsSupported(SSE2));
-      ASSERT(result_kind_ < NUMBER);
-      result_kind_ = NUMBER;
     }
   }
 }
 
 
 BinaryOpIC::State::Kind BinaryOpIC::State::UpdateKind(Handle<Object> object,
                                                       Kind kind) const {
   Kind new_kind = GENERIC;
   bool is_truncating = Token::IsTruncatingBinaryOp(op());
   if (object->IsBoolean() && is_truncating) {
@@ skipping 522 matching lines @@
 #undef ADDR
 };
 
 
 Address IC::AddressFromUtilityId(IC::UtilityId id) {
   return IC_utilities[id];
 }
 
 
 } }  // namespace v8::internal