Expands the use of Immediate and Operand wrappers.

runtime/vm/intermediate_language_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/intermediate_language.h"
 
 #include "vm/dart_entry.h"
@@ skipping 624 matching lines @@
   const Register val_reg = locs()->in(0).reg();
   const Register cid_reg = locs()->temp(0).reg();
 
   Label* deopt = CanDeoptimize() ?
       compiler->AddDeoptStub(deopt_id(), ICData::kDeoptTestCids) : NULL;
 
   const intptr_t true_result = (kind() == Token::kIS) ? 1 : 0;
   const ZoneGrowableArray<intptr_t>& data = cid_results();
   ASSERT(data[0] == kSmiCid);
   bool result = data[1] == true_result;
-  __ tsti(val_reg, kSmiTagMask);
+  __ tsti(val_reg, Immediate(kSmiTagMask));
   __ b(result ? labels.true_label : labels.false_label, EQ);
   __ LoadClassId(cid_reg, val_reg, PP);
 
   for (intptr_t i = 2; i < data.length(); i += 2) {
     const intptr_t test_cid = data[i];
     ASSERT(test_cid != kSmiCid);
     result = data[i + 1] == true_result;
     __ CompareImmediate(cid_reg, test_cid, PP);
     __ b(result ? labels.true_label : labels.false_label, EQ);
   }
@@ skipping 274 matching lines @@
                                LocationSummary::kNoCall);
 }
 
 
 void LoadClassIdInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const Register object = locs()->in(0).reg();
   const Register result = locs()->out(0).reg();
   static const intptr_t kSmiCidSource = kSmiCid << RawObject::kClassIdTagPos;
 
   __ LoadImmediate(TMP, reinterpret_cast<int64_t>(&kSmiCidSource) + 1, PP);
