Make sure all new Code objects have a non-null PcDescriptors

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 71 matching lines @@
 #if defined(RAW_NULL)
 #error RAW_NULL should not be defined.
 #endif
 #define RAW_NULL kHeapObjectTag
 Object* Object::null_object_ = NULL;
 Array* Object::null_array_ = NULL;
 String* Object::null_string_ = NULL;
 Instance* Object::null_instance_ = NULL;
 AbstractTypeArguments* Object::null_abstract_type_arguments_ = NULL;
 Array* Object::empty_array_ = NULL;
+PcDescriptors* Object::empty_descriptors_ = 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 326 matching lines @@
   Isolate* isolate = Isolate::Current();
   Heap* heap = isolate->heap();
 
   // Allocate the read only object handles here.
   null_object_ = Object::ReadOnlyHandle();
   null_array_ = Array::ReadOnlyHandle();
   null_string_ = String::ReadOnlyHandle();
   null_instance_ = Instance::ReadOnlyHandle();
   null_abstract_type_arguments_ = AbstractTypeArguments::ReadOnlyHandle();
   empty_array_ = Array::ReadOnlyHandle();
+  empty_descriptors_ = PcDescriptors::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 190 matching lines @@
   // Allocate and initialize the empty_array instance.
   {
     uword address = heap->Allocate(Array::InstanceSize(0), Heap::kOld);
     InitializeObject(address, kArrayCid, Array::InstanceSize(0));
     Array::initializeHandle(
         empty_array_,
         reinterpret_cast<RawArray*>(address + kHeapObjectTag));
     empty_array_->raw()->ptr()->length_ = Smi::New(0);
   }
 
+  // Allocate and initialize the empty_descriptors instance.
+  {
+    uword address = heap->Allocate(PcDescriptors::InstanceSize(0), Heap::kOld);
+    InitializeObject(address, kPcDescriptorsCid,
+                     PcDescriptors::InstanceSize(0));
+    PcDescriptors::initializeHandle(
+        empty_descriptors_,
+        reinterpret_cast<RawPcDescriptors*>(address + kHeapObjectTag));
+    empty_descriptors_->raw()->ptr()->length_ = Smi::New(0);

[Ivan Posva, 2014/01/21 06:36:05]

Can't you use raw_ptr() instead of raw()->ptr()?
Same above when initializing the empty_array.

[Cutch, 2014/01/21 15:49:58]

Done here and above.

+  }
+
+
   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 9217 matching lines @@
   Code& result = Code::Handle();
   {
     uword size = Code::InstanceSize(pointer_offsets_length);
     RawObject* raw = Object::Allocate(Code::kClassId, size, Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
     result.set_pointer_offsets_length(pointer_offsets_length);
     result.set_is_optimized(false);
     result.set_is_alive(true);
     result.set_comments(Comments::New(0));
+    result.set_pc_descriptors(Object::empty_descriptors());
   }
   return result.raw();
 }
 
 
 RawCode* Code::FinalizeCode(const char* name,
                             Assembler* assembler,
                             bool optimized) {
   ASSERT(assembler != NULL);
 
@@ skipping 7079 matching lines @@
   return "_MirrorReference";
 }
 
 
 void MirrorReference::PrintToJSONStream(JSONStream* stream, bool ref) const {
   Instance::PrintToJSONStream(stream, ref);
 }
 
 
 }  // namespace dart