Support Int32 representation for selected binary operations.

runtime/vm/intermediate_language.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/intermediate_language.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/bit_vector.h"
 #include "vm/cpu.h"
 #include "vm/dart_entry.h"
@@ skipping 294 matching lines @@
 
 bool BinarySmiOpInstr::AttributesEqual(Instruction* other) const {
   BinarySmiOpInstr* other_op = other->AsBinarySmiOp();
   ASSERT(other_op != NULL);
   return (op_kind() == other_op->op_kind()) &&
       (overflow_ == other_op->overflow_) &&
       (is_truncating_ == other_op->is_truncating_);
 }
 
 
+bool BinaryInt32OpInstr::AttributesEqual(Instruction* other) const {
+  BinaryInt32OpInstr* other_op = other->AsBinaryInt32Op();
+  ASSERT(other_op != NULL);
+  return (op_kind() == other_op->op_kind()) &&
+      (overflow_ == other_op->overflow_) &&
+      (is_truncating_ == other_op->is_truncating_);
+}
+
+
 EffectSet LoadFieldInstr::Dependencies() const {
   return immutable_ ? EffectSet::None() : EffectSet::All();
 }
 
 
 bool LoadFieldInstr::AttributesEqual(Instruction* other) const {
   LoadFieldInstr* other_load = other->AsLoadField();
   ASSERT(other_load != NULL);
   if (field() != NULL) {
     return (other_load->field() != NULL) &&
@@ skipping 56 matching lines @@
 }
 
 
 bool ConstantInstr::AttributesEqual(Instruction* other) const {
   ConstantInstr* other_constant = other->AsConstant();
   ASSERT(other_constant != NULL);
   return (value().raw() == other_constant->value().raw());
 }
 
 
-UnboxedConstantInstr::UnboxedConstantInstr(const Object& value)
-    : ConstantInstr(value), constant_address_(0) {
-  // Only doubles supported for now.
-  ASSERT(value.IsDouble());
-  constant_address_ =
-      FlowGraphBuilder::FindDoubleConstant(Double::Cast(value).value());
+UnboxedConstantInstr::UnboxedConstantInstr(const Object& value,
+                                           Representation representation)
+    : ConstantInstr(value),
+      representation_(representation),
+      constant_address_(0) {
+  if (representation_ == kUnboxedDouble) {
+    ASSERT(value.IsDouble());
+    constant_address_ =
+        FlowGraphBuilder::FindDoubleConstant(Double::Cast(value).value());
+  }
 }
 
 
 bool Value::BindsTo32BitMaskConstant() const {
   if (!definition()->IsUnboxInteger() || !definition()->IsUnboxUint32()) {
     return false;
   }
   // Two cases to consider: UnboxInteger and UnboxUint32.
   if (definition()->IsUnboxInteger()) {
     UnboxIntegerInstr* instr = definition()->AsUnboxInteger();
@@ skipping 264 matching lines @@
   }
 
   set_previous_use(NULL);
   set_next_use(NULL);
 }
 
 
 // True if the definition has a single input use and is used only in
 // environments at the same instruction as that input use.
 bool Definition::HasOnlyUse(Value* use) const {
-  if ((input_use_list() != use) || (use->next_use() != NULL)) return false;
+  if (!HasOnlyInputUse(use)) {
+    return false;
+  }
 
   Instruction* target = use->instruction();
   for (Value::Iterator it(env_use_list()); !it.Done(); it.Advance()) {
     if (it.Current()->instruction() != target) return false;
   }
   return true;
 }
 
 
+bool Definition::HasOnlyInputUse(Value* use) const {
+  return (input_use_list() == use) && (use->next_use() == NULL);
+}
+
+
 void Definition::ReplaceUsesWith(Definition* other) {
   ASSERT(other != NULL);
   ASSERT(this != other);
 
   Value* current = NULL;
   Value* next = input_use_list();
   if (next != NULL) {
     // Change all the definitions.
     while (next != NULL) {
       current = next;
@@ skipping 441 matching lines @@
   ASSERT(index == 0);
   return successor();
 }
 
 
 void Instruction::Goto(JoinEntryInstr* entry) {
   LinkTo(new GotoInstr(entry));
 }
 
 
+bool UnboxedIntConverterInstr::CanDeoptimize() const {
+  return (to() == kUnboxedInt32) &&
+      !Range::Fits(value()->definition()->range(),
+                   RangeBoundary::kRangeBoundaryInt32);
+}
+
+
+bool UnboxInt32Instr::CanDeoptimize() const {
+  const intptr_t value_cid = value()->Type()->ToCid();
+  if (value_cid == kSmiCid) {
+    return false;
+  } else if (value_cid == kMintCid) {
+    return !Range::Fits(value()->definition()->range(),
+                        RangeBoundary::kRangeBoundaryInt32);
+  } else {
+    return true;
+  }
+}
+
+
+bool BinaryInt32OpInstr::CanDeoptimize() const {
+  switch (op_kind()) {
+    case Token::kBIT_AND:
+    case Token::kBIT_OR:
+    case Token::kBIT_XOR:
+      return false;
+
+    case Token::kSHR:
+      return false;
+
+    case Token::kSHL:
+      return true;
+
+    case Token::kMOD: {
+      UNREACHABLE();
+    }
+
+    default:
+      return overflow_;
+  }
+}
+
+
 bool BinarySmiOpInstr::CanDeoptimize() const {
   if (FLAG_throw_on_javascript_int_overflow && (Smi::kBits > 32)) {
     // If Smi's are bigger than 32-bits, then the instruction could deoptimize
     // if the result is too big.
     return true;
   }
   switch (op_kind()) {
     case Token::kBIT_AND:
     case Token::kBIT_OR:
     case Token::kBIT_XOR:
@@ skipping 256 matching lines @@
                                              left(),
                                              truncation_mask);
   if (result != NULL) {
     return result;
   }
 
   return this;
 }
 
 
+Definition* BinaryInt32OpInstr::Canonicalize(FlowGraph* flow_graph) {
+  Definition* result = NULL;
+
+  result = CanonicalizeCommutativeArithmetic(op_kind(),
+                                             kSmiCid,
+                                             left(),
+                                             right());
+  if (result != NULL) {
+    return result;
+  }
+
+  result = CanonicalizeCommutativeArithmetic(op_kind(),
+                                             kSmiCid,
+                                             right(),
+                                             left());
+  if (result != NULL) {
+    return result;
+  }
+
+  return this;
+}
+
+
 // Optimizations that eliminate or simplify individual instructions.
 Instruction* Instruction::Canonicalize(FlowGraph* flow_graph) {
   return this;
 }
 
 
 Definition* Definition::Canonicalize(FlowGraph* flow_graph) {
   return this;
 }
 
@@ skipping 178 matching lines @@
   // Fold away BoxDouble(UnboxDouble(v)) if value is known to be double.
   UnboxDoubleInstr* defn = value()->definition()->AsUnboxDouble();
   if ((defn != NULL) && (defn->value()->Type()->ToCid() == kDoubleCid)) {
     return defn->value()->definition();
   }
 
   return this;
 }
 
 
+bool BoxIntNInstr::ValueFitsSmi() const {
+  Range* range = value()->definition()->range();
+  return Range::Fits(range, RangeBoundary::kRangeBoundarySmi);
+}
+
+
+Definition* BoxIntNInstr::Canonicalize(FlowGraph* flow_graph) {
+  if ((input_use_list() == NULL) && !HasTryBlockUse(env_use_list())) {
+    // Environments can accomodate any representation. No need to box.
+    return value()->definition();
+  }
+
+  return this;
+}
+
+
+Definition* UnboxIntNInstr::Canonicalize(FlowGraph* flow_graph) {
+  if (!HasUses()) return NULL;
+
+  // Fold away UnboxInt<N>Instr(BoxInt<N>Instr(v)).
+  BoxIntNInstr* box_defn = value()->definition()->AsBoxIntN();
+  if (box_defn != NULL) {
+    if (box_defn->value()->definition()->representation() == representation()) {
+      return box_defn->value()->definition();
+    } else {
+      UnboxedIntConverterInstr* converter = new UnboxedIntConverterInstr(
+          box_defn->value()->definition()->representation(),
+          representation(),
+          box_defn->value()->CopyWithType(),
+          representation() == kUnboxedInt32 ? deopt_id_ : Isolate::kNoDeoptId);
+      flow_graph->InsertBefore(this, converter, env(), FlowGraph::kValue);
+      return converter;
+    }
+  }
+
+  return this;
+}
+
+
+Definition* UnboxedIntConverterInstr::Canonicalize(FlowGraph* flow_graph) {
+  if (!HasUses()) return NULL;
+
+  UnboxedIntConverterInstr* box_defn =
+      value()->definition()->AsUnboxedIntConverter();
+  if ((box_defn != NULL) && (box_defn->representation() == from())) {
+    if (box_defn->from() == to()) {
+      return box_defn->value()->definition();
+    }
+
+    UnboxedIntConverterInstr* converter = new UnboxedIntConverterInstr(
+        box_defn->from(),
+        representation(),
+        box_defn->value()->CopyWithType(),
+        to() == kUnboxedInt32 ? deopt_id_ : NULL);
+    flow_graph->InsertBefore(this, converter, env(), FlowGraph::kValue);
+    return converter;
+  }
+
+  UnboxIntegerInstr* unbox_defn = value()->definition()->AsUnboxInteger();
+  if (unbox_defn != NULL &&
+      (from() == kUnboxedMint) &&
+      (to() == kUnboxedInt32) &&
+      unbox_defn->HasOnlyInputUse(value())) {
+    // TODO(vegorov): there is a duplication of code between UnboxedIntCoverter
+    // and code path that unboxes Mint into Int32. We should just schedule
+    // these instructions close to each other instead of fusing them.
+    Definition* replacement =
+        new UnboxInt32Instr(unbox_defn->value()->CopyWithType(), deopt_id_);
+    flow_graph->InsertBefore(this,
+                             replacement,
+                             env(),
+                             FlowGraph::kValue);
+    return replacement;
+  }
+
+  return this;
+}
+
+
+Definition* UnboxInt32Instr::Canonicalize(FlowGraph* flow_graph) {
+  Definition* replacement = UnboxIntNInstr::Canonicalize(flow_graph);
+  if (replacement != this) {
+    return replacement;
+  }
+
+  ConstantInstr* c = value()->definition()->AsConstant();
+  if ((c != NULL) && c->value().IsSmi()) {
+    UnboxedConstantInstr* uc =
+        new UnboxedConstantInstr(c->value(), kUnboxedInt32);
+    flow_graph->InsertBefore(this, uc, NULL, FlowGraph::kValue);
+    return uc;
+  }
+
+  return this;
+}
+
+
 Definition* UnboxDoubleInstr::Canonicalize(FlowGraph* flow_graph) {
   if (!HasUses()) return NULL;
   // Fold away UnboxDouble(BoxDouble(v)).
   BoxDoubleInstr* box_defn = value()->definition()->AsBoxDouble();
   if (box_defn != NULL) {
     return box_defn->value()->definition();
   }
 
   ConstantInstr* c = value()->definition()->AsConstant();
   if ((c != NULL) && c->value().IsDouble()) {
-    UnboxedConstantInstr* uc = new UnboxedConstantInstr(c->value());
+    UnboxedConstantInstr* uc =
+        new UnboxedConstantInstr(c->value(), kUnboxedDouble);
     flow_graph->InsertBefore(this, uc, NULL, FlowGraph::kValue);
     return uc;
   }
 
   return this;
 }
 
 
+Definition* BoxIntegerInstr::Canonicalize(FlowGraph* flow_graph) {
+  if ((input_use_list() == NULL) && !HasTryBlockUse(env_use_list())) {
+    // Environments can accomodate any representation. No need to box.
+    return value()->definition();
+  }
+
+  UnboxedIntConverterInstr* conv =
+      value()->definition()->AsUnboxedIntConverter();
+  if (conv != NULL) {
+    Definition* replacement = this;
+
+    switch (conv->from()) {
+      case kUnboxedInt32:
+        replacement = new BoxInt32Instr(conv->value()->CopyWithType());
+        break;
+      case kUnboxedUint32:
+        replacement = new BoxUint32Instr(conv->value()->CopyWithType());
+        break;
+      default:
+        UNREACHABLE();
+        break;
+    }
+
+    if (replacement != this) {
+      flow_graph->InsertBefore(this,
+                               replacement,
+                               NULL,
+                               FlowGraph::kValue);
+    }
+
+    return replacement;
+  }
+
+  return this;
+}
+
+
+Definition* UnboxIntegerInstr::Canonicalize(FlowGraph* flow_graph) {
+  if (!HasUses()) return NULL;
+  return this;
+}
+
+
 Definition* BoxFloat32x4Instr::Canonicalize(FlowGraph* flow_graph) {
   if ((input_use_list() == NULL) && !HasTryBlockUse(env_use_list())) {
     // Environments can accomodate any representation. No need to box.
     return value()->definition();
   }
 
   // Fold away BoxFloat32x4(UnboxFloat32x4(v)).
   UnboxFloat32x4Instr* defn = value()->definition()->AsUnboxFloat32x4();
   if ((defn != NULL) && (defn->value()->Type()->ToCid() == kFloat32x4Cid)) {
     return defn->value()->definition();
@@ skipping 1206 matching lines @@
     case Token::kTRUNCDIV: return 0;
     case Token::kMOD: return 1;
     default: UNIMPLEMENTED(); return -1;
   }
 }
 
 
 #undef __
 
 }  // namespace dart