Adding deopt info to code object.

runtime/vm/object.cc

 // 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.
 
 #include "vm/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
@@ skipping 69 matching lines @@
 RawClass* Object::library_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::library_prefix_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::code_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::instructions_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::pc_descriptors_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::stackmap_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::var_descriptors_class_ =
     reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::exception_handlers_class_ =
     reinterpret_cast<RawClass*>(RAW_NULL);
+RawClass* Object::deopt_info_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::context_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::context_scope_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::icdata_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::subtypetestcache_class_ =
     reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::api_error_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::language_error_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::unhandled_exception_class_ =
     reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::unwind_error_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
@@ skipping 38 matching lines @@
   } else if (raw_class == instructions_class()) {
     return kInstructionsClass;
   } else if (raw_class == pc_descriptors_class()) {
     return kPcDescriptorsClass;
   } else if (raw_class == stackmap_class()) {
     return kStackmapClass;
   } else if (raw_class == var_descriptors_class()) {
     return kLocalVarDescriptorsClass;
   } else if (raw_class == exception_handlers_class()) {
     return kExceptionHandlersClass;
+  } else if (raw_class == deopt_info_class()) {
+    return kDeoptInfoClass;
   } else if (raw_class == context_class()) {
     return kContextClass;
   } else if (raw_class == context_scope_class()) {
     return kContextScopeClass;
   } else if (raw_class == icdata_class()) {
     return kICDataClass;
   } else if (raw_class == subtypetestcache_class()) {
     return kSubtypeTestCacheClass;
   } else if (raw_class == api_error_class()) {
     return kApiErrorClass;
@@ skipping 26 matching lines @@
     case kTokenStreamClass: return token_stream_class();
     case kScriptClass: return script_class();
     case kLibraryClass: return library_class();
     case kLibraryPrefixClass: return library_prefix_class();
     case kCodeClass: return code_class();
     case kInstructionsClass: return instructions_class();
     case kPcDescriptorsClass: return pc_descriptors_class();
     case kStackmapClass: return stackmap_class();
     case kLocalVarDescriptorsClass: return var_descriptors_class();
     case kExceptionHandlersClass: return exception_handlers_class();
+    case kDeoptInfoClass: return deopt_info_class();
     case kContextClass: return context_class();
     case kContextScopeClass: return context_scope_class();
     case kICDataClass: return icdata_class();
     case kSubtypeTestCacheClass: return subtypetestcache_class();
     case kApiErrorClass: return api_error_class();
     case kLanguageErrorClass: return language_error_class();
     case kUnhandledExceptionClass: return unhandled_exception_class();
     case kUnwindErrorClass: return unwind_error_class();
     default: break;
   }
@@ skipping 19 matching lines @@
     case kTokenStreamClass: return "TokenStream";
     case kScriptClass: return "Script";
     case kLibraryClass: return "Library";
     case kLibraryPrefixClass: return "LibraryPrefix";
     case kCodeClass: return "Code";
     case kInstructionsClass: return "Instructions";
     case kPcDescriptorsClass: return "PcDescriptors";
     case kStackmapClass: return "Stackmap";
     case kLocalVarDescriptorsClass: return "LocalVarDescriptors";
     case kExceptionHandlersClass: return "ExceptionHandlers";
+    case kDeoptInfoClass: return "DeoptInfo";
     case kContextClass: return "Context";
     case kContextScopeClass: return "ContextScope";
     case kICDataClass: return "ICData";
     case kSubtypeTestCacheClass: return "SubtypeTestCache";
     case kApiErrorClass: return "ApiError";
     case kLanguageErrorClass: return "LanguageError";
     case kUnhandledExceptionClass: return "UnhandledException";
     case kUnwindErrorClass: return "UnwindError";
     default: break;
   }
@@ skipping 145 matching lines @@
 
   cls = Class::New<Stackmap>();
   stackmap_class_ = cls.raw();
 
   cls = Class::New<LocalVarDescriptors>();
   var_descriptors_class_ = cls.raw();
 
   cls = Class::New<ExceptionHandlers>();
   exception_handlers_class_ = cls.raw();
 
+  cls = Class::New<DeoptInfo>();
+  deopt_info_class_ = cls.raw();
+
   cls = Class::New<Context>();
   context_class_ = cls.raw();
 
   cls = Class::New<ContextScope>();
   context_scope_class_ = cls.raw();
 
   cls = Class::New<ICData>();
   icdata_class_ = cls.raw();
 
   cls = Class::New<SubtypeTestCache>();
