Expands the use of Immediate and Operand wrappers.

runtime/vm/intrinsifier_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/intrinsifier.h"
 
 #include "vm/assembler.h"
@@ skipping 196 matching lines @@
 void Intrinsifier::GrowableArraySetData(Assembler* assembler) {
   if (FLAG_enable_type_checks) {
     return;
   }
   Label fall_through;
   __ lw(T1, Address(SP, 0 * kWordSize));  // Data.
   // Check that data is an ObjectArray.
   __ andi(CMPRES1, T1, Immediate(kSmiTagMask));
   __ beq(CMPRES1, ZR, &fall_through);  // Data is Smi.
   __ LoadClassId(CMPRES1, T1);
-  __ BranchNotEqual(CMPRES1, kArrayCid, &fall_through);
+  __ BranchNotEqual(CMPRES1, Immediate(kArrayCid), &fall_through);
   __ lw(T0, Address(SP, 1 * kWordSize));  // Growable array.
   __ StoreIntoObject(T0,
                      FieldAddress(T0, GrowableObjectArray::data_offset()),
                      T1);
   __ Ret();
   __ Bind(&fall_through);
 }
 
 
 // Add an element to growable array if it doesn't need to grow, otherwise
@@ skipping 31 matching lines @@
 
 
 #define TYPED_ARRAY_ALLOCATION(type_name, cid, max_len, scale_shift)           \
   Label fall_through;                                                          \
   const intptr_t kArrayLengthStackOffset = 0 * kWordSize;                      \
   __ lw(T2, Address(SP, kArrayLengthStackOffset));  /* Array length. */        \
   /* Check that length is a positive Smi. */                                   \
   /* T2: requested array length argument. */                                   \
   __ andi(CMPRES1, T2, Immediate(kSmiTagMask));                                \
   __ bne(CMPRES1, ZR, &fall_through);                                          \
-  __ BranchSignedLess(T2, 0, &fall_through);                                   \
+  __ BranchSignedLess(T2, Immediate(0), &fall_through);                        \
   __ SmiUntag(T2);                                                             \
   /* Check for maximum allowed length. */                                      \
   /* T2: untagged array length. */                                             \
