Expands the use of Immediate and Operand wrappers.

runtime/vm/flow_graph_compiler_arm64.cc

 // Copyright (c) 2014, 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_ARM64.
 #if defined(TARGET_ARCH_ARM64)
 
 #include "vm/flow_graph_compiler.h"
 
 #include "vm/ast_printer.h"
@@ skipping 237 matching lines @@
   __ Comment("InstantiatedTypeWithArgumentsTest");
   ASSERT(type.IsInstantiated());
   const Class& type_class = Class::ZoneHandle(type.type_class());
   ASSERT((type_class.NumTypeArguments() > 0) || type_class.IsSignatureClass());
   const Register kInstanceReg = R0;
   Error& malformed_error = Error::Handle();
   const Type& int_type = Type::Handle(Type::IntType());
   const bool smi_is_ok = int_type.IsSubtypeOf(type, &malformed_error);
   // Malformed type should have been handled at graph construction time.
   ASSERT(smi_is_ok || malformed_error.IsNull());
-  __ tsti(kInstanceReg, kSmiTagMask);
+  __ tsti(kInstanceReg, Immediate(kSmiTagMask));
   if (smi_is_ok) {
     __ b(is_instance_lbl, EQ);
   } else {
     __ b(is_not_instance_lbl, EQ);
   }
   const intptr_t num_type_args = type_class.NumTypeArguments();
   const intptr_t num_type_params = type_class.NumTypeParameters();
   const intptr_t from_index = num_type_args - num_type_params;
   const TypeArguments& type_arguments =
       TypeArguments::ZoneHandle(type.arguments());
@@ skipping 65 matching lines @@
     intptr_t token_pos,
     const AbstractType& type,
     Label* is_instance_lbl,
     Label* is_not_instance_lbl) {
   __ Comment("InstantiatedTypeNoArgumentsTest");
   ASSERT(type.IsInstantiated());
   const Class& type_class = Class::Handle(type.type_class());
   ASSERT(type_class.NumTypeArguments() == 0);
 
   const Register kInstanceReg = R0;
-  __ tsti(kInstanceReg, kSmiTagMask);
+  __ tsti(kInstanceReg, Immediate(kSmiTagMask));
   // If instance is Smi, check directly.
   const Class& smi_class = Class::Handle(Smi::Class());
   if (smi_class.IsSubtypeOf(TypeArguments::Handle(),
                             type_class,
                             TypeArguments::Handle(),
                             NULL)) {
     __ b(is_instance_lbl, EQ);
   } else {
     __ b(is_not_instance_lbl, EQ);
   }
@@ skipping 89 matching lines @@
         R2, R1, TypeArguments::type_at_offset(type_param.index()), PP);
     // R2: concrete type of type.
     // Check if type argument is dynamic.
     __ CompareObject(R2, Type::ZoneHandle(Type::DynamicType()), PP);
     __ b(is_instance_lbl, EQ);
     __ CompareObject(R2, Type::ZoneHandle(Type::ObjectType()), PP);
     __ b(is_instance_lbl, EQ);
 
     // For Smi check quickly against int and num interfaces.
     Label not_smi;
-    __ tsti(R0, kSmiTagMask);  // Value is Smi?
+    __ tsti(R0, Immediate(kSmiTagMask));  // Value is Smi?
     __ b(&not_smi, NE);
     __ CompareObject(R2, Type::ZoneHandle(Type::IntType()), PP);
     __ b(is_instance_lbl, EQ);
     __ CompareObject(R2, Type::ZoneHandle(Type::Number()), PP);
     __ b(is_instance_lbl, EQ);
     // Smi must be handled in runtime.
     Label fall_through;
     __ b(&fall_through);
 
     __ Bind(&not_smi);
     // R1: instantiator type arguments.
     // R0: instance.
     const Register kInstanceReg = R0;
     const Register kTypeArgumentsReg = R1;
     const Register kTempReg = kNoRegister;
     const SubtypeTestCache& type_test_cache =
         SubtypeTestCache::ZoneHandle(
             GenerateCallSubtypeTestStub(kTestTypeThreeArgs,
                                         kInstanceReg,
                                         kTypeArgumentsReg,
                                         kTempReg,
                                         is_instance_lbl,
                                         is_not_instance_lbl));
     __ Bind(&fall_through);
     return type_test_cache.raw();
   }
   if (type.IsType()) {
     const Register kInstanceReg = R0;
     const Register kTypeArgumentsReg = R1;
-    __ tsti(kInstanceReg, kSmiTagMask);  // Is instance Smi?
+    __ tsti(kInstanceReg, Immediate(kSmiTagMask));  // Is instance Smi?
     __ b(is_not_instance_lbl, EQ);
     __ ldr(kTypeArgumentsReg, Address(SP));  // Instantiator type args.
     // Uninstantiated type class is known at compile time, but the type
     // arguments are determined at runtime by the instantiator.
     const Register kTempReg = kNoRegister;
     return GenerateCallSubtypeTestStub(kTestTypeThreeArgs,
                                        kInstanceReg,
                                        kTypeArgumentsReg,
                                        kTempReg,
                                        is_instance_lbl,
@@ skipping 1272 matching lines @@
 void ParallelMoveResolver::RestoreFpuScratch(FpuRegister reg) {
   __ PopDouble(reg);
 }
 
 
 #undef __
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM64