Remove instantiator argument in generated code for type tests.

runtime/vm/flow_graph_compiler_mips.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/globals.h"  // Needed here to get TARGET_ARCH_MIPS.
 #if defined(TARGET_ARCH_MIPS)
 
 #include "vm/flow_graph_compiler.h"
 
 #include "vm/ast_printer.h"
@@ skipping 432 matching lines @@
 RawSubtypeTestCache* FlowGraphCompiler::GenerateUninstantiatedTypeTest(
     intptr_t token_pos,
     const AbstractType& type,
     Label* is_instance_lbl,
     Label* is_not_instance_lbl) {
   __ Comment("UninstantiatedTypeTest");
   ASSERT(!type.IsInstantiated());
   // Skip check if destination is a dynamic type.
   if (type.IsTypeParameter()) {
     const TypeParameter& type_param = TypeParameter::Cast(type);
-    // Load instantiator (or null) and instantiator type arguments on stack.
+    // Load instantiator type arguments on stack.
     __ lw(A1, Address(SP, 0));  // Get instantiator type arguments.
     // A1: instantiator type arguments.
     // Check if type arguments are null, i.e. equivalent to vector of dynamic.
     __ LoadObject(T7, Object::null_object());
     __ beq(A1, T7, is_instance_lbl);
     __ lw(T2,
         FieldAddress(A1, TypeArguments::type_at_offset(type_param.index())));
     // R2: concrete type of type.
     // Check if type argument is dynamic.
     __ BranchEqual(T2,
@@ skipping 104 matching lines @@
 
 
 // If instanceof type test cannot be performed successfully at compile time and
 // therefore eliminated, optimize it by adding inlined tests for:
 // - NULL -> return false.
 // - Smi -> compile time subtype check (only if dst class is not parameterized).
 // - Class equality (only if class is not parameterized).
 // Inputs:
 // - A0: object.
 // - A1: instantiator type arguments or raw_null.
-// - A2: instantiator or raw_null.
 // Returns:
 // - true or false in V0.
 void FlowGraphCompiler::GenerateInstanceOf(intptr_t token_pos,
                                            intptr_t deopt_id,
                                            const AbstractType& type,
                                            bool negate_result,
                                            LocationSummary* locs) {
   ASSERT(type.IsFinalized() && !type.IsMalformed() && !type.IsMalbounded());
 
-  // Preserve instantiator (A2) and its type arguments (A1).
-  __ addiu(SP, SP, Immediate(-2 * kWordSize));
-  __ sw(A2, Address(SP, 1 * kWordSize));
+  // Preserve instantiator type arguments (A1).
+  __ addiu(SP, SP, Immediate(-1 * kWordSize));
   __ sw(A1, Address(SP, 0 * kWordSize));
 
   Label is_instance, is_not_instance;
   // If type is instantiated and non-parameterized, we can inline code
   // checking whether the tested instance is a Smi.
   if (type.IsInstantiated()) {
     // A null object is only an instance of Object and dynamic, which has
     // already been checked above (if the type is instantiated). So we can
     // return false here if the instance is null (and if the type is
     // instantiated).
     // We can only inline this null check if the type is instantiated at compile
     // time, since an uninstantiated type at compile time could be Object or
     // dynamic at run time.
     __ BranchEqual(A0, Object::null_object(),
         type.IsNullType() ? &is_instance : &is_not_instance);
   }
 
   // Generate inline instanceof test.
   SubtypeTestCache& test_cache = SubtypeTestCache::ZoneHandle(zone());
   test_cache = GenerateInlineInstanceof(token_pos, type,
                                         &is_instance, &is_not_instance);
 
   // test_cache is null if there is no fall-through.
   Label done;
   if (!test_cache.IsNull()) {
     // Generate runtime call.
-    // Load instantiator (A2) and its type arguments (A1).
+    // Load instantiator type arguments (A1).
     __ lw(A1, Address(SP, 0 * kWordSize));
-    __ lw(A2, Address(SP, 1 * kWordSize));
 
-    __ addiu(SP, SP, Immediate(-6 * kWordSize));
+    __ addiu(SP, SP, Immediate(-5 * kWordSize));
     __ LoadObject(TMP, Object::null_object());
-    __ sw(TMP, Address(SP, 5 * kWordSize));  // Make room for the result.
-    __ sw(A0, Address(SP, 4 * kWordSize));  // Push the instance.
+    __ sw(TMP, Address(SP, 4 * kWordSize));  // Make room for the result.
+    __ sw(A0, Address(SP, 3 * kWordSize));  // Push the instance.
     __ LoadObject(TMP, type);
-    __ sw(TMP, Address(SP, 3 * kWordSize));  // Push the type.
-    __ sw(A2, Address(SP, 2 * kWordSize));  // Push instantiator.
+    __ sw(TMP, Address(SP, 2 * kWordSize));  // Push the type.
     __ sw(A1, Address(SP, 1 * kWordSize));  // Push type arguments.
     __ LoadUniqueObject(A0, test_cache);
     __ sw(A0, Address(SP, 0 * kWordSize));
-    GenerateRuntimeCall(token_pos, deopt_id, kInstanceofRuntimeEntry, 5, locs);
+    GenerateRuntimeCall(token_pos, deopt_id, kInstanceofRuntimeEntry, 4, locs);
     // Pop the parameters supplied to the runtime entry. The result of the
     // instanceof runtime call will be left as the result of the operation.
-    __ lw(T0, Address(SP, 5 * kWordSize));
-    __ addiu(SP, SP, Immediate(6 * kWordSize));
+    __ lw(T0, Address(SP, 4 * kWordSize));
+    __ addiu(SP, SP, Immediate(5 * kWordSize));
     if (negate_result) {
       __ LoadObject(V0, Bool::True());
       __ bne(T0, V0, &done);
       __ LoadObject(V0, Bool::False());
     } else {
       __ mov(V0, T0);
     }
     __ b(&done);
   }
   __ Bind(&is_not_instance);
   __ LoadObject(V0, Bool::Get(negate_result));
   __ b(&done);
 
   __ Bind(&is_instance);
   __ LoadObject(V0, Bool::Get(!negate_result));
   __ Bind(&done);
-  // Remove instantiator (A2) and its type arguments (A1).
-  __ Drop(2);
+  // Remove instantiator type arguments (A1).
+  __ Drop(1);
 }
 
 
 // Optimize assignable type check by adding inlined tests for:
 // - NULL -> return NULL.
 // - Smi -> compile time subtype check (only if dst class is not parameterized).
 // - Class equality (only if class is not parameterized).
 // Inputs:
 // - A0: instance being type checked.
 // - A1: instantiator type arguments or raw_null.
-// - A2: instantiator or raw_null.
 // Returns:
 // - object in A0 for successful assignable check (or throws TypeError).
 // Clobbers: T0, T1, T2
 // Performance notes: positive checks must be quick, negative checks can be slow
 // as they throw an exception.
 void FlowGraphCompiler::GenerateAssertAssignable(intptr_t token_pos,
                                                  intptr_t deopt_id,
                                                  const AbstractType& dst_type,
                                                  const String& dst_name,
                                                  LocationSummary* locs) {
   __ Comment("AssertAssignable");
   ASSERT(token_pos >= 0);
   ASSERT(!dst_type.IsNull());
   ASSERT(dst_type.IsFinalized());
   // Assignable check is skipped in FlowGraphBuilder, not here.
   ASSERT(dst_type.IsMalformedOrMalbounded() ||
          (!dst_type.IsDynamicType() && !dst_type.IsObjectType()));
-  // Preserve instantiator and its type arguments.
-  __ addiu(SP, SP, Immediate(-2 * kWordSize));
-  __ sw(A2, Address(SP, 1 * kWordSize));
+  // Preserve instantiator type arguments.
+  __ addiu(SP, SP, Immediate(-1 * kWordSize));
+  __ sw(A1, Address(SP, 0 * kWordSize));
 
   // A null object is always assignable and is returned as result.
   Label is_assignable, runtime_call;
 
   __ BranchEqual(A0, Object::null_object(), &is_assignable);
   __ delay_slot()->sw(A1, Address(SP, 0 * kWordSize));
 
   // Generate throw new TypeError() if the type is malformed or malbounded.
   if (dst_type.IsMalformedOrMalbounded()) {
     __ addiu(SP, SP, Immediate(-4 * kWordSize));
     __ LoadObject(TMP, Object::null_object());
     __ sw(TMP, Address(SP, 3 * kWordSize));  // Make room for the result.
     __ sw(A0, Address(SP, 2 * kWordSize));  // Push the source object.
     __ LoadObject(TMP, dst_name);
     __ sw(TMP, Address(SP, 1 * kWordSize));  // Push the destination name.
     __ LoadObject(TMP, dst_type);
     __ sw(TMP, Address(SP, 0 * kWordSize));  // Push the destination type.
 
     GenerateRuntimeCall(token_pos,
                         deopt_id,
                         kBadTypeErrorRuntimeEntry,
                         3,
                         locs);
     // We should never return here.
     __ break_(0);
 
     __ Bind(&is_assignable);  // For a null object.
-    // Restore instantiator and its type arguments.
+    // Restore instantiator type arguments.
     __ lw(A1, Address(SP, 0 * kWordSize));
-    __ lw(A2, Address(SP, 1 * kWordSize));
-    __ addiu(SP, SP, Immediate(2 * kWordSize));
+    __ addiu(SP, SP, Immediate(1 * kWordSize));
     return;
   }
 
   // Generate inline type check, linking to runtime call if not assignable.
   SubtypeTestCache& test_cache = SubtypeTestCache::ZoneHandle(zone());
   test_cache = GenerateInlineInstanceof(token_pos, dst_type,
                                         &is_assignable, &runtime_call);
 
   __ Bind(&runtime_call);
-  // Load instantiator (A2) and its type arguments (A1).
+  // Load instantiator type arguments (A1).
   __ lw(A1, Address(SP, 0 * kWordSize));
-  __ lw(A2, Address(SP, 1 * kWordSize));
 
-  __ addiu(SP, SP, Immediate(-7 * kWordSize));
+  __ addiu(SP, SP, Immediate(-6 * kWordSize));
   __ LoadObject(TMP, Object::null_object());
-  __ sw(TMP, Address(SP, 6 * kWordSize));  // Make room for the result.
-  __ sw(A0, Address(SP, 5 * kWordSize));  // Push the source object.
+  __ sw(TMP, Address(SP, 5 * kWordSize));  // Make room for the result.
+  __ sw(A0, Address(SP, 4 * kWordSize));  // Push the source object.
   __ LoadObject(TMP, dst_type);
-  __ sw(TMP, Address(SP, 4 * kWordSize));  // Push the type of the destination.
-  __ sw(A2, Address(SP, 3 * kWordSize));  // Push instantiator.
+  __ sw(TMP, Address(SP, 3 * kWordSize));  // Push the type of the destination.
   __ sw(A1, Address(SP, 2 * kWordSize));  // Push type arguments.
   __ LoadObject(TMP, dst_name);
   __ sw(TMP, Address(SP, 1 * kWordSize));  // Push the name of the destination.
   __ LoadUniqueObject(T0, test_cache);
   __ sw(T0, Address(SP, 0 * kWordSize));
 
-  GenerateRuntimeCall(token_pos, deopt_id, kTypeCheckRuntimeEntry, 6, locs);
+  GenerateRuntimeCall(token_pos, deopt_id, kTypeCheckRuntimeEntry, 5, locs);
   // Pop the parameters supplied to the runtime entry. The result of the
   // type check runtime call is the checked value.
-  __ lw(A0, Address(SP, 6 * kWordSize));
-  __ addiu(SP, SP, Immediate(7 * kWordSize));
+  __ lw(A0, Address(SP, 5 * kWordSize));
+  __ addiu(SP, SP, Immediate(6 * kWordSize));
 
   __ Bind(&is_assignable);
-  // Restore instantiator and its type arguments.
+  // Restore instantiator type arguments.
   __ lw(A1, Address(SP, 0 * kWordSize));
-  __ lw(A2, Address(SP, 1 * kWordSize));
-  __ addiu(SP, SP, Immediate(2 * kWordSize));
+  __ addiu(SP, SP, Immediate(1 * kWordSize));
 }
 
 
 void FlowGraphCompiler::EmitInstructionEpilogue(Instruction* instr) {
   if (is_optimizing()) return;
   Definition* defn = instr->AsDefinition();
   if ((defn != NULL) && defn->HasTemp()) {
     __ Push(defn->locs()->out(0).reg());
   }
 }
@@ skipping 1142 matching lines @@
   __ AddImmediate(SP, kDoubleSize);
 }
 
 
 #undef __
 
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_MIPS