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 319 matching lines @@
 
 
 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());
 }
 
+
+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();
+    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;
+  } else if (definition()->IsUnboxUint32()) {
+    UnboxUint32Instr* instr = definition()->AsUnboxUint32();
+    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;
+  }
+  return false;
+}
+
+
 // Returns true if the value represents a constant.
 bool Value::BindsToConstant() const {
   return definition()->IsConstant();
 }
 
 
 // Returns true if the value represents constant null.
 bool Value::BindsToConstantNull() const {
   ConstantInstr* constant = definition()->AsConstant();
   return (constant != NULL) && constant->value().IsNull();
@@ skipping 909 matching lines @@
 
 bool BinarySmiOpInstr::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 bool ToIntegerConstant(Value* value, intptr_t* result) {
+static bool ToIntegerConstant(Value* value, int64_t* result) {
   if (!value->BindsToConstant()) {
     if (value->definition()->IsUnboxDouble()) {
       return ToIntegerConstant(value->definition()->AsUnboxDouble()->value(),
                                result);
     }
     return false;
   }
 
   const Object& constant = value->BoundConstant();
   if (constant.IsDouble()) {
     const Double& double_constant = Double::Cast(constant);
-    *result = static_cast<intptr_t>(double_constant.value());
+    *result = static_cast<int64_t>(double_constant.value());
     return (static_cast<double>(*result) == double_constant.value());
   } else if (constant.IsSmi()) {
     *result = Smi::Cast(constant).Value();
     return true;
+  } else if (constant.IsMint()) {
+    *result = Mint::Cast(constant).value();
+    return true;
   }
 
   return false;
 }
 
 
-static Definition* CanonicalizeCommutativeArithmetic(Token::Kind op,
-                                                     intptr_t cid,
-                                                     Value* left,
-                                                     Value* right) {
+static Definition* CanonicalizeCommutativeArithmetic(
+    Token::Kind op,
+    intptr_t cid,
+    Value* left,
+    Value* right,
+    int64_t mask = static_cast<int64_t>(0xFFFFFFFFFFFFFFFF)) {
   ASSERT((cid == kSmiCid) || (cid == kDoubleCid) || (cid == kMintCid));
 
-  intptr_t left_value;
+  int64_t left_value;
   if (!ToIntegerConstant(left, &left_value)) {
     return NULL;
   }
 
+  // Apply truncation mask to left_value.
+  left_value &= mask;
+
   switch (op) {
     case Token::kMUL:
       if (left_value == 1) {
         if ((cid == kDoubleCid) &&
             (right->definition()->representation() != kUnboxedDouble)) {
           // Can't yet apply the equivalence because representation selection
           // did not run yet. We need it to guarantee that right value is
           // correctly coerced to double. The second canonicalization pass
           // will apply this equivalence.
           return NULL;
@@ skipping 10 matching lines @@
       if ((left_value == 0) && (cid != kDoubleCid)) {
         // Can't apply this equivalence to double operations because
         // 0.0 + (-0.0) is 0.0 not -0.0.
         return right->definition();
       }
       break;
     case Token::kBIT_AND:
       ASSERT(cid != kDoubleCid);
       if (left_value == 0) {
         return left->definition();
       } else if (left_value == -1) {

[Vyacheslav Egorov (Google), 2014/07/11 16:00:08]

I think you should s/-1/mask/ in this function.

[Cutch, 2014/07/11 22:04:13]

Done.

         return right->definition();
       }
       break;
     case Token::kBIT_OR:
       ASSERT(cid != kDoubleCid);
       if (left_value == 0) {
         return right->definition();
       } else if (left_value == -1) {

[Vyacheslav Egorov (Google), 2014/07/11 16:00:08]

ditto

[Cutch, 2014/07/11 22:04:14]

Done.

         return left->definition();
       }
       break;
     case Token::kBIT_XOR:
       ASSERT(cid != kDoubleCid);
       if (left_value == 0) {
         return right->definition();
       }
       break;
     default:
@@ skipping 105 matching lines @@
                                              right(),
                                              left());
   if (result != NULL) {
     return result;
   }
 
   return this;
 }
 
 
+static bool IsUint32Mask(BinaryUint32OpInstr* defn) {
+  ASSERT(defn != NULL);
+  if (defn->op_kind() != Token::kBIT_AND) {
+    // Not a mask.
+    return false;
+  }
+  Value* left = defn->left();
+  Value* right = defn->right();
+  return left->BindsTo32BitMaskConstant() != right->BindsTo32BitMaskConstant();
+}
+
+
+Definition* BinaryUint32OpInstr::Canonicalize(FlowGraph* flow_graph) {
+  // If this is (value & 0xFFFFFFFF) the mask operation can be dropped because
+  // all Uint32 operations are implicitly masked with 0xFFFFFFFF.
+  if (IsUint32Mask(this)) {

[Vyacheslav Egorov (Google), 2014/07/11 16:00:08]

I think this is not needed anymore once you replace -1 with mask as described
above.

[Cutch, 2014/07/11 22:04:13]

Done.

+    return NULL;
+  }
+
+  Definition* result = NULL;
+
+  const int64_t truncation_mask = static_cast<int64_t>(0xFFFFFFFF);
+
+  result = CanonicalizeCommutativeArithmetic(op_kind(),
+                                             kMintCid,
+                                             left(),
+                                             right(),
+                                             truncation_mask);
+  if (result != NULL) {
+    return result;
+  }
+
+  result = CanonicalizeCommutativeArithmetic(op_kind(),
+                                             kMintCid,
+                                             right(),
+                                             left(),
+                                             truncation_mask);
+  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 2498 matching lines @@
     case Token::kTRUNCDIV: return 0;
     case Token::kMOD: return 1;
     default: UNIMPLEMENTED(); return -1;
   }
 }
 
 
 #undef __
 
 }  // namespace dart