Redo "Fix for issue 16497 - fix load elimination aliasing for typed arrays"

sdk/lib/_internal/compiler/implementation/ssa/optimize.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.
 
 part of ssa;
 
 abstract class OptimizationPhase {
   String get name;
   void visitGraph(HGraph graph);
 }
@@ skipping 1688 matching lines @@
       <HInstruction, Map<HInstruction, HInstruction>> {};
 
   /**
    * Set of objects that we know don't escape the current function.
    */
   final Setlet<HInstruction> nonEscapingReceivers = new Setlet<HInstruction>();
 
   MemorySet(this.compiler);
 
   /**
-   * Returns whether [first] and [second] may alias to the same
-   * object.
+   * Returns whether [first] and [second] always alias to the same object.
+   */
+  bool mustAlias(HInstruction first, HInstruction second) {
+    return first == second;
+  }
+
+  /**
+   * Returns whether [first] and [second] may alias to the same object.
    */
   bool mayAlias(HInstruction first, HInstruction second) {
-    if (first == second) return true;
+    if (mustAlias(first, second)) return true;
     if (isConcrete(first) && isConcrete(second)) return false;
     if (nonEscapingReceivers.contains(first)) return false;
     if (nonEscapingReceivers.contains(second)) return false;
+    // Typed arrays of different types might have a shared buffer.
+    if (couldBeTypedArray(first) && couldBeTypedArray(second)) return true;
     TypeMask intersection = first.instructionType.intersection(
         second.instructionType, compiler);
     if (intersection.isEmpty) return false;
     return true;
   }
 
   bool isFinal(Element element) {
     return compiler.world.fieldNeverChanges(element);
   }
 
   bool isConcrete(HInstruction instruction) {
     return instruction is HForeignNew
         || instruction is HConstant
         || instruction is HLiteralList;
   }
 
+  bool couldBeTypedArray(HInstruction receiver) {
+    JavaScriptBackend backend = compiler.backend;
+    return backend.couldBeTypedArray(receiver.instructionType);
+  }
+
   /**
    * Returns whether [receiver] escapes the current function.
    */
   bool escapes(HInstruction receiver) {
     return !nonEscapingReceivers.contains(receiver);
   }
 
   void registerAllocation(HInstruction instruction) {
     nonEscapingReceivers.add(instruction);
   }
@@ skipping 99 matching lines @@
   /**
    * Sets `receiver[index]` to contain [value]. Kills all potential
    * places that may be affected by this update.
    */
   void registerKeyedValueUpdate(HInstruction receiver,
                                 HInstruction index,
                                 HInstruction value) {
     nonEscapingReceivers.remove(value);
     keyedValues.forEach((key, values) {
       if (mayAlias(receiver, key)) {
+        // Typed arrays that are views of the same buffer may have different
+        // offsets or element sizes, unless they are the same typed array.
+        bool weakIndex = couldBeTypedArray(key) && !mustAlias(receiver, key);
         values.forEach((otherIndex, otherValue) {
-          if (mayAlias(index, otherIndex)) values[otherIndex] = null;
+          if (weakIndex || mayAlias(index, otherIndex)) {
+            values[otherIndex] = null;
+          }
         });
       }
     });
 
-    JavaScriptBackend backend = compiler.backend;
     // Typed arrays may narrow incoming values.
-    if (backend.couldBeTypedArray(receiver.instructionType)) return;
+    if (couldBeTypedArray(receiver)) return;
 
     Map<HInstruction, HInstruction> map = keyedValues.putIfAbsent(
         receiver, () => <HInstruction, HInstruction> {});
     map[index] = value;
   }
 
   /**
    * Returns null if either [first] or [second] is null. Otherwise
    * returns [first] if [first] and [second] are equal. Otherwise
    * creates or re-uses a phi in [block] that holds [first] and [second].
@@ skipping 78 matching lines @@
 
     keyedValues.forEach((receiver, values) {
       result.keyedValues[receiver] =
           new Map<HInstruction, HInstruction>.from(values);
     });
 
     result.nonEscapingReceivers.addAll(nonEscapingReceivers);
     return result;
   }
 }