Avoid generating '>>> 0' for bitops for which the result is only

lib/compiler/implementation/ssa/codegen.dart

 // Copyright (c) 2012, 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.
 
 class SsaCodeGeneratorTask extends CompilerTask {
   final JavaScriptBackend backend;
   SsaCodeGeneratorTask(JavaScriptBackend backend)
       : this.backend = backend,
         super(backend.compiler);
   String get name() => 'SSA code generator';
@@ skipping 180 matching lines @@
 
   LibraryElement get currentLibrary() => work.element.getLibrary();
   Compiler get compiler() => backend.compiler;
   NativeEmitter get nativeEmitter() => backend.emitter.nativeEmitter;
   Enqueuer get world() => backend.compiler.enqueuer.codegen;
 
   bool isGenerateAtUseSite(HInstruction instruction) {
     return generateAtUseSite.contains(instruction);
   }
 
+  bool isNonNegativeInt32Constant(HInstruction instruction) {
+    if (instruction.isConstantInteger()) {
+      int value = instruction.constant.value;
+      if (value >= 0 && value < Math.pow(2, 31)) {

[floitsch, 2012/06/28 22:57:18]

(1 << 31) would be a compile time constant. Math.pow isn't.
Not a strong preference, though.

[Mads Ager (google), 2012/06/29 00:03:23]

Done.

+        return true;
+      }
+    }
+    return false;
+  }
+
+  // We want the outcome of bit-operations to be positive. However, if
+  // the result of a bit-operation is only used by other bit
+  // operations we do not have to convert to an unsigned
+  // integer. Also, if we are using & with a positive constant we know
+  // that the result is positive already and need no conversion.
+  bool requiresUintConversion(HInstruction instruction) {
+    if (instruction is HBitAnd &&
+        (isNonNegativeInt32Constant(instruction.left) ||
+         isNonNegativeInt32Constant(instruction.right))) {
+      return false;
+    }
+    bool result = false;
+    for (HInstruction use in instruction.usedBy) {
+      if (use is! HBitNot && use is! HBinaryBitOp) {
+        result = true;
+        break;
+      }
+    }
+    return result;
+  }
+
   SsaCodeGenerator(this.backend,
                    this.work,
                    this.parameters,
                    this.parameterNames)
     : declaredVariables = new Set<String>(),
       delayedVariableDeclarations = new Set<String>(),
       buffer = new StringBuffer(),
       generateAtUseSite = new Set<HInstruction>(),
       controlFlowOperators = new Set<HInstruction>(),
       breakAction = new Map<Element, ElementAction>(),
@@ skipping 930 matching lines @@
       use(node.right, operatorPrecedences.right);
       endExpression(operatorPrecedences.precedence);
     } else {
       visitInvokeStatic(node);
     }
   }
 
   // We want the outcome of bit-operations to be positive. We use the unsigned
   // shift operator to achieve this.
   visitBitInvokeBinary(HBinaryBitOp node, String op) {
-    if (node.builtin) {
+    if (node.builtin && requiresUintConversion(node)) {
       beginExpression(unsignedShiftPrecedences.precedence);
       int oldPrecedence = this.expectedPrecedence;
       this.expectedPrecedence = JSPrecedence.SHIFT_PRECEDENCE;
       visitInvokeBinary(node, op);
       buffer.add(' >>> 0');
       this.expectedPrecedence = oldPrecedence;
       endExpression(unsignedShiftPrecedences.precedence);
     } else {
       visitInvokeBinary(node, op);
     }
   }
 
   visitInvokeUnary(HInvokeUnary node, String op) {
     if (node.builtin) {
       beginExpression(JSPrecedence.PREFIX_PRECEDENCE);
       buffer.add('$op');
       use(node.operand, JSPrecedence.PREFIX_PRECEDENCE);
       endExpression(JSPrecedence.PREFIX_PRECEDENCE);
     } else {
       visitInvokeStatic(node);
     }
   }
 
   // We want the outcome of bit-operations to be positive. We use the unsigned
   // shift operator to achieve this.
   visitBitInvokeUnary(HInvokeUnary node, String op) {
-    if (node.builtin){
+    if (node.builtin && requiresUintConversion(node)) {
       beginExpression(unsignedShiftPrecedences.precedence);
       int oldPrecedence = this.expectedPrecedence;
       this.expectedPrecedence = JSPrecedence.SHIFT_PRECEDENCE;
       visitInvokeUnary(node, op);
       buffer.add(' >>> 0');
       this.expectedPrecedence = oldPrecedence;
       endExpression(unsignedShiftPrecedences.precedence);
     } else {
       visitInvokeUnary(node, op);
     }
@@ skipping 1883 matching lines @@
       startBailoutSwitch();
     }
   }
 
   void endLabeledBlock(HLabeledBlockInformation labeledBlockInfo) {
     if (labeledBlockInfo.body.start.hasGuards()) {
       endBailoutSwitch();
     }
   }
 }