Add a genuine unary minus instruction to Crankshaft....

src/hydrogen-instructions.cc

 // Copyright 2010 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 662 matching lines @@
 
 void HChange::PrintDataTo(StringStream* stream) const {
   HUnaryOperation::PrintDataTo(stream);
   stream->Add(" %s to %s", from_.Mnemonic(), to_.Mnemonic());
 
   if (CanTruncateToInt32()) stream->Add(" truncating-int32");
   if (CheckFlag(kBailoutOnMinusZero)) stream->Add(" -0?");
 }
 
 
+void HNeg::PrintDataTo(StringStream* stream) const {
+  HUnaryOperation::PrintDataTo(stream);
+  if (CheckFlag(kBailoutOnMinusZero)) stream->Add(" -0?");
+}
+
+
 HCheckInstanceType* HCheckInstanceType::NewIsJSObjectOrJSFunction(
     HValue* value)  {
   STATIC_ASSERT((LAST_JS_OBJECT_TYPE + 1) == JS_FUNCTION_TYPE);
   return new HCheckInstanceType(value, FIRST_JS_OBJECT_TYPE, JS_FUNCTION_TYPE);
 }
 
 
 void HCheckMap::PrintDataTo(StringStream* stream) const {
   value()->PrintNameTo(stream);
   stream->Add(" %p", *map());
@@ skipping 174 matching lines @@
     if (!right()->range()->CanBeZero()) {
       ClearFlag(HValue::kCanBeDivByZero);
     }
     return result;
   } else {
     return HArithmeticBinaryOperation::InferRange();
   }
 }
 
 
+Range* HNeg::InferRange() {
+  if (representation().IsInteger32()) {
+    Range* input_range = value()->range();
+    Range* result = input_range->Copy();
+    Range neg_one(-1, -1);
+    if (!result->MulAndCheckOverflow(&neg_one)) {
+      ClearFlag(HValue::kCanOverflow);
+    }
+    result->set_can_be_minus_zero(input_range->CanBeZero());
+    return result;
+  } else {
+    return HValue::InferRange();
+  }
+}
+
+
 void HPhi::PrintTo(StringStream* stream) const {
   stream->Add("[");
   for (int i = 0; i < OperandCount(); ++i) {
     HValue* value = OperandAt(i);
     stream->Add(" ");
     value->PrintNameTo(stream);
     stream->Add(" ");
   }
   stream->Add(" uses%d_%di_%dd_%dt]",
               uses()->length(),
@@ skipping 394 matching lines @@
 HType HBitOr::CalculateInferredType() const {
   return HType::TaggedNumber();
 }
 
 
 HType HBitNot::CalculateInferredType() const {
   return HType::TaggedNumber();
 }
 
 
+HType HNeg::CalculateInferredType() const {
+  return HType::TaggedNumber();
+}
+
+
 HType HUnaryMathOperation::CalculateInferredType() const {
   return HType::TaggedNumber();
 }
 
 
 HType HShl::CalculateInferredType() const {
   return HType::TaggedNumber();
 }
 
 
@@ skipping 58 matching lines @@
 
 HValue* HMul::EnsureAndPropagateNotMinusZero(BitVector* visited) {
   visited->Add(id());
   if (range() == NULL || range()->CanBeMinusZero()) {
     SetFlag(kBailoutOnMinusZero);
   }
   return NULL;
 }
 
 
+HValue* HNeg::EnsureAndPropagateNotMinusZero(BitVector* visited) {
+  visited->Add(id());
+  if (range() == NULL || range()->CanBeMinusZero()) {
+    SetFlag(kBailoutOnMinusZero);
+  }
+  return NULL;
+}
+
+
 HValue* HSub::EnsureAndPropagateNotMinusZero(BitVector* visited) {
   visited->Add(id());
   // Propagate to the left argument. If the left argument cannot be -0, then
   // the result of the add operation cannot be either.
   if (range() == NULL || range()->CanBeMinusZero()) {
     return left();
   }
   return NULL;
 }
 
@@ skipping 67 matching lines @@
 
 
 void HCheckPrototypeMaps::Verify() {
   HInstruction::Verify();
   ASSERT(HasNoUses());
 }
 
 #endif
 
 } }  // namespace v8::internal