-  __ tsti(object, kSmiTagMask);
+  __ tsti(object, Immediate(kSmiTagMask));
   __ csel(TMP, TMP, object, EQ);
   __ LoadClassId(result, TMP, PP);
   __ SmiTag(result);
 }
 
 
 CompileType LoadIndexedInstr::ComputeType() const {
   switch (class_id_) {
     case kArrayCid:
     case kImmutableArrayCid:
@@ skipping 369 matching lines @@
 
 
 static void LoadValueCid(FlowGraphCompiler* compiler,
                          Register value_cid_reg,
                          Register value_reg,
                          Label* value_is_smi = NULL) {
   Label done;
   if (value_is_smi == NULL) {
     __ LoadImmediate(value_cid_reg, kSmiCid, PP);
   }
-  __ tsti(value_reg, kSmiTagMask);
+  __ tsti(value_reg, Immediate(kSmiTagMask));
   if (value_is_smi == NULL) {
     __ b(&done, EQ);
   } else {
     __ b(value_is_smi, EQ);
   }
   __ LoadClassId(value_cid_reg, value_reg, PP);
   __ Bind(&done);
 }
 
 
@@ skipping 133 matching lines @@
       __ CallRuntime(kUpdateFieldCidRuntimeEntry, 2);
       __ Drop(2);  // Drop the field and the value.
     }
   } else {
     ASSERT(compiler->is_optimizing());
     ASSERT(deopt != NULL);
 
     // Field guard class has been initialized and is known.
     if (value_cid == kDynamicCid) {
       // Value's class id is not known.
-      __ tsti(value_reg, kSmiTagMask);
+      __ tsti(value_reg, Immediate(kSmiTagMask));
 
       if (field_cid != kSmiCid) {
         __ b(fail, EQ);
         __ LoadClassId(value_cid_reg, value_reg, PP);
         __ CompareImmediate(value_cid_reg, field_cid, PP);
       }
 
       if (field().is_nullable() && (field_cid != kNullCid)) {
         __ b(&ok, EQ);
         __ CompareObject(value_reg, Object::null_object(), PP);
@@ skipping 289 matching lines @@
 
     __ LoadObject(temp, Field::ZoneHandle(field().raw()), PP);
 
     __ LoadFieldFromOffset(temp2, temp, Field::is_nullable_offset(), PP, kWord);
     __ CompareImmediate(temp2, kNullCid, PP);
     __ b(&store_pointer, EQ);
 
     __ LoadFromOffset(
         temp2, temp, Field::kind_bits_offset() - kHeapObjectTag,
         PP, kUnsignedByte);
-    __ tsti(temp2, 1 << Field::kUnboxingCandidateBit);
+    __ tsti(temp2, Immediate(1 << Field::kUnboxingCandidateBit));
     __ b(&store_pointer, EQ);
 
     __ LoadFieldFromOffset(temp2, temp, Field::guarded_cid_offset(), PP, kWord);
     __ CompareImmediate(temp2, kDoubleCid, PP);
     __ b(&store_double, EQ);
 
     __ LoadFieldFromOffset(temp2, temp, Field::guarded_cid_offset(), PP, kWord);
     __ CompareImmediate(temp2, kFloat32x4Cid, PP);
     __ b(&store_float32x4, EQ);
 
@@ skipping 1136 matching lines @@
 
 
 void CheckEitherNonSmiInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Label* deopt = compiler->AddDeoptStub(deopt_id(),
                                         ICData::kDeoptBinaryDoubleOp);
   intptr_t left_cid = left()->Type()->ToCid();
   intptr_t right_cid = right()->Type()->ToCid();
   const Register left = locs()->in(0).reg();
   const Register right = locs()->in(1).reg();
   if (left_cid == kSmiCid) {
-    __ tsti(right, kSmiTagMask);
+    __ tsti(right, Immediate(kSmiTagMask));
   } else if (right_cid == kSmiCid) {
-    __ tsti(left, kSmiTagMask);
+    __ tsti(left, Immediate(kSmiTagMask));
   } else {
     __ orr(TMP, left, Operand(right));
-    __ tsti(TMP, kSmiTagMask);
+    __ tsti(TMP, Immediate(kSmiTagMask));
   }
   __ b(deopt, EQ);
 }
 
 
 LocationSummary* BoxDoubleInstr::MakeLocationSummary(Isolate* isolate,
                                                      bool opt) const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 1;
   LocationSummary* summary = new(isolate) LocationSummary(
@@ skipping 43 matching lines @@
     Label* deopt = compiler->AddDeoptStub(deopt_id_,
                                           ICData::kDeoptBinaryDoubleOp);
     if (value_type->is_nullable() &&
         (value_type->ToNullableCid() == kDoubleCid)) {
       __ CompareObject(value, Object::null_object(), PP);
       __ b(deopt, EQ);
       // It must be double now.
       __ LoadDFieldFromOffset(result, value, Double::value_offset(), PP);
     } else {
       Label is_smi, done;
-      __ tsti(value, kSmiTagMask);
+      __ tsti(value, Immediate(kSmiTagMask));
       __ b(&is_smi, EQ);
       __ CompareClassId(value, kDoubleCid, PP);
       __ b(deopt, NE);
       __ LoadDFieldFromOffset(result, value, Double::value_offset(), PP);
       __ b(&done);
       __ Bind(&is_smi);
       __ SmiUntag(TMP, value);  // Copy and untag.
       __ scvtfd(result, TMP);
       __ Bind(&done);
     }
@@ skipping 37 matching lines @@
 }
 
 
 void UnboxFloat32x4Instr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const intptr_t value_cid = value()->Type()->ToCid();
   const Register value = locs()->in(0).reg();
   const VRegister result = locs()->out(0).fpu_reg();
 
   if (value_cid != kFloat32x4Cid) {
     Label* deopt = compiler->AddDeoptStub(deopt_id_, ICData::kDeoptCheckClass);
-    __ tsti(value, kSmiTagMask);
+    __ tsti(value, Immediate(kSmiTagMask));
     __ b(deopt, EQ);
     __ CompareClassId(value, kFloat32x4Cid, PP);
     __ b(deopt, NE);
   }
 
   __ LoadQFieldFromOffset(result, value, Float32x4::value_offset(), PP);
 }
 
 
 LocationSummary* BoxFloat64x2Instr::MakeLocationSummary(Isolate* isolate,
@@ skipping 32 matching lines @@
 }
 
 
 void UnboxFloat64x2Instr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const intptr_t value_cid = value()->Type()->ToCid();
   const Register value = locs()->in(0).reg();
   const VRegister result = locs()->out(0).fpu_reg();
 
   if (value_cid != kFloat64x2Cid) {
     Label* deopt = compiler->AddDeoptStub(deopt_id_, ICData::kDeoptCheckClass);
-    __ tsti(value, kSmiTagMask);
+    __ tsti(value, Immediate(kSmiTagMask));
     __ b(deopt, EQ);
     __ CompareClassId(value, kFloat64x2Cid, PP);
     __ b(deopt, NE);
   }
 
   __ LoadQFieldFromOffset(result, value, Float64x2::value_offset(), PP);
 }
 
 
 LocationSummary* BoxInt32x4Instr::MakeLocationSummary(Isolate* isolate,
@@ skipping 31 matching lines @@
 }
 
 
 void UnboxInt32x4Instr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const intptr_t value_cid = value()->Type()->ToCid();
   const Register value = locs()->in(0).reg();
   const VRegister result = locs()->out(0).fpu_reg();
 
   if (value_cid != kInt32x4Cid) {
     Label* deopt = compiler->AddDeoptStub(deopt_id_, ICData::kDeoptCheckClass);
-    __ tsti(value, kSmiTagMask);
+    __ tsti(value, Immediate(kSmiTagMask));
     __ b(deopt, EQ);
     __ CompareClassId(value, kInt32x4Cid, PP);
     __ b(deopt, NE);
   }
 
   __ LoadQFieldFromOffset(result, value, Int32x4::value_offset(), PP);
 }
 
 
 LocationSummary* BinaryDoubleOpInstr::MakeLocationSummary(Isolate* isolate,
@@ skipping 1159 matching lines @@
       __ subs(result, ZR, Operand(value));
       __ b(deopt, VS);
       if (FLAG_throw_on_javascript_int_overflow) {
         EmitJavascriptOverflowCheck(compiler, range(), deopt, value);
       }
       break;
     }
     case Token::kBIT_NOT:
       __ mvn(result, value);
       // Remove inverted smi-tag.
