src/share/vm/opto/runtime.cpp

Print this page




  79 //  MarkSweep::invoke(0, "Debugging");
  80 //
  81 // At command line specify the parameters: -XX:+FullGCALot -XX:FullGCALotStart=100000000
  82 
  83 
  84 
  85 
  86 // Compiled code entry points
  87 address OptoRuntime::_new_instance_Java                           = NULL;
  88 address OptoRuntime::_new_array_Java                              = NULL;
  89 address OptoRuntime::_new_array_nozero_Java                       = NULL;
  90 address OptoRuntime::_multianewarray2_Java                        = NULL;
  91 address OptoRuntime::_multianewarray3_Java                        = NULL;
  92 address OptoRuntime::_multianewarray4_Java                        = NULL;
  93 address OptoRuntime::_multianewarray5_Java                        = NULL;
  94 address OptoRuntime::_multianewarrayN_Java                        = NULL;
  95 address OptoRuntime::_g1_wb_pre_Java                              = NULL;
  96 address OptoRuntime::_g1_wb_post_Java                             = NULL;
  97 address OptoRuntime::_vtable_must_compile_Java                    = NULL;
  98 address OptoRuntime::_complete_monitor_locking_Java               = NULL;


  99 address OptoRuntime::_rethrow_Java                                = NULL;
 100 
 101 address OptoRuntime::_slow_arraycopy_Java                         = NULL;
 102 address OptoRuntime::_register_finalizer_Java                     = NULL;
 103 
 104 # ifdef ENABLE_ZAP_DEAD_LOCALS
 105 address OptoRuntime::_zap_dead_Java_locals_Java                   = NULL;
 106 address OptoRuntime::_zap_dead_native_locals_Java                 = NULL;
 107 # endif
 108 
 109 ExceptionBlob* OptoRuntime::_exception_blob;
 110 
 111 // This should be called in an assertion at the start of OptoRuntime routines
 112 // which are entered from compiled code (all of them)
 113 #ifdef ASSERT
 114 static bool check_compiled_frame(JavaThread* thread) {
 115   assert(thread->last_frame().is_runtime_frame(), "cannot call runtime directly from compiled code");
 116   RegisterMap map(thread, false);
 117   frame caller = thread->last_frame().sender(&map);
 118   assert(caller.is_compiled_frame(), "not being called from compiled like code");


 127 
 128 bool OptoRuntime::generate(ciEnv* env) {
 129 
 130   generate_exception_blob();
 131 
 132   // Note: tls: Means fetching the return oop out of the thread-local storage
 133   //
 134   //   variable/name                       type-function-gen              , runtime method                  ,fncy_jp, tls,save_args,retpc
 135   // -------------------------------------------------------------------------------------------------------------------------------
 136   gen(env, _new_instance_Java              , new_instance_Type            , new_instance_C                  ,    0 , true , false, false);
 137   gen(env, _new_array_Java                 , new_array_Type               , new_array_C                     ,    0 , true , false, false);
 138   gen(env, _new_array_nozero_Java          , new_array_Type               , new_array_nozero_C              ,    0 , true , false, false);
 139   gen(env, _multianewarray2_Java           , multianewarray2_Type         , multianewarray2_C               ,    0 , true , false, false);
 140   gen(env, _multianewarray3_Java           , multianewarray3_Type         , multianewarray3_C               ,    0 , true , false, false);
 141   gen(env, _multianewarray4_Java           , multianewarray4_Type         , multianewarray4_C               ,    0 , true , false, false);
 142   gen(env, _multianewarray5_Java           , multianewarray5_Type         , multianewarray5_C               ,    0 , true , false, false);
 143   gen(env, _multianewarrayN_Java           , multianewarrayN_Type         , multianewarrayN_C               ,    0 , true , false, false);
 144   gen(env, _g1_wb_pre_Java                 , g1_wb_pre_Type               , SharedRuntime::g1_wb_pre        ,    0 , false, false, false);
 145   gen(env, _g1_wb_post_Java                , g1_wb_post_Type              , SharedRuntime::g1_wb_post       ,    0 , false, false, false);
 146   gen(env, _complete_monitor_locking_Java  , complete_monitor_enter_Type  , SharedRuntime::complete_monitor_locking_C, 0, false, false, false);


 147   gen(env, _rethrow_Java                   , rethrow_Type                 , rethrow_C                       ,    2 , true , false, true );
 148 
 149   gen(env, _slow_arraycopy_Java            , slow_arraycopy_Type          , SharedRuntime::slow_arraycopy_C ,    0 , false, false, false);
 150   gen(env, _register_finalizer_Java        , register_finalizer_Type      , register_finalizer              ,    0 , false, false, false);
 151 
 152 # ifdef ENABLE_ZAP_DEAD_LOCALS
 153   gen(env, _zap_dead_Java_locals_Java      , zap_dead_locals_Type         , zap_dead_Java_locals_C          ,    0 , false, true , false );
 154   gen(env, _zap_dead_native_locals_Java    , zap_dead_locals_Type         , zap_dead_native_locals_C        ,    0 , false, true , false );
 155 # endif
 156   return true;
 157 }
 158 
 159 #undef gen
 160 
 161 
 162 // Helper method to do generation of RunTimeStub's
 163 address OptoRuntime::generate_stub( ciEnv* env,
 164                                     TypeFunc_generator gen, address C_function,
 165                                     const char *name, int is_fancy_jump,
 166                                     bool pass_tls,


 409   thread->set_vm_result(obj);
 410 JRT_END
 411 
 412 JRT_ENTRY(void, OptoRuntime::multianewarrayN_C(Klass* elem_type, arrayOopDesc* dims, JavaThread *thread))
 413   assert(check_compiled_frame(thread), "incorrect caller");
 414   assert(elem_type->is_klass(), "not a class");
 415   assert(oop(dims)->is_typeArray(), "not an array");
 416 
 417   ResourceMark rm;
 418   jint len = dims->length();
 419   assert(len > 0, "Dimensions array should contain data");
 420   jint *j_dims = typeArrayOop(dims)->int_at_addr(0);
 421   jint *c_dims = NEW_RESOURCE_ARRAY(jint, len);
 422   Copy::conjoint_jints_atomic(j_dims, c_dims, len);
 423 
 424   oop obj = ArrayKlass::cast(elem_type)->multi_allocate(len, c_dims, THREAD);
 425   deoptimize_caller_frame(thread, HAS_PENDING_EXCEPTION);
 426   thread->set_vm_result(obj);
 427 JRT_END
 428 



 429 








































 430 const TypeFunc *OptoRuntime::new_instance_Type() {
 431   // create input type (domain)
 432   const Type **fields = TypeTuple::fields(1);
 433   fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // Klass to be allocated
 434   const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+1, fields);
 435 
 436   // create result type (range)
 437   fields = TypeTuple::fields(1);
 438   fields[TypeFunc::Parms+0] = TypeRawPtr::NOTNULL; // Returned oop
 439 
 440   const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1, fields);
 441 
 442   return TypeFunc::make(domain, range);
 443 }
 444 
 445 
 446 const TypeFunc *OptoRuntime::athrow_Type() {
 447   // create input type (domain)
 448   const Type **fields = TypeTuple::fields(1);
 449   fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // Klass to be allocated


 587   fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL;  // Object to be Locked
 588   fields[TypeFunc::Parms+1] = TypeRawPtr::BOTTOM;   // Address of stack location for lock
 589   const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2,fields);
 590 
 591   // create result type (range)
 592   fields = TypeTuple::fields(0);
 593 
 594   const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0,fields);
 595 
 596   return TypeFunc::make(domain,range);
 597 }
 598 
 599 
 600 //-----------------------------------------------------------------------------
 601 const TypeFunc *OptoRuntime::complete_monitor_exit_Type() {
 602   // create input type (domain)
 603   const Type **fields = TypeTuple::fields(3);
 604   fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL;  // Object to be Locked
 605   fields[TypeFunc::Parms+1] = TypeRawPtr::BOTTOM;    // Address of stack location for lock - BasicLock
 606   fields[TypeFunc::Parms+2] = TypeRawPtr::BOTTOM;    // Thread pointer (Self)
 607   const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+3,fields);
 608 
 609   // create result type (range)
 610   fields = TypeTuple::fields(0);
 611 
 612   const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0,fields);
 613 
 614   return TypeFunc::make(domain,range);
 615 }
 616 












 617 const TypeFunc* OptoRuntime::flush_windows_Type() {
 618   // create input type (domain)
 619   const Type** fields = TypeTuple::fields(1);
 620   fields[TypeFunc::Parms+0] = NULL; // void
 621   const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms, fields);
 622 
 623   // create result type
 624   fields = TypeTuple::fields(1);
 625   fields[TypeFunc::Parms+0] = NULL; // void
 626   const TypeTuple *range = TypeTuple::make(TypeFunc::Parms, fields);
 627 
 628   return TypeFunc::make(domain, range);
 629 }
 630 
 631 const TypeFunc* OptoRuntime::l2f_Type() {
 632   // create input type (domain)
 633   const Type **fields = TypeTuple::fields(2);
 634   fields[TypeFunc::Parms+0] = TypeLong::LONG;
 635   fields[TypeFunc::Parms+1] = Type::HALF;
 636   const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2, fields);




  79 //  MarkSweep::invoke(0, "Debugging");
  80 //
  81 // At command line specify the parameters: -XX:+FullGCALot -XX:FullGCALotStart=100000000
  82 
  83 
  84 
  85 
  86 // Compiled code entry points
  87 address OptoRuntime::_new_instance_Java                           = NULL;
  88 address OptoRuntime::_new_array_Java                              = NULL;
  89 address OptoRuntime::_new_array_nozero_Java                       = NULL;
  90 address OptoRuntime::_multianewarray2_Java                        = NULL;
  91 address OptoRuntime::_multianewarray3_Java                        = NULL;
  92 address OptoRuntime::_multianewarray4_Java                        = NULL;
  93 address OptoRuntime::_multianewarray5_Java                        = NULL;
  94 address OptoRuntime::_multianewarrayN_Java                        = NULL;
  95 address OptoRuntime::_g1_wb_pre_Java                              = NULL;
  96 address OptoRuntime::_g1_wb_post_Java                             = NULL;
  97 address OptoRuntime::_vtable_must_compile_Java                    = NULL;
  98 address OptoRuntime::_complete_monitor_locking_Java               = NULL;
  99 address OptoRuntime::_monitor_notify_Java                         = NULL;
 100 address OptoRuntime::_monitor_notifyAll_Java                      = NULL;
 101 address OptoRuntime::_rethrow_Java                                = NULL;
 102 
 103 address OptoRuntime::_slow_arraycopy_Java                         = NULL;
 104 address OptoRuntime::_register_finalizer_Java                     = NULL;
 105 
 106 # ifdef ENABLE_ZAP_DEAD_LOCALS
 107 address OptoRuntime::_zap_dead_Java_locals_Java                   = NULL;
 108 address OptoRuntime::_zap_dead_native_locals_Java                 = NULL;
 109 # endif
 110 
 111 ExceptionBlob* OptoRuntime::_exception_blob;
 112 
 113 // This should be called in an assertion at the start of OptoRuntime routines
 114 // which are entered from compiled code (all of them)
 115 #ifdef ASSERT
 116 static bool check_compiled_frame(JavaThread* thread) {
 117   assert(thread->last_frame().is_runtime_frame(), "cannot call runtime directly from compiled code");
 118   RegisterMap map(thread, false);
 119   frame caller = thread->last_frame().sender(&map);
 120   assert(caller.is_compiled_frame(), "not being called from compiled like code");


 129 
 130 bool OptoRuntime::generate(ciEnv* env) {
 131 
 132   generate_exception_blob();
 133 
 134   // Note: tls: Means fetching the return oop out of the thread-local storage
 135   //
 136   //   variable/name                       type-function-gen              , runtime method                  ,fncy_jp, tls,save_args,retpc
 137   // -------------------------------------------------------------------------------------------------------------------------------
 138   gen(env, _new_instance_Java              , new_instance_Type            , new_instance_C                  ,    0 , true , false, false);
 139   gen(env, _new_array_Java                 , new_array_Type               , new_array_C                     ,    0 , true , false, false);
 140   gen(env, _new_array_nozero_Java          , new_array_Type               , new_array_nozero_C              ,    0 , true , false, false);
 141   gen(env, _multianewarray2_Java           , multianewarray2_Type         , multianewarray2_C               ,    0 , true , false, false);
 142   gen(env, _multianewarray3_Java           , multianewarray3_Type         , multianewarray3_C               ,    0 , true , false, false);
 143   gen(env, _multianewarray4_Java           , multianewarray4_Type         , multianewarray4_C               ,    0 , true , false, false);
 144   gen(env, _multianewarray5_Java           , multianewarray5_Type         , multianewarray5_C               ,    0 , true , false, false);
 145   gen(env, _multianewarrayN_Java           , multianewarrayN_Type         , multianewarrayN_C               ,    0 , true , false, false);
 146   gen(env, _g1_wb_pre_Java                 , g1_wb_pre_Type               , SharedRuntime::g1_wb_pre        ,    0 , false, false, false);
 147   gen(env, _g1_wb_post_Java                , g1_wb_post_Type              , SharedRuntime::g1_wb_post       ,    0 , false, false, false);
 148   gen(env, _complete_monitor_locking_Java  , complete_monitor_enter_Type  , SharedRuntime::complete_monitor_locking_C, 0, false, false, false);
 149   gen(env, _monitor_notify_Java            , monitor_notify_Type          , monitor_notify_C                ,    0 , false, false, false);
 150   gen(env, _monitor_notifyAll_Java         , monitor_notify_Type          , monitor_notifyAll_C             ,    0 , false, false, false);
 151   gen(env, _rethrow_Java                   , rethrow_Type                 , rethrow_C                       ,    2 , true , false, true );
 152 
 153   gen(env, _slow_arraycopy_Java            , slow_arraycopy_Type          , SharedRuntime::slow_arraycopy_C ,    0 , false, false, false);
 154   gen(env, _register_finalizer_Java        , register_finalizer_Type      , register_finalizer              ,    0 , false, false, false);
 155 
 156 # ifdef ENABLE_ZAP_DEAD_LOCALS
 157   gen(env, _zap_dead_Java_locals_Java      , zap_dead_locals_Type         , zap_dead_Java_locals_C          ,    0 , false, true , false );
 158   gen(env, _zap_dead_native_locals_Java    , zap_dead_locals_Type         , zap_dead_native_locals_C        ,    0 , false, true , false );
 159 # endif
 160   return true;
 161 }
 162 
 163 #undef gen
 164 
 165 
 166 // Helper method to do generation of RunTimeStub's
 167 address OptoRuntime::generate_stub( ciEnv* env,
 168                                     TypeFunc_generator gen, address C_function,
 169                                     const char *name, int is_fancy_jump,
 170                                     bool pass_tls,


 413   thread->set_vm_result(obj);
 414 JRT_END
 415 
 416 JRT_ENTRY(void, OptoRuntime::multianewarrayN_C(Klass* elem_type, arrayOopDesc* dims, JavaThread *thread))
 417   assert(check_compiled_frame(thread), "incorrect caller");
 418   assert(elem_type->is_klass(), "not a class");
 419   assert(oop(dims)->is_typeArray(), "not an array");
 420 
 421   ResourceMark rm;
 422   jint len = dims->length();
 423   assert(len > 0, "Dimensions array should contain data");
 424   jint *j_dims = typeArrayOop(dims)->int_at_addr(0);
 425   jint *c_dims = NEW_RESOURCE_ARRAY(jint, len);
 426   Copy::conjoint_jints_atomic(j_dims, c_dims, len);
 427 
 428   oop obj = ArrayKlass::cast(elem_type)->multi_allocate(len, c_dims, THREAD);
 429   deoptimize_caller_frame(thread, HAS_PENDING_EXCEPTION);
 430   thread->set_vm_result(obj);
 431 JRT_END
 432 
 433 // Note that hashCode() deserves the same treatment as notify/notifyAll.
 434 // The situation is slightly more complicated since hashCode() is virtual,
 435 // requiring guards, whereas notify/notifyAll are final
 436 
 437 JRT_BLOCK_ENTRY(void, OptoRuntime::monitor_notify_C(oopDesc* obj, JavaThread *thread))
 438 
 439   // Very few notify/notifyAll operations find any threads on the waitset, so
 440   // the dominant fast-path is to simply return.
 441   // Relatedly, it's critical that notify/notifyAll be fast in order to
 442   // reduce lock hold times.
 443   if (!SafepointSynchronize::is_synchronizing()) {
 444     if (ObjectSynchronizer::quick_notify(obj, thread, false)) {
 445       return;
 446     }
 447   }
 448 
 449   // This is the case the fast-path above isn't provisioned to handle.
 450   // The fast-path is designed to handle frequently arising cases in an efficient manner.
 451   // (The fast-path is just a degenerate variant of the slow-path).
 452   // Perform the dreaded state transition and pass control into the slow-path.
 453   JRT_BLOCK;
 454   Handle h_obj(THREAD, obj);
 455   ObjectSynchronizer::notify(h_obj, CHECK);
 456   JRT_BLOCK_END;
 457 JRT_END
 458 
 459 JRT_BLOCK_ENTRY(void, OptoRuntime::monitor_notifyAll_C(oopDesc* obj, JavaThread *thread))
 460 
 461   if (!SafepointSynchronize::is_synchronizing() ) {
 462     if (ObjectSynchronizer::quick_notify(obj, thread, true)) {
 463       return;
 464     }
 465   }
 466 
 467   // This is the case the fast-path above isn't provisioned to handle.
 468   // The fast-path is designed to handle frequently arising cases in an efficient manner.
 469   // (The fast-path is just a degenerate variant of the slow-path).
 470   // Perform the dreaded state transition and pass control into the slow-path.
 471   JRT_BLOCK;
 472   Handle h_obj(THREAD, obj);
 473   ObjectSynchronizer::notifyall(h_obj, CHECK);
 474   JRT_BLOCK_END;
 475 JRT_END
 476 
 477 const TypeFunc *OptoRuntime::new_instance_Type() {
 478   // create input type (domain)
 479   const Type **fields = TypeTuple::fields(1);
 480   fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // Klass to be allocated
 481   const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+1, fields);
 482 
 483   // create result type (range)
 484   fields = TypeTuple::fields(1);
 485   fields[TypeFunc::Parms+0] = TypeRawPtr::NOTNULL; // Returned oop
 486 
 487   const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1, fields);
 488 
 489   return TypeFunc::make(domain, range);
 490 }
 491 
 492 
 493 const TypeFunc *OptoRuntime::athrow_Type() {
 494   // create input type (domain)
 495   const Type **fields = TypeTuple::fields(1);
 496   fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // Klass to be allocated


 634   fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL;  // Object to be Locked
 635   fields[TypeFunc::Parms+1] = TypeRawPtr::BOTTOM;   // Address of stack location for lock
 636   const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2,fields);
 637 
 638   // create result type (range)
 639   fields = TypeTuple::fields(0);
 640 
 641   const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0,fields);
 642 
 643   return TypeFunc::make(domain,range);
 644 }
 645 
 646 
 647 //-----------------------------------------------------------------------------
 648 const TypeFunc *OptoRuntime::complete_monitor_exit_Type() {
 649   // create input type (domain)
 650   const Type **fields = TypeTuple::fields(3);
 651   fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL;  // Object to be Locked
 652   fields[TypeFunc::Parms+1] = TypeRawPtr::BOTTOM;    // Address of stack location for lock - BasicLock
 653   fields[TypeFunc::Parms+2] = TypeRawPtr::BOTTOM;    // Thread pointer (Self)
 654   const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+3, fields);
 655 
 656   // create result type (range)
 657   fields = TypeTuple::fields(0);
 658 
 659   const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0, fields);
 660 
 661   return TypeFunc::make(domain, range);
 662 }
 663 
 664 const TypeFunc *OptoRuntime::monitor_notify_Type() {
 665   // create input type (domain)
 666   const Type **fields = TypeTuple::fields(1);
 667   fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL;  // Object to be Locked
 668   const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+1, fields);
 669 
 670   // create result type (range)
 671   fields = TypeTuple::fields(0);
 672   const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0, fields);
 673   return TypeFunc::make(domain, range);
 674 }
 675 
 676 const TypeFunc* OptoRuntime::flush_windows_Type() {
 677   // create input type (domain)
 678   const Type** fields = TypeTuple::fields(1);
 679   fields[TypeFunc::Parms+0] = NULL; // void
 680   const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms, fields);
 681 
 682   // create result type
 683   fields = TypeTuple::fields(1);
 684   fields[TypeFunc::Parms+0] = NULL; // void
 685   const TypeTuple *range = TypeTuple::make(TypeFunc::Parms, fields);
 686 
 687   return TypeFunc::make(domain, range);
 688 }
 689 
 690 const TypeFunc* OptoRuntime::l2f_Type() {
 691   // create input type (domain)
 692   const Type **fields = TypeTuple::fields(2);
 693   fields[TypeFunc::Parms+0] = TypeLong::LONG;
 694   fields[TypeFunc::Parms+1] = Type::HALF;
 695   const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2, fields);