IR refactoring: consolidate all boxing and unboxing instructions.

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/cpu.h"
 #include "vm/dart_entry.h"
@@ skipping 610 matching lines @@
     ASSERT(phi->is_alive());
     // For phis conversions have to be inserted in the predecessor.
     insert_before =
         phi->block()->PredecessorAt(use->use_index())->last_instruction();
     deopt_target = NULL;
   } else {
     deopt_target = insert_before = use->instruction();
   }
 
   Definition* converted = NULL;
-  if ((from == kTagged) && (to == kUnboxedMint)) {
-    ASSERT((deopt_target != NULL) ||
-           (use->Type()->ToCid() == kUnboxedMint));
-    const intptr_t deopt_id = (deopt_target != NULL) ?
-        deopt_target->DeoptimizationTarget() : Isolate::kNoDeoptId;
-    converted = new(I) UnboxIntegerInstr(use->CopyWithType(), deopt_id);
-  } else if ((from == kUnboxedMint) && (to == kTagged)) {
-    converted = new(I) BoxIntegerInstr(use->CopyWithType());
-  } else if ((from == kUnboxedUint32) && (to == kTagged)) {
-    converted = new(I) BoxUint32Instr(use->CopyWithType());
-  } else if (IsUnboxedInteger(from) && IsUnboxedInteger(to)) {
+  if (IsUnboxedInteger(from) && IsUnboxedInteger(to)) {
     const intptr_t deopt_id = (to == kUnboxedInt32) && (deopt_target != NULL) ?
-        deopt_target->DeoptimizationTarget() : Isolate::kNoDeoptId;
+      deopt_target->DeoptimizationTarget() : Isolate::kNoDeoptId;
     converted = new(I) UnboxedIntConverterInstr(from,
                                                 to,
                                                 use->CopyWithType(),
                                                 deopt_id);
   } else if ((from == kUnboxedInt32) && (to == kUnboxedDouble)) {
     converted = new Int32ToDoubleInstr(use->CopyWithType());
-  } else if ((from == kTagged) && (to == kUnboxedInt32)) {
+  } else if ((from == kUnboxedMint) &&
+             (to == kUnboxedDouble) &&
+             CanConvertUnboxedMintToDouble()) {
     const intptr_t deopt_id = (deopt_target != NULL) ?
-        deopt_target->DeoptimizationTarget() : Isolate::kNoDeoptId;
-    converted = new UnboxInt32Instr(use->CopyWithType(), deopt_id);
-  } else if ((from == kUnboxedInt32) && (to == kTagged)) {
-    converted = new BoxInt32Instr(use->CopyWithType());
-  } else if ((from == kTagged) && (to == kUnboxedUint32)) {
+      deopt_target->DeoptimizationTarget() : Isolate::kNoDeoptId;
+    ASSERT(CanUnboxDouble());
+    converted = new MintToDoubleInstr(use->CopyWithType(), deopt_id);
+  } else if ((from == kTagged) && Boxing::Supports(to)) {
     const intptr_t deopt_id = (deopt_target != NULL) ?
-        deopt_target->DeoptimizationTarget() : Isolate::kNoDeoptId;
-    converted = new UnboxUint32Instr(use->CopyWithType(), deopt_id);
-  } else if (from == kUnboxedMint && to == kUnboxedDouble) {
-    ASSERT(CanUnboxDouble());
-    const intptr_t deopt_id = (deopt_target != NULL) ?
-        deopt_target->DeoptimizationTarget() : Isolate::kNoDeoptId;
-    if (CanConvertUnboxedMintToDouble()) {
-      // Fast path.
-      converted = new MintToDoubleInstr(use->CopyWithType(), deopt_id);
-    } else {
-      // Slow path.
-      BoxIntegerInstr* boxed = new(I) BoxIntegerInstr(use->CopyWithType());
-      use->BindTo(boxed);
-      InsertBefore(insert_before, boxed, NULL, FlowGraph::kValue);
-      converted = new(I) UnboxDoubleInstr(new(I) Value(boxed), deopt_id);
-    }
-  } else if ((from == kUnboxedDouble) && (to == kTagged)) {
-    ASSERT(CanUnboxDouble());
-    converted = new(I) BoxDoubleInstr(use->CopyWithType());
-  } else if ((from == kTagged) && (to == kUnboxedDouble)) {
-    ASSERT(CanUnboxDouble());
-    ASSERT((deopt_target != NULL) ||
-           (use->Type()->ToCid() == kDoubleCid));
-    const intptr_t deopt_id = (deopt_target != NULL) ?
-        deopt_target->DeoptimizationTarget() : Isolate::kNoDeoptId;
-    ConstantInstr* constant = use->definition()->AsConstant();
-    if ((constant != NULL) && constant->value().IsSmi()) {
-      const double dbl_val = Smi::Cast(constant->value()).AsDoubleValue();
-      const Double& dbl_obj =
-          Double::ZoneHandle(I, Double::NewCanonical(dbl_val));
-      ConstantInstr* double_const = flow_graph()->GetConstant(dbl_obj);
-      converted = new(I) UnboxDoubleInstr(new(I) Value(double_const), deopt_id);
-    } else {
-      converted = new(I) UnboxDoubleInstr(use->CopyWithType(), deopt_id);
-    }
-  } else if ((from == kTagged) && (to == kUnboxedFloat32x4)) {
-    ASSERT((deopt_target != NULL) ||
-           (use->Type()->ToCid() == kFloat32x4Cid));
-    const intptr_t deopt_id = (deopt_target != NULL) ?
-        deopt_target->DeoptimizationTarget() : Isolate::kNoDeoptId;
-    converted = new(I) UnboxFloat32x4Instr(
-        use->CopyWithType(), deopt_id);
-  } else if ((from == kUnboxedFloat32x4) && (to == kTagged)) {
-    converted = new(I) BoxFloat32x4Instr(use->CopyWithType());
-  } else if ((from == kTagged) && (to == kUnboxedInt32x4)) {
-    ASSERT((deopt_target != NULL) || (use->Type()->ToCid() == kInt32x4Cid));
-    const intptr_t deopt_id = (deopt_target != NULL) ?
-        deopt_target->DeoptimizationTarget() : Isolate::kNoDeoptId;
-    converted = new(I) UnboxInt32x4Instr(use->CopyWithType(), deopt_id);
-  } else if ((from == kUnboxedInt32x4) && (to == kTagged)) {
-    converted = new(I) BoxInt32x4Instr(use->CopyWithType());
-  } else if ((from == kTagged) && (to == kUnboxedFloat64x2)) {
-    ASSERT((deopt_target != NULL) || (use->Type()->ToCid() == kFloat64x2Cid));
-    const intptr_t deopt_id = (deopt_target != NULL) ?
-        deopt_target->DeoptimizationTarget() : Isolate::kNoDeoptId;
-    converted = new(I) UnboxFloat64x2Instr(use->CopyWithType(), deopt_id);
-  } else if ((from == kUnboxedFloat64x2) && (to == kTagged)) {
-    converted = new(I) BoxFloat64x2Instr(use->CopyWithType());
+      deopt_target->DeoptimizationTarget() : Isolate::kNoDeoptId;
+    converted = UnboxInstr::Create(to, use->CopyWithType(), deopt_id);
+  } else if ((to == kTagged) && Boxing::Supports(from)) {
+    converted = BoxInstr::Create(from, use->CopyWithType());
   } else {
     // We have failed to find a suitable conversion instruction.
     // Insert two "dummy" conversion instructions with the correct
     // "from" and "to" representation. The inserted instructions will
     // trigger a deoptimization if executed. See #12417 for a discussion.
     const intptr_t deopt_id = (deopt_target != NULL) ?
-        deopt_target->DeoptimizationTarget() : Isolate::kNoDeoptId;
-    ASSERT(from != kTagged);
-    ASSERT(to != kTagged);
-    Definition* boxed = NULL;
-    if (from == kUnboxedDouble) {
-      boxed = new(I) BoxDoubleInstr(use->CopyWithType());
-    } else if (from == kUnboxedInt32x4) {
-      boxed = new(I) BoxInt32x4Instr(use->CopyWithType());
-    } else if (from == kUnboxedFloat32x4) {
-      boxed = new(I) BoxFloat32x4Instr(use->CopyWithType());
-    } else if (from == kUnboxedMint) {
-      boxed = new(I) BoxIntegerInstr(use->CopyWithType());
-    } else if (from == kUnboxedFloat64x2) {
-      boxed = new(I) BoxFloat64x2Instr(use->CopyWithType());
-    } else if (from == kUnboxedInt32) {
-      boxed = new(I) BoxInt32Instr(use->CopyWithType());
-    } else if (from == kUnboxedUint32) {
-      boxed = new(I) BoxUint32Instr(use->CopyWithType());
-    } else {
-      UNIMPLEMENTED();
-    }
+      deopt_target->DeoptimizationTarget() : Isolate::kNoDeoptId;
+    ASSERT(Boxing::Supports(from));
+    ASSERT(Boxing::Supports(to));
+    Definition* boxed = BoxInstr::Create(from, use->CopyWithType());
     use->BindTo(boxed);
     InsertBefore(insert_before, boxed, NULL, FlowGraph::kValue);
-    Value* to_value = new(I) Value(boxed);
-    if (to == kUnboxedDouble) {
-      converted = new(I) UnboxDoubleInstr(to_value, deopt_id);
-    } else if (to == kUnboxedInt32x4) {
-      converted = new(I) UnboxInt32x4Instr(to_value, deopt_id);
-    } else if (to == kUnboxedFloat32x4) {
-      converted = new(I) UnboxFloat32x4Instr(to_value, deopt_id);
-    } else if (to == kUnboxedMint) {
-      converted = new(I) UnboxIntegerInstr(to_value, deopt_id);
-    } else if (to == kUnboxedFloat64x2) {
-      converted = new(I) UnboxFloat64x2Instr(to_value, deopt_id);
-    } else if (to == kUnboxedInt32) {
-      boxed = new(I) UnboxInt32Instr(use->CopyWithType(), deopt_id);
-    } else if (to == kUnboxedUint32) {
-      boxed = new(I) UnboxUint32Instr(use->CopyWithType(), deopt_id);
-    } else {
-      UNIMPLEMENTED();
-    }
+    converted = UnboxInstr::Create(to, new(I) Value(boxed), deopt_id);
   }
   ASSERT(converted != NULL);
   InsertBefore(insert_before, converted, use->instruction()->env(),
                FlowGraph::kValue);
   if (is_environment_use) {
     use->BindToEnvironment(converted);
   } else {
     use->BindTo(converted);
   }
 
@@ skipping 614 matching lines @@
   if (array_cid == kTypedDataFloat32ArrayCid) {
     stored_value =
         new(I) DoubleToFloatInstr(
             new(I) Value(stored_value), call->deopt_id());
     cursor = flow_graph()->AppendTo(cursor,
                                     stored_value,
                                     NULL,
                                     FlowGraph::kValue);
   } else if (array_cid == kTypedDataInt32ArrayCid) {
     stored_value = new(I) UnboxInt32Instr(
+        UnboxInt32Instr::kTruncate,
         new(I) Value(stored_value),
         call->deopt_id());
-    stored_value->AsUnboxIntN()->mark_truncating();
     cursor = flow_graph()->AppendTo(cursor,
                                     stored_value,
                                     call->env(),
                                     FlowGraph::kValue);
   } else if (array_cid == kTypedDataUint32ArrayCid) {
     stored_value = new(I) UnboxUint32Instr(
         new(I) Value(stored_value),
         call->deopt_id());
-    ASSERT(stored_value->AsUnboxIntN()->is_truncating());
+    ASSERT(stored_value->AsUnboxInteger()->is_truncating());
     cursor = flow_graph()->AppendTo(cursor,
                                     stored_value,
                                     call->env(),
                                     FlowGraph::kValue);
   }
 
   const intptr_t index_scale = Instance::ElementSizeFor(array_cid);
   *last = new(I) StoreIndexedInstr(new(I) Value(array),
                                    new(I) Value(index),
                                    new(I) Value(stored_value),
@@ skipping 2456 matching lines @@
 
   if (view_cid == kTypedDataFloat32ArrayCid) {
     stored_value = new(I) DoubleToFloatInstr(
         new(I) Value(stored_value), call->deopt_id());
     cursor = flow_graph()->AppendTo(cursor,
                                     stored_value,
                                     NULL,
                                     FlowGraph::kValue);
   } else if (view_cid == kTypedDataInt32ArrayCid) {
     stored_value = new(I) UnboxInt32Instr(
+        UnboxInt32Instr::kTruncate,
         new(I) Value(stored_value),
         call->deopt_id());
-    stored_value->AsUnboxIntN()->mark_truncating();
     cursor = flow_graph()->AppendTo(cursor,
                                     stored_value,
                                     call->env(),
                                     FlowGraph::kValue);
   } else if (view_cid == kTypedDataUint32ArrayCid) {
     stored_value = new(I) UnboxUint32Instr(
         new(I) Value(stored_value),
         call->deopt_id());
-    ASSERT(stored_value->AsUnboxIntN()->is_truncating());
+    ASSERT(stored_value->AsUnboxInteger()->is_truncating());
     cursor = flow_graph()->AppendTo(cursor,
                                     stored_value,
                                     call->env(),
                                     FlowGraph::kValue);
   }
 
   StoreBarrierType needs_store_barrier = kNoStoreBarrier;
   *last = new(I) StoreIndexedInstr(new(I) Value(array),
                                    new(I) Value(index),
                                    new(I) Value(stored_value),
@@ skipping 4486 matching lines @@
 void ConstantPropagator::VisitBinaryMintOp(BinaryMintOpInstr* instr) {
   VisitBinaryIntegerOp(instr);
 }
 
 
 void ConstantPropagator::VisitShiftMintOp(ShiftMintOpInstr* instr) {
   VisitBinaryIntegerOp(instr);
 }
 
 
-void ConstantPropagator::VisitBoxInteger(BoxIntegerInstr* instr) {
+void ConstantPropagator::VisitBoxInt64(BoxInt64Instr* instr) {
   // TODO(kmillikin): Handle box operation.
   SetValue(instr, non_constant_);
 }
 
 
-void ConstantPropagator::VisitUnboxInteger(UnboxIntegerInstr* instr) {
+void ConstantPropagator::VisitUnboxInt64(UnboxInt64Instr* instr) {
   // TODO(kmillikin): Handle unbox operation.
   SetValue(instr, non_constant_);
 }
 
 
 void ConstantPropagator::VisitUnaryMintOp(UnaryMintOpInstr* instr) {
   // TODO(kmillikin): Handle unary operations.
   SetValue(instr, non_constant_);
 }
 
@@ skipping 362 matching lines @@
   const Object& right = instr->right()->definition()->constant_value();
   if (IsNonConstant(left) || IsNonConstant(right)) {
     SetValue(instr, non_constant_);
   } else if (IsConstant(left) && IsConstant(right)) {
     // TODO(srdjan): Handle min and max.
     SetValue(instr, non_constant_);
   }
 }
 
 
-void ConstantPropagator::VisitUnboxDouble(UnboxDoubleInstr* instr) {
+void ConstantPropagator::VisitUnbox(UnboxInstr* instr) {
   const Object& value = instr->value()->definition()->constant_value();
   if (IsNonConstant(value)) {
     SetValue(instr, non_constant_);
-  } else if (IsConstant(value)) {
-    // TODO(kmillikin): Handle conversion.
-    SetValue(instr, non_constant_);
-  }
-}
-
-
-void ConstantPropagator::VisitBoxDouble(BoxDoubleInstr* instr) {
-  const Object& value = instr->value()->definition()->constant_value();
-  if (IsNonConstant(value)) {
-    SetValue(instr, non_constant_);
-  } else if (IsConstant(value)) {
-    // TODO(kmillikin): Handle conversion.
-    SetValue(instr, non_constant_);
-  }
-}
-
-
-void ConstantPropagator::VisitUnboxFloat32x4(UnboxFloat32x4Instr* instr) {
-  const Object& value = instr->value()->definition()->constant_value();
-  if (IsNonConstant(value)) {
-    SetValue(instr, non_constant_);
-  } else if (IsConstant(value)) {
-    // TODO(kmillikin): Handle conversion.
-    SetValue(instr, non_constant_);
-  }
-}
-
-
-void ConstantPropagator::VisitBoxFloat32x4(BoxFloat32x4Instr* instr) {
-  const Object& value = instr->value()->definition()->constant_value();
-  if (IsNonConstant(value)) {
-    SetValue(instr, non_constant_);
-  } else if (IsConstant(value)) {
-    // TODO(kmillikin): Handle conversion.
-    SetValue(instr, non_constant_);
-  }
-}
-
-
-void ConstantPropagator::VisitUnboxFloat64x2(UnboxFloat64x2Instr* instr) {
-  const Object& value = instr->value()->definition()->constant_value();
-  if (IsNonConstant(value)) {
-    SetValue(instr, non_constant_);
-  } else if (IsConstant(value)) {
-    // TODO(kmillikin): Handle conversion.
-    SetValue(instr, non_constant_);
-  }
-}
-
-
-void ConstantPropagator::VisitBoxFloat64x2(BoxFloat64x2Instr* instr) {
-  const Object& value = instr->value()->definition()->constant_value();
-  if (IsNonConstant(value)) {
-    SetValue(instr, non_constant_);
-  } else if (IsConstant(value)) {
-    // TODO(kmillikin): Handle conversion.
-    SetValue(instr, non_constant_);
-  }
-}
-
-
-void ConstantPropagator::VisitUnboxInt32x4(UnboxInt32x4Instr* instr) {
-  const Object& value = instr->value()->definition()->constant_value();
-  if (IsNonConstant(value)) {
-    SetValue(instr, non_constant_);
   } else if (IsConstant(value)) {
     // TODO(kmillikin): Handle conversion.
     SetValue(instr, non_constant_);
   }
 }
 
 
-void ConstantPropagator::VisitBoxInt32x4(BoxInt32x4Instr* instr) {
+void ConstantPropagator::VisitBox(BoxInstr* instr) {
   const Object& value = instr->value()->definition()->constant_value();
   if (IsNonConstant(value)) {
     SetValue(instr, non_constant_);
   } else if (IsConstant(value)) {
     // TODO(kmillikin): Handle conversion.
     SetValue(instr, non_constant_);
   }
 }
 
 
@@ skipping 1006 matching lines @@
   }
 
   // Process materializations and unbox their arguments: materializations
   // are part of the environment and can materialize boxes for double/mint/simd
   // values when needed.
   // TODO(vegorov): handle all box types here.
   for (intptr_t i = 0; i < materializations_.length(); i++) {
     MaterializeObjectInstr* mat = materializations_[i];
     for (intptr_t j = 0; j < mat->InputCount(); j++) {
       Definition* defn = mat->InputAt(j)->definition();
-      if (defn->IsBoxDouble() ||
-          defn->IsBoxFloat32x4() ||
-          defn->IsBoxInt32x4()) {
+      if (defn->IsBox()) {
         mat->InputAt(j)->BindTo(defn->InputAt(0)->definition());
       }
     }
   }
 }
 
 
 // Remove materializations from the graph. Register allocator will treat them
 // as part of the environment not as a real instruction.
 void AllocationSinking::DetachMaterializations() {
@@ skipping 213 matching lines @@
 
   // Insert materializations at environment uses.
   for (intptr_t i = 0; i < exits_collector_.exits().length(); i++) {
     CreateMaterializationAt(
         exits_collector_.exits()[i], alloc, alloc->cls(), *slots);
   }
 }
 
 
 }  // namespace dart