Adding deopt info to code object.

runtime/vm/object.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_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 152 matching lines @@
     kTokenStreamClass,
     kScriptClass,
     kLibraryClass,
     kLibraryPrefixClass,
     kCodeClass,
     kInstructionsClass,
     kPcDescriptorsClass,
     kStackmapClass,
     kLocalVarDescriptorsClass,
     kExceptionHandlersClass,
+    kDeoptInfoClass,
     kContextClass,
     kContextScopeClass,
     kICDataClass,
     kSubtypeTestCacheClass,
     kApiErrorClass,
     kLanguageErrorClass,
     kUnhandledExceptionClass,
     kUnwindErrorClass,
     kMaxId,
     kInvalidIndex = -1,
@@ skipping 119 matching lines @@
   static RawClass* library_class() { return library_class_; }
   static RawClass* library_prefix_class() { return library_prefix_class_; }
   static RawClass* code_class() { return code_class_; }
   static RawClass* instructions_class() { return instructions_class_; }
   static RawClass* pc_descriptors_class() { return pc_descriptors_class_; }
   static RawClass* stackmap_class() { return stackmap_class_; }
   static RawClass* var_descriptors_class() { return var_descriptors_class_; }
   static RawClass* exception_handlers_class() {
     return exception_handlers_class_;
   }
+  static RawClass* deopt_info_class() { return deopt_info_class_; }
   static RawClass* context_class() { return context_class_; }
   static RawClass* context_scope_class() { return context_scope_class_; }
   static RawClass* api_error_class() { return api_error_class_; }
   static RawClass* language_error_class() { return language_error_class_; }
   static RawClass* unhandled_exception_class() {
     return unhandled_exception_class_;
   }
   static RawClass* unwind_error_class() { return unwind_error_class_; }
   static RawClass* icdata_class() { return icdata_class_; }
   static RawClass* subtypetestcache_class() { return subtypetestcache_class_; }
@@ skipping 111 matching lines @@
   static RawClass* token_stream_class_;  // Class of the TokenStream vm object.
   static RawClass* script_class_;  // Class of the Script vm object.
   static RawClass* library_class_;  // Class of the Library vm object.
   static RawClass* library_prefix_class_;  // Class of Library prefix vm object.
   static RawClass* code_class_;  // Class of the Code vm object.
   static RawClass* instructions_class_;  // Class of the Instructions vm object.
   static RawClass* pc_descriptors_class_;  // Class of PcDescriptors vm object.
   static RawClass* stackmap_class_;  // Class of Stackmap vm object.
   static RawClass* var_descriptors_class_;  // Class of LocalVarDescriptors.
   static RawClass* exception_handlers_class_;  // Class of ExceptionHandlers.
+  static RawClass* deopt_info_class_;  // Class of DeoptInfo.
   static RawClass* context_class_;  // Class of the Context vm object.
   static RawClass* context_scope_class_;  // Class of ContextScope vm object.
   static RawClass* icdata_class_;  // Class of ICData.
   static RawClass* subtypetestcache_class_;  // Class of SubtypeTestCache.
   static RawClass* api_error_class_;  // Class of ApiError.
   static RawClass* language_error_class_;  // Class of LanguageError.
   static RawClass* unhandled_exception_class_;  // Class of UnhandledException.
   static RawClass* unwind_error_class_;  // Class of UnwindError.
 
   friend void ClassTable::Register(const Class& cls);
@@ skipping 1745 matching lines @@
     kNodeIdEntry,      // AST node id.
     kTokenIndexEntry,  // Token position in source of PC.
     kTryIndexEntry,    // Try block index of PC.
     // We would potentially be adding other objects here like
     // pointer maps for optimized functions, local variables information  etc.
     kNumberOfEntries
   };
 
  public:
   enum Kind {
-    kDeopt = 0,  // Deoptimization cotinuation point.
-    kPatchCode,  // Buffer for patching code entry.
-    kIcCall,     // IC call.
-    kFuncCall,   // Call to known target, e.g. static call, closure call.
-    kReturn,     // Return from function.
+    kDeopt = 0,   // Deoptimization cotinuation point.
+    kDeoptIndex,  // Index into deopt info array.
+    kPatchCode,   // Buffer for patching code entry.
+    kIcCall,      // IC call.
+    kFuncCall,    // Call to known target, e.g. static call, closure call.
+    kReturn,      // Return from function.
     kOther
   };
 
   intptr_t Length() const;
 
   uword PC(intptr_t index) const;
   PcDescriptors::Kind DescriptorKind(intptr_t index) const;
   const char* KindAsStr(intptr_t index) const;
   intptr_t NodeId(intptr_t index) const;
   intptr_t TokenIndex(intptr_t index) const;
   intptr_t TryIndex(intptr_t index) const;
+  // Index into the deopt-info array of Code object.
+  intptr_t DeoptIndex(intptr_t index) const;
 
   void AddDescriptor(intptr_t index,
                      uword pc,
                      PcDescriptors::Kind kind,
                      intptr_t node_id,
                      intptr_t token_pos,
                      intptr_t try_index) const {
     SetPC(index, pc);
     SetKind(index, kind);
     SetNodeId(index, node_id);
@@ skipping 153 matching lines @@
     ASSERT((index >=0) && (index < Length()));
     intptr_t data_index = (index * kNumberOfEntries) + entry_offset;
     return &raw_ptr()->data_[data_index];
   }
 
   HEAP_OBJECT_IMPLEMENTATION(ExceptionHandlers, Object);
   friend class Class;
 };
 
 
