Add support for ldrd/strd from Kun Zhang (zhangk@codeaurora.org), Code Aurora

src/arm/codegen-arm.cc

 // Copyright 2006-2009 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 1872 matching lines @@
   // sp[0] : index
   // sp[1] : array/enum cache length
   // sp[2] : array or enum cache
   // sp[3] : 0 or map
   // sp[4] : enumerable
   // Grab the current frame's height for the break and continue
   // targets only after all the state is pushed on the frame.
   node->break_target()->set_direction(JumpTarget::FORWARD_ONLY);
   node->continue_target()->set_direction(JumpTarget::FORWARD_ONLY);
 
-  __ ldr(r0, frame_->ElementAt(0));  // load the current count
-  __ ldr(r1, frame_->ElementAt(1));  // load the length
+  // load the current count to r0, load the length to r1

[Erik Corry, 2010/05/04 07:06:13]

When we are reformatting comments we should take the oportunity to format them
correctly with capital letters and full stops.

[zhangk, 2010/05/07 05:32:14]

On 2010/05/04 07:06:13, Erik Corry wrote:

Done.

+  __ ldrd(r0, frame_->ElementAt(0));
   __ cmp(r0, Operand(r1));  // compare to the array length
   node->break_target()->Branch(hs);
 
   __ ldr(r0, frame_->ElementAt(0));
 
   // Get the i'th entry of the array.
   __ ldr(r2, frame_->ElementAt(2));
   __ add(r2, r2, Operand(FixedArray::kHeaderSize - kHeapObjectTag));
   __ ldr(r3, MemOperand(r2, r0, LSL, kPointerSizeLog2 - kSmiTagSize));
 
@@ skipping 3457 matching lines @@
   if (mode == OVERWRITE_RIGHT) {
     __ mov(r5, Operand(r0));  // Overwrite this heap number.
   }
   if (CpuFeatures::IsSupported(VFP3) && Token::MOD != operation) {
     CpuFeatures::Scope scope(VFP3);
     // Load the double from tagged HeapNumber r0 to d7.
     __ sub(r7, r0, Operand(kHeapObjectTag));
     __ vldr(d7, r7, HeapNumber::kValueOffset);
   } else {
     // Calling convention says that second double is in r2 and r3.
-    __ ldr(r2, FieldMemOperand(r0, HeapNumber::kValueOffset));
-    __ ldr(r3, FieldMemOperand(r0, HeapNumber::kValueOffset + 4));
+    __ ldrd(r2, FieldMemOperand(r0, HeapNumber::kValueOffset));
   }
   __ jmp(&finished_loading_r0);
   __ bind(&r0_is_smi);
   if (mode == OVERWRITE_RIGHT) {
     // We can't overwrite a Smi so get address of new heap number into r5.
     AllocateHeapNumber(masm, &slow, r5, r6, r7);
   }
 
   if (CpuFeatures::IsSupported(VFP3) && Token::MOD != operation) {
     CpuFeatures::Scope scope(VFP3);
@@ skipping 20 matching lines @@
   if (mode == OVERWRITE_LEFT) {
     __ mov(r5, Operand(r1));  // Overwrite this heap number.
   }
   if (CpuFeatures::IsSupported(VFP3) && Token::MOD != operation) {
     CpuFeatures::Scope scope(VFP3);
     // Load the double from tagged HeapNumber r1 to d6.
     __ sub(r7, r1, Operand(kHeapObjectTag));
     __ vldr(d6, r7, HeapNumber::kValueOffset);
   } else {
     // Calling convention says that first double is in r0 and r1.
-    __ ldr(r0, FieldMemOperand(r1, HeapNumber::kValueOffset));
-    __ ldr(r1, FieldMemOperand(r1, HeapNumber::kValueOffset + 4));
+    __ ldrd(r0, FieldMemOperand(r1, HeapNumber::kValueOffset));
   }
   __ jmp(&finished_loading_r1);
   __ bind(&r1_is_smi);
   if (mode == OVERWRITE_LEFT) {
     // We can't overwrite a Smi so get address of new heap number into r5.
     AllocateHeapNumber(masm, &slow, r5, r6, r7);
   }
 
   if (CpuFeatures::IsSupported(VFP3) && Token::MOD != operation) {
     CpuFeatures::Scope scope(VFP3);
@@ skipping 60 matching lines @@
   __ pop(r4, eq);  // Conditional pop instruction to get rid of alignment push.
   // Store answer in the overwritable heap number.
 #if !defined(USE_ARM_EABI)
   // Double returned in fp coprocessor register 0 and 1, encoded as register
   // cr8.  Offsets must be divisible by 4 for coprocessor so we need to
   // substract the tag from r4.
   __ sub(r5, r4, Operand(kHeapObjectTag));
   __ stc(p1, cr8, MemOperand(r5, HeapNumber::kValueOffset));
 #else
   // Double returned in registers 0 and 1.
-  __ str(r0, FieldMemOperand(r4, HeapNumber::kValueOffset));
-  __ str(r1, FieldMemOperand(r4, HeapNumber::kValueOffset + 4));
+  __ strd(r0, FieldMemOperand(r4, HeapNumber::kValueOffset));
 #endif
   __ mov(r0, Operand(r4));
   // And we are done.
   __ pop(pc);
 }
 
 
 // Tries to get a signed int32 out of a double precision floating point heap
 // number.  Rounds towards 0.  Fastest for doubles that are in the ranges
 // -0x7fffffff to -0x40000000 or 0x40000000 to 0x7fffffff.  This corresponds
@@ skipping 1362 matching lines @@
   // Call the runtime; it returns -1 (less), 0 (equal), or 1 (greater)
   // tagged as a small integer.
   __ bind(&runtime);
   __ TailCallRuntime(ExternalReference(Runtime::kStringCompare), 2, 1);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal