Improve precision of range analysis by allowing it to track ranges across all int typed phis.

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/bit_vector.h"
 #include "vm/cpu.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_allocator.h"
@@ skipping 1242 matching lines @@
 
 bool BinaryIntegerOpInstr::RightIsPowerOfTwoConstant() const {
   if (!right()->definition()->IsConstant()) return false;
   const Object& constant = right()->definition()->AsConstant()->value();
   if (!constant.IsSmi()) return false;
   const intptr_t int_value = Smi::Cast(constant).Value();
   return Utils::IsPowerOfTwo(Utils::Abs(int_value));
 }
 
 
+static intptr_t RepresentationBits(Representation r) {
+  switch (r) {
+    case kTagged:
+      return kBitsPerWord - 1;
+    case kUnboxedInt32:
+    case kUnboxedUint32:
+      return 32;
+    case kUnboxedMint:
+      return 64;
+    default:
+      UNREACHABLE();
+      return 0;
+  }
+}
+
+
+static int64_t RepresentationMask(Representation r) {
+  return static_cast<int64_t>(
+      static_cast<uint64_t>(-1) >> (64 - RepresentationBits(r)));
+}
+
+
 static bool ToIntegerConstant(Value* value, int64_t* result) {
   if (!value->BindsToConstant()) {
     UnboxInstr* unbox = value->definition()->AsUnbox();
-    if ((unbox != NULL) && (unbox->representation() == kUnboxedDouble)) {
-      return ToIntegerConstant(unbox->value(), result);
+    if (unbox != NULL) {
+      if (unbox->representation() == kUnboxedDouble) {
+        return ToIntegerConstant(unbox->value(), result);
+      } else if (unbox->representation() == kUnboxedUint32) {

[Florian Schneider, 2014/11/10 16:10:47]

Why are kUnboxedInt32 and kInboxedMint not handled here?

+        if (ToIntegerConstant(unbox->value(), result)) {
+          *result &= RepresentationMask(kUnboxedUint32);
+          return true;
+        }
+        return false;
+      }
     }
     return false;
   }
 
   const Object& constant = value->BoundConstant();
   if (constant.IsDouble()) {
     const Double& double_constant = Double::Cast(constant);
     *result = static_cast<int64_t>(double_constant.value());
     return (static_cast<double>(*result) == double_constant.value());
   } else if (constant.IsSmi()) {
@@ skipping 107 matching lines @@
     case Token::kBIT_AND:
     case Token::kBIT_OR:
     case Token::kBIT_XOR:
       return true;
     default:
       return false;
   }
 }
 
 
-static intptr_t RepresentationBits(Representation r) {
-  switch (r) {
-    case kTagged:
-      return kBitsPerWord - 1;
-    case kUnboxedInt32:
-    case kUnboxedUint32:
-      return 32;
-    case kUnboxedMint:
-      return 64;
-    default:
-      UNREACHABLE();
-      return 0;
-  }
-}
-
-
-static int64_t RepresentationMask(Representation r) {
-  return static_cast<int64_t>(
-      static_cast<uint64_t>(-1) >> (64 - RepresentationBits(r)));
-}
-
-
 UnaryIntegerOpInstr* UnaryIntegerOpInstr::Make(Representation representation,
                                                Token::Kind op_kind,
                                                Value* value,
                                                intptr_t deopt_id,
                                                Range* range) {
   UnaryIntegerOpInstr* op = NULL;
   switch (representation) {
     case kTagged:
       op = new UnarySmiOpInstr(op_kind, value, deopt_id);
       break;
@@ skipping 1921 matching lines @@
     case Token::kTRUNCDIV: return 0;
     case Token::kMOD: return 1;
     default: UNIMPLEMENTED(); return -1;
   }
 }
 
 
 #undef __
 
 }  // namespace dart