Merge CommonElements and BackendHelpers!

pkg/compiler/lib/src/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.
 
 import '../common/codegen.dart' show CodegenRegistry, CodegenWorkItem;
 import '../common/names.dart' show Selectors;
 import '../common/tasks.dart' show CompilerTask;
 import '../compiler.dart' show Compiler;
 import '../constants/constant_system.dart';
 import '../constants/values.dart';
 import '../common_elements.dart' show CommonElements;
 import '../elements/elements.dart'
     show ClassElement, FieldElement, MethodElement;
 import '../elements/entities.dart';
 import '../elements/resolution_types.dart';
 import '../js/js.dart' as js;
-import '../js_backend/backend_helpers.dart' show BackendHelpers;
 import '../js_backend/js_backend.dart';
 import '../js_backend/interceptor_data.dart' show InterceptorData;
 import '../js_backend/native_data.dart' show NativeData;
 import '../native/native.dart' as native;
 import '../options.dart';
 import '../tree/dartstring.dart' as ast;
 import '../types/types.dart';
 import '../universe/selector.dart' show Selector;
 import '../universe/side_effects.dart' show SideEffects;
 import '../util/util.dart';
@@ skipping 16 matching lines @@
   Map<HInstruction, Range> ranges = <HInstruction, Range>{};
 
   SsaOptimizerTask(this._backend) : super(_backend.compiler.measurer);
 
   String get name => 'SSA optimizer';
 
   Compiler get _compiler => _backend.compiler;
 
   GlobalTypeInferenceResults get _results => _compiler.globalInference.results;
 
