Adding collected type feedback to the IL nodes (only in optimized mode).

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 52 matching lines @@
 
 
 #define FORWARD_DECLARATION(ShortName, ClassName) class ClassName;
 FOR_EACH_COMPUTATION(FORWARD_DECLARATION)
 #undef FORWARD_DECLARATION
 
 class Computation : public ZoneAllocated {
  public:
   static const int kNoCid = -1;
 
-  Computation() : cid_(GetNextCid()) { }
+  Computation() : cid_(-1), ic_data_(NULL) {
+    Isolate* isolate = Isolate::Current();
+    cid_ = GetNextCid(isolate);
+    ic_data_ = GetICDataForCid(cid_, isolate);
+  }
 
   // Unique computation/instruction id, used for deoptimization.
   intptr_t cid() const { return cid_; }
 
+  const ICData* ic_data() const { return ic_data_; }
+
   // Visiting support.
   virtual void Accept(FlowGraphVisitor* visitor) = 0;
 
   virtual intptr_t InputCount() const = 0;
 
  private:
   friend class Instruction;
-  static intptr_t GetNextCid() {
-    Isolate* isolate = Isolate::Current();
+  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());
+      ICData& ic_data_handle = ICData::ZoneHandle();
+      if (cid < array_handle.Length()) {
+        ic_data_handle ^= array_handle.At(cid);
+      }
+      return &ic_data_handle;
+    }
+  }
 
-  const intptr_t cid_;
+  intptr_t cid_;
+  ICData* ic_data_;
 
   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 {
  public:
@@ skipping 1028 matching lines @@
 // Functions required in all concrete instruction classes.
 #define DECLARE_INSTRUCTION(type)                                              \
   virtual Instruction* Accept(FlowGraphVisitor* visitor);                      \
   virtual bool Is##type() const { return true; }                               \
   virtual type##Instr* As##type() { return this; }                             \
   virtual intptr_t InputCount() const;                                         \
 
 
 class Instruction : public ZoneAllocated {
  public:
-  Instruction() : cid_(Computation::GetNextCid()) { }
+  Instruction() : cid_(-1), ic_data_(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_; }
+
   virtual bool IsBlockEntry() const { return false; }
   BlockEntryInstr* AsBlockEntry() {
     return IsBlockEntry() ? reinterpret_cast<BlockEntryInstr*>(this) : NULL;
   }
   virtual bool IsDefinition() const { return false; }
   Definition* AsDefinition() {
     return IsDefinition() ? reinterpret_cast<Definition*>(this) : NULL;
   }
 
   virtual intptr_t InputCount() const = 0;
@@ skipping 24 matching lines @@
     UNREACHABLE();
   }
 
 #define INSTRUCTION_TYPE_CHECK(type)                                           \
   virtual bool Is##type() const { return false; }                              \
   virtual type##Instr* As##type() { return NULL; }
 FOR_EACH_INSTRUCTION(INSTRUCTION_TYPE_CHECK)
 #undef INSTRUCTION_TYPE_CHECK
 
  private:
-  const intptr_t cid_;
+  intptr_t cid_;
+  ICData* ic_data_;
   DISALLOW_COPY_AND_ASSIGN(Instruction);
 };
 
 
 // Basic block entries are administrative nodes.  Joins are the only nodes
 // with multiple predecessors.  Targets are the other basic block entries.
 // The types enforce edge-split form---joins are forbidden as the successors
 // of branches.
 class BlockEntryInstr : public Instruction {
  public:
@@ skipping 433 matching lines @@
   const GrowableArray<BlockEntryInstr*>& block_order_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_