Add type propagation phase in optimizing compiler (work in progress).

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 100 matching lines @@
 class BindInstr;
 class BranchInstr;
 class BufferFormatter;
 class ComparisonComp;
 class Instruction;
 class PushArgumentInstr;
 class Value;
 
 class Computation : public ZoneAllocated {
  public:
-  static const int kNoCid = -1;
+  static const intptr_t kNoCid = -1;
 
-  Computation() : cid_(-1), ic_data_(NULL), locs_(NULL) {
+  Computation() : cid_(kNoCid), ic_data_(NULL), locs_(NULL) {
     Isolate* isolate = Isolate::Current();
-    cid_ = GetNextCid(isolate);
-    ic_data_ = GetICDataForCid(cid_, isolate);
+    cid_ = isolate->GetNextCid();
+    ic_data_ = isolate->GetICDataForCid(cid_);
   }
 
   // Unique computation/instruction id, used for deoptimization.
   intptr_t cid() const { return cid_; }
 
   ICData* ic_data() const { return ic_data_; }
   void set_ic_data(ICData* value) { ic_data_ = value; }
   bool HasICData() const {
     return (ic_data() != NULL) && !ic_data()->IsNull();
   }
@@ skipping 53 matching lines @@
 #define DECLARE_COMPUTATION_TYPE(ShortName, ClassName) k##ShortName,
 
   FOR_EACH_COMPUTATION(DECLARE_COMPUTATION_TYPE)
 
 #undef DECLARE_COMPUTATION_TYPE
   };
 
   virtual ComputationType computation_type() const = 0;
 
   // Declare predicate for each computation.
-#define DECLARE_PREDICATE(ShortName, ClassName)                             \
-  inline bool Is##ShortName() const;                                        \
+#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)
+FOR_EACH_COMPUTATION(DECLARE_PREDICATE)
 #undef DECLARE_PREDICATE
 
  private:
-  friend class Instruction;
-  static intptr_t GetNextCid(Isolate* isolate) {
-    intptr_t tmp = isolate->computation_id();
-    isolate->set_computation_id(tmp + 1);
-    return tmp;
-  }
-  static ICData* GetICDataForCid(intptr_t cid, Isolate* isolate) {
-    if (isolate->ic_data_array() == Array::null()) {
-      return NULL;
-    } else {
-      const Array& array_handle = Array::Handle(isolate->ic_data_array());
-      if (cid >= array_handle.Length()) {
-        // For computations being added in the optimizing compiler.
-        return NULL;
-      }
-      ICData& ic_data_handle = ICData::ZoneHandle();
-      ic_data_handle ^= array_handle.At(cid);
-      return &ic_data_handle;
-    }
-  }
-
   intptr_t cid_;
   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.
@@ skipping 55 matching lines @@
 
  protected:
   EmbeddedArray<Value*, N> inputs_;
 };
 
 
 class Value : public TemplateComputation<0> {
  public:
   Value() { }
 
+  bool StaticTypeIsMoreSpecificThan(const AbstractType& dst_type) const;
+
  private:
   DISALLOW_COPY_AND_ASSIGN(Value);
 };
 
 
 // Functions defined in all concrete computation classes.
 #define DECLARE_COMPUTATION(ShortName)                                         \
   virtual void Accept(FlowGraphVisitor* visitor, BindInstr* instr);            \
   virtual ComputationType computation_type() const {                           \
     return Computation::k##ShortName;                                          \
@@ skipping 1440 matching lines @@
 
 
 #undef DECLARE_COMPUTATION
 
 
 // Implementation of type testers and cast functins.
 #define DEFINE_PREDICATE(ShortName, ClassName)                                 \
 bool Computation::Is##ShortName() const {                                      \
   return computation_type() == k##ShortName;                                   \
 }                                                                              \
+const ClassName* Computation::As##ShortName() const {                          \
+  if (!Is##ShortName()) return NULL;                                           \
+  return static_cast<const ClassName*>(this);                                  \
+}                                                                              \
 ClassName* Computation::As##ShortName() {                                      \
   if (!Is##ShortName()) return NULL;                                           \
   return static_cast<ClassName*>(this);                                        \
 }
 FOR_EACH_COMPUTATION(DEFINE_PREDICATE)
 #undef DEFINE_PREDICATE
 
 
 // Instructions.
 
