Support for unboxed 64-bit integer bitwise operations and equality on ia32.

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"
 #include "vm/hash_map.h"
 #include "vm/il_printer.h"
 #include "vm/intermediate_language.h"
 #include "vm/object_store.h"
 #include "vm/parser.h"
 #include "vm/scopes.h"
 #include "vm/symbols.h"
 
 namespace dart {
 
@@ skipping 56 matching lines @@
       }
     }
   }
 }
 
 
 static Definition* CreateConversion(Representation from,
                                     Representation to,
                                     Definition* def,
                                     Instruction* deopt_target) {
-  if ((from == kUnboxedDouble) && (to == kTagged)) {
+  if ((from == kTagged) && (to == kUnboxedInteger)) {
+    const intptr_t deopt_id = (deopt_target != NULL) ?
+        deopt_target->DeoptimizationTarget() : Isolate::kNoDeoptId;
+    ASSERT((deopt_target != NULL) || (def->GetPropagatedCid() == kDoubleCid));
+    return new UnboxIntegerInstr(new Value(def), deopt_id);
+  } else if ((from == kUnboxedInteger) && (to == kTagged)) {
+    return new BoxIntegerInstr(new Value(def));
+  } else if ((from == kUnboxedDouble) && (to == kTagged)) {
     return new BoxDoubleInstr(new Value(def), NULL);
   } else if ((from == kTagged) && (to == kUnboxedDouble)) {
     const intptr_t deopt_id = (deopt_target != NULL) ?
         deopt_target->DeoptimizationTarget() : Isolate::kNoDeoptId;
     ASSERT((deopt_target != NULL) || (def->GetPropagatedCid() == kDoubleCid));
     return new UnboxDoubleInstr(new Value(def), deopt_id);
   } else {
     UNREACHABLE();
     return NULL;
   }
@@ skipping 367 matching lines @@
       if (ShouldSpecializeForDouble(ic_data)) {
         operands_type = kDoubleCid;
       } else {
         return false;
       }
       break;
     case Token::kMOD:
       // TODO(vegorov): implement fast path code for modulo.
       return false;
     case Token::kBIT_AND:
+    case Token::kBIT_OR:
+    case Token::kBIT_XOR:
       if (HasOnlyTwoSmi(ic_data)) {
         operands_type = kSmiCid;
-      } else if (HasTwoMintOrSmi(ic_data)) {
+      } else if (HasTwoMintOrSmi(ic_data) &&
+                 FlowGraphCompiler::SupportsUnboxedMints()) {
         operands_type = kMintCid;
       } else {
         return false;
       }
       break;
-    case Token::kBIT_OR:
-    case Token::kBIT_XOR:
     case Token::kTRUNCDIV:
     case Token::kSHR:
     case Token::kSHL:
       if (HasOnlyTwoSmi(ic_data)) {
         operands_type = kSmiCid;
       } else {
         return false;
       }
       break;
     default:
@@ skipping 17 matching lines @@
     UnboxedDoubleBinaryOpInstr* double_bin_op =
         new UnboxedDoubleBinaryOpInstr(op_kind,
                                        left->Copy(),
                                        right->Copy(),
                                        call);
     call->ReplaceWith(double_bin_op, current_iterator());
     RemovePushArguments(call);
   } else if (operands_type == kMintCid) {
     Value* left = call->ArgumentAt(0)->value();
     Value* right = call->ArgumentAt(1)->value();
-    BinaryMintOpInstr* bin_op = new BinaryMintOpInstr(op_kind,
-                                                      call,
-                                                      left,
-                                                      right);
+    UnboxedMintBinaryOpInstr* bin_op =
+        new UnboxedMintBinaryOpInstr(op_kind, left, right, call);
     call->ReplaceWith(bin_op, current_iterator());
     RemovePushArguments(call);
   } else {
     ASSERT(operands_type == kSmiCid);
     Value* left = call->ArgumentAt(0)->value();
     Value* right = call->ArgumentAt(1)->value();
     // Insert two smi checks and attach a copy of the original
     // environment because the smi operation can still deoptimize.
     InsertBefore(call,
                  new CheckSmiInstr(left->Copy(), call->deopt_id()),
@@ skipping 429 matching lines @@
         new StrictCompareInstr(strict_kind, comp->left(), comp->right());
     instr->ReplaceWith(strict_comp, iterator);
     return;
   }
   if (!comp->HasICData() || (comp->ic_data()->NumberOfChecks() == 0)) return;
   if (comp->ic_data()->NumberOfChecks() == 1) {
     ASSERT(comp->ic_data()->num_args_tested() == 2);
     GrowableArray<intptr_t> class_ids;
     Function& target = Function::Handle();
     comp->ic_data()->GetCheckAt(0, &class_ids, &target);
-    // TODO(srdjan): allow for mixed mode comparison.
+    // TODO(srdjan): allow for mixed mode int/double comparison.
+
     if ((class_ids[0] == kSmiCid) && (class_ids[1] == kSmiCid)) {
       optimizer->InsertBefore(
           instr,
           new CheckSmiInstr(comp->left()->Copy(), comp->deopt_id()),
           instr->env(),
           Definition::kEffect);
       optimizer->InsertBefore(
           instr,
           new CheckSmiInstr(comp->right()->Copy(), comp->deopt_id()),
           instr->env(),
           Definition::kEffect);
       comp->set_receiver_class_id(kSmiCid);
     } else if ((class_ids[0] == kDoubleCid) && (class_ids[1] == kDoubleCid)) {
       comp->set_receiver_class_id(kDoubleCid);
+    } else if (HasTwoMintOrSmi(*comp->ic_data()) &&
+               FlowGraphCompiler::SupportsUnboxedMints()) {
+      comp->set_receiver_class_id(kMintCid);
     } else {
       ASSERT(comp->receiver_class_id() == kIllegalCid);
     }
+  } else if (HasTwoMintOrSmi(*comp->ic_data())) {
+    comp->set_receiver_class_id(kMintCid);
   } else if (comp->ic_data()->AllReceiversAreNumbers()) {
     comp->set_receiver_class_id(kNumberCid);
   }
 }
 
 
 void FlowGraphOptimizer::VisitEqualityCompare(EqualityCompareInstr* instr) {
   HandleEqualityCompare(this, instr, instr, current_iterator());
 }
 
@@ skipping 1774 matching lines @@
           SetValue(instr, non_constant_);
       }
     } else {
       // TODO(kmillikin): support other types.
       SetValue(instr, non_constant_);
     }
   }
 }
 
 
