More compact string representation on 64 bit.

runtime/vm/intrinsifier_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/intrinsifier.h"
 
 #include "vm/assembler.h"
@@ skipping 178 matching lines @@
   __ tsti(R2, Immediate(kSmiTagMask));                                         \
   __ b(&fall_through, NE);                                                     \
   __ CompareRegisters(R2, ZR);                                                 \
   __ b(&fall_through, LT);                                                     \
   __ SmiUntag(R2);                                                             \
   /* Check for maximum allowed length. */                                      \
   /* R2: untagged array length. */                                             \
   __ CompareImmediate(R2, max_len);                                            \
   __ b(&fall_through, GT);                                                     \
   __ LslImmediate(R2, R2, scale_shift);                                        \
-  const intptr_t fixed_size = sizeof(Raw##type_name) + kObjectAlignment - 1;   \
-  __ AddImmediate(R2, fixed_size);                                             \
+  const intptr_t fixed_size_plus_alignment_padding =                           \
+      sizeof(Raw##type_name) + kObjectAlignment - 1;                           \
+  __ AddImmediate(R2, fixed_size_plus_alignment_padding);                      \
   __ andi(R2, R2, Immediate(~(kObjectAlignment - 1)));                         \
   Heap::Space space = Heap::kNew;                                              \
   __ ldr(R3, Address(THR, Thread::heap_offset()));                             \
   __ ldr(R0, Address(R3, Heap::TopOffset(space)));                             \
                                                                                \
   /* R2: allocation size. */                                                   \
   __ adds(R1, R0, Operand(R2));                                                \
   __ b(&fall_through, CS); /* Fail on unsigned overflow. */                    \
                                                                                \
   /* Check if the allocation fits into the remaining space. */                 \
@@ skipping 1604 matching lines @@
   __ LoadObject(R0, Bool::False());
   __ ret();
 
   __ Bind(&fall_through);
 }
 
 
 void Intrinsifier::String_getHashCode(Assembler* assembler) {
   Label fall_through;
   __ ldr(R0, Address(SP, 0 * kWordSize));
-  __ ldr(R0, FieldAddress(R0, String::hash_offset()));
-  __ CompareRegisters(R0, ZR);
+  __ ldr(R0, FieldAddress(R0, String::hash_offset()), kUnsignedWord);
+  __ adds(R0, R0, Operand(R0));  // Smi tag the hash code, setting Z flag.
   __ b(&fall_through, EQ);
   __ ret();
   // Hash not yet computed.
   __ Bind(&fall_through);
 }
 
 
 void GenerateSubstringMatchesSpecialization(Assembler* assembler,
                                             intptr_t receiver_cid,
                                             intptr_t other_cid,
@@ skipping 151 matching lines @@
   __ LoadObject(R0, Bool::True());
   __ LoadObject(TMP, Bool::False());
   __ csel(R0, TMP, R0, NE);
   __ ret();
 }
 
 
 void Intrinsifier::OneByteString_getHashCode(Assembler* assembler) {
   Label compute_hash;
   __ ldr(R1, Address(SP, 0 * kWordSize));  // OneByteString object.
-  __ ldr(R0, FieldAddress(R1, String::hash_offset()));
-  __ CompareRegisters(R0, ZR);
+  __ ldr(R0, FieldAddress(R1, String::hash_offset()), kUnsignedWord);
+  __ adds(R0, R0, Operand(R0));  // Smi tag the hash code, setting Z flag.
   __ b(&compute_hash, EQ);
   __ ret();  // Return if already computed.
 
   __ Bind(&compute_hash);
   __ ldr(R2, FieldAddress(R1, String::length_offset()));
   __ SmiUntag(R2);
 
   Label done;
   // If the string is empty, set the hash to 1, and return.
   __ CompareRegisters(R2, ZR);
@@ skipping 29 matching lines @@
   // hash_ += hash_ << 15;
   __ addw(R0, R0, Operand(R0, LSL, 3));
   __ eorw(R0, R0, Operand(R0, LSR, 11));
   __ addw(R0, R0, Operand(R0, LSL, 15));
   // hash_ = hash_ & ((static_cast<intptr_t>(1) << bits) - 1);
   __ AndImmediate(R0, R0, (static_cast<intptr_t>(1) << String::kHashBits) - 1);
   __ CompareRegisters(R0, ZR);
   // return hash_ == 0 ? 1 : hash_;
   __ Bind(&done);
   __ csinc(R0, R0, ZR, NE);  // R0 <- (R0 != 0) ? R0 : (ZR + 1).
+  __ str(R0, FieldAddress(R1, String::hash_offset()), kUnsignedWord);
   __ SmiTag(R0);
-  __ str(R0, FieldAddress(R1, String::hash_offset()));
   __ ret();
 }
 
 
 // Allocates one-byte string of length 'end - start'. The content is not
 // initialized.
 // 'length-reg' (R2) contains tagged length.
 // Returns new string as tagged pointer in R0.
 static void TryAllocateOnebyteString(Assembler* assembler,
                                      Label* ok,
                                      Label* failure) {
   const Register length_reg = R2;
   Label fail;
   NOT_IN_PRODUCT(__ MaybeTraceAllocation(kOneByteStringCid, R0, failure));
   __ mov(R6, length_reg);  // Save the length register.
   // TODO(koda): Protect against negative length and overflow here.
-  __ SmiUntag(length_reg);
-  const intptr_t fixed_size = sizeof(RawString) + kObjectAlignment - 1;
-  __ AddImmediate(length_reg, fixed_size);
+  __ adds(length_reg, ZR, Operand(length_reg, ASR, kSmiTagSize));  // Smi untag.
+  // If the length is 0 then we have to make the allocated size a bit bigger,
+  // otherwise the string takes up less space than an ExternalOneByteString,
+  // and cannot be externalized.  TODO(erikcorry): We should probably just
+  // return a static zero length string here instead.
+  // length <- (length != 0) ? length : (ZR + 1).
+  __ csinc(length_reg, length_reg, ZR, NE);
+  const intptr_t fixed_size_plus_alignment_padding =
+      sizeof(RawString) + kObjectAlignment - 1;
+  __ AddImmediate(length_reg, fixed_size_plus_alignment_padding);
   __ andi(length_reg, length_reg, Immediate(~(kObjectAlignment - 1)));
 
   const intptr_t cid = kOneByteStringCid;
   Heap::Space space = Heap::kNew;
   __ ldr(R3, Address(THR, Thread::heap_offset()));
   __ ldr(R0, Address(R3, Heap::TopOffset(space)));
 
   // length_reg: allocation size.
   __ adds(R1, R0, Operand(length_reg));
   __ b(&fail, CS);  // Fail on unsigned overflow.
@@ skipping 19 matching lines @@
   // R2: allocation size.
   {
     const intptr_t shift = RawObject::kSizeTagPos - kObjectAlignmentLog2;
 
     __ CompareImmediate(R2, RawObject::SizeTag::kMaxSizeTag);
     __ LslImmediate(R2, R2, shift);
     __ csel(R2, R2, ZR, LS);
 
     // Get the class index and insert it into the tags.
     // R2: size and bit tags.
+    // This also clears the hash, which is in the high word of the tags.
     __ LoadImmediate(TMP, RawObject::ClassIdTag::encode(cid));
     __ orr(R2, R2, Operand(TMP));
     __ str(R2, FieldAddress(R0, String::tags_offset()));  // Store tags.
   }
 
   // Set the length field using the saved length (R6).
   __ StoreIntoObjectNoBarrier(R0, FieldAddress(R0, String::length_offset()),
                               R6);
-  // Clear hash.
-  __ mov(TMP, ZR);
-  __ str(TMP, FieldAddress(R0, String::hash_offset()));
   __ b(ok);
 
   __ Bind(&fail);
   __ b(failure);
 }
 
 
 // Arg0: OneByteString (receiver).
 // Arg1: Start index as Smi.
 // Arg2: End index as Smi.
@@ skipping 247 matching lines @@
 
 void Intrinsifier::SetAsyncThreadStackTrace(Assembler* assembler) {
   __ ldr(R0, Address(THR, Thread::async_stack_trace_offset()));
   __ LoadObject(R0, Object::null_object());
   __ ret();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM64