[vm] Cleanup Instruction::Dependencies(), EffectSet, BlockEffects

runtime/vm/intermediate_language.h

 // 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.
 
 #ifndef RUNTIME_VM_INTERMEDIATE_LANGUAGE_H_
 #define RUNTIME_VM_INTERMEDIATE_LANGUAGE_H_
 
 #include "vm/allocation.h"
 #include "vm/ast.h"
 #include "vm/flags.h"
@@ skipping 160 matching lines @@
  private:
   bool CanComputeIsInstanceOf(const AbstractType& type,
                               bool is_nullable,
                               bool* is_instance);
 
   bool is_nullable_;
   intptr_t cid_;
   const AbstractType* type_;
 };
 
-// TODO(dartbug.com/30474): remove EffectSet as there are no tracked effects
-// anymore.
-class EffectSet : public ValueObject {
- public:
-  enum Effects {
-    kNoEffects = 0,
-    kUnusedEffect = 1,  // Currently unused.
-    kLastEffect = kUnusedEffect
-  };
-
-  EffectSet(const EffectSet& other) : ValueObject(), effects_(other.effects_) {}
-
-  bool IsNone() const { return effects_ == kNoEffects; }
-
-  static EffectSet None() { return EffectSet(kNoEffects); }
-  static EffectSet All() {
-    ASSERT(EffectSet::kLastEffect == 1);
-    return EffectSet(kUnusedEffect);
-  }
-
-  bool ToInt() { return effects_; }
-
- private:
-  explicit EffectSet(intptr_t effects) : effects_(effects) {}
-
-  intptr_t effects_;
-};
-
 class Value : public ZoneAllocated {
  public:
   // A forward iterator that allows removing the current value from the
   // underlying use list during iteration.
   class Iterator {
    public:
     explicit Iterator(Value* head) : next_(head) { Advance(); }
     Value* Current() const { return current_; }
     bool Done() const { return current_ == NULL; }
     void Advance() {
@@ skipping 651 matching lines @@
   // instruction.
   Instruction* AppendInstruction(Instruction* tail);
 
   // Returns true if CSE and LICM are allowed for this instruction.
   virtual bool AllowsCSE() const { return false; }
 
   // Returns true if this instruction has any side-effects besides storing.
   // See StoreInstanceFieldInstr::HasUnknownSideEffects() for rationale.
   virtual bool HasUnknownSideEffects() const = 0;
 
-  // Returns set of effects that affect this instruction.
-  virtual EffectSet Dependencies() const {
-    UNREACHABLE();
-    return EffectSet::All();
-  }
-
   // Get the block entry for this instruction.
   virtual BlockEntryInstr* GetBlock();
 
   // Place identifiers used by the load optimization pass.
   intptr_t place_id() const { return place_id_; }
   void set_place_id(intptr_t place_id) { place_id_ = place_id; }
   bool HasPlaceId() const { return place_id_ != kNoPlaceId; }
 
   intptr_t inlining_id() const { return inlining_id_; }
   void set_inlining_id(intptr_t value) {
@@ skipping 83 matching lines @@
   Label* true_label;
   Label* false_label;
   Label* fall_through;
 };
 
 class PureInstruction : public Instruction {
  public:
   explicit PureInstruction(intptr_t deopt_id) : Instruction(deopt_id) {}
 
   virtual bool AllowsCSE() const { return true; }
-  virtual EffectSet Dependencies() const { return EffectSet::None(); }
-
   virtual bool HasUnknownSideEffects() const { return false; }
 };
 
 // Types to be used as ThrowsTrait for TemplateInstruction/TemplateDefinition.
 struct Throws {
   static const bool kCanThrow = true;
 };
 
 struct NoThrow {
   static const bool kCanThrow = false;
@@ skipping 98 matching lines @@
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual bool HasUnknownSideEffects() const {
     UNREACHABLE();  // This instruction never visited by optimization passes.
     return false;
   }
 
-  virtual EffectSet Dependencies() const {
-    UNREACHABLE();  // This instruction never visited by optimization passes.
-    return EffectSet::None();
-  }
-
   MoveOperands* AddMove(Location dest, Location src) {
     MoveOperands* move = new MoveOperands(dest, src);
     moves_.Add(move);
     return move;
   }
 
   MoveOperands* MoveOperandsAt(intptr_t index) const { return moves_[index]; }
 
   intptr_t NumMoves() const { return moves_.length(); }
 
@@ skipping 95 matching lines @@
 
   virtual bool CanBecomeDeoptimizationTarget() const {
     // BlockEntry environment is copied to Goto and Branch instructions
     // when we insert new blocks targeting this block.
     return true;
   }
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual bool HasUnknownSideEffects() const { return false; }
-  virtual EffectSet Dependencies() const { return EffectSet::None(); }
 
   virtual bool MayThrow() const { return false; }
 
   intptr_t try_index() const { return try_index_; }
   void set_try_index(intptr_t index) { try_index_ = index; }
 
   // True for blocks inside a try { } region.
   bool InsideTryBlock() const {
     return try_index_ != CatchClauseNode::kInvalidTryIndex;
   }
@@ skipping 225 matching lines @@
 
   ZoneGrowableArray<PhiInstr*>* phis() const { return phis_; }
 
   PhiInstr* InsertPhi(intptr_t var_index, intptr_t var_count);
   void RemoveDeadPhis(Definition* replacement);
 
   void InsertPhi(PhiInstr* phi);
   void RemovePhi(PhiInstr* phi);
 
   virtual bool HasUnknownSideEffects() const { return false; }
-  virtual EffectSet Dependencies() const { return EffectSet::None(); }
 
   PRINT_TO_SUPPORT
 
  private:
   // Classes that have access to predecessors_ when inlining.
   friend class BlockEntryInstr;
   friend class InlineExitCollector;
   friend class PolymorphicInliner;
   friend class IndirectEntryInstr;  // Access in il_printer.cc.
 
@@ skipping 391 matching lines @@
   RemoveFromUseList();
   set_definition(def);
   def->AddEnvUse(this);
 }
 
 class PureDefinition : public Definition {
  public:
   explicit PureDefinition(intptr_t deopt_id) : Definition(deopt_id) {}
 
   virtual bool AllowsCSE() const { return true; }
-  virtual EffectSet Dependencies() const { return EffectSet::None(); }
-
   virtual bool HasUnknownSideEffects() const { return false; }
 };
 
 template <intptr_t N,
           typename ThrowsTrait,
           template <typename Impure, typename Pure> class CSETrait = NoCSE>
 class TemplateDefinition : public CSETrait<Definition, PureDefinition>::Base {
  public:
   explicit TemplateDefinition(intptr_t deopt_id = Thread::kNoDeoptId)
       : CSETrait<Definition, PureDefinition>::Base(deopt_id), inputs_() {}
@@ skipping 131 matching lines @@
 
   intptr_t InputCount() const { return 0; }
   Value* InputAt(intptr_t i) const {
     UNREACHABLE();
     return NULL;
   }
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual bool HasUnknownSideEffects() const { return false; }
-  virtual EffectSet Dependencies() const { return EffectSet::None(); }
 
   virtual intptr_t Hashcode() const {
     UNREACHABLE();
     return 0;
   }
 
   virtual CompileType ComputeType() const;
 
   virtual bool MayThrow() const { return false; }
 
@@ skipping 124 matching lines @@
   const char* message() const { return message_; }
 
   DECLARE_INSTRUCTION(Stop);
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual bool HasUnknownSideEffects() const { return false; }
 
-  virtual EffectSet Dependencies() const { return EffectSet::None(); }
-
  private:
   const char* message_;
 
   DISALLOW_COPY_AND_ASSIGN(StopInstr);
 };
 
 class GotoInstr : public TemplateInstruction<0, NoThrow> {
  public:
   explicit GotoInstr(JoinEntryInstr* entry, intptr_t deopt_id)
       : TemplateInstruction(deopt_id),
@@ skipping 182 matching lines @@
   const TokenPosition token_pos_;
   Token::Kind kind_;
   intptr_t operation_cid_;  // Set by optimizer.
 
   DISALLOW_COPY_AND_ASSIGN(ComparisonInstr);
 };
 
 class PureComparison : public ComparisonInstr {
  public:
   virtual bool AllowsCSE() const { return true; }
-  virtual EffectSet Dependencies() const { return EffectSet::None(); }
-
   virtual bool HasUnknownSideEffects() const { return false; }
 
  protected:
   PureComparison(TokenPosition token_pos, Token::Kind kind, intptr_t deopt_id)
       : ComparisonInstr(token_pos, kind, deopt_id) {}
 };
 
 template <intptr_t N,
           typename ThrowsTrait,
           template <typename Impure, typename Pure> class CSETrait = NoCSE>
@@ skipping 130 matching lines @@
 
   virtual CompileType ComputeType() const;
   virtual bool RecomputeType();
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
   void set_constrained_type(CompileType* type) { constrained_type_ = type; }
   CompileType* constrained_type() const { return constrained_type_; }
 
   virtual bool ComputeCanDeoptimize() const { return false; }
-  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool HasUnknownSideEffects() const { return false; }
 
  private:
   CompileType* constrained_type_;
   DISALLOW_COPY_AND_ASSIGN(RedefinitionInstr);
 };
 
 class ConstraintInstr : public TemplateDefinition<1, NoThrow> {
  public:
   ConstraintInstr(Value* value, Range* constraint)
@@ skipping 178 matching lines @@
   enum SpecialParameterKind { kContext, kTypeArgs };
   SpecialParameterInstr(SpecialParameterKind kind, intptr_t deopt_id)
       : TemplateDefinition(deopt_id), kind_(kind) {}
 
   DECLARE_INSTRUCTION(SpecialParameter)
   virtual CompileType ComputeType() const;
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual bool HasUnknownSideEffects() const { return false; }
-  virtual EffectSet Dependencies() const { return EffectSet::None(); }
+
   virtual bool AttributesEqual(Instruction* other) const {
     return kind() == other->AsSpecialParameter()->kind();
   }
   SpecialParameterKind kind() const { return kind_; }
 
  private:
   const SpecialParameterKind kind_;
   DISALLOW_COPY_AND_ASSIGN(SpecialParameterInstr);
 };
 
@@ skipping 503 matching lines @@
   virtual void InferRange(RangeAnalysis* analysis, Range* range);
 
   ComparisonInstr* comparison() const { return comparison_; }
   intptr_t if_true() const { return if_true_; }
   intptr_t if_false() const { return if_false_; }
 
   virtual bool AllowsCSE() const { return comparison()->AllowsCSE(); }
   virtual bool HasUnknownSideEffects() const {
     return comparison()->HasUnknownSideEffects();
   }
-  virtual EffectSet Dependencies() const {
-    return comparison()->Dependencies();
-  }
+
   virtual bool AttributesEqual(Instruction* other) const {
     IfThenElseInstr* other_if_then_else = other->AsIfThenElse();
     return (comparison()->tag() == other_if_then_else->comparison()->tag()) &&
            comparison()->AttributesEqual(other_if_then_else->comparison()) &&
            (if_true_ == other_if_then_else->if_true_) &&
            (if_false_ == other_if_then_else->if_false_);
   }
 
   virtual bool MayThrow() const { return comparison()->MayThrow(); }
 
@@ skipping 497 matching lines @@
   const Field& StaticField() const;
 
   Value* field_value() const { return inputs_[0]; }
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual bool AllowsCSE() const {
     return StaticField().is_final() && !FLAG_fields_may_be_reset;
   }
   virtual bool HasUnknownSideEffects() const { return false; }
-  virtual EffectSet Dependencies() const;
+
   virtual bool AttributesEqual(Instruction* other) const;
 
   virtual TokenPosition token_pos() const { return token_pos_; }
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   const TokenPosition token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadStaticFieldInstr);
@@ skipping 714 matching lines @@
   bool Evaluate(const Object& instance_value, Object* result);
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
   static MethodRecognizer::Kind RecognizedKindFromArrayCid(intptr_t cid);
 
   static bool IsFixedLengthArrayCid(intptr_t cid);
 
   virtual bool AllowsCSE() const { return immutable_; }
   virtual bool HasUnknownSideEffects() const { return false; }
-  virtual EffectSet Dependencies() const;
+
   virtual bool AttributesEqual(Instruction* other) const;
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   const intptr_t offset_in_bytes_;
   const AbstractType& type_;
   intptr_t result_cid_;
   bool immutable_;
 
@@ skipping 3083 matching lines @@
   bool IsNullCheck() const { return IsDeoptIfNull() || IsDeoptIfNotNull(); }
 
   bool IsDeoptIfNull() const;
   bool IsDeoptIfNotNull() const;
 
   bool IsBitTest() const;
   static bool IsCompactCidRange(const Cids& cids);
   intptr_t ComputeCidMask() const;
 
   virtual bool AllowsCSE() const { return true; }
-  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool HasUnknownSideEffects() const { return false; }
+
   virtual bool AttributesEqual(Instruction* other) const;
 
   bool licm_hoisted() const { return licm_hoisted_; }
   void set_licm_hoisted(bool value) { licm_hoisted_ = value; }
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   const Cids& cids_;
   bool licm_hoisted_;
@@ skipping 58 matching lines @@
   Value* value() const { return inputs_[0]; }
   const CidRange& cids() const { return cids_; }
 
   DECLARE_INSTRUCTION(CheckClassId)
 
   virtual bool ComputeCanDeoptimize() const { return true; }
 
   virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
   virtual bool AllowsCSE() const { return true; }
-  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool HasUnknownSideEffects() const { return false; }
+
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   bool Contains(intptr_t cid) const;
 
   CidRange cids_;
 
   DISALLOW_COPY_AND_ASSIGN(CheckClassIdInstr);
@@ skipping 46 matching lines @@
   GenericCheckBoundInstr(Value* length, Value* index, intptr_t deopt_id)
       : TemplateInstruction(deopt_id) {
     SetInputAt(kLengthPos, length);
     SetInputAt(kIndexPos, index);
   }
 
   Value* length() const { return inputs_[kLengthPos]; }
   Value* index() const { return inputs_[kIndexPos]; }
 
   virtual bool HasUnknownSideEffects() const { return false; }
-  virtual EffectSet Dependencies() const { return EffectSet::None(); }
 
   DECLARE_INSTRUCTION(GenericCheckBound)
 
   virtual bool ComputeCanDeoptimize() const { return true; }
 
   // Give a name to the location/input indices.
   enum { kLengthPos = 0, kIndexPos = 1 };
 
  private:
   DISALLOW_COPY_AND_ASSIGN(GenericCheckBoundInstr);
@@ skipping 30 matching lines @@
   virtual bool ComputeCanDeoptimize() const;
 
   virtual Representation representation() const { return to(); }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return from();
   }
 
   virtual bool HasUnknownSideEffects() const { return false; }
-  virtual EffectSet Dependencies() const { return EffectSet::None(); }
+
   virtual bool AttributesEqual(Instruction* other) const {
     ASSERT(other->IsUnboxedIntConverter());
     UnboxedIntConverterInstr* converter = other->AsUnboxedIntConverter();
     return (converter->from() == from()) && (converter->to() == to()) &&
            (converter->is_truncating() == is_truncating());
   }
 
   virtual void InferRange(RangeAnalysis* analysis, Range* range);
 
   virtual CompileType ComputeType() const {
@@ skipping 270 matching lines @@
 #define DEFINE_UNIMPLEMENTED_INSTRUCTION(Name)                                 \
   LocationSummary* Name::MakeLocationSummary(Zone* zone, bool opt) const {     \
     UNIMPLEMENTED();                                                           \
     return NULL;                                                               \
   }                                                                            \
   void Name::EmitNativeCode(FlowGraphCompiler* compiler) { UNIMPLEMENTED(); }
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_INTERMEDIATE_LANGUAGE_H_