Integer HConstants don't need to kDependsOnOsrEntries

src/hydrogen-instructions.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 1794 matching lines @@
   return BitCast<int64_t>(roundtrip_value) == BitCast<int64_t>(value);
 }
 
 
 HConstant::HConstant(Handle<Object> handle, Representation r)
     : handle_(handle),
       has_int32_value_(false),
       has_double_value_(false) {
   // Dereferencing here is safe: the value of a number object does not change.
   AllowHandleDereference allow_handle_deref(Isolate::Current());
-  SetFlag(kUseGVN);
   if (handle_->IsNumber()) {
     double n = handle_->Number();
     has_int32_value_ = IsInteger32(n);
     int32_value_ = DoubleToInt32(n);
     double_value_ = n;
     has_double_value_ = true;
   }
   if (r.IsNone()) {
     if (has_int32_value_) {
       r = Representation::Integer32();
     } else if (has_double_value_) {
       r = Representation::Double();
     } else {
       r = Representation::Tagged();
     }
   }
-  set_representation(r);
+  Initialize(r);
 }
 
 
 HConstant::HConstant(int32_t integer_value, Representation r)
     : has_int32_value_(true),
       has_double_value_(true),
       int32_value_(integer_value),
       double_value_(FastI2D(integer_value)) {
-  set_representation(r);
-  SetFlag(kUseGVN);
+  Initialize(r);
 }
 
 
 HConstant::HConstant(double double_value, Representation r)
     : has_int32_value_(IsInteger32(double_value)),
       has_double_value_(true),
       int32_value_(DoubleToInt32(double_value)),
       double_value_(double_value) {
-  set_representation(r);
-  SetFlag(kUseGVN);
+  Initialize(r);
 }
 
 
+void HConstant::Initialize(Representation r) {
+  set_representation(r);
+  SetFlag(kUseGVN);
+  if (representation().IsInteger32()) {
+    ClearGVNFlag(kDependsOnOsrEntries);
+  }
+}
+
+
 HConstant* HConstant::CopyToRepresentation(Representation r, Zone* zone) const {
   if (r.IsInteger32() && !has_int32_value_) return NULL;
   if (r.IsDouble() && !has_double_value_) return NULL;
   if (handle_.is_null()) {
     ASSERT(has_int32_value_ || has_double_value_);
     if (has_int32_value_) return new(zone) HConstant(int32_value_, r);
     return new(zone) HConstant(double_value_, r);
   }
   return new(zone) HConstant(handle_, r);
 }
@@ skipping 1390 matching lines @@
 
 
 void HCheckFunction::Verify() {
   HInstruction::Verify();
   ASSERT(HasNoUses());
 }
 
 #endif
 
 } }  // namespace v8::internal