Revision f230a1cf deps/v8/src/ia32/lithium-gap-resolver-ia32.cc

View differences:

deps/v8/src/ia32/lithium-gap-resolver-ia32.cc
326 326 
        } else {
327 327 
          __ push(Immediate(upper));
328 328 
          __ push(Immediate(lower));
329 
          __ movdbl(dst, Operand(esp, 0));
329 
          __ movsd(dst, Operand(esp, 0));
330 330 
          __ add(esp, Immediate(kDoubleSize));
331 331 
        }
332 332 
      } else {
......
360 360 
      } else {
361 361 
        ASSERT(destination->IsDoubleStackSlot());
362 362 
        Operand dst = cgen_->ToOperand(destination);
363 
        __ movdbl(dst, src);
363 
        __ movsd(dst, src);
364 364 
      }
365 365 
    } else {
366 366 
      // load from the register onto the stack, store in destination, which must
......
378 378 
      Operand src = cgen_->ToOperand(source);
379 379 
      if (destination->IsDoubleRegister()) {
380 380 
        XMMRegister dst = cgen_->ToDoubleRegister(destination);
381 
        __ movdbl(dst, src);
381 
        __ movsd(dst, src);
382 382 
      } else {
383 383 
        // We rely on having xmm0 available as a fixed scratch register.
384 384 
        Operand dst = cgen_->ToOperand(destination);
385 
        __ movdbl(xmm0, src);
386 
        __ movdbl(dst, xmm0);
385 
        __ movsd(xmm0, src);
386 
        __ movsd(dst, xmm0);
387 387 
      }
388 388 
    } else {
389 389 
      // load from the stack slot on top of the floating point stack, and then
......
486 486 
                                              : destination);
487 487 
    Operand other =
488 488 
        cgen_->ToOperand(source->IsDoubleRegister() ? destination : source);
489 
    __ movdbl(xmm0, other);
490 
    __ movdbl(other, reg);
491 
    __ movdbl(reg, Operand(xmm0));
489 
    __ movsd(xmm0, other);
490 
    __ movsd(other, reg);
491 
    __ movsd(reg, Operand(xmm0));
492 492 
  } else if (source->IsDoubleStackSlot() && destination->IsDoubleStackSlot()) {
493 493 
    CpuFeatureScope scope(cgen_->masm(), SSE2);
494 494 
    // Double-width memory-to-memory.  Spill on demand to use a general
......
499 499 
    Operand src1 = cgen_->HighOperand(source);
500 500 
    Operand dst0 = cgen_->ToOperand(destination);
501 501 
    Operand dst1 = cgen_->HighOperand(destination);
502 
    __ movdbl(xmm0, dst0);  // Save destination in xmm0.
502 
    __ movsd(xmm0, dst0);  // Save destination in xmm0.
503 503 
    __ mov(tmp, src0);  // Then use tmp to copy source to destination.
504 504 
    __ mov(dst0, tmp);
505 505 
    __ mov(tmp, src1);
506 506 
    __ mov(dst1, tmp);
507 
    __ movdbl(src0, xmm0);
507 
    __ movsd(src0, xmm0);
508 508 

  		




  509
  509
  
    
  } else {


  		




  510
  510
  
    
    // No other combinations are possible.


  		












Also available in:  Unified diff