src/hotspot/share/jvmci/jvmciRuntime.hpp

*** 23,48 ****
  
  #ifndef SHARE_JVMCI_JVMCIRUNTIME_HPP
  #define SHARE_JVMCI_JVMCIRUNTIME_HPP
  
  #include "interpreter/interpreter.hpp"
  #include "memory/allocation.hpp"
  #include "runtime/arguments.hpp"
  #include "runtime/deoptimization.hpp"
  
! #define JVMCI_ERROR(...)       \
!   { Exceptions::fthrow(THREAD_AND_LOCATION, vmSymbols::jdk_vm_ci_common_JVMCIError(), __VA_ARGS__); return; }
  
! #define JVMCI_ERROR_(ret, ...) \
!   { Exceptions::fthrow(THREAD_AND_LOCATION, vmSymbols::jdk_vm_ci_common_JVMCIError(), __VA_ARGS__); return ret; }
  
! #define JVMCI_ERROR_0(...)    JVMCI_ERROR_(0, __VA_ARGS__)
! #define JVMCI_ERROR_NULL(...) JVMCI_ERROR_(NULL, __VA_ARGS__)
! #define JVMCI_ERROR_OK(...)   JVMCI_ERROR_(JVMCIEnv::ok, __VA_ARGS__)
! #define CHECK_OK              CHECK_(JVMCIEnv::ok)
  