@@ skipping 6138 matching lines @@
   return Smi::Value(*SmiAddr(index, kTokenIndexEntry));
 }
 
 
 void PcDescriptors::SetTokenIndex(intptr_t index, intptr_t value) const {
   *SmiAddr(index, kTokenIndexEntry) = Smi::New(value);
 }
 
 
 intptr_t PcDescriptors::TryIndex(intptr_t index) const {
+  ASSERT(DescriptorKind(index) != kDeoptIndex);
+  return *(EntryAddr(index, kTryIndexEntry));
+}
+
+
+intptr_t PcDescriptors::DeoptIndex(intptr_t index) const {
+  ASSERT(DescriptorKind(index) == kDeoptIndex);
   return *(EntryAddr(index, kTryIndexEntry));
 }
 
 
 void PcDescriptors::SetTryIndex(intptr_t index, intptr_t value) const {
   *(EntryAddr(index, kTryIndexEntry)) = value;
 }
 
 
 RawPcDescriptors* PcDescriptors::New(intptr_t num_descriptors) {
@@ skipping 12 matching lines @@
     NoGCScope no_gc;
     result ^= raw;
     result.SetLength(num_descriptors);
   }
   return result.raw();
 }
 
 
 const char* PcDescriptors::KindAsStr(intptr_t index) const {
   switch (DescriptorKind(index)) {
-    case PcDescriptors::kDeopt: return "deopt";
-    case PcDescriptors::kPatchCode: return "patch";
-    case PcDescriptors::kIcCall: return "ic-call";
-    case PcDescriptors::kFuncCall: return "fn-call";
-    case PcDescriptors::kReturn: return "return";
-    case PcDescriptors::kOther: return "other";
+    case PcDescriptors::kDeopt:      return "deopt   ";
+    case PcDescriptors::kDeoptIndex: return "deopt-ix";
+    case PcDescriptors::kPatchCode:  return "patch   ";
+    case PcDescriptors::kIcCall:     return "ic-call ";
+    case PcDescriptors::kFuncCall:   return "fn-call ";
+    case PcDescriptors::kReturn:     return "return  ";
+    case PcDescriptors::kOther:      return "other   ";
   }
   UNREACHABLE();
   return "";
 }
 
 
 const char* PcDescriptors::ToCString() const {
   if (Length() == 0) {
     return "No pc descriptors\n";
   }
   const char* kFormat = "0x%x\t%s\t%ld\t%ld\t%ld\n";
   // First compute the buffer size required.
   intptr_t len = 0;
   for (intptr_t i = 0; i < Length(); i++) {
+    const intptr_t multi_purpose_index = DescriptorKind(i) == kDeoptIndex ?
+        DeoptIndex(i) : TryIndex(i);
     len += OS::SNPrint(NULL, 0, kFormat,
-        PC(i), KindAsStr(i), NodeId(i), TryIndex(i), TokenIndex(i));
+        PC(i), KindAsStr(i), NodeId(i), TokenIndex(i), multi_purpose_index);
   }
   // Allocate the buffer.
   char* buffer = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len + 1));
   // Layout the fields in the buffer.
   intptr_t index = 0;
   for (intptr_t i = 0; i < Length(); i++) {
+    const intptr_t multi_purpose_index = DescriptorKind(i) == kDeoptIndex ?
+        DeoptIndex(i) : TryIndex(i);
     index += OS::SNPrint((buffer + index), (len - index), kFormat,
-        PC(i), KindAsStr(i), NodeId(i), TryIndex(i), TokenIndex(i));
+        PC(i), KindAsStr(i), NodeId(i), TokenIndex(i), multi_purpose_index);
   }
   return buffer;
 }
 
 
 // Verify assumptions (in debug mode only).
 // - No two deopt descriptors have the same node id (deoptimization).
 // - No two ic-call descriptors have the same node id (type feedback).
 // - No two descriptors of same kind have the same PC.
 // A function without unique ids is marked as non-optimizable (e.g., because of
@@ skipping 255 matching lines @@
     index += OS::SNPrint((buffer + index),
                          (len - index),
                          "%ld => 0x%x\n",
                          TryIndex(i),
                          HandlerPC(i));
   }
   return buffer;
 }
 
 
+intptr_t DeoptInfo::Length() const {
+  return Smi::Value(raw_ptr()->length_);
+}
+
+
+intptr_t DeoptInfo::FromIndex(intptr_t index) const {
+  return *(EntryAddr(index, kFromIndex));
+}
+

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

For better readability it might make sense to also have a
intptr_t DeoptInfo::ToIndex(intptr_t index) const {
  return index;
}

method  and use this consistently instead of index directly.

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

Done

