Add double unary operation (negate).

runtime/vm/flow_graph_optimizer.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/flow_graph_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 1202 matching lines @@
                  Definition::kEffect);
     unary_op = new UnarySmiOpInstr(op_kind, new Value(input), call->deopt_id());
   } else if ((op_kind == Token::kBIT_NOT) &&
              HasOnlySmiOrMint(*call->ic_data()) &&
              FlowGraphCompiler::SupportsUnboxedMints()) {
     unary_op = new UnaryMintOpInstr(
         op_kind, new Value(input), call->deopt_id());
   } else if (HasOnlyOneDouble(*call->ic_data()) &&
              (op_kind == Token::kNEGATE)) {
     AddReceiverCheck(call);
-    ConstantInstr* minus_one =
-        flow_graph()->GetConstant(Double::ZoneHandle(Double::NewCanonical(-1)));
-    unary_op = new BinaryDoubleOpInstr(Token::kMUL,
-                                       new Value(input),
-                                       new Value(minus_one),
-                                       call->deopt_id());
+    unary_op = new UnaryDoubleOpInstr(
+        Token::kNEGATE, new Value(input), call->deopt_id());
+  } else {
+    return false;
   }
-  if (unary_op == NULL) return false;
-
+  ASSERT(unary_op != NULL);
   ReplaceCall(call, unary_op);
   return true;
 }
 
 
 // Using field class
 static RawField* GetField(intptr_t class_id, const String& field_name) {
   Class& cls = Class::Handle(Isolate::Current()->class_table()->At(class_id));
   Field& field = Field::Handle();
   while (!cls.IsNull()) {
@@ skipping 5107 matching lines @@
   const Object& value = instr->value()->definition()->constant_value();
   if (IsNonConstant(value)) {
     SetValue(instr, non_constant_);
   } else if (IsConstant(value)) {
     // TODO(kmillikin): Handle unary operations.
     SetValue(instr, non_constant_);
   }
 }
 
 
+void ConstantPropagator::VisitUnaryDoubleOp(UnaryDoubleOpInstr* instr) {
+  const Object& value = instr->value()->definition()->constant_value();
+  if (IsNonConstant(value)) {
+    SetValue(instr, non_constant_);
+  } else if (IsConstant(value)) {
+    // TODO(kmillikin): Handle unary operations.
+    SetValue(instr, non_constant_);
+  }
+}
+
+
 void ConstantPropagator::VisitSmiToDouble(SmiToDoubleInstr* instr) {
   const Object& value = instr->value()->definition()->constant_value();
   if (IsConstant(value) && value.IsInteger()) {
     SetValue(instr, Double::Handle(
         Double::New(Integer::Cast(value).AsDoubleValue(), Heap::kOld)));
   } else if (IsNonConstant(value)) {
     SetValue(instr, non_constant_);
   }
 }
 
@@ skipping 1101 matching lines @@
   }
 
   // Insert materializations at environment uses.
   for (intptr_t i = 0; i < exits.length(); i++) {
     CreateMaterializationAt(exits[i], alloc, alloc->cls(), *fields);
   }
 }
 
 
 }  // namespace dart