Add fast 64-bit bitwise negation to the IA32 optimizing compiler.

runtime/vm/flow_graph_optimizer.cc

Index: runtime/vm/flow_graph_optimizer.cc
===================================================================
--- runtime/vm/flow_graph_optimizer.cc	(revision 13214)
+++ runtime/vm/flow_graph_optimizer.cc	(working copy)
@@ -250,11 +250,23 @@
 }
 
 
-static bool HasOneSmi(const ICData& ic_data) {
-  return ICDataHasReceiverClassId(ic_data, kSmiCid);
+static bool HasOnlyOneSmi(const ICData& ic_data) {
+  return (ic_data.NumberOfChecks() == 1)
+      && ICDataHasReceiverClassId(ic_data, kSmiCid);
 }
 
 
+static bool HasOnlySmiOrMint(const ICData& ic_data) {
+  if (ic_data.NumberOfChecks() == 1) {
+    return ICDataHasReceiverClassId(ic_data, kSmiCid)
+        || ICDataHasReceiverClassId(ic_data, kMintCid);
+  }
+  return (ic_data.NumberOfChecks() == 2)
+      && ICDataHasReceiverClassId(ic_data, kSmiCid)
+      && ICDataHasReceiverClassId(ic_data, kMintCid);
+}
+
+
 static bool HasOnlyTwoSmi(const ICData& ic_data) {
   return (ic_data.NumberOfChecks() == 1) &&
       ICDataHasReceiverArgumentClassIds(ic_data, kSmiCid, kSmiCid);
@@ -271,8 +283,9 @@
 }
 
 
-static bool HasOneDouble(const ICData& ic_data) {
-  return ICDataHasReceiverClassId(ic_data, kDoubleCid);
+static bool HasOnlyOneDouble(const ICData& ic_data) {
+  return (ic_data.NumberOfChecks() == 1)
+      && ICDataHasReceiverClassId(ic_data, kDoubleCid);
 }
 
 
@@ -592,13 +605,9 @@
 
 bool FlowGraphOptimizer::TryReplaceWithUnaryOp(InstanceCallInstr* call,
                                                Token::Kind op_kind) {
-  if (call->ic_data()->NumberOfChecks() != 1) {
-    // TODO(srdjan): Not yet supported.
-    return false;
-  }
   ASSERT(call->ArgumentCount() == 1);
   Definition* unary_op = NULL;
-  if (HasOneSmi(*call->ic_data())) {
+  if (HasOnlyOneSmi(*call->ic_data())) {
     Value* value = call->ArgumentAt(0)->value();
     InsertBefore(call,
                  new CheckSmiInstr(value->Copy(), call->deopt_id()),
@@ -607,8 +616,14 @@
     unary_op = new UnarySmiOpInstr(op_kind,
                                    (op_kind == Token::kNEGATE) ? call : NULL,
                                    value);
-  } else if (HasOneDouble(*call->ic_data()) && (op_kind == Token::kNEGATE)) {
+  } else if ((op_kind == Token::kBIT_NOT) &&
+             HasOnlySmiOrMint(*call->ic_data()) &&
+             FlowGraphCompiler::SupportsUnboxedMints()) {
     Value* value = call->ArgumentAt(0)->value();
+    unary_op = new UnboxedMintUnaryOpInstr(op_kind, value, call);
+  } else if (HasOnlyOneDouble(*call->ic_data()) &&
+             (op_kind == Token::kNEGATE)) {
+    Value* value = call->ArgumentAt(0)->value();
     AddCheckClass(call, value->Copy());
     ConstantInstr* minus_one =
         new ConstantInstr(Double::ZoneHandle(Double::NewCanonical(-1)));
@@ -2913,6 +2928,13 @@
 }
 
 
+void ConstantPropagator::VisitUnboxedMintUnaryOp(
+    UnboxedMintUnaryOpInstr* instr) {
+  // TODO(kmillikin): Handle unary operations.

[Kevin Millikin (Google), 2012/10/04 11:56:06]

TODO(fschneider) :)

+  SetValue(instr, non_constant_);
+}
+
+
 void ConstantPropagator::VisitUnarySmiOp(UnarySmiOpInstr* instr) {
   const Object& value = instr->value()->definition()->constant_value();
   if (IsNonConstant(value)) {