@@ skipping 35 matching lines @@
   virtual Value* InputAt(intptr_t i) const;                                    \
   virtual void SetInputAt(intptr_t i, Value* value);                           \
   virtual const char* DebugName() const { return #type; }                      \
   virtual void PrintTo(BufferFormatter* f) const;                              \
   virtual void PrintToVisualizer(BufferFormatter* f) const;
 
 
 class Instruction : public ZoneAllocated {
  public:
   Instruction()
-      : cid_(-1),
-        lifetime_position_(-1),
-        ic_data_(NULL),
-        previous_(NULL),
-        next_(NULL),
-        env_(NULL) {
-    Isolate* isolate = Isolate::Current();
-    cid_ = Computation::GetNextCid(isolate);
-    ic_data_ = Computation::GetICDataForCid(cid_, isolate);
-  }
-
-  // Unique computation/instruction id, used for deoptimization, e.g. for
-  // ReturnInstr, ThrowInstr and ReThrowInstr.
-  intptr_t cid() const { return cid_; }
-
-  const ICData* ic_data() const { return ic_data_; }
-  bool HasICData() const {
-    return (ic_data() != NULL) && !ic_data()->IsNull();
-  }
+      : lifetime_position_(-1), previous_(NULL), next_(NULL), env_(NULL) { }
 
   virtual bool IsBlockEntry() const { return false; }
   BlockEntryInstr* AsBlockEntry() {
     return IsBlockEntry() ? reinterpret_cast<BlockEntryInstr*>(this) : NULL;
   }
   virtual bool IsDefinition() const { return false; }
   virtual Definition* AsDefinition() { return NULL; }
 
   virtual intptr_t InputCount() const = 0;
   virtual Value* InputAt(intptr_t i) const = 0;
@@ skipping 95 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:
-  intptr_t cid_;  // Computation id.
   intptr_t lifetime_position_;  // Position used by register allocator.
-  ICData* ic_data_;
   Instruction* previous_;
   Instruction* next_;
   Environment* env_;
   DISALLOW_COPY_AND_ASSIGN(Instruction);
 };
 
 
 class InstructionWithInputs : public Instruction {
  public:
   InstructionWithInputs() : locs_(NULL) { }
@@ skipping 531 matching lines @@
  private:
   Value* value_;
 
   DISALLOW_COPY_AND_ASSIGN(PushArgumentInstr);
 };
 
 
 class ReturnInstr : public InstructionWithInputs {
  public:
   ReturnInstr(intptr_t token_pos, Value* value)
-      : InstructionWithInputs(), token_pos_(token_pos), value_(value) {
+      : InstructionWithInputs(),
+        cid_(Isolate::Current()->GetNextCid()),
+        token_pos_(token_pos),
+        value_(value) {
     ASSERT(value_ != NULL);
   }
 
   DECLARE_INSTRUCTION(Return)
 
+  intptr_t cid() const { return cid_; }
+  intptr_t token_pos() const { return token_pos_; }
   Value* value() const { return value_; }
-  intptr_t token_pos() const { return token_pos_; }
 
   virtual LocationSummary* MakeLocationSummary() const;
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler);
 
   virtual bool CanDeoptimize() const { return false; }
 
  private:
+  const intptr_t cid_;  // Computation/instruction id.
   const intptr_t token_pos_;
   Value* value_;
 
   DISALLOW_COPY_AND_ASSIGN(ReturnInstr);
 };
 
 
 class ThrowInstr : public InstructionWithInputs {
  public:
   ThrowInstr(intptr_t token_pos,
              intptr_t try_index,
              Value* exception)
       : InstructionWithInputs(),
+        cid_(Isolate::Current()->GetNextCid()),
         token_pos_(token_pos),
         try_index_(try_index),
         exception_(exception) {
     ASSERT(exception_ != NULL);
   }
 
   DECLARE_INSTRUCTION(Throw)
 
+  intptr_t cid() const { return cid_; }
   intptr_t token_pos() const { return token_pos_; }
   intptr_t try_index() const { return try_index_; }
   Value* exception() const { return exception_; }
 
   virtual LocationSummary* MakeLocationSummary() const;
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler);
 
   virtual bool CanDeoptimize() const { return false; }
 
  private:
+  const intptr_t cid_;  // Computation/instruction id.
   const intptr_t token_pos_;
   const intptr_t try_index_;
   Value* exception_;
 
   DISALLOW_COPY_AND_ASSIGN(ThrowInstr);
 };
 
 
 class ReThrowInstr : public InstructionWithInputs {
  public:
   ReThrowInstr(intptr_t token_pos,
                intptr_t try_index,
                Value* exception,
                Value* stack_trace)
       : InstructionWithInputs(),
+        cid_(Isolate::Current()->GetNextCid()),
         token_pos_(token_pos),
         try_index_(try_index),
         exception_(exception),
         stack_trace_(stack_trace) {
     ASSERT(exception_ != NULL);
     ASSERT(stack_trace_ != NULL);
   }
 
   DECLARE_INSTRUCTION(ReThrow)
 
+  intptr_t cid() const { return cid_; }
   intptr_t token_pos() const { return token_pos_; }
   intptr_t try_index() const { return try_index_; }
   Value* exception() const { return exception_; }
   Value* stack_trace() const { return stack_trace_; }
 
   virtual LocationSummary* MakeLocationSummary() const;
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler);
 
   virtual bool CanDeoptimize() const { return false; }
 
  private:
