Mercurial Mercurial > jdk-sandbox / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
hotspot/src/share/vm/prims/jvmtiExport.hpp
changeset 13975 2f7431485cfa
parent 13728 882756847a04
child 14477 95e66ea71f71
equal deleted inserted replaced
13951:3fc49366dc15 13975:2f7431485cfa 
    44 class JvmtiManageCapabilities;
 
    44 class JvmtiManageCapabilities;
 
    45 class JvmtiEnv;
 
    45 class JvmtiEnv;
 
    46 class JvmtiThreadState;
 
    46 class JvmtiThreadState;
 
    47 class AttachOperation;
 
    47 class AttachOperation;
 
    48 
    48 
    49 #ifndef JVMTI_KERNEL
 
       
    50 #define JVMTI_SUPPORT_FLAG(key)                                         \
 
       
    51   private:                                                              \
 
       
    52   static bool  _##key;                                                  \
 
       
    53   public:                                                               \
 
       
    54   inline static void set_##key(bool on)       { _##key = (on != 0); }   \
 
       
    55   inline static bool key()                    { return _##key; }
 
       
    56 #else  // JVMTI_KERNEL
 
       
    57 #define JVMTI_SUPPORT_FLAG(key)                                           \
 
    49 #define JVMTI_SUPPORT_FLAG(key)                                           \
 
    58   private:                                                                \
 
    50   private:                                                                \
 
    59   const static bool _##key = false;                                       \
 
    51   static bool  _##key;                                                    \
 
    60   public:                                                                 \
 
    52   public:                                                                 \
 
    61   inline static void set_##key(bool on)       { report_unsupported(on); } \
 
    53   inline static void set_##key(bool on) {                                 \
 
    62   inline static bool key()                    { return _##key; }
 
    54     JVMTI_ONLY(_##key = (on != 0));                                       \
 
    63 #endif // JVMTI_KERNEL
 
    55     NOT_JVMTI(report_unsupported(on));                                    \
 
       
    56   }                                                                       \
 
       
    57   inline static bool key() {                                              \
 
       
    58     JVMTI_ONLY(return _##key);                                            \
 
       
    59     NOT_JVMTI(return false);                                              \
 
       
    60   }
 
    64 
    61 
    65 
    62 
    66 // This class contains the JVMTI interface for the rest of hotspot.
 
    63 // This class contains the JVMTI interface for the rest of hotspot.
 
    67 //
 
    64 //
 
    68 class JvmtiExport : public AllStatic {
 
    65 class JvmtiExport : public AllStatic {
 
    69   friend class VMStructs;
 
    66   friend class VMStructs;
 
    70  private:
 
    67  private:
 
       
    68 
       
    69 #if INCLUDE_JVMTI
 
    71   static int         _field_access_count;
 
    70   static int         _field_access_count;
 
    72   static int         _field_modification_count;
 
    71   static int         _field_modification_count;
 
    73 
    72 
    74   static bool        _can_access_local_variables;
 
    73   static bool        _can_access_local_variables;
 
    75   static bool        _can_hotswap_or_post_breakpoint;
 
    74   static bool        _can_hotswap_or_post_breakpoint;
 
    76   static bool        _can_modify_any_class;
 
    75   static bool        _can_modify_any_class;
 
    77   static bool        _can_walk_any_space;
 
    76   static bool        _can_walk_any_space;
 
       
    77 #endif // INCLUDE_JVMTI
 
    78 
    78 
    79   JVMTI_SUPPORT_FLAG(can_get_source_debug_extension)
 
    79   JVMTI_SUPPORT_FLAG(can_get_source_debug_extension)
 
    80   JVMTI_SUPPORT_FLAG(can_maintain_original_method_order)
 
    80   JVMTI_SUPPORT_FLAG(can_maintain_original_method_order)
 
    81   JVMTI_SUPPORT_FLAG(can_post_interpreter_events)
 
    81   JVMTI_SUPPORT_FLAG(can_post_interpreter_events)
 
    82   JVMTI_SUPPORT_FLAG(can_post_on_exceptions)
 
    82   JVMTI_SUPPORT_FLAG(can_post_on_exceptions)
 
   123   // If flag cannot be implemented, give an error if on=true
 
   123   // If flag cannot be implemented, give an error if on=true
 
   124   static void report_unsupported(bool on);
 
   124   static void report_unsupported(bool on);
 
   125 
   125 
   126   // these should only be called by the friend class
 
   126   // these should only be called by the friend class
 
   127   friend class JvmtiManageCapabilities;
 
   127   friend class JvmtiManageCapabilities;
 
   128   inline static void set_can_modify_any_class(bool on)                 { _can_modify_any_class = (on != 0); }
 
   128   inline static void set_can_modify_any_class(bool on) {
 
   129   inline static void set_can_access_local_variables(bool on)           { _can_access_local_variables = (on != 0); }
 
   129     JVMTI_ONLY(_can_modify_any_class = (on != 0);)
 
   130   inline static void set_can_hotswap_or_post_breakpoint(bool on)       { _can_hotswap_or_post_breakpoint = (on != 0); }
 
   130   }
 
   131   inline static void set_can_walk_any_space(bool on)                   { _can_walk_any_space = (on != 0); }
 
   131   inline static void set_can_access_local_variables(bool on) {
 
       
   132     JVMTI_ONLY(_can_access_local_variables = (on != 0);)
 
       
   133   }
 
       
   134   inline static void set_can_hotswap_or_post_breakpoint(bool on) {
 
       
   135     JVMTI_ONLY(_can_hotswap_or_post_breakpoint = (on != 0);)
 
       
   136   }
 
       
   137   inline static void set_can_walk_any_space(bool on) {
 
       
   138     JVMTI_ONLY(_can_walk_any_space = (on != 0);)
 
       
   139   }
 
   132 
   140 
   133   enum {
 
   141   enum {
 
   134     JVMTI_VERSION_MASK   = 0x70000000,
 
   142     JVMTI_VERSION_MASK   = 0x70000000,
 
   135     JVMTI_VERSION_VALUE  = 0x30000000,
 
   143     JVMTI_VERSION_VALUE  = 0x30000000,
 
   136     JVMDI_VERSION_VALUE  = 0x20000000
 
   144     JVMDI_VERSION_VALUE  = 0x20000000
 
   142 
   150 
   143 
   151 
   144   // posts a DynamicCodeGenerated event (internal/private implementation).
 
   152   // posts a DynamicCodeGenerated event (internal/private implementation).
 
   145   // The public post_dynamic_code_generated* functions make use of the
 
   153   // The public post_dynamic_code_generated* functions make use of the
 
   146   // internal implementation.  Also called from JvmtiDeferredEvent::post()
 
   154   // internal implementation.  Also called from JvmtiDeferredEvent::post()
 
   147   static void post_dynamic_code_generated_internal(const char *name, const void *code_begin, const void *code_end) KERNEL_RETURN;
 
   155   static void post_dynamic_code_generated_internal(const char *name, const void *code_begin, const void *code_end) NOT_JVMTI_RETURN;
 
   148 
   156 
   149  private:
 
   157  private:
 
   150 
   158 
   151   // GenerateEvents support to allow posting of CompiledMethodLoad and
 
   159   // GenerateEvents support to allow posting of CompiledMethodLoad and
 
   152   // DynamicCodeGenerated events for a given environment.
 
   160   // DynamicCodeGenerated events for a given environment.
 
   153   friend class JvmtiCodeBlobEvents;
 
   161   friend class JvmtiCodeBlobEvents;
 
   154 
   162 
   155   static void post_compiled_method_load(JvmtiEnv* env, const jmethodID method, const jint length,
 
   163   static void post_compiled_method_load(JvmtiEnv* env, const jmethodID method, const jint length,
 
   156                                         const void *code_begin, const jint map_length,
 
   164                                         const void *code_begin, const jint map_length,
 
   157                                         const jvmtiAddrLocationMap* map) KERNEL_RETURN;
 
   165                                         const jvmtiAddrLocationMap* map) NOT_JVMTI_RETURN;
 
   158   static void post_dynamic_code_generated(JvmtiEnv* env, const char *name, const void *code_begin,
 
   166   static void post_dynamic_code_generated(JvmtiEnv* env, const char *name, const void *code_begin,
 
   159                                           const void *code_end) KERNEL_RETURN;
 
   167                                           const void *code_end) NOT_JVMTI_RETURN;
 
   160 
   168 
   161   // The RedefineClasses() API breaks some invariants in the "regular"
 
   169   // The RedefineClasses() API breaks some invariants in the "regular"
 
   162   // system. For example, there are sanity checks when GC'ing nmethods
 
   170   // system. For example, there are sanity checks when GC'ing nmethods
 
   163   // that require the containing class to be unloading. However, when a
 
   171   // that require the containing class to be unloading. However, when a
 
   164   // method is redefined, the old method and nmethod can become GC'able
 
   172   // method is redefined, the old method and nmethod can become GC'able
 
   176   // only be set by the friend class and can be queried by other sub
 
   184   // only be set by the friend class and can be queried by other sub
 
   177   // systems as needed to relax invariant checks.
 
   185   // systems as needed to relax invariant checks.
 
   178   static bool _has_redefined_a_class;
 
   186   static bool _has_redefined_a_class;
 
   179   friend class VM_RedefineClasses;
 
   187   friend class VM_RedefineClasses;
 
   180   inline static void set_has_redefined_a_class() {
 
   188   inline static void set_has_redefined_a_class() {
 
   181     _has_redefined_a_class = true;
 
   189     JVMTI_ONLY(_has_redefined_a_class = true;)
 
   182   }
 
   190   }
 
   183 
       
   184   // Flag to indicate if the compiler has recorded all dependencies. When the
 
   191   // Flag to indicate if the compiler has recorded all dependencies. When the
 
   185   // can_redefine_classes capability is enabled in the OnLoad phase then the compiler
 
   192   // can_redefine_classes capability is enabled in the OnLoad phase then the compiler
 
   186   // records all dependencies from startup. However if the capability is first
 
   193   // records all dependencies from startup. However if the capability is first
 
   187   // enabled some time later then the dependencies recorded by the compiler
 
   194   // enabled some time later then the dependencies recorded by the compiler
 
   188   // are incomplete. This flag is used by RedefineClasses to know if the
 
   195   // are incomplete. This flag is used by RedefineClasses to know if the
 
   189   // dependency information is complete or not.
 
   196   // dependency information is complete or not.
 
   190   static bool _all_dependencies_are_recorded;
 
   197   static bool _all_dependencies_are_recorded;
 
   191 
   198 
   192  public:
 
   199  public:
 
   193   inline static bool has_redefined_a_class() {
 
   200   inline static bool has_redefined_a_class() {
 
   194     return _has_redefined_a_class;
 
   201     JVMTI_ONLY(return _has_redefined_a_class);
 
       
   202     NOT_JVMTI(return false);
 
   195   }
 
   203   }
 
   196 
   204 
   197   inline static bool all_dependencies_are_recorded() {
 
   205   inline static bool all_dependencies_are_recorded() {
 
   198     return _all_dependencies_are_recorded;
 
   206     return _all_dependencies_are_recorded;
 
   199   }
 
   207   }
 
   202     _all_dependencies_are_recorded = (on != 0);
 
   210     _all_dependencies_are_recorded = (on != 0);
 
   203   }
 
   211   }
 
   204 
   212 
   205 
   213 
   206   // let JVMTI know that the JVM_OnLoad code is running
 
   214   // let JVMTI know that the JVM_OnLoad code is running
 
   207   static void enter_onload_phase();
 
   215   static void enter_onload_phase() NOT_JVMTI_RETURN;
 
   208 
   216 
   209   // let JVMTI know that the VM isn't up yet (and JVM_OnLoad code isn't running)
 
   217   // let JVMTI know that the VM isn't up yet (and JVM_OnLoad code isn't running)
 
   210   static void enter_primordial_phase();
 
   218   static void enter_primordial_phase() NOT_JVMTI_RETURN;
 
   211 
   219 
   212   // let JVMTI know that the VM isn't up yet but JNI is live
 
   220   // let JVMTI know that the VM isn't up yet but JNI is live
 
   213   static void enter_start_phase();
 
   221   static void enter_start_phase() NOT_JVMTI_RETURN;
 
   214 
   222 
   215   // let JVMTI know that the VM is fully up and running now
 
   223   // let JVMTI know that the VM is fully up and running now
 
   216   static void enter_live_phase();
 
   224   static void enter_live_phase() NOT_JVMTI_RETURN;
 
   217 
   225 
   218   // ------ can_* conditions (below) are set at OnLoad and never changed ------------
 
   226   // ------ can_* conditions (below) are set at OnLoad and never changed ------------
 
   219   inline static bool can_modify_any_class()                       { return _can_modify_any_class; }
 
   227   inline static bool can_modify_any_class()                       {
 
   220   inline static bool can_access_local_variables()                 { return _can_access_local_variables; }
 
   228     JVMTI_ONLY(return _can_modify_any_class);
 
   221   inline static bool can_hotswap_or_post_breakpoint()             { return _can_hotswap_or_post_breakpoint; }
 
   229     NOT_JVMTI(return false);
 
   222   inline static bool can_walk_any_space()                         { return _can_walk_any_space; }
 
   230   }
 
       
   231   inline static bool can_access_local_variables()                 {
 
       
   232     JVMTI_ONLY(return _can_access_local_variables);
 
       
   233     NOT_JVMTI(return false);
 
       
   234   }
 
       
   235   inline static bool can_hotswap_or_post_breakpoint()             {
 
       
   236     JVMTI_ONLY(return _can_hotswap_or_post_breakpoint);
 
       
   237     NOT_JVMTI(return false);
 
       
   238   }
 
       
   239   inline static bool can_walk_any_space()                         {
 
       
   240     JVMTI_ONLY(return _can_walk_any_space);
 
       
   241     NOT_JVMTI(return false);
 
       
   242   }
 
   223 
   243 
   224   // field access management
 
   244   // field access management
 
   225   static address  get_field_access_count_addr();
 
   245   static address  get_field_access_count_addr() NOT_JVMTI_RETURN_(0);
 
   226 
   246 
   227   // field modification management
 
   247   // field modification management
 
   228   static address  get_field_modification_count_addr();
 
   248   static address  get_field_modification_count_addr() NOT_JVMTI_RETURN_(0);
 
   229 
   249 
   230   // -----------------
 
   250   // -----------------
 
   231 
   251 
   232   static bool is_jvmti_version(jint version)                      { return (version & JVMTI_VERSION_MASK) == JVMTI_VERSION_VALUE; }
 
   252   static bool is_jvmti_version(jint version)                      {
 
   233   static bool is_jvmdi_version(jint version)                      { return (version & JVMTI_VERSION_MASK) == JVMDI_VERSION_VALUE; }
 
   253     JVMTI_ONLY(return (version & JVMTI_VERSION_MASK) == JVMTI_VERSION_VALUE);
 
   234   static jint get_jvmti_interface(JavaVM *jvm, void **penv, jint version);
 
   254     NOT_JVMTI(return false);
 
       
   255   }
 
       
   256   static bool is_jvmdi_version(jint version)                      {
 
       
   257     JVMTI_ONLY(return (version & JVMTI_VERSION_MASK) == JVMDI_VERSION_VALUE);
 
       
   258     NOT_JVMTI(return false);
 
       
   259   }
 
       
   260   static jint get_jvmti_interface(JavaVM *jvm, void **penv, jint version) NOT_JVMTI_RETURN_(0);
 
   235   static void decode_version_values(jint version, int * major, int * minor,
 
   261   static void decode_version_values(jint version, int * major, int * minor,
 
   236                                     int * micro);
 
   262                                     int * micro) NOT_JVMTI_RETURN;
 
   237 
   263 
   238   // single stepping management methods
 
   264   // single stepping management methods
 
   239   static void at_single_stepping_point(JavaThread *thread, Method* method, address location) KERNEL_RETURN;
 
   265   static void at_single_stepping_point(JavaThread *thread, Method* method, address location) NOT_JVMTI_RETURN;
 
   240   static void expose_single_stepping(JavaThread *thread) KERNEL_RETURN;
 
   266   static void expose_single_stepping(JavaThread *thread) NOT_JVMTI_RETURN;
 
   241   static bool hide_single_stepping(JavaThread *thread) KERNEL_RETURN_(false);
 
   267   static bool hide_single_stepping(JavaThread *thread) NOT_JVMTI_RETURN_(false);
 
   242 
   268 
   243   // Methods that notify the debugger that something interesting has happened in the VM.
 
   269   // Methods that notify the debugger that something interesting has happened in the VM.
 
   244   static void post_vm_start              ();
 
   270   static void post_vm_start              () NOT_JVMTI_RETURN;
 
   245   static void post_vm_initialized        ();
 
   271   static void post_vm_initialized        () NOT_JVMTI_RETURN;
 
   246   static void post_vm_death              ();
 
   272   static void post_vm_death              () NOT_JVMTI_RETURN;
 
   247 
   273 
   248   static void post_single_step           (JavaThread *thread, Method* method, address location) KERNEL_RETURN;
 
   274   static void post_single_step           (JavaThread *thread, Method* method, address location) NOT_JVMTI_RETURN;
 
   249   static void post_raw_breakpoint        (JavaThread *thread, Method* method, address location) KERNEL_RETURN;
 
   275   static void post_raw_breakpoint        (JavaThread *thread, Method* method, address location) NOT_JVMTI_RETURN;
 
   250 
   276 
   251   static void post_exception_throw       (JavaThread *thread, Method* method, address location, oop exception) KERNEL_RETURN;
 
   277   static void post_exception_throw       (JavaThread *thread, Method* method, address location, oop exception) NOT_JVMTI_RETURN;
 
   252   static void notice_unwind_due_to_exception (JavaThread *thread, Method* method, address location, oop exception, bool in_handler_frame) KERNEL_RETURN;
 
   278   static void notice_unwind_due_to_exception (JavaThread *thread, Method* method, address location, oop exception, bool in_handler_frame) NOT_JVMTI_RETURN;
 
   253 
   279 
   254   static oop jni_GetField_probe          (JavaThread *thread, jobject jobj,
 
   280   static oop jni_GetField_probe          (JavaThread *thread, jobject jobj,
 
   255     oop obj, Klass* klass, jfieldID fieldID, bool is_static)
 
   281     oop obj, Klass* klass, jfieldID fieldID, bool is_static)
 
   256     KERNEL_RETURN_(NULL);
 
   282     NOT_JVMTI_RETURN_(NULL);
 
   257   static oop jni_GetField_probe_nh       (JavaThread *thread, jobject jobj,
 
   283   static oop jni_GetField_probe_nh       (JavaThread *thread, jobject jobj,
 
   258     oop obj, Klass* klass, jfieldID fieldID, bool is_static)
 
   284     oop obj, Klass* klass, jfieldID fieldID, bool is_static)
 
   259     KERNEL_RETURN_(NULL);
 
   285     NOT_JVMTI_RETURN_(NULL);
 
   260   static void post_field_access_by_jni   (JavaThread *thread, oop obj,
 
   286   static void post_field_access_by_jni   (JavaThread *thread, oop obj,
 
   261     Klass* klass, jfieldID fieldID, bool is_static) KERNEL_RETURN;
 
   287     Klass* klass, jfieldID fieldID, bool is_static) NOT_JVMTI_RETURN;
 
   262   static void post_field_access          (JavaThread *thread, Method* method,
 
   288   static void post_field_access          (JavaThread *thread, Method* method,
 
   263     address location, KlassHandle field_klass, Handle object, jfieldID field) KERNEL_RETURN;
 
   289     address location, KlassHandle field_klass, Handle object, jfieldID field) NOT_JVMTI_RETURN;
 
   264   static oop jni_SetField_probe          (JavaThread *thread, jobject jobj,
 
   290   static oop jni_SetField_probe          (JavaThread *thread, jobject jobj,
 
   265     oop obj, Klass* klass, jfieldID fieldID, bool is_static, char sig_type,
 
   291     oop obj, Klass* klass, jfieldID fieldID, bool is_static, char sig_type,
 
   266     jvalue *value) KERNEL_RETURN_(NULL);
 
   292     jvalue *value) NOT_JVMTI_RETURN_(NULL);
 
   267   static oop jni_SetField_probe_nh       (JavaThread *thread, jobject jobj,
 
   293   static oop jni_SetField_probe_nh       (JavaThread *thread, jobject jobj,
 
   268     oop obj, Klass* klass, jfieldID fieldID, bool is_static, char sig_type,
 
   294     oop obj, Klass* klass, jfieldID fieldID, bool is_static, char sig_type,
 
   269     jvalue *value) KERNEL_RETURN_(NULL);
 
   295     jvalue *value) NOT_JVMTI_RETURN_(NULL);
 
   270   static void post_field_modification_by_jni(JavaThread *thread, oop obj,
 
   296   static void post_field_modification_by_jni(JavaThread *thread, oop obj,
 
   271     Klass* klass, jfieldID fieldID, bool is_static, char sig_type,
 
   297     Klass* klass, jfieldID fieldID, bool is_static, char sig_type,
 
   272     jvalue *value);
 
   298     jvalue *value);
 
   273   static void post_raw_field_modification(JavaThread *thread, Method* method,
 
   299   static void post_raw_field_modification(JavaThread *thread, Method* method,
 
   274     address location, KlassHandle field_klass, Handle object, jfieldID field,
 
   300     address location, KlassHandle field_klass, Handle object, jfieldID field,
 
   275     char sig_type, jvalue *value) KERNEL_RETURN;
 
   301     char sig_type, jvalue *value) NOT_JVMTI_RETURN;
 
   276 
   302 
   277   static void post_method_entry          (JavaThread *thread, Method* method, frame current_frame) KERNEL_RETURN;
 
   303   static void post_method_entry          (JavaThread *thread, Method* method, frame current_frame) NOT_JVMTI_RETURN;
 
   278   static void post_method_exit           (JavaThread *thread, Method* method, frame current_frame) KERNEL_RETURN;
 
   304   static void post_method_exit           (JavaThread *thread, Method* method, frame current_frame) NOT_JVMTI_RETURN;
 
   279 
   305 
   280   static void post_class_load            (JavaThread *thread, Klass* klass) KERNEL_RETURN;
 
   306   static void post_class_load            (JavaThread *thread, Klass* klass) NOT_JVMTI_RETURN;
 
   281   static void post_class_unload          (Klass* klass) KERNEL_RETURN;
 
   307   static void post_class_unload          (Klass* klass) NOT_JVMTI_RETURN;
 
   282   static void post_class_prepare         (JavaThread *thread, Klass* klass) KERNEL_RETURN;
 
   308   static void post_class_prepare         (JavaThread *thread, Klass* klass) NOT_JVMTI_RETURN;
 
   283 
   309 
   284   static void post_thread_start          (JavaThread *thread) KERNEL_RETURN;
 
   310   static void post_thread_start          (JavaThread *thread) NOT_JVMTI_RETURN;
 
   285   static void post_thread_end            (JavaThread *thread) KERNEL_RETURN;
 
   311   static void post_thread_end            (JavaThread *thread) NOT_JVMTI_RETURN;
 
   286 
   312 
   287   // Support for java.lang.instrument agent loading.
 
   313   // Support for java.lang.instrument agent loading.
 
   288   static bool _should_post_class_file_load_hook;
 
   314   static bool _should_post_class_file_load_hook;
 
   289   inline static void set_should_post_class_file_load_hook(bool on)     { _should_post_class_file_load_hook = on;  }
 
   315   inline static void set_should_post_class_file_load_hook(bool on)     { _should_post_class_file_load_hook = on;  }
 
   290   inline static bool should_post_class_file_load_hook()           { return _should_post_class_file_load_hook; }
 
   316   inline static bool should_post_class_file_load_hook()           {
 
       
   317     JVMTI_ONLY(return _should_post_class_file_load_hook);
 
       
   318     NOT_JVMTI(return false;)
 
       
   319   }
 
   291   static void post_class_file_load_hook(Symbol* h_name, Handle class_loader,
 
   320   static void post_class_file_load_hook(Symbol* h_name, Handle class_loader,
 
   292                                         Handle h_protection_domain,
 
   321                                         Handle h_protection_domain,
 
   293                                         unsigned char **data_ptr, unsigned char **end_ptr,
 
   322                                         unsigned char **data_ptr, unsigned char **end_ptr,
 
   294                                         unsigned char **cached_data_ptr,
 
   323                                         unsigned char **cached_data_ptr,
 
   295                                         jint *cached_length_ptr);
 
   324                                         jint *cached_length_ptr) NOT_JVMTI_RETURN;
 
   296   static void post_native_method_bind(Method* method, address* function_ptr) KERNEL_RETURN;
 
   325   static void post_native_method_bind(Method* method, address* function_ptr) NOT_JVMTI_RETURN;
 
   297   static void post_compiled_method_load(nmethod *nm) KERNEL_RETURN;
 
   326   static void post_compiled_method_load(nmethod *nm) NOT_JVMTI_RETURN;
 
   298   static void post_dynamic_code_generated(const char *name, const void *code_begin, const void *code_end) KERNEL_RETURN;
 
   327   static void post_dynamic_code_generated(const char *name, const void *code_begin, const void *code_end) NOT_JVMTI_RETURN;
 
   299 
   328 
   300   // used to post a CompiledMethodUnload event
 
   329   // used to post a CompiledMethodUnload event
 
   301   static void post_compiled_method_unload(jmethodID mid, const void *code_begin) KERNEL_RETURN;
 
   330   static void post_compiled_method_unload(jmethodID mid, const void *code_begin) NOT_JVMTI_RETURN;
 
   302 
   331 
   303   // similiar to post_dynamic_code_generated except that it can be used to
 
   332   // similiar to post_dynamic_code_generated except that it can be used to
 
   304   // post a DynamicCodeGenerated event while holding locks in the VM. Any event
 
   333   // post a DynamicCodeGenerated event while holding locks in the VM. Any event
 
   305   // posted using this function is recorded by the enclosing event collector
 
   334   // posted using this function is recorded by the enclosing event collector
 
   306   // -- JvmtiDynamicCodeEventCollector.
 
   335   // -- JvmtiDynamicCodeEventCollector.
 
   307   static void post_dynamic_code_generated_while_holding_locks(const char* name, address code_begin, address code_end) KERNEL_RETURN;
 
   336   static void post_dynamic_code_generated_while_holding_locks(const char* name, address code_begin, address code_end) NOT_JVMTI_RETURN;
 
   308 
   337 
   309   static void post_garbage_collection_finish() KERNEL_RETURN;
 
   338   static void post_garbage_collection_finish() NOT_JVMTI_RETURN;
 
   310   static void post_garbage_collection_start() KERNEL_RETURN;
 
   339   static void post_garbage_collection_start() NOT_JVMTI_RETURN;
 
   311   static void post_data_dump() KERNEL_RETURN;
 
   340   static void post_data_dump() NOT_JVMTI_RETURN;
 
   312   static void post_monitor_contended_enter(JavaThread *thread, ObjectMonitor *obj_mntr) KERNEL_RETURN;
 
   341   static void post_monitor_contended_enter(JavaThread *thread, ObjectMonitor *obj_mntr) NOT_JVMTI_RETURN;
 
   313   static void post_monitor_contended_entered(JavaThread *thread, ObjectMonitor *obj_mntr) KERNEL_RETURN;
 
   342   static void post_monitor_contended_entered(JavaThread *thread, ObjectMonitor *obj_mntr) NOT_JVMTI_RETURN;
 
   314   static void post_monitor_wait(JavaThread *thread, oop obj, jlong timeout) KERNEL_RETURN;
 
   343   static void post_monitor_wait(JavaThread *thread, oop obj, jlong timeout) NOT_JVMTI_RETURN;
 
   315   static void post_monitor_waited(JavaThread *thread, ObjectMonitor *obj_mntr, jboolean timed_out) KERNEL_RETURN;
 
   344   static void post_monitor_waited(JavaThread *thread, ObjectMonitor *obj_mntr, jboolean timed_out) NOT_JVMTI_RETURN;
 
   316   static void post_object_free(JvmtiEnv* env, jlong tag) KERNEL_RETURN;
 
   345   static void post_object_free(JvmtiEnv* env, jlong tag) NOT_JVMTI_RETURN;
 
   317   static void post_resource_exhausted(jint resource_exhausted_flags, const char* detail) KERNEL_RETURN;
 
   346   static void post_resource_exhausted(jint resource_exhausted_flags, const char* detail) NOT_JVMTI_RETURN;
 
   318   static void record_vm_internal_object_allocation(oop object) KERNEL_RETURN;
 
   347   static void record_vm_internal_object_allocation(oop object) NOT_JVMTI_RETURN;
 
   319   // Post objects collected by vm_object_alloc_event_collector.
 
   348   // Post objects collected by vm_object_alloc_event_collector.
 
   320   static void post_vm_object_alloc(JavaThread *thread, oop object) KERNEL_RETURN;
 
   349   static void post_vm_object_alloc(JavaThread *thread, oop object) NOT_JVMTI_RETURN;
 
   321   // Collects vm internal objects for later event posting.
 
   350   // Collects vm internal objects for later event posting.
 
   322   inline static void vm_object_alloc_event_collector(oop object) {
 
   351   inline static void vm_object_alloc_event_collector(oop object) {
 
   323     if (should_post_vm_object_alloc()) {
 
   352     if (should_post_vm_object_alloc()) {
 
   324       record_vm_internal_object_allocation(object);
 
   353       record_vm_internal_object_allocation(object);
 
   325     }
 
   354     }
 
   329       post_resource_exhausted(JVMTI_RESOURCE_EXHAUSTED_OOM_ERROR,
 
   358       post_resource_exhausted(JVMTI_RESOURCE_EXHAUSTED_OOM_ERROR,
 
   330                               "Requested array size exceeds VM limit");
 
   359                               "Requested array size exceeds VM limit");
 
   331     }
 
   360     }
 
   332   }
 
   361   }
 
   333 
   362 
   334   static void cleanup_thread             (JavaThread* thread) KERNEL_RETURN;
 
   363   static void cleanup_thread             (JavaThread* thread) NOT_JVMTI_RETURN;
 
   335 
   364 
   336   static void oops_do(OopClosure* f) KERNEL_RETURN;
 
   365   static void oops_do(OopClosure* f) NOT_JVMTI_RETURN;
 
   337   static void weak_oops_do(BoolObjectClosure* b, OopClosure* f) KERNEL_RETURN;
 
   366   static void weak_oops_do(BoolObjectClosure* b, OopClosure* f) NOT_JVMTI_RETURN;
 
   338   static void gc_epilogue() KERNEL_RETURN;
 
   367   static void gc_epilogue() NOT_JVMTI_RETURN;
 
   339 
   368 
   340   static void transition_pending_onload_raw_monitors() KERNEL_RETURN;
 
   369   static void transition_pending_onload_raw_monitors() NOT_JVMTI_RETURN;
 
   341 
   370 
   342 #ifndef SERVICES_KERNEL
 
       
   343   // attach support
 
   371   // attach support
 
   344   static jint load_agent_library(AttachOperation* op, outputStream* out);
 
   372   static jint load_agent_library(AttachOperation* op, outputStream* out) NOT_JVMTI_RETURN_(JNI_ERR);
 
   345 #endif // SERVICES_KERNEL
 
       
   346 
   373 
   347   // SetNativeMethodPrefix support
 
   374   // SetNativeMethodPrefix support
 
   348   static char** get_all_native_method_prefixes(int* count_ptr);
 
   375   static char** get_all_native_method_prefixes(int* count_ptr) NOT_JVMTI_RETURN_(NULL);
 
   349 };
 
   376 };
 
   350 
   377 
   351 // Support class used by JvmtiDynamicCodeEventCollector and others. It
 
   378 // Support class used by JvmtiDynamicCodeEventCollector and others. It
 
   352 // describes a single code blob by name and address range.
 
   379 // describes a single code blob by name and address range.
 
   353 class JvmtiCodeBlobDesc : public CHeapObj<mtInternal> {
 
   380 class JvmtiCodeBlobDesc : public CHeapObj<mtInternal> {
 
   406 
   433 
   407   friend class JvmtiExport;
 
   434   friend class JvmtiExport;
 
   408   void register_stub(const char* name, address start, address end);
 
   435   void register_stub(const char* name, address start, address end);
 
   409 
   436 
   410  public:
 
   437  public:
 
   411   JvmtiDynamicCodeEventCollector()  KERNEL_RETURN;
 
   438   JvmtiDynamicCodeEventCollector()  NOT_JVMTI_RETURN;
 
   412   ~JvmtiDynamicCodeEventCollector() KERNEL_RETURN;
 
   439   ~JvmtiDynamicCodeEventCollector() NOT_JVMTI_RETURN;
 
   413   bool is_dynamic_code_event()   { return true; }
 
   440   bool is_dynamic_code_event()   { return true; }
 
   414 
   441 
   415 };
 
   442 };
 
   416 
   443 
   417 // Used to record vm internally allocated object oops and post
 
   444 // Used to record vm internally allocated object oops and post
 
   439 
   466 
   440   //GC support
 
   467   //GC support
 
   441   static void oops_do_for_all_threads(OopClosure* f);
 
   468   static void oops_do_for_all_threads(OopClosure* f);
 
   442 
   469 
   443  public:
 
   470  public:
 
   444   JvmtiVMObjectAllocEventCollector()  KERNEL_RETURN;
 
   471   JvmtiVMObjectAllocEventCollector()  NOT_JVMTI_RETURN;
 
   445   ~JvmtiVMObjectAllocEventCollector() KERNEL_RETURN;
 
   472   ~JvmtiVMObjectAllocEventCollector() NOT_JVMTI_RETURN;
 
   446   bool is_vm_object_alloc_event()   { return true; }
 
   473   bool is_vm_object_alloc_event()   { return true; }
 
   447 
   474 
   448   bool is_enabled()                 { return _enable; }
 
   475   bool is_enabled()                 { return _enable; }
 
   449   void set_enabled(bool on)         { _enable = on; }
 
   476   void set_enabled(bool on)         { _enable = on; }
 
   450 };
 
   477 };
 
   470   JvmtiVMObjectAllocEventCollector *_collector;
 
   497   JvmtiVMObjectAllocEventCollector *_collector;
 
   471 
   498 
   472   bool was_enabled()    { return _collector != NULL; }
 
   499   bool was_enabled()    { return _collector != NULL; }
 
   473 
   500 
   474  public:
 
   501  public:
 
   475   NoJvmtiVMObjectAllocMark() KERNEL_RETURN;
 
   502   NoJvmtiVMObjectAllocMark() NOT_JVMTI_RETURN;
 
   476   ~NoJvmtiVMObjectAllocMark() KERNEL_RETURN;
 
   503   ~NoJvmtiVMObjectAllocMark() NOT_JVMTI_RETURN;
 
   477 };
 
   504 };
 
   478 
   505 
   479 
   506 
   480 // Base class for reporting GC events to JVMTI.
 
   507 // Base class for reporting GC events to JVMTI.
 
   481 class JvmtiGCMarker : public StackObj {
 
   508 class JvmtiGCMarker : public StackObj {
 
   482  public:
 
   509  public:
 
   483   JvmtiGCMarker() KERNEL_RETURN;
 
   510   JvmtiGCMarker() NOT_JVMTI_RETURN;
 
   484   ~JvmtiGCMarker() KERNEL_RETURN;
 
   511   ~JvmtiGCMarker() NOT_JVMTI_RETURN;
 
   485 };
 
   512 };
 
   486 
   513 
   487 // JvmtiHideSingleStepping is a helper class for hiding
 
   514 // JvmtiHideSingleStepping is a helper class for hiding
 
   488 // internal single step events.
 
   515 // internal single step events.
 
   489 class JvmtiHideSingleStepping : public StackObj {
 
   516 class JvmtiHideSingleStepping : public StackObj {
jdk-sandbox