Make sure that ICData always contains valid data (non-null values).

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 8846 matching lines @@
   const intptr_t num_checks = NumberOfChecks();
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, name.ToCString(),
       num_args, num_checks) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, name.ToCString(), num_args, num_checks);
   return chars;
 }
 
 
 void ICData::set_function(const Function& value) const {
+  ASSERT(!value.IsNull());
   StorePointer(&raw_ptr()->function_, value.raw());
 }
 
 
 void ICData::set_target_name(const String& value) const {
+  ASSERT(!value.IsNull());
   StorePointer(&raw_ptr()->target_name_, value.raw());
 }
 
 
 void ICData::set_arguments_descriptor(const Array& value) const {
+  ASSERT(!value.IsNull());
   StorePointer(&raw_ptr()->args_descriptor_, value.raw());
 }
 
 void ICData::set_deopt_id(intptr_t value) const {
   raw_ptr()->deopt_id_ = value;
 }
 
 
 void ICData::set_num_args_tested(intptr_t value) const {
   raw_ptr()->num_args_tested_ = value;
 }
 
 
 void ICData::set_ic_data(const Array& value) const {
+  ASSERT(!value.IsNull());
   StorePointer(&raw_ptr()->ic_data_, value.raw());
 }
 
 
 void ICData::set_deopt_reason(intptr_t deopt_reason) const {
   raw_ptr()->deopt_reason_ = deopt_reason;
 }
 
 void ICData::set_is_closure_call(bool value) const {
   raw_ptr()->is_closure_call_ = value ? 1 : 0;
@@ skipping 10 matching lines @@
 }
 
 
 intptr_t ICData::NumberOfChecks() const {
   // Do not count the sentinel;
   return (Array::Handle(ic_data()).Length() / TestEntryLength()) - 1;
 }
 
 
 void ICData::WriteSentinel(const Array& data) const {
+  ASSERT(!data.IsNull());
   for (intptr_t i = 1; i <= TestEntryLength(); i++) {
     data.SetAt(data.Length() - i, smi_illegal_cid());
   }
 }
 
 
 #if defined(DEBUG)
 // Used in asserts to verify that a check is not added twice.
 bool ICData::HasCheck(const GrowableArray<intptr_t>& cids) const {
   const intptr_t len = NumberOfChecks();
@@ skipping 12 matching lines @@
       return true;
     }
   }
   return false;
 }
 #endif  // DEBUG
 
 
 // Used for unoptimized static calls when no class-ids are checked.
 void ICData::AddTarget(const Function& target) const {
+  ASSERT(!target.IsNull());
   if (num_args_tested() > 0) {
     // Create a fake cid entry, so that we can store the target.
     GrowableArray<intptr_t> class_ids(num_args_tested());
     for (intptr_t i = 0; i < num_args_tested(); i++) {
       class_ids.Add(kObjectCid);
     }
     AddCheck(class_ids, target);
     return;
   }
   ASSERT(num_args_tested() >= 0);
   // Can add only once.
   const intptr_t old_num = NumberOfChecks();
   ASSERT(old_num == 0);
   Array& data = Array::Handle(ic_data());
   const intptr_t new_len = data.Length() + TestEntryLength();
   data = Array::Grow(data, new_len, Heap::kOld);
   set_ic_data(data);
   WriteSentinel(data);
   intptr_t data_pos = old_num * TestEntryLength();
   ASSERT(!target.IsNull());
   data.SetAt(data_pos++, target);
   const Smi& value = Smi::Handle(Smi::New(0));
   data.SetAt(data_pos, value);
 }
 
 
 void ICData::AddCheck(const GrowableArray<intptr_t>& class_ids,
                       const Function& target) const {
+  ASSERT(!target.IsNull());
   DEBUG_ASSERT(!HasCheck(class_ids));
   ASSERT(num_args_tested() > 1);  // Otherwise use 'AddReceiverCheck'.
   ASSERT(class_ids.length() == num_args_tested());
   const intptr_t old_num = NumberOfChecks();
   Array& data = Array::Handle(ic_data());
   // ICData of static calls with num_args_tested() > 0 have initially a
   // dummy set of cids entered (see ICData::AddTarget). That entry is
   // overwritten by first real type feedback data.
   if (old_num == 1) {
     bool has_dummy_entry = true;
@@ skipping 35 matching lines @@
 
 
 void ICData::AddReceiverCheck(intptr_t receiver_class_id,
                               const Function& target,
                               intptr_t count) const {
 #if defined(DEBUG)
   GrowableArray<intptr_t> class_ids(1);
   class_ids.Add(receiver_class_id);
   ASSERT(!HasCheck(class_ids));
 #endif  // DEBUG
+  ASSERT(!target.IsNull());
   ASSERT(num_args_tested() == 1);  // Otherwise use 'AddCheck'.
   ASSERT(receiver_class_id != kIllegalCid);
 
   const intptr_t old_num = NumberOfChecks();
   Array& data = Array::Handle(ic_data());
   const intptr_t new_len = data.Length() + TestEntryLength();
   data = Array::Grow(data, new_len, Heap::kOld);
   set_ic_data(data);
   WriteSentinel(data);
   intptr_t data_pos = old_num * TestEntryLength();
@@ skipping 216 matching lines @@
   }
   return true;
 }
 
 
 RawICData* ICData::New(const Function& function,
                        const String& target_name,
                        const Array& arguments_descriptor,
                        intptr_t deopt_id,
                        intptr_t num_args_tested) {
+  ASSERT(!function.IsNull());
+  ASSERT(!target_name.IsNull());
+  ASSERT(!arguments_descriptor.IsNull());
   ASSERT(Object::icdata_class() != Class::null());
   ASSERT(num_args_tested >= 0);
   ICData& result = ICData::Handle();
   {
     // IC data objects are long living objects, allocate them in old generation.
     RawObject* raw = Object::Allocate(ICData::kClassId,
                                       ICData::InstanceSize(),
                                       Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
@@ skipping 5086 matching lines @@
 }
 
 
 void MirrorReference::PrintToJSONStream(JSONStream* stream, bool ref) const {
   stream->OpenObject();
   stream->CloseObject();
 }
 
 
 }  // namespace dart