More compact string representation on 64 bit.

runtime/vm/intrinsifier_ia32.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.
 //
 // The intrinsic code below is executed before a method has built its frame.
 // The return address is on the stack and the arguments below it.
 // Registers EDX (arguments descriptor) and ECX (function) must be preserved.
 // Each intrinsification method returns true if the corresponding
 // Dart method was intrinsified.
 
@@ skipping 194 matching lines @@
   /* EDI: untagged array length. */                                            \
   __ cmpl(EDI, Immediate(max_len));                                            \
   __ j(GREATER, &fall_through);                                                \
   /* Special case for scaling by 16. */                                        \
   if (scale_factor == TIMES_16) {                                              \
     /* double length of array. */                                              \
     __ addl(EDI, EDI);                                                         \
     /* only scale by 8. */                                                     \
     scale_factor = TIMES_8;                                                    \
   }                                                                            \
-  const intptr_t fixed_size = sizeof(Raw##type_name) + kObjectAlignment - 1;   \
-  __ leal(EDI, Address(EDI, scale_factor, fixed_size));                        \
+  const intptr_t fixed_size_plus_alignment_padding =                           \
+      sizeof(Raw##type_name) + kObjectAlignment - 1;                           \
+  __ leal(EDI, Address(EDI, scale_factor, fixed_size_plus_alignment_padding)); \
   __ andl(EDI, Immediate(-kObjectAlignment));                                  \
   Heap::Space space = Heap::kNew;                                              \
   __ movl(ECX, Address(THR, Thread::heap_offset()));                           \
   __ movl(EAX, Address(ECX, Heap::TopOffset(space)));                          \
   __ movl(EBX, EAX);                                                           \
                                                                                \
   /* EDI: allocation size. */                                                  \
   __ addl(EBX, EDI);                                                           \
   __ j(CARRY, &fall_through);                                                  \
                                                                                \
@@ skipping 1793 matching lines @@
                                      Label* failure,
                                      Register length_reg) {
   NOT_IN_PRODUCT(
       __ MaybeTraceAllocation(kOneByteStringCid, EAX, failure, false));
   if (length_reg != EDI) {
     __ movl(EDI, length_reg);
   }
   Label pop_and_fail;
   __ pushl(EDI);  // Preserve length.
   __ SmiUntag(EDI);
-  const intptr_t fixed_size = sizeof(RawString) + kObjectAlignment - 1;
-  __ leal(EDI, Address(EDI, TIMES_1, fixed_size));  // EDI is untagged.
+  const intptr_t fixed_size_plus_alignment_padding =
+      sizeof(RawString) + kObjectAlignment - 1;
+  __ leal(EDI, Address(EDI, TIMES_1,
+                       fixed_size_plus_alignment_padding));  // EDI is untagged.
   __ andl(EDI, Immediate(-kObjectAlignment));
 
   const intptr_t cid = kOneByteStringCid;
   Heap::Space space = Heap::kNew;
   __ movl(ECX, Address(THR, Thread::heap_offset()));
   __ movl(EAX, Address(ECX, Heap::TopOffset(space)));
   __ movl(EBX, EAX);
 
   // EDI: allocation size.
   __ addl(EBX, EDI);
@@ skipping 286 matching lines @@
   __ movl(Address(THR, Thread::async_stack_trace_offset()), EAX);
   __ LoadObject(EAX, Object::null_object());
   __ ret();
 }
 
 #undef __
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32