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

runtime/vm/flow_graph_optimizer.cc

 // Copyright (c) 2012, 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/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
@@ skipping 232 matching lines @@
     ASSERT(class_ids.length() == 2);
     if (!ClassIdIsOneOf(class_ids[0], receiver_class_ids) ||
         !ClassIdIsOneOf(class_ids[1], argument_class_ids)) {
       return false;
     }
   }
   return true;
 }
 
 
-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);
 }
 
 
 // Returns false if the ICData contains anything other than the 4 combinations
 // of Mint and Smi for the receiver and argument classes.
 static bool HasTwoMintOrSmi(const ICData& ic_data) {
   GrowableArray<intptr_t> class_ids(2);
   class_ids.Add(kSmiCid);
   class_ids.Add(kMintCid);
   return ICDataHasOnlyReceiverArgumentClassIds(ic_data, class_ids, class_ids);
 }
 
 
-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);
 }
 
 
 static bool ShouldSpecializeForDouble(const ICData& ic_data) {
   // Unboxed double operation can't handle case of two smis.
   if (ICDataHasReceiverArgumentClassIds(ic_data, kSmiCid, kSmiCid)) {
     return false;
   }
 
   // Check that it have seen only smis and doubles.
@@ skipping 299 matching lines @@
     BinarySmiOpInstr* bin_op = new BinarySmiOpInstr(op_kind, call, left, right);
     call->ReplaceWith(bin_op, current_iterator());
     RemovePushArguments(call);
   }
   return true;
 }
 
 
 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()),
                  call->env(),
                  Definition::kEffect);
     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)));
     InsertBefore(call, minus_one, NULL, Definition::kValue);
     unary_op = new UnboxedDoubleBinaryOpInstr(Token::kMUL,
                                               value,
                                               new Value(minus_one),
                                               call);
   }
@@ skipping 2285 matching lines @@
 }
 
 
 void ConstantPropagator::VisitUnboxedMintBinaryOp(
     UnboxedMintBinaryOpInstr* instr) {
   // TODO(kmillikin): Handle binary operations.
   SetValue(instr, non_constant_);
 }
 
 
+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)) {
     SetValue(instr, non_constant_);
   } else if (IsConstant(value)) {
     // TODO(kmillikin): Handle unary operations.
     SetValue(instr, non_constant_);
   }
 }
 
@@ skipping 223 matching lines @@
 
   if (FLAG_trace_constant_propagation) {
     OS::Print("\n==== After constant propagation ====\n");
     FlowGraphPrinter printer(*graph_);
     printer.PrintBlocks();
   }
 }
 
 
 }  // namespace dart