+// Holds deopt information at one deoptimization point. The information
+// is a list of DeoptInstr objects, specifying transformation information
+// for each slot in unoptimized frame(s).
+class DeoptInfo : public Object {
+ private:
+  // Describes the layout of deopt info data.

[siva, 2012/08/02 16:57:37]

You should also mention here that the index of the deopt-info entry is
implicitly the stack slot in the unoptimized frame into which the value is
written into.

+  enum {
+    kInstruction = 0,
+    kFromIndex,
+    kNumberOfEntries,
+  };
+
+ public:
+  intptr_t Length() const;
+
+  static RawDeoptInfo* New(intptr_t num_commands);
+
+  static const intptr_t kBytesPerElement = (kNumberOfEntries * kWordSize);
+  static const intptr_t kMaxElements = kSmiMax / kBytesPerElement;
+
+  static intptr_t InstanceSize() {
+    ASSERT(sizeof(RawDeoptInfo) == OFFSET_OF(RawDeoptInfo, data_));
+    return 0;
+  }
+
+  static intptr_t InstanceSize(intptr_t len) {
+    ASSERT(0 <= len && len <= kMaxElements);
+    return RoundedAllocationSize(sizeof(RawDeoptInfo) +
+                                 (len * kBytesPerElement));
+  }
+
+  // 'index' corresponds to target, to-index.

[siva, 2012/08/02 16:57:37]

We have one deopt_info array per code object and we will have multiple deopt-ix
pc descriptor entries pointing into this deopt info array. For the first pc
descriptor entry I can see how index and to-index map nicely but for the
subsequent ones you would have to do subtract index from the start index right?
I am little confused by this maybe you can explain offline.

[srdjan, 2012/08/02 17:51:44]

Discussed offline. There is another level of indirection: deopt-ix points to an
array of DeoptInfo objects.

+  void SetAt(intptr_t index,
+             intptr_t instr_kind,
+             intptr_t from_index) const;
+
+  intptr_t Instruction(intptr_t index) const;
+  intptr_t FromIndex(intptr_t index) const;
+
+ private:
+  intptr_t* EntryAddr(intptr_t index, intptr_t entry_offset) const {
+    ASSERT((index >=0) && (index < Length()));
+    intptr_t data_index = (index * kNumberOfEntries) + entry_offset;
+    return &raw_ptr()->data_[data_index];
+  }
+
+  void SetLength(intptr_t value) const;
+
+  HEAP_OBJECT_IMPLEMENTATION(DeoptInfo, Object);
+  friend class Class;
+};
+
+
 class Code : public Object {
  public:
   RawInstructions* instructions() const { return raw_ptr()->instructions_; }
   static intptr_t instructions_offset() {
     return OFFSET_OF(RawCode, instructions_);
   }
   intptr_t pointer_offsets_length() const {
     return raw_ptr()->pointer_offsets_length_;
   }
   bool is_optimized() const {
@@ skipping 11 matching lines @@
     return instr.size();
   }
 
   RawPcDescriptors* pc_descriptors() const {
     return raw_ptr()->pc_descriptors_;
   }
   void set_pc_descriptors(const PcDescriptors& descriptors) const {
     StorePointer(&raw_ptr()->pc_descriptors_, descriptors.raw());
   }
 
+  // Array of DeoptInfo objects.
+  RawArray* deopt_info_array() const {
+    return raw_ptr()->deopt_info_array_;
+  }
+  void set_deopt_info_array(const Array& array) const;
+
+  RawArray* object_table() const {
+    return raw_ptr()->object_table_;
+  }
+  void set_object_table(const Array& array) const;
+
   RawArray* stackmaps() const {
     return raw_ptr()->stackmaps_;
   }
   void set_stackmaps(const Array& maps) const;
   RawStackmap* GetStackmap(uword pc, Array* stackmaps, Stackmap* map) const;
 
   class Comments : public ZoneAllocated {
    public:
     static Comments& New(intptr_t count);
 
@@ skipping 72 matching lines @@
   intptr_t GetTokenIndexOfPC(uword pc) const;
 
   // Find pc of patch code buffer. Return 0 if not found.
   uword GetPatchCodePc() const;
 
   uword GetDeoptPcAtNodeId(intptr_t node_id) const;
   uword GetTypeTestAtNodeId(intptr_t node_id) const;
 
   // Returns true if there is an object in the code between 'start_offset'
   // (inclusive) and 'end_offset' (exclusive).
-  bool ObjectExistInArea(intptr_t start_offest, intptr_t end_offset) const;
+  bool ObjectExistsInArea(intptr_t start_offest, intptr_t end_offset) const;
 
   // Each (*node_ids)[n] has a an extracted ic data array (*arrays)[n].
   // Returns the maximum id found.
   intptr_t ExtractIcDataArraysAtCalls(
       GrowableArray<intptr_t>* node_ids,
       const GrowableObjectArray& ic_data_objs) const;
 
  private:
   // An object finder visitor interface.
   class FindRawCodeVisitor : public FindObjectVisitor {
@@ skipping 2838 matching lines @@
     if (this->CharAt(i) != str.CharAt(begin_index + i)) {
       return false;
     }
   }
   return true;
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_