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