Propagate class ids using existing type propagation framework.

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 138 matching lines @@
   // 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; }
 
   // 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; }

[regis, 2012/08/15 22:46:54]

This is correct to provide a default implementation. I preferred not to provide
one to make sure I do not forget to handle a computation, especially when we add
a new one later. You could add a TODO to make this abstract later.

[srdjan, 2012/08/16 00:34:46]

Added TODO.

 
   // 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);
 
   virtual const char* DebugName() const = 0;
 
   // Printing support. These functions are sometimes overridden for custom
   // formatting. Otherwise, it prints in the format "opcode(op1, op2, op3)".
@@ skipping 178 matching lines @@
   inline Definition* definition() const;
   void SetDefinition(Definition* definition);
 
   virtual bool CanDeoptimize() const { return false; }
 
   UseVal* next_use() const { return next_use_; }
   UseVal* previous_use() const { return previous_use_; }
   virtual void RemoveFromUseList();
   virtual void RemoveInputUses() { RemoveFromUseList(); }
 
+  virtual intptr_t ResultCid() const;
+
  private:
   void AddToUseList();
   Definition* definition_;
   UseVal* next_use_;
   UseVal* previous_use_;
 
   friend class Definition;
 
   DISALLOW_COPY_AND_ASSIGN(UseVal);
 };
 
 
-class ConstantVal: public Value {
+class ConstantVal : public Value {
  public:
   explicit ConstantVal(const Object& value)
       : value_(value) {
     ASSERT(value.IsZoneHandle());
     ASSERT(value.IsSmi() || value.IsOld());
   }
 
   DECLARE_VALUE(Constant)
 
   const Object& value() const { return value_; }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual void RemoveFromUseList() { }
 
+  virtual intptr_t ResultCid() const;
+
  private:
   const Object& value_;
 
   DISALLOW_COPY_AND_ASSIGN(ConstantVal);
 };
 
 #undef DECLARE_VALUE
 
 
 class AssertAssignableComp : public TemplateComputation<3> {
@@ skipping 77 matching lines @@
   }
   void eliminate() {
     ASSERT(!is_eliminated_);
     is_eliminated_ = true;
   }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
+  virtual intptr_t ResultCid() const { return kBoolCid; }
+
  private:
   const intptr_t token_pos_;
   const intptr_t try_index_;
   bool is_eliminated_;
 
   DISALLOW_COPY_AND_ASSIGN(AssertBooleanComp);
 };
 
 
 // Denotes the current context, normally held in a register.  This is
@@ skipping 174 matching lines @@
   }
 
   DECLARE_COMPUTATION(StrictCompare)
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Definition* TryReplace(BindInstr* instr);
 
+  virtual intptr_t ResultCid() const { return kBoolCid; }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(StrictCompareComp);
 };
 
 
 class EqualityCompareComp : public ComparisonComp {
  public:
   EqualityCompareComp(intptr_t token_pos,
                       intptr_t try_index,
                       Token::Kind kind,
@@ skipping 12 matching lines @@
   intptr_t try_index() const { return try_index_; }
 
   // Receiver class id is computed from collected ICData.
   void set_receiver_class_id(intptr_t value) { receiver_class_id_ = value; }
   intptr_t receiver_class_id() const { return receiver_class_id_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return true; }
 
+  virtual intptr_t ResultCid() const { return kBoolCid; }
+
  private:
   const intptr_t token_pos_;
   const intptr_t try_index_;
   intptr_t receiver_class_id_;  // Set by optimizer.
 
   DISALLOW_COPY_AND_ASSIGN(EqualityCompareComp);
 };
 
 
 class RelationalOpComp : public ComparisonComp {
@@ skipping 20 matching lines @@
   void set_operands_class_id(intptr_t value) {
     operands_class_id_ = value;
   }
 
   intptr_t operands_class_id() const { return operands_class_id_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return true; }
 
+  virtual intptr_t ResultCid() const { return kBoolCid; }
+
  private:
   const intptr_t token_pos_;
   const intptr_t try_index_;
   intptr_t operands_class_id_;  // class id of both operands.
 
   DISALLOW_COPY_AND_ASSIGN(RelationalOpComp);
 };
 
 
 class StaticCallComp : public TemplateComputation<0> {
@@ skipping 1590 matching lines @@
 };
 
 
 // Abstract super-class of all instructions that define a value (Bind, Phi).
 class Definition : public Instruction {
  public:
   Definition()
       : temp_index_(-1),
         ssa_temp_index_(-1),
         propagated_type_(AbstractType::Handle()),
+        propagated_cid_(kIllegalCid),
         use_list_(NULL) { }
 
   virtual bool IsDefinition() const { return true; }
   virtual Definition* AsDefinition() { return this; }
 
   intptr_t temp_index() const { return temp_index_; }
   void set_temp_index(intptr_t index) { temp_index_ = index; }
 
   intptr_t ssa_temp_index() const { return ssa_temp_index_; }
   void set_ssa_temp_index(intptr_t index) {
@@ skipping 18 matching lines @@
     if (propagated_type.IsNull()) {
       // Not a typed definition, e.g. access to a VM field.
       return false;
     }
     const bool changed =
         propagated_type_.IsNull() || !propagated_type.Equals(propagated_type_);
     propagated_type_ = propagated_type.raw();
     return changed;
   }
 
+  bool has_propagated_cid() const { return propagated_cid_ != kIllegalCid; }
+  intptr_t propagated_cid() const { return propagated_cid_; }
+
+  // Returns true if the propagated cid has changed.
+  // Merges the cids:
+  // - overwrite if not set before.
+  // - if cid-s differ set to kDynamicCid.
+  bool SetPropagatedCid(intptr_t cid) {

[regis, 2012/08/15 22:46:54]

I see now that you are not just setting the propagated cid, but implementing the
merge logic here. SetPropagatedType does not implement the merging logic, but
just sets the type. Note that the merging logic can be different for Phi and
Bind. I think it would be better to move the logic out of here.

[srdjan, 2012/08/16 00:34:46]

Moved the merge logic out.

+    ASSERT(cid != 1);
+    ASSERT(cid != kIllegalCid);
+    if (propagated_cid_ == kDynamicCid) {
+      return false;
+    }
+    if (propagated_cid_ == kIllegalCid) {
+      propagated_cid_ = cid;
+      return true;
+    }
+    if (propagated_cid_ != cid) {
+      propagated_cid_ = kDynamicCid;
+      return true;
+    }
+    return false;
+  }
+
   UseVal* use_list() { return use_list_; }
   void set_use_list(UseVal* head) {
     ASSERT(head == NULL || head->previous_use() == NULL);
     use_list_ = head;
   }
 
   void ReplaceUsesWith(Definition* other);
 
  private:
   intptr_t temp_index_;
   intptr_t ssa_temp_index_;
   // TODO(regis): GrowableArray<const AbstractType*> propagated_types_;
   // For now:
   AbstractType& propagated_type_;
+  intptr_t propagated_cid_;
   UseVal* use_list_;
 
   DISALLOW_COPY_AND_ASSIGN(Definition);
 };
 
 
 Definition* UseVal::definition() const {
   // Check that the definition is either a Phi or a linked in the the IR.
   ASSERT(definition_ != NULL);
   return definition_;
@@ skipping 485 matching lines @@
   const GrowableArray<BlockEntryInstr*>& block_order_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_