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

runtime/vm/flow_graph_optimizer.cc

 // Copyright (c) 2013, 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/flow_graph_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 115 matching lines @@
     if (function.IsNull()) {
       return false;
     }
     // Create new ICData, do not modify the one attached to the instruction
     // since it is attached to the assembly instruction itself.
     // TODO(srdjan): Prevent modification of ICData object that is
     // referenced in assembly code.
     ICData& ic_data = ICData::ZoneHandle(ICData::New(
         flow_graph_->parsed_function().function(),
         call->function_name(),
-        Object::null_array(),  // Dummy argument descriptor.
+        Object::empty_array(),  // Dummy argument descriptor.
         call->deopt_id(),
         class_ids.length()));
     ic_data.AddReceiverCheck(class_ids[0], function);
     call->set_ic_data(&ic_data);
     return true;
   }
   return false;
 }
 
 
 static const ICData& SpecializeICData(const ICData& ic_data, intptr_t cid) {
   ASSERT(ic_data.num_args_tested() == 1);
 
   if ((ic_data.NumberOfChecks() == 1) &&
       (ic_data.GetReceiverClassIdAt(0) == cid)) {
     return ic_data;  // Nothing to do
   }
 
   const ICData& new_ic_data = ICData::ZoneHandle(ICData::New(
       Function::Handle(ic_data.function()),
       String::Handle(ic_data.target_name()),
-      Object::null_array(),  // Dummy argument descriptor.
+      Object::empty_array(),  // Dummy argument descriptor.
       ic_data.deopt_id(),
       ic_data.num_args_tested()));
 
   const Function& function =
       Function::Handle(ic_data.GetTargetForReceiverClassId(cid));
   if (!function.IsNull()) {
     new_ic_data.AddReceiverCheck(cid, function);
   }
 
   return new_ic_data;
@@ skipping 1736 matching lines @@
             call, class_ids[0], kTypedDataFloat32ArrayCid);
       case MethodRecognizer::kByteArrayBaseGetFloat64:
         return BuildByteArrayViewLoad(
             call, class_ids[0], kTypedDataFloat64ArrayCid);
       case MethodRecognizer::kByteArrayBaseGetFloat32x4:
         return BuildByteArrayViewLoad(
             call, class_ids[0], kTypedDataFloat32x4ArrayCid);
 
       // ByteArray setters.
       case MethodRecognizer::kByteArrayBaseSetInt8:
-        return BuildByteArrayViewStore(
-            call, class_ids[0], kTypedDataInt8ArrayCid);
+        return BuildByteArrayViewStore(call, kTypedDataInt8ArrayCid);
       case MethodRecognizer::kByteArrayBaseSetUint8:
-        return BuildByteArrayViewStore(
-            call, class_ids[0], kTypedDataUint8ArrayCid);
+        return BuildByteArrayViewStore(call, kTypedDataUint8ArrayCid);
       case MethodRecognizer::kByteArrayBaseSetInt16:
-        return BuildByteArrayViewStore(
-            call, class_ids[0], kTypedDataInt16ArrayCid);
+        return BuildByteArrayViewStore(call, kTypedDataInt16ArrayCid);
       case MethodRecognizer::kByteArrayBaseSetUint16:
-        return BuildByteArrayViewStore(
-            call, class_ids[0], kTypedDataUint16ArrayCid);
+        return BuildByteArrayViewStore(call, kTypedDataUint16ArrayCid);
       case MethodRecognizer::kByteArrayBaseSetInt32:
-        return BuildByteArrayViewStore(
-            call, class_ids[0], kTypedDataInt32ArrayCid);
+        return BuildByteArrayViewStore(call, kTypedDataInt32ArrayCid);
       case MethodRecognizer::kByteArrayBaseSetUint32:
-        return BuildByteArrayViewStore(
-            call, class_ids[0], kTypedDataUint32ArrayCid);
+        return BuildByteArrayViewStore(call, kTypedDataUint32ArrayCid);
       case MethodRecognizer::kByteArrayBaseSetFloat32:
-        return BuildByteArrayViewStore(
-            call, class_ids[0], kTypedDataFloat32ArrayCid);
+        return BuildByteArrayViewStore(call, kTypedDataFloat32ArrayCid);
       case MethodRecognizer::kByteArrayBaseSetFloat64:
-        return BuildByteArrayViewStore(
-            call, class_ids[0], kTypedDataFloat64ArrayCid);
+        return BuildByteArrayViewStore(call, kTypedDataFloat64ArrayCid);
       case MethodRecognizer::kByteArrayBaseSetFloat32x4:
-        return BuildByteArrayViewStore(
-            call, class_ids[0], kTypedDataFloat32x4ArrayCid);
+        return BuildByteArrayViewStore(call, kTypedDataFloat32x4ArrayCid);
       default:
         // Unsupported method.
         return false;
     }
   }
 
   if ((class_ids[0] == kFloat32x4Cid) && (ic_data.NumberOfChecks() == 1)) {
     return TryInlineFloat32x4Method(call, recognized_kind);
   }
 