-  __ BranchSignedGreater(T2, max_len, &fall_through);                          \
+  __ BranchSignedGreater(T2, Immediate(max_len), &fall_through);               \
   __ sll(T2, T2, scale_shift);                                                 \
   const intptr_t fixed_size = sizeof(Raw##type_name) + kObjectAlignment - 1;   \
   __ AddImmediate(T2, fixed_size);                                             \
   __ LoadImmediate(TMP, -kObjectAlignment);                                    \
   __ and_(T2, T2, TMP);                                                        \
   Heap* heap = Isolate::Current()->heap();                                     \
   Heap::Space space = heap->SpaceForAllocation(cid);                           \
   __ LoadImmediate(V0, heap->TopAddress(space));                               \
   __ lw(V0, Address(V0, 0));                                                   \
                                                                                \
@@ skipping 14 matching lines @@
   __ LoadImmediate(T3, heap->TopAddress(space));                               \
   __ sw(T1, Address(T3, 0));                                                   \
   __ AddImmediate(V0, kHeapObjectTag);                                         \
   __ UpdateAllocationStatsWithSize(cid, T2, T4, space);                        \
   /* Initialize the tags. */                                                   \
   /* V0: new object start as a tagged pointer. */                              \
   /* T1: new object end address. */                                            \
   /* T2: allocation size. */                                                   \
   {                                                                            \
     Label size_tag_overflow, done;                                             \
-    __ BranchUnsignedGreater(T2, RawObject::SizeTag::kMaxSizeTag,              \
+    __ BranchUnsignedGreater(T2, Immediate(RawObject::SizeTag::kMaxSizeTag),   \
                              &size_tag_overflow);                              \
     __ b(&done);                                                               \
     __ delay_slot()->sll(T2, T2,                                               \
         RawObject::kSizeTagPos - kObjectAlignmentLog2);                        \
                                                                                \
     __ Bind(&size_tag_overflow);                                               \
     __ mov(T2, ZR);                                                            \
     __ Bind(&done);                                                            \
                                                                                \
     /* Get the class index and insert it into the tags. */                     \
@@ skipping 214 matching lines @@
 
   TestBothArgumentsSmis(assembler, &fall_through);
   __ beq(T0, ZR, &fall_through);  // If b is 0, fall through.
 
   __ SmiUntag(T0);
   __ SmiUntag(T1);
   __ div(T1, T0);  // LO <- T1 / T0
   __ mflo(V0);  // V0 <- LO
   // Check the corner case of dividing the 'MIN_SMI' with -1, in which case we
   // cannot tag the result.
-  __ BranchEqual(V0, 0x40000000, &fall_through);
+  __ BranchEqual(V0, Immediate(0x40000000), &fall_through);
   __ Ret();
   __ delay_slot()->SmiTag(V0);
   __ Bind(&fall_through);
 }
 
 
 void Intrinsifier::Integer_negate(Assembler* assembler) {
   Label fall_through;
 
   __ lw(T0, Address(SP, + 0 * kWordSize));  // Grabs first argument.
@@ skipping 50 matching lines @@
   Integer_bitXorFromInteger(assembler);
 }
 
 
 void Intrinsifier::Integer_shl(Assembler* assembler) {
   ASSERT(kSmiTagShift == 1);
   ASSERT(kSmiTag == 0);
   Label fall_through, overflow;
 
   TestBothArgumentsSmis(assembler, &fall_through);
-  __ BranchUnsignedGreater(T0, Smi::RawValue(Smi::kBits), &fall_through);
+  __ BranchUnsignedGreater(
+      T0, Immediate(Smi::RawValue(Smi::kBits)), &fall_through);
   __ SmiUntag(T0);
 
   // Check for overflow by shifting left and shifting back arithmetically.
   // If the result is different from the original, there was overflow.
   __ sllv(TMP, T1, T0);
   __ srav(CMPRES1, TMP, T0);
   __ bne(CMPRES1, T1, &overflow);
 
   // No overflow, result in V0.
   __ Ret();
@@ skipping 40 matching lines @@
   __ bne(CMPRES1, ZR, &not_smi);
   __ SmiUntag(reg);
 
   // Sign extend to 64 bit
   __ mov(res_lo, reg);
   __ b(&done);
   __ delay_slot()->sra(res_hi, reg, 31);
 
   __ Bind(&not_smi);
   __ LoadClassId(CMPRES1, reg);
-  __ BranchNotEqual(CMPRES1, kMintCid, not_smi_or_mint);
+  __ BranchNotEqual(CMPRES1, Immediate(kMintCid), not_smi_or_mint);
 
   // Mint.
   __ lw(res_lo, FieldAddress(reg, Mint::value_offset()));
   __ lw(res_hi, FieldAddress(reg, Mint::value_offset() + kWordSize));
   __ Bind(&done);
   return;
 }
 
 
 static void CompareIntegers(Assembler* assembler, Condition true_condition) {
@@ skipping 119 matching lines @@
   __ Bind(&check_for_mint);
 
   __ andi(CMPRES1, T1, Immediate(kSmiTagMask));
   __ bne(CMPRES1, ZR, &receiver_not_smi);  // Check receiver.
 
   // Left (receiver) is Smi, return false if right is not Double.
   // Note that an instance of Mint or Bigint never contains a value that can be
   // represented by Smi.
 
   __ LoadClassId(CMPRES1, T0);
-  __ BranchEqual(CMPRES1, kDoubleCid, &fall_through);
+  __ BranchEqual(CMPRES1, Immediate(kDoubleCid), &fall_through);
   __ LoadObject(V0, Bool::False());  // Smi == Mint -> false.
   __ Ret();
 
   __ Bind(&receiver_not_smi);
   // T1:: receiver.
 
   __ LoadClassId(CMPRES1, T1);
-  __ BranchNotEqual(CMPRES1, kMintCid, &fall_through);
+  __ BranchNotEqual(CMPRES1, Immediate(kMintCid), &fall_through);
   // Receiver is Mint, return false if right is Smi.
   __ andi(CMPRES1, T0, Immediate(kSmiTagMask));
   __ bne(CMPRES1, ZR, &fall_through);
   __ LoadObject(V0, Bool::False());
   __ Ret();
   // TODO(srdjan): Implement Mint == Mint comparison.
 
   __ Bind(&fall_through);
 }
 
@@ skipping 69 matching lines @@
 // Check if the last argument is a double, jump to label 'is_smi' if smi
 // (easy to convert to double), otherwise jump to label 'not_double_smi',
 // Returns the last argument in T0.
 static void TestLastArgumentIsDouble(Assembler* assembler,
                                      Label* is_smi,
                                      Label* not_double_smi) {
   __ lw(T0, Address(SP, 0 * kWordSize));
   __ andi(CMPRES1, T0, Immediate(kSmiTagMask));
   __ beq(CMPRES1, ZR, is_smi);
   __ LoadClassId(CMPRES1, T0);
-  __ BranchNotEqual(CMPRES1, kDoubleCid, not_double_smi);
+  __ BranchNotEqual(CMPRES1, Immediate(kDoubleCid), not_double_smi);
   // Fall through with Double in T0.
 }
 
 
 // Both arguments on stack, arg0 (left) is a double, arg1 (right) is of unknown
 // type. Return true or false object in the register V0. Any NaN argument
 // returns false. Any non-double arg1 causes control flow to fall through to the
 // slow case (compiled method body).
 static void CompareDoubles(Assembler* assembler, Condition true_condition) {
   Label is_smi, double_op, no_NaN, fall_through;
@@ skipping 338 matching lines @@
   __ lw(T1, Address(SP, 0 * kWordSize));  // Index.
   __ lw(T0, Address(SP, 1 * kWordSize));  // String.
 
   // Checks.
   __ andi(CMPRES1, T1, Immediate(kSmiTagMask));
   __ bne(T1, ZR, &fall_through);  // Index is not a Smi.
   __ lw(T2, FieldAddress(T0, String::length_offset()));  // Range check.
   // Runtime throws exception.
   __ BranchUnsignedGreaterEqual(T1, T2, &fall_through);
   __ LoadClassId(CMPRES1, T0);  // Class ID check.
-  __ BranchNotEqual(CMPRES1, kOneByteStringCid, &try_two_byte_string);
+  __ BranchNotEqual(
+      CMPRES1, Immediate(kOneByteStringCid), &try_two_byte_string);
 
   // Grab byte and return.
   __ SmiUntag(T1);
   __ addu(T2, T0, T1);
   __ lbu(V0, FieldAddress(T2, OneByteString::data_offset()));
   __ Ret();
   __ delay_slot()->SmiTag(V0);
 
   __ Bind(&try_two_byte_string);
-  __ BranchNotEqual(CMPRES1, kTwoByteStringCid, &fall_through);
+  __ BranchNotEqual(CMPRES1, Immediate(kTwoByteStringCid), &fall_through);
   ASSERT(kSmiTagShift == 1);
   __ addu(T2, T0, T1);
   __ lhu(V0, FieldAddress(T2, TwoByteString::data_offset()));
   __ Ret();
   __ delay_slot()->SmiTag(V0);
 
   __ Bind(&fall_through);
 }
 
 
 void Intrinsifier::StringBaseCharAt(Assembler* assembler) {
   Label fall_through, try_two_byte_string;
 
   __ lw(T1, Address(SP, 0 * kWordSize));  // Index.
   __ lw(T0, Address(SP, 1 * kWordSize));  // String.
 
   // Checks.
   __ andi(CMPRES1, T1, Immediate(kSmiTagMask));
   __ bne(T1, ZR, &fall_through);  // Index is not a Smi.
   __ lw(T2, FieldAddress(T0, String::length_offset()));  // Range check.
   // Runtime throws exception.
   __ BranchUnsignedGreaterEqual(T1, T2, &fall_through);
   __ LoadClassId(CMPRES1, T0);  // Class ID check.
-  __ BranchNotEqual(CMPRES1, kOneByteStringCid, &try_two_byte_string);
+  __ BranchNotEqual(
+      CMPRES1, Immediate(kOneByteStringCid), &try_two_byte_string);
 
   // Grab byte and return.
   __ SmiUntag(T1);
   __ addu(T2, T0, T1);
   __ lbu(T2, FieldAddress(T2, OneByteString::data_offset()));
   __ BranchUnsignedGreaterEqual(
-      T2, Symbols::kNumberOfOneCharCodeSymbols, &fall_through);
+      T2, Immediate(Symbols::kNumberOfOneCharCodeSymbols), &fall_through);
   __ LoadImmediate(
       V0, reinterpret_cast<uword>(Symbols::PredefinedAddress()));
   __ AddImmediate(V0, Symbols::kNullCharCodeSymbolOffset * kWordSize);
   __ sll(T2, T2, 2);
   __ addu(T2, T2, V0);
   __ Ret();
   __ delay_slot()->lw(V0, Address(T2));
 
   __ Bind(&try_two_byte_string);
-  __ BranchNotEqual(CMPRES1, kTwoByteStringCid, &fall_through);
+  __ BranchNotEqual(CMPRES1, Immediate(kTwoByteStringCid), &fall_through);
   ASSERT(kSmiTagShift == 1);
   __ addu(T2, T0, T1);
   __ lhu(T2, FieldAddress(T2, TwoByteString::data_offset()));
   __ BranchUnsignedGreaterEqual(
-      T2, Symbols::kNumberOfOneCharCodeSymbols, &fall_through);
+      T2, Immediate(Symbols::kNumberOfOneCharCodeSymbols), &fall_through);
   __ LoadImmediate(V0,
                    reinterpret_cast<uword>(Symbols::PredefinedAddress()));
   __ AddImmediate(V0, Symbols::kNullCharCodeSymbolOffset * kWordSize);
   __ sll(T2, T2, 2);
   __ addu(T2, T2, V0);
   __ Ret();
   __ delay_slot()->lw(V0, Address(T2));
 
   __ Bind(&fall_through);
 }