-      __ andi(result, result, ~kSmiTagMask);
+      __ andi(result, result, Immediate(~kSmiTagMask));
       break;
     default:
       UNREACHABLE();
   }
 }
 
 
 LocationSummary* UnaryDoubleOpInstr::MakeLocationSummary(Isolate* isolate,
                                                          bool opt) const {
   const intptr_t kNumInputs = 1;
@@ skipping 542 matching lines @@
   }
 
   ASSERT((unary_checks().GetReceiverClassIdAt(0) != kSmiCid) ||
          (unary_checks().NumberOfChecks() > 1));
   const Register value = locs()->in(0).reg();
   const Register temp = locs()->temp(0).reg();
   Label* deopt = compiler->AddDeoptStub(deopt_id(), deopt_reason);
   Label is_ok;
   intptr_t cix = 0;
   if (unary_checks().GetReceiverClassIdAt(cix) == kSmiCid) {
-    __ tsti(value, kSmiTagMask);
+    __ tsti(value, Immediate(kSmiTagMask));
     __ b(&is_ok, EQ);
     cix++;  // Skip first check.
   } else {
-    __ tsti(value, kSmiTagMask);
+    __ tsti(value, Immediate(kSmiTagMask));
     __ b(deopt, EQ);
   }
   __ LoadClassId(temp, value, PP);
 
   if (IsDenseSwitch()) {
     ASSERT(cids_[0] < cids_[cids_.length() - 1]);
     __ AddImmediate(temp, temp, -cids_[0], PP);
     __ CompareImmediate(temp, cids_[cids_.length() - 1] - cids_[0], PP);
     __ b(deopt, HI);
 
@@ skipping 50 matching lines @@
   LocationSummary* summary = new(isolate) LocationSummary(
       isolate, kNumInputs, kNumTemps, LocationSummary::kNoCall);
   summary->set_in(0, Location::RequiresRegister());
   return summary;
 }
 
 
 void CheckSmiInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const Register value = locs()->in(0).reg();
   Label* deopt = compiler->AddDeoptStub(deopt_id(), ICData::kDeoptCheckSmi);
-  __ tsti(value, kSmiTagMask);
+  __ tsti(value, Immediate(kSmiTagMask));
   __ b(deopt, NE);
 }
 
 
 LocationSummary* CheckArrayBoundInstr::MakeLocationSummary(Isolate* isolate,
                                                            bool opt) const {
   const intptr_t kNumInputs = 2;
   const intptr_t kNumTemps = 0;
   LocationSummary* locs = new(isolate) LocationSummary(
       isolate, kNumInputs, kNumTemps, LocationSummary::kNoCall);
@@ skipping 469 matching lines @@
   compiler->GenerateCall(token_pos(), &label, stub_kind_, locs());
 #if defined(DEBUG)
   __ LoadImmediate(R4, kInvalidObjectPointer, kNoPP);
   __ LoadImmediate(R5, kInvalidObjectPointer, kNoPP);
 #endif
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM64