src/hotspot/cpu/x86/jniFastGetField_x86_64.cpp
changeset 51996 84743156e780
parent 50164 88bf53770be5
child 52105 537dbfcef4a7
equal deleted inserted replaced
51995:f7babf9d1592 51996:84743156e780
    75   ExternalAddress counter(SafepointSynchronize::safepoint_counter_addr());
    75   ExternalAddress counter(SafepointSynchronize::safepoint_counter_addr());
    76   __ mov32 (rcounter, counter);
    76   __ mov32 (rcounter, counter);
    77   __ mov   (robj, c_rarg1);
    77   __ mov   (robj, c_rarg1);
    78   __ testb (rcounter, 1);
    78   __ testb (rcounter, 1);
    79   __ jcc (Assembler::notZero, slow);
    79   __ jcc (Assembler::notZero, slow);
    80   if (os::is_MP()) {
    80 
    81     __ xorptr(robj, rcounter);
    81   __ xorptr(robj, rcounter);
    82     __ xorptr(robj, rcounter);                   // obj, since
    82   __ xorptr(robj, rcounter);  // obj, since
    83                                                 // robj ^ rcounter ^ rcounter == robj
    83                               // robj ^ rcounter ^ rcounter == robj
    84                                                 // robj is data dependent on rcounter.
    84                               // robj is data dependent on rcounter.
    85   }
       
    86 
    85 
    87   __ mov   (roffset, c_rarg2);
    86   __ mov   (roffset, c_rarg2);
    88   __ shrptr(roffset, 2);                         // offset
    87   __ shrptr(roffset, 2);                         // offset
    89 
    88 
    90   // Both robj and rtmp are clobbered by try_resolve_jobject_in_native.
    89   // Both robj and rtmp are clobbered by try_resolve_jobject_in_native.
   102     case T_INT:     __ movl   (rax, Address(robj, roffset, Address::times_1)); break;
   101     case T_INT:     __ movl   (rax, Address(robj, roffset, Address::times_1)); break;
   103     case T_LONG:    __ movq   (rax, Address(robj, roffset, Address::times_1)); break;
   102     case T_LONG:    __ movq   (rax, Address(robj, roffset, Address::times_1)); break;
   104     default:        ShouldNotReachHere();
   103     default:        ShouldNotReachHere();
   105   }
   104   }
   106 
   105 
   107   if (os::is_MP()) {
   106   // create data dependency on rax
   108     __ lea(rcounter_addr, counter);
   107   __ lea(rcounter_addr, counter);
   109     // ca is data dependent on rax.
   108   __ xorptr(rcounter_addr, rax);
   110     __ xorptr(rcounter_addr, rax);
   109   __ xorptr(rcounter_addr, rax);
   111     __ xorptr(rcounter_addr, rax);
   110   __ cmpl (rcounter, Address(rcounter_addr, 0));
   112     __ cmpl (rcounter, Address(rcounter_addr, 0));
   111 
   113   } else {
       
   114     __ cmp32 (rcounter, counter);
       
   115   }
       
   116   __ jcc (Assembler::notEqual, slow);
   112   __ jcc (Assembler::notEqual, slow);
   117 
   113 
   118   __ ret (0);
   114   __ ret (0);
   119 
   115 
   120   slowcase_entry_pclist[count++] = __ pc();
   116   slowcase_entry_pclist[count++] = __ pc();
   179   ExternalAddress counter(SafepointSynchronize::safepoint_counter_addr());
   175   ExternalAddress counter(SafepointSynchronize::safepoint_counter_addr());
   180   __ mov32 (rcounter, counter);
   176   __ mov32 (rcounter, counter);
   181   __ mov   (robj, c_rarg1);
   177   __ mov   (robj, c_rarg1);
   182   __ testb (rcounter, 1);
   178   __ testb (rcounter, 1);
   183   __ jcc (Assembler::notZero, slow);
   179   __ jcc (Assembler::notZero, slow);
   184   if (os::is_MP()) {
   180 
   185     __ xorptr(robj, rcounter);
   181   __ xorptr(robj, rcounter);
   186     __ xorptr(robj, rcounter);                   // obj, since
   182   __ xorptr(robj, rcounter);  // obj, since
   187                                                 // robj ^ rcounter ^ rcounter == robj
   183                               // robj ^ rcounter ^ rcounter == robj
   188                                                 // robj is data dependent on rcounter.
   184                               // robj is data dependent on rcounter.
   189   }
       
   190 
   185 
   191   // Both robj and rtmp are clobbered by try_resolve_jobject_in_native.
   186   // Both robj and rtmp are clobbered by try_resolve_jobject_in_native.
   192   BarrierSetAssembler* bs = BarrierSet::barrier_set()->barrier_set_assembler();
   187   BarrierSetAssembler* bs = BarrierSet::barrier_set()->barrier_set_assembler();
   193   bs->try_resolve_jobject_in_native(masm, /* jni_env */ c_rarg0, robj, rtmp, slow);
   188   bs->try_resolve_jobject_in_native(masm, /* jni_env */ c_rarg0, robj, rtmp, slow);
   194   DEBUG_ONLY(__ movl(rtmp, 0xDEADC0DE);)
   189   DEBUG_ONLY(__ movl(rtmp, 0xDEADC0DE);)
   202     case T_FLOAT:  __ movflt (xmm0, Address(robj, roffset, Address::times_1)); break;
   197     case T_FLOAT:  __ movflt (xmm0, Address(robj, roffset, Address::times_1)); break;
   203     case T_DOUBLE: __ movdbl (xmm0, Address(robj, roffset, Address::times_1)); break;
   198     case T_DOUBLE: __ movdbl (xmm0, Address(robj, roffset, Address::times_1)); break;
   204     default:        ShouldNotReachHere();
   199     default:        ShouldNotReachHere();
   205   }
   200   }
   206 
   201 
   207   if (os::is_MP()) {
   202   __ lea(rcounter_addr, counter);
   208     __ lea(rcounter_addr, counter);
   203   __ movdq (rax, xmm0);
   209     __ movdq (rax, xmm0);
   204   // counter address is data dependent on xmm0.
   210     // counter address is data dependent on xmm0.
   205   __ xorptr(rcounter_addr, rax);
   211     __ xorptr(rcounter_addr, rax);
   206   __ xorptr(rcounter_addr, rax);
   212     __ xorptr(rcounter_addr, rax);
   207   __ cmpl (rcounter, Address(rcounter_addr, 0));
   213     __ cmpl (rcounter, Address(rcounter_addr, 0));
       
   214   } else {
       
   215     __ cmp32 (rcounter, counter);
       
   216   }
       
   217   __ jcc (Assembler::notEqual, slow);
   208   __ jcc (Assembler::notEqual, slow);
   218 
   209 
   219   __ ret (0);
   210   __ ret (0);
   220 
   211 
   221   slowcase_entry_pclist[count++] = __ pc();
   212   slowcase_entry_pclist[count++] = __ pc();