More compact string representation on 64 bit.

runtime/vm/intrinsifier_x64.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_X64.
 #if defined(TARGET_ARCH_X64)
 
 #include "vm/intrinsifier.h"
 
 #include "vm/assembler.h"
@@ skipping 152 matching lines @@
   /* RDI: untagged array length. */                                            \
   __ cmpq(RDI, Immediate(max_len));                                            \
   __ j(GREATER, &fall_through);                                                \
   /* Special case for scaling by 16. */                                        \
   if (scale_factor == TIMES_16) {                                              \
     /* double length of array. */                                              \
     __ addq(RDI, RDI);                                                         \
     /* only scale by 8. */                                                     \
     scale_factor = TIMES_8;                                                    \
   }                                                                            \
-  const intptr_t fixed_size = sizeof(Raw##type_name) + kObjectAlignment - 1;   \
-  __ leaq(RDI, Address(RDI, scale_factor, fixed_size));                        \
+  const intptr_t fixed_size_plus_alignment_padding =                           \
+      sizeof(Raw##type_name) + kObjectAlignment - 1;                           \
+  __ leaq(RDI, Address(RDI, scale_factor, fixed_size_plus_alignment_padding)); \
   __ andq(RDI, Immediate(-kObjectAlignment));                                  \
   Heap::Space space = Heap::kNew;                                              \
   __ movq(R13, Address(THR, Thread::heap_offset()));                           \
   __ movq(RAX, Address(R13, Heap::TopOffset(space)));                          \
   __ movq(RCX, RAX);                                                           \
                                                                                \
   /* RDI: allocation size. */                                                  \
   __ addq(RCX, RDI);                                                           \
   __ j(CARRY, &fall_through);                                                  \
                                                                                \
@@ skipping 1550 matching lines @@
   __ LoadObject(RAX, Bool::False());
   __ ret();
 
   __ Bind(&fall_through);
 }
 
 
 void Intrinsifier::String_getHashCode(Assembler* assembler) {
   Label fall_through;
   __ movq(RAX, Address(RSP, +1 * kWordSize));  // String object.
-  __ movq(RAX, FieldAddress(RAX, String::hash_offset()));
-  __ cmpq(RAX, Immediate(0));
-  __ j(EQUAL, &fall_through, Assembler::kNearJump);
+  __ movl(RAX, FieldAddress(RAX, String::hash_offset()));
+  ASSERT(kSmiTag == 0);
+  ASSERT(kSmiTagShift == 1);
+  __ addq(RAX, RAX);  // Smi tag RAX, setting Z flag.
+  __ j(ZERO, &fall_through, Assembler::kNearJump);
   __ ret();
   __ Bind(&fall_through);
   // Hash not yet computed.
 }
 
 
 void GenerateSubstringMatchesSpecialization(Assembler* assembler,
                                             intptr_t receiver_cid,
                                             intptr_t other_cid,
                                             Label* return_true,
@@ skipping 146 matching lines @@
   __ ret();
   __ Bind(&is_true);
   __ LoadObject(RAX, Bool::True());
   __ ret();
 }
 
 
 void Intrinsifier::OneByteString_getHashCode(Assembler* assembler) {
   Label compute_hash;
   __ movq(RBX, Address(RSP, +1 * kWordSize));  // OneByteString object.
-  __ movq(RAX, FieldAddress(RBX, String::hash_offset()));
+  __ movl(RAX, FieldAddress(RBX, String::hash_offset()));
   __ cmpq(RAX, Immediate(0));
   __ j(EQUAL, &compute_hash, Assembler::kNearJump);
+  __ SmiTag(RAX);
   __ ret();
 
   __ Bind(&compute_hash);
   // Hash not yet computed, use algorithm of class StringHasher.
   __ movq(RCX, FieldAddress(RBX, String::length_offset()));
   __ SmiUntag(RCX);
   __ xorq(RAX, RAX);
   __ xorq(RDI, RDI);
   // RBX: Instance of OneByteString.
   // RCX: String length, untagged integer.
@@ skipping 37 matching lines @@
   __ addl(RAX, RDX);
   // hash_ = hash_ & ((static_cast<intptr_t>(1) << bits) - 1);
   __ andl(RAX,
           Immediate(((static_cast<intptr_t>(1) << String::kHashBits) - 1)));
 
   // return hash_ == 0 ? 1 : hash_;
   __ cmpq(RAX, Immediate(0));
   __ j(NOT_EQUAL, &set_hash_code, Assembler::kNearJump);
   __ incq(RAX);
   __ Bind(&set_hash_code);
+  __ movl(FieldAddress(RBX, String::hash_offset()), RAX);
   __ SmiTag(RAX);
-  __ StoreIntoSmiField(FieldAddress(RBX, String::hash_offset()), RAX);
   __ ret();
 }
 
 
 // Allocates one-byte string of length 'end - start'. The content is not
 // initialized. 'length-reg' contains tagged length.
 // Returns new string as tagged pointer in RAX.
 static void TryAllocateOnebyteString(Assembler* assembler,
                                      Label* ok,
                                      Label* failure,
                                      Register length_reg) {
   NOT_IN_PRODUCT(__ MaybeTraceAllocation(kOneByteStringCid, failure, false));
   if (length_reg != RDI) {
     __ movq(RDI, length_reg);
   }
-  Label pop_and_fail;
+  Label pop_and_fail, not_zero_length;
   __ pushq(RDI);  // Preserve length.
-  __ SmiUntag(RDI);
-  const intptr_t fixed_size = sizeof(RawString) + kObjectAlignment - 1;
-  __ leaq(RDI, Address(RDI, TIMES_1, fixed_size));  // RDI is a Smi.
+  __ sarq(RDI, Immediate(kSmiTagShift));  // Untag length.
+  // 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.
+  __ j(NOT_ZERO, &not_zero_length);
+  __ addq(RDI, Immediate(1));
+  __ Bind(&not_zero_length);
+  const intptr_t fixed_size_plus_alignment_padding =
+      sizeof(RawString) + kObjectAlignment - 1;
+  __ addq(RDI, Immediate(fixed_size_plus_alignment_padding));
   __ andq(RDI, Immediate(-kObjectAlignment));
 
   const intptr_t cid = kOneByteStringCid;
   Heap::Space space = Heap::kNew;
   __ movq(R13, Address(THR, Thread::heap_offset()));
   __ movq(RAX, Address(R13, Heap::TopOffset(space)));
 
   // RDI: allocation size.
   __ movq(RCX, RAX);
   __ addq(RCX, RDI);
@@ skipping 21 matching lines @@
     __ cmpq(RDI, Immediate(RawObject::SizeTag::kMaxSizeTag));
     __ j(ABOVE, &size_tag_overflow, Assembler::kNearJump);
     __ shlq(RDI, Immediate(RawObject::kSizeTagPos - kObjectAlignmentLog2));
     __ jmp(&done, Assembler::kNearJump);
 
     __ Bind(&size_tag_overflow);
     __ xorq(RDI, RDI);
     __ Bind(&done);
 
     // Get the class index and insert it into the tags.
+    // This also clears the hash, which is in the high bits of the tags.
     __ orq(RDI, Immediate(RawObject::ClassIdTag::encode(cid)));
     __ movq(FieldAddress(RAX, String::tags_offset()), RDI);  // Tags.
   }
 
   // Set the length field.
   __ popq(RDI);
   __ StoreIntoObjectNoBarrier(RAX, FieldAddress(RAX, String::length_offset()),
                               RDI);
-  // Clear hash.
-  __ ZeroInitSmiField(FieldAddress(RAX, String::hash_offset()));
   __ jmp(ok, Assembler::kNearJump);
 
   __ Bind(&pop_and_fail);
   __ popq(RDI);
   __ jmp(failure);
 }
 
 
 // Arg0: OneByteString (receiver).
 // Arg1: Start index as Smi.
@@ skipping 234 matching lines @@
   __ movq(Address(THR, Thread::async_stack_trace_offset()), RAX);
   __ LoadObject(RAX, Object::null_object());
   __ ret();
 }
 
 #undef __
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64