@@ skipping 20 matching lines @@
   __ lw(T1, Address(SP, 0 * kWordSize));
   __ lw(V0, FieldAddress(T1, String::hash_offset()));
   __ beq(V0, ZR, &no_hash);
   __ Ret();  // Return if already computed.
   __ Bind(&no_hash);
 
   __ lw(T2, FieldAddress(T1, String::length_offset()));
 
   Label done;
   // If the string is empty, set the hash to 1, and return.
-  __ BranchEqual(T2, Smi::RawValue(0), &done);
+  __ BranchEqual(T2, Immediate(Smi::RawValue(0)), &done);
   __ delay_slot()->mov(V0, ZR);
 
   __ SmiUntag(T2);
   __ AddImmediate(T3, T1, OneByteString::data_offset() - kHeapObjectTag);
   __ addu(T4, T3, T2);
   // V0: Hash code, untagged integer.
   // T1: Instance of OneByteString.
   // T2: String length, untagged integer.
   // T3: String data start.
   // T4: String data end.
@@ skipping 83 matching lines @@
   __ UpdateAllocationStatsWithSize(cid, T2, T3, space);
 
   // Initialize the tags.
   // V0: new object start as a tagged pointer.
   // T1: new object end address.
   // T2: allocation size.
   {
     Label overflow, done;
     const intptr_t shift = RawObject::kSizeTagPos - kObjectAlignmentLog2;
 
-    __ BranchUnsignedGreater(T2, RawObject::SizeTag::kMaxSizeTag, &overflow);
+    __ BranchUnsignedGreater(
+        T2, Immediate(RawObject::SizeTag::kMaxSizeTag), &overflow);
     __ b(&done);
     __ delay_slot()->sll(T2, T2, shift);
     __ Bind(&overflow);
     __ mov(T2, ZR);
     __ Bind(&done);
 
     // Get the class index and insert it into the tags.
     // T2: size and bit tags.
     __ LoadImmediate(TMP, RawObject::ClassIdTag::encode(cid));
     __ or_(T2, T2, TMP);
@@ skipping 99 matching lines @@
   __ lw(T0, Address(SP, 1 * kWordSize));  // This.
   __ lw(T1, Address(SP, 0 * kWordSize));  // Other.
 
   // Are identical?
   __ beq(T0, T1, &is_true);
 
   // Is other OneByteString?
   __ andi(CMPRES1, T1, Immediate(kSmiTagMask));
   __ beq(CMPRES1, ZR, &fall_through);  // Other is Smi.
   __ LoadClassId(CMPRES1, T1);  // Class ID check.
-  __ BranchNotEqual(CMPRES1, string_cid, &fall_through);
+  __ BranchNotEqual(CMPRES1, Immediate(string_cid), &fall_through);
 
   // Have same length?
   __ lw(T2, FieldAddress(T0, String::length_offset()));
   __ lw(T3, FieldAddress(T1, String::length_offset()));
   __ bne(T2, T3, &is_false);
 
   // Check contents, no fall-through possible.
   ASSERT((string_cid == kOneByteStringCid) ||
          (string_cid == kTwoByteStringCid));
   __ SmiUntag(T2);
   __ Bind(&loop);
   __ AddImmediate(T2, -1);
-  __ BranchSignedLess(T2, 0, &is_true);
+  __ BranchSignedLess(T2, Immediate(0), &is_true);
   if (string_cid == kOneByteStringCid) {
     __ lbu(V0, FieldAddress(T0, OneByteString::data_offset()));
     __ lbu(V1, FieldAddress(T1, OneByteString::data_offset()));
     __ AddImmediate(T0, 1);
     __ AddImmediate(T1, 1);
   } else if (string_cid == kTwoByteStringCid) {
     __ lhu(V0, FieldAddress(T0, OneByteString::data_offset()));
     __ lhu(V1, FieldAddress(T1, OneByteString::data_offset()));
     __ AddImmediate(T0, 2);
     __ AddImmediate(T1, 2);
@@ skipping 58 matching lines @@
   Isolate* isolate = Isolate::Current();
   __ LoadImmediate(V0, reinterpret_cast<uword>(isolate));
   // Set return value.
   __ Ret();
   __ delay_slot()->lw(V0, Address(V0, Isolate::current_tag_offset()));
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_MIPS