Always 64-bit align floating point values in heap numbers....

src/ia32/codegen-ia32.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 724 matching lines @@
   dest->Split(not_equal);
 }
 
 
 class FloatingPointHelper : public AllStatic {
  public:
   // Code pattern for loading a floating point value. Input value must
   // be either a smi or a heap number object (fp value). Requirements:
   // operand in register number. Returns operand as floating point number
   // on FPU stack.
-  static void LoadFloatOperand(MacroAssembler* masm, Register number);
+  static void LoadFloatOperand(MacroAssembler* masm,
+                               Register number,
+                               Register scratch);
   // Code pattern for loading floating point values. Input values must
   // be either smi or heap number objects (fp values). Requirements:
   // operand_1 on TOS+1 , operand_2 on TOS+2; Returns operands as
   // floating point numbers on FPU stack.
   static void LoadFloatOperands(MacroAssembler* masm, Register scratch);
   // Test if operands are smi or number objects (fp). Requirements:
   // operand_1 in eax, operand_2 in edx; falls through on float
   // operands, jumps to the non_float label otherwise.
   static void CheckFloatOperands(MacroAssembler* masm,
                                  Label* non_float,
                                  Register scratch);
   // Test if operands are numbers (smi or HeapNumber objects), and load
   // them into xmm0 and xmm1 if they are.  Jump to label not_numbers if
   // either operand is not a number.  Operands are in edx and eax.
   // Leaves operands unchanged.
-  static void LoadSse2Operands(MacroAssembler* masm, Label* not_numbers);
+  static void LoadSse2Operands(MacroAssembler* masm, Register scratch, Label* not_numbers);
 };
 
 
 const char* GenericBinaryOpStub::GetName() {
+  bool smi = (flags_ & NO_SMI_CODE_IN_STUB) == 0;
   switch (op_) {
-    case Token::ADD: return "GenericBinaryOpStub_ADD";
-    case Token::SUB: return "GenericBinaryOpStub_SUB";
-    case Token::MUL: return "GenericBinaryOpStub_MUL";
-    case Token::DIV: return "GenericBinaryOpStub_DIV";
-    case Token::BIT_OR: return "GenericBinaryOpStub_BIT_OR";
-    case Token::BIT_AND: return "GenericBinaryOpStub_BIT_AND";
-    case Token::BIT_XOR: return "GenericBinaryOpStub_BIT_XOR";
-    case Token::SAR: return "GenericBinaryOpStub_SAR";
-    case Token::SHL: return "GenericBinaryOpStub_SHL";
-    case Token::SHR: return "GenericBinaryOpStub_SHR";
-    default:         return "GenericBinaryOpStub";
+    case Token::ADD:
+      return smi ? "GenericBinaryOpStub_ADD_Smi" : "GenericBinaryOpStub_ADD";
+    case Token::SUB:
+      return smi ? "GenericBinaryOpStub_SUB_Smi" : "GenericBinaryOpStub_SUB";
+    case Token::MUL:
+      return smi ? "GenericBinaryOpStub_MUL_Smi" : "GenericBinaryOpStub_MUL";
+    case Token::DIV:
+      return smi ? "GenericBinaryOpStub_DIV_Smi" : "GenericBinaryOpStub_DIV";
+    case Token::BIT_OR:
+      return smi ?
+             "GenericBinaryOpStub_BIT_OR_Smi" :
+             "GenericBinaryOpStub_BIT_OR";
+    case Token::BIT_AND:
+      return smi ?
+             "GenericBinaryOpStub_BIT_AND_Smi" :
+             "GenericBinaryOpStub_BIT_AND";
+    case Token::BIT_XOR:
+      return smi ?
+             "GenericBinaryOpStub_BIT_XOR_Smi" :
+             "GenericBinaryOpStub_BIT_XOR";
+    case Token::SAR:
+      return smi ? "GenericBinaryOpStub_SAR_Smi" : "GenericBinaryOpStub_SAR";
+    case Token::SHL:
+      return smi ? "GenericBinaryOpStub_SHL_Smi" : "GenericBinaryOpStub_SHL";
+    case Token::SHR:
+      return smi ? "GenericBinaryOpStub_SHR_Smi" : "GenericBinaryOpStub_SHR";
+    default:
+      return "GenericBinaryOpStub";
   }
 }
 
 
 // Call the specialized stub for a binary operation.
 class DeferredInlineBinaryOperation: public DeferredCode {
  public:
   DeferredInlineBinaryOperation(Token::Value op,
                                 Register dst,
                                 Register left,
@@ skipping 4359 matching lines @@
   JumpTarget done;
   JumpTarget call_runtime;
   ASSERT(args->length() == 1);
 
   // Load number and duplicate it.
   Load(args->at(0));
   frame_->Dup();
 
   // Get the number into an unaliased register and load it onto the
   // floating point stack still leaving one copy on the frame.
+  Result scratch = allocator_->Allocate();
+  ASSERT(scratch.is_valid());
   Result number = frame_->Pop();
   number.ToRegister();
   frame_->Spill(number.reg());
-  FloatingPointHelper::LoadFloatOperand(masm_, number.reg());
+  FloatingPointHelper::LoadFloatOperand(masm_, number.reg(), scratch.reg());
   number.Unuse();
+  scratch.Unuse();
 
   // Perform the operation on the number.
   switch (op) {
     case SIN:
       __ fsin();
       break;
     case COS:
       __ fcos();
       break;
   }
 
   // Go slow case if argument to operation is out of range.
   Result eax_reg = allocator_->Allocate(eax);
   ASSERT(eax_reg.is_valid());
   __ fnstsw_ax();
   __ sahf();
   eax_reg.Unuse();
   call_runtime.Branch(parity_even, not_taken);
 
   // Allocate heap number for result if possible.
   Result scratch1 = allocator()->Allocate();
   Result scratch2 = allocator()->Allocate();
   Result heap_number = allocator()->Allocate();
   __ AllocateHeapNumber(heap_number.reg(),
                         scratch1.reg(),
                         scratch2.reg(),
                         call_runtime.entry_label());
   scratch1.Unuse();
+
+  // Store the result in the allocated heap number.
+  __ GenerateHeapNumberValueAddress(scratch2.reg(), heap_number.reg());
+  __ fstp_d(Operand(scratch2.reg(), 0));
   scratch2.Unuse();
 
-  // Store the result in the allocated heap number.
-  __ fstp_d(FieldOperand(heap_number.reg(), HeapNumber::kValueOffset));
   // Replace the extra copy of the argument with the result.
   frame_->SetElementAt(0, &heap_number);
   done.Jump();
 
   call_runtime.Bind();
   // Free ST(0) which was not popped before calling into the runtime.
   __ ffree(0);
   Result answer;
   switch (op) {
     case SIN:
@@ skipping 1303 matching lines @@
   __ mov(edx, FieldOperand(eax, String::kLengthOffset));
   __ test(edx, Operand(edx));
   __ j(zero, &false_result);
   __ jmp(&true_result);
 
   __ bind(&not_string);
   // HeapNumber => false iff +0, -0, or NaN.
   __ cmp(edx, Factory::heap_number_map());
   __ j(not_equal, &true_result);
   __ fldz();
-  __ fld_d(FieldOperand(eax, HeapNumber::kValueOffset));
+  __ GenerateHeapNumberValueAddress(edx, eax);
+  __ fld_d(Operand(edx, 0));
   __ FCmp();
   __ j(zero, &false_result);
   // Fall through to |true_result|.
 
   // Return 1/0 for true/false in eax.
   __ bind(&true_result);
   __ mov(eax, 1);
   __ ret(1 * kPointerSize);
   __ bind(&false_result);
   __ mov(eax, 0);
@@ skipping 291 matching lines @@
   switch (op_) {
     case Token::ADD:
     case Token::SUB:
     case Token::MUL:
     case Token::DIV: {
       // eax: y
       // edx: x
 
       if (CpuFeatures::IsSupported(SSE2)) {
         CpuFeatures::Scope use_sse2(SSE2);
-        FloatingPointHelper::LoadSse2Operands(masm, &call_runtime);
+        FloatingPointHelper::LoadSse2Operands(masm, ecx, &call_runtime);
 
         switch (op_) {
           case Token::ADD: __ addsd(xmm0, xmm1); break;
           case Token::SUB: __ subsd(xmm0, xmm1); break;
           case Token::MUL: __ mulsd(xmm0, xmm1); break;
           case Token::DIV: __ divsd(xmm0, xmm1); break;
           default: UNREACHABLE();
         }
         // Allocate a heap number, if needed.
         Label skip_allocation;
@@ skipping 12 matching lines @@
             // for the possible runtime call.
             __ AllocateHeapNumber(ebx, ecx, no_reg, &call_runtime);
             // Now eax can be overwritten losing one of the arguments as we are
             // now done and will not need it any more.
             __ mov(eax, ebx);
             __ bind(&skip_allocation);
             break;
           }
           default: UNREACHABLE();
         }
-        __ movdbl(FieldOperand(eax, HeapNumber::kValueOffset), xmm0);
+        __ GenerateHeapNumberValueAddress(ecx, eax);
+        __ movdbl(Operand(ecx, 0), xmm0);
         GenerateReturn(masm);
       } else {  // SSE2 not available, use FPU.
         FloatingPointHelper::CheckFloatOperands(masm, &call_runtime, ebx);
         // Allocate a heap number, if needed.
         Label skip_allocation;
         switch (mode_) {
           case OVERWRITE_LEFT:
             __ mov(eax, Operand(edx));
             // Fall through!
           case OVERWRITE_RIGHT:
@@ skipping 15 matching lines @@
         }
         FloatingPointHelper::LoadFloatOperands(masm, ecx);
 
         switch (op_) {
           case Token::ADD: __ faddp(1); break;
           case Token::SUB: __ fsubp(1); break;
           case Token::MUL: __ fmulp(1); break;
           case Token::DIV: __ fdivp(1); break;
           default: UNREACHABLE();
         }
-        __ fstp_d(FieldOperand(eax, HeapNumber::kValueOffset));
+        __ GenerateHeapNumberValueAddress(ecx, eax);
+        __ fstp_d(Operand(ecx, 0));
         GenerateReturn(masm);
       }
     }
     case Token::MOD: {
       // For MOD we go directly to runtime in the non-smi case.
       break;
     }
     case Token::BIT_OR:
     case Token::BIT_AND:
     case Token::BIT_XOR:
@@ skipping 76 matching lines @@
             // Fall through!
           case NO_OVERWRITE:
             __ AllocateHeapNumber(eax, ecx, edx, &call_runtime);
             __ bind(&skip_allocation);
             break;
           default: UNREACHABLE();
         }
         // Store the result in the HeapNumber and return.
         __ mov(Operand(esp, 1 * kPointerSize), ebx);
         __ fild_s(Operand(esp, 1 * kPointerSize));
-        __ fstp_d(FieldOperand(eax, HeapNumber::kValueOffset));
+        __ GenerateHeapNumberValueAddress(ecx, eax);
+        __ fstp_d(Operand(ecx, 0));
         GenerateReturn(masm);
       }
 
       // Clear the FPU exception flag and reset the stack before calling
       // the runtime system.
       __ bind(&operand_conversion_failure);
       __ add(Operand(esp), Immediate(2 * kPointerSize));
       if (use_sse3_) {
         // If we've used the SSE3 instructions for truncating the
         // floating point values to integers and it failed, we have a
@@ skipping 123 matching lines @@
   // returning.
   if (!HasArgumentsInRegisters()) {
     __ ret(2 * kPointerSize);  // Remove both operands
   } else {
     __ ret(0);
   }
 }
 
 
 void FloatingPointHelper::LoadFloatOperand(MacroAssembler* masm,
-                                           Register number) {
+                                           Register number,
+                                           Register scratch) {
   Label load_smi, done;
 
   __ test(number, Immediate(kSmiTagMask));
   __ j(zero, &load_smi, not_taken);
-  __ fld_d(FieldOperand(number, HeapNumber::kValueOffset));
+  __ GenerateHeapNumberValueAddress(scratch, number);
+  __ fld_d(Operand(scratch, 0));
   __ jmp(&done);
 
   __ bind(&load_smi);
   __ sar(number, kSmiTagSize);
   __ push(number);
   __ fild_s(Operand(esp, 0));
   __ pop(number);
 
   __ bind(&done);
 }
 
 
 void FloatingPointHelper::LoadSse2Operands(MacroAssembler* masm,
+                                           Register scratch,
                                            Label* not_numbers) {
   Label load_smi_edx, load_eax, load_smi_eax, load_float_eax, done;
   // Load operand in edx into xmm0, or branch to not_numbers.
   __ test(edx, Immediate(kSmiTagMask));
   __ j(zero, &load_smi_edx, not_taken);  // Argument in edx is a smi.
   __ cmp(FieldOperand(edx, HeapObject::kMapOffset), Factory::heap_number_map());
   __ j(not_equal, not_numbers);  // Argument in edx is not a number.
-  __ movdbl(xmm0, FieldOperand(edx, HeapNumber::kValueOffset));
+  __ GenerateHeapNumberValueAddress(scratch, edx);
+  __ movdbl(xmm0, Operand(scratch, 0));
   __ bind(&load_eax);
   // Load operand in eax into xmm1, or branch to not_numbers.
   __ test(eax, Immediate(kSmiTagMask));
   __ j(zero, &load_smi_eax, not_taken);  // Argument in eax is a smi.
   __ cmp(FieldOperand(eax, HeapObject::kMapOffset), Factory::heap_number_map());
   __ j(equal, &load_float_eax);
   __ jmp(not_numbers);  // Argument in eax is not a number.
   __ bind(&load_smi_edx);
   __ sar(edx, 1);  // Untag smi before converting to float.
   __ cvtsi2sd(xmm0, Operand(edx));
   __ shl(edx, 1);  // Retag smi for heap number overwriting test.
   __ jmp(&load_eax);
   __ bind(&load_smi_eax);
   __ sar(eax, 1);  // Untag smi before converting to float.
   __ cvtsi2sd(xmm1, Operand(eax));
   __ shl(eax, 1);  // Retag smi for heap number overwriting test.
   __ jmp(&done);
   __ bind(&load_float_eax);
-  __ movdbl(xmm1, FieldOperand(eax, HeapNumber::kValueOffset));
+  __ GenerateHeapNumberValueAddress(scratch, eax);
+  __ movdbl(xmm1, Operand(scratch, 0));
   __ bind(&done);
 }
 
 
 void FloatingPointHelper::LoadFloatOperands(MacroAssembler* masm,
                                             Register scratch) {
   Label load_smi_1, load_smi_2, done_load_1, done;
   __ mov(scratch, Operand(esp, 2 * kPointerSize));
   __ test(scratch, Immediate(kSmiTagMask));
   __ j(zero, &load_smi_1, not_taken);
-  __ fld_d(FieldOperand(scratch, HeapNumber::kValueOffset));
+  __ GenerateHeapNumberValueAddress(scratch, scratch);
+  __ fld_d(Operand(scratch, 0));
   __ bind(&done_load_1);
 
   __ mov(scratch, Operand(esp, 1 * kPointerSize));
   __ test(scratch, Immediate(kSmiTagMask));
   __ j(zero, &load_smi_2, not_taken);
-  __ fld_d(FieldOperand(scratch, HeapNumber::kValueOffset));
+  __ GenerateHeapNumberValueAddress(scratch, scratch);
+  __ fld_d(Operand(scratch, 0));
   __ jmp(&done);
 
   __ bind(&load_smi_1);
   __ sar(scratch, kSmiTagSize);
   __ push(scratch);
   __ fild_s(Operand(esp, 0));
   __ pop(scratch);
   __ jmp(&done_load_1);
 
   __ bind(&load_smi_2);
@@ skipping 66 matching lines @@
   __ push(eax);
   __ push(ecx);  // push return address
   __ InvokeBuiltin(Builtins::UNARY_MINUS, JUMP_FUNCTION);
 
   // Try floating point case.
   __ bind(&try_float);
   __ mov(edx, FieldOperand(eax, HeapObject::kMapOffset));
   __ cmp(edx, Factory::heap_number_map());
   __ j(not_equal, &slow);
   if (overwrite_) {
-    __ mov(edx, FieldOperand(eax, HeapNumber::kExponentOffset));
+    __ GenerateHeapNumberValueAddress(ebx, eax);
+    __ mov(edx, Operand(ebx, HeapNumber::kExponentRelativeOffset));
     __ xor_(edx, HeapNumber::kSignMask);  // Flip sign.
-    __ mov(FieldOperand(eax, HeapNumber::kExponentOffset), edx);
+    __ mov(Operand(ebx, HeapNumber::kExponentRelativeOffset), edx);
   } else {
     __ mov(edx, Operand(eax));
     // edx: operand
     __ AllocateHeapNumber(eax, ebx, ecx, &undo);
     // eax: allocated 'empty' number
-    __ mov(ecx, FieldOperand(edx, HeapNumber::kExponentOffset));
+    __ GenerateHeapNumberValueAddress(edx, edx);
+    __ GenerateHeapNumberValueAddress(ebx, eax);
+    __ mov(ecx, Operand(edx, HeapNumber::kExponentRelativeOffset));
     __ xor_(ecx, HeapNumber::kSignMask);  // Flip sign.
-    __ mov(FieldOperand(eax, HeapNumber::kExponentOffset), ecx);
-    __ mov(ecx, FieldOperand(edx, HeapNumber::kMantissaOffset));
-    __ mov(FieldOperand(eax, HeapNumber::kMantissaOffset), ecx);
+    __ mov(Operand(ebx, HeapNumber::kExponentRelativeOffset), ecx);
+    __ mov(ecx, Operand(edx, HeapNumber::kMantissaRelativeOffset));
+    __ mov(Operand(ebx, HeapNumber::kMantissaRelativeOffset), ecx);
   }
 
   __ bind(&done);
 
   __ StubReturn(1);
 }
 
 
 void ArgumentsAccessStub::GenerateReadLength(MacroAssembler* masm) {
   // Check if the calling frame is an arguments adaptor frame.
@@ skipping 130 matching lines @@
       // not NaN.
       // The representation of NaN values has all exponent bits (52..62) set,
       // and not all mantissa bits (0..51) clear.
       // We only accept QNaNs, which have bit 51 set.
       // Read top bits of double representation (second word of value).
 
       // Value is a QNaN if value & kQuietNaNMask == kQuietNaNMask, i.e.,
       // all bits in the mask are set. We only need to check the word
       // that contains the exponent and high bit of the mantissa.
       ASSERT_NE(0, (kQuietNaNHighBitsMask << 1) & 0x80000000u);
-      __ mov(edx, FieldOperand(edx, HeapNumber::kExponentOffset));
+      __ GenerateHeapNumberValueAddress(edx, edx);
+      __ mov(edx, Operand(edx, HeapNumber::kExponentRelativeOffset));
       __ xor_(eax, Operand(eax));
       // Shift value and mask so kQuietNaNHighBitsMask applies to topmost bits.
       __ add(edx, Operand(edx));
       __ cmp(edx, kQuietNaNHighBitsMask << 1);
       __ setcc(above_equal, eax);
       __ ret(0);
 
       __ bind(&not_identical);
     }
 
@@ skipping 83 matching lines @@
   __ push(ecx);
 
   // Inlined floating point compare.
   // Call builtin if operands are not floating point or smi.
   Label check_for_symbols;
   Label unordered;
   if (CpuFeatures::IsSupported(SSE2)) {
     CpuFeatures::Scope use_sse2(SSE2);
     CpuFeatures::Scope use_cmov(CMOV);
 
-    FloatingPointHelper::LoadSse2Operands(masm, &check_for_symbols);
+    FloatingPointHelper::LoadSse2Operands(masm, ecx, &check_for_symbols);
     __ comisd(xmm0, xmm1);
 
     // Jump to builtin for NaN.
     __ j(parity_even, &unordered, not_taken);
     __ mov(eax, 0);  // equal
     __ mov(ecx, Immediate(Smi::FromInt(1)));
     __ cmov(above, eax, Operand(ecx));
     __ mov(ecx, Immediate(Smi::FromInt(-1)));
     __ cmov(below, eax, Operand(ecx));
     __ ret(2 * kPointerSize);
@@ skipping 833 matching lines @@
     __ add(Operand(dest), Immediate(2));
   }
   __ sub(Operand(count), Immediate(1));
   __ j(not_zero, &loop);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal