Fix fp code for mixed-endian ARM.

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 4385 matching lines @@
 
   const char* GetName() { return "ConvertToDoubleStub"; }
 
 #ifdef DEBUG
   void Print() { PrintF("ConvertToDoubleStub\n"); }
 #endif
 };
 
 
 void ConvertToDoubleStub::Generate(MacroAssembler* masm) {
-  Label not_special, done;
+#ifndef BIG_ENDIAN_FLOATING_POINT
+  Register exponent = result1_;
+  Register mantissa = result2_;
+#else
+  Register exponent = result2_;
+  Register mantissa = result1_;
+#endif
+  Label not_special;
   // Convert from Smi to integer.
   __ mov(source_, Operand(source_, ASR, kSmiTagSize));
   // Move sign bit from source to destination.  This works because the sign bit
   // in the exponent word of the double has the same position and polarity as
   // the 2's complement sign bit in a Smi.
   ASSERT(HeapNumber::kSignMask == 0x80000000u);
-  __ and_(result1_, source_, Operand(HeapNumber::kSignMask), SetCC);
+  __ and_(exponent, source_, Operand(HeapNumber::kSignMask), SetCC);
   // Subtract from 0 if source was negative.
   __ rsb(source_, source_, Operand(0), LeaveCC, ne);
   __ cmp(source_, Operand(1));
   __ b(gt, &not_special);
 
   // We have -1, 0 or 1, which we treat specially.
   __ cmp(source_, Operand(0));
   // For 1 or -1 we need to or in the 0 exponent (biased to 1023).
   static const uint32_t exponent_word_for_1 =
       HeapNumber::kExponentBias << HeapNumber::kExponentShift;
-  __ orr(result1_, result1_, Operand(exponent_word_for_1), LeaveCC, ne);
+  __ orr(exponent, exponent, Operand(exponent_word_for_1), LeaveCC, ne);
   // 1, 0 and -1 all have 0 for the second word.
-  __ mov(result2_, Operand(0));
-  __ jmp(&done);
+  __ mov(mantissa, Operand(0));
+  __ Ret();
 
   __ bind(&not_special);
   // Count leading zeros.  Uses result2 for a scratch register on pre-ARM5.
   // Gets the wrong answer for 0, but we already checked for that case above.
-  CountLeadingZeros(masm, source_, result2_, zeros_);
+  CountLeadingZeros(masm, source_, mantissa, zeros_);
   // Compute exponent and or it into the exponent register.
   // We use result2 as a scratch register here.
-  __ rsb(result2_, zeros_, Operand(31 + HeapNumber::kExponentBias));
-  __ orr(result1_,
-         result1_,
-         Operand(result2_, LSL, HeapNumber::kExponentShift));
+  __ rsb(mantissa, zeros_, Operand(31 + HeapNumber::kExponentBias));
+  __ orr(exponent,
+         exponent,
+         Operand(mantissa, LSL, HeapNumber::kExponentShift));
   // Shift up the source chopping the top bit off.
   __ add(zeros_, zeros_, Operand(1));
   // This wouldn't work for 1.0 or -1.0 as the shift would be 32 which means 0.
   __ mov(source_, Operand(source_, LSL, zeros_));
   // Compute lower part of fraction (last 12 bits).
-  __ mov(result2_, Operand(source_, LSL, HeapNumber::kMantissaBitsInTopWord));
+  __ mov(mantissa, Operand(source_, LSL, HeapNumber::kMantissaBitsInTopWord));
   // And the top (top 20 bits).
-  __ orr(result1_,
-         result1_,
+  __ orr(exponent,
+         exponent,
          Operand(source_, LSR, 32 - HeapNumber::kMantissaBitsInTopWord));
-  __ bind(&done);
   __ Ret();
 }
 
 
 // This stub can convert a signed int32 to a heap number (double).  It does
 // not work for int32s that are in Smi range!  No GC occurs during this stub
 // so you don't have to set up the frame.
 class WriteInt32ToHeapNumberStub : public CodeStub {
  public:
   WriteInt32ToHeapNumberStub(Register the_int,
@@ skipping 160 matching lines @@
 
   // Move r0 to a double in r2-r3.
   __ tst(r0, Operand(kSmiTagMask));
   __ b(eq, &r0_is_smi);  // It's a Smi so don't check it's a heap number.
   __ CompareObjectType(r0, r4, r4, HEAP_NUMBER_TYPE);
   __ b(ne, &slow);
   if (mode == OVERWRITE_RIGHT) {
     __ mov(r5, Operand(r0));  // Overwrite this heap number.
   }
   // Calling convention says that second double is in r2 and r3.
-  __ ldr(r2, FieldMemOperand(r0, HeapNumber::kMantissaOffset));
-  __ ldr(r3, FieldMemOperand(r0, HeapNumber::kExponentOffset));
+  __ ldr(r2, FieldMemOperand(r0, HeapNumber::kValueOffset));
+  __ ldr(r3, FieldMemOperand(r0, HeapNumber::kValueOffset + 4));
   __ 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);
   }
   // Write Smi from r0 to r3 and r2 in double format.
   __ mov(r7, Operand(r0));
   ConvertToDoubleStub stub3(r3, r2, r7, r6);
   __ push(lr);
   __ Call(stub3.GetCode(), RelocInfo::CODE_TARGET);
   __ pop(lr);
   __ bind(&finished_loading_r0);
 
   // Move r1 to a double in r0-r1.
   __ tst(r1, Operand(kSmiTagMask));
   __ b(eq, &r1_is_smi);  // It's a Smi so don't check it's a heap number.
   __ CompareObjectType(r1, r4, r4, HEAP_NUMBER_TYPE);
   __ b(ne, &slow);
   if (mode == OVERWRITE_LEFT) {
     __ mov(r5, Operand(r1));  // Overwrite this heap number.
   }
   // Calling convention says that first double is in r0 and r1.
-  __ ldr(r0, FieldMemOperand(r1, HeapNumber::kMantissaOffset));
-  __ ldr(r1, FieldMemOperand(r1, HeapNumber::kExponentOffset));
+  __ ldr(r0, FieldMemOperand(r1, HeapNumber::kValueOffset));
+  __ ldr(r1, FieldMemOperand(r1, HeapNumber::kValueOffset + 4));
   __ 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);
   }
   // Write Smi from r1 to r1 and r0 in double format.
   __ mov(r7, Operand(r1));
   ConvertToDoubleStub stub4(r1, r0, r7, r6);
   __ push(lr);
@@ skipping 15 matching lines @@
   // Store answer in the overwritable heap number.
   __ pop(r4);
 #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::kMantissaOffset));
-  __ str(r1, FieldMemOperand(r4, HeapNumber::kExponentOffset));
+  __ str(r0, FieldMemOperand(r4, HeapNumber::kValueOffset));
+  __ str(r1, FieldMemOperand(r4, HeapNumber::kValueOffset + 4));
 #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.  Only succeeds for doubles that are in the ranges
 // -0x7fffffff to -0x40000000 or 0x40000000 to 0x7fffffff.  This corresponds
@@ skipping 946 matching lines @@
   __ mov(r2, Operand(0));
   __ GetBuiltinEntry(r3, Builtins::CALL_NON_FUNCTION);
   __ Jump(Handle<Code>(Builtins::builtin(Builtins::ArgumentsAdaptorTrampoline)),
           RelocInfo::CODE_TARGET);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal