Remove instantiator argument in generated code for type tests.

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/compiler.h"
 #include "vm/cpu.h"
@@ skipping 1285 matching lines @@
   *entry = new(Z) TargetEntryInstr(flow_graph()->allocate_block_id(),
                                    call->GetBlock()->try_index());
   (*entry)->InheritDeoptTarget(Z, call);
   Instruction* cursor = *entry;
   if (I->flags().type_checks()) {
     // Only type check for the value. A type check for the index is not
     // needed here because we insert a deoptimizing smi-check for the case
     // the index is not a smi.
     const AbstractType& value_type =
         AbstractType::ZoneHandle(Z, target.ParameterTypeAt(2));
-    Definition* instantiator = NULL;
     Definition* type_args = NULL;
     switch (array_cid) {
       case kArrayCid:
       case kGrowableObjectArrayCid: {
         const Class& instantiator_class =  Class::Handle(Z, target.Owner());
         intptr_t type_arguments_field_offset =
             instantiator_class.type_arguments_field_offset();
         LoadFieldInstr* load_type_args =
             new(Z) LoadFieldInstr(new(Z) Value(array),
                                   type_arguments_field_offset,
                                   Type::ZoneHandle(Z),  // No type.
                                   call->token_pos());
         cursor = flow_graph()->AppendTo(cursor,
                                         load_type_args,
                                         NULL,
                                         FlowGraph::kValue);
 
-        instantiator = array;
         type_args = load_type_args;
         break;
       }
       case kTypedDataInt8ArrayCid:
       case kTypedDataUint8ArrayCid:
       case kTypedDataUint8ClampedArrayCid:
       case kExternalTypedDataUint8ArrayCid:
       case kExternalTypedDataUint8ClampedArrayCid:
       case kTypedDataInt16ArrayCid:
       case kTypedDataUint16ArrayCid:
       case kTypedDataInt32ArrayCid:
       case kTypedDataUint32ArrayCid:
       case kTypedDataInt64ArrayCid:
         ASSERT(value_type.IsIntType());
         // Fall through.
       case kTypedDataFloat32ArrayCid:
       case kTypedDataFloat64ArrayCid: {
-        type_args = instantiator = flow_graph_->constant_null();
+        type_args = flow_graph_->constant_null();
         ASSERT((array_cid != kTypedDataFloat32ArrayCid &&
                 array_cid != kTypedDataFloat64ArrayCid) ||
                value_type.IsDoubleType());
         ASSERT(value_type.IsInstantiated());
         break;
       }
       case kTypedDataFloat32x4ArrayCid: {
-        type_args = instantiator = flow_graph_->constant_null();
+        type_args = flow_graph_->constant_null();
         ASSERT((array_cid != kTypedDataFloat32x4ArrayCid) ||
                value_type.IsFloat32x4Type());
         ASSERT(value_type.IsInstantiated());
         break;
       }
       case kTypedDataFloat64x2ArrayCid: {
-        type_args = instantiator = flow_graph_->constant_null();
+        type_args = flow_graph_->constant_null();
         ASSERT((array_cid != kTypedDataFloat64x2ArrayCid) ||
                value_type.IsFloat64x2Type());
         ASSERT(value_type.IsInstantiated());
         break;
       }
       default:
         // TODO(fschneider): Add support for other array types.
         UNREACHABLE();
     }
     AssertAssignableInstr* assert_value =
         new(Z) AssertAssignableInstr(token_pos,
                                      new(Z) Value(stored_value),
-                                     new(Z) Value(instantiator),
                                      new(Z) Value(type_args),
                                      value_type,
                                      Symbols::Value(),
                                      call->deopt_id());
     cursor = flow_graph()->AppendTo(cursor,
                                     assert_value,
                                     call->env(),
                                     FlowGraph::kValue);
   }
 
