Some assembler-level optimizations on ARM.

src/arm/builtins-arm.cc

 // Copyright 2012 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 118 matching lines @@
                         gc_required,
                         TAG_OBJECT);
 
   // Allocated the JSArray. Now initialize the fields except for the elements
   // array.
   // result: JSObject
   // scratch1: initial map
   // scratch2: start of next object
   __ str(scratch1, FieldMemOperand(result, JSObject::kMapOffset));
   __ LoadRoot(scratch1, Heap::kEmptyFixedArrayRootIndex);
-  __ str(scratch1, FieldMemOperand(result, JSArray::kPropertiesOffset));
   // Field JSArray::kElementsOffset is initialized later.
   __ mov(scratch3,  Operand(0, RelocInfo::NONE));
   __ str(scratch3, FieldMemOperand(result, JSArray::kLengthOffset));
+  // scratch1: empty FixedArray
+  __ str(scratch1, FieldMemOperand(result, JSArray::kPropertiesOffset));
 
   if (initial_capacity == 0) {
     __ str(scratch1, FieldMemOperand(result, JSArray::kElementsOffset));
     return;
   }
 
   // Calculate the location of the elements array and set elements array member
   // of the JSArray.
   // result: JSObject
   // scratch2: start of next object
   __ add(scratch1, result, Operand(JSArray::kSize));
   __ str(scratch1, FieldMemOperand(result, JSArray::kElementsOffset));
 
+  __ LoadRoot(scratch3, Heap::kFixedArrayMapRootIndex);

[ulan, 2012/01/27 13:19:11]

In this case it seems to reduce readability. I think such optimizations should
be done on hot paths only.

+
   // Clear the heap tag on the elements array.
   __ sub(scratch1, scratch1, Operand(kHeapObjectTag));
 
   // Initialize the FixedArray and fill it with holes. FixedArray length is
   // stored as a smi.
   // result: JSObject
   // scratch1: elements array (untagged)
   // scratch2: start of next object
-  __ LoadRoot(scratch3, Heap::kFixedArrayMapRootIndex);
+  // scratch3: FixedArray map
   STATIC_ASSERT(0 * kPointerSize == FixedArray::kMapOffset);
   __ str(scratch3, MemOperand(scratch1, kPointerSize, PostIndex));
   __ mov(scratch3,  Operand(Smi::FromInt(initial_capacity)));
   STATIC_ASSERT(1 * kPointerSize == FixedArray::kLengthOffset);
   __ str(scratch3, MemOperand(scratch1, kPointerSize, PostIndex));
 
   // Fill the FixedArray with the hole value. Inline the code if short.
   STATIC_ASSERT(2 * kPointerSize == FixedArray::kHeaderSize);
   __ LoadRoot(scratch3, Heap::kTheHoleValueRootIndex);
   static const int kLoopUnfoldLimit = 4;
@@ skipping 70 matching lines @@
   __ str(array_size, FieldMemOperand(result, JSArray::kLengthOffset));
 
   // Calculate the location of the elements array and set elements array member
   // of the JSArray.
   // result: JSObject
   // array_size: size of array (smi)
   __ add(elements_array_storage, result, Operand(JSArray::kSize));
   __ str(elements_array_storage,
          FieldMemOperand(result, JSArray::kElementsOffset));
 
+  __ LoadRoot(scratch1, Heap::kFixedArrayMapRootIndex);

[ulan, 2012/01/27 13:19:11]

Ditto.

+
   // Clear the heap tag on the elements array.
   STATIC_ASSERT(kSmiTag == 0);
   __ sub(elements_array_storage,
          elements_array_storage,
          Operand(kHeapObjectTag));
   // Initialize the fixed array and fill it with holes. FixedArray length is
   // stored as a smi.
   // result: JSObject
   // elements_array_storage: elements array (untagged)
   // array_size: size of array (smi)
-  __ LoadRoot(scratch1, Heap::kFixedArrayMapRootIndex);
+  // scratch1: FixedArray map
   ASSERT_EQ(0 * kPointerSize, FixedArray::kMapOffset);
   __ str(scratch1, MemOperand(elements_array_storage, kPointerSize, PostIndex));
   STATIC_ASSERT(kSmiTag == 0);
   ASSERT_EQ(1 * kPointerSize, FixedArray::kLengthOffset);
   __ str(array_size,
          MemOperand(elements_array_storage, kPointerSize, PostIndex));
 
   // Calculate elements array and elements array end.
   // result: JSObject
   // elements_array_storage: elements array element storage
@@ skipping 1493 matching lines @@
   __ bind(&dont_adapt_arguments);
   __ Jump(r3);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_ARM