! class JVMCIRuntime: public AllStatic {
   public:
    // Constants describing whether JVMCI wants to be able to adjust the compilation
    // level selected for a method by the VM compilation policy and if so, based on
    // what information about the method being schedule for compilation.
    enum CompLevelAdjustment {
--- 23,94 ----
  
  #ifndef SHARE_JVMCI_JVMCIRUNTIME_HPP
  #define SHARE_JVMCI_JVMCIRUNTIME_HPP
  
  #include "interpreter/interpreter.hpp"
+ #include "jvmci/jvmci.hpp"
  #include "memory/allocation.hpp"
  #include "runtime/arguments.hpp"
  #include "runtime/deoptimization.hpp"
  
! class JVMCIObject;
! class JVMCIEnv;
! class JVMCICompileState;
! 
! // Encapsulates the JVMCI metadata for an nmethod.
! // JVMCINMethodData objects are inlined into nmethods
! // at nmethod::_jvmci_data_offset.
! class JVMCINMethodData {
!   // Index for the HotSpotNmethod mirror in the nmethod's oops table.
!   // This is -1 if there is no mirror in the oops table.
!   int _nmethod_mirror_index;
! 
!   // Is HotSpotNmethod.name non-null? If so, the value is
!   // embedded in the end of this object.
!   bool _has_name;
! 
!   // Address of the failed speculations list to which a speculation
!   // is appended when it causes a deoptimization.
!   FailedSpeculation** _failed_speculations;
! 
! public:
!   // Computes the size of a JVMCINMethodData object
!   static int compute_size(const char* nmethod_mirror_name) {
!     int size = sizeof(JVMCINMethodData);
!     if (nmethod_mirror_name != NULL) {
!       size += (int) strlen(nmethod_mirror_name) + 1;
!     }
!     return size;
!   }
! 
!   void initialize(int nmethod_mirror_index,
!              const char* name,
!              FailedSpeculation** failed_speculations);
! 
!   // Adds `speculation` to the failed speculations list.
!   void add_failed_speculation(nmethod* nm, jlong speculation);
! 
!   // Gets the JVMCI name of the nmethod (which may be NULL).
!   const char* name() { return _has_name ? (char*)(((address) this) + sizeof(JVMCINMethodData)) : NULL; }
  
!   // Clears the HotSpotNmethod.address field in the  mirror. If nm
!   // is dead, the HotSpotNmethod.entryPoint field is also cleared.
!   void invalidate_nmethod_mirror(nmethod* nm);
  
!   // Gets the mirror from nm's oops table.
!   oop get_nmethod_mirror(nmethod* nm);
  
!   // Sets the mirror in nm's oops table.
!   void set_nmethod_mirror(nmethod* nm, oop mirror);
! 
!   // Clears the mirror in nm's oops table.
!   void clear_nmethod_mirror(nmethod* nm);
! };
! 
! // A top level class that represents an initialized JVMCI runtime.
! // There is one instance of this class per HotSpotJVMCIRuntime object.
! class JVMCIRuntime: public CHeapObj<mtCompiler> {
   public:
    // Constants describing whether JVMCI wants to be able to adjust the compilation
    // level selected for a method by the VM compilation policy and if so, based on
    // what information about the method being schedule for compilation.
    enum CompLevelAdjustment {
*** 50,113 ****
       by_holder = 1,        // adjust based on declaring class of method
       by_full_signature = 2 // adjust based on declaring class, name and signature of method
    };
  
   private:
!   static jobject _HotSpotJVMCIRuntime_instance;
!   static bool _HotSpotJVMCIRuntime_initialized;
!   static bool _well_known_classes_initialized;
  
!   static CompLevelAdjustment _comp_level_adjustment;
  
!   static bool _shutdown_called;
  
!   static CompLevel adjust_comp_level_inner(const methodHandle& method, bool is_osr, CompLevel level, JavaThread* thread);
  
   public:
!   static bool is_HotSpotJVMCIRuntime_initialized() {
!     return _HotSpotJVMCIRuntime_initialized;
    }
  
    /**
!    * Gets the singleton HotSpotJVMCIRuntime instance, initializing it if necessary
     */
!   static Handle get_HotSpotJVMCIRuntime(TRAPS);
! 
!   static jobject get_HotSpotJVMCIRuntime_jobject(TRAPS) {
!     initialize_JVMCI(CHECK_NULL);
!     assert(_HotSpotJVMCIRuntime_initialized, "must be");
!     return _HotSpotJVMCIRuntime_instance;
!   }
! 
!   static Handle callStatic(const char* className, const char* methodName, const char* returnType, JavaCallArguments* args, TRAPS);
  
    /**
!    * Determines if the VM is sufficiently booted to initialize JVMCI.
     */
!   static bool can_initialize_JVMCI();
  
    /**
     * Trigger initialization of HotSpotJVMCIRuntime through JVMCI.getRuntime()
     */
!   static void initialize_JVMCI(TRAPS);
  
    /**
     * Explicitly initialize HotSpotJVMCIRuntime itself
     */
!   static void initialize_HotSpotJVMCIRuntime(TRAPS);
! 
!   static void initialize_well_known_classes(TRAPS);
  
!   static void metadata_do(void f(Metadata*));
! 
!   static void shutdown(TRAPS);
! 
!   static void bootstrap_finished(TRAPS);
! 
!   static bool shutdown_called() {
!     return _shutdown_called;
!   }
  
    /**
     * Lets JVMCI modify the compilation level currently selected for a method by
     * the VM compilation policy.
     *
--- 96,175 ----
       by_holder = 1,        // adjust based on declaring class of method
       by_full_signature = 2 // adjust based on declaring class, name and signature of method
    };
  
   private:
!   volatile bool _being_initialized;
!   volatile bool _initialized;
! 
!   JVMCIObject _HotSpotJVMCIRuntime_instance;
  
!   CompLevelAdjustment _comp_level_adjustment;
  
!   bool _shutdown_called;
  
!   CompLevel adjust_comp_level_inner(methodHandle method, bool is_osr, CompLevel level, JavaThread* thread);
! 
!   JVMCIObject create_jvmci_primitive_type(BasicType type, JVMCI_TRAPS);
! 
!   // Implementation methods for loading and constant pool access.
!   static Klass* get_klass_by_name_impl(Klass*& accessing_klass,
!                                        const constantPoolHandle& cpool,
!                                        Symbol* klass_name,
!                                        bool require_local);
!   static Klass*   get_klass_by_index_impl(const constantPoolHandle& cpool,
!                                           int klass_index,
!                                           bool& is_accessible,
!                                           Klass* loading_klass);
!   static void   get_field_by_index_impl(InstanceKlass* loading_klass, fieldDescriptor& fd,
!                                         int field_index);
!   static methodHandle  get_method_by_index_impl(const constantPoolHandle& cpool,
!                                                 int method_index, Bytecodes::Code bc,
!                                                 InstanceKlass* loading_klass);
! 
!   // Helper methods
!   static bool       check_klass_accessibility(Klass* accessing_klass, Klass* resolved_klass);
!   static methodHandle  lookup_method(InstanceKlass*  accessor,
!                                      Klass*  holder,
!                                      Symbol*         name,
!                                      Symbol*         sig,
!                                      Bytecodes::Code bc,
!                                      constantTag     tag);
  
   public:
!   JVMCIRuntime() {
!     _comp_level_adjustment = JVMCIRuntime::none;
!     _initialized = false;
!     _being_initialized = false;
!     _shutdown_called = false;
    }
  
    /**
!    * Compute offsets and construct any state required before executing JVMCI code.
     */
!   void initialize(JVMCIEnv* jvmciEnv);
  
    /**
!    * Gets the singleton HotSpotJVMCIRuntime instance, initializing it if necessary
     */
!   JVMCIObject get_HotSpotJVMCIRuntime(JVMCI_TRAPS);
! 
!   bool is_HotSpotJVMCIRuntime_initialized() {
!     return _HotSpotJVMCIRuntime_instance.is_non_null();
!   }
  
    /**
     * Trigger initialization of HotSpotJVMCIRuntime through JVMCI.getRuntime()
     */
!   void initialize_JVMCI(JVMCI_TRAPS);
  
    /**
     * Explicitly initialize HotSpotJVMCIRuntime itself
     */
!   void initialize_HotSpotJVMCIRuntime(JVMCI_TRAPS);
  
!   void call_getCompiler(TRAPS);
  
    /**
     * Lets JVMCI modify the compilation level currently selected for a method by
     * the VM compilation policy.
     *
*** 115,125 ****
     * @param is_osr specifies if the compilation is an OSR compilation
     * @param level the compilation level currently selected by the VM compilation policy
     * @param thread the current thread
     * @return the compilation level to use for the compilation
     */
!   static CompLevel adjust_comp_level(const methodHandle& method, bool is_osr, CompLevel level, JavaThread* thread);
  
    static BasicType kindToBasicType(Handle kind, TRAPS);
  
    static void new_instance_common(JavaThread* thread, Klass* klass, bool null_on_fail);
    static void new_array_common(JavaThread* thread, Klass* klass, jint length, bool null_on_fail);
--- 177,301 ----
     * @param is_osr specifies if the compilation is an OSR compilation
     * @param level the compilation level currently selected by the VM compilation policy
     * @param thread the current thread
     * @return the compilation level to use for the compilation
     */
!   CompLevel adjust_comp_level(methodHandle method, bool is_osr, CompLevel level, JavaThread* thread);
! 
!   void shutdown();
! 
!   bool shutdown_called() {
!     return _shutdown_called;
!   }
! 
!   void bootstrap_finished(TRAPS);
! 
!   // Look up a klass by name from a particular class loader (the accessor's).
!   // If require_local, result must be defined in that class loader, or NULL.
!   // If !require_local, a result from remote class loader may be reported,
!   // if sufficient class loader constraints exist such that initiating
!   // a class loading request from the given loader is bound to return
!   // the class defined in the remote loader (or throw an error).
!   //
!   // Return an unloaded klass if !require_local and no class at all is found.
!   //
!   // The CI treats a klass as loaded if it is consistently defined in
!   // another loader, even if it hasn't yet been loaded in all loaders
!   // that could potentially see it via delegation.
!   static Klass* get_klass_by_name(Klass* accessing_klass,
!                                   Symbol* klass_name,
!                                   bool require_local);
! 
!   // Constant pool access.
!   static Klass*   get_klass_by_index(const constantPoolHandle& cpool,
!                                      int klass_index,
!                                      bool& is_accessible,
!                                      Klass* loading_klass);
!   static void   get_field_by_index(InstanceKlass* loading_klass, fieldDescriptor& fd,
!                                    int field_index);
!   static methodHandle  get_method_by_index(const constantPoolHandle& cpool,
!                                            int method_index, Bytecodes::Code bc,
!                                            InstanceKlass* loading_klass);
! 
!   // converts the Klass* representing the holder of a method into a
!   // InstanceKlass*.  This is needed since the holder of a method in
!   // the bytecodes could be an array type.  Basically this converts
!   // array types into java/lang/Object and other types stay as they are.
!   static InstanceKlass* get_instance_klass_for_declared_method_holder(Klass* klass);
! 
!   // Helper routine for determining the validity of a compilation
!   // with respect to concurrent class loading.
!   static JVMCI::CodeInstallResult validate_compile_task_dependencies(Dependencies* target, JVMCICompileState* task, char** failure_detail);
! 
!   // Compiles `target` with the JVMCI compiler.
!   void compile_method(JVMCIEnv* JVMCIENV, JVMCICompiler* compiler, const methodHandle& target, int entry_bci);
! 
!   // Register the result of a compilation.
!   JVMCI::CodeInstallResult register_method(JVMCIEnv* JVMCIENV,
!                        const methodHandle&       target,
!                        nmethod*&                 nm,
!                        int                       entry_bci,
!                        CodeOffsets*              offsets,
!                        int                       orig_pc_offset,
!                        CodeBuffer*               code_buffer,
!                        int                       frame_words,
!                        OopMapSet*                oop_map_set,
!                        ExceptionHandlerTable*    handler_table,
!                        AbstractCompiler*         compiler,
!                        DebugInformationRecorder* debug_info,
!                        Dependencies*             dependencies,
!                        int                       compile_id,
!                        bool                      has_unsafe_access,
!                        bool                      has_wide_vector,
!                        JVMCIObject               compiled_code,
!                        JVMCIObject               nmethod_mirror,
!                        FailedSpeculation**       failed_speculations,
!                        char*                     speculations,
!                        int                       speculations_len);
! 
!   /**
!    * Exits the VM due to an unexpected exception.
!    */
!   static void exit_on_pending_exception(JVMCIEnv* JVMCIENV, const char* message);
! 
!   static void describe_pending_hotspot_exception(JavaThread* THREAD, bool clear);
! 
! #define CHECK_EXIT THREAD); \
!   if (HAS_PENDING_EXCEPTION) { \
!     char buf[256]; \
!     jio_snprintf(buf, 256, "Uncaught exception at %s:%d", __FILE__, __LINE__); \
!     JVMCIRuntime::exit_on_pending_exception(NULL, buf); \
!     return; \
!   } \
!   (void)(0
! 
! #define CHECK_EXIT_(v) THREAD);                 \
!   if (HAS_PENDING_EXCEPTION) { \
!     char buf[256]; \
!     jio_snprintf(buf, 256, "Uncaught exception at %s:%d", __FILE__, __LINE__); \
!     JVMCIRuntime::exit_on_pending_exception(NULL, buf); \
!     return v; \
!   } \
!   (void)(0
! 
! #define JVMCI_CHECK_EXIT JVMCIENV); \
!   if (JVMCIENV->has_pending_exception()) {      \
!     char buf[256]; \
!     jio_snprintf(buf, 256, "Uncaught exception at %s:%d", __FILE__, __LINE__); \
!     JVMCIRuntime::exit_on_pending_exception(JVMCIENV, buf); \
!     return; \
!   } \
!   (void)(0
! 
! #define JVMCI_CHECK_EXIT_(result) JVMCIENV); \
!   if (JVMCIENV->has_pending_exception()) {      \
!     char buf[256]; \
!     jio_snprintf(buf, 256, "Uncaught exception at %s:%d", __FILE__, __LINE__); \
!     JVMCIRuntime::exit_on_pending_exception(JVMCIENV, buf); \
!     return result; \
!   } \
!   (void)(0
  
    static BasicType kindToBasicType(Handle kind, TRAPS);
  
    static void new_instance_common(JavaThread* thread, Klass* klass, bool null_on_fail);
    static void new_array_common(JavaThread* thread, Klass* klass, jint length, bool null_on_fail);
*** 177,203 ****
    static void throw_and_post_jvmti_exception(JavaThread* thread, const char* exception, const char* message);
    // helper methods to throw exception with complex messages
    static void throw_klass_external_name_exception(JavaThread* thread, const char* exception, Klass* klass);
    static void throw_class_cast_exception(JavaThread* thread, const char* exception, Klass* caster_klass, Klass* target_klass);
  
-   // Forces initialization of the JVMCI runtime.
-   static void force_initialization(TRAPS);
- 
    // Test only function
!   static int test_deoptimize_call_int(JavaThread* thread, int value);
  };
  
  // Tracing macros.
  
  #define IF_TRACE_jvmci_1 if (!(JVMCITraceLevel >= 1)) ; else
  #define IF_TRACE_jvmci_2 if (!(JVMCITraceLevel >= 2)) ; else
  #define IF_TRACE_jvmci_3 if (!(JVMCITraceLevel >= 3)) ; else
  #define IF_TRACE_jvmci_4 if (!(JVMCITraceLevel >= 4)) ; else
  #define IF_TRACE_jvmci_5 if (!(JVMCITraceLevel >= 5)) ; else
  
! #define TRACE_jvmci_1 if (!(JVMCITraceLevel >= 1 && (tty->print("JVMCITrace-1: "), true))) ; else tty->print_cr
! #define TRACE_jvmci_2 if (!(JVMCITraceLevel >= 2 && (tty->print("   JVMCITrace-2: "), true))) ; else tty->print_cr
! #define TRACE_jvmci_3 if (!(JVMCITraceLevel >= 3 && (tty->print("      JVMCITrace-3: "), true))) ; else tty->print_cr
! #define TRACE_jvmci_4 if (!(JVMCITraceLevel >= 4 && (tty->print("         JVMCITrace-4: "), true))) ; else tty->print_cr
! #define TRACE_jvmci_5 if (!(JVMCITraceLevel >= 5 && (tty->print("            JVMCITrace-5: "), true))) ; else tty->print_cr
  
  #endif // SHARE_JVMCI_JVMCIRUNTIME_HPP
--- 353,376 ----
    static void throw_and_post_jvmti_exception(JavaThread* thread, const char* exception, const char* message);
    // helper methods to throw exception with complex messages
    static void throw_klass_external_name_exception(JavaThread* thread, const char* exception, Klass* klass);
    static void throw_class_cast_exception(JavaThread* thread, const char* exception, Klass* caster_klass, Klass* target_klass);
  
    // Test only function
!   static jint test_deoptimize_call_int(JavaThread* thread, int value);
  };
  
  // Tracing macros.
  
  #define IF_TRACE_jvmci_1 if (!(JVMCITraceLevel >= 1)) ; else
  #define IF_TRACE_jvmci_2 if (!(JVMCITraceLevel >= 2)) ; else
  #define IF_TRACE_jvmci_3 if (!(JVMCITraceLevel >= 3)) ; else
  #define IF_TRACE_jvmci_4 if (!(JVMCITraceLevel >= 4)) ; else
  #define IF_TRACE_jvmci_5 if (!(JVMCITraceLevel >= 5)) ; else
  
! #define TRACE_jvmci_1 if (!(JVMCITraceLevel >= 1 && (tty->print(PTR_FORMAT " JVMCITrace-1: ", p2i(JavaThread::current())), true))) ; else tty->print_cr
! #define TRACE_jvmci_2 if (!(JVMCITraceLevel >= 2 && (tty->print(PTR_FORMAT "    JVMCITrace-2: ", p2i(JavaThread::current())), true))) ; else tty->print_cr
! #define TRACE_jvmci_3 if (!(JVMCITraceLevel >= 3 && (tty->print(PTR_FORMAT "       JVMCITrace-3: ", p2i(JavaThread::current())), true))) ; else tty->print_cr
! #define TRACE_jvmci_4 if (!(JVMCITraceLevel >= 4 && (tty->print(PTR_FORMAT "          JVMCITrace-4: ", p2i(JavaThread::current())), true))) ; else tty->print_cr
! #define TRACE_jvmci_5 if (!(JVMCITraceLevel >= 5 && (tty->print(PTR_FORMAT "             JVMCITrace-5: ", p2i(JavaThread::current())), true))) ; else tty->print_cr
  
  #endif // SHARE_JVMCI_JVMCIRUNTIME_HPP