Add Uint32 representation

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 325 matching lines @@
   constant_address_ =
       FlowGraphBuilder::FindDoubleConstant(Double::Cast(value).value());
 }
 
 // Returns true if the value represents a constant.
 bool Value::BindsToConstant() const {
   return definition()->IsConstant();
 }
 
 
+bool Value::BindsTo32BitMint() const {
+  if (!definition()->IsMintDefinition()) {
+    return false;
+  }
+  if (definition()->IsBinaryMintOp()) {
+    BinaryMintOpInstr* instr = definition()->AsBinaryMintOp();
+    return instr->is_32_bit();
+  } else if (definition()->IsShiftMintOp()) {
+    ShiftMintOpInstr* instr = definition()->AsShiftMintOp();
+    return instr->is_32_bit();
+  } else if (definition()->IsUnboxInteger()) {
+    UnboxIntegerInstr* instr = definition()->AsUnboxInteger();
+    return instr->is_32_bit();
+  } else if (definition()->IsUnaryMintOp()) {
+    UnaryMintOpInstr* instr = definition()->AsUnaryMintOp();
+    return instr->is_32_bit();
+  }
+  return false;
+}
+
+
+bool Value::BindsTo32BitMaskConstant() const {
+  if (!definition()->IsUnboxInteger()) {
+    return false;
+  }
+  UnboxIntegerInstr* instr = definition()->AsUnboxInteger();
+  if (!instr->value()->BindsToConstant()) {
+    return false;
+  }
+  const Object& obj = instr->value()->BoundConstant();
+  if (!obj.IsMint()) {
+    return false;
+  }
+  Mint& mint = Mint::Handle();
+  mint ^= obj.raw();
+  return mint.value() == kMaxUint32;
+}
+
+
 // Returns true if the value represents constant null.
 bool Value::BindsToConstantNull() const {
   ConstantInstr* constant = definition()->AsConstant();
   return (constant != NULL) && constant->value().IsNull();
 }
 
 
 const Object& Value::BoundConstant() const {
   ASSERT(BindsToConstant());
   ConstantInstr* constant = definition()->AsConstant();
@@ skipping 2854 matching lines @@
   // Calculate overflowed status before clamping.
   const bool overflowed = range_->min().LowerBound().OverflowedSmi() ||
                           range_->max().UpperBound().OverflowedSmi();
   // Clamp value to be within smi range.
   range_->Clamp(RangeBoundary::kRangeBoundarySmi);
 
   set_overflow(overflowed);
 }
 
 
+Representation BinaryMintOpInstr::RequiredInputRepresentation(
+    intptr_t idx) const {
+  ASSERT((idx == 0) || (idx == 1));
+  return InputAt(idx)->BindsTo32BitMint() ? kUnboxedMint32 : kUnboxedMint;
+}
+
+
 void BinaryMintOpInstr::InferRange() {
   // TODO(vegorov): canonicalize BinaryMintOpInstr to always have constant on
   // the right and a non-constant on the left.
   Definition* left_defn = left()->definition();
 
   Range* left_range = left_defn->range();
   Range* right_range = right()->definition()->range();
 
   if ((left_range == NULL) || (right_range == NULL)) {
     range_ = Range::Unknown();
@@ skipping 173 matching lines @@
 
 bool Range::And(const Range* left_range,
                 const Range* right_range,
                 RangeBoundary* result_min,
                 RangeBoundary* result_max) {
   ASSERT(left_range != NULL);
   ASSERT(right_range != NULL);
   ASSERT(result_min != NULL);
   ASSERT(result_max != NULL);
 
+  // Both ranges are >= 0.
+  if ((Range::ConstantMin(left_range).ConstantValue() >= 0) &&
+      (Range::ConstantMin(right_range).ConstantValue() >= 0)) {
+    *result_min = RangeBoundary::FromConstant(0);
+    // Take minimum value as new range.
+    *result_max = RangeBoundary::Min(Range::ConstantMax(left_range),
+                                     Range::ConstantMax(right_range),
+                                     RangeBoundary::kRangeBoundaryInt64);
+    return true;
+  }
+
+  // Right range is >= 0.
   if (Range::ConstantMin(right_range).ConstantValue() >= 0) {
     *result_min = RangeBoundary::FromConstant(0);
     *result_max = Range::ConstantMax(right_range);
     return true;
   }
 
+  // Left range is >= 0.
   if (Range::ConstantMin(left_range).ConstantValue() >= 0) {
     *result_min = RangeBoundary::FromConstant(0);
     *result_max = Range::ConstantMax(left_range);
     return true;
   }
 
   return false;
 }
 
 
@@ skipping 488 matching lines @@
     case Token::kTRUNCDIV: return 0;
     case Token::kMOD: return 1;
     default: UNIMPLEMENTED(); return -1;
   }
 }
 
 
 #undef __
 
 }  // namespace dart