< prev index next >

src/hotspot/share/runtime/stubRoutines.hpp

Print this page




 144   static address _atomic_xchg_entry;
 145   static address _atomic_xchg_long_entry;
 146   static address _atomic_store_entry;
 147   static address _atomic_cmpxchg_entry;
 148   static address _atomic_cmpxchg_byte_entry;
 149   static address _atomic_cmpxchg_long_entry;
 150   static address _atomic_add_entry;
 151   static address _atomic_add_long_entry;
 152   static address _fence_entry;
 153   static address _d2i_wrapper;
 154   static address _d2l_wrapper;
 155 
 156   static jint    _fpu_cntrl_wrd_std;
 157   static jint    _fpu_cntrl_wrd_24;
 158   static jint    _fpu_cntrl_wrd_trunc;
 159   static jint    _mxcsr_std;
 160   static jint    _fpu_subnormal_bias1[3];
 161   static jint    _fpu_subnormal_bias2[3];
 162 
 163   static BufferBlob* _code1;                               // code buffer for initial routines
 164   static BufferBlob* _code2;                               // code buffer for all other routines

 165 
 166   // Leaf routines which implement arraycopy and their addresses
 167   // arraycopy operands aligned on element type boundary
 168   static address _jbyte_arraycopy;
 169   static address _jshort_arraycopy;
 170   static address _jint_arraycopy;
 171   static address _jlong_arraycopy;
 172   static address _oop_arraycopy, _oop_arraycopy_uninit;
 173   static address _jbyte_disjoint_arraycopy;
 174   static address _jshort_disjoint_arraycopy;
 175   static address _jint_disjoint_arraycopy;
 176   static address _jlong_disjoint_arraycopy;
 177   static address _oop_disjoint_arraycopy, _oop_disjoint_arraycopy_uninit;
 178 
 179   // arraycopy operands aligned on zero'th element boundary
 180   // These are identical to the ones aligned aligned on an
 181   // element type boundary, except that they assume that both
 182   // source and destination are HeapWord aligned.
 183   static address _arrayof_jbyte_arraycopy;
 184   static address _arrayof_jshort_arraycopy;


 230 
 231   static address _multiplyToLen;
 232   static address _squareToLen;
 233   static address _mulAdd;
 234   static address _montgomeryMultiply;
 235   static address _montgomerySquare;
 236 
 237   static address _vectorizedMismatch;
 238 
 239   static address _dexp;
 240   static address _dlog;
 241   static address _dlog10;
 242   static address _dpow;
 243   static address _dsin;
 244   static address _dcos;
 245   static address _dlibm_sin_cos_huge;
 246   static address _dlibm_reduce_pi04l;
 247   static address _dlibm_tan_cot_huge;
 248   static address _dtan;
 249 










 250   // Safefetch stubs.
 251   static address _safefetch32_entry;
 252   static address _safefetch32_fault_pc;
 253   static address _safefetch32_continuation_pc;
 254   static address _safefetchN_entry;
 255   static address _safefetchN_fault_pc;
 256   static address _safefetchN_continuation_pc;
 257 
 258  public:
 259   // Initialization/Testing
 260   static void    initialize1();                            // must happen before universe::genesis
 261   static void    initialize2();                            // must happen after  universe::genesis

 262 
 263   static bool is_stub_code(address addr)                   { return contains(addr); }
 264 
 265   static bool contains(address addr) {
 266     return
 267       (_code1 != NULL && _code1->blob_contains(addr)) ||
 268       (_code2 != NULL && _code2->blob_contains(addr)) ;
 269   }
 270 
 271   static RuntimeBlob* code1() { return _code1; }
 272   static RuntimeBlob* code2() { return _code2; }

 273 
 274   // Debugging
 275   static jint    verify_oop_count()                        { return _verify_oop_count; }
 276   static jint*   verify_oop_count_addr()                   { return &_verify_oop_count; }
 277   // a subroutine for debugging the GC
 278   static address verify_oop_subroutine_entry_address()     { return (address)&_verify_oop_subroutine_entry; }
 279 
 280   static address catch_exception_entry()                   { return _catch_exception_entry; }
 281 
 282   // Calls to Java
 283   typedef void (*CallStub)(
 284     address   link,
 285     intptr_t* result,
 286     BasicType result_type,
 287     Method* method,
 288     address   entry_point,
 289     intptr_t* parameters,
 290     int       size_of_parameters,
 291     TRAPS
 292   );


 394   static address updateBytesAdler32()  { return _updateBytesAdler32; }
 395 
 396   static address multiplyToLen()       { return _multiplyToLen; }
 397   static address squareToLen()         { return _squareToLen; }
 398   static address mulAdd()              { return _mulAdd; }
 399   static address montgomeryMultiply()  { return _montgomeryMultiply; }
 400   static address montgomerySquare()    { return _montgomerySquare; }
 401 
 402   static address vectorizedMismatch()  { return _vectorizedMismatch; }
 403 
 404   static address dexp()                { return _dexp; }
 405   static address dlog()                { return _dlog; }
 406   static address dlog10()              { return _dlog10; }
 407   static address dpow()                { return _dpow; }
 408   static address dsin()                { return _dsin; }
 409   static address dcos()                { return _dcos; }
 410   static address dlibm_reduce_pi04l()  { return _dlibm_reduce_pi04l; }
 411   static address dlibm_sin_cos_huge()  { return _dlibm_sin_cos_huge; }
 412   static address dlibm_tan_cot_huge()  { return _dlibm_tan_cot_huge; }
 413   static address dtan()                { return _dtan; }














 414 
 415   static address select_fill_function(BasicType t, bool aligned, const char* &name);
 416 
 417   static address zero_aligned_words()  { return _zero_aligned_words; }
 418 
 419   //
 420   // Safefetch stub support
 421   //
 422 
 423   typedef int      (*SafeFetch32Stub)(int*      adr, int      errValue);
 424   typedef intptr_t (*SafeFetchNStub) (intptr_t* adr, intptr_t errValue);
 425 
 426   static SafeFetch32Stub SafeFetch32_stub() { return CAST_TO_FN_PTR(SafeFetch32Stub, _safefetch32_entry); }
 427   static SafeFetchNStub  SafeFetchN_stub()  { return CAST_TO_FN_PTR(SafeFetchNStub,  _safefetchN_entry); }
 428 
 429   static bool is_safefetch_fault(address pc) {
 430     return pc != NULL &&
 431           (pc == _safefetch32_fault_pc ||
 432            pc == _safefetchN_fault_pc);
 433   }




 144   static address _atomic_xchg_entry;
 145   static address _atomic_xchg_long_entry;
 146   static address _atomic_store_entry;
 147   static address _atomic_cmpxchg_entry;
 148   static address _atomic_cmpxchg_byte_entry;
 149   static address _atomic_cmpxchg_long_entry;
 150   static address _atomic_add_entry;
 151   static address _atomic_add_long_entry;
 152   static address _fence_entry;
 153   static address _d2i_wrapper;
 154   static address _d2l_wrapper;
 155 
 156   static jint    _fpu_cntrl_wrd_std;
 157   static jint    _fpu_cntrl_wrd_24;
 158   static jint    _fpu_cntrl_wrd_trunc;
 159   static jint    _mxcsr_std;
 160   static jint    _fpu_subnormal_bias1[3];
 161   static jint    _fpu_subnormal_bias2[3];
 162 
 163   static BufferBlob* _code1;                               // code buffer for initial routines
 164   static BufferBlob* _code2;
 165   static BufferBlob* _code3;                               // code buffer for all other routines
 166 
 167   // Leaf routines which implement arraycopy and their addresses
 168   // arraycopy operands aligned on element type boundary
 169   static address _jbyte_arraycopy;
 170   static address _jshort_arraycopy;
 171   static address _jint_arraycopy;
 172   static address _jlong_arraycopy;
 173   static address _oop_arraycopy, _oop_arraycopy_uninit;
 174   static address _jbyte_disjoint_arraycopy;
 175   static address _jshort_disjoint_arraycopy;
 176   static address _jint_disjoint_arraycopy;
 177   static address _jlong_disjoint_arraycopy;
 178   static address _oop_disjoint_arraycopy, _oop_disjoint_arraycopy_uninit;
 179 
 180   // arraycopy operands aligned on zero'th element boundary
 181   // These are identical to the ones aligned aligned on an
 182   // element type boundary, except that they assume that both
 183   // source and destination are HeapWord aligned.
 184   static address _arrayof_jbyte_arraycopy;
 185   static address _arrayof_jshort_arraycopy;


 231 
 232   static address _multiplyToLen;
 233   static address _squareToLen;
 234   static address _mulAdd;
 235   static address _montgomeryMultiply;
 236   static address _montgomerySquare;
 237 
 238   static address _vectorizedMismatch;
 239 
 240   static address _dexp;
 241   static address _dlog;
 242   static address _dlog10;
 243   static address _dpow;
 244   static address _dsin;
 245   static address _dcos;
 246   static address _dlibm_sin_cos_huge;
 247   static address _dlibm_reduce_pi04l;
 248   static address _dlibm_tan_cot_huge;
 249   static address _dtan;
 250 
 251   static RuntimeStub* _cont_doYield_stub;
 252   static address _cont_doYield;
 253   static address _cont_jump_from_sp;
 254   static address _cont_jump;
 255   static address _cont_thaw;
 256   static address _cont_returnBarrier;
 257   static address _cont_returnBarrierExc;  
 258   static address _cont_getSP;
 259   static address _cont_getPC;
 260 
 261   // Safefetch stubs.
 262   static address _safefetch32_entry;
 263   static address _safefetch32_fault_pc;
 264   static address _safefetch32_continuation_pc;
 265   static address _safefetchN_entry;
 266   static address _safefetchN_fault_pc;
 267   static address _safefetchN_continuation_pc;
 268 
 269  public:
 270   // Initialization/Testing
 271   static void    initialize1();                            // must happen before universe::genesis
 272   static void    initialize2();                            // must happen after  universe::genesis
 273   static void    initializeContinuationStubs();            // must happen after  universe::genesis
 274 
 275   static bool is_stub_code(address addr)                   { return contains(addr); }
 276 
 277   static bool contains(address addr) {
 278     return
 279       (_code1 != NULL && _code1->blob_contains(addr)) ||
 280       (_code2 != NULL && _code2->blob_contains(addr)) ;
 281   }
 282 
 283   static RuntimeBlob* code1() { return _code1; }
 284   static RuntimeBlob* code2() { return _code2; }
 285   static RuntimeBlob* code3() { return _code3; }
 286 
 287   // Debugging
 288   static jint    verify_oop_count()                        { return _verify_oop_count; }
 289   static jint*   verify_oop_count_addr()                   { return &_verify_oop_count; }
 290   // a subroutine for debugging the GC
 291   static address verify_oop_subroutine_entry_address()     { return (address)&_verify_oop_subroutine_entry; }
 292 
 293   static address catch_exception_entry()                   { return _catch_exception_entry; }
 294 
 295   // Calls to Java
 296   typedef void (*CallStub)(
 297     address   link,
 298     intptr_t* result,
 299     BasicType result_type,
 300     Method* method,
 301     address   entry_point,
 302     intptr_t* parameters,
 303     int       size_of_parameters,
 304     TRAPS
 305   );


 407   static address updateBytesAdler32()  { return _updateBytesAdler32; }
 408 
 409   static address multiplyToLen()       { return _multiplyToLen; }
 410   static address squareToLen()         { return _squareToLen; }
 411   static address mulAdd()              { return _mulAdd; }
 412   static address montgomeryMultiply()  { return _montgomeryMultiply; }
 413   static address montgomerySquare()    { return _montgomerySquare; }
 414 
 415   static address vectorizedMismatch()  { return _vectorizedMismatch; }
 416 
 417   static address dexp()                { return _dexp; }
 418   static address dlog()                { return _dlog; }
 419   static address dlog10()              { return _dlog10; }
 420   static address dpow()                { return _dpow; }
 421   static address dsin()                { return _dsin; }
 422   static address dcos()                { return _dcos; }
 423   static address dlibm_reduce_pi04l()  { return _dlibm_reduce_pi04l; }
 424   static address dlibm_sin_cos_huge()  { return _dlibm_sin_cos_huge; }
 425   static address dlibm_tan_cot_huge()  { return _dlibm_tan_cot_huge; }
 426   static address dtan()                { return _dtan; }
 427 
 428   typedef void (*cont_jump_from_sp_t)();
 429 
 430   static RuntimeStub* cont_doYield_stub() { return _cont_doYield_stub; }
 431   static address cont_doYield()        { return _cont_doYield; }
 432   static address cont_jump_from_sp()   { return _cont_jump_from_sp; }
 433   static address cont_jump()           { return _cont_jump; }
 434   static address cont_thaw()           { return _cont_thaw; }
 435   static address cont_returnBarrier()  { return _cont_returnBarrier; }
 436   static address cont_returnBarrierExc(){return _cont_returnBarrierExc; }
 437   static address cont_getSP()          { return _cont_getSP; }
 438   static address cont_getPC()          { return _cont_getPC; }
 439   static cont_jump_from_sp_t  cont_jump_from_sp_C() { return CAST_TO_FN_PTR(cont_jump_from_sp_t, _cont_jump_from_sp); }
 440 
 441 
 442   static address select_fill_function(BasicType t, bool aligned, const char* &name);
 443 
 444   static address zero_aligned_words()  { return _zero_aligned_words; }
 445 
 446   //
 447   // Safefetch stub support
 448   //
 449 
 450   typedef int      (*SafeFetch32Stub)(int*      adr, int      errValue);
 451   typedef intptr_t (*SafeFetchNStub) (intptr_t* adr, intptr_t errValue);
 452 
 453   static SafeFetch32Stub SafeFetch32_stub() { return CAST_TO_FN_PTR(SafeFetch32Stub, _safefetch32_entry); }
 454   static SafeFetchNStub  SafeFetchN_stub()  { return CAST_TO_FN_PTR(SafeFetchNStub,  _safefetchN_entry); }
 455 
 456   static bool is_safefetch_fault(address pc) {
 457     return pc != NULL &&
 458           (pc == _safefetch32_fault_pc ||
 459            pc == _safefetchN_fault_pc);
 460   }


< prev index next >