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

runtime/vm/intermediate_language.h

Index: runtime/vm/intermediate_language.h
===================================================================
--- runtime/vm/intermediate_language.h	(revision 10885)
+++ runtime/vm/intermediate_language.h	(working copy)
@@ -101,7 +101,8 @@
   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;
@@ -129,8 +130,8 @@
   // 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();
   }
@@ -153,6 +154,12 @@
   // that wraps this computation or NULL if nothing to replace.
   virtual Definition* TryReplace(BindInstr* instr) { return NULL; }
 
+  // Functions to support CSE.

[srdjan, 2012/08/17 22:30:22]

Please document these functions briefly.

[Florian Schneider, 2012/08/20 12:09:37]

Done.

+  bool Equals(Computation* other) const;
+  virtual intptr_t Hashcode() const;
+  virtual bool AttributesEqual(Computation* other) const { return 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;
@@ -214,7 +221,7 @@
 
  private:
   intptr_t deopt_id_;
-  ICData* ic_data_;
+  const ICData* ic_data_;
   LocationSummary* locs_;
 
   DISALLOW_COPY_AND_ASSIGN(Computation);
@@ -1773,6 +1780,34 @@
 };
 
 
+class CheckClassComp : public TemplateComputation<1> {

[srdjan, 2012/08/17 22:30:22]

Consider renaming it to CheckClassesComp since it checks a set of classes.

[Florian Schneider, 2012/08/20 12:09:37]

Done.

+ 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; }

[srdjan, 2012/08/17 22:30:22]

Why is CheckClassComp the only computation that does not have side effect?
Please add comment.

[Florian Schneider, 2012/08/20 12:09:37]

Currently only CheckClass participates in CSE, but I added a TODO to implement
it for all computations. By default it returns the safe default (true) for now.

+
+  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
 
 
@@ -1882,9 +1917,13 @@
 
   // 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;
 
+  // Insert this instruction before 'next'.
+  void InsertBefore(Instruction* next);
+
   // Normal instructions can have 0 (inside a block) or 1 (last instruction in
   // a block) successors. Branch instruction with >1 successors override this
   // function.
@@ -2503,6 +2542,12 @@
   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();
   }