@@ skipping 2663 matching lines @@
   }
 
   return true;  // May deoptimize since we have not identified all 'true' tests.
 }
 
 
 // TODO(srdjan): Use ICData to check if always true or false.
 void FlowGraphOptimizer::ReplaceWithInstanceOf(InstanceCallInstr* call) {
   ASSERT(Token::IsTypeTestOperator(call->token_kind()));
   Definition* left = call->ArgumentAt(0);
-  Definition* instantiator = NULL;
   Definition* type_args = NULL;
   AbstractType& type = AbstractType::ZoneHandle(Z);
   bool negate = false;
   if (call->ArgumentCount() == 2) {
-    instantiator = flow_graph()->constant_null();
     type_args = flow_graph()->constant_null();
     if (call->function_name().raw() ==
         Library::PrivateCoreLibName(Symbols::_instanceOfNum()).raw()) {
       type = Type::Number();
     } else if (call->function_name().raw() ==
         Library::PrivateCoreLibName(Symbols::_instanceOfInt()).raw()) {
       type = Type::IntType();
     } else if (call->function_name().raw() ==
         Library::PrivateCoreLibName(Symbols::_instanceOfSmi()).raw()) {
       type = Type::SmiType();
     } else if (call->function_name().raw() ==
         Library::PrivateCoreLibName(Symbols::_instanceOfDouble()).raw()) {
       type = Type::Double();
     } else if (call->function_name().raw() ==
         Library::PrivateCoreLibName(Symbols::_instanceOfString()).raw()) {
       type = Type::StringType();
     } else {
       UNIMPLEMENTED();
     }
     negate = Bool::Cast(call->ArgumentAt(1)->OriginalDefinition()
         ->AsConstant()->value()).value();
   } else {
-    instantiator = call->ArgumentAt(1);
-    type_args = call->ArgumentAt(2);
-    type = AbstractType::Cast(call->ArgumentAt(3)->AsConstant()->value()).raw();
-    negate = Bool::Cast(call->ArgumentAt(4)->OriginalDefinition()
+    type_args = call->ArgumentAt(1);
+    type = AbstractType::Cast(call->ArgumentAt(2)->AsConstant()->value()).raw();
+    negate = Bool::Cast(call->ArgumentAt(3)->OriginalDefinition()
         ->AsConstant()->value()).value();
   }
   const ICData& unary_checks =
       ICData::ZoneHandle(Z, call->ic_data()->AsUnaryClassChecks());
   if (FLAG_warn_on_javascript_compatibility &&
       !unary_checks.IssuedJSWarning() &&
       (type.IsIntType() || type.IsDoubleType() || !type.IsInstantiated())) {
     // No warning was reported yet for this type check, either because it has
     // not been executed yet, or because no problematic combinations of instance
     // type and test type have been encountered so far. A warning may still be
@@ skipping 56 matching lines @@
             new(Z) Value(left_cid),
             new(Z) Value(cid),
             false);  // No number check.
     ReplaceCall(call, check_cid);
     return;
   }
 
   InstanceOfInstr* instance_of =
       new(Z) InstanceOfInstr(call->token_pos(),
                              new(Z) Value(left),
-                             new(Z) Value(instantiator),
                              new(Z) Value(type_args),
                              type,
                              negate,
                              call->deopt_id());
   ReplaceCall(call, instance_of);
 }
 
 
 // TODO(srdjan): Apply optimizations as in ReplaceWithInstanceOf (TestCids).
 void FlowGraphOptimizer::ReplaceWithTypeCast(InstanceCallInstr* call) {
   ASSERT(Token::IsTypeCastOperator(call->token_kind()));
   Definition* left = call->ArgumentAt(0);
-  Definition* instantiator = call->ArgumentAt(1);
-  Definition* type_args = call->ArgumentAt(2);
+  Definition* type_args = call->ArgumentAt(1);
   const AbstractType& type =
-      AbstractType::Cast(call->ArgumentAt(3)->AsConstant()->value());
+      AbstractType::Cast(call->ArgumentAt(2)->AsConstant()->value());
   ASSERT(!type.IsMalformedOrMalbounded());
   const ICData& unary_checks =
       ICData::ZoneHandle(Z, call->ic_data()->AsUnaryClassChecks());
   if (FLAG_warn_on_javascript_compatibility &&
       !unary_checks.IssuedJSWarning() &&
       (type.IsIntType() || type.IsDoubleType() || !type.IsInstantiated())) {
     // No warning was reported yet for this type check, either because it has
     // not been executed yet, or because no problematic combinations of instance
     // type and test type have been encountered so far. A warning may still be
     // reported, so do not replace the instance call.
@@ skipping 18 matching lines @@
       ASSERT(current_iterator()->Current() == call);
       current_iterator()->RemoveCurrentFromGraph();
       return;
     }
   }
   const String& dst_name = String::ZoneHandle(Z,
       Symbols::New(Exceptions::kCastErrorDstName));
   AssertAssignableInstr* assert_as =
       new(Z) AssertAssignableInstr(call->token_pos(),
                                    new(Z) Value(left),
-                                   new(Z) Value(instantiator),
                                    new(Z) Value(type_args),
                                    type,
                                    dst_name,
                                    call->deopt_id());
   ReplaceCall(call, assert_as);
 }
 
 
 bool FlowGraphOptimizer::IsBlackListedForInlining(intptr_t call_deopt_id) {
   for (intptr_t i = 0; i < inlining_black_list_->length(); ++i) {
@@ skipping 4626 matching lines @@
 
   // Insert materializations at environment uses.
   for (intptr_t i = 0; i < exits_collector_.exits().length(); i++) {
     CreateMaterializationAt(
         exits_collector_.exits()[i], alloc, *slots);
   }
 }
 
 
 }  // namespace dart