+void ConstantPropagator::VisitBoxInteger(BoxIntegerInstr* instr) {
+  // TODO(kmillikin): Handle box operation.
+  SetValue(instr, non_constant_);
+}
+
+
+void ConstantPropagator::VisitUnboxInteger(UnboxIntegerInstr* instr) {
+  // TODO(kmillikin): Handle unbox operation.
+  SetValue(instr, non_constant_);
+}
+
+
+void ConstantPropagator::VisitUnboxedMintBinaryOp(
+    UnboxedMintBinaryOpInstr* instr) {
+  // TODO(kmillikin): Handle binary operations.
+  SetValue(instr, non_constant_);
+}
+
+
 void ConstantPropagator::VisitBinaryMintOp(BinaryMintOpInstr* instr) {
   const Object& left = instr->left()->definition()->constant_value();
   const Object& right = instr->right()->definition()->constant_value();
   if (IsNonConstant(left) || IsNonConstant(right)) {
     SetValue(instr, non_constant_);
   } else if (IsConstant(left) && IsConstant(right)) {
     // TODO(kmillikin): Handle binary operations.
     SetValue(instr, non_constant_);
   }
 }
@@ skipping 235 matching lines @@
 
   if (FLAG_trace_constant_propagation) {
     OS::Print("\n==== After constant propagation ====\n");
     FlowGraphPrinter printer(*graph_);
     printer.PrintBlocks();
   }
 }
 
 
 }  // namespace dart