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;
+  // TODO(srdjan): Make this abstract so that it gets correctly implemented
+  // in all computations.
+  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);
 
   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 192 matching lines @@
   // Returns true if the value represents constant null.
   virtual bool BindsToConstantNull() const;
 
   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_; }
 
   // Returns true if the value represents a constant.
   virtual bool BindsToConstant() const { return true; }
 
   // Returns true if the value represents constant null.
   virtual bool BindsToConstantNull() const { return value().IsNull(); }
 
   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_; }
+  // May compute and set propagated cid.
+  virtual intptr_t GetPropagatedCid() = 0;
+
+  // Returns true if the propagated cid has changed.
+  bool SetPropagatedCid(intptr_t cid);
+
   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 22 matching lines @@
     computation()->SetInputAt(i, value);
   }
 
   virtual bool CanDeoptimize() const { return computation()->CanDeoptimize(); }
 
   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);
 
   virtual LocationSummary* locs() {
     return computation()->locs();
   }
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler);
 
@@ skipping 10 matching lines @@
 class PhiInstr : public Definition {
  public:
   explicit PhiInstr(intptr_t num_inputs)
     : inputs_(num_inputs), is_alive_(false) {
     for (intptr_t i = 0; i < num_inputs; ++i) {
       inputs_.Add(NULL);
     }
   }
 
   virtual RawAbstractType* CompileType() const;
+  virtual intptr_t GetPropagatedCid() { return propagated_cid(); }
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   intptr_t InputCount() const { return inputs_.length(); }
 
   Value* InputAt(intptr_t i) const { return inputs_[i]; }
 
   void SetInputAt(intptr_t i, Value* value) { inputs_[i] = value; }
 
   virtual bool CanDeoptimize() const { return false; }
@@ skipping 25 matching lines @@
 class ParameterInstr : public Definition {
  public:
   explicit ParameterInstr(intptr_t index) : index_(index) { }
 
   DECLARE_INSTRUCTION(Parameter)
 
   intptr_t index() const { return index_; }
 
   // Compile type of the passed-in parameter.
   virtual RawAbstractType* CompileType() const;
+  // No known propagated cid for parameters.
+  virtual intptr_t GetPropagatedCid() { return propagated_cid(); }
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   intptr_t InputCount() const { return 0; }
   Value* InputAt(intptr_t i) const {
     UNREACHABLE();
     return NULL;
   }
   void SetInputAt(intptr_t i, Value* value) { UNREACHABLE(); }
 
@@ skipping 22 matching lines @@
     return value_;
   }
   void SetInputAt(intptr_t i, Value* value) {
     ASSERT(i == 0);
     value_ = value;
   }
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   virtual RawAbstractType* CompileType() const;
+  virtual intptr_t GetPropagatedCid() { return propagated_cid(); }
 
   Value* value() const { return value_; }
 
   virtual LocationSummary* locs() {
     if (locs_ == NULL) {
       locs_ = MakeLocationSummary();
     }
     return locs_;
   }
 
@@ skipping 331 matching lines @@
   ForwardInstructionIterator* current_iterator_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_