OLD | NEW |
1 // Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file | 1 // Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file |
2 // for details. All rights reserved. Use of this source code is governed by a | 2 // for details. All rights reserved. Use of this source code is governed by a |
3 // BSD-style license that can be found in the LICENSE file. | 3 // BSD-style license that can be found in the LICENSE file. |
4 | 4 |
5 #include "vm/globals.h" | 5 #include "vm/globals.h" |
6 #if defined(TARGET_ARCH_X64) | 6 #if defined(TARGET_ARCH_X64) |
7 | 7 |
8 #include "vm/assembler.h" | 8 #include "vm/assembler.h" |
9 #include "vm/heap.h" | 9 #include "vm/heap.h" |
10 #include "vm/memory_region.h" | 10 #include "vm/memory_region.h" |
(...skipping 377 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
388 | 388 |
389 void Assembler::leaq(Register dst, const Address& src) { | 389 void Assembler::leaq(Register dst, const Address& src) { |
390 AssemblerBuffer::EnsureCapacity ensured(&buffer_); | 390 AssemblerBuffer::EnsureCapacity ensured(&buffer_); |
391 EmitOperandREX(dst, src, REX_W); | 391 EmitOperandREX(dst, src, REX_W); |
392 EmitUint8(0x8D); | 392 EmitUint8(0x8D); |
393 EmitOperand(dst & 7, src); | 393 EmitOperand(dst & 7, src); |
394 } | 394 } |
395 | 395 |
396 | 396 |
397 void Assembler::movss(XmmRegister dst, const Address& src) { | 397 void Assembler::movss(XmmRegister dst, const Address& src) { |
398 // TODO(srdjan): implement and test XMM8 - XMM15. | 398 ASSERT(dst <= XMM15); |
399 ASSERT(dst <= XMM7); | |
400 AssemblerBuffer::EnsureCapacity ensured(&buffer_); | 399 AssemblerBuffer::EnsureCapacity ensured(&buffer_); |
401 EmitUint8(0xF3); | 400 EmitUint8(0xF3); |
402 EmitOperandREX(0, src, REX_NONE); | 401 EmitREX_RB(dst, src); |
403 EmitUint8(0x0F); | 402 EmitUint8(0x0F); |
404 EmitUint8(0x10); | 403 EmitUint8(0x10); |
405 EmitOperand(dst & 7, src); | 404 EmitOperand(dst & 7, src); |
406 } | 405 } |
407 | 406 |
408 | 407 |
409 void Assembler::movss(const Address& dst, XmmRegister src) { | 408 void Assembler::movss(const Address& dst, XmmRegister src) { |
410 // TODO(srdjan): implement and test XMM8 - XMM15. | 409 ASSERT(src <= XMM15); |
411 ASSERT(src <= XMM7); | |
412 AssemblerBuffer::EnsureCapacity ensured(&buffer_); | 410 AssemblerBuffer::EnsureCapacity ensured(&buffer_); |
413 EmitUint8(0xF3); | 411 EmitUint8(0xF3); |
414 EmitOperandREX(0, dst, REX_NONE); | 412 EmitREX_RB(src, dst); |
415 EmitUint8(0x0F); | 413 EmitUint8(0x0F); |
416 EmitUint8(0x11); | 414 EmitUint8(0x11); |
417 EmitOperand(src & 7, dst); | 415 EmitOperand(src & 7, dst); |
418 } | 416 } |
419 | 417 |
420 | 418 |
421 void Assembler::movss(XmmRegister dst, XmmRegister src) { | 419 void Assembler::movss(XmmRegister dst, XmmRegister src) { |
422 // TODO(srdjan): implement and test XMM8 - XMM15. | 420 ASSERT(src <= XMM15); |
423 ASSERT(src <= XMM7); | 421 ASSERT(dst <= XMM15); |
424 ASSERT(dst <= XMM7); | |
425 AssemblerBuffer::EnsureCapacity ensured(&buffer_); | 422 AssemblerBuffer::EnsureCapacity ensured(&buffer_); |
426 EmitUint8(0xF3); | 423 EmitUint8(0xF3); |
| 424 EmitREX_RB(src, dst); |
427 EmitUint8(0x0F); | 425 EmitUint8(0x0F); |
428 EmitUint8(0x11); | 426 EmitUint8(0x11); |
429 EmitXmmRegisterOperand(src & 7, dst); | 427 EmitXmmRegisterOperand(src & 7, dst); |
430 } | 428 } |
431 | 429 |
432 | 430 |
433 void Assembler::movd(XmmRegister dst, Register src) { | 431 void Assembler::movd(XmmRegister dst, Register src) { |
434 ASSERT(dst <= XMM7); | 432 ASSERT(dst <= XMM15); |
435 AssemblerBuffer::EnsureCapacity ensured(&buffer_); | 433 AssemblerBuffer::EnsureCapacity ensured(&buffer_); |
436 EmitUint8(0x66); | 434 EmitUint8(0x66); |
| 435 EmitREX_RB(dst, src); |
437 EmitUint8(0x0F); | 436 EmitUint8(0x0F); |
438 EmitUint8(0x6E); | 437 EmitUint8(0x6E); |
439 EmitOperand(dst & 7, Operand(src)); | 438 EmitOperand(dst & 7, Operand(src)); |
440 } | 439 } |
441 | 440 |
442 | 441 |
443 void Assembler::movd(Register dst, XmmRegister src) { | 442 void Assembler::movd(Register dst, XmmRegister src) { |
444 ASSERT(src <= XMM7); | 443 ASSERT(src <= XMM15); |
445 AssemblerBuffer::EnsureCapacity ensured(&buffer_); | 444 AssemblerBuffer::EnsureCapacity ensured(&buffer_); |
446 EmitUint8(0x66); | 445 EmitUint8(0x66); |
| 446 EmitREX_RB(src, dst); |
447 EmitUint8(0x0F); | 447 EmitUint8(0x0F); |
448 EmitUint8(0x7E); | 448 EmitUint8(0x7E); |
449 EmitOperand(src & 7, Operand(dst)); | 449 EmitOperand(src & 7, Operand(dst)); |
450 } | 450 } |
451 | 451 |
452 | 452 |
453 void Assembler::addss(XmmRegister dst, XmmRegister src) { | 453 void Assembler::addss(XmmRegister dst, XmmRegister src) { |
454 // TODO(srdjan): implement and test XMM8 - XMM15. | 454 ASSERT(src <= XMM15); |
455 ASSERT(src <= XMM7); | 455 ASSERT(dst <= XMM15); |
456 ASSERT(dst <= XMM7); | |
457 AssemblerBuffer::EnsureCapacity ensured(&buffer_); | 456 AssemblerBuffer::EnsureCapacity ensured(&buffer_); |
458 EmitUint8(0xF3); | 457 EmitUint8(0xF3); |
| 458 EmitREX_RB(dst, src); |
459 EmitUint8(0x0F); | 459 EmitUint8(0x0F); |
460 EmitUint8(0x58); | 460 EmitUint8(0x58); |
461 EmitXmmRegisterOperand(dst, src); | 461 EmitXmmRegisterOperand(dst & 7, src); |
462 } | 462 } |
463 | 463 |
464 | 464 |
465 void Assembler::subss(XmmRegister dst, XmmRegister src) { | 465 void Assembler::subss(XmmRegister dst, XmmRegister src) { |
466 // TODO(srdjan): implement and test XMM8 - XMM15. | 466 ASSERT(src <= XMM15); |
467 ASSERT(src <= XMM7); | 467 ASSERT(dst <= XMM15); |
468 ASSERT(dst <= XMM7); | |
469 AssemblerBuffer::EnsureCapacity ensured(&buffer_); | 468 AssemblerBuffer::EnsureCapacity ensured(&buffer_); |
470 EmitUint8(0xF3); | 469 EmitUint8(0xF3); |
| 470 EmitREX_RB(dst, src); |
471 EmitUint8(0x0F); | 471 EmitUint8(0x0F); |
472 EmitUint8(0x5C); | 472 EmitUint8(0x5C); |
473 EmitXmmRegisterOperand(dst, src); | 473 EmitXmmRegisterOperand(dst & 7, src); |
474 } | 474 } |
475 | 475 |
476 | 476 |
477 void Assembler::mulss(XmmRegister dst, XmmRegister src) { | 477 void Assembler::mulss(XmmRegister dst, XmmRegister src) { |
478 // TODO(srdjan): implement and test XMM8 - XMM15. | 478 ASSERT(src <= XMM15); |
479 ASSERT(src <= XMM7); | 479 ASSERT(dst <= XMM15); |
480 ASSERT(dst <= XMM7); | |
481 AssemblerBuffer::EnsureCapacity ensured(&buffer_); | 480 AssemblerBuffer::EnsureCapacity ensured(&buffer_); |
482 EmitUint8(0xF3); | 481 EmitUint8(0xF3); |
| 482 EmitREX_RB(dst, src); |
483 EmitUint8(0x0F); | 483 EmitUint8(0x0F); |
484 EmitUint8(0x59); | 484 EmitUint8(0x59); |
485 EmitXmmRegisterOperand(dst, src); | 485 EmitXmmRegisterOperand(dst & 7, src); |
486 } | 486 } |
487 | 487 |
488 | 488 |
489 void Assembler::divss(XmmRegister dst, XmmRegister src) { | 489 void Assembler::divss(XmmRegister dst, XmmRegister src) { |
490 // TODO(srdjan): implement and test XMM8 - XMM15. | 490 ASSERT(src <= XMM15); |
491 ASSERT(src <= XMM7); | 491 ASSERT(dst <= XMM15); |
492 ASSERT(dst <= XMM7); | |
493 AssemblerBuffer::EnsureCapacity ensured(&buffer_); | 492 AssemblerBuffer::EnsureCapacity ensured(&buffer_); |
494 EmitUint8(0xF3); | 493 EmitUint8(0xF3); |
| 494 EmitREX_RB(dst, src); |
495 EmitUint8(0x0F); | 495 EmitUint8(0x0F); |
496 EmitUint8(0x5E); | 496 EmitUint8(0x5E); |
497 EmitXmmRegisterOperand(dst, src); | 497 EmitXmmRegisterOperand(dst & 7, src); |
498 } | 498 } |
499 | 499 |
500 | 500 |
501 void Assembler::movsd(XmmRegister dst, const Address& src) { | 501 void Assembler::movsd(XmmRegister dst, const Address& src) { |
502 // TODO(srdjan): implement and test XMM8 - XMM15. | 502 ASSERT(dst <= XMM15); |
503 ASSERT(dst <= XMM7); | |
504 AssemblerBuffer::EnsureCapacity ensured(&buffer_); | 503 AssemblerBuffer::EnsureCapacity ensured(&buffer_); |
505 EmitUint8(0xF2); | 504 EmitUint8(0xF2); |
506 EmitOperandREX(0, src, REX_NONE); | 505 EmitREX_RB(dst, src); |
507 EmitUint8(0x0F); | 506 EmitUint8(0x0F); |
508 EmitUint8(0x10); | 507 EmitUint8(0x10); |
509 EmitOperand(dst & 7, src); | 508 EmitOperand(dst & 7, src); |
510 } | 509 } |
511 | 510 |
512 | 511 |
513 void Assembler::movsd(const Address& dst, XmmRegister src) { | 512 void Assembler::movsd(const Address& dst, XmmRegister src) { |
514 // TODO(srdjan): implement and test XMM8 - XMM15. | 513 ASSERT(src <= XMM15); |
515 ASSERT(src <= XMM7); | |
516 AssemblerBuffer::EnsureCapacity ensured(&buffer_); | 514 AssemblerBuffer::EnsureCapacity ensured(&buffer_); |
517 EmitUint8(0xF2); | 515 EmitUint8(0xF2); |
518 EmitOperandREX(0, dst, REX_NONE); | 516 EmitREX_RB(src, dst); |
519 EmitUint8(0x0F); | 517 EmitUint8(0x0F); |
520 EmitUint8(0x11); | 518 EmitUint8(0x11); |
521 EmitOperand(src & 7, dst); | 519 EmitOperand(src & 7, dst); |
522 } | 520 } |
523 | 521 |
524 | 522 |
525 void Assembler::movsd(XmmRegister dst, XmmRegister src) { | 523 void Assembler::movsd(XmmRegister dst, XmmRegister src) { |
526 // TODO(srdjan): implement and test XMM8 - XMM15. | 524 ASSERT(src <= XMM15); |
527 ASSERT(src <= XMM7); | 525 ASSERT(dst <= XMM15); |
528 ASSERT(dst <= XMM7); | |
529 AssemblerBuffer::EnsureCapacity ensured(&buffer_); | 526 AssemblerBuffer::EnsureCapacity ensured(&buffer_); |
530 EmitUint8(0xF2); | 527 EmitUint8(0xF2); |
| 528 EmitREX_RB(src, dst); |
531 EmitUint8(0x0F); | 529 EmitUint8(0x0F); |
532 EmitUint8(0x11); | 530 EmitUint8(0x11); |
533 EmitXmmRegisterOperand(src & 7, dst); | 531 EmitXmmRegisterOperand(src & 7, dst); |
534 } | 532 } |
535 | 533 |
536 | 534 |
537 void Assembler::movaps(XmmRegister dst, XmmRegister src) { | 535 void Assembler::movaps(XmmRegister dst, XmmRegister src) { |
538 // TODO(vegorov): implement and test XMM8 - XMM15. | 536 ASSERT(src <= XMM15); |
539 ASSERT(src <= XMM7); | 537 ASSERT(dst <= XMM15); |
540 ASSERT(dst <= XMM7); | |
541 AssemblerBuffer::EnsureCapacity ensured(&buffer_); | 538 AssemblerBuffer::EnsureCapacity ensured(&buffer_); |
| 539 EmitREX_RB(dst, src); |
542 EmitUint8(0x0F); | 540 EmitUint8(0x0F); |
543 EmitUint8(0x28); | 541 EmitUint8(0x28); |
544 EmitXmmRegisterOperand(dst & 7, src); | 542 EmitXmmRegisterOperand(dst & 7, src); |
545 } | 543 } |
546 | 544 |
547 | 545 |
548 void Assembler::addsd(XmmRegister dst, XmmRegister src) { | 546 void Assembler::addsd(XmmRegister dst, XmmRegister src) { |
549 // TODO(srdjan): implement and test XMM8 - XMM15. | 547 ASSERT(src <= XMM15); |
550 ASSERT(src <= XMM7); | 548 ASSERT(dst <= XMM15); |
551 ASSERT(dst <= XMM7); | |
552 AssemblerBuffer::EnsureCapacity ensured(&buffer_); | 549 AssemblerBuffer::EnsureCapacity ensured(&buffer_); |
553 EmitUint8(0xF2); | 550 EmitUint8(0xF2); |
| 551 EmitREX_RB(dst, src); |
554 EmitUint8(0x0F); | 552 EmitUint8(0x0F); |
555 EmitUint8(0x58); | 553 EmitUint8(0x58); |
556 EmitXmmRegisterOperand(dst, src); | 554 EmitXmmRegisterOperand(dst & 7, src); |
557 } | 555 } |
558 | 556 |
559 | 557 |
560 void Assembler::subsd(XmmRegister dst, XmmRegister src) { | 558 void Assembler::subsd(XmmRegister dst, XmmRegister src) { |
561 // TODO(srdjan): implement and test XMM8 - XMM15. | 559 ASSERT(src <= XMM15); |
562 ASSERT(src <= XMM7); | 560 ASSERT(dst <= XMM15); |
563 ASSERT(dst <= XMM7); | |
564 AssemblerBuffer::EnsureCapacity ensured(&buffer_); | 561 AssemblerBuffer::EnsureCapacity ensured(&buffer_); |
565 EmitUint8(0xF2); | 562 EmitUint8(0xF2); |
| 563 EmitREX_RB(dst, src); |
566 EmitUint8(0x0F); | 564 EmitUint8(0x0F); |
567 EmitUint8(0x5C); | 565 EmitUint8(0x5C); |
568 EmitXmmRegisterOperand(dst, src); | 566 EmitXmmRegisterOperand(dst & 7, src); |
569 } | 567 } |
570 | 568 |
571 | 569 |
572 void Assembler::mulsd(XmmRegister dst, XmmRegister src) { | 570 void Assembler::mulsd(XmmRegister dst, XmmRegister src) { |
573 // TODO(srdjan): implement and test XMM8 - XMM15. | 571 ASSERT(src <= XMM15); |
574 ASSERT(src <= XMM7); | 572 ASSERT(dst <= XMM15); |
575 ASSERT(dst <= XMM7); | |
576 AssemblerBuffer::EnsureCapacity ensured(&buffer_); | 573 AssemblerBuffer::EnsureCapacity ensured(&buffer_); |
577 EmitUint8(0xF2); | 574 EmitUint8(0xF2); |
| 575 EmitREX_RB(dst, src); |
578 EmitUint8(0x0F); | 576 EmitUint8(0x0F); |
579 EmitUint8(0x59); | 577 EmitUint8(0x59); |
580 EmitXmmRegisterOperand(dst, src); | 578 EmitXmmRegisterOperand(dst & 7, src); |
581 } | 579 } |
582 | 580 |
583 | 581 |
584 void Assembler::divsd(XmmRegister dst, XmmRegister src) { | 582 void Assembler::divsd(XmmRegister dst, XmmRegister src) { |
585 // TODO(srdjan): implement and test XMM8 - XMM15. | 583 ASSERT(src <= XMM15); |
586 ASSERT(src <= XMM7); | 584 ASSERT(dst <= XMM15); |
587 ASSERT(dst <= XMM7); | |
588 AssemblerBuffer::EnsureCapacity ensured(&buffer_); | 585 AssemblerBuffer::EnsureCapacity ensured(&buffer_); |
589 EmitUint8(0xF2); | 586 EmitUint8(0xF2); |
| 587 EmitREX_RB(dst, src); |
590 EmitUint8(0x0F); | 588 EmitUint8(0x0F); |
591 EmitUint8(0x5E); | 589 EmitUint8(0x5E); |
592 EmitXmmRegisterOperand(dst, src); | 590 EmitXmmRegisterOperand(dst & 7, src); |
593 } | 591 } |
594 | 592 |
595 | 593 |
596 void Assembler::comisd(XmmRegister a, XmmRegister b) { | 594 void Assembler::comisd(XmmRegister a, XmmRegister b) { |
597 ASSERT(a <= XMM7); | 595 ASSERT(a <= XMM15); |
598 ASSERT(b <= XMM7); | 596 ASSERT(b <= XMM15); |
599 AssemblerBuffer::EnsureCapacity ensured(&buffer_); | 597 AssemblerBuffer::EnsureCapacity ensured(&buffer_); |
600 EmitUint8(0x66); | 598 EmitUint8(0x66); |
| 599 EmitREX_RB(a, b); |
601 EmitUint8(0x0F); | 600 EmitUint8(0x0F); |
602 EmitUint8(0x2F); | 601 EmitUint8(0x2F); |
603 EmitXmmRegisterOperand(a, b); | 602 EmitXmmRegisterOperand(a & 7, b); |
604 } | 603 } |
605 | 604 |
606 | 605 |
607 void Assembler::movmskpd(Register dst, XmmRegister src) { | 606 void Assembler::movmskpd(Register dst, XmmRegister src) { |
608 ASSERT(src <= XMM7); | 607 ASSERT(src <= XMM15); |
609 AssemblerBuffer::EnsureCapacity ensured(&buffer_); | 608 AssemblerBuffer::EnsureCapacity ensured(&buffer_); |
610 EmitUint8(0x66); | 609 EmitUint8(0x66); |
| 610 EmitREX_RB(dst, src); |
611 EmitUint8(0x0F); | 611 EmitUint8(0x0F); |
612 EmitUint8(0x50); | 612 EmitUint8(0x50); |
613 EmitXmmRegisterOperand(dst, src); | 613 EmitXmmRegisterOperand(dst & 7, src); |
614 } | 614 } |
615 | 615 |
616 | 616 |
617 void Assembler::sqrtsd(XmmRegister dst, XmmRegister src) { | 617 void Assembler::sqrtsd(XmmRegister dst, XmmRegister src) { |
618 ASSERT(dst <= XMM7); | 618 ASSERT(dst <= XMM15); |
619 ASSERT(src <= XMM7); | 619 ASSERT(src <= XMM15); |
620 AssemblerBuffer::EnsureCapacity ensured(&buffer_); | 620 AssemblerBuffer::EnsureCapacity ensured(&buffer_); |
621 EmitUint8(0xF2); | 621 EmitUint8(0xF2); |
| 622 EmitREX_RB(dst, src); |
622 EmitUint8(0x0F); | 623 EmitUint8(0x0F); |
623 EmitUint8(0x51); | 624 EmitUint8(0x51); |
624 EmitXmmRegisterOperand(dst, src); | 625 EmitXmmRegisterOperand(dst & 7, src); |
625 } | 626 } |
626 | 627 |
627 | 628 |
628 void Assembler::xorpd(XmmRegister dst, const Address& src) { | 629 void Assembler::xorpd(XmmRegister dst, const Address& src) { |
629 ASSERT(dst <= XMM7); | 630 ASSERT(dst <= XMM15); |
630 AssemblerBuffer::EnsureCapacity ensured(&buffer_); | 631 AssemblerBuffer::EnsureCapacity ensured(&buffer_); |
631 EmitUint8(0x66); | 632 EmitUint8(0x66); |
632 EmitOperandREX(0, src, REX_NONE); | 633 EmitOperandREX(dst, src, REX_NONE); |
633 EmitUint8(0x0F); | 634 EmitUint8(0x0F); |
634 EmitUint8(0x57); | 635 EmitUint8(0x57); |
635 EmitOperand(dst & 7, src); | 636 EmitOperand(dst & 7, src); |
636 } | 637 } |
637 | 638 |
638 | 639 |
639 void Assembler::xorpd(XmmRegister dst, XmmRegister src) { | 640 void Assembler::xorpd(XmmRegister dst, XmmRegister src) { |
640 ASSERT(dst <= XMM7); | 641 ASSERT(dst <= XMM15); |
641 ASSERT(src <= XMM7); | 642 ASSERT(src <= XMM15); |
642 AssemblerBuffer::EnsureCapacity ensured(&buffer_); | 643 AssemblerBuffer::EnsureCapacity ensured(&buffer_); |
643 EmitUint8(0x66); | 644 EmitUint8(0x66); |
| 645 EmitREX_RB(dst, src); |
644 EmitUint8(0x0F); | 646 EmitUint8(0x0F); |
645 EmitUint8(0x57); | 647 EmitUint8(0x57); |
646 EmitXmmRegisterOperand(dst, src); | 648 EmitXmmRegisterOperand(dst & 7, src); |
647 } | 649 } |
648 | 650 |
649 | 651 |
650 void Assembler::cvtsi2sd(XmmRegister dst, Register src) { | 652 void Assembler::cvtsi2sd(XmmRegister dst, Register src) { |
651 AssemblerBuffer::EnsureCapacity ensured(&buffer_); | 653 AssemblerBuffer::EnsureCapacity ensured(&buffer_); |
652 ASSERT(dst <= XMM7); | 654 ASSERT(dst <= XMM15); |
653 Operand operand(src); | 655 Operand operand(src); |
654 EmitUint8(0xF2); | 656 EmitUint8(0xF2); |
655 EmitOperandREX(0, operand, REX_W); | 657 EmitOperandREX(dst, operand, REX_W); |
656 EmitUint8(0x0F); | 658 EmitUint8(0x0F); |
657 EmitUint8(0x2A); | 659 EmitUint8(0x2A); |
658 EmitOperand(dst, operand); | 660 EmitOperand(dst & 7, operand); |
659 } | 661 } |
660 | 662 |
661 | 663 |
662 void Assembler::cvttsd2siq(Register dst, XmmRegister src) { | 664 void Assembler::cvttsd2siq(Register dst, XmmRegister src) { |
663 ASSERT(src <= XMM7); | 665 ASSERT(src <= XMM15); |
664 AssemblerBuffer::EnsureCapacity ensured(&buffer_); | 666 AssemblerBuffer::EnsureCapacity ensured(&buffer_); |
665 EmitUint8(0xF2); | 667 EmitUint8(0xF2); |
666 Operand operand(dst); | 668 Operand operand(dst); |
667 EmitOperandREX(0, operand, REX_W); | 669 EmitREX_RB(dst, src, REX_W); |
668 EmitUint8(0x0F); | 670 EmitUint8(0x0F); |
669 EmitUint8(0x2C); | 671 EmitUint8(0x2C); |
670 EmitXmmRegisterOperand(dst, src); | 672 EmitXmmRegisterOperand(dst & 7, src); |
671 } | 673 } |
672 | 674 |
673 | 675 |
674 void Assembler::cvtss2sd(XmmRegister dst, XmmRegister src) { | 676 void Assembler::cvtss2sd(XmmRegister dst, XmmRegister src) { |
675 ASSERT(src <= XMM7); | 677 ASSERT(src <= XMM15); |
676 ASSERT(dst <= XMM7); | 678 ASSERT(dst <= XMM15); |
677 AssemblerBuffer::EnsureCapacity ensured(&buffer_); | 679 AssemblerBuffer::EnsureCapacity ensured(&buffer_); |
678 EmitUint8(0xF3); | 680 EmitUint8(0xF3); |
| 681 EmitREX_RB(dst, src); |
679 EmitUint8(0x0F); | 682 EmitUint8(0x0F); |
680 EmitUint8(0x5A); | 683 EmitUint8(0x5A); |
681 EmitXmmRegisterOperand(dst, src); | 684 EmitXmmRegisterOperand(dst & 7, src); |
682 } | 685 } |
683 | 686 |
684 | 687 |
685 void Assembler::cvtsd2ss(XmmRegister dst, XmmRegister src) { | 688 void Assembler::cvtsd2ss(XmmRegister dst, XmmRegister src) { |
686 ASSERT(src <= XMM7); | 689 ASSERT(src <= XMM15); |
687 ASSERT(dst <= XMM7); | 690 ASSERT(dst <= XMM15); |
688 AssemblerBuffer::EnsureCapacity ensured(&buffer_); | 691 AssemblerBuffer::EnsureCapacity ensured(&buffer_); |
689 EmitUint8(0xF2); | 692 EmitUint8(0xF2); |
| 693 EmitREX_RB(dst, src); |
690 EmitUint8(0x0F); | 694 EmitUint8(0x0F); |
691 EmitUint8(0x5A); | 695 EmitUint8(0x5A); |
692 EmitXmmRegisterOperand(dst, src); | 696 EmitXmmRegisterOperand(dst & 7, src); |
693 } | 697 } |
694 | 698 |
695 | 699 |
696 void Assembler::fldl(const Address& src) { | 700 void Assembler::fldl(const Address& src) { |
697 AssemblerBuffer::EnsureCapacity ensured(&buffer_); | 701 AssemblerBuffer::EnsureCapacity ensured(&buffer_); |
698 EmitUint8(0xDD); | 702 EmitUint8(0xDD); |
699 EmitOperand(0, src); | 703 EmitOperand(0, src); |
700 } | 704 } |
701 | 705 |
702 | 706 |
(...skipping 1397 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2100 }; | 2104 }; |
2101 | 2105 |
2102 | 2106 |
2103 const char* Assembler::RegisterName(Register reg) { | 2107 const char* Assembler::RegisterName(Register reg) { |
2104 ASSERT((0 <= reg) && (reg < kNumberOfCpuRegisters)); | 2108 ASSERT((0 <= reg) && (reg < kNumberOfCpuRegisters)); |
2105 return cpu_reg_names[reg]; | 2109 return cpu_reg_names[reg]; |
2106 } | 2110 } |
2107 | 2111 |
2108 | 2112 |
2109 static const char* xmm_reg_names[kNumberOfXmmRegisters] = { | 2113 static const char* xmm_reg_names[kNumberOfXmmRegisters] = { |
2110 "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7" | 2114 "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7", |
| 2115 "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15" |
2111 }; | 2116 }; |
2112 | 2117 |
2113 | 2118 |
2114 const char* Assembler::XmmRegisterName(XmmRegister reg) { | 2119 const char* Assembler::XmmRegisterName(XmmRegister reg) { |
2115 ASSERT((0 <= reg) && (reg < kNumberOfXmmRegisters)); | 2120 ASSERT((0 <= reg) && (reg < kNumberOfXmmRegisters)); |
2116 return xmm_reg_names[reg]; | 2121 return xmm_reg_names[reg]; |
2117 } | 2122 } |
2118 | 2123 |
2119 | 2124 |
2120 } // namespace dart | 2125 } // namespace dart |
2121 | 2126 |
2122 #endif // defined TARGET_ARCH_X64 | 2127 #endif // defined TARGET_ARCH_X64 |
OLD | NEW |