First step towards implementing stack map descriptions for the optimizing compiler.

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 "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
@@ skipping 61 matching lines @@
 RawClass* Object::function_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::field_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::literal_token_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::token_stream_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::script_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 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::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::api_error_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::language_error_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::unhandled_exception_class_ =
@@ skipping 38 matching lines @@
   } else if (raw_class == library_class()) {
     return kLibraryClass;
   } else if (raw_class == library_prefix_class()) {
     return kLibraryPrefixClass;
   } else if (raw_class == code_class()) {
     return kCodeClass;
   } 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 == context_class()) {
     return kContextClass;
   } else if (raw_class == context_scope_class()) {
     return kContextScopeClass;
   } else if (raw_class == icdata_class()) {
     return kICDataClass;
@@ skipping 27 matching lines @@
     case kFunctionClass: return function_class();
     case kFieldClass: return field_class();
     case kLiteralTokenClass: return literal_token_class();
     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 kContextClass: return context_class();
     case kContextScopeClass: return context_scope_class();
     case kICDataClass: return icdata_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 18 matching lines @@
     case kInstantiatedTypeArgumentsClass: return "InstantiatedTypeArguments";
     case kFunctionClass: return "Function";
     case kFieldClass: return "Field";
     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 kContextClass: return "Context";
     case kContextScopeClass: return "ContextScope";
     case kICDataClass: return "ICData";
     case kApiErrorClass: return "ApiError";
     case kLanguageErrorClass: return "LanguageError";
     case kUnhandledExceptionClass: return "UnhandledException";
     case kUnwindErrorClass: return "UnwindError";
     default: break;
@@ skipping 123 matching lines @@
 
   cls = Class::New<Code>();
   code_class_ = cls.raw();
 
   cls = Class::New<Instructions>();
   instructions_class_ = cls.raw();
 
   cls = Class::New<PcDescriptors>();
   pc_descriptors_class_ = cls.raw();
 
+  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<Context>();
   context_class_ = cls.raw();
 
   cls = Class::New<ContextScope>();
@@ skipping 4995 matching lines @@
           ASSERT(NodeId(k) != node_id);
         }
         ASSERT(pc != PC(k));
       }
     }
   }
 #endif  // DEBUG
 }
 
 
+// Return the bit offset of the highest bit set.
+intptr_t Stackmap::Maximum() const {
+  intptr_t bound = SizeInBits();
+  for (intptr_t i = (bound - 1); i >= 0; i--) {
+    if (IsObject(i)) return i;
+  }
+  return kNoMaximum;
+}
+
+
+// Return the bit offset of the lowest bit set.
+intptr_t Stackmap::Minimum() const {
+  intptr_t bound = SizeInBits();
+  for (intptr_t i = 0; i < bound; i++) {
+    if (IsObject(i)) return i;
+  }
+  return kNoMinimum;
+}
+
+
+bool Stackmap::GetBit(intptr_t bit_offset) const {
+  ASSERT(InRange(bit_offset));
+  int byte_offset = bit_offset >> kBitsPerByteLog2;
+  int bit_remainder = bit_offset & (kBitsPerByte - 1);
+  uint8_t byte_mask = 1U << bit_remainder;
+  uint8_t byte = raw_ptr()->data_[byte_offset];
+  return (byte & byte_mask);
+}
+
+
+void Stackmap::SetBit(intptr_t bit_offset, bool value) const {
+  ASSERT(InRange(bit_offset));
+  int byte_offset = bit_offset >> kBitsPerByteLog2;
+  int bit_remainder = bit_offset & (kBitsPerByte - 1);
+  uint8_t byte_mask = 1U << bit_remainder;
+  uint8_t* byte_addr = &(raw_ptr()->data_[byte_offset]);
+  if (value) {
+    *byte_addr |= byte_mask;
+  } else {
+    *byte_addr &= ~byte_mask;
+  }
+}
+
+
+RawStackmap* Stackmap::New(uword pc, const Code& code, BitmapBuilder* bmap) {
+  const Class& cls = Class::Handle(Object::stackmap_class());
+  ASSERT(!cls.IsNull());
+  ASSERT(bmap != NULL);
+  Stackmap& result = Stackmap::Handle();
+  intptr_t size = bmap->SizeInBytes();
+  {
+    // Stackmap data objects are associated with a code object, allocate them
+    // in old generation.
+    RawObject* raw =
+        Object::Allocate(cls, Stackmap::InstanceSize(size), Heap::kOld);
+    NoGCScope no_gc;
+    result ^= raw;
+    result.set_bitmap_size_in_bytes(size);
+  }
+  result.set_pc(pc);
+  result.set_code(code);
+  intptr_t bound = bmap->SizeInBits();
+  for (intptr_t i = 0; i < bound; i++) {
+    result.SetBit(i, bmap->Get(i));
+  }
+  return result.raw();
+}
+
+
+void Stackmap::set_bitmap_size_in_bytes(intptr_t value) const {
+  // This is only safe because we create a new Smi, which does not cause
+  // heap allocation.
+  raw_ptr()->bitmap_size_in_bytes_ = Smi::New(value);
+}
+
+
+void Stackmap::set_pc(uword value) const {
+  raw_ptr()->pc_ = value;
+}
+
+
+void Stackmap::set_code(const Code& code) const {
+  StorePointer(&raw_ptr()->code_, code.raw());
+}
+
+
+const char* Stackmap::ToCString() const {
+  if (IsNull()) {
+    return "{null}";
+  } else {
+    intptr_t index = OS::SNPrint(NULL, 0, "0x%lx { ", pc());
+    intptr_t alloc_size = index + ((Maximum() + 1) * 2) + 2;  // "{ 1 0 .... }".
+    Isolate* isolate = Isolate::Current();
+    char* chars = reinterpret_cast<char*>(
+        isolate->current_zone()->Allocate(alloc_size));
+    index = OS::SNPrint(chars, alloc_size, "0x%lx { ", pc());
+    for (intptr_t i = 0; i <= Maximum(); i++) {
+      index += OS::SNPrint((chars + index),
+                           (alloc_size - index),
+                           "%d ",
+                           IsObject(i) ? 1 : 0);
+    }
+    OS::SNPrint((chars + index), (alloc_size - index), "}");
+    return chars;
+  }
+}
+
+
 RawString* LocalVarDescriptors::GetName(intptr_t var_index) const {
   ASSERT(var_index < Length());
   const Array& names = Array::Handle(raw_ptr()->names_);
   ASSERT(Length() == names.Length());
   const String& name = String::CheckedHandle(names.At(var_index));
   return name.raw();
 }
 
 
 void LocalVarDescriptors::GetScopeInfo(
@@ skipping 3393 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