Eliminate 99% of allocated ExceptionHandler objects

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/cpu.h"
@@ skipping 81 matching lines @@
 #define RAW_NULL kHeapObjectTag
 Object* Object::null_object_ = NULL;
 Array* Object::null_array_ = NULL;
 String* Object::null_string_ = NULL;
 Instance* Object::null_instance_ = NULL;
 TypeArguments* Object::null_type_arguments_ = NULL;
 Array* Object::empty_array_ = NULL;
 Array* Object::zero_array_ = NULL;
 PcDescriptors* Object::empty_descriptors_ = NULL;
 LocalVarDescriptors* Object::empty_var_descriptors_ = NULL;
+ExceptionHandlers* Object::empty_exception_handlers_ = NULL;
 Instance* Object::sentinel_ = NULL;
 Instance* Object::transition_sentinel_ = NULL;
 Instance* Object::unknown_constant_ = NULL;
 Instance* Object::non_constant_ = NULL;
 Bool* Object::bool_true_ = NULL;
 Bool* Object::bool_false_ = NULL;
 Smi* Object::smi_illegal_cid_ = NULL;
 LanguageError* Object::snapshot_writer_error_ = NULL;
 LanguageError* Object::branch_offset_error_ = NULL;
 
@@ skipping 318 matching lines @@
   // Allocate the read only object handles here.
   null_object_ = Object::ReadOnlyHandle();
   null_array_ = Array::ReadOnlyHandle();
   null_string_ = String::ReadOnlyHandle();
   null_instance_ = Instance::ReadOnlyHandle();
   null_type_arguments_ = TypeArguments::ReadOnlyHandle();
   empty_array_ = Array::ReadOnlyHandle();
   zero_array_ = Array::ReadOnlyHandle();
   empty_descriptors_ = PcDescriptors::ReadOnlyHandle();
   empty_var_descriptors_ = LocalVarDescriptors::ReadOnlyHandle();
+  empty_exception_handlers_ = ExceptionHandlers::ReadOnlyHandle();
   sentinel_ = Instance::ReadOnlyHandle();
   transition_sentinel_ = Instance::ReadOnlyHandle();
   unknown_constant_ =  Instance::ReadOnlyHandle();
   non_constant_ =  Instance::ReadOnlyHandle();
   bool_true_ = Bool::ReadOnlyHandle();
   bool_false_ = Bool::ReadOnlyHandle();
   smi_illegal_cid_ = Smi::ReadOnlyHandle();
   snapshot_writer_error_ = LanguageError::ReadOnlyHandle();
   branch_offset_error_ = LanguageError::ReadOnlyHandle();
 
@@ skipping 223 matching lines @@
         heap->Allocate(LocalVarDescriptors::InstanceSize(0), Heap::kOld);
     InitializeObject(address,
                      kLocalVarDescriptorsCid,
                      LocalVarDescriptors::InstanceSize(0));
     LocalVarDescriptors::initializeHandle(
         empty_var_descriptors_,
         reinterpret_cast<RawLocalVarDescriptors*>(address + kHeapObjectTag));
     empty_var_descriptors_->raw_ptr()->num_entries_ = 0;
   }
 
+  // Allocate and initialize the canonical empty exception handler info object.
+  // The vast majority of all functions do not contain an exception handler
+  // and can share this canonical descriptor.
+  {
+    uword address =
+        heap->Allocate(ExceptionHandlers::InstanceSize(0), Heap::kOld);
+    InitializeObject(address,
+                     kExceptionHandlersCid,
+                     ExceptionHandlers::InstanceSize(0));
+    ExceptionHandlers::initializeHandle(
+        empty_exception_handlers_,
+        reinterpret_cast<RawExceptionHandlers*>(address + kHeapObjectTag));
+    empty_exception_handlers_->raw_ptr()->num_entries_ = 0;
+  }
+
   cls = Class::New<Instance>(kDynamicCid);
   cls.set_is_abstract();
   cls.set_num_type_arguments(0);
   cls.set_num_own_type_arguments(0);
   cls.set_is_type_finalized();
   cls.set_is_finalized();
   dynamic_class_ = cls.raw();
 
   cls = Class::New<Instance>(kVoidCid);
   cls.set_num_type_arguments(0);
@@ skipping 10290 matching lines @@
   }
   return result.raw();
 }
 
 
 intptr_t LocalVarDescriptors::Length() const {
   return raw_ptr()->num_entries_;
 }
 
 