+  const intptr_t cid_;  // Computation/instruction id.
   const intptr_t token_pos_;
   const intptr_t try_index_;
   Value* exception_;
   Value* stack_trace_;
 
   DISALLOW_COPY_AND_ASSIGN(ReThrowInstr);
 };
 
 
 class GotoInstr : public InstructionWithInputs {
@@ skipping 37 matching lines @@
   // Parallel move that will be used by linear scan register allocator to
   // connect live ranges at the end of the block and resolve phis.
   ParallelMoveInstr* parallel_move_;
 };
 
 
 class BranchInstr : public InstructionWithInputs {
  public:
   BranchInstr(intptr_t token_pos,
               intptr_t try_index,
-               Value* left,
-             Value* right,
+              Value* left,
+              Value* right,
               Token::Kind kind)
       : InstructionWithInputs(),
+        cid_(Computation::kNoCid),
+        ic_data_(NULL),
         token_pos_(token_pos),
         try_index_(try_index),
         left_(left),
         right_(right),
         kind_(kind),
         true_successor_(NULL),
         false_successor_(NULL) {
     ASSERT(left_ != NULL);
     ASSERT(right_ != NULL);
     ASSERT(Token::IsEqualityOperator(kind) ||
            Token::IsRelationalOperator(kind) ||
            Token::IsTypeTestOperator(kind));
+    Isolate* isolate = Isolate::Current();
+    cid_ = isolate->GetNextCid();
+    ic_data_ = isolate->GetICDataForCid(cid_);
   }
 
   DECLARE_INSTRUCTION(Branch)
 
   Value* left() const { return left_; }
   Value* right() const { return right_; }
   Token::Kind kind() const { return kind_; }
   void set_kind(Token::Kind kind) {
     ASSERT(Token::IsEqualityOperator(kind) ||
            Token::IsRelationalOperator(kind) ||
            Token::IsTypeTestOperator(kind));
     kind_ = kind;
   }
+
+  intptr_t cid() const { return cid_; }
+
+  const ICData* ic_data() const { return ic_data_; }
+  bool HasICData() const {
+    return (ic_data() != NULL) && !ic_data()->IsNull();
+  }
+
   intptr_t token_pos() const { return token_pos_;}
   intptr_t try_index() const { return try_index_; }
 
   TargetEntryInstr* true_successor() const { return true_successor_; }
   TargetEntryInstr* false_successor() const { return false_successor_; }
 
   TargetEntryInstr** true_successor_address() { return &true_successor_; }
   TargetEntryInstr** false_successor_address() { return &false_successor_; }
 
   virtual intptr_t SuccessorCount() const;
@@ skipping 11 matching lines @@
   virtual LocationSummary* MakeLocationSummary() const;
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler);
 
   void EmitBranchOnCondition(FlowGraphCompiler* compiler,
                              Condition true_condition);
 
   virtual bool CanDeoptimize() const { return true; }
 
  private:
+  intptr_t cid_;  // Computation/instruction id.
+  ICData* ic_data_;
   const intptr_t token_pos_;
   const intptr_t try_index_;
   Value* left_;
   Value* right_;
   Token::Kind kind_;
   TargetEntryInstr* true_successor_;
   TargetEntryInstr* false_successor_;
 
   DISALLOW_COPY_AND_ASSIGN(BranchInstr);
 };
@@ skipping 77 matching lines @@
   const GrowableArray<BlockEntryInstr*>& block_order_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_