Implement class id checks as a separate instruction and add a local CSE optimization pass.

runtime/vm/intermediate_language.h

 // 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.
 
 #ifndef VM_INTERMEDIATE_LANGUAGE_H_
 #define VM_INTERMEDIATE_LANGUAGE_H_
 
 #include "vm/allocation.h"
 #include "vm/ast.h"
 #include "vm/growable_array.h"
@@ skipping 83 matching lines @@
   M(AllocateContext, AllocateContextComp)                                      \
   M(ChainContext, ChainContextComp)                                            \
   M(CloneContext, CloneContextComp)                                            \
   M(CatchEntry, CatchEntryComp)                                                \
   M(BinaryOp, BinaryOpComp)                                                    \
   M(DoubleBinaryOp, DoubleBinaryOpComp)                                        \
   M(UnarySmiOp, UnarySmiOpComp)                                                \
   M(NumberNegate, NumberNegateComp)                                            \
   M(CheckStackOverflow, CheckStackOverflowComp)                                \
   M(DoubleToDouble, DoubleToDoubleComp)                                        \
-  M(SmiToDouble, SmiToDoubleComp)
+  M(SmiToDouble, SmiToDoubleComp)                                              \
+  M(CheckClass, CheckClassComp)
 
 
 #define FORWARD_DECLARATION(ShortName, ClassName) class ClassName;
 FOR_EACH_COMPUTATION(FORWARD_DECLARATION)
 #undef FORWARD_DECLARATION
 
 // Forward declarations.
 class BindInstr;
 class BranchInstr;
 class BufferFormatter;
 class ComparisonComp;
 class Definition;
 class Instruction;
 class PushArgumentInstr;
 class Value;
 
 class Computation : public ZoneAllocated {
  public:
   Computation() : deopt_id_(Isolate::kNoDeoptId), ic_data_(NULL), locs_(NULL) {
     Isolate* isolate = Isolate::Current();
     deopt_id_ = isolate->GetNextDeoptId();
     ic_data_ = isolate->GetICDataForDeoptId(deopt_id_);
   }
 
   // Unique id used for deoptimization.
   intptr_t deopt_id() const { return deopt_id_; }
 
-  ICData* ic_data() const { return ic_data_; }
-  void set_ic_data(ICData* value) { ic_data_ = value; }
+  const ICData* ic_data() const { return ic_data_; }
+  void set_ic_data(const ICData* value) { ic_data_ = value; }
   bool HasICData() const {
     return (ic_data() != NULL) && !ic_data()->IsNull();
   }
 
   // Visiting support.
   virtual void Accept(FlowGraphVisitor* visitor, BindInstr* instr) = 0;
 
   virtual intptr_t InputCount() const = 0;
   virtual Value* InputAt(intptr_t i) const = 0;
   virtual void SetInputAt(intptr_t i, Value* value) = 0;
 
   // Call computations override this function and return the
   // number of pushed arguments.
   virtual intptr_t ArgumentCount() const = 0;
 
   // Returns true, if this computation can deoptimize.
   virtual bool CanDeoptimize() const  = 0;
 
   // Optimize this computation. Returns a replacement for the instruction
   // that wraps this computation or NULL if nothing to replace.
   virtual Definition* TryReplace(BindInstr* instr) { return NULL; }
 
+  // Compares two computations. Returns true, if:
+  // 1. They are of the same kind.
+  // 2. All input operands match.
+  // 3. All other attributes match.
+  bool Equals(Computation* other) const;
+
+  // Returns a hash code for use with hash maps.
+  virtual intptr_t Hashcode() const;
+
+  // Compare attributes of an computation (except input operands and kind).
+  // TODO(fschneider): Make this abstract and implement for all computations.
+  virtual bool AttributesEqual(Computation* other) const { return true; }
+
+  // Returns true if the instruction may have side effects.
+  // TODO(fschneider): Make this abstract and implement for all computations
+  // instead of returning the safe default (true).
+  virtual bool HasSideEffect() const { return true; }
+
   // Compile time type of the computation, which typically depends on the
   // compile time types (and possibly propagated types) of its inputs.
   virtual RawAbstractType* CompileType() const = 0;
   virtual intptr_t ResultCid() const { return kDynamicCid; }
 
   // Mutate assigned_vars to add the local variable index for all
   // frame-allocated locals assigned to by the computation.
   virtual void RecordAssignedVars(BitVector* assigned_vars,
                                   intptr_t fixed_parameter_count);
 
@@ skipping 41 matching lines @@
   // Declare predicate for each computation.
 #define DECLARE_PREDICATE(ShortName, ClassName)                                \
   inline bool Is##ShortName() const;                                           \
   inline const ClassName* As##ShortName() const;                               \
   inline ClassName* As##ShortName();
 FOR_EACH_COMPUTATION(DECLARE_PREDICATE)
 #undef DECLARE_PREDICATE
 
  private:
   intptr_t deopt_id_;
-  ICData* ic_data_;
+  const ICData* ic_data_;
   LocationSummary* locs_;
 
   DISALLOW_COPY_AND_ASSIGN(Computation);
 };
 
 
 // An embedded container with N elements of type T.  Used (with partial
 // specialization for N=0) because embedded arrays cannot have size 0.
 template<typename T, intptr_t N>
 class EmbeddedArray {
@@ skipping 701 matching lines @@
   const intptr_t try_index_;
 
   DISALLOW_COPY_AND_ASSIGN(NativeCallComp);
 };
 
 
 class LoadInstanceFieldComp : public TemplateComputation<1> {
  public:
   LoadInstanceFieldComp(const Field& field,
                         Value* instance,
-                        InstanceCallComp* original)  // Maybe NULL.
-      : field_(field), original_(original) {
+                        InstanceCallComp* original,  // Maybe NULL.
+                        bool can_deoptimize)
+      : field_(field), original_(original), can_deoptimize_(can_deoptimize) {
     ASSERT(instance != NULL);
     inputs_[0] = instance;
   }
 
   DECLARE_COMPUTATION(LoadInstanceField)
 
   const Field& field() const { return field_; }
   Value* instance() const { return inputs_[0]; }
   const InstanceCallComp* original() const { return original_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
-  virtual bool CanDeoptimize() const { return true; }
+  virtual bool CanDeoptimize() const { return can_deoptimize_; }
 
  private:
   const Field& field_;
   const InstanceCallComp* original_;  // For optimizations.
+  const bool can_deoptimize_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadInstanceFieldComp);
 };
 
 
 class StoreInstanceFieldComp : public TemplateComputation<2> {
  public:
   StoreInstanceFieldComp(const Field& field,
                          Value* instance,
                          Value* value,
@@ skipping 798 matching lines @@
   virtual bool CanDeoptimize() const { return true; }
   virtual intptr_t ResultCid() const { return kDoubleCid; }
 
  private:
   InstanceCallComp* instance_call_;
 
   DISALLOW_COPY_AND_ASSIGN(SmiToDoubleComp);
 };
 
 
+class CheckClassComp : public TemplateComputation<1> {
+ public:
+  CheckClassComp(Value* value, InstanceCallComp* original)
+      : original_(original) {
+    ASSERT(value != NULL);
+    inputs_[0] = value;
+  }
+
+  DECLARE_COMPUTATION(CheckClass)
+
+  virtual bool CanDeoptimize() const { return true; }
+
+  virtual bool AttributesEqual(Computation* other) const;
+
+  virtual bool HasSideEffect() const { return false; }
+
+  Value* value() const { return inputs_[0]; }
+
+  intptr_t deopt_id() const { return original_->deopt_id(); }
+  intptr_t try_index() const { return original_->try_index(); }
+
+ private:
+  InstanceCallComp* original_;
+
+  DISALLOW_COPY_AND_ASSIGN(CheckClassComp);
+};
+
+
 #undef DECLARE_COMPUTATION
 
 
 // Implementation of type testers and cast functins.
 #define DEFINE_PREDICATE(ShortName, ClassName)                                 \
 bool Computation::Is##ShortName() const {                                      \
   return computation_kind() == k##ShortName;                                   \
 }                                                                              \
 const ClassName* Computation::As##ShortName() const {                          \
   if (!Is##ShortName()) return NULL;                                           \
@@ skipping 89 matching lines @@
     ASSERT(instr == NULL || !instr->IsBlockEntry());
     // TODO(fschneider): Also add Throw and ReThrow to the list of instructions
     // that do not have a successor. Currently, the graph builder will continue
     // to append instruction in case of a Throw inside an expression. This
     // condition should be handled in the graph builder
     next_ = instr;
   }
 
   // Removed this instruction from the graph.
   Instruction* RemoveFromGraph(bool return_previous = true);
