< prev index next >

src/cpu/x86/vm/stubGenerator_x86_64.cpp

Print this page
rev 7584 : code minimum


 513     // make sure exception is set
 514     {
 515       Label L;
 516       __ testptr(rax, rax);
 517       __ jcc(Assembler::notEqual, L);
 518       __ stop("StubRoutines::forward exception: no pending exception (2)");
 519       __ bind(L);
 520     }
 521 #endif
 522 
 523     // continue at exception handler (return address removed)
 524     // rax: exception
 525     // rbx: exception handler
 526     // rdx: throwing pc
 527     __ verify_oop(rax);
 528     __ jmp(rbx);
 529 
 530     return start;
 531   }
 532 
 533   // Support for jint atomic::xchg(jint exchange_value, volatile jint* dest)
 534   //
 535   // Arguments :
 536   //    c_rarg0: exchange_value
 537   //    c_rarg0: dest
 538   //
 539   // Result:
 540   //    *dest <- ex, return (orig *dest)
 541   address generate_atomic_xchg() {
 542     StubCodeMark mark(this, "StubRoutines", "atomic_xchg");
 543     address start = __ pc();
 544 
 545     __ movl(rax, c_rarg0); // Copy to eax we need a return value anyhow
 546     __ xchgl(rax, Address(c_rarg1, 0)); // automatic LOCK
 547     __ ret(0);
 548 
 549     return start;
 550   }
 551 
 552   // Support for intptr_t atomic::xchg_ptr(intptr_t exchange_value, volatile intptr_t* dest)
 553   //
 554   // Arguments :
 555   //    c_rarg0: exchange_value
 556   //    c_rarg1: dest
 557   //
 558   // Result:
 559   //    *dest <- ex, return (orig *dest)
 560   address generate_atomic_xchg_ptr() {
 561     StubCodeMark mark(this, "StubRoutines", "atomic_xchg_ptr");
 562     address start = __ pc();
 563 
 564     __ movptr(rax, c_rarg0); // Copy to eax we need a return value anyhow
 565     __ xchgptr(rax, Address(c_rarg1, 0)); // automatic LOCK
 566     __ ret(0);
 567 
 568     return start;
 569   }
 570 
 571   // Support for jint atomic::atomic_cmpxchg(jint exchange_value, volatile jint* dest,
 572   //                                         jint compare_value)
 573   //
 574   // Arguments :
 575   //    c_rarg0: exchange_value
 576   //    c_rarg1: dest
 577   //    c_rarg2: compare_value
 578   //
 579   // Result:
 580   //    if ( compare_value == *dest ) {
 581   //       *dest = exchange_value
 582   //       return compare_value;
 583   //    else
 584   //       return *dest;
 585   address generate_atomic_cmpxchg() {
 586     StubCodeMark mark(this, "StubRoutines", "atomic_cmpxchg");
 587     address start = __ pc();
 588 
 589     __ movl(rax, c_rarg2);
 590    if ( os::is_MP() ) __ lock();
 591     __ cmpxchgl(c_rarg0, Address(c_rarg1, 0));
 592     __ ret(0);
 593 
 594     return start;
 595   }
 596 
 597   // Support for jbyte atomic::atomic_cmpxchg(jbyte exchange_value, volatile jbyte* dest,
 598   //                                          jbyte compare_value)
 599   //
 600   // Arguments :
 601   //    c_rarg0: exchange_value
 602   //    c_rarg1: dest
 603   //    c_rarg2: compare_value
 604   //
 605   // Result:
 606   //    if ( compare_value == *dest ) {
 607   //       *dest = exchange_value
 608   //       return compare_value;
 609   //    else
 610   //       return *dest;
 611   address generate_atomic_cmpxchg_byte() {
 612     StubCodeMark mark(this, "StubRoutines", "atomic_cmpxchg_byte");
 613     address start = __ pc();
 614 
 615     __ movsbq(rax, c_rarg2);
 616    if ( os::is_MP() ) __ lock();
 617     __ cmpxchgb(c_rarg0, Address(c_rarg1, 0));
 618     __ ret(0);
 619 
 620     return start;
 621   }
 622 
 623   // Support for jlong atomic::atomic_cmpxchg(jlong exchange_value,
 624   //                                          volatile jlong* dest,
 625   //                                          jlong compare_value)
 626   // Arguments :
 627   //    c_rarg0: exchange_value
 628   //    c_rarg1: dest
 629   //    c_rarg2: compare_value
 630   //
 631   // Result:
 632   //    if ( compare_value == *dest ) {
 633   //       *dest = exchange_value
 634   //       return compare_value;
 635   //    else
 636   //       return *dest;
 637   address generate_atomic_cmpxchg_long() {
 638     StubCodeMark mark(this, "StubRoutines", "atomic_cmpxchg_long");
 639     address start = __ pc();
 640 
 641     __ movq(rax, c_rarg2);
 642    if ( os::is_MP() ) __ lock();
 643     __ cmpxchgq(c_rarg0, Address(c_rarg1, 0));
 644     __ ret(0);
 645 
 646     return start;
 647   }
 648 
 649   // Support for jint atomic::add(jint add_value, volatile jint* dest)
 650   //
 651   // Arguments :
 652   //    c_rarg0: add_value
 653   //    c_rarg1: dest
 654   //
 655   // Result:
 656   //    *dest += add_value
 657   //    return *dest;
 658   address generate_atomic_add() {
 659     StubCodeMark mark(this, "StubRoutines", "atomic_add");
 660     address start = __ pc();
 661 
 662     __ movl(rax, c_rarg0);
 663    if ( os::is_MP() ) __ lock();
 664     __ xaddl(Address(c_rarg1, 0), c_rarg0);
 665     __ addl(rax, c_rarg0);
 666     __ ret(0);
 667 
 668     return start;
 669   }
 670 
 671   // Support for intptr_t atomic::add_ptr(intptr_t add_value, volatile intptr_t* dest)
 672   //
 673   // Arguments :
 674   //    c_rarg0: add_value
 675   //    c_rarg1: dest
 676   //
 677   // Result:
 678   //    *dest += add_value
 679   //    return *dest;
 680   address generate_atomic_add_ptr() {
 681     StubCodeMark mark(this, "StubRoutines", "atomic_add_ptr");
 682     address start = __ pc();
 683 
 684     __ movptr(rax, c_rarg0); // Copy to eax we need a return value anyhow
 685    if ( os::is_MP() ) __ lock();
 686     __ xaddptr(Address(c_rarg1, 0), c_rarg0);
 687     __ addptr(rax, c_rarg0);
 688     __ ret(0);
 689 
 690     return start;
 691   }




 513     // make sure exception is set
 514     {
 515       Label L;
 516       __ testptr(rax, rax);
 517       __ jcc(Assembler::notEqual, L);
 518       __ stop("StubRoutines::forward exception: no pending exception (2)");
 519       __ bind(L);
 520     }
 521 #endif
 522 
 523     // continue at exception handler (return address removed)
 524     // rax: exception
 525     // rbx: exception handler
 526     // rdx: throwing pc
 527     __ verify_oop(rax);
 528     __ jmp(rbx);
 529 
 530     return start;
 531   }
 532 
 533   // Support for jint Atomic::xchg(jint exchange_value, volatile jint* dest)
 534   //
 535   // Arguments :
 536   //    c_rarg0: exchange_value
 537   //    c_rarg0: dest
 538   //
 539   // Result:
 540   //    *dest <- ex, return (orig *dest)
 541   address generate_atomic_xchg() {
 542     StubCodeMark mark(this, "StubRoutines", "atomic_xchg");
 543     address start = __ pc();
 544 
 545     __ movl(rax, c_rarg0); // Copy to eax we need a return value anyhow
 546     __ xchgl(rax, Address(c_rarg1, 0)); // automatic LOCK
 547     __ ret(0);
 548 
 549     return start;
 550   }
 551 
 552   // Support for intptr_t Atomic::xchg_ptr(intptr_t exchange_value, volatile intptr_t* dest)
 553   //
 554   // Arguments :
 555   //    c_rarg0: exchange_value
 556   //    c_rarg1: dest
 557   //
 558   // Result:
 559   //    *dest <- ex, return (orig *dest)
 560   address generate_atomic_xchg_ptr() {
 561     StubCodeMark mark(this, "StubRoutines", "atomic_xchg_ptr");
 562     address start = __ pc();
 563 
 564     __ movptr(rax, c_rarg0); // Copy to eax we need a return value anyhow
 565     __ xchgptr(rax, Address(c_rarg1, 0)); // automatic LOCK
 566     __ ret(0);
 567 
 568     return start;
 569   }
 570 
 571   // Support for jint Atomic::cmpxchg(jint exchange_value, volatile jint* dest,
 572   //                                  jint compare_value)
 573   //
 574   // Arguments :
 575   //    c_rarg0: exchange_value
 576   //    c_rarg1: dest
 577   //    c_rarg2: compare_value
 578   //
 579   // Result:
 580   //    if ( compare_value == *dest ) {
 581   //       *dest = exchange_value
 582   //       return compare_value;
 583   //    else
 584   //       return *dest;
 585   address generate_atomic_cmpxchg() {
 586     StubCodeMark mark(this, "StubRoutines", "atomic_cmpxchg");
 587     address start = __ pc();
 588 
 589     __ movl(rax, c_rarg2);
 590    if ( os::is_MP() ) __ lock();
 591     __ cmpxchgl(c_rarg0, Address(c_rarg1, 0));
 592     __ ret(0);
 593 
 594     return start;
 595   }
 596 
 597   // Support for jbyte Atomic::cmpxchg(jbyte exchange_value, volatile jbyte* dest,
 598   //                                   jbyte compare_value)
 599   //
 600   // Arguments :
 601   //    c_rarg0: exchange_value
 602   //    c_rarg1: dest
 603   //    c_rarg2: compare_value
 604   //
 605   // Result:
 606   //    if ( compare_value == *dest ) {
 607   //       *dest = exchange_value
 608   //       return compare_value;
 609   //    else
 610   //       return *dest;
 611   address generate_atomic_cmpxchg_byte() {
 612     StubCodeMark mark(this, "StubRoutines", "atomic_cmpxchg_byte");
 613     address start = __ pc();
 614 
 615     __ movsbq(rax, c_rarg2);
 616    if ( os::is_MP() ) __ lock();
 617     __ cmpxchgb(c_rarg0, Address(c_rarg1, 0));
 618     __ ret(0);
 619 
 620     return start;
 621   }
 622 
 623   // Support for jlong Atomic::cmpxchg(jlong exchange_value, volatile jlong* dest,

 624   //                                   jlong compare_value)
 625   // Arguments :
 626   //    c_rarg0: exchange_value
 627   //    c_rarg1: dest
 628   //    c_rarg2: compare_value
 629   //
 630   // Result:
 631   //    if ( compare_value == *dest ) {
 632   //       *dest = exchange_value
 633   //       return compare_value;
 634   //    else
 635   //       return *dest;
 636   address generate_atomic_cmpxchg_long() {
 637     StubCodeMark mark(this, "StubRoutines", "atomic_cmpxchg_long");
 638     address start = __ pc();
 639 
 640     __ movq(rax, c_rarg2);
 641    if ( os::is_MP() ) __ lock();
 642     __ cmpxchgq(c_rarg0, Address(c_rarg1, 0));
 643     __ ret(0);
 644 
 645     return start;
 646   }
 647 
 648   // Support for jint Atomic::add(jint add_value, volatile jint* dest)
 649   //
 650   // Arguments :
 651   //    c_rarg0: add_value
 652   //    c_rarg1: dest
 653   //
 654   // Result:
 655   //    *dest += add_value
 656   //    return *dest;
 657   address generate_atomic_add() {
 658     StubCodeMark mark(this, "StubRoutines", "atomic_add");
 659     address start = __ pc();
 660 
 661     __ movl(rax, c_rarg0);
 662    if ( os::is_MP() ) __ lock();
 663     __ xaddl(Address(c_rarg1, 0), c_rarg0);
 664     __ addl(rax, c_rarg0);
 665     __ ret(0);
 666 
 667     return start;
 668   }
 669 
 670   // Support for intptr_t Atomic::add_ptr(intptr_t add_value, volatile intptr_t* dest)
 671   //
 672   // Arguments :
 673   //    c_rarg0: add_value
 674   //    c_rarg1: dest
 675   //
 676   // Result:
 677   //    *dest += add_value
 678   //    return *dest;
 679   address generate_atomic_add_ptr() {
 680     StubCodeMark mark(this, "StubRoutines", "atomic_add_ptr");
 681     address start = __ pc();
 682 
 683     __ movptr(rax, c_rarg0); // Copy to eax we need a return value anyhow
 684    if ( os::is_MP() ) __ lock();
 685     __ xaddptr(Address(c_rarg1, 0), c_rarg0);
 686     __ addptr(rax, c_rarg0);
 687     __ ret(0);
 688 
 689     return start;
 690   }


< prev index next >