-  BackendHelpers get _helpers => _backend.helpers;
-
   CompilerOptions get _options => _compiler.options;
 
   RuntimeTypesSubstitutions get _rtiSubstitutions => _backend.rtiSubstitutions;
 
   InterceptorData get _interceptorData => _backend.interceptorData;
 
   void optimize(CodegenWorkItem work, HGraph graph, ClosedWorld closedWorld) {
     void runPhase(OptimizationPhase phase) {
       measureSubtask(phase.name, () => phase.visitGraph(graph));
       _backend.tracer.traceGraph(phase.name, graph);
       assert(graph.isValid(), 'Graph not valid after ${phase.name}');
     }
 
     bool trustPrimitives = _options.trustPrimitives;
     CodegenRegistry registry = work.registry;
     Set<HInstruction> boundsChecked = new Set<HInstruction>();
     SsaCodeMotion codeMotion;
     SsaLoadElimination loadElimination;
     measure(() {
       List<OptimizationPhase> phases = <OptimizationPhase>[
         // Run trivial instruction simplification first to optimize
         // some patterns useful for type conversion.
-        new SsaInstructionSimplifier(_results, _options, _helpers,
-            _rtiSubstitutions, closedWorld, registry),
+        new SsaInstructionSimplifier(
+            _results, _options, _rtiSubstitutions, closedWorld, registry),
         new SsaTypeConversionInserter(closedWorld),
         new SsaRedundantPhiEliminator(),
         new SsaDeadPhiEliminator(),
-        new SsaTypePropagator(_results, _options, _helpers, closedWorld),
+        new SsaTypePropagator(
+            _results, _options, closedWorld.commonElements, closedWorld),
         // After type propagation, more instructions can be
         // simplified.
-        new SsaInstructionSimplifier(_results, _options, _helpers,
-            _rtiSubstitutions, closedWorld, registry),
-        new SsaCheckInserter(
-            trustPrimitives, _helpers, closedWorld, boundsChecked),
-        new SsaInstructionSimplifier(_results, _options, _helpers,
-            _rtiSubstitutions, closedWorld, registry),
-        new SsaCheckInserter(
-            trustPrimitives, _helpers, closedWorld, boundsChecked),
-        new SsaTypePropagator(_results, _options, _helpers, closedWorld),
+        new SsaInstructionSimplifier(
+            _results, _options, _rtiSubstitutions, closedWorld, registry),
+        new SsaCheckInserter(trustPrimitives, closedWorld, boundsChecked),
+        new SsaInstructionSimplifier(
+            _results, _options, _rtiSubstitutions, closedWorld, registry),
+        new SsaCheckInserter(trustPrimitives, closedWorld, boundsChecked),
+        new SsaTypePropagator(
+            _results, _options, closedWorld.commonElements, closedWorld),
         // Run a dead code eliminator before LICM because dead
         // interceptors are often in the way of LICM'able instructions.
         new SsaDeadCodeEliminator(closedWorld, this),
         new SsaGlobalValueNumberer(),
         // After GVN, some instructions might need their type to be
         // updated because they now have different inputs.
-        new SsaTypePropagator(_results, _options, _helpers, closedWorld),
+        new SsaTypePropagator(
+            _results, _options, closedWorld.commonElements, closedWorld),
         codeMotion = new SsaCodeMotion(),
-        loadElimination =
-            new SsaLoadElimination(_helpers, _compiler, closedWorld),
+        loadElimination = new SsaLoadElimination(_compiler, closedWorld),
         new SsaRedundantPhiEliminator(),
         new SsaDeadPhiEliminator(),
         // After GVN and load elimination the same value may be used in code
         // controlled by a test on the value, so redo 'conversion insertion' to
         // learn from the refined type.
         new SsaTypeConversionInserter(closedWorld),
-        new SsaTypePropagator(_results, _options, _helpers, closedWorld),
-        new SsaValueRangeAnalyzer(_helpers, closedWorld, this),
+        new SsaTypePropagator(
+            _results, _options, closedWorld.commonElements, closedWorld),
+        new SsaValueRangeAnalyzer(closedWorld, this),
         // Previous optimizations may have generated new
         // opportunities for instruction simplification.
-        new SsaInstructionSimplifier(_results, _options, _helpers,
-            _rtiSubstitutions, closedWorld, registry),
-        new SsaCheckInserter(
-            trustPrimitives, _helpers, closedWorld, boundsChecked),
+        new SsaInstructionSimplifier(
+            _results, _options, _rtiSubstitutions, closedWorld, registry),
+        new SsaCheckInserter(trustPrimitives, closedWorld, boundsChecked),
       ];
       phases.forEach(runPhase);
 
       // Simplifying interceptors is not strictly just an optimization, it is
       // required for implementation correctness because the code generator
       // assumes it is always performed.
-      runPhase(new SsaSimplifyInterceptors(closedWorld, _helpers,
-          _interceptorData, work.element.enclosingClass));
+      runPhase(new SsaSimplifyInterceptors(
+          closedWorld,
+          closedWorld.commonElements,
+          _interceptorData,
+          work.element.enclosingClass));
 
       SsaDeadCodeEliminator dce = new SsaDeadCodeEliminator(closedWorld, this);
       runPhase(dce);
       if (codeMotion.movedCode ||
           dce.eliminatedSideEffects ||
           loadElimination.newGvnCandidates) {
         phases = <OptimizationPhase>[
-          new SsaTypePropagator(_results, _options, _helpers, closedWorld),
+          new SsaTypePropagator(
+              _results, _options, closedWorld.commonElements, closedWorld),
           new SsaGlobalValueNumberer(),
           new SsaCodeMotion(),
-          new SsaValueRangeAnalyzer(_helpers, closedWorld, this),
-          new SsaInstructionSimplifier(_results, _options, _helpers,
-              _rtiSubstitutions, closedWorld, registry),
-          new SsaCheckInserter(
-              trustPrimitives, _helpers, closedWorld, boundsChecked),
-          new SsaSimplifyInterceptors(closedWorld, _helpers, _interceptorData,
-              work.element.enclosingClass),
+          new SsaValueRangeAnalyzer(closedWorld, this),
+          new SsaInstructionSimplifier(
+              _results, _options, _rtiSubstitutions, closedWorld, registry),
+          new SsaCheckInserter(trustPrimitives, closedWorld, boundsChecked),
+          new SsaSimplifyInterceptors(closedWorld, closedWorld.commonElements,
+              _interceptorData, work.element.enclosingClass),
           new SsaDeadCodeEliminator(closedWorld, this),
         ];
       } else {
         phases = <OptimizationPhase>[
-          new SsaTypePropagator(_results, _options, _helpers, closedWorld),
+          new SsaTypePropagator(
+              _results, _options, closedWorld.commonElements, closedWorld),
           // Run the simplifier to remove unneeded type checks inserted by
           // type propagation.
-          new SsaInstructionSimplifier(_results, _options, _helpers,
-              _rtiSubstitutions, closedWorld, registry),
+          new SsaInstructionSimplifier(
+              _results, _options, _rtiSubstitutions, closedWorld, registry),
         ];
       }
       phases.forEach(runPhase);
     });
   }
 }
 
 /// Returns `true` if [mask] represents only types that have a length that
 /// cannot change.  The current implementation is conservative for the purpose
 /// of identifying gvn-able lengths and mis-identifies some unions of fixed
