Revert "Changing string length field type from int to SMI."

src/arm/codegen-arm.cc

 // Copyright 2010 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 3960 matching lines @@
   ASSERT(kSmiTag == 0);
   __ tst(r0, Operand(kSmiTagMask | 0x80000000u));
   __ b(ne, &slow);  // The index was negative or not a Smi.
 
   __ bind(&try_again_with_new_string);
   __ CompareObjectType(r1, r2, r2, FIRST_NONSTRING_TYPE);
   __ b(ge, &slow);
 
   // Now r2 has the string type.
   __ ldr(r3, FieldMemOperand(r1, String::kLengthOffset));
-  // Now r3 has the length of the string. Compare with the index.
-  __ cmp(r3, Operand(r0));
+  // Now r3 has the length of the string.  Compare with the index.
+  __ cmp(r3, Operand(r0, LSR, kSmiTagSize));
   __ b(le, &slow);
 
   // Here we know the index is in range.  Check that string is sequential.
   ASSERT_EQ(0, kSeqStringTag);
   __ tst(r2, Operand(kStringRepresentationMask));
   __ b(ne, &not_a_flat_string);
 
   // Check whether it is an ASCII string.
   ASSERT_EQ(0, kTwoByteStringTag);
   __ tst(r2, Operand(kStringEncodingMask));
@@ skipping 4388 matching lines @@
   // Check that the second argument is a string.
   __ ldr(subject, MemOperand(sp, kSubjectOffset));
   __ tst(subject, Operand(kSmiTagMask));
   __ b(eq, &runtime);
   Condition is_string = masm->IsObjectStringType(subject, r0);
   __ b(NegateCondition(is_string), &runtime);
   // Get the length of the string to r3.
   __ ldr(r3, FieldMemOperand(subject, String::kLengthOffset));
 
   // r2: Number of capture registers
-  // r3: Length of subject string as a smi
+  // r3: Length of subject string
   // subject: Subject string
   // regexp_data: RegExp data (FixedArray)
   // Check that the third argument is a positive smi less than the subject
   // string length. A negative value will be greater (unsigned comparison).
   __ ldr(r0, MemOperand(sp, kPreviousIndexOffset));
-  __ tst(r0, Operand(kSmiTagMask));
-  __ b(eq, &runtime);
-  __ cmp(r3, Operand(r0));
-  __ b(le, &runtime);
+  __ cmp(r3, Operand(r0, ASR, kSmiTagSize + kSmiShiftSize));
+  __ b(ls, &runtime);
 
   // r2: Number of capture registers
   // subject: Subject string
   // regexp_data: RegExp data (FixedArray)
   // Check that the fourth object is a JSArray object.
   __ ldr(r0, MemOperand(sp, kLastMatchInfoOffset));
   __ tst(r0, Operand(kSmiTagMask));
   __ b(eq, &runtime);
   __ CompareObjectType(r0, r1, r1, JS_ARRAY_TYPE);
   __ b(ne, &runtime);
@@ skipping 105 matching lines @@
   __ add(r0, r0, Operand(r2));
   __ str(r0, MemOperand(sp, 1 * kPointerSize));
 
   // Argument 5 (sp[0]): static offsets vector buffer.
   __ mov(r0, Operand(ExternalReference::address_of_static_offsets_vector()));
   __ str(r0, MemOperand(sp, 0 * kPointerSize));
 
   // For arguments 4 and 3 get string length, calculate start of string data and
   // calculate the shift of the index (0 for ASCII and 1 for two byte).
   __ ldr(r0, FieldMemOperand(subject, String::kLengthOffset));
-  __ mov(r0, Operand(r0, ASR, kSmiTagSize));
   ASSERT_EQ(SeqAsciiString::kHeaderSize, SeqTwoByteString::kHeaderSize);
   __ add(r9, subject, Operand(SeqAsciiString::kHeaderSize - kHeapObjectTag));
   __ eor(r3, r3, Operand(1));
   // Argument 4 (r3): End of string data
   // Argument 3 (r2): Start of string data
   __ add(r2, r9, Operand(r1, LSL, r3));
   __ add(r3, r9, Operand(r0, LSL, r3));
 
   // Argument 2 (r1): Previous index.
   // Already there
@@ skipping 487 matching lines @@
                       candidate,
                       LSL,
                       kPointerSizeLog2));
 
     // If entry is undefined no string with this hash can be found.
     __ cmp(candidate, undefined);
     __ b(eq, not_found);
 
     // If length is not 2 the string is not a candidate.
     __ ldr(scratch, FieldMemOperand(candidate, String::kLengthOffset));