-intptr_t ExceptionHandlers::Length() const {
-  return raw_ptr()->length_;
+intptr_t ExceptionHandlers::num_entries() const {
+  return raw_ptr()->num_entries_;
 }
 
 
 void ExceptionHandlers::SetHandlerInfo(intptr_t try_index,
                                        intptr_t outer_try_index,
                                        intptr_t handler_pc,
                                        bool needs_stacktrace,
                                        bool has_catch_all) const {
-  ASSERT((try_index >= 0) && (try_index < Length()));
+  ASSERT((try_index >= 0) && (try_index < num_entries()));
   RawExceptionHandlers::HandlerInfo* info = &raw_ptr()->data()[try_index];
   info->outer_try_index = outer_try_index;
   info->handler_pc = handler_pc;
   info->needs_stacktrace = needs_stacktrace;
   info->has_catch_all = has_catch_all;
 }
 
 void ExceptionHandlers::GetHandlerInfo(
     intptr_t try_index,
     RawExceptionHandlers::HandlerInfo* info) const {
-  ASSERT((try_index >= 0) && (try_index < Length()));
+  ASSERT((try_index >= 0) && (try_index < num_entries()));
   ASSERT(info != NULL);
   *info = raw_ptr()->data()[try_index];
 }
 
 
 intptr_t ExceptionHandlers::HandlerPC(intptr_t try_index) const {
-  ASSERT((try_index >= 0) && (try_index < Length()));
+  ASSERT((try_index >= 0) && (try_index < num_entries()));
   return raw_ptr()->data()[try_index].handler_pc;
 }
 
 
 intptr_t ExceptionHandlers::OuterTryIndex(intptr_t try_index) const {
-  ASSERT((try_index >= 0) && (try_index < Length()));
+  ASSERT((try_index >= 0) && (try_index < num_entries()));
   return raw_ptr()->data()[try_index].outer_try_index;
 }
 
 
 bool ExceptionHandlers::NeedsStacktrace(intptr_t try_index) const {
-  ASSERT((try_index >= 0) && (try_index < Length()));
+  ASSERT((try_index >= 0) && (try_index < num_entries()));
   return raw_ptr()->data()[try_index].needs_stacktrace;
 }
 
 
 bool ExceptionHandlers::HasCatchAll(intptr_t try_index) const {
-  ASSERT((try_index >= 0) && (try_index < Length()));
+  ASSERT((try_index >= 0) && (try_index < num_entries()));
   return raw_ptr()->data()[try_index].has_catch_all;
 }
 
 
 void ExceptionHandlers::SetHandledTypes(intptr_t try_index,
                                         const Array& handled_types) const {
-  ASSERT((try_index >= 0) && (try_index < Length()));
+  ASSERT((try_index >= 0) && (try_index < num_entries()));
   const Array& handled_types_data =
       Array::Handle(raw_ptr()->handled_types_data_);
   handled_types_data.SetAt(try_index, handled_types);
 }
 
 
 RawArray* ExceptionHandlers::GetHandledTypes(intptr_t try_index) const {
-  ASSERT((try_index >= 0) && (try_index < Length()));
+  ASSERT((try_index >= 0) && (try_index < num_entries()));
   Array& array = Array::Handle(raw_ptr()->handled_types_data_);
   array ^= array.At(try_index);
   return array.raw();
 }
 
 
 void ExceptionHandlers::set_handled_types_data(const Array& value) const {
   StorePointer(&raw_ptr()->handled_types_data_, value.raw());
 }
 
 
 RawExceptionHandlers* ExceptionHandlers::New(intptr_t num_handlers) {
   ASSERT(Object::exception_handlers_class() != Class::null());
   if ((num_handlers < 0) || (num_handlers >= kMaxHandlers)) {
     FATAL1("Fatal error in ExceptionHandlers::New(): "
            "invalid num_handlers %" Pd "\n",
            num_handlers);
   }
   ExceptionHandlers& result = ExceptionHandlers::Handle();
   {
     uword size = ExceptionHandlers::InstanceSize(num_handlers);
     RawObject* raw = Object::Allocate(ExceptionHandlers::kClassId,
                                       size,
                                       Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
-    result.raw_ptr()->length_ = num_handlers;
+    result.raw_ptr()->num_entries_ = num_handlers;
   }
   const Array& handled_types_data = (num_handlers == 0) ?
       Object::empty_array() :
       Array::Handle(Array::New(num_handlers));
   result.set_handled_types_data(handled_types_data);
   return result.raw();
 }
 
 
 const char* ExceptionHandlers::ToCString() const {
-  if (Length() == 0) {
+  if (num_entries() == 0) {
     return "No exception handlers\n";
   }
   Array& handled_types = Array::Handle();
   Type& type = Type::Handle();
   RawExceptionHandlers::HandlerInfo info;
   // First compute the buffer size required.
   const char* kFormat = "%" Pd " => %#" Px "  (%" Pd
                         " types) (outer %" Pd ")\n";
   const char* kFormat2 = "  %d. %s\n";
   intptr_t len = 1;  // Trailing '\0'.
-  for (intptr_t i = 0; i < Length(); i++) {
+  for (intptr_t i = 0; i < num_entries(); i++) {
     GetHandlerInfo(i, &info);
     handled_types = GetHandledTypes(i);
     ASSERT(!handled_types.IsNull());
     const intptr_t num_types = handled_types.Length();
     len += OS::SNPrint(NULL, 0, kFormat,
                        i,
                        info.handler_pc,
                        num_types,
                        info.outer_try_index);
     for (int k = 0; k < num_types; k++) {
       type ^= handled_types.At(k);
       ASSERT(!type.IsNull());
       len += OS::SNPrint(NULL, 0, kFormat2, k, type.ToCString());
     }
   }
   // Allocate the buffer.
   char* buffer = Isolate::Current()->current_zone()->Alloc<char>(len);
   // Layout the fields in the buffer.
   intptr_t num_chars = 0;
-  for (intptr_t i = 0; i < Length(); i++) {
+  for (intptr_t i = 0; i < num_entries(); i++) {
     GetHandlerInfo(i, &info);
     handled_types = GetHandledTypes(i);
     const intptr_t num_types = handled_types.Length();
     num_chars += OS::SNPrint((buffer + num_chars),
                              (len - num_chars),
                              kFormat,
                              i,
                              info.handler_pc,
                              num_types,
                              info.outer_try_index);
@@ skipping 9200 matching lines @@
   return tag_label.ToCString();
 }
 
 
 void UserTag::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 }  // namespace dart