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 1107 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) {
+  Definition* result = NULL;
+
+  result = CanonicalizeCommutativeArithmetic(op_kind(),
+                                             kMintCid,
+                                             left(),
+                                             right());
+  if (result != NULL) {
+    return result;
+  }
+
+  result = CanonicalizeCommutativeArithmetic(op_kind(),
+                                             kMintCid,
+                                             right(),
+                                             left());
+  if (result != NULL) {
+    return result;
+  }
+
+  // If this is (value & 0xFFFFFFFF) the mask operation can be dropped.
+  if (IsUint32Mask(this)) {

[Vyacheslav Egorov (Google), 2014/07/08 12:39:31]

I would fold it into CanonicalizeCommutativeArithmetic() for generality? If
value is Uint32 and mask is 0x100000000 then result is 0 etc (similar for
addition --- v + 0x100000000 == v).

You can achieve it by supplying truncation rule to
CanonicalizeCommutativeArithmetic, so that instead of == there we compare only
the given number of bits.

[Cutch, 2014/07/09 17:48:26]

This specific case can't be folded into CanonicalizeCommunitativeArithmetic, it
should actually be moved up above the other exit cases.

I've gone ahead and added the truncation value to
CanonicalizeCommunitativeArithmetic and fixed possible crashing bugs (treating a
32 intptr_t as a double!). I should cover the cases you highlighted above.

+    return NULL;
+  }
+
+  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