+
+intptr_t DeoptInfo::Instruction(intptr_t index) const {
+  return *(EntryAddr(index, kInstruction));
+}
+
+
+const char* DeoptInfo::ToCString() const {
+  if (Length() == 0) {
+    return "No DeoptInfo";
+  }
+  // First compute the buffer size required.
+  intptr_t len = 0;
+  for (intptr_t i = 0; i < Length(); i++) {
+    len += OS::SNPrint(NULL, 0, "[%d(%d):%d]",
+        Instruction(i), FromIndex(i), i);
+  }
+  // Allocate the buffer.
+  char* buffer = reinterpret_cast<char*>(
+      Isolate::Current()->current_zone()->Allocate(len + 1));
+  // Layout the fields in the buffer.
+  intptr_t index = 0;
+  for (intptr_t i = 0; i < Length(); i++) {
+    index += OS::SNPrint((buffer + index),
+                         (len - index),
+                         "[%d(%d):%d]",
+                         Instruction(i),
+                         FromIndex(i),
+                         i);
+  }
+  return buffer;
+}
+
+
+RawDeoptInfo* DeoptInfo::New(intptr_t num_commands) {
+  ASSERT(Object::deopt_info_class() != Class::null());
+  DeoptInfo& result = DeoptInfo::Handle();
+  {
+    uword size = DeoptInfo::InstanceSize(num_commands);
+    RawObject* raw = Object::Allocate(DeoptInfo::kInstanceKind,
+                                      size,
+                                      Heap::kOld);
+    NoGCScope no_gc;
+    result ^= raw;
+    result.SetLength(num_commands);
+  }
+  return result.raw();
+}
+
+
+void DeoptInfo::SetLength(intptr_t value) const {
+  // This is only safe because we create a new Smi, which does not cause
+  // heap allocation.
+  raw_ptr()->length_ = Smi::New(value);
+}
+
+
+void DeoptInfo::SetAt(intptr_t index,
+                      intptr_t instr_kind,
+                      intptr_t from_index) const {
+  *(EntryAddr(index, kInstruction)) = instr_kind;
+  *(EntryAddr(index, kFromIndex)) = from_index;
+}
+
+
 Code::Comments& Code::Comments::New(intptr_t count) {
   Comments* comments;
   if (count < 0 || count > (kIntptrMax / kNumberOfEntries)) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in Code::Comments::New: invalid count %ld\n", count);
   }
   if (count == 0) {
     comments = new Comments(Array::Empty());
   } else {
     comments = new Comments(Array::New(count * kNumberOfEntries));
@@ skipping 36 matching lines @@
 Code::Comments::Comments(RawArray* comments)
     : comments_(Array::Handle(comments)) {
 }
 
 
 void Code::set_stackmaps(const Array& maps) const {
   StorePointer(&raw_ptr()->stackmaps_, maps.raw());
 }
 
 
+void Code::set_deopt_info_array(const Array& array) const {
+  StorePointer(&raw_ptr()->deopt_info_array_, array.raw());
+}
+
+
+void Code::set_object_table(const Array& array) const {
+  StorePointer(&raw_ptr()->object_table_, array.raw());
+}
+
+
 const Code::Comments& Code::comments() const  {
   Comments* comments = new Code::Comments(raw_ptr()->comments_);
   return *comments;
 }
 
 
 void Code::set_comments(const Code::Comments& comments) const {
   StorePointer(&raw_ptr()->comments_, comments.comments_.raw());
 }
 
 
 RawCode* Code::New(intptr_t pointer_offsets_length) {
   if (pointer_offsets_length < 0 || pointer_offsets_length > kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in Code::New: invalid pointer_offsets_length %ld\n",
            pointer_offsets_length);
   }
   ASSERT(Object::code_class() != Class::null());
   Code& result = Code::Handle();
   {
     uword size = Code::InstanceSize(pointer_offsets_length);
     RawObject* raw = Object::Allocate(Code::kInstanceKind, size, Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
     result.set_pointer_offsets_length(pointer_offsets_length);
     result.set_is_optimized(false);
     result.set_comments(Comments::New(0));
+    result.set_deopt_info_array(Array::Handle(Array::Empty()));
+    result.set_object_table(Array::Handle(Array::Empty()));

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

Is there an advantage to initializing these to empty arrays as opposed to
leaving them as null objects?

I am presuming you would have to do a set_deopt_info_array and set_object_table
after generating code for the method at that point you could set them to empty
arrays if there is no deopt info at all for the method.

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

Removed code, setting them to NULL.

   }
   return result.raw();
 }
 
 
 RawCode* Code::FinalizeCode(const char* name, Assembler* assembler) {
   ASSERT(assembler != NULL);
 
   // Allocate the Instructions object.
   Instructions& instrs =
@@ skipping 142 matching lines @@
   const PcDescriptors& descriptors = PcDescriptors::Handle(pc_descriptors());
   for (intptr_t i = 0; i < descriptors.Length(); i++) {
     if (descriptors.DescriptorKind(i) == PcDescriptors::kPatchCode) {
       return descriptors.PC(i);
     }
   }
   return 0;
 }
 
 
-bool Code::ObjectExistInArea(intptr_t start_offset, intptr_t end_offset) const {
+bool Code::ObjectExistsInArea(intptr_t start_offset,
+                              intptr_t end_offset) const {
   for (intptr_t i = 0; i < this->pointer_offsets_length(); i++) {
     const intptr_t offset = this->GetPointerOffsetAt(i);
     if ((start_offset <= offset) && (offset < end_offset)) {
       return false;
     }
   }
   return true;
 }
 
 
@@ skipping 3812 matching lines @@
   const String& str = String::Handle(pattern());
   const char* format = "JSRegExp: pattern=%s flags=%s";
   intptr_t len = OS::SNPrint(NULL, 0, format, str.ToCString(), Flags());
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len + 1));
   OS::SNPrint(chars, (len + 1), format, str.ToCString(), Flags());
   return chars;
 }
 
 }  // namespace dart