@@ skipping 305 matching lines @@
   LoadIndexedInstr* array_op = new LoadIndexedInstr(new Value(array),
                                                     new Value(byte_index),
                                                     1,  // Index scale.
                                                     view_cid,
                                                     deopt_id);
   ReplaceCall(call, array_op);
   return true;
 }
 
 
-bool FlowGraphOptimizer::BuildByteArrayViewStore(
-    InstanceCallInstr* call,
-    intptr_t receiver_cid,
-    intptr_t view_cid) {
+bool FlowGraphOptimizer::BuildByteArrayViewStore(InstanceCallInstr* call,
+                                                 intptr_t view_cid) {
   if ((view_cid == kTypedDataFloat32x4ArrayCid) && !ShouldInlineSimd()) {
     return false;
   }
+  ASSERT(call->HasICData());
+  Function& target = Function::Handle();
+  GrowableArray<intptr_t> class_ids;
+  call->ic_data()->GetCheckAt(0, &class_ids, &target);
+  const intptr_t receiver_cid = class_ids[0];
+
   Definition* array = call->ArgumentAt(0);
   PrepareByteArrayViewOp(call, receiver_cid, view_cid, &array);
   ICData& value_check = ICData::ZoneHandle();
   switch (view_cid) {
     case kTypedDataInt8ArrayCid:
     case kTypedDataUint8ArrayCid:
     case kTypedDataUint8ClampedArrayCid:
     case kExternalTypedDataUint8ArrayCid:
     case kExternalTypedDataUint8ClampedArrayCid:
     case kTypedDataInt16ArrayCid:
     case kTypedDataUint16ArrayCid: {
       // Check that value is always smi.
-      value_check = ICData::New(Function::Handle(),
-                                Object::null_string(),
-                                Object::null_array(),
+      value_check = ICData::New(flow_graph_->parsed_function().function(),
+                                call->function_name(),
+                                Object::empty_array(),  // Dummy args. descr.
                                 Isolate::kNoDeoptId,
                                 1);
-      value_check.AddReceiverCheck(kSmiCid, Function::Handle());
+      value_check.AddReceiverCheck(kSmiCid, target);
       break;
     }
     case kTypedDataInt32ArrayCid:
     case kTypedDataUint32ArrayCid:
       // We don't have ICData for the value stored, so we optimistically assume
       // smis first. If we ever deoptimized here, we require to unbox the value
       // before storing to handle the mint case, too.
       if (call->ic_data()->deopt_reason() == kDeoptUnknown) {
-        value_check = ICData::New(Function::Handle(),
-                                  Object::null_string(),
-                                  Object::null_array(),  // Dummy args. descr.
+        value_check = ICData::New(flow_graph_->parsed_function().function(),
+                                  call->function_name(),
+                                  Object::empty_array(),  // Dummy args. descr.
                                   Isolate::kNoDeoptId,
                                   1);
-        value_check.AddReceiverCheck(kSmiCid, Function::Handle());
+        value_check.AddReceiverCheck(kSmiCid, target);
       }
       break;
     case kTypedDataFloat32ArrayCid:
     case kTypedDataFloat64ArrayCid: {
       // Check that value is always double.
-      value_check = ICData::New(Function::Handle(),
-                                Object::null_string(),
-                                Object::null_array(),  // Dummy args. descr.
+      value_check = ICData::New(flow_graph_->parsed_function().function(),
+                                call->function_name(),
+                                Object::empty_array(),  // Dummy args. descr.
                                 Isolate::kNoDeoptId,
                                 1);
-      value_check.AddReceiverCheck(kDoubleCid, Function::Handle());
+      value_check.AddReceiverCheck(kDoubleCid, target);
       break;
     }
     case kTypedDataFloat32x4ArrayCid: {
       // Check that value is always Float32x4.
-      value_check = ICData::New(Function::Handle(),
-                                Object::null_string(),
-                                Object::null_array(),  // Dummy args. descr.
+      value_check = ICData::New(flow_graph_->parsed_function().function(),
+                                call->function_name(),
+                                Object::empty_array(),  // Dummy args. descr.
                                 Isolate::kNoDeoptId,
                                 1);
-      value_check.AddReceiverCheck(kFloat32x4Cid, Function::Handle());
+      value_check.AddReceiverCheck(kFloat32x4Cid, target);
       break;
     }
     default:
       // Array cids are already checked in the caller.
       UNREACHABLE();
   }
 
   Definition* index = call->ArgumentAt(1);
   Definition* stored_value = call->ArgumentAt(2);
   if (!value_check.IsNull()) {
@@ skipping 5007 matching lines @@
 
   // Insert materializations at environment uses.
   const Class& cls = Class::Handle(alloc->constructor().Owner());
   for (intptr_t i = 0; i < exits.length(); i++) {
     CreateMaterializationAt(exits[i], alloc, cls, *fields);
   }
 }
 
 
 }  // namespace dart