Remove deprecated v8::base::OS::nan_value().

src/hydrogen-instructions.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/base/bits.h"
 #include "src/double.h"
 #include "src/factory.h"
 #include "src/hydrogen-infer-representation.h"
@@ skipping 2940 matching lines @@
 }
 
 
 Maybe<HConstant*> HConstant::CopyToTruncatedNumber(Zone* zone) {
   HConstant* res = NULL;
   Handle<Object> handle = this->handle(zone->isolate());
   if (handle->IsBoolean()) {
     res = handle->BooleanValue() ?
       new(zone) HConstant(1) : new(zone) HConstant(0);
   } else if (handle->IsUndefined()) {
-    res = new(zone) HConstant(base::OS::nan_value());
+    res = new (zone) HConstant(std::numeric_limits<double>::quiet_NaN());
   } else if (handle->IsNull()) {
     res = new(zone) HConstant(0);
   }
   return Maybe<HConstant*>(res != NULL, res);
 }
 
 
 std::ostream& HConstant::PrintDataTo(std::ostream& os) const {  // NOLINT
   if (HasInteger32Value()) {
     os << int32_value_ << " ";
@@ skipping 1194 matching lines @@
 
 HInstruction* HUnaryMathOperation::New(
     Zone* zone, HValue* context, HValue* value, BuiltinFunctionId op) {
   do {
     if (!FLAG_fold_constants) break;
     if (!value->IsConstant()) break;
     HConstant* constant = HConstant::cast(value);
     if (!constant->HasNumberValue()) break;
     double d = constant->DoubleValue();
     if (std::isnan(d)) {  // NaN poisons everything.
-      return H_CONSTANT_DOUBLE(base::OS::nan_value());
+      return H_CONSTANT_DOUBLE(std::numeric_limits<double>::quiet_NaN());
     }
     if (std::isinf(d)) {  // +Infinity and -Infinity.
       switch (op) {
         case kMathExp:
           return H_CONSTANT_DOUBLE((d > 0.0) ? d : 0.0);
         case kMathLog:
         case kMathSqrt:
-          return H_CONSTANT_DOUBLE((d > 0.0) ? d : base::OS::nan_value());
+          return H_CONSTANT_DOUBLE(
+              (d > 0.0) ? d : std::numeric_limits<double>::quiet_NaN());
         case kMathPowHalf:
         case kMathAbs:
           return H_CONSTANT_DOUBLE((d > 0.0) ? d : -d);
         case kMathRound:
         case kMathFround:
         case kMathFloor:
           return H_CONSTANT_DOUBLE(d);
         case kMathClz32:
           return H_CONSTANT_INT(32);
         default:
@@ skipping 76 matching lines @@
 HInstruction* HPower::New(Zone* zone,
                           HValue* context,
                           HValue* left,
                           HValue* right) {
   if (FLAG_fold_constants && left->IsConstant() && right->IsConstant()) {
     HConstant* c_left = HConstant::cast(left);
     HConstant* c_right = HConstant::cast(right);
     if (c_left->HasNumberValue() && c_right->HasNumberValue()) {
       double result = power_helper(c_left->DoubleValue(),
                                    c_right->DoubleValue());
-      return H_CONSTANT_DOUBLE(std::isnan(result) ? base::OS::nan_value()
-                                                  : result);
+      return H_CONSTANT_DOUBLE(std::isnan(result)
+                                   ? std::numeric_limits<double>::quiet_NaN()
+                                   : result);
     }
   }
   return new(zone) HPower(left, right);
 }
 
 
 HInstruction* HMathMinMax::New(
     Zone* zone, HValue* context, HValue* left, HValue* right, Operation op) {
   if (FLAG_fold_constants && left->IsConstant() && right->IsConstant()) {
     HConstant* c_left = HConstant::cast(left);
@@ skipping 12 matching lines @@
       } else {
         if (d_left < d_right) return H_CONSTANT_DOUBLE(d_right);
         if (d_left > d_right) return H_CONSTANT_DOUBLE(d_left);
         if (d_left == d_right) {
           // Handle +0 and -0.
           return H_CONSTANT_DOUBLE((Double(d_left).Sign() == -1) ? d_right
                                                                  : d_left);
         }
       }
       // All comparisons failed, must be NaN.
-      return H_CONSTANT_DOUBLE(base::OS::nan_value());
+      return H_CONSTANT_DOUBLE(std::numeric_limits<double>::quiet_NaN());
     }
   }
   return new(zone) HMathMinMax(context, left, right, op);
 }
 
 
 HInstruction* HMod::New(Zone* zone,
                         HValue* context,
                         HValue* left,
                         HValue* right) {
@@ skipping 495 matching lines @@
       break;
     case HObjectAccess::kExternalMemory:
       os << "[external-memory]";
       break;
   }
 
   return os << "@" << access.offset();
 }
 
 } }  // namespace v8::internal