pkg/compiler/lib/src/cps_ir/effects.dart

// Copyright (c) 2016, 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.
library dart2js.cps_ir.effects;

import 'dart:typed_data';
import '../universe/side_effects.dart' show SideEffects;

/// Bitmasks for tracking non-local side effects and dependencies.
///
/// All effects must be attributed to an effect area.  The `other` area is a
/// catch-all for any effect that does not belong to any of the specific areas;
/// this includes external effects such as printing to the console.
class Effects {
  // Effect areas.
  // These are bit positions, not bit masks. They are private because it is
  // otherwise easy to mistake them for bitmasks.
  static const int _staticField = 0;
  static const int _instanceField = 1;
  static const int _indexableContent = 2;
  static const int _indexableLength = 3;
  static const int _other = 4;
  static const int numberOfEffectAreas = 5;

  // Bitmasks for computation that modifies state in a given area.
  static const int _changes = 1;
  static const int changesStaticField = _changes << _staticField;
  static const int changesInstanceField = _changes << _instanceField;
  static const int changesIndexableContent = _changes << _indexableContent;
  static const int changesIndexableLength = _changes << _indexableLength;
  static const int changesOther = _changes << _other;

  static const int changesAll = changesStaticField |
      changesInstanceField |
      changesIndexableContent |
      changesIndexableLength |
      changesOther;

  // Bitmasks for computation that depends on state in a given area.
  static const int _depends = 1 << numberOfEffectAreas;
  static const int dependsOnStaticField = _depends << _staticField;
  static const int dependsOnInstanceField = _depends << _instanceField;
  static const int dependsOnIndexableContent = _depends << _indexableContent;
  static const int dependsOnIndexableLength = _depends << _indexableLength;
  static const int dependsOnOther = _depends << _other;

  static const int dependsOnAll = dependsOnStaticField |
      dependsOnInstanceField |
      dependsOnIndexableContent |
      dependsOnIndexableLength |
      dependsOnOther;

  static const int all = changesAll | dependsOnAll;
  static const int none = 0;

  static int _changesArea(int effectArea) => _changes << effectArea;

  static int _dependsOnArea(int effectArea) => _depends << effectArea;

  static int changesToDepends(int changesFlags) {
    return (changesFlags & changesAll) << numberOfEffectAreas;
  }

  static int dependsToChanges(int dependsFlags) {
    return (dependsFlags & dependsOnAll) >> numberOfEffectAreas;
  }

  /// Converts [SideEffects] from a JS annotation or type inference to the
  /// more fine-grained flag set.
  //
  // TODO(asgerf): Once we finalize the set of flags to use, unify the two
  //               systems.
  static int from(SideEffects fx) {
    int result = 0;
    if (fx.changesInstanceProperty()) {
      result |= changesInstanceField;
    }
    if (fx.changesStaticProperty()) {
      result |= changesStaticField;
    }
    if (fx.changesIndex()) {
      result |= changesIndexableContent | changesIndexableLength;
    }
    if (fx.hasSideEffects()) {
      result |= changesOther;
    }
    if (fx.dependsOnInstancePropertyStore()) {
      result |= dependsOnInstanceField;
    }
    if (fx.dependsOnStaticPropertyStore()) {
      result |= dependsOnStaticField;
    }
    if (fx.dependsOnIndexStore()) {
      result |= dependsOnIndexableContent | dependsOnIndexableLength;
    }
    if (fx.dependsOnSomething()) {
      result |= dependsOnOther;
    }
    return result;
  }
}

/// Creates fresh IDs to ensure effect numbers do not clash with each other.
class EffectNumberer {
  int _id = 0;
  int next() => ++_id;

  /// Special effect number that can be used in place for an effect area that
  /// is irrelevant for a computation.
  ///
  /// This value is never returned by [next].
  static const int none = 0;
}

/// A mutable vector of effect numbers, one for each effect area.
///
/// Effect numbers are used to identify regions of code wherein the given
/// effect area is unmodified.
class EffectNumbers {
  final Int32List _effectNumbers = new Int32List(Effects.numberOfEffectAreas);

  EffectNumbers._zero();

  EffectNumbers.fresh(EffectNumberer numberer) {
    reset(numberer);
  }

  EffectNumbers copy() {
    return new EffectNumbers._zero().._effectNumbers.setAll(0, _effectNumbers);
  }

  int operator [](int i) => _effectNumbers[i];

  void operator []=(int i, int value) {
    _effectNumbers[i] = value;
  }

  int get staticField => _effectNumbers[Effects._staticField];
  int get instanceField => _effectNumbers[Effects._instanceField];
  int get indexableContent => _effectNumbers[Effects._indexableContent];
  int get indexableLength => _effectNumbers[Effects._indexableLength];
  int get other => _effectNumbers[Effects._other];

  void set staticField(int n) {
    _effectNumbers[Effects._staticField] = n;
  }

  void set instanceField(int n) {
    _effectNumbers[Effects._instanceField] = n;
  }

  void set indexableContent(int n) {
    _effectNumbers[Effects._indexableContent] = n;
  }

  void set indexableLength(int n) {
    _effectNumbers[Effects._indexableLength] = n;
  }

  void set other(int n) {
    _effectNumbers[Effects._other] = n;
  }

  void reset(EffectNumberer numberer) {
    for (int i = 0; i < Effects.numberOfEffectAreas; ++i) {
      _effectNumbers[i] = numberer.next();
    }
  }

  void join(EffectNumberer numberer, EffectNumbers other) {
    for (int i = 0; i < Effects.numberOfEffectAreas; ++i) {
      if (_effectNumbers[i] != other._effectNumbers[i]) {
        _effectNumbers[i] = numberer.next();
      }
    }
  }

  void change(EffectNumberer numberer, int changeFlags) {
    for (int i = 0; i < Effects.numberOfEffectAreas; ++i) {
      if (changeFlags & Effects._changesArea(i) != 0) {
        _effectNumbers[i] = numberer.next();
      }
    }
  }

  /// Builds a vector where all entries that are not depended on are replaced
  /// by [EffectNumberer.none].
  //
  // TODO(asgerf): Use this in GVN to simplify the dispatching code.
  List<int> getDependencies(int dependsFlags) {
    Int32List copy = new Int32List.fromList(_effectNumbers);
    for (int i = 0; i < Effects.numberOfEffectAreas; ++i) {
      if (dependsFlags & Effects._dependsOnArea(i) == 0) {
        copy[i] = EffectNumberer.none;
      }
    }
    return copy;
  }
}