@@ skipping 20 matching lines @@
 class SsaInstructionSimplifier extends HBaseVisitor
     implements OptimizationPhase {
   // We don't produce constant-folded strings longer than this unless they have
   // a single use.  This protects against exponentially large constant folded
   // strings.
   static const MAX_SHARED_CONSTANT_FOLDED_STRING_LENGTH = 512;
 
   final String name = "SsaInstructionSimplifier";
   final GlobalTypeInferenceResults _globalInferenceResults;
   final CompilerOptions _options;
-  final BackendHelpers _helpers;
   final RuntimeTypesSubstitutions _rtiSubstitutions;
   final ClosedWorld _closedWorld;
   final CodegenRegistry _registry;
   HGraph _graph;
 
   SsaInstructionSimplifier(this._globalInferenceResults, this._options,
-      this._helpers, this._rtiSubstitutions, this._closedWorld, this._registry);
+      this._rtiSubstitutions, this._closedWorld, this._registry);
 
   CommonElements get commonElements => _closedWorld.commonElements;
 
   ConstantSystem get constantSystem => _closedWorld.constantSystem;
 
   NativeData get _nativeData => _closedWorld.nativeData;
 
   void visitGraph(HGraph visitee) {
     _graph = visitee;
     visitDominatorTree(visitee);
@@ skipping 103 matching lines @@
     if (input.isBoolean(_closedWorld)) return input;
 
     // If the code is unreachable, remove the HBoolify.  This can happen when
     // there is a throw expression in a short-circuit conditional.  Removing the
     // unreachable HBoolify makes it easier to reconstruct the short-circuit
     // operation.
     if (input.instructionType.isEmpty) return input;
 
     // All values that cannot be 'true' are boolified to false.
     TypeMask mask = input.instructionType;
-    if (!mask.contains(_helpers.jsBoolClass, _closedWorld)) {
+    if (!mask.contains(commonElements.jsBoolClass, _closedWorld)) {
       return _graph.addConstantBool(false, _closedWorld);
     }
     return node;
   }
 
   HInstruction visitNot(HNot node) {
     List<HInstruction> inputs = node.inputs;
     assert(inputs.length == 1);
     HInstruction input = inputs[0];
     if (input is HConstant) {
@@ skipping 32 matching lines @@
         HConstant constantInput = actualReceiver;
         ListConstantValue constant = constantInput.constant;
         return _graph.addConstantInt(constant.length, _closedWorld);
       }
       bool isFixed =
           isFixedLength(actualReceiver.instructionType, _closedWorld);
       TypeMask actualType = node.instructionType;
       TypeMask resultType = _closedWorld.commonMasks.positiveIntType;
       // If we already have computed a more specific type, keep that type.
       if (HInstruction.isInstanceOf(
-          actualType, _helpers.jsUInt31Class, _closedWorld)) {
+          actualType, commonElements.jsUInt31Class, _closedWorld)) {
         resultType = _closedWorld.commonMasks.uint31Type;
       } else if (HInstruction.isInstanceOf(
-          actualType, _helpers.jsUInt32Class, _closedWorld)) {
+          actualType, commonElements.jsUInt32Class, _closedWorld)) {
         resultType = _closedWorld.commonMasks.uint32Type;
       }
       HGetLength result =
           new HGetLength(actualReceiver, resultType, isAssignable: !isFixed);
       return result;
     } else if (actualReceiver.isConstantMap()) {
       HConstant constantInput = actualReceiver;
       MapConstantValue constant = constantInput.constant;
       return _graph.addConstantInt(constant.length, _closedWorld);
     }
     return null;
   }
 
   HInstruction handleInterceptedCall(HInvokeDynamic node) {
     // Try constant folding the instruction.
     Operation operation = node.specializer.operation(constantSystem);
     if (operation != null) {
       HInstruction instruction = node.inputs.length == 2
           ? foldUnary(operation, node.inputs[1])
           : foldBinary(operation, node.inputs[1], node.inputs[2]);
       if (instruction != null) return instruction;
     }
 
     // Try converting the instruction to a builtin instruction.
-    HInstruction instruction = node.specializer.tryConvertToBuiltin(node,
-        _graph, _globalInferenceResults, _options, _helpers, _closedWorld);
+    HInstruction instruction = node.specializer.tryConvertToBuiltin(
+        node,
+        _graph,
+        _globalInferenceResults,
+        _options,
+        commonElements,
+        _closedWorld);
     if (instruction != null) return instruction;
 
     Selector selector = node.selector;
     TypeMask mask = node.mask;
     HInstruction input = node.inputs[1];
 
     bool applies(MemberEntity element) {
       return selector.applies(element) &&
           (mask == null || mask.canHit(element, selector, _closedWorld));
     }
 
     if (selector.isCall || selector.isOperator) {
       FunctionEntity target;
       if (input.isExtendableArray(_closedWorld)) {
-        if (applies(_helpers.jsArrayRemoveLast)) {
-          target = _helpers.jsArrayRemoveLast;
-        } else if (applies(_helpers.jsArrayAdd)) {
+        if (applies(commonElements.jsArrayRemoveLast)) {
+          target = commonElements.jsArrayRemoveLast;
+        } else if (applies(commonElements.jsArrayAdd)) {
           // The codegen special cases array calls, but does not
           // inline argument type checks.
           if (!_options.enableTypeAssertions) {
-            target = _helpers.jsArrayAdd;
+            target = commonElements.jsArrayAdd;
           }
         }
       } else if (input.isStringOrNull(_closedWorld)) {
-        if (applies(_helpers.jsStringSplit)) {
+        if (applies(commonElements.jsStringSplit)) {
           HInstruction argument = node.inputs[2];
           if (argument.isString(_closedWorld)) {
-            target = _helpers.jsStringSplit;
+            target = commonElements.jsStringSplit;
           }
-        } else if (applies(_helpers.jsStringOperatorAdd)) {
+        } else if (applies(commonElements.jsStringOperatorAdd)) {
           // `operator+` is turned into a JavaScript '+' so we need to
           // make sure the receiver and the argument are not null.
           // TODO(sra): Do this via [node.specializer].
           HInstruction argument = node.inputs[2];
           if (argument.isString(_closedWorld) && !input.canBeNull()) {
             return new HStringConcat(input, argument, node.instructionType);
           }
-        } else if (applies(_helpers.jsStringToString) && !input.canBeNull()) {
+        } else if (applies(commonElements.jsStringToString) &&
+            !input.canBeNull()) {
           return input;
         }
       }
       if (target != null) {
         // TODO(ngeoffray): There is a strong dependency between codegen
         // and this optimization that the dynamic invoke does not need an
         // interceptor. We currently need to keep a
         // HInvokeDynamicMethod and not create a HForeign because
         // HForeign is too opaque for the SsaCheckInserter (that adds a
         // bounds check on removeLast). Once we start inlining, the
         // bounds check will become explicit, so we won't need this
         // optimization.
         HInvokeDynamicMethod result = new HInvokeDynamicMethod(node.selector,
             node.mask, node.inputs.sublist(1), node.instructionType);
         result.element = target;
         return result;
       }
     } else if (selector.isGetter) {
-      if (selector.applies(_helpers.jsIndexableLength)) {
+      if (selector.applies(commonElements.jsIndexableLength)) {
         HInstruction optimized = tryOptimizeLengthInterceptedGetter(node);
         if (optimized != null) return optimized;
       }
     }
 
     return node;
   }
 
   HInstruction visitInvokeDynamicMethod(HInvokeDynamicMethod node) {
     propagateConstantValueToUses(node);
@@ skipping 587 matching lines @@
   HInstruction visitInvokeStatic(HInvokeStatic node) {
     propagateConstantValueToUses(node);
     MemberEntity element = node.element;
 
     if (element == commonElements.identicalFunction) {
       if (node.inputs.length == 2) {
         return new HIdentity(node.inputs[0], node.inputs[1], null,
             _closedWorld.commonMasks.boolType)
           ..sourceInformation = node.sourceInformation;
       }
-    } else if (element == _helpers.checkConcurrentModificationError) {
+    } else if (element == commonElements.checkConcurrentModificationError) {
       if (node.inputs.length == 2) {
         HInstruction firstArgument = node.inputs[0];
         if (firstArgument is HConstant) {
           HConstant constant = firstArgument;
           if (constant.constant.isTrue) return constant;
         }
       }
-    } else if (element == _helpers.checkInt) {
+    } else if (element == commonElements.checkInt) {
       if (node.inputs.length == 1) {
         HInstruction argument = node.inputs[0];
         if (argument.isInteger(_closedWorld)) return argument;
       }
-    } else if (element == _helpers.checkNum) {
+    } else if (element == commonElements.checkNum) {
       if (node.inputs.length == 1) {
         HInstruction argument = node.inputs[0];
         if (argument.isNumber(_closedWorld)) return argument;
       }
-    } else if (element == _helpers.checkString) {
+    } else if (element == commonElements.checkString) {
       if (node.inputs.length == 1) {
         HInstruction argument = node.inputs[0];
         if (argument.isString(_closedWorld)) return argument;
       }
     }
     return node;
   }
 
   HInstruction visitStringConcat(HStringConcat node) {
     // Simplify string concat:
@@ skipping 71 matching lines @@
       // (since SsaInstructionSimplifier runs after SsaSimplifyInterceptors).
       if (input.canBePrimitive(_closedWorld)) return null;
       if (input.canBeNull()) return null;
       Selector selector = Selectors.toString_;
       TypeMask toStringType = TypeMaskFactory.inferredTypeForSelector(
           selector, input.instructionType, _globalInferenceResults);
       if (!toStringType.containsOnlyString(_closedWorld)) return null;
       // All intercepted classes extend `Interceptor`, so if the receiver can't
       // be a class extending `Interceptor` then it can be called directly.
       if (new TypeMask.nonNullSubclass(
-              _helpers.jsInterceptorClass, _closedWorld)
+              commonElements.jsInterceptorClass, _closedWorld)
           .isDisjoint(input.instructionType, _closedWorld)) {
         var inputs = <HInstruction>[input, input]; // [interceptor, receiver].
         HInstruction result = new HInvokeDynamicMethod(
             selector,
             input.instructionType, // receiver mask.
             inputs,
             toStringType)
           ..sourceInformation = node.sourceInformation;
         return result;
       }
@@ skipping 172 matching lines @@
     // arguments. The [selectTypeArgumentFromObjectCreation] argument of
     // [finishSubstituted] indexes into these type arguments.
 
     return node;
   }
 }
 
 class SsaCheckInserter extends HBaseVisitor implements OptimizationPhase {
   final Set<HInstruction> boundsChecked;
   final bool trustPrimitives;
-  final BackendHelpers _helpers;
   final ClosedWorld closedWorld;
   final String name = "SsaCheckInserter";
   HGraph graph;
 
-  SsaCheckInserter(this.trustPrimitives, this._helpers, this.closedWorld,
-      this.boundsChecked);
+  SsaCheckInserter(this.trustPrimitives, this.closedWorld, this.boundsChecked);
 
   void visitGraph(HGraph graph) {
     this.graph = graph;
 
     // In --trust-primitives mode we don't add bounds checks.  This is better
     // than trying to remove them later as the limit expression would become
     // dead and require DCE.
     if (trustPrimitives) return;
 
     visitDominatorTree(graph);
@@ skipping 42 matching lines @@
 
   void visitIndexAssign(HIndexAssign node) {
     if (boundsChecked.contains(node)) return;
     HInstruction index = node.index;
     index = insertBoundsCheck(node, node.receiver, index);
   }
 
   void visitInvokeDynamicMethod(HInvokeDynamicMethod node) {
     MemberEntity element = node.element;
     if (node.isInterceptedCall) return;
-    if (element != _helpers.jsArrayRemoveLast) return;
+    if (element != closedWorld.commonElements.jsArrayRemoveLast) return;
     if (boundsChecked.contains(node)) return;
     // `0` is the index we want to check, but we want to report `-1`, as if we
     // executed `a[a.length-1]`
     HBoundsCheck check = insertBoundsCheck(
         node, node.receiver, graph.addConstantInt(0, closedWorld));
     HInstruction minusOne = graph.addConstantInt(-1, closedWorld);
     check.inputs.add(minusOne);
     minusOne.usedBy.add(check);
   }
 }
@@ skipping 839 matching lines @@
     }
   }
 }
 
 /**
  * Optimization phase that tries to eliminate memory loads (for
  * example [HFieldGet]), when it knows the value stored in that memory
  * location.
  */
 class SsaLoadElimination extends HBaseVisitor implements OptimizationPhase {
-  final BackendHelpers _helpers;
   final Compiler compiler;
   final ClosedWorld closedWorld;
   final String name = "SsaLoadElimination";
   MemorySet memorySet;
   List<MemorySet> memories;
   bool newGvnCandidates = false;
 
-  SsaLoadElimination(this._helpers, this.compiler, this.closedWorld);
+  SsaLoadElimination(this.compiler, this.closedWorld);
 
   void visitGraph(HGraph graph) {
     memories = new List<MemorySet>(graph.blocks.length);
     List<HBasicBlock> blocks = graph.blocks;
     for (int i = 0; i < blocks.length; i++) {
       HBasicBlock block = blocks[i];
       visitBasicBlock(block);
       if (block.successors.isNotEmpty && block.successors[0].isLoopHeader()) {
         // We've reached the ending block of a loop. Iterate over the
         // blocks of the loop again to take values that flow from that
@@ skipping 48 matching lines @@
   }
 
   void visitFieldGet(HFieldGet instruction) {
     if (instruction.isNullCheck) return;
     FieldEntity element = instruction.element;
     HInstruction receiver = instruction.getDartReceiver(closedWorld).nonCheck();
     _visitFieldGet(element, receiver, instruction);
   }
 
   void visitGetLength(HGetLength instruction) {
-    _visitFieldGet(_helpers.jsIndexableLength, instruction.receiver.nonCheck(),
-        instruction);
+    _visitFieldGet(closedWorld.commonElements.jsIndexableLength,
+        instruction.receiver.nonCheck(), instruction);
   }
 
   void _visitFieldGet(
       MemberEntity element, HInstruction receiver, HInstruction instruction) {
     HInstruction existing = memorySet.lookupFieldValue(element, receiver);
     if (existing != null) {
       checkNewGvnCandidates(instruction, existing);
       instruction.block.rewriteWithBetterUser(instruction, existing);
       instruction.block.remove(instruction);
     } else {
@@ skipping 466 matching lines @@
 
     keyedValues.forEach((receiver, values) {
       result.keyedValues[receiver] =
           new Map<HInstruction, HInstruction>.from(values);
     });
 
     result.nonEscapingReceivers.addAll(nonEscapingReceivers);
     return result;
   }
 }