+
   // Remove value uses within this instruction and its inputs.
   virtual void RemoveInputUses() = 0;
 
   // Normal instructions can have 0 (inside a block) or 1 (last instruction in
   // a block) successors. Branch instruction with >1 successors override this
   // function.
   virtual intptr_t SuccessorCount() const;
   virtual BlockEntryInstr* SuccessorAt(intptr_t index) const;
 
   void Goto(JoinEntryInstr* entry);
@@ skipping 53 matching lines @@
 
   Environment* env() const { return env_; }
   void set_env(Environment* env) { env_ = env; }
 
   intptr_t lifetime_position() const { return lifetime_position_; }
   void set_lifetime_position(intptr_t pos) {
     lifetime_position_ = pos;
   }
 
  private:
+  friend class BindInstr;  // Needed for BindInstr::InsertBefore.
+
   intptr_t lifetime_position_;  // Position used by register allocator.
   Instruction* previous_;
   Instruction* next_;
   Environment* env_;
   DISALLOW_COPY_AND_ASSIGN(Instruction);
 };
 
 
 template<intptr_t N>
 class TemplateInstruction: public Instruction {
@@ skipping 528 matching lines @@
   Computation* computation() const { return computation_; }
   void set_computation(Computation* value) { computation_ = value; }
   bool is_used() const { return is_used_; }
 
   virtual RawAbstractType* CompileType() const;
   virtual intptr_t GetPropagatedCid();
 
   virtual void RecordAssignedVars(BitVector* assigned_vars,
                                   intptr_t fixed_parameter_count);
 
+  intptr_t Hashcode() const { return computation()->Hashcode(); }
+
+  bool Equals(BindInstr* other) const {
+    return computation()->Equals(other->computation());
+  }
+
   virtual LocationSummary* locs() {
     return computation()->locs();
   }
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler);
 
   virtual void RemoveInputUses() { computation()->RemoveInputUses(); }
 
+  // Insert this instruction before 'next'.
+  void InsertBefore(BindInstr* next);
+
  private:
   Computation* computation_;
   const bool is_used_;
 
   DISALLOW_COPY_AND_ASSIGN(BindInstr);
 };
 
 
 class PhiInstr : public Definition {
  public:
@@ skipping 440 matching lines @@
   ForwardInstructionIterator* current_iterator_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_