437 jvmtiError

   438 JvmtiExport::add_module_reads(Handle module, Handle to_module, TRAPS) {

   439   if (!Universe::is_module_initialized()) {

   440     return JVMTI_ERROR_NONE; // extra safety

   441   }

   442   assert(!module.is_null(), "module should always be set");

   443   assert(!to_module.is_null(), "to_module should always be set");

   444 

   445   // Invoke the addReads method

   446   JavaValue result(T_VOID);

   447   JavaCalls::call_static(&result,

   448                          SystemDictionary::module_Modules_klass(),

   449                          vmSymbols::addReads_name(),

   450                          vmSymbols::addReads_signature(),

   451                          module,

   452                          to_module,

   453                          THREAD);

   454 

   455   if (HAS_PENDING_EXCEPTION) {

   456     LogTarget(Trace, jvmti) log;

   457     LogStreamCHeap log_stream(log);

   458     java_lang_Throwable::print(PENDING_EXCEPTION, &log_stream);

   459     log_stream.cr();

   460     CLEAR_PENDING_EXCEPTION;

   461     return JVMTI_ERROR_INTERNAL;

   462   }

   463   return JVMTI_ERROR_NONE;

   464 }

   465 

   466 jvmtiError

   467 JvmtiExport::add_module_exports(Handle module, Handle pkg_name, Handle to_module, TRAPS) {

   468   if (!Universe::is_module_initialized()) {

   469     return JVMTI_ERROR_NONE; // extra safety

   470   }

   471   assert(!module.is_null(), "module should always be set");

   472   assert(!to_module.is_null(), "to_module should always be set");

   473   assert(!pkg_name.is_null(), "pkg_name should always be set");

   474 

   475   // Invoke the addExports method

   476   JavaValue result(T_VOID);

   477   JavaCalls::call_static(&result,

   478                          SystemDictionary::module_Modules_klass(),

   479                          vmSymbols::addExports_name(),

   480                          vmSymbols::addExports_signature(),

   481                          module,

   482                          pkg_name,

   483                          to_module,

   484                          THREAD);

   485 

   486   if (HAS_PENDING_EXCEPTION) {

   487     Symbol* ex_name = PENDING_EXCEPTION->klass()->name();

   488     LogTarget(Trace, jvmti) log;

   489     LogStreamCHeap log_stream(log);

   490     java_lang_Throwable::print(PENDING_EXCEPTION, &log_stream);

   491     log_stream.cr();

   492     CLEAR_PENDING_EXCEPTION;

   493     if (ex_name == vmSymbols::java_lang_IllegalArgumentException()) {

   494       return JVMTI_ERROR_ILLEGAL_ARGUMENT;

   495     }

   496     return JVMTI_ERROR_INTERNAL;

   497   }

   498   return JVMTI_ERROR_NONE;

   499 }

   500 

   501 jvmtiError

   502 JvmtiExport::add_module_opens(Handle module, Handle pkg_name, Handle to_module, TRAPS) {

   503   if (!Universe::is_module_initialized()) {

   504     return JVMTI_ERROR_NONE; // extra safety

   505   }

   506   assert(!module.is_null(), "module should always be set");

   507   assert(!to_module.is_null(), "to_module should always be set");

   508   assert(!pkg_name.is_null(), "pkg_name should always be set");

   509 

   510   // Invoke the addOpens method

   511   JavaValue result(T_VOID);

   512   JavaCalls::call_static(&result,

   513                          SystemDictionary::module_Modules_klass(),

   514                          vmSymbols::addOpens_name(),

   515                          vmSymbols::addExports_signature(),

   516                          module,

   517                          pkg_name,

   518                          to_module,

   519                          THREAD);

   520 

   521   if (HAS_PENDING_EXCEPTION) {

   522     Symbol* ex_name = PENDING_EXCEPTION->klass()->name();

   523     LogTarget(Trace, jvmti) log;

   524     LogStreamCHeap log_stream(log);

   525     java_lang_Throwable::print(PENDING_EXCEPTION, &log_stream);

   526     log_stream.cr();

   527     CLEAR_PENDING_EXCEPTION;

   528     if (ex_name == vmSymbols::java_lang_IllegalArgumentException()) {

   529       return JVMTI_ERROR_ILLEGAL_ARGUMENT;

   530     }

   531     return JVMTI_ERROR_INTERNAL;

   532   }

   533   return JVMTI_ERROR_NONE;

   534 }

   535 

   536 jvmtiError

   537 JvmtiExport::add_module_uses(Handle module, Handle service, TRAPS) {

   538   if (!Universe::is_module_initialized()) {

   539     return JVMTI_ERROR_NONE; // extra safety

   540   }

   541   assert(!module.is_null(), "module should always be set");

   542   assert(!service.is_null(), "service should always be set");

   543 

   544   // Invoke the addUses method

   545   JavaValue result(T_VOID);

   546   JavaCalls::call_static(&result,

   547                          SystemDictionary::module_Modules_klass(),

   548                          vmSymbols::addUses_name(),

   549                          vmSymbols::addUses_signature(),

   550                          module,

   551                          service,

   552                          THREAD);

   553 

   554   if (HAS_PENDING_EXCEPTION) {

   555     LogTarget(Trace, jvmti) log;

   556     LogStreamCHeap log_stream(log);

   557     java_lang_Throwable::print(PENDING_EXCEPTION, &log_stream);

   558     log_stream.cr();

   559     CLEAR_PENDING_EXCEPTION;

   560     return JVMTI_ERROR_INTERNAL;

   561   }

   562   return JVMTI_ERROR_NONE;

   563 }

   564 

   565 jvmtiError

   566 JvmtiExport::add_module_provides(Handle module, Handle service, Handle impl_class, TRAPS) {

   567   if (!Universe::is_module_initialized()) {

   568     return JVMTI_ERROR_NONE; // extra safety

   569   }

   570   assert(!module.is_null(), "module should always be set");

   571   assert(!service.is_null(), "service should always be set");

   572   assert(!impl_class.is_null(), "impl_class should always be set");

   573 

   574   // Invoke the addProvides method

   575   JavaValue result(T_VOID);

   576   JavaCalls::call_static(&result,

   577                          SystemDictionary::module_Modules_klass(),

   578                          vmSymbols::addProvides_name(),

   579                          vmSymbols::addProvides_signature(),

   580                          module,

   581                          service,

   582                          impl_class,

   583                          THREAD);

   584 

   585   if (HAS_PENDING_EXCEPTION) {

   586     LogTarget(Trace, jvmti) log;

   587     LogStreamCHeap log_stream(log);

   588     java_lang_Throwable::print(PENDING_EXCEPTION, &log_stream);

   589     log_stream.cr();

   590     CLEAR_PENDING_EXCEPTION;

   591     return JVMTI_ERROR_INTERNAL;

   592   }

   593   return JVMTI_ERROR_NONE;

   594 }

   595