3646 %}
3647
3648 operand rFlagsRegUCF() %{
3649 constraint(ALLOC_IN_RC(int_flags));
3650 match(RegFlags);
3651 predicate(false);
3652
3653 format %{ "RFLAGS_U_CF" %}
3654 interface(REG_INTER);
3655 %}
3656
3657 // Float register operands
3658 operand regF() %{
3659 constraint(ALLOC_IN_RC(float_reg));
3660 match(RegF);
3661
3662 format %{ %}
3663 interface(REG_INTER);
3664 %}
3665
3666 // Float register operands
3667 operand vlRegF() %{
3668 constraint(ALLOC_IN_RC(float_reg_vl));
3669 match(RegF);
3670
3671 format %{ %}
3672 interface(REG_INTER);
3673 %}
3674
3675 // Double register operands
3676 operand regD() %{
3677 constraint(ALLOC_IN_RC(double_reg));
3678 match(RegD);
3679
3680 format %{ %}
3681 interface(REG_INTER);
3682 %}
3683
3684 // Double register operands
3685 operand vlRegD() %{
3686 constraint(ALLOC_IN_RC(double_reg_vl));
3687 match(RegD);
3688
3689 format %{ %}
3690 interface(REG_INTER);
3691 %}
3692
3693 // Vectors
3694 operand vecS() %{
3695 constraint(ALLOC_IN_RC(vectors_reg_vlbwdq));
3696 match(VecS);
3697
3698 format %{ %}
3699 interface(REG_INTER);
3700 %}
3701
3702 // Vectors
3703 operand legVecS() %{
3704 constraint(ALLOC_IN_RC(vectors_reg_legacy));
5392 format %{ "movl $dst, $mem\t# compressed klass ptr" %}
5393 ins_encode %{
5394 __ movl($dst$$Register, $mem$$Address);
5395 %}
5396 ins_pipe(ialu_reg_mem); // XXX
5397 %}
5398
5399 // Load Float
5400 instruct loadF(regF dst, memory mem)
5401 %{
5402 match(Set dst (LoadF mem));
5403
5404 ins_cost(145); // XXX
5405 format %{ "movss $dst, $mem\t# float" %}
5406 ins_encode %{
5407 __ movflt($dst$$XMMRegister, $mem$$Address);
5408 %}
5409 ins_pipe(pipe_slow); // XXX
5410 %}
5411
5412 // Load Float
5413 instruct MoveF2VL(vlRegF dst, regF src) %{
5414 match(Set dst src);
5415 format %{ "movss $dst,$src\t! load float (4 bytes)" %}
5416 ins_encode %{
5417 __ movflt($dst$$XMMRegister, $src$$XMMRegister);
5418 %}
5419 ins_pipe( fpu_reg_reg );
5420 %}
5421
5422 // Load Float
5423 instruct MoveVL2F(regF dst, vlRegF src) %{
5424 match(Set dst src);
5425 format %{ "movss $dst,$src\t! load float (4 bytes)" %}
5426 ins_encode %{
5427 __ movflt($dst$$XMMRegister, $src$$XMMRegister);
5428 %}
5429 ins_pipe( fpu_reg_reg );
5430 %}
5431
5432 // Load Double
5433 instruct loadD_partial(regD dst, memory mem)
5434 %{
5435 predicate(!UseXmmLoadAndClearUpper);
5436 match(Set dst (LoadD mem));
5437
5438 ins_cost(145); // XXX
5439 format %{ "movlpd $dst, $mem\t# double" %}
5440 ins_encode %{
5441 __ movdbl($dst$$XMMRegister, $mem$$Address);
5442 %}
5443 ins_pipe(pipe_slow); // XXX
5444 %}
5445
5446 instruct loadD(regD dst, memory mem)
5447 %{
5448 predicate(UseXmmLoadAndClearUpper);
5449 match(Set dst (LoadD mem));
5450
5451 ins_cost(145); // XXX
5452 format %{ "movsd $dst, $mem\t# double" %}
5453 ins_encode %{
5454 __ movdbl($dst$$XMMRegister, $mem$$Address);
5455 %}
5456 ins_pipe(pipe_slow); // XXX
5457 %}
5458
5459 // Load Double
5460 instruct MoveD2VL(vlRegD dst, regD src) %{
5461 match(Set dst src);
5462 format %{ "movsd $dst,$src\t! load double (8 bytes)" %}
5463 ins_encode %{
5464 __ movdbl($dst$$XMMRegister, $src$$XMMRegister);
5465 %}
5466 ins_pipe( fpu_reg_reg );
5467 %}
5468
5469 // Load Double
5470 instruct MoveVL2D(regD dst, vlRegD src) %{
5471 match(Set dst src);
5472 format %{ "movsd $dst,$src\t! load double (8 bytes)" %}
5473 ins_encode %{
5474 __ movdbl($dst$$XMMRegister, $src$$XMMRegister);
5475 %}
5476 ins_pipe( fpu_reg_reg );
5477 %}
5478
5479 // Load Effective Address
5480 instruct leaP8(rRegP dst, indOffset8 mem)
5481 %{
5482 match(Set dst mem);
5483
5484 ins_cost(110); // XXX
5485 format %{ "leaq $dst, $mem\t# ptr 8" %}
5486 opcode(0x8D);
5487 ins_encode(REX_reg_mem_wide(dst, mem), OpcP, reg_mem(dst, mem));
5488 ins_pipe(ialu_reg_reg_fat);
5489 %}
5490
|
3646 %}
3647
3648 operand rFlagsRegUCF() %{
3649 constraint(ALLOC_IN_RC(int_flags));
3650 match(RegFlags);
3651 predicate(false);
3652
3653 format %{ "RFLAGS_U_CF" %}
3654 interface(REG_INTER);
3655 %}
3656
3657 // Float register operands
3658 operand regF() %{
3659 constraint(ALLOC_IN_RC(float_reg));
3660 match(RegF);
3661
3662 format %{ %}
3663 interface(REG_INTER);
3664 %}
3665
3666
3667 // Float register operands
3668 operand legRegF() %{
3669 constraint(ALLOC_IN_RC(float_reg_legacy));
3670 match(RegF);
3671
3672 format %{ %}
3673 interface(REG_INTER);
3674 %}
3675
3676 // Float register operands
3677 operand vlRegF() %{
3678 constraint(ALLOC_IN_RC(float_reg_vl));
3679 match(RegF);
3680
3681 format %{ %}
3682 interface(REG_INTER);
3683 %}
3684
3685 // Double register operands
3686 operand regD() %{
3687 constraint(ALLOC_IN_RC(double_reg));
3688 match(RegD);
3689
3690 format %{ %}
3691 interface(REG_INTER);
3692 %}
3693
3694 // Double register operands
3695 operand legRegD() %{
3696 constraint(ALLOC_IN_RC(double_reg_legacy));
3697 match(RegD);
3698
3699 format %{ %}
3700 interface(REG_INTER);
3701 %}
3702
3703 // Double register operands
3704 operand vlRegD() %{
3705 constraint(ALLOC_IN_RC(double_reg_vl));
3706 match(RegD);
3707
3708 format %{ %}
3709 interface(REG_INTER);
3710 %}
3711
3712 // Vectors
3713 operand vecS() %{
3714 constraint(ALLOC_IN_RC(vectors_reg_vlbwdq));
3715 match(VecS);
3716
3717 format %{ %}
3718 interface(REG_INTER);
3719 %}
3720
3721 // Vectors
3722 operand legVecS() %{
3723 constraint(ALLOC_IN_RC(vectors_reg_legacy));
5411 format %{ "movl $dst, $mem\t# compressed klass ptr" %}
5412 ins_encode %{
5413 __ movl($dst$$Register, $mem$$Address);
5414 %}
5415 ins_pipe(ialu_reg_mem); // XXX
5416 %}
5417
5418 // Load Float
5419 instruct loadF(regF dst, memory mem)
5420 %{
5421 match(Set dst (LoadF mem));
5422
5423 ins_cost(145); // XXX
5424 format %{ "movss $dst, $mem\t# float" %}
5425 ins_encode %{
5426 __ movflt($dst$$XMMRegister, $mem$$Address);
5427 %}
5428 ins_pipe(pipe_slow); // XXX
5429 %}
5430
5431
5432 // Load Float
5433 instruct MoveF2VL(vlRegF dst, regF src) %{
5434 match(Set dst src);
5435 format %{ "movss $dst,$src\t! load float (4 bytes)" %}
5436 ins_encode %{
5437 __ movflt($dst$$XMMRegister, $src$$XMMRegister);
5438 %}
5439 ins_pipe( fpu_reg_reg );
5440 %}
5441
5442 // Load Float
5443 instruct MoveF2LEG(legRegF dst, regF src) %{
5444 match(Set dst src);
5445 format %{ "movss $dst,$src\t! load float (4 bytes)" %}
5446 ins_encode %{
5447 __ movflt($dst$$XMMRegister, $src$$XMMRegister);
5448 %}
5449 ins_pipe( fpu_reg_reg );
5450 %}
5451
5452 // Load Float
5453 instruct MoveVL2F(regF dst, vlRegF src) %{
5454 match(Set dst src);
5455 format %{ "movss $dst,$src\t! load float (4 bytes)" %}
5456 ins_encode %{
5457 __ movflt($dst$$XMMRegister, $src$$XMMRegister);
5458 %}
5459 ins_pipe( fpu_reg_reg );
5460 %}
5461
5462 // Load Float
5463 instruct MoveLEG2F(regF dst, legRegF src) %{
5464 match(Set dst src);
5465 format %{ "movss $dst,$src\t! load float (4 bytes)" %}
5466 ins_encode %{
5467 __ movflt($dst$$XMMRegister, $src$$XMMRegister);
5468 %}
5469 ins_pipe( fpu_reg_reg );
5470 %}
5471
5472 // Load Double
5473 instruct loadD_partial(regD dst, memory mem)
5474 %{
5475 predicate(!UseXmmLoadAndClearUpper);
5476 match(Set dst (LoadD mem));
5477
5478 ins_cost(145); // XXX
5479 format %{ "movlpd $dst, $mem\t# double" %}
5480 ins_encode %{
5481 __ movdbl($dst$$XMMRegister, $mem$$Address);
5482 %}
5483 ins_pipe(pipe_slow); // XXX
5484 %}
5485
5486
5487 instruct loadD(regD dst, memory mem)
5488 %{
5489 predicate(UseXmmLoadAndClearUpper);
5490 match(Set dst (LoadD mem));
5491
5492 ins_cost(145); // XXX
5493 format %{ "movsd $dst, $mem\t# double" %}
5494 ins_encode %{
5495 __ movdbl($dst$$XMMRegister, $mem$$Address);
5496 %}
5497 ins_pipe(pipe_slow); // XXX
5498 %}
5499
5500 // Load Double
5501 instruct MoveD2VL(vlRegD dst, regD src) %{
5502 match(Set dst src);
5503 format %{ "movsd $dst,$src\t! load double (8 bytes)" %}
5504 ins_encode %{
5505 __ movdbl($dst$$XMMRegister, $src$$XMMRegister);
5506 %}
5507 ins_pipe( fpu_reg_reg );
5508 %}
5509
5510 // Load Double
5511 instruct MoveD2LEG(legRegD dst, regD src) %{
5512 match(Set dst src);
5513 format %{ "movsd $dst,$src\t! load double (8 bytes)" %}
5514 ins_encode %{
5515 __ movdbl($dst$$XMMRegister, $src$$XMMRegister);
5516 %}
5517 ins_pipe( fpu_reg_reg );
5518 %}
5519
5520 // Load Double
5521 instruct MoveVL2D(regD dst, vlRegD src) %{
5522 match(Set dst src);
5523 format %{ "movsd $dst,$src\t! load double (8 bytes)" %}
5524 ins_encode %{
5525 __ movdbl($dst$$XMMRegister, $src$$XMMRegister);
5526 %}
5527 ins_pipe( fpu_reg_reg );
5528 %}
5529
5530 // Load Double
5531 instruct MoveLEG2D(regD dst, legRegD src) %{
5532 match(Set dst src);
5533 format %{ "movsd $dst,$src\t! load double (8 bytes)" %}
5534 ins_encode %{
5535 __ movdbl($dst$$XMMRegister, $src$$XMMRegister);
5536 %}
5537 ins_pipe( fpu_reg_reg );
5538 %}
5539
5540 // Load Effective Address
5541 instruct leaP8(rRegP dst, indOffset8 mem)
5542 %{
5543 match(Set dst mem);
5544
5545 ins_cost(110); // XXX
5546 format %{ "leaq $dst, $mem\t# ptr 8" %}
5547 opcode(0x8D);
5548 ins_encode(REX_reg_mem_wide(dst, mem), OpcP, reg_mem(dst, mem));
5549 ins_pipe(ialu_reg_reg_fat);
5550 %}
5551
|