hotspot/src/share/vm/prims/jvmtiImpl.hpp
author kamg
Wed, 02 Feb 2011 14:38:01 -0500
changeset 8110 c992c8d52344
parent 7918 ce1e4ae77aea
child 8475 c2b97a27943a
permissions -rw-r--r--
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" Summary: Defer posting events from the compiler thread: use service thread Reviewed-by: coleenp, dholmes, never, dcubed
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
8110
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
     2
 * Copyright (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 *
5547
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 2137
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 2137
diff changeset
    20
 * or visit www.oracle.com if you need additional information or have any
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 2137
diff changeset
    21
 * questions.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    25
#ifndef SHARE_VM_PRIMS_JVMTIIMPL_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    26
#define SHARE_VM_PRIMS_JVMTIIMPL_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    27
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    28
#ifndef JVMTI_KERNEL
7408
c04a5c989f26 7003125: precompiled.hpp is included when precompiled headers are not used
stefank
parents: 7397
diff changeset
    29
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    30
#include "classfile/systemDictionary.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    31
#include "jvmtifiles/jvmti.h"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    32
#include "oops/objArrayOop.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    33
#include "prims/jvmtiEnvThreadState.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    34
#include "prims/jvmtiEventController.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    35
#include "prims/jvmtiTrace.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    36
#include "prims/jvmtiUtil.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    37
#include "runtime/stackValueCollection.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    38
#include "runtime/vm_operations.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    39
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
// Forward Declarations
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
class JvmtiBreakpoint;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
class JvmtiBreakpoints;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
///////////////////////////////////////////////////////////////
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
// class GrowableCache, GrowableElement
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
// Used by              : JvmtiBreakpointCache
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
// Used by JVMTI methods: none directly.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
// GrowableCache is a permanent CHeap growable array of <GrowableElement *>
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
// In addition, the GrowableCache maintains a NULL terminated cache array of type address
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
// that's created from the element array using the function:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
//     address GrowableElement::getCacheValue().
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
// Whenever the GrowableArray changes size, the cache array gets recomputed into a new C_HEAP allocated
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
// block of memory. Additionally, every time the cache changes its position in memory, the
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
//    void (*_listener_fun)(void *this_obj, address* cache)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
// gets called with the cache's new address. This gives the user of the GrowableCache a callback
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
// to update its pointer to the address cache.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
class GrowableElement : public CHeapObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
  virtual address getCacheValue()          =0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
  virtual bool equals(GrowableElement* e)  =0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
  virtual bool lessThan(GrowableElement *e)=0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
  virtual GrowableElement *clone()         =0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
  virtual void oops_do(OopClosure* f)      =0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
class GrowableCache VALUE_OBJ_CLASS_SPEC {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
  // Object pointer passed into cache & listener functions.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
  void *_this_obj;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
  // Array of elements in the collection
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
  GrowableArray<GrowableElement *> *_elements;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
  // Parallel array of cached values
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
  address *_cache;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
  // Listener for changes to the _cache field.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
  // Called whenever the _cache field has it's value changed
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
  // (but NOT when cached elements are recomputed).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
  void (*_listener_fun)(void *, address*);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
  static bool equals(void *, GrowableElement *);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
  // recache all elements after size change, notify listener
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
  void recache();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
   GrowableCache();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
   ~GrowableCache();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
  void initialize(void *this_obj, void listener_fun(void *, address*) );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
  // number of elements in the collection
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
  int length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
  // get the value of the index element in the collection
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
  GrowableElement* at(int index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
  // find the index of the element, -1 if it doesn't exist
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
  int find(GrowableElement* e);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
  // append a copy of the element to the end of the collection, notify listener
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
  void append(GrowableElement* e);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
  // insert a copy of the element using lessthan(), notify listener
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
  void insert(GrowableElement* e);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
  // remove the element at index, notify listener
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
  void remove (int index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
  // clear out all elements and release all heap space, notify listener
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
  void clear();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
  // apply f to every element and update the cache
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
  void oops_do(OopClosure* f);
7918
ce1e4ae77aea 7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220)
kamg
parents: 7896
diff changeset
   120
  // update the cache after a full gc
ce1e4ae77aea 7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220)
kamg
parents: 7896
diff changeset
   121
  void gc_epilogue();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
///////////////////////////////////////////////////////////////
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
// class JvmtiBreakpointCache
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
// Used by              : JvmtiBreakpoints
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
// Used by JVMTI methods: none directly.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
// Note   : typesafe wrapper for GrowableCache of JvmtiBreakpoint
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
class JvmtiBreakpointCache : public CHeapObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
  GrowableCache _cache;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
  JvmtiBreakpointCache()  {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
  ~JvmtiBreakpointCache() {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
  void initialize(void *this_obj, void listener_fun(void *, address*) ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
    _cache.initialize(this_obj,listener_fun);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
  int length()                          { return _cache.length(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
  JvmtiBreakpoint& at(int index)        { return (JvmtiBreakpoint&) *(_cache.at(index)); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
  int find(JvmtiBreakpoint& e)          { return _cache.find((GrowableElement *) &e); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
  void append(JvmtiBreakpoint& e)       { _cache.append((GrowableElement *) &e); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
  void remove (int index)               { _cache.remove(index); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
  void clear()                          { _cache.clear(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
  void oops_do(OopClosure* f)           { _cache.oops_do(f); }
7918
ce1e4ae77aea 7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220)
kamg
parents: 7896
diff changeset
   153
  void gc_epilogue()                    { _cache.gc_epilogue(); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
///////////////////////////////////////////////////////////////
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
// class JvmtiBreakpoint
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
// Used by              : JvmtiBreakpoints
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
// Used by JVMTI methods: SetBreakpoint, ClearBreakpoint, ClearAllBreakpoints
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
// Note: Extends GrowableElement for use in a GrowableCache
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
// A JvmtiBreakpoint describes a location (class, method, bci) to break at.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
typedef void (methodOopDesc::*method_action)(int _bci);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
class JvmtiBreakpoint : public GrowableElement {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
  methodOop             _method;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
  int                   _bci;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
  Bytecodes::Code       _orig_bytecode;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
  JvmtiBreakpoint();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
  JvmtiBreakpoint(methodOop m_method, jlocation location);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
  bool equals(JvmtiBreakpoint& bp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
  bool lessThan(JvmtiBreakpoint &bp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
  void copy(JvmtiBreakpoint& bp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
  bool is_valid();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
  address getBcp();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
  void each_method_version_do(method_action meth_act);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
  void set();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
  void clear();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
  void print();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
  methodOop method() { return _method; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
  // GrowableElement implementation
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
  address getCacheValue()         { return getBcp(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
  bool lessThan(GrowableElement* e) { Unimplemented(); return false; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
  bool equals(GrowableElement* e) { return equals((JvmtiBreakpoint&) *e); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
  void oops_do(OopClosure* f)     { f->do_oop((oop *) &_method); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
  GrowableElement *clone()        {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
    JvmtiBreakpoint *bp = new JvmtiBreakpoint();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
    bp->copy(*this);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
    return bp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
///////////////////////////////////////////////////////////////
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
// class VM_ChangeBreakpoints
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
// Used by              : JvmtiBreakpoints
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
// Used by JVMTI methods: none directly.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
// Note: A Helper class.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
// VM_ChangeBreakpoints implements a VM_Operation for ALL modifications to the JvmtiBreakpoints class.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
class VM_ChangeBreakpoints : public VM_Operation {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
  JvmtiBreakpoints* _breakpoints;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
  int               _operation;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
  JvmtiBreakpoint*  _bp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
  enum { SET_BREAKPOINT=0, CLEAR_BREAKPOINT=1, CLEAR_ALL_BREAKPOINT=2 };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
  VM_ChangeBreakpoints(JvmtiBreakpoints* breakpoints, int operation) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
    _breakpoints = breakpoints;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
    _bp = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
    _operation = operation;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
    assert(breakpoints != NULL, "breakpoints != NULL");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
    assert(operation == CLEAR_ALL_BREAKPOINT, "unknown breakpoint operation");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
  VM_ChangeBreakpoints(JvmtiBreakpoints* breakpoints, int operation, JvmtiBreakpoint *bp) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
    _breakpoints = breakpoints;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
    _bp = bp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
    _operation = operation;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
    assert(breakpoints != NULL, "breakpoints != NULL");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
    assert(bp != NULL, "bp != NULL");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
    assert(operation == SET_BREAKPOINT || operation == CLEAR_BREAKPOINT , "unknown breakpoint operation");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
  VMOp_Type type() const { return VMOp_ChangeBreakpoints; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
  void doit();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
  void oops_do(OopClosure* f);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
///////////////////////////////////////////////////////////////
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
// class JvmtiBreakpoints
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
// Used by              : JvmtiCurrentBreakpoints
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
// Used by JVMTI methods: none directly
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
// Note: A Helper class
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
// JvmtiBreakpoints is a GrowableCache of JvmtiBreakpoint.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
// All changes to the GrowableCache occur at a safepoint using VM_ChangeBreakpoints.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
// Because _bps is only modified at safepoints, its possible to always use the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
// cached byte code pointers from _bps without doing any synchronization (see JvmtiCurrentBreakpoints).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
// It would be possible to make JvmtiBreakpoints a static class, but I've made it
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
// CHeap allocated to emphasize its similarity to JvmtiFramePops.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
class JvmtiBreakpoints : public CHeapObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
  JvmtiBreakpointCache _bps;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
  // These should only be used by VM_ChangeBreakpoints
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
  // to insure they only occur at safepoints.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
  // Todo: add checks for safepoint
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
  friend class VM_ChangeBreakpoints;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
  void set_at_safepoint(JvmtiBreakpoint& bp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
  void clear_at_safepoint(JvmtiBreakpoint& bp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
  void clearall_at_safepoint();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
  static void do_element(GrowableElement *e);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
  JvmtiBreakpoints(void listener_fun(void *, address *));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
  ~JvmtiBreakpoints();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
  int length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
  void oops_do(OopClosure* f);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
  void print();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
  int  set(JvmtiBreakpoint& bp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
  int  clear(JvmtiBreakpoint& bp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
  void clearall_in_class_at_safepoint(klassOop klass);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
  void clearall();
7918
ce1e4ae77aea 7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220)
kamg
parents: 7896
diff changeset
   288
  void gc_epilogue();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
///////////////////////////////////////////////////////////////
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
// class JvmtiCurrentBreakpoints
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
// A static wrapper class for the JvmtiBreakpoints that provides:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
// 1. a fast inlined function to check if a byte code pointer is a breakpoint (is_breakpoint).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
// 2. a function for lazily creating the JvmtiBreakpoints class (this is not strictly necessary,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
//    but I'm copying the code from JvmtiThreadState which needs to lazily initialize
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
//    JvmtiFramePops).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
// 3. An oops_do entry point for GC'ing the breakpoint array.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
class JvmtiCurrentBreakpoints : public AllStatic {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
  // Current breakpoints, lazily initialized by get_jvmti_breakpoints();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
  static JvmtiBreakpoints *_jvmti_breakpoints;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
  // NULL terminated cache of byte-code pointers corresponding to current breakpoints.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
  // Updated only at safepoints (with listener_fun) when the cache is moved.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
  // It exists only to make is_breakpoint fast.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
  static address          *_breakpoint_list;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
  static inline void set_breakpoint_list(address *breakpoint_list) { _breakpoint_list = breakpoint_list; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
  static inline address *get_breakpoint_list()                     { return _breakpoint_list; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
  // Listener for the GrowableCache in _jvmti_breakpoints, updates _breakpoint_list.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
  static void listener_fun(void *this_obj, address *cache);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
  static void initialize();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
  static void destroy();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
  // lazily create _jvmti_breakpoints and _breakpoint_list
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
  static JvmtiBreakpoints& get_jvmti_breakpoints();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
  // quickly test whether the bcp matches a cached breakpoint in the list
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
  static inline bool is_breakpoint(address bcp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
  static void oops_do(OopClosure* f);
7918
ce1e4ae77aea 7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220)
kamg
parents: 7896
diff changeset
   332
  static void gc_epilogue();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
// quickly test whether the bcp matches a cached breakpoint in the list
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
bool JvmtiCurrentBreakpoints::is_breakpoint(address bcp) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
    address *bps = get_breakpoint_list();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
    if (bps == NULL) return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
    for ( ; (*bps) != NULL; bps++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
      if ((*bps) == bcp) return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
    return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
///////////////////////////////////////////////////////////////
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
// The get/set local operations must only be done by the VM thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
// because the interpreter version needs to access oop maps, which can
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
// only safely be done by the VM thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
// I'm told that in 1.5 oop maps are now protected by a lock and
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
// we could get rid of the VM op
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
// However if the VM op is removed then the target thread must
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
// be suspended AND a lock will be needed to prevent concurrent
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
// setting of locals to the same java thread. This lock is needed
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
// to prevent compiledVFrames from trying to add deferred updates
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
// to the thread simultaneously.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
class VM_GetOrSetLocal : public VM_Operation {
7444
be338e543a57 7004582: Add GetThisObject() function to JVMTI 1.2
kamg
parents: 7408
diff changeset
   359
 protected:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   360
  JavaThread* _thread;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   361
  JavaThread* _calling_thread;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
  jint        _depth;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
  jint        _index;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
  BasicType   _type;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   365
  jvalue      _value;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   366
  javaVFrame* _jvf;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
  bool        _set;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
7444
be338e543a57 7004582: Add GetThisObject() function to JVMTI 1.2
kamg
parents: 7408
diff changeset
   369
  // It is possible to get the receiver out of a non-static native wrapper
be338e543a57 7004582: Add GetThisObject() function to JVMTI 1.2
kamg
parents: 7408
diff changeset
   370
  // frame.  Use VM_GetReceiver to do this.
be338e543a57 7004582: Add GetThisObject() function to JVMTI 1.2
kamg
parents: 7408
diff changeset
   371
  virtual bool getting_receiver() const { return false; }
be338e543a57 7004582: Add GetThisObject() function to JVMTI 1.2
kamg
parents: 7408
diff changeset
   372
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
  jvmtiError  _result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
  vframe* get_vframe();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
  javaVFrame* get_java_vframe();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
  bool check_slot_type(javaVFrame* vf);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
  // Constructor for non-object getter
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
  VM_GetOrSetLocal(JavaThread* thread, jint depth, jint index, BasicType type);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   382
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
  // Constructor for object or non-object setter
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
  VM_GetOrSetLocal(JavaThread* thread, jint depth, jint index, BasicType type, jvalue value);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
  // Constructor for object getter
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
  VM_GetOrSetLocal(JavaThread* thread, JavaThread* calling_thread, jint depth,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
                   int index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
  VMOp_Type type() const { return VMOp_GetOrSetLocal; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
  jvalue value()         { return _value; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
  jvmtiError result()    { return _result; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   393
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
  bool doit_prologue();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
  void doit();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
  bool allow_nested_vm_operations() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
  const char* name() const                       { return "get/set locals"; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
489c9b5090e2 Initial load
duke
parents:
diff changeset
   399
  // Check that the klass is assignable to a type with the given signature.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
  static bool is_assignable(const char* ty_sign, Klass* klass, Thread* thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
7444
be338e543a57 7004582: Add GetThisObject() function to JVMTI 1.2
kamg
parents: 7408
diff changeset
   403
class VM_GetReceiver : public VM_GetOrSetLocal {
be338e543a57 7004582: Add GetThisObject() function to JVMTI 1.2
kamg
parents: 7408
diff changeset
   404
 protected:
be338e543a57 7004582: Add GetThisObject() function to JVMTI 1.2
kamg
parents: 7408
diff changeset
   405
  virtual bool getting_receiver() const { return true; }
be338e543a57 7004582: Add GetThisObject() function to JVMTI 1.2
kamg
parents: 7408
diff changeset
   406
be338e543a57 7004582: Add GetThisObject() function to JVMTI 1.2
kamg
parents: 7408
diff changeset
   407
 public:
be338e543a57 7004582: Add GetThisObject() function to JVMTI 1.2
kamg
parents: 7408
diff changeset
   408
  VM_GetReceiver(JavaThread* thread, JavaThread* calling_thread, jint depth);
be338e543a57 7004582: Add GetThisObject() function to JVMTI 1.2
kamg
parents: 7408
diff changeset
   409
  const char* name() const                       { return "get receiver"; }
be338e543a57 7004582: Add GetThisObject() function to JVMTI 1.2
kamg
parents: 7408
diff changeset
   410
};
be338e543a57 7004582: Add GetThisObject() function to JVMTI 1.2
kamg
parents: 7408
diff changeset
   411
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   412
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
///////////////////////////////////////////////////////////////
489c9b5090e2 Initial load
duke
parents:
diff changeset
   414
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
// class JvmtiSuspendControl
489c9b5090e2 Initial load
duke
parents:
diff changeset
   416
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
// Convenience routines for suspending and resuming threads.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
// All attempts by JVMTI to suspend and resume threads must go through the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
// JvmtiSuspendControl interface.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
// methods return true if successful
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
class JvmtiSuspendControl : public AllStatic {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   425
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
  // suspend the thread, taking it to a safepoint
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
  static bool suspend(JavaThread *java_thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
  // resume the thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
  static bool resume(JavaThread *java_thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   430
489c9b5090e2 Initial load
duke
parents:
diff changeset
   431
  static void print();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   432
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   433
7408
c04a5c989f26 7003125: precompiled.hpp is included when precompiled headers are not used
stefank
parents: 7397
diff changeset
   434
#endif // !JVMTI_KERNEL
c04a5c989f26 7003125: precompiled.hpp is included when precompiled headers are not used
stefank
parents: 7397
diff changeset
   435
8110
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   436
/**
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   437
 * When a thread (such as the compiler thread or VM thread) cannot post a
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   438
 * JVMTI event itself because the event needs to be posted from a Java
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   439
 * thread, then it can defer the event to the Service thread for posting.
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   440
 * The information needed to post the event is encapsulated into this class
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   441
 * and then enqueued onto the JvmtiDeferredEventQueue, where the Service
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   442
 * thread will pick it up and post it.
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   443
 *
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   444
 * This is currently only used for posting compiled-method-load and unload
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   445
 * events, which we don't want posted from the compiler thread.
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   446
 */
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   447
class JvmtiDeferredEvent VALUE_OBJ_CLASS_SPEC {
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   448
  friend class JvmtiDeferredEventQueue;
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   449
 private:
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   450
  typedef enum {
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   451
    TYPE_NONE,
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   452
    TYPE_COMPILED_METHOD_LOAD,
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   453
    TYPE_COMPILED_METHOD_UNLOAD,
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   454
    TYPE_FLUSH // pseudo-event used to implement flush_queue()
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   455
  } Type;
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   456
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   457
  Type _type;
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   458
  union {
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   459
    nmethod* compiled_method_load;
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   460
    struct {
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   461
      jmethodID method_id;
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   462
      const void* code_begin;
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   463
    } compiled_method_unload;
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   464
    int* flush_state_addr;
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   465
  } _event_data;
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   466
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   467
  JvmtiDeferredEvent(Type t) : _type(t) {}
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   468
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   469
  void set_compiled_method_load(nmethod* nm) {
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   470
    assert(_type == TYPE_COMPILED_METHOD_LOAD, "must be");
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   471
    _event_data.compiled_method_load = nm;
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   472
  }
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   473
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   474
  nmethod* compiled_method_load() const {
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   475
    assert(_type == TYPE_COMPILED_METHOD_LOAD, "must be");
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   476
    return _event_data.compiled_method_load;
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   477
  }
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   478
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   479
  void set_compiled_method_unload(jmethodID id, const void* code) {
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   480
    assert(_type == TYPE_COMPILED_METHOD_UNLOAD, "must be");
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   481
    _event_data.compiled_method_unload.method_id = id;
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   482
    _event_data.compiled_method_unload.code_begin = code;
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   483
  }
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   484
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   485
  jmethodID compiled_method_unload_method_id() const {
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   486
    assert(_type == TYPE_COMPILED_METHOD_UNLOAD, "must be");
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   487
    return _event_data.compiled_method_unload.method_id;
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   488
  }
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   489
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   490
  const void* compiled_method_unload_code_begin() const {
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   491
    assert(_type == TYPE_COMPILED_METHOD_UNLOAD, "must be");
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   492
    return _event_data.compiled_method_unload.code_begin;
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   493
  }
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   494
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   495
  bool is_flush_event() const { return _type == TYPE_FLUSH; }
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   496
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   497
  int* flush_state_addr() const {
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   498
    assert(is_flush_event(), "must be");
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   499
    return _event_data.flush_state_addr;
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   500
  }
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   501
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   502
  void set_flush_state_addr(int* flag) {
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   503
    assert(is_flush_event(), "must be");
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   504
    _event_data.flush_state_addr = flag;
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   505
  }
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   506
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   507
 public:
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   508
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   509
  JvmtiDeferredEvent() : _type(TYPE_NONE) {}
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   510
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   511
  // Factory methods
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   512
  static JvmtiDeferredEvent compiled_method_load_event(nmethod* nm)
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   513
    KERNEL_RETURN_(JvmtiDeferredEvent());
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   514
  static JvmtiDeferredEvent compiled_method_unload_event(
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   515
      jmethodID id, const void* code) KERNEL_RETURN_(JvmtiDeferredEvent());
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   516
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   517
  // Actually posts the event.
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   518
  void post() KERNEL_RETURN;
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   519
};
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   520
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   521
/**
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   522
 * Events enqueued on this queue wake up the Service thread which dequeues
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   523
 * and posts the events.  The Service_lock is required to be held
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   524
 * when operating on the queue (except for the "pending" events).
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   525
 */
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   526
class JvmtiDeferredEventQueue : AllStatic {
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   527
  friend class JvmtiDeferredEvent;
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   528
 private:
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   529
  class QueueNode : public CHeapObj {
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   530
   private:
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   531
    JvmtiDeferredEvent _event;
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   532
    QueueNode* _next;
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   533
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   534
   public:
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   535
    QueueNode(const JvmtiDeferredEvent& event)
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   536
      : _event(event), _next(NULL) {}
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   537
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   538
    const JvmtiDeferredEvent& event() const { return _event; }
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   539
    QueueNode* next() const { return _next; }
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   540
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   541
    void set_next(QueueNode* next) { _next = next; }
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   542
  };
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   543
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   544
  static QueueNode* _queue_head;             // Hold Service_lock to access
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   545
  static QueueNode* _queue_tail;             // Hold Service_lock to access
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   546
  static volatile QueueNode* _pending_list;  // Uses CAS for read/update
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   547
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   548
  // Transfers events from the _pending_list to the _queue.
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   549
  static void process_pending_events() KERNEL_RETURN;
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   550
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   551
  static void flush_complete(int* flush_state) KERNEL_RETURN;
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   552
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   553
 public:
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   554
  // Must be holding Service_lock when calling these
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   555
  static bool has_events() KERNEL_RETURN_(false);
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   556
  static void enqueue(const JvmtiDeferredEvent& event) KERNEL_RETURN;
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   557
  static JvmtiDeferredEvent dequeue() KERNEL_RETURN_(JvmtiDeferredEvent());
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   558
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   559
  // This call blocks until all events enqueued prior to this call
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   560
  // have been posted.  The Service_lock is acquired and waited upon.
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   561
  //
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   562
  // Implemented by creating a "flush" event and placing it in the queue.
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   563
  // When the flush event is "posted" it will call flush_complete(), which
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   564
  // will release the caller.
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   565
  //
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   566
  // Can be called by any thread (maybe even the service thread itself).
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   567
  // Not necessary for the caller to be a JavaThread.
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   568
  static void flush_queue(Thread* current) KERNEL_RETURN;
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   569
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   570
  // Used to enqueue events without using a lock, for times (such as during
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   571
  // safepoint) when we can't or don't want to lock the Service_lock.
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   572
  //
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   573
  // Events will be held off to the side until there's a call to
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   574
  // dequeue(), enqueue(), or process_pending_events() (all of which require
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   575
  // the holding of the Service_lock), and will be enqueued at that time.
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   576
  static void add_pending_event(const JvmtiDeferredEvent&) KERNEL_RETURN;
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   577
};
c992c8d52344 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents: 7918
diff changeset
   578
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   579
// Utility macro that checks for NULL pointers:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   580
#define NULL_CHECK(X, Y) if ((X) == NULL) { return (Y); }
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
   581
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
   582
#endif // SHARE_VM_PRIMS_JVMTIIMPL_HPP