-    __ cmp(scratch, Operand(Smi::FromInt(2)));
+    __ cmp(scratch, Operand(2));
     __ b(ne, &next_probe[i]);
 
     // Check that the candidate is a non-external ascii string.
     __ ldr(scratch, FieldMemOperand(candidate, HeapObject::kMapOffset));
     __ ldrb(scratch, FieldMemOperand(scratch, Map::kInstanceTypeOffset));
     __ JumpIfInstanceTypeIsNotSequentialAscii(scratch, scratch,
                                               &next_probe[i]);
 
     // Check if the two characters match.
     // Assumes that word load is little endian.
@@ skipping 130 matching lines @@
   // Definitly a sequential string.
   __ bind(&seq_string);
 
   // r1: instance type.
   // r2: length
   // r3: from index (untaged smi)
   // r5: string
   // r6: from (smi)
   // r7: to (smi)
   __ ldr(r4, FieldMemOperand(r5, String::kLengthOffset));
-  __ cmp(r4, Operand(r7));
+  __ cmp(r4, Operand(r7, ASR, 1));
   __ b(lt, &runtime);  // Fail if to > length.
 
   // r1: instance type.
   // r2: result string length.
   // r3: from index (untaged smi)
   // r5: string.
   // r6: from offset (smi)
   // Check for flat ascii string.
   Label non_ascii_flat;
   __ tst(r1, Operand(kStringEncodingMask));
@@ skipping 98 matching lines @@
                                                         Register scratch3,
                                                         Register scratch4) {
   Label compare_lengths;
   // Find minimum length and length difference.
   __ ldr(scratch1, FieldMemOperand(left, String::kLengthOffset));
   __ ldr(scratch2, FieldMemOperand(right, String::kLengthOffset));
   __ sub(scratch3, scratch1, Operand(scratch2), SetCC);
   Register length_delta = scratch3;
   __ mov(scratch1, scratch2, LeaveCC, gt);
   Register min_length = scratch1;
-  ASSERT(kSmiTag == 0);
   __ tst(min_length, Operand(min_length));
   __ b(eq, &compare_lengths);
 
-  // Untag smi.
-  __ mov(min_length, Operand(min_length, ASR, kSmiTagSize));
-
   // Setup registers so that we only need to increment one register
   // in the loop.
   __ add(scratch2, min_length,
          Operand(SeqAsciiString::kHeaderSize - kHeapObjectTag));
   __ add(left, left, Operand(scratch2));
   __ add(right, right, Operand(scratch2));
   // Registers left and right points to the min_length character of strings.
   __ rsb(min_length, min_length, Operand(-1));
   Register index = min_length;
   // Index starts at -min_length.
@@ skipping 89 matching lines @@
   // Both arguments are strings.
   // r0: first string
   // r1: second string
   // r4: first string instance type (if string_check_)
   // r5: second string instance type (if string_check_)
   {
     Label strings_not_empty;
     // Check if either of the strings are empty. In that case return the other.
     __ ldr(r2, FieldMemOperand(r0, String::kLengthOffset));
     __ ldr(r3, FieldMemOperand(r1, String::kLengthOffset));
-    ASSERT(kSmiTag == 0);
-    __ cmp(r2, Operand(Smi::FromInt(0)));  // Test if first string is empty.
+    __ cmp(r2, Operand(0));  // Test if first string is empty.
     __ mov(r0, Operand(r1), LeaveCC, eq);  // If first is empty, return second.
-    ASSERT(kSmiTag == 0);
-     // Else test if second string is empty.
-    __ cmp(r3, Operand(Smi::FromInt(0)), ne);
+    __ cmp(r3, Operand(0), ne);  // Else test if second string is empty.
     __ b(ne, &strings_not_empty);  // If either string was empty, return r0.
 
     __ IncrementCounter(&Counters::string_add_native, 1, r2, r3);
     __ add(sp, sp, Operand(2 * kPointerSize));
     __ Ret();
 
     __ bind(&strings_not_empty);
   }
 
-  __ mov(r2, Operand(r2, ASR, kSmiTagSize));
-  __ mov(r3, Operand(r3, ASR, kSmiTagSize));
   // Both strings are non-empty.
   // r0: first string
   // r1: second string
   // r2: length of first string
   // r3: length of second string
   // r4: first string instance type (if string_check_)
   // r5: second string instance type (if string_check_)
   // Look at the length of the result of adding the two strings.
   Label string_add_flat_result, longer_than_two;
   // Adding two lengths can't overflow.
@@ skipping 188 matching lines @@
 
   // Just jump to runtime to add the two strings.
   __ bind(&string_add_runtime);
   __ TailCallRuntime(Runtime::kStringAdd, 2, 1);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal