/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp

Bug Summary

File:	jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp
Warning:	line 1048, column 5 Null pointer passed to 1st parameter expecting 'nonnull'

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name jvmtiEnvBase.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -mthread-model posix -fno-delete-null-pointer-checks -mframe-pointer=all -relaxed-aliasing -fmath-errno -fno-rounding-math -masm-verbose -mconstructor-aliases -munwind-tables -target-cpu x86-64 -dwarf-column-info -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib/llvm-10/lib/clang/10.0.0 -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/hotspot/variant-server/libjvm/objs/precompiled -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -D __STDC_CONSTANT_MACROS -D _GNU_SOURCE -D _REENTRANT -D LIBC=gnu -D LINUX -D VM_LITTLE_ENDIAN -D _LP64=1 -D ASSERT -D CHECK_UNHANDLED_OOPS -D TARGET_ARCH_x86 -D INCLUDE_SUFFIX_OS=_linux -D INCLUDE_SUFFIX_CPU=_x86 -D INCLUDE_SUFFIX_COMPILER=_gcc -D TARGET_COMPILER_gcc -D AMD64 -D HOTSPOT_LIB_ARCH="amd64" -D COMPILER1 -D COMPILER2 -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/hotspot/variant-server/gensrc/adfiles -I /home/daniel/Projects/java/jdk/src/hotspot/share -I /home/daniel/Projects/java/jdk/src/hotspot/os/linux -I /home/daniel/Projects/java/jdk/src/hotspot/os/posix -I /home/daniel/Projects/java/jdk/src/hotspot/cpu/x86 -I /home/daniel/Projects/java/jdk/src/hotspot/os_cpu/linux_x86 -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/hotspot/variant-server/gensrc -I /home/daniel/Projects/java/jdk/src/hotspot/share/precompiled -I /home/daniel/Projects/java/jdk/src/hotspot/share/include -I /home/daniel/Projects/java/jdk/src/hotspot/os/posix/include -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/support/modules_include/java.base -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/support/modules_include/java.base/linux -I /home/daniel/Projects/java/jdk/src/java.base/share/native/libjimage -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/hotspot/variant-server/gensrc/adfiles -I /home/daniel/Projects/java/jdk/src/hotspot/share -I /home/daniel/Projects/java/jdk/src/hotspot/os/linux -I /home/daniel/Projects/java/jdk/src/hotspot/os/posix -I /home/daniel/Projects/java/jdk/src/hotspot/cpu/x86 -I /home/daniel/Projects/java/jdk/src/hotspot/os_cpu/linux_x86 -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/hotspot/variant-server/gensrc -D _FORTIFY_SOURCE=2 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.5.0/../../../../include/c++/7.5.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.5.0/../../../../include/x86_64-linux-gnu/c++/7.5.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.5.0/../../../../include/x86_64-linux-gnu/c++/7.5.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.5.0/../../../../include/c++/7.5.0/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-10/lib/clang/10.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O3 -Wno-format-zero-length -Wno-unused-parameter -Wno-unused -Wno-parentheses -Wno-comment -Wno-unknown-pragmas -Wno-address -Wno-delete-non-virtual-dtor -Wno-char-subscripts -Wno-array-bounds -Wno-int-in-bool-context -Wno-ignored-qualifiers -Wno-missing-field-initializers -Wno-implicit-fallthrough -Wno-empty-body -Wno-strict-overflow -Wno-sequence-point -Wno-maybe-uninitialized -Wno-misleading-indentation -Wno-cast-function-type -Wno-shift-negative-value -std=c++14 -fdeprecated-macro -fdebug-compilation-dir /home/daniel/Projects/java/jdk/make/hotspot -ferror-limit 19 -fmessage-length 0 -fvisibility hidden -stack-protector 1 -fno-rtti -fgnuc-version=4.2.1 -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -faddrsig -o /home/daniel/Projects/java/scan/2021-12-21-193737-8510-1 -x c++ /home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp

/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp

→

1/*
* Copyright (c) 2003, 2021, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*
*/

25#include "precompiled.hpp"
26#include "classfile/classLoaderDataGraph.hpp"
27#include "classfile/javaClasses.hpp"
28#include "classfile/moduleEntry.hpp"
29#include "jvmtifiles/jvmtiEnv.hpp"
30#include "memory/iterator.hpp"
31#include "memory/resourceArea.hpp"
32#include "oops/klass.inline.hpp"
33#include "oops/objArrayKlass.hpp"
34#include "oops/objArrayOop.hpp"
35#include "oops/oop.inline.hpp"
36#include "oops/oopHandle.inline.hpp"
37#include "prims/jvmtiEnvBase.hpp"
38#include "prims/jvmtiEventController.inline.hpp"
39#include "prims/jvmtiExtensions.hpp"
40#include "prims/jvmtiImpl.hpp"
41#include "prims/jvmtiManageCapabilities.hpp"
42#include "prims/jvmtiTagMap.hpp"
43#include "prims/jvmtiThreadState.inline.hpp"
44#include "runtime/deoptimization.hpp"
45#include "runtime/frame.inline.hpp"
46#include "runtime/handles.inline.hpp"
47#include "runtime/interfaceSupport.inline.hpp"
48#include "runtime/jfieldIDWorkaround.hpp"
49#include "runtime/jniHandles.inline.hpp"
50#include "runtime/objectMonitor.inline.hpp"
51#include "runtime/osThread.hpp"
52#include "runtime/signature.hpp"
53#include "runtime/thread.inline.hpp"
54#include "runtime/threadSMR.hpp"
55#include "runtime/vframe.inline.hpp"
56#include "runtime/vframe_hp.hpp"
57#include "runtime/vmThread.hpp"
58#include "runtime/vmOperations.hpp"


61///////////////////////////////////////////////////////////////
62//
63// JvmtiEnvBase
64//

66JvmtiEnvBase* JvmtiEnvBase::_head_environment = NULL__null;

68bool JvmtiEnvBase::_globally_initialized = false;
69volatile bool JvmtiEnvBase::_needs_clean_up = false;

71jvmtiPhase JvmtiEnvBase::_phase = JVMTI_PHASE_PRIMORDIAL;

73volatile int JvmtiEnvBase::_dying_thread_env_iteration_count = 0;

75extern jvmtiInterface_1_ jvmti_Interface;
76extern jvmtiInterface_1_ jvmtiTrace_Interface;


79// perform initializations that must occur before any JVMTI environments
80// are released but which should only be initialized once (no matter
81// how many environments are created).
82void
83JvmtiEnvBase::globally_initialize() {
assert(Threads::number_of_threads() == 0 || JvmtiThreadState_lock->is_locked(), "sanity check")do { if (!(Threads::number_of_threads() == 0 || JvmtiThreadState_lock
->is_locked())) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp"
, 84, "assert(" "Threads::number_of_threads() == 0 || JvmtiThreadState_lock->is_locked()"
 ") failed", "sanity check"); ::breakpoint(); } } while (0);
assert(_globally_initialized == false, "bad call")do { if (!(_globally_initialized == false)) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp"
, 85, "assert(" "_globally_initialized == false" ") failed", "bad call"
); ::breakpoint(); } } while (0);

JvmtiManageCapabilities::initialize();

// register extension functions and events
JvmtiExtensions::register_extensions();

92#ifdef JVMTI_TRACE
JvmtiTrace::initialize();
94#endif

_globally_initialized = true;
97}


100void
101JvmtiEnvBase::initialize() {
assert(Threads::number_of_threads() == 0 || JvmtiThreadState_lock->is_locked(), "sanity check")do { if (!(Threads::number_of_threads() == 0 || JvmtiThreadState_lock
->is_locked())) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp"
, 102, "assert(" "Threads::number_of_threads() == 0 || JvmtiThreadState_lock->is_locked()"
 ") failed", "sanity check"); ::breakpoint(); } } while (0);

// Add this environment to the end of the environment list (order is important)
{
  // This block of code must not contain any safepoints, as list deallocation
  // (which occurs at a safepoint) cannot occur simultaneously with this list
  // addition.  Note: NoSafepointVerifier cannot, currently, be used before
  // threads exist.
  JvmtiEnvIterator it;
  JvmtiEnvBase *previous_env = NULL__null;
  for (JvmtiEnvBase* env = it.first(); env != NULL__null; env = it.next(env)) {
    previous_env = env;
  }
  if (previous_env == NULL__null) {
    _head_environment = this;
  } else {
    previous_env->set_next_environment(this);
  }
}

if (_globally_initialized == false) {
  globally_initialize();
}
125}

127jvmtiPhase
128JvmtiEnvBase::phase() {
// For the JVMTI environments possessed the can_generate_early_vmstart:
//   replace JVMTI_PHASE_PRIMORDIAL with JVMTI_PHASE_START
if (_phase == JVMTI_PHASE_PRIMORDIAL &&
    JvmtiExport::early_vmstart_recorded() &&
    early_vmstart_env()) {
  return JVMTI_PHASE_START;
}
return _phase; // Normal case
137}

139bool
140JvmtiEnvBase::is_valid() {
jint value = 0;

// This object might not be a JvmtiEnvBase so we can't assume
// the _magic field is properly aligned. Get the value in a safe
// way and then check against JVMTI_MAGIC.

switch (sizeof(_magic)) {
case 2:
  value = Bytes::get_native_u2((address)&_magic);
  break;

case 4:
  value = Bytes::get_native_u4((address)&_magic);
  break;

case 8:
  value = Bytes::get_native_u8((address)&_magic);
  break;

default:
  guarantee(false, "_magic field is an unexpected size")do { if (!(false)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp"
, 161, "guarantee(" "false" ") failed", "_magic field is an unexpected size"
); ::breakpoint(); } } while (0);
}

return value == JVMTI_MAGIC;
165}


168bool
169JvmtiEnvBase::use_version_1_0_semantics() {
int major, minor, micro;

JvmtiExport::decode_version_values(_version, &major, &minor, &micro);
return major == 1 && minor == 0;  // micro version doesn't matter here
174}


177bool
178JvmtiEnvBase::use_version_1_1_semantics() {
int major, minor, micro;

JvmtiExport::decode_version_values(_version, &major, &minor, &micro);
return major == 1 && minor == 1;  // micro version doesn't matter here
183}

185bool
186JvmtiEnvBase::use_version_1_2_semantics() {
int major, minor, micro;

JvmtiExport::decode_version_values(_version, &major, &minor, &micro);
return major == 1 && minor == 2;  // micro version doesn't matter here
191}


194JvmtiEnvBase::JvmtiEnvBase(jint version) : _env_event_enable() {
_version = version;
_env_local_storage = NULL__null;
_tag_map = NULL__null;
_native_method_prefix_count = 0;
_native_method_prefixes = NULL__null;
_next = NULL__null;
_class_file_load_hook_ever_enabled = false;

// Moot since ClassFileLoadHook not yet enabled.
// But "true" will give a more predictable ClassFileLoadHook behavior
// for environment creation during ClassFileLoadHook.
_is_retransformable = true;

// all callbacks initially NULL
memset(&_event_callbacks,0,sizeof(jvmtiEventCallbacks));

// all capabilities initially off
memset(&_current_capabilities, 0, sizeof(_current_capabilities));

// all prohibited capabilities initially off
memset(&_prohibited_capabilities, 0, sizeof(_prohibited_capabilities));

_magic = JVMTI_MAGIC;

JvmtiEventController::env_initialize((JvmtiEnv*)this);

221#ifdef JVMTI_TRACE
_jvmti_external.functions = TraceJVMTI != NULL__null ? &jvmtiTrace_Interface : &jvmti_Interface;
223#else
_jvmti_external.functions = &jvmti_Interface;
225#endif
226}


229void
230JvmtiEnvBase::dispose() {

232#ifdef JVMTI_TRACE
JvmtiTrace::shutdown();
234#endif

// Dispose of event info and let the event controller call us back
// in a locked state (env_dispose, below)
JvmtiEventController::env_dispose(this);
239}

241void
242JvmtiEnvBase::env_dispose() {
assert(Threads::number_of_threads() == 0 || JvmtiThreadState_lock->is_locked(), "sanity check")do { if (!(Threads::number_of_threads() == 0 || JvmtiThreadState_lock
->is_locked())) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp"
, 243, "assert(" "Threads::number_of_threads() == 0 || JvmtiThreadState_lock->is_locked()"
 ") failed", "sanity check"); ::breakpoint(); } } while (0);

// We have been entered with all events disabled on this environment.
// A race to re-enable events (by setting callbacks) is prevented by
// checking for a valid environment when setting callbacks (while
// holding the JvmtiThreadState_lock).

// Mark as invalid.
_magic = DISPOSED_MAGIC;

// Relinquish all capabilities.
jvmtiCapabilities *caps = get_capabilities();
JvmtiManageCapabilities::relinquish_capabilities(caps, caps, caps);

// Same situation as with events (see above)
set_native_method_prefixes(0, NULL__null);

JvmtiTagMap* tag_map_to_clear = tag_map_acquire();
// A tag map can be big, clear it now to save memory until
// the destructor runs.
if (tag_map_to_clear != NULL__null) {
  tag_map_to_clear->clear();
}

_needs_clean_up = true;
268}


271JvmtiEnvBase::~JvmtiEnvBase() {
assert(SafepointSynchronize::is_at_safepoint(), "sanity check")do { if (!(SafepointSynchronize::is_at_safepoint())) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp"
, 272, "assert(" "SafepointSynchronize::is_at_safepoint()" ") failed"
, "sanity check"); ::breakpoint(); } } while (0);

// There is a small window of time during which the tag map of a
// disposed environment could have been reallocated.
// Make sure it is gone.
JvmtiTagMap* tag_map_to_deallocate = _tag_map;
set_tag_map(NULL__null);
// A tag map can be big, deallocate it now
if (tag_map_to_deallocate != NULL__null) {
  delete tag_map_to_deallocate;
}

_magic = BAD_MAGIC;
285}


288void
289JvmtiEnvBase::periodic_clean_up() {
assert(SafepointSynchronize::is_at_safepoint(), "sanity check")do { if (!(SafepointSynchronize::is_at_safepoint())) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp"
, 290, "assert(" "SafepointSynchronize::is_at_safepoint()" ") failed"
, "sanity check"); ::breakpoint(); } } while (0);

// JvmtiEnvBase reference is saved in JvmtiEnvThreadState. So
// clean up JvmtiThreadState before deleting JvmtiEnv pointer.
JvmtiThreadState::periodic_clean_up();

// Unlink all invalid environments from the list of environments
// and deallocate them
JvmtiEnvIterator it;
JvmtiEnvBase* previous_env = NULL__null;
JvmtiEnvBase* env = it.first();
while (env != NULL__null) {
  if (env->is_valid()) {
    previous_env = env;
    env = it.next(env);
  } else {
    // This one isn't valid, remove it from the list and deallocate it
    JvmtiEnvBase* defunct_env = env;
    env = it.next(env);
    if (previous_env == NULL__null) {
      _head_environment = env;
    } else {
      previous_env->set_next_environment(env);
    }
    delete defunct_env;
  }
}

318}


321void
322JvmtiEnvBase::check_for_periodic_clean_up() {
assert(SafepointSynchronize::is_at_safepoint(), "sanity check")do { if (!(SafepointSynchronize::is_at_safepoint())) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp"
, 323, "assert(" "SafepointSynchronize::is_at_safepoint()" ") failed"
, "sanity check"); ::breakpoint(); } } while (0);

class ThreadInsideIterationClosure: public ThreadClosure {
 private:
  bool _inside;
 public:
  ThreadInsideIterationClosure() : _inside(false) {};

  void do_thread(Thread* thread) {
    _inside |= thread->is_inside_jvmti_env_iteration();
  }

  bool is_inside_jvmti_env_iteration() {
    return _inside;
  }
};

if (_needs_clean_up) {
  // Check if we are currently iterating environment,
  // deallocation should not occur if we are
  ThreadInsideIterationClosure tiic;
  Threads::threads_do(&tiic);
  if (!tiic.is_inside_jvmti_env_iteration() &&
           !is_inside_dying_thread_env_iteration()) {
    _needs_clean_up = false;
    JvmtiEnvBase::periodic_clean_up();
  }
}
351}


354void
355JvmtiEnvBase::record_first_time_class_file_load_hook_enabled() {
assert(Threads::number_of_threads() == 0 || JvmtiThreadState_lock->is_locked(),do { if (!(Threads::number_of_threads() == 0 || JvmtiThreadState_lock
->is_locked())) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp"
, 357, "assert(" "Threads::number_of_threads() == 0 || JvmtiThreadState_lock->is_locked()"
 ") failed", "sanity check"); ::breakpoint(); } } while (0)
       "sanity check")do { if (!(Threads::number_of_threads() == 0 || JvmtiThreadState_lock
->is_locked())) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp"
, 357, "assert(" "Threads::number_of_threads() == 0 || JvmtiThreadState_lock->is_locked()"
 ") failed", "sanity check"); ::breakpoint(); } } while (0);

if (!_class_file_load_hook_ever_enabled) {
  _class_file_load_hook_ever_enabled = true;

  if (get_capabilities()->can_retransform_classes) {
    _is_retransformable = true;
  } else {
    _is_retransformable = false;

    // cannot add retransform capability after ClassFileLoadHook has been enabled
    get_prohibited_capabilities()->can_retransform_classes = 1;
  }
}
371}


374void
375JvmtiEnvBase::record_class_file_load_hook_enabled() {
if (!_class_file_load_hook_ever_enabled) {
  if (Threads::number_of_threads() == 0) {
    record_first_time_class_file_load_hook_enabled();
  } else {
    MutexLocker mu(JvmtiThreadState_lock);
    record_first_time_class_file_load_hook_enabled();
  }
}
384}


387jvmtiError
388JvmtiEnvBase::set_native_method_prefixes(jint prefix_count, char** prefixes) {
assert(Threads::number_of_threads() == 0 || JvmtiThreadState_lock->is_locked(),do { if (!(Threads::number_of_threads() == 0 || JvmtiThreadState_lock
->is_locked())) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp"
, 390, "assert(" "Threads::number_of_threads() == 0 || JvmtiThreadState_lock->is_locked()"
 ") failed", "sanity check"); ::breakpoint(); } } while (0)
       "sanity check")do { if (!(Threads::number_of_threads() == 0 || JvmtiThreadState_lock
->is_locked())) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp"
, 390, "assert(" "Threads::number_of_threads() == 0 || JvmtiThreadState_lock->is_locked()"
 ") failed", "sanity check"); ::breakpoint(); } } while (0);

int old_prefix_count = get_native_method_prefix_count();
char **old_prefixes = get_native_method_prefixes();

// allocate and install the new prefixex
if (prefix_count == 0 || !is_valid()) {
  _native_method_prefix_count = 0;
  _native_method_prefixes = NULL__null;
} else {
  // there are prefixes, allocate an array to hold them, and fill it
  char** new_prefixes = (char**)os::malloc((prefix_count) * sizeof(char*), mtInternal);
  if (new_prefixes == NULL__null) {
    return JVMTI_ERROR_OUT_OF_MEMORY;
  }
  for (int i = 0; i < prefix_count; i++) {
    char* prefix = prefixes[i];
    if (prefix == NULL__null) {
      for (int j = 0; j < (i-1); j++) {
        os::free(new_prefixes[j]);
      }
      os::free(new_prefixes);
      return JVMTI_ERROR_NULL_POINTER;
    }
    prefix = os::strdup(prefixes[i]);
    if (prefix == NULL__null) {
      for (int j = 0; j < (i-1); j++) {
        os::free(new_prefixes[j]);
      }
      os::free(new_prefixes);
      return JVMTI_ERROR_OUT_OF_MEMORY;
    }
    new_prefixes[i] = prefix;
  }
  _native_method_prefix_count = prefix_count;
  _native_method_prefixes = new_prefixes;
}

// now that we know the new prefixes have been successfully installed we can
// safely remove the old ones
if (old_prefix_count != 0) {
  for (int i = 0; i < old_prefix_count; i++) {
    os::free(old_prefixes[i]);
  }
  os::free(old_prefixes);
}

return JVMTI_ERROR_NONE;
438}


441// Collect all the prefixes which have been set in any JVM TI environments
442// by the SetNativeMethodPrefix(es) functions.  Be sure to maintain the
443// order of environments and the order of prefixes within each environment.
444// Return in a resource allocated array.
445char**
446JvmtiEnvBase::get_all_native_method_prefixes(int* count_ptr) {
assert(Threads::number_of_threads() == 0 ||do { if (!(Threads::number_of_threads() == 0 || SafepointSynchronize
::is_at_safepoint() || JvmtiThreadState_lock->is_locked())
) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp"
, 450, "assert(" "Threads::number_of_threads() == 0 || SafepointSynchronize::is_at_safepoint() || JvmtiThreadState_lock->is_locked()"
 ") failed", "sanity check"); ::breakpoint(); } } while (0)
       SafepointSynchronize::is_at_safepoint() ||do { if (!(Threads::number_of_threads() == 0 || SafepointSynchronize
::is_at_safepoint() || JvmtiThreadState_lock->is_locked())
) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp"
, 450, "assert(" "Threads::number_of_threads() == 0 || SafepointSynchronize::is_at_safepoint() || JvmtiThreadState_lock->is_locked()"
 ") failed", "sanity check"); ::breakpoint(); } } while (0)
       JvmtiThreadState_lock->is_locked(),do { if (!(Threads::number_of_threads() == 0 || SafepointSynchronize
::is_at_safepoint() || JvmtiThreadState_lock->is_locked())
) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp"
, 450, "assert(" "Threads::number_of_threads() == 0 || SafepointSynchronize::is_at_safepoint() || JvmtiThreadState_lock->is_locked()"
 ") failed", "sanity check"); ::breakpoint(); } } while (0)
       "sanity check")do { if (!(Threads::number_of_threads() == 0 || SafepointSynchronize
::is_at_safepoint() || JvmtiThreadState_lock->is_locked())
) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp"
, 450, "assert(" "Threads::number_of_threads() == 0 || SafepointSynchronize::is_at_safepoint() || JvmtiThreadState_lock->is_locked()"
 ") failed", "sanity check"); ::breakpoint(); } } while (0);

int total_count = 0;
GrowableArray<char*>* prefix_array =new GrowableArray<char*>(5);

JvmtiEnvIterator it;
for (JvmtiEnvBase* env = it.first(); env != NULL__null; env = it.next(env)) {
  int prefix_count = env->get_native_method_prefix_count();
  char** prefixes = env->get_native_method_prefixes();
  for (int j = 0; j < prefix_count; j++) {
    // retrieve a prefix and so that it is safe against asynchronous changes
    // copy it into the resource area
    char* prefix = prefixes[j];
    char* prefix_copy = NEW_RESOURCE_ARRAY(char, strlen(prefix)+1)(char*) resource_allocate_bytes((strlen(prefix)+1) * sizeof(char
));
    strcpy(prefix_copy, prefix);
    prefix_array->at_put_grow(total_count++, prefix_copy);
  }
}

char** all_prefixes = NEW_RESOURCE_ARRAY(char*, total_count)(char**) resource_allocate_bytes((total_count) * sizeof(char*
));
char** p = all_prefixes;
for (int i = 0; i < total_count; ++i) {
  *p++ = prefix_array->at(i);
}
*count_ptr = total_count;
return all_prefixes;
476}

478void
479JvmtiEnvBase::set_event_callbacks(const jvmtiEventCallbacks* callbacks,
                                             jint size_of_callbacks) {
assert(Threads::number_of_threads() == 0 || JvmtiThreadState_lock->is_locked(), "sanity check")do { if (!(Threads::number_of_threads() == 0 || JvmtiThreadState_lock
->is_locked())) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp"
, 481, "assert(" "Threads::number_of_threads() == 0 || JvmtiThreadState_lock->is_locked()"
 ") failed", "sanity check"); ::breakpoint(); } } while (0);

size_t byte_cnt = sizeof(jvmtiEventCallbacks);

// clear in either case to be sure we got any gap between sizes
memset(&_event_callbacks, 0, byte_cnt);

// Now that JvmtiThreadState_lock is held, prevent a possible race condition where events
// are re-enabled by a call to set event callbacks where the DisposeEnvironment
// occurs after the boiler-plate environment check and before the lock is acquired.
if (callbacks != NULL__null && is_valid()) {
  if (size_of_callbacks < (jint)byte_cnt) {
    byte_cnt = size_of_callbacks;
  }
  memcpy(&_event_callbacks, callbacks, byte_cnt);
}
497}


500// In the fullness of time, all users of the method should instead
501// directly use allocate, besides being cleaner and faster, this will
502// mean much better out of memory handling
503unsigned char *
504JvmtiEnvBase::jvmtiMalloc(jlong size) {
unsigned char* mem = NULL__null;
jvmtiError result = allocate(size, &mem);
assert(result == JVMTI_ERROR_NONE, "Allocate failed")do { if (!(result == JVMTI_ERROR_NONE)) { (*g_assert_poison) =
 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp"
, 507, "assert(" "result == JVMTI_ERROR_NONE" ") failed", "Allocate failed"
); ::breakpoint(); } } while (0);
return mem;
509}


512// Handle management

514jobject JvmtiEnvBase::jni_reference(Handle hndl) {
return JNIHandles::make_local(hndl());
516}

518jobject JvmtiEnvBase::jni_reference(JavaThread *thread, Handle hndl) {
return JNIHandles::make_local(thread, hndl());
520}

522void JvmtiEnvBase::destroy_jni_reference(jobject jobj) {
JNIHandles::destroy_local(jobj);
524}

526void JvmtiEnvBase::destroy_jni_reference(JavaThread *thread, jobject jobj) {
JNIHandles::destroy_local(jobj); // thread is unused.
528}

530//
531// Threads
532//

534jobject *
535JvmtiEnvBase::new_jobjectArray(int length, Handle *handles) {
if (length == 0) {
  return NULL__null;
}

jobject *objArray = (jobject *) jvmtiMalloc(sizeof(jobject) * length);
NULL_CHECK(objArray, NULL)if ((objArray) == __null) { return (__null); };

for (int i=0; i<length; i++) {
  objArray[i] = jni_reference(handles[i]);
}
return objArray;
547}

549jthread *
550JvmtiEnvBase::new_jthreadArray(int length, Handle *handles) {
return (jthread *) new_jobjectArray(length,handles);
552}

554jthreadGroup *
555JvmtiEnvBase::new_jthreadGroupArray(int length, Handle *handles) {
return (jthreadGroup *) new_jobjectArray(length,handles);
557}

559// return the vframe on the specified thread and depth, NULL if no such frame
560// The thread and the oops in the returned vframe might not have been process.
561vframe*
562JvmtiEnvBase::vframeForNoProcess(JavaThread* java_thread, jint depth) {
if (!java_thread->has_last_Java_frame()) {
  return NULL__null;
}
RegisterMap reg_map(java_thread, true /* update_map */, false /* process_frames */);
vframe *vf = java_thread->last_java_vframe(&reg_map);
int d = 0;
while ((vf != NULL__null) && (d < depth)) {
  vf = vf->java_sender();
  d++;
}
return vf;
574}


577//
578// utilities: JNI objects
579//


582jclass
583JvmtiEnvBase::get_jni_class_non_null(Klass* k) {
assert(k != NULL, "k != NULL")do { if (!(k != __null)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp"
, 584, "assert(" "k != __null" ") failed", "k != NULL"); ::breakpoint
(); } } while (0);
Thread *thread = Thread::current();
return (jclass)jni_reference(Handle(thread, k->java_mirror()));
587}

589//
590// Field Information
591//

593bool
594JvmtiEnvBase::get_field_descriptor(Klass* k, jfieldID field, fieldDescriptor* fd) {
if (!jfieldIDWorkaround::is_valid_jfieldID(k, field)) {
  return false;
}
bool found = false;
if (jfieldIDWorkaround::is_static_jfieldID(field)) {
  JNIid* id = jfieldIDWorkaround::from_static_jfieldID(field);
  found = id->find_local_field(fd);
} else {
  // Non-static field. The fieldID is really the offset of the field within the object.
  int offset = jfieldIDWorkaround::from_instance_jfieldID(k, field);
  found = InstanceKlass::cast(k)->find_field_from_offset(offset, false, fd);
}
return found;
608}

610//
611// Object Monitor Information
612//

614//
615// Count the number of objects for a lightweight monitor. The hobj
616// parameter is object that owns the monitor so this routine will
617// count the number of times the same object was locked by frames
618// in java_thread.
619//
620jint
621JvmtiEnvBase::count_locked_objects(JavaThread *java_thread, Handle hobj) {
jint ret = 0;
if (!java_thread->has_last_Java_frame()) {
  return ret;  // no Java frames so no monitors
}

Thread* current_thread = Thread::current();
ResourceMark rm(current_thread);
HandleMark   hm(current_thread);
RegisterMap  reg_map(java_thread);

for(javaVFrame *jvf=java_thread->last_java_vframe(&reg_map); jvf != NULL__null;
                                               jvf = jvf->java_sender()) {
  GrowableArray<MonitorInfo*>* mons = jvf->monitors();
  if (!mons->is_empty()) {
    for (int i = 0; i < mons->length(); i++) {
      MonitorInfo *mi = mons->at(i);
      if (mi->owner_is_scalar_replaced()) continue;

      // see if owner of the monitor is our object
      if (mi->owner() != NULL__null && mi->owner() == hobj()) {
        ret++;
      }
    }
  }
}
return ret;
648}



652jvmtiError
653JvmtiEnvBase::get_current_contended_monitor(JavaThread *calling_thread, JavaThread *java_thread, jobject *monitor_ptr) {
Thread *current_thread = Thread::current();
assert(java_thread->is_handshake_safe_for(current_thread),do { if (!(java_thread->is_handshake_safe_for(current_thread
))) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp"
, 656, "assert(" "java_thread->is_handshake_safe_for(current_thread)"
 ") failed", "call by myself or at handshake"); ::breakpoint(
); } } while (0)
       "call by myself or at handshake")do { if (!(java_thread->is_handshake_safe_for(current_thread
))) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp"
, 656, "assert(" "java_thread->is_handshake_safe_for(current_thread)"
 ") failed", "call by myself or at handshake"); ::breakpoint(
); } } while (0);
oop obj = NULL__null;
// The ObjectMonitor* can't be async deflated since we are either
// at a safepoint or the calling thread is operating on itself so
// it cannot leave the underlying wait()/enter() call.
ObjectMonitor *mon = java_thread->current_waiting_monitor();
if (mon == NULL__null) {
  // thread is not doing an Object.wait() call
  mon = java_thread->current_pending_monitor();
  if (mon != NULL__null) {
    // The thread is trying to enter() an ObjectMonitor.
    obj = mon->object();
    assert(obj != NULL, "ObjectMonitor should have a valid object!")do { if (!(obj != __null)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp"
, 668, "assert(" "obj != __null" ") failed", "ObjectMonitor should have a valid object!"
); ::breakpoint(); } } while (0);
  }
  // implied else: no contended ObjectMonitor
} else {
  // thread is doing an Object.wait() call
  obj = mon->object();
  assert(obj != NULL, "Object.wait() should have an object")do { if (!(obj != __null)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp"
, 674, "assert(" "obj != __null" ") failed", "Object.wait() should have an object"
); ::breakpoint(); } } while (0);
}

if (obj == NULL__null) {
  *monitor_ptr = NULL__null;
} else {
  HandleMark hm(current_thread);
  Handle     hobj(current_thread, obj);
  *monitor_ptr = jni_reference(calling_thread, hobj);
}
return JVMTI_ERROR_NONE;
685}


688jvmtiError
689JvmtiEnvBase::get_owned_monitors(JavaThread *calling_thread, JavaThread* java_thread,
                               GrowableArray<jvmtiMonitorStackDepthInfo*> *owned_monitors_list) {
// Note:
// calling_thread is the thread that requested the list of monitors for java_thread.
// java_thread is the thread owning the monitors.
// current_thread is the thread executing this code, can be a non-JavaThread (e.g. VM Thread).
// And they all may be different threads.
jvmtiError err = JVMTI_ERROR_NONE;
Thread *current_thread = Thread::current();
assert(java_thread->is_handshake_safe_for(current_thread),do { if (!(java_thread->is_handshake_safe_for(current_thread
))) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp"
, 699, "assert(" "java_thread->is_handshake_safe_for(current_thread)"
 ") failed", "call by myself or at handshake"); ::breakpoint(
); } } while (0)
       "call by myself or at handshake")do { if (!(java_thread->is_handshake_safe_for(current_thread
))) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp"
, 699, "assert(" "java_thread->is_handshake_safe_for(current_thread)"
 ") failed", "call by myself or at handshake"); ::breakpoint(
); } } while (0);

if (java_thread->has_last_Java_frame()) {
  ResourceMark rm(current_thread);
  HandleMark   hm(current_thread);
  RegisterMap  reg_map(java_thread);

  int depth = 0;
  for (javaVFrame *jvf = java_thread->last_java_vframe(&reg_map); jvf != NULL__null;
       jvf = jvf->java_sender()) {
    if (MaxJavaStackTraceDepth == 0 || depth++ < MaxJavaStackTraceDepth) {  // check for stack too deep
      // add locked objects for this frame into list
      err = get_locked_objects_in_frame(calling_thread, java_thread, jvf, owned_monitors_list, depth-1);
      if (err != JVMTI_ERROR_NONE) {
        return err;
      }
    }
  }
}

// Get off stack monitors. (e.g. acquired via jni MonitorEnter).
JvmtiMonitorClosure jmc(calling_thread, owned_monitors_list, this);
ObjectSynchronizer::monitors_iterate(&jmc, java_thread);
err = jmc.error();

return err;
725}

727// Save JNI local handles for any objects that this frame owns.
728jvmtiError
729JvmtiEnvBase::get_locked_objects_in_frame(JavaThread* calling_thread, JavaThread* java_thread,
                               javaVFrame *jvf, GrowableArray<jvmtiMonitorStackDepthInfo*>* owned_monitors_list, jint stack_depth) {
jvmtiError err = JVMTI_ERROR_NONE;
Thread* current_thread = Thread::current();
ResourceMark rm(current_thread);
HandleMark   hm(current_thread);

GrowableArray<MonitorInfo*>* mons = jvf->monitors();
if (mons->is_empty()) {
  return err;  // this javaVFrame holds no monitors
}

oop wait_obj = NULL__null;
{
  // The ObjectMonitor* can't be async deflated since we are either
  // at a safepoint or the calling thread is operating on itself so
  // it cannot leave the underlying wait() call.
  // Save object of current wait() call (if any) for later comparison.
  ObjectMonitor *mon = java_thread->current_waiting_monitor();
  if (mon != NULL__null) {
    wait_obj = mon->object();
  }
}
oop pending_obj = NULL__null;
{
  // The ObjectMonitor* can't be async deflated since we are either
  // at a safepoint or the calling thread is operating on itself so
  // it cannot leave the underlying enter() call.
  // Save object of current enter() call (if any) for later comparison.
  ObjectMonitor *mon = java_thread->current_pending_monitor();
  if (mon != NULL__null) {
    pending_obj = mon->object();
  }
}

for (int i = 0; i < mons->length(); i++) {
  MonitorInfo *mi = mons->at(i);

  if (mi->owner_is_scalar_replaced()) continue;

  oop obj = mi->owner();
  if (obj == NULL__null) {
    // this monitor doesn't have an owning object so skip it
    continue;
  }

  if (wait_obj == obj) {
    // the thread is waiting on this monitor so it isn't really owned
    continue;
  }

  if (pending_obj == obj) {
    // the thread is pending on this monitor so it isn't really owned
    continue;
  }

  if (owned_monitors_list->length() > 0) {
    // Our list has at least one object on it so we have to check
    // for recursive object locking
    bool found = false;
    for (int j = 0; j < owned_monitors_list->length(); j++) {
      jobject jobj = ((jvmtiMonitorStackDepthInfo*)owned_monitors_list->at(j))->monitor;
      oop check = JNIHandles::resolve(jobj);
      if (check == obj) {
        found = true;  // we found the object
        break;
      }
    }

    if (found) {
      // already have this object so don't include it
      continue;
    }
  }

  // add the owning object to our list
  jvmtiMonitorStackDepthInfo *jmsdi;
  err = allocate(sizeof(jvmtiMonitorStackDepthInfo), (unsigned char **)&jmsdi);
  if (err != JVMTI_ERROR_NONE) {
      return err;
  }
  Handle hobj(Thread::current(), obj);
  jmsdi->monitor = jni_reference(calling_thread, hobj);
  jmsdi->stack_depth = stack_depth;
  owned_monitors_list->append(jmsdi);
}

return err;
817}

819jvmtiError
820JvmtiEnvBase::get_stack_trace(JavaThread *java_thread,
                            jint start_depth, jint max_count,
                            jvmtiFrameInfo* frame_buffer, jint* count_ptr) {
823#ifdef ASSERT1
uint32_t debug_bits = 0;
825#endif
Thread *current_thread = Thread::current();
assert(SafepointSynchronize::is_at_safepoint() ||do { if (!(SafepointSynchronize::is_at_safepoint() || java_thread
->is_handshake_safe_for(current_thread))) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp"
, 829, "assert(" "SafepointSynchronize::is_at_safepoint() || java_thread->is_handshake_safe_for(current_thread)"
 ") failed", "call by myself / at safepoint / at handshake");
 ::breakpoint(); } } while (0)
       java_thread->is_handshake_safe_for(current_thread),do { if (!(SafepointSynchronize::is_at_safepoint() || java_thread
->is_handshake_safe_for(current_thread))) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp"
, 829, "assert(" "SafepointSynchronize::is_at_safepoint() || java_thread->is_handshake_safe_for(current_thread)"
 ") failed", "call by myself / at safepoint / at handshake");
 ::breakpoint(); } } while (0)
       "call by myself / at safepoint / at handshake")do { if (!(SafepointSynchronize::is_at_safepoint() || java_thread
->is_handshake_safe_for(current_thread))) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp"
, 829, "assert(" "SafepointSynchronize::is_at_safepoint() || java_thread->is_handshake_safe_for(current_thread)"
 ") failed", "call by myself / at safepoint / at handshake");
 ::breakpoint(); } } while (0);
int count = 0;
if (java_thread->has_last_Java_frame()) {
  RegisterMap reg_map(java_thread, false /* update_map */, false /* process_frames */);
  ResourceMark rm(current_thread);
  javaVFrame *jvf = java_thread->last_java_vframe(&reg_map);
  HandleMark hm(current_thread);
  if (start_depth != 0) {
    if (start_depth > 0) {
      for (int j = 0; j < start_depth && jvf != NULL__null; j++) {
        jvf = jvf->java_sender();
      }
      if (jvf == NULL__null) {
        // start_depth is deeper than the stack depth
        return JVMTI_ERROR_ILLEGAL_ARGUMENT;
      }
    } else { // start_depth < 0
      // we are referencing the starting depth based on the oldest
      // part of the stack.
      // optimize to limit the number of times that java_sender() is called
      javaVFrame *jvf_cursor = jvf;
      javaVFrame *jvf_prev = NULL__null;
      javaVFrame *jvf_prev_prev = NULL__null;
      int j = 0;
      while (jvf_cursor != NULL__null) {
        jvf_prev_prev = jvf_prev;
        jvf_prev = jvf_cursor;
        for (j = 0; j > start_depth && jvf_cursor != NULL__null; j--) {
          jvf_cursor = jvf_cursor->java_sender();
        }
      }
      if (j == start_depth) {
        // previous pointer is exactly where we want to start
        jvf = jvf_prev;
      } else {
        // we need to back up further to get to the right place
        if (jvf_prev_prev == NULL__null) {
          // the -start_depth is greater than the stack depth
          return JVMTI_ERROR_ILLEGAL_ARGUMENT;
        }
        // j now is the number of frames on the stack starting with
        // jvf_prev, we start from jvf_prev_prev and move older on
        // the stack that many, the result is -start_depth frames
        // remaining.
        jvf = jvf_prev_prev;
        for (; j < 0; j++) {
          jvf = jvf->java_sender();
        }
      }
    }
  }
  for (; count < max_count && jvf != NULL__null; count++) {
    frame_buffer[count].method = jvf->method()->jmethod_id();
    frame_buffer[count].location = (jvf->method()->is_native() ? -1 : jvf->bci());
    jvf = jvf->java_sender();
  }
} else {
  if (start_depth != 0) {
    // no frames and there is a starting depth
    return JVMTI_ERROR_ILLEGAL_ARGUMENT;
  }
}
*count_ptr = count;
return JVMTI_ERROR_NONE;
893}

895jvmtiError
896JvmtiEnvBase::get_frame_count(JvmtiThreadState *state, jint *count_ptr) {
assert((state != NULL),do { if (!((state != __null))) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp"
, 898, "assert(" "(state != __null)" ") failed", "JavaThread should create JvmtiThreadState before calling this method"
); ::breakpoint(); } } while (0)
       "JavaThread should create JvmtiThreadState before calling this method")do { if (!((state != __null))) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp"
, 898, "assert(" "(state != __null)" ") failed", "JavaThread should create JvmtiThreadState before calling this method"
); ::breakpoint(); } } while (0);
*count_ptr = state->count_frames();
return JVMTI_ERROR_NONE;
901}

903jvmtiError
904JvmtiEnvBase::get_frame_location(JavaThread *java_thread, jint depth,
                               jmethodID* method_ptr, jlocation* location_ptr) {
906#ifdef ASSERT1
uint32_t debug_bits = 0;
908#endif
Thread* current_thread = Thread::current();
assert(java_thread->is_handshake_safe_for(current_thread),do { if (!(java_thread->is_handshake_safe_for(current_thread
))) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp"
, 911, "assert(" "java_thread->is_handshake_safe_for(current_thread)"
 ") failed", "call by myself or at handshake"); ::breakpoint(
); } } while (0)
       "call by myself or at handshake")do { if (!(java_thread->is_handshake_safe_for(current_thread
))) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp"
, 911, "assert(" "java_thread->is_handshake_safe_for(current_thread)"
 ") failed", "call by myself or at handshake"); ::breakpoint(
); } } while (0);
ResourceMark rm(current_thread);

vframe *vf = vframeForNoProcess(java_thread, depth);
if (vf == NULL__null) {
  return JVMTI_ERROR_NO_MORE_FRAMES;
}

// vframeFor should return a java frame. If it doesn't
// it means we've got an internal error and we return the
// error in product mode. In debug mode we will instead
// attempt to cast the vframe to a javaVFrame and will
// cause an assertion/crash to allow further diagnosis.
924#ifdef PRODUCT
if (!vf->is_java_frame()) {
  return JVMTI_ERROR_INTERNAL;
}
928#endif

HandleMark hm(current_thread);
javaVFrame *jvf = javaVFrame::cast(vf);
Method* method = jvf->method();
if (method->is_native()) {
  *location_ptr = -1;
} else {
  *location_ptr = jvf->bci();
}
*method_ptr = method->jmethod_id();

return JVMTI_ERROR_NONE;
941}


944jvmtiError
945JvmtiEnvBase::get_object_monitor_usage(JavaThread* calling_thread, jobject object, jvmtiMonitorUsage* info_ptr) {
assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint")do { if (!(SafepointSynchronize::is_at_safepoint())) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp"
, 946, "assert(" "SafepointSynchronize::is_at_safepoint()" ") failed"
, "must be at safepoint"); ::breakpoint(); } } while (0);
1
Assuming the condition is false→
2
←
Taking false branch→
3
←
Loop condition is false.  Exiting loop→
Thread* current_thread = VMThread::vm_thread();
assert(current_thread == Thread::current(), "must be")do { if (!(current_thread == Thread::current())) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp"
, 948, "assert(" "current_thread == Thread::current()" ") failed"
, "must be"); ::breakpoint(); } } while (0);
4
←
Assuming the condition is true→
5
←
Taking false branch→
6
←
Loop condition is false.  Exiting loop→

HandleMark hm(current_thread);
Handle hobj;

// Check arguments
{
  oop mirror = JNIHandles::resolve_external_guard(object);
  NULL_CHECK(mirror, JVMTI_ERROR_INVALID_OBJECT)if ((mirror) == __null) { return (JVMTI_ERROR_INVALID_OBJECT)
; };
7
←
Calling 'oop::operator=='→
10
←
Returning from 'oop::operator=='→
11
←
Taking false branch→
  NULL_CHECK(info_ptr, JVMTI_ERROR_NULL_POINTER)if ((info_ptr) == __null) { return (JVMTI_ERROR_NULL_POINTER)
; };
12
←
Assuming the condition is false→
13
←
Taking false branch→

  hobj = Handle(current_thread, mirror);
}

ThreadsListHandle tlh(current_thread);
JavaThread *owning_thread = NULL__null;
ObjectMonitor *mon = NULL__null;
jvmtiMonitorUsage ret = {
14
←
'ret.notify_waiters' initialized to a null pointer value→
    NULL__null, 0, 0, NULL__null, 0, NULL__null
};

uint32_t debug_bits = 0;
// first derive the object's owner and entry_count (if any)
{
  address owner = NULL__null;
  {
    markWord mark = hobj()->mark();

    if (!mark.has_monitor()) {
15
←
Taking false branch→
      // this object has a lightweight monitor

      if (mark.has_locker()) {
        owner = (address)mark.locker(); // save the address of the Lock word
      }
      // implied else: no owner
    } else {
      // this object has a heavyweight monitor
      mon = mark.monitor();

      // The owner field of a heavyweight monitor may be NULL for no
      // owner, a JavaThread * or it may still be the address of the
      // Lock word in a JavaThread's stack. A monitor can be inflated
      // by a non-owning JavaThread, but only the owning JavaThread
      // can change the owner field from the Lock word to the
      // JavaThread * and it may not have done that yet.
      owner = (address)mon->owner();
    }
  }

  if (owner15.1
'owner' is equal to NULL
1
'owner' is equal to NULL
1
'owner' is equal to NULL
 != NULL__null) {
16
←
Taking false branch→
    // This monitor is owned so we have to find the owning JavaThread.
    owning_thread = Threads::owning_thread_from_monitor_owner(tlh.list(), owner);
    assert(owning_thread != NULL, "owning JavaThread must not be NULL")do { if (!(owning_thread != __null)) { (*g_assert_poison) = 'X'
;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp"
, 1000, "assert(" "owning_thread != __null" ") failed", "owning JavaThread must not be NULL"
); ::breakpoint(); } } while (0);
    Handle     th(current_thread, owning_thread->threadObj());
    ret.owner = (jthread)jni_reference(calling_thread, th);
  }

  if (owning_thread16.1
'owning_thread' is equal to NULL
1
'owning_thread' is equal to NULL
1
'owning_thread' is equal to NULL
 != NULL__null) {  // monitor is owned
17
←
Taking false branch→
    // The recursions field of a monitor does not reflect recursions
    // as lightweight locks before inflating the monitor are not included.
    // We have to count the number of recursive monitor entries the hard way.
    // We pass a handle to survive any GCs along the way.
    ret.entry_count = count_locked_objects(owning_thread, hobj);
  }
  // implied else: entry_count == 0
}

jint nWant = 0, nWait = 0;
if (mon17.1
'mon' is not equal to NULL
1
'mon' is not equal to NULL
1
'mon' is not equal to NULL
 != NULL__null) {
18
←
Taking true branch→
  // this object has a heavyweight monitor
  nWant = mon->contentions(); // # of threads contending for monitor
  nWait = mon->waiters();     // # of threads in Object.wait()
  ret.waiter_count = nWant + nWait;
  ret.notify_waiter_count = nWait;
} else {
  // this object has a lightweight monitor
  ret.waiter_count = 0;
  ret.notify_waiter_count = 0;
}

// Allocate memory for heavyweight and lightweight monitor.
jvmtiError err;
err = allocate(ret.waiter_count * sizeof(jthread *), (unsigned char**)&ret.waiters);
if (err18.1
'err' is equal to JVMTI_ERROR_NONE
1
'err' is equal to JVMTI_ERROR_NONE
1
'err' is equal to JVMTI_ERROR_NONE
 != JVMTI_ERROR_NONE) {
19
←
Taking false branch→
  return err;
}
err = allocate(ret.notify_waiter_count * sizeof(jthread *),
20
←
Calling 'JvmtiEnvBase::allocate'→
24
←
Returning from 'JvmtiEnvBase::allocate'→
               (unsigned char**)&ret.notify_waiters);
if (err24.1
'err' is equal to JVMTI_ERROR_NONE
1
'err' is equal to JVMTI_ERROR_NONE
1
'err' is equal to JVMTI_ERROR_NONE
 != JVMTI_ERROR_NONE) {
25
←
Taking false branch→
  deallocate((unsigned char*)ret.waiters);
  return err;
}

// now derive the rest of the fields
if (mon25.1
'mon' is not equal to NULL
1
'mon' is not equal to NULL
1
'mon' is not equal to NULL
 != NULL__null) {
26
←
Taking true branch→
  // this object has a heavyweight monitor

  // Number of waiters may actually be less than the waiter count.
  // So NULL out memory so that unused memory will be NULL.
  memset(ret.waiters, 0, ret.waiter_count * sizeof(jthread *));
  memset(ret.notify_waiters, 0, ret.notify_waiter_count * sizeof(jthread *));
27
←
Null pointer passed to 1st parameter expecting 'nonnull'

  if (ret.waiter_count > 0) {
    // we have contending and/or waiting threads
    if (nWant > 0) {
      // we have contending threads
      ResourceMark rm(current_thread);
      // get_pending_threads returns only java thread so we do not need to
      // check for non java threads.
      GrowableArray<JavaThread*>* wantList = Threads::get_pending_threads(tlh.list(), nWant, (address)mon);
      if (wantList->length() < nWant) {
        // robustness: the pending list has gotten smaller
        nWant = wantList->length();
      }
      for (int i = 0; i < nWant; i++) {
        JavaThread *pending_thread = wantList->at(i);
        Handle th(current_thread, pending_thread->threadObj());
        ret.waiters[i] = (jthread)jni_reference(calling_thread, th);
      }
    }
    if (nWait > 0) {
      // we have threads in Object.wait()
      int offset = nWant;  // add after any contending threads
      ObjectWaiter *waiter = mon->first_waiter();
      for (int i = 0, j = 0; i < nWait; i++) {
        if (waiter == NULL__null) {
          // robustness: the waiting list has gotten smaller
          nWait = j;
          break;
        }
        JavaThread *w = mon->thread_of_waiter(waiter);
        if (w != NULL__null) {
          // If the thread was found on the ObjectWaiter list, then
          // it has not been notified. This thread can't change the
          // state of the monitor so it doesn't need to be suspended.
          Handle th(current_thread, w->threadObj());
          ret.waiters[offset + j] = (jthread)jni_reference(calling_thread, th);
          ret.notify_waiters[j++] = (jthread)jni_reference(calling_thread, th);
        }
        waiter = mon->next_waiter(waiter);
      }
    }
  } // ThreadsListHandle is destroyed here.

  // Adjust count. nWant and nWait count values may be less than original.
  ret.waiter_count = nWant + nWait;
  ret.notify_waiter_count = nWait;
} else {
  // this object has a lightweight monitor and we have nothing more
  // to do here because the defaults are just fine.
}

// we don't update return parameter unless everything worked
*info_ptr = ret;

return JVMTI_ERROR_NONE;
1104}

1106ResourceTracker::ResourceTracker(JvmtiEnv* env) {
_env = env;
_allocations = new (ResourceObj::C_HEAP, mtServiceability) GrowableArray<unsigned char*>(20, mtServiceability);
_failed = false;
1110}
1111ResourceTracker::~ResourceTracker() {
if (_failed) {
  for (int i=0; i<_allocations->length(); i++) {
    _env->deallocate(_allocations->at(i));
  }
}
delete _allocations;
1118}

1120jvmtiError ResourceTracker::allocate(jlong size, unsigned char** mem_ptr) {
unsigned char *ptr;
jvmtiError err = _env->allocate(size, &ptr);
if (err == JVMTI_ERROR_NONE) {
  _allocations->append(ptr);
  *mem_ptr = ptr;
} else {
  *mem_ptr = NULL__null;
  _failed = true;
}
return err;
}

1133unsigned char* ResourceTracker::allocate(jlong size) {
unsigned char* ptr;
allocate(size, &ptr);
return ptr;
1137}

1139char* ResourceTracker::strdup(const char* str) {
char *dup_str = (char*)allocate(strlen(str)+1);
if (dup_str != NULL__null) {
  strcpy(dup_str, str);
}
return dup_str;
1145}

1147struct StackInfoNode {
struct StackInfoNode *next;
jvmtiStackInfo info;
1150};

1152// Create a jvmtiStackInfo inside a linked list node and create a
1153// buffer for the frame information, both allocated as resource objects.
1154// Fill in both the jvmtiStackInfo and the jvmtiFrameInfo.
1155// Note that either or both of thr and thread_oop
1156// may be null if the thread is new or has exited.
1157void
1158MultipleStackTracesCollector::fill_frames(jthread jt, JavaThread *thr, oop thread_oop) {
1159#ifdef ASSERT1
Thread *current_thread = Thread::current();
assert(SafepointSynchronize::is_at_safepoint() ||do { if (!(SafepointSynchronize::is_at_safepoint() || thr->
is_handshake_safe_for(current_thread))) { (*g_assert_poison) =
 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp"
, 1163, "assert(" "SafepointSynchronize::is_at_safepoint() || thr->is_handshake_safe_for(current_thread)"
 ") failed", "call by myself / at safepoint / at handshake");
 ::breakpoint(); } } while (0)
       thr->is_handshake_safe_for(current_thread),do { if (!(SafepointSynchronize::is_at_safepoint() || thr->
is_handshake_safe_for(current_thread))) { (*g_assert_poison) =
 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp"
, 1163, "assert(" "SafepointSynchronize::is_at_safepoint() || thr->is_handshake_safe_for(current_thread)"
 ") failed", "call by myself / at safepoint / at handshake");
 ::breakpoint(); } } while (0)
       "call by myself / at safepoint / at handshake")do { if (!(SafepointSynchronize::is_at_safepoint() || thr->
is_handshake_safe_for(current_thread))) { (*g_assert_poison) =
 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp"
, 1163, "assert(" "SafepointSynchronize::is_at_safepoint() || thr->is_handshake_safe_for(current_thread)"
 ") failed", "call by myself / at safepoint / at handshake");
 ::breakpoint(); } } while (0);
1164#endif

jint state = 0;
struct StackInfoNode *node = NEW_RESOURCE_OBJ(struct StackInfoNode)(struct StackInfoNode*) resource_allocate_bytes((1) * sizeof(
struct StackInfoNode));
jvmtiStackInfo *infop = &(node->info);
node->next = head();
set_head(node);
infop->frame_count = 0;
infop->thread = jt;

if (thread_oop != NULL__null) {
  // get most state bits
  state = (jint)java_lang_Thread::get_thread_status(thread_oop);
}

if (thr != NULL__null) {    // add more state bits if there is a JavaThead to query
  if (thr->is_suspended()) {
    state |= JVMTI_THREAD_STATE_SUSPENDED;
  }
  JavaThreadState jts = thr->thread_state();
  if (jts == _thread_in_native) {
    state |= JVMTI_THREAD_STATE_IN_NATIVE;
  }
  if (thr->is_interrupted(false)) {
    state |= JVMTI_THREAD_STATE_INTERRUPTED;
  }
}
infop->state = state;

if (thr != NULL__null && (state & JVMTI_THREAD_STATE_ALIVE) != 0) {
  infop->frame_buffer = NEW_RESOURCE_ARRAY(jvmtiFrameInfo, max_frame_count())(jvmtiFrameInfo*) resource_allocate_bytes((max_frame_count())
 * sizeof(jvmtiFrameInfo));
  env()->get_stack_trace(thr, 0, max_frame_count(),
                         infop->frame_buffer, &(infop->frame_count));
} else {
  infop->frame_buffer = NULL__null;
  infop->frame_count = 0;
}
_frame_count_total += infop->frame_count;
1202}

1204// Based on the stack information in the linked list, allocate memory
1205// block to return and fill it from the info in the linked list.
1206void
1207MultipleStackTracesCollector::allocate_and_fill_stacks(jint thread_count) {
// do I need to worry about alignment issues?
jlong alloc_size =  thread_count       * sizeof(jvmtiStackInfo)
                  + _frame_count_total * sizeof(jvmtiFrameInfo);
env()->allocate(alloc_size, (unsigned char **)&_stack_info);

// pointers to move through the newly allocated space as it is filled in
jvmtiStackInfo *si = _stack_info + thread_count;      // bottom of stack info
jvmtiFrameInfo *fi = (jvmtiFrameInfo *)si;            // is the top of frame info

// copy information in resource area into allocated buffer
// insert stack info backwards since linked list is backwards
// insert frame info forwards
// walk the StackInfoNodes
for (struct StackInfoNode *sin = head(); sin != NULL__null; sin = sin->next) {
  jint frame_count = sin->info.frame_count;
  size_t frames_size = frame_count * sizeof(jvmtiFrameInfo);
  --si;
  memcpy(si, &(sin->info), sizeof(jvmtiStackInfo));
  if (frames_size == 0) {
    si->frame_buffer = NULL__null;
  } else {
    memcpy(fi, sin->info.frame_buffer, frames_size);
    si->frame_buffer = fi;  // point to the new allocated copy of the frames
    fi += frame_count;
  }
}
assert(si == _stack_info, "the last copied stack info must be the first record")do { if (!(si == _stack_info)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp"
, 1234, "assert(" "si == _stack_info" ") failed", "the last copied stack info must be the first record"
); ::breakpoint(); } } while (0);
assert((unsigned char *)fi == ((unsigned char *)_stack_info) + alloc_size,do { if (!((unsigned char *)fi == ((unsigned char *)_stack_info
) + alloc_size)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp"
, 1236, "assert(" "(unsigned char *)fi == ((unsigned char *)_stack_info) + alloc_size"
 ") failed", "the last copied frame info must be the last record"
); ::breakpoint(); } } while (0)
       "the last copied frame info must be the last record")do { if (!((unsigned char *)fi == ((unsigned char *)_stack_info
) + alloc_size)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp"
, 1236, "assert(" "(unsigned char *)fi == ((unsigned char *)_stack_info) + alloc_size"
 ") failed", "the last copied frame info must be the last record"
); ::breakpoint(); } } while (0);
1237}


1240void
1241VM_GetThreadListStackTraces::doit() {
assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint")do { if (!(SafepointSynchronize::is_at_safepoint())) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp"
, 1242, "assert(" "SafepointSynchronize::is_at_safepoint()" ") failed"
, "must be at safepoint"); ::breakpoint(); } } while (0);

ResourceMark rm;
ThreadsListHandle tlh;
for (int i = 0; i < _thread_count; ++i) {
  jthread jt = _thread_list[i];
  JavaThread* java_thread = NULL__null;
  oop thread_oop = NULL__null;
  jvmtiError err = JvmtiExport::cv_external_thread_to_JavaThread(tlh.list(), jt, &java_thread, &thread_oop);
  if (err != JVMTI_ERROR_NONE) {
    // We got an error code so we don't have a JavaThread *, but
    // only return an error from here if we didn't get a valid
    // thread_oop.
    if (thread_oop == NULL__null) {
      _collector.set_result(err);
      return;
    }
    // We have a valid thread_oop.
  }
  _collector.fill_frames(jt, java_thread, thread_oop);
}
_collector.allocate_and_fill_stacks(_thread_count);
1264}

1266void
1267GetSingleStackTraceClosure::do_thread(Thread *target) {
JavaThread *jt = JavaThread::cast(target);
oop thread_oop = jt->threadObj();

if (!jt->is_exiting() && thread_oop != NULL__null) {
  ResourceMark rm;
  _collector.fill_frames(_jthread, jt, thread_oop);
  _collector.allocate_and_fill_stacks(1);
}
1276}

1278void
1279VM_GetAllStackTraces::doit() {
assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint")do { if (!(SafepointSynchronize::is_at_safepoint())) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp"
, 1280, "assert(" "SafepointSynchronize::is_at_safepoint()" ") failed"
, "must be at safepoint"); ::breakpoint(); } } while (0);

ResourceMark rm;
_final_thread_count = 0;
for (JavaThreadIteratorWithHandle jtiwh; JavaThread *jt = jtiwh.next(); ) {
  oop thread_oop = jt->threadObj();
  if (thread_oop != NULL__null &&
      !jt->is_exiting() &&
      java_lang_Thread::is_alive(thread_oop) &&
      !jt->is_hidden_from_external_view()) {
    ++_final_thread_count;
    // Handle block of the calling thread is used to create local refs.
    _collector.fill_frames((jthread)JNIHandles::make_local(_calling_thread, thread_oop),
                           jt, thread_oop);
  }
}
_collector.allocate_and_fill_stacks(_final_thread_count);
1297}

1299// Verifies that the top frame is a java frame in an expected state.
1300// Deoptimizes frame if needed.
1301// Checks that the frame method signature matches the return type (tos).
1302// HandleMark must be defined in the caller only.
1303// It is to keep a ret_ob_h handle alive after return to the caller.
1304jvmtiError
1305JvmtiEnvBase::check_top_frame(Thread* current_thread, JavaThread* java_thread,
                            jvalue value, TosState tos, Handle* ret_ob_h) {
ResourceMark rm(current_thread);

vframe *vf = vframeForNoProcess(java_thread, 0);
NULL_CHECK(vf, JVMTI_ERROR_NO_MORE_FRAMES)if ((vf) == __null) { return (JVMTI_ERROR_NO_MORE_FRAMES); };

javaVFrame *jvf = (javaVFrame*) vf;
if (!vf->is_java_frame() || jvf->method()->is_native()) {
  return JVMTI_ERROR_OPAQUE_FRAME;
}

// If the frame is a compiled one, need to deoptimize it.
if (vf->is_compiled_frame()) {
  if (!vf->fr().can_be_deoptimized()) {
    return JVMTI_ERROR_OPAQUE_FRAME;
  }
  Deoptimization::deoptimize_frame(java_thread, jvf->fr().id());
}

// Get information about method return type
Symbol* signature = jvf->method()->signature();

ResultTypeFinder rtf(signature);
TosState fr_tos = as_TosState(rtf.type());
if (fr_tos != tos) {
  if (tos != itos || (fr_tos != btos && fr_tos != ztos && fr_tos != ctos && fr_tos != stos)) {
    return JVMTI_ERROR_TYPE_MISMATCH;
  }
}

// Check that the jobject class matches the return type signature.
jobject jobj = value.l;
if (tos == atos && jobj != NULL__null) { // NULL reference is allowed
  Handle ob_h(current_thread, JNIHandles::resolve_external_guard(jobj));
  NULL_CHECK(ob_h, JVMTI_ERROR_INVALID_OBJECT)if ((ob_h) == __null) { return (JVMTI_ERROR_INVALID_OBJECT); };
  Klass* ob_k = ob_h()->klass();
  NULL_CHECK(ob_k, JVMTI_ERROR_INVALID_OBJECT)if ((ob_k) == __null) { return (JVMTI_ERROR_INVALID_OBJECT); };

  // Method return type signature.
  char* ty_sign = 1 + strchr(signature->as_C_string(), JVM_SIGNATURE_ENDFUNC);

  if (!VM_GetOrSetLocal::is_assignable(ty_sign, ob_k, current_thread)) {
    return JVMTI_ERROR_TYPE_MISMATCH;
  }
  *ret_ob_h = ob_h;
}
return JVMTI_ERROR_NONE;
1353} /* end check_top_frame */


1356// ForceEarlyReturn<type> follows the PopFrame approach in many aspects.
1357// Main difference is on the last stage in the interpreter.
1358// The PopFrame stops method execution to continue execution
1359// from the same method call instruction.
1360// The ForceEarlyReturn forces return from method so the execution
1361// continues at the bytecode following the method call.

1363// java_thread - protected by ThreadsListHandle and pre-checked

1365jvmtiError
1366JvmtiEnvBase::force_early_return(JavaThread* java_thread, jvalue value, TosState tos) {
// retrieve or create the state
JvmtiThreadState* state = JvmtiThreadState::state_for(java_thread);
if (state == NULL__null) {
  return JVMTI_ERROR_THREAD_NOT_ALIVE;
}

// Eagerly reallocate scalar replaced objects.
JavaThread* current_thread = JavaThread::current();
EscapeBarrier eb(true, current_thread, java_thread);
if (!eb.deoptimize_objects(0)) {
  // Reallocation of scalar replaced objects failed -> return with error
  return JVMTI_ERROR_OUT_OF_MEMORY;
}

SetForceEarlyReturn op(state, value, tos);
if (java_thread == current_thread) {
  op.doit(java_thread, true /* self */);
} else {
  Handshake::execute(&op, java_thread);
}
return op.result();
1388}

1390void
1391SetForceEarlyReturn::doit(Thread *target, bool self) {
JavaThread* java_thread = JavaThread::cast(target);
Thread* current_thread = Thread::current();
HandleMark   hm(current_thread);

if (java_thread->is_exiting()) {
  return; /* JVMTI_ERROR_THREAD_NOT_ALIVE (default) */
}
if (!self) {
  if (!java_thread->is_suspended()) {
    _result = JVMTI_ERROR_THREAD_NOT_SUSPENDED;
    return;
  }
}

// Check to see if a ForceEarlyReturn was already in progress
if (_state->is_earlyret_pending()) {
  // Probably possible for JVMTI clients to trigger this, but the
  // JPDA backend shouldn't allow this to happen
  _result = JVMTI_ERROR_INTERNAL;
  return;
}
{
  // The same as for PopFrame. Workaround bug:
  //  4812902: popFrame hangs if the method is waiting at a synchronize
  // Catch this condition and return an error to avoid hanging.
  // Now JVMTI spec allows an implementation to bail out with an opaque
  // frame error.
  OSThread* osThread = java_thread->osthread();
  if (osThread->get_state() == MONITOR_WAIT) {
    _result = JVMTI_ERROR_OPAQUE_FRAME;
    return;
  }
}

Handle ret_ob_h;
_result = JvmtiEnvBase::check_top_frame(current_thread, java_thread, _value, _tos, &ret_ob_h);
if (_result != JVMTI_ERROR_NONE) {
  return;
}
assert(_tos != atos || _value.l == NULL || ret_ob_h() != NULL,do { if (!(_tos != atos || _value.l == __null || ret_ob_h() !=
 __null)) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp"
, 1432, "assert(" "_tos != atos || _value.l == __null || ret_ob_h() != __null"
 ") failed", "return object oop must not be NULL if jobject is not NULL"
); ::breakpoint(); } } while (0)
       "return object oop must not be NULL if jobject is not NULL")do { if (!(_tos != atos || _value.l == __null || ret_ob_h() !=
 __null)) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp"
, 1432, "assert(" "_tos != atos || _value.l == __null || ret_ob_h() != __null"
 ") failed", "return object oop must not be NULL if jobject is not NULL"
); ::breakpoint(); } } while (0);

// Update the thread state to reflect that the top frame must be
// forced to return.
// The current frame will be returned later when the suspended
// thread is resumed and right before returning from VM to Java.
// (see call_VM_base() in assembler_<cpu>.cpp).

_state->set_earlyret_pending();
_state->set_earlyret_oop(ret_ob_h());
_state->set_earlyret_value(_value, _tos);

// Set pending step flag for this early return.
// It is cleared when next step event is posted.
_state->set_pending_step_for_earlyret();
1447}

1449void
1450JvmtiMonitorClosure::do_monitor(ObjectMonitor* mon) {
if ( _error != JVMTI_ERROR_NONE) {
  // Error occurred in previous iteration so no need to add
  // to the list.
  return;
}
// Filter out on stack monitors collected during stack walk.
oop obj = mon->object();
bool found = false;
for (int j = 0; j < _owned_monitors_list->length(); j++) {
  jobject jobj = ((jvmtiMonitorStackDepthInfo*)_owned_monitors_list->at(j))->monitor;
  oop check = JNIHandles::resolve(jobj);
  if (check == obj) {
    // On stack monitor already collected during the stack walk.
    found = true;
    break;
  }
}
if (found == false) {
  // This is off stack monitor (e.g. acquired via jni MonitorEnter).
  jvmtiError err;
  jvmtiMonitorStackDepthInfo *jmsdi;
  err = _env->allocate(sizeof(jvmtiMonitorStackDepthInfo), (unsigned char **)&jmsdi);
  if (err != JVMTI_ERROR_NONE) {
    _error = err;
    return;
  }
  Handle hobj(Thread::current(), obj);
  jmsdi->monitor = _env->jni_reference(_calling_thread, hobj);
  // stack depth is unknown for this monitor.
  jmsdi->stack_depth = -1;
  _owned_monitors_list->append(jmsdi);
}
1483}

1485GrowableArray<OopHandle>* JvmtiModuleClosure::_tbl = NULL__null;

1487void JvmtiModuleClosure::do_module(ModuleEntry* entry) {
assert_locked_or_safepoint(Module_lock);
OopHandle module = entry->module_handle();
guarantee(module.resolve() != NULL, "module object is NULL")do { if (!(module.resolve() != __null)) { (*g_assert_poison) =
 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp"
, 1490, "guarantee(" "module.resolve() != NULL" ") failed", "module object is NULL"
); ::breakpoint(); } } while (0);
_tbl->push(module);
1492}

1494jvmtiError
1495JvmtiModuleClosure::get_all_modules(JvmtiEnv* env, jint* module_count_ptr, jobject** modules_ptr) {
ResourceMark rm;
MutexLocker mcld(ClassLoaderDataGraph_lock);
MutexLocker ml(Module_lock);

_tbl = new GrowableArray<OopHandle>(77);
if (_tbl == NULL__null) {
  return JVMTI_ERROR_OUT_OF_MEMORY;
}

// Iterate over all the modules loaded to the system.
ClassLoaderDataGraph::modules_do(&do_module);

jint len = _tbl->length();
guarantee(len > 0, "at least one module must be present")do { if (!(len > 0)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp"
, 1509, "guarantee(" "len > 0" ") failed", "at least one module must be present"
); ::breakpoint(); } } while (0);

jobject* array = (jobject*)env->jvmtiMalloc((jlong)(len * sizeof(jobject)));
if (array == NULL__null) {
  return JVMTI_ERROR_OUT_OF_MEMORY;
}
for (jint idx = 0; idx < len; idx++) {
  array[idx] = JNIHandles::make_local(_tbl->at(idx).resolve());
}
_tbl = NULL__null;
*modules_ptr = array;
*module_count_ptr = len;
return JVMTI_ERROR_NONE;
1522}

1524void
1525UpdateForPopTopFrameClosure::doit(Thread *target, bool self) {
Thread* current_thread  = Thread::current();
HandleMark hm(current_thread);
JavaThread* java_thread = JavaThread::cast(target);

if (java_thread->is_exiting()) {
  return; /* JVMTI_ERROR_THREAD_NOT_ALIVE (default) */
}
assert(java_thread == _state->get_thread(), "Must be")do { if (!(java_thread == _state->get_thread())) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp"
, 1533, "assert(" "java_thread == _state->get_thread()" ") failed"
, "Must be"); ::breakpoint(); } } while (0);

if (!self && !java_thread->is_suspended()) {
  _result = JVMTI_ERROR_THREAD_NOT_SUSPENDED;
  return;
}

// Check to see if a PopFrame was already in progress
if (java_thread->popframe_condition() != JavaThread::popframe_inactive) {
  // Probably possible for JVMTI clients to trigger this, but the
  // JPDA backend shouldn't allow this to happen
  _result = JVMTI_ERROR_INTERNAL;
  return;
}

// Was workaround bug
//    4812902: popFrame hangs if the method is waiting at a synchronize
// Catch this condition and return an error to avoid hanging.
// Now JVMTI spec allows an implementation to bail out with an opaque frame error.
OSThread* osThread = java_thread->osthread();
if (osThread->get_state() == MONITOR_WAIT) {
  _result = JVMTI_ERROR_OPAQUE_FRAME;
  return;
}

ResourceMark rm(current_thread);
// Check if there is more than one Java frame in this thread, that the top two frames
// are Java (not native) frames, and that there is no intervening VM frame
int frame_count = 0;
bool is_interpreted[2];
intptr_t *frame_sp[2];
// The 2-nd arg of constructor is needed to stop iterating at java entry frame.
for (vframeStream vfs(java_thread, true, false /* process_frames */); !vfs.at_end(); vfs.next()) {
  methodHandle mh(current_thread, vfs.method());
  if (mh->is_native()) {
    _result = JVMTI_ERROR_OPAQUE_FRAME;
    return;
  }
  is_interpreted[frame_count] = vfs.is_interpreted_frame();
  frame_sp[frame_count] = vfs.frame_id();
  if (++frame_count > 1) break;
}
if (frame_count < 2)  {
  // We haven't found two adjacent non-native Java frames on the top.
  // There can be two situations here:
  //  1. There are no more java frames
  //  2. Two top java frames are separated by non-java native frames
  if(JvmtiEnvBase::vframeForNoProcess(java_thread, 1) == NULL__null) {
    _result = JVMTI_ERROR_NO_MORE_FRAMES;
    return;
  } else {
    // Intervening non-java native or VM frames separate java frames.
    // Current implementation does not support this. See bug #5031735.
    // In theory it is possible to pop frames in such cases.
    _result = JVMTI_ERROR_OPAQUE_FRAME;
    return;
  }
}

// If any of the top 2 frames is a compiled one, need to deoptimize it
for (int i = 0; i < 2; i++) {
  if (!is_interpreted[i]) {
    Deoptimization::deoptimize_frame(java_thread, frame_sp[i]);
  }
}

// Update the thread state to reflect that the top frame is popped
// so that cur_stack_depth is maintained properly and all frameIDs
// are invalidated.
// The current frame will be popped later when the suspended thread
// is resumed and right before returning from VM to Java.
// (see call_VM_base() in assembler_<cpu>.cpp).

// It's fine to update the thread state here because no JVMTI events
// shall be posted for this PopFrame.

_state->update_for_pop_top_frame();
java_thread->set_popframe_condition(JavaThread::popframe_pending_bit);
// Set pending step flag for this popframe and it is cleared when next
// step event is posted.
_state->set_pending_step_for_popframe();
_result = JVMTI_ERROR_NONE;
1615}

1617void
1618SetFramePopClosure::doit(Thread *target, bool self) {
ResourceMark rm;
JavaThread* java_thread = JavaThread::cast(target);

if (java_thread->is_exiting()) {
  return; /* JVMTI_ERROR_THREAD_NOT_ALIVE (default) */
}
assert(_state->get_thread() == java_thread, "Must be")do { if (!(_state->get_thread() == java_thread)) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp"
, 1625, "assert(" "_state->get_thread() == java_thread" ") failed"
, "Must be"); ::breakpoint(); } } while (0);

if (!self && !java_thread->is_suspended()) {
  _result = JVMTI_ERROR_THREAD_NOT_SUSPENDED;
  return;
}

vframe *vf = JvmtiEnvBase::vframeForNoProcess(java_thread, _depth);
if (vf == NULL__null) {
  _result = JVMTI_ERROR_NO_MORE_FRAMES;
  return;
}

if (!vf->is_java_frame() || ((javaVFrame*) vf)->method()->is_native()) {
  _result = JVMTI_ERROR_OPAQUE_FRAME;
  return;
}

assert(vf->frame_pointer() != NULL, "frame pointer mustn't be NULL")do { if (!(vf->frame_pointer() != __null)) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp"
, 1643, "assert(" "vf->frame_pointer() != __null" ") failed"
, "frame pointer mustn't be NULL"); ::breakpoint(); } } while
 (0);
int frame_number = _state->count_frames() - _depth;
_state->env_thread_state((JvmtiEnvBase*)_env)->set_frame_pop(frame_number);
_result = JVMTI_ERROR_NONE;
1647}

1649void
1650GetOwnedMonitorInfoClosure::do_thread(Thread *target) {
JavaThread *jt = JavaThread::cast(target);
if (!jt->is_exiting() && (jt->threadObj() != NULL__null)) {
  _result = ((JvmtiEnvBase *)_env)->get_owned_monitors(_calling_thread,
                                                       jt,
                                                       _owned_monitors_list);
}
1657}

1659void
1660GetCurrentContendedMonitorClosure::do_thread(Thread *target) {
JavaThread *jt = JavaThread::cast(target);
if (!jt->is_exiting() && (jt->threadObj() != NULL__null)) {
  _result = ((JvmtiEnvBase *)_env)->get_current_contended_monitor(_calling_thread,
                                                                  jt,
                                                                  _owned_monitor_ptr);
}
1667}

1669void
1670GetStackTraceClosure::do_thread(Thread *target) {
JavaThread *jt = JavaThread::cast(target);
if (!jt->is_exiting() && jt->threadObj() != NULL__null) {
  _result = ((JvmtiEnvBase *)_env)->get_stack_trace(jt,
                                                    _start_depth, _max_count,
                                                    _frame_buffer, _count_ptr);
}
1677}

1679void
1680GetFrameCountClosure::do_thread(Thread *target) {
JavaThread* jt = _state->get_thread();
assert(target == jt, "just checking")do { if (!(target == jt)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.cpp"
, 1682, "assert(" "target == jt" ") failed", "just checking")
; ::breakpoint(); } } while (0);
if (!jt->is_exiting() && jt->threadObj() != NULL__null) {
  _result = ((JvmtiEnvBase*)_env)->get_frame_count(_state, _count_ptr);
}
1686}

1688void
1689GetFrameLocationClosure::do_thread(Thread *target) {
JavaThread *jt = JavaThread::cast(target);
if (!jt->is_exiting() && jt->threadObj() != NULL__null) {
  _result = ((JvmtiEnvBase*)_env)->get_frame_location(jt, _depth,
                                                      _method_ptr, _location_ptr);
}
1695}

←

/home/daniel/Projects/java/jdk/src/hotspot/share/oops/oopsHierarchy.hpp

→

1/*
2 * Copyright (c) 1997, 2020, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24 
25#ifndef SHARE_OOPS_OOPSHIERARCHY_HPP
26#define SHARE_OOPS_OOPSHIERARCHY_HPP
27 
28#include "metaprogramming/integralConstant.hpp"
29#include "metaprogramming/primitiveConversions.hpp"
30#include "utilities/globalDefinitions.hpp"
31 
32// OBJECT hierarchy
33// This hierarchy is a representation hierarchy, i.e. if A is a superclass
34// of B, A's representation is a prefix of B's representation.
35 
36// Global offset instead of address for an oop within a java object.
37enum class narrowOop : uint32_t { null = 0 };
38 
39// If compressed klass pointers then use narrowKlass.
40typedef juint  narrowKlass;
41 
42typedef void* OopOrNarrowOopStar;
43 
44#ifndef CHECK_UNHANDLED_OOPS1
45 
46typedef class oopDesc*                    oop;
47typedef class   instanceOopDesc*            instanceOop;
48typedef class   arrayOopDesc*               arrayOop;
49typedef class     objArrayOopDesc*            objArrayOop;
50typedef class     typeArrayOopDesc*           typeArrayOop;
51 
52#else
53 
54// When CHECK_UNHANDLED_OOPS is defined, an "oop" is a class with a
55// carefully chosen set of constructors and conversion operators to go
56// to and from the underlying oopDesc pointer type.
57//
58// Because oop and its subclasses <type>Oop are class types, arbitrary
59// conversions are not accepted by the compiler.  Applying a cast to
60// an oop will cause the best matched conversion operator to be
61// invoked returning the underlying oopDesc* type if appropriate.
62// No copy constructors, explicit user conversions or operators of
63// numerical type should be defined within the oop class. Most C++
64// compilers will issue a compile time error concerning the overloading
65// ambiguity between operators of numerical and pointer types. If
66// a conversion to or from an oop to a numerical type is needed,
67// use the inline template methods, cast_*_oop, defined below.
68//
69// Converting NULL to oop to Handle implicit is no longer accepted by the
70// compiler because there are too many steps in the conversion.  Use Handle()
71// instead, which generates less code anyway.
72 
73class Thread;
74class oopDesc;
75 
76extern "C" bool CheckUnhandledOops;
77 
78class oop {
79  oopDesc* _o;
80 
81  void register_oop();
82  void unregister_oop();
83 
84  void register_if_checking() {
85    if (CheckUnhandledOops) register_oop();
86  }
87 
88public:
89  oop()             : _o(nullptr) { register_if_checking(); }
90  oop(const oop& o) : _o(o._o)    { register_if_checking(); }
91  oop(oopDesc* o)   : _o(o)       { register_if_checking(); }
92  ~oop() {
93    if (CheckUnhandledOops) unregister_oop();
94  }
95 
96  oopDesc* obj() const                 { return _o; }
97  oopDesc* operator->() const          { return _o; }
98  operator oopDesc* () const           { return _o; }
99 
100  bool operator==(const oop& o) const  { return _o == o._o; }
101  bool operator!=(const oop& o) const  { return _o != o._o; }
102 
103  bool operator==(std::nullptr_t) const     { return _o == nullptr; }
8
←
Assuming the condition is false→
9
←
Returning zero, which participates in a condition later→
104  bool operator!=(std::nullptr_t) const     { return _o != nullptr; }
105 
106  oop& operator=(const oop& o)         { _o = o._o; return *this; }
107};
108 
109template<>
110struct PrimitiveConversions::Translate<oop> : public TrueType {
111  typedef oop Value;
112  typedef oopDesc* Decayed;
113 
114  static Decayed decay(Value x) { return x.obj(); }
115  static Value recover(Decayed x) { return oop(x); }
116};
117 
118#define DEF_OOP(type)class typeOopDesc; class typeOop : public oop { public: typeOop
() : oop() {} typeOop(const typeOop& o) : oop(o) {} typeOop
(const oop& o) : oop(o) {} typeOop(typeOopDesc* o) : oop(
(oopDesc*)o) {} operator typeOopDesc* () const { return (typeOopDesc
*)obj(); } typeOopDesc* operator->() const { return (typeOopDesc
*)obj(); } typeOop& operator=(const typeOop& o) { oop
::operator=(o); return *this; } }; template<> struct PrimitiveConversions
::Translate<typeOop> : public TrueType { typedef typeOop
 Value; typedef typeOopDesc* Decayed; static Decayed decay(Value
 x) { return (typeOopDesc*)x.obj(); } static Value recover(Decayed
 x) { return typeOop(x); } };                                                      \
119   class type##OopDesc;                                                    \
120   class type##Oop : public oop {                                          \
121     public:                                                               \
122       type##Oop() : oop() {}                                              \
123       type##Oop(const type##Oop& o) : oop(o) {}                           \
124       type##Oop(const oop& o) : oop(o) {}                                 \
125       type##Oop(type##OopDesc* o) : oop((oopDesc*)o) {}                   \
126       operator type##OopDesc* () const { return (type##OopDesc*)obj(); }  \
127       type##OopDesc* operator->() const {                                 \
128            return (type##OopDesc*)obj();                                  \
129       }                                                                   \
130       type##Oop& operator=(const type##Oop& o) {                          \
131            oop::operator=(o);                                             \
132            return *this;                                                  \
133       }                                                                   \
134   };                                                                      \
135                                                                           \
136   template<>                                                              \
137   struct PrimitiveConversions::Translate<type##Oop> : public TrueType {   \
138     typedef type##Oop Value;                                              \
139     typedef type##OopDesc* Decayed;                                       \
140                                                                           \
141     static Decayed decay(Value x) { return (type##OopDesc*)x.obj(); }     \
142     static Value recover(Decayed x) { return type##Oop(x); }              \
143   };
144 
145DEF_OOP(instance)class instanceOopDesc; class instanceOop : public oop { public
: instanceOop() : oop() {} instanceOop(const instanceOop&
 o) : oop(o) {} instanceOop(const oop& o) : oop(o) {} instanceOop
(instanceOopDesc* o) : oop((oopDesc*)o) {} operator instanceOopDesc
* () const { return (instanceOopDesc*)obj(); } instanceOopDesc
* operator->() const { return (instanceOopDesc*)obj(); } instanceOop
& operator=(const instanceOop& o) { oop::operator=(o)
; return *this; } }; template<> struct PrimitiveConversions
::Translate<instanceOop> : public TrueType { typedef instanceOop
 Value; typedef instanceOopDesc* Decayed; static Decayed decay
(Value x) { return (instanceOopDesc*)x.obj(); } static Value recover
(Decayed x) { return instanceOop(x); } };;
146DEF_OOP(array)class arrayOopDesc; class arrayOop : public oop { public: arrayOop
() : oop() {} arrayOop(const arrayOop& o) : oop(o) {} arrayOop
(const oop& o) : oop(o) {} arrayOop(arrayOopDesc* o) : oop
((oopDesc*)o) {} operator arrayOopDesc* () const { return (arrayOopDesc
*)obj(); } arrayOopDesc* operator->() const { return (arrayOopDesc
*)obj(); } arrayOop& operator=(const arrayOop& o) { oop
::operator=(o); return *this; } }; template<> struct PrimitiveConversions
::Translate<arrayOop> : public TrueType { typedef arrayOop
 Value; typedef arrayOopDesc* Decayed; static Decayed decay(Value
 x) { return (arrayOopDesc*)x.obj(); } static Value recover(Decayed
 x) { return arrayOop(x); } };;
147DEF_OOP(objArray)class objArrayOopDesc; class objArrayOop : public oop { public
: objArrayOop() : oop() {} objArrayOop(const objArrayOop&
 o) : oop(o) {} objArrayOop(const oop& o) : oop(o) {} objArrayOop
(objArrayOopDesc* o) : oop((oopDesc*)o) {} operator objArrayOopDesc
* () const { return (objArrayOopDesc*)obj(); } objArrayOopDesc
* operator->() const { return (objArrayOopDesc*)obj(); } objArrayOop
& operator=(const objArrayOop& o) { oop::operator=(o)
; return *this; } }; template<> struct PrimitiveConversions
::Translate<objArrayOop> : public TrueType { typedef objArrayOop
 Value; typedef objArrayOopDesc* Decayed; static Decayed decay
(Value x) { return (objArrayOopDesc*)x.obj(); } static Value recover
(Decayed x) { return objArrayOop(x); } };;
148DEF_OOP(typeArray)class typeArrayOopDesc; class typeArrayOop : public oop { public
: typeArrayOop() : oop() {} typeArrayOop(const typeArrayOop&
 o) : oop(o) {} typeArrayOop(const oop& o) : oop(o) {} typeArrayOop
(typeArrayOopDesc* o) : oop((oopDesc*)o) {} operator typeArrayOopDesc
* () const { return (typeArrayOopDesc*)obj(); } typeArrayOopDesc
* operator->() const { return (typeArrayOopDesc*)obj(); } typeArrayOop
& operator=(const typeArrayOop& o) { oop::operator=(o
); return *this; } }; template<> struct PrimitiveConversions
::Translate<typeArrayOop> : public TrueType { typedef typeArrayOop
 Value; typedef typeArrayOopDesc* Decayed; static Decayed decay
(Value x) { return (typeArrayOopDesc*)x.obj(); } static Value
 recover(Decayed x) { return typeArrayOop(x); } };;
149 
150#endif // CHECK_UNHANDLED_OOPS
151 
152// Cast functions to convert to and from oops.
153template <typename T> inline oop cast_to_oop(T value) {
154  return (oopDesc*)value;
155}
156template <typename T> inline T cast_from_oop(oop o) {
157  return (T)(CHECK_UNHANDLED_OOPS_ONLY((oopDesc*))(oopDesc*)o);
158}
159 
160// The metadata hierarchy is separate from the oop hierarchy
161 
162//      class MetaspaceObj
163class   ConstMethod;
164class   ConstantPoolCache;
165class   MethodData;
166//      class Metadata
167class   Method;
168class   ConstantPool;
169//      class CHeapObj
170class   CompiledICHolder;
171 
172 
173// The klass hierarchy is separate from the oop hierarchy.
174 
175class Klass;
176class   InstanceKlass;
177class     InstanceMirrorKlass;
178class     InstanceClassLoaderKlass;
179class     InstanceRefKlass;
180class   ArrayKlass;
181class     ObjArrayKlass;
182class     TypeArrayKlass;
183 
184#endif // SHARE_OOPS_OOPSHIERARCHY_HPP

←

/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.hpp

1/*
* Copyright (c) 2003, 2021, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*
*/

25#ifndef SHARE_PRIMS_JVMTIENVBASE_HPP
26#define SHARE_PRIMS_JVMTIENVBASE_HPP

28#include "prims/jvmtiEnvThreadState.hpp"
29#include "prims/jvmtiEventController.hpp"
30#include "prims/jvmtiThreadState.hpp"
31#include "oops/oopHandle.hpp"
32#include "runtime/atomic.hpp"
33#include "runtime/fieldDescriptor.hpp"
34#include "runtime/frame.hpp"
35#include "runtime/thread.hpp"
36#include "runtime/vmOperation.hpp"
37#include "utilities/growableArray.hpp"
38#include "utilities/macros.hpp"

40//
41// Forward Declarations
42//

44class JvmtiEnv;
45class JvmtiThreadState;
46class JvmtiRawMonitor; // for jvmtiEnv.hpp
47class JvmtiEventControllerPrivate;
48class JvmtiTagMap;



52// One JvmtiEnv object is created per jvmti attachment;
53// done via JNI GetEnv() call. Multiple attachments are
54// allowed in jvmti.

56class JvmtiEnvBase : public CHeapObj<mtInternal> {

private:

60#if INCLUDE_JVMTI1
static JvmtiEnvBase*     _head_environment;  // head of environment list
62#endif // INCLUDE_JVMTI

static bool              _globally_initialized;
static jvmtiPhase        _phase;
static volatile int      _dying_thread_env_iteration_count;

public:

enum {
  JDK15_JVMTI_VERSION = JVMTI_VERSION_1_0 +  33,  /* version: 1.0.33  */
  JDK16_JVMTI_VERSION = JVMTI_VERSION_1_1 + 102,  /* version: 1.1.102 */
  JDK17_JVMTI_VERSION = JVMTI_VERSION_1_2 +   2   /* version: 1.2.2   */
};

static jvmtiPhase  get_phase()                    { return _phase; }
static jvmtiPhase  get_phase(jvmtiEnv* env)       { return ((JvmtiEnvBase*)JvmtiEnv_from_jvmti_env(env))->phase(); }
static void  set_phase(jvmtiPhase phase)          { _phase = phase; }
static bool is_vm_live()                          { return _phase == JVMTI_PHASE_LIVE; }

static void entering_dying_thread_env_iteration() { ++_dying_thread_env_iteration_count; }
static void leaving_dying_thread_env_iteration()  { --_dying_thread_env_iteration_count; }
static bool is_inside_dying_thread_env_iteration(){ return _dying_thread_env_iteration_count > 0; }

private:

enum {
    JVMTI_MAGIC    = 0x71EE,
    DISPOSED_MAGIC = 0xDEFC,
    BAD_MAGIC      = 0xDEAD
};

jvmtiEnv _jvmti_external;
jint _magic;
jint _version;  // version value passed to JNI GetEnv()
JvmtiEnvBase* _next;
bool _is_retransformable;
const void *_env_local_storage;     // per env agent allocated data.
jvmtiEventCallbacks _event_callbacks;
jvmtiExtEventCallbacks _ext_event_callbacks;
JvmtiTagMap* volatile _tag_map;
JvmtiEnvEventEnable _env_event_enable;
jvmtiCapabilities _current_capabilities;
jvmtiCapabilities _prohibited_capabilities;
volatile bool _class_file_load_hook_ever_enabled;
static volatile bool _needs_clean_up;
char** _native_method_prefixes;
int    _native_method_prefix_count;

protected:
JvmtiEnvBase(jint version);
~JvmtiEnvBase();
void dispose();
void env_dispose();

void set_env_local_storage(const void* data)     { _env_local_storage = data; }
const void* get_env_local_storage()              { return _env_local_storage; }

void record_class_file_load_hook_enabled();
void record_first_time_class_file_load_hook_enabled();

char** get_native_method_prefixes()              { return _native_method_prefixes; }
int    get_native_method_prefix_count()          { return _native_method_prefix_count; }
jvmtiError set_native_method_prefixes(jint prefix_count, char** prefixes);

private:
friend class JvmtiEventControllerPrivate;
void initialize();
void set_event_callbacks(const jvmtiEventCallbacks* callbacks, jint size_of_callbacks);
static void globally_initialize();
static void periodic_clean_up();

friend class JvmtiEnvIterator;
JvmtiEnv* next_environment()                     { return (JvmtiEnv*)_next; }
void set_next_environment(JvmtiEnvBase* env)     { _next = env; }
static JvmtiEnv* head_environment()              {
  JVMTI_ONLY(return (JvmtiEnv*)_head_environment)return (JvmtiEnv*)_head_environment;
  NOT_JVMTI(return NULL);
}

public:

jvmtiPhase  phase();
bool is_valid();

bool use_version_1_0_semantics();  // agent asked for version 1.0
bool use_version_1_1_semantics();  // agent asked for version 1.1
bool use_version_1_2_semantics();  // agent asked for version 1.2

bool is_retransformable()                        { return _is_retransformable; }

static ByteSize jvmti_external_offset() {
  return byte_offset_of(JvmtiEnvBase, _jvmti_external)in_ByteSize((int)(size_t)((intx)&(((JvmtiEnvBase*)16)->
_jvmti_external) - 16));
};

static JvmtiEnv* JvmtiEnv_from_jvmti_env(jvmtiEnv *env) {
  return (JvmtiEnv*)((intptr_t)env - in_bytes(jvmti_external_offset()));
};

jvmtiCapabilities *get_capabilities()             { return &_current_capabilities; }

jvmtiCapabilities *get_prohibited_capabilities()  { return &_prohibited_capabilities; }

bool early_class_hook_env() {
  return get_capabilities()->can_generate_early_class_hook_events != 0
      && get_capabilities()->can_generate_all_class_hook_events != 0;
}

bool early_vmstart_env() {
  return get_capabilities()->can_generate_early_vmstart != 0;
}

static char** get_all_native_method_prefixes(int* count_ptr);

// This test will answer true when all environments have been disposed and some have
// not yet been deallocated.  As a result, this test should only be used as an
// optimization for the no environment case.
static bool environments_might_exist() {
  return head_environment() != NULL__null;
}

static void check_for_periodic_clean_up();

JvmtiEnvEventEnable *env_event_enable() {
  return &_env_event_enable;
}

jvmtiError allocate(jlong size, unsigned char** mem_ptr) {
  if (size20.1
'size' is >= 0
1
'size' is >= 0
1
'size' is >= 0
 < 0) {
21
←
Taking false branch→
    return JVMTI_ERROR_ILLEGAL_ARGUMENT;
  }
  if (size == 0) {
22
←
Assuming 'size' is equal to 0→
23
←
Taking true branch→
    *mem_ptr = NULL__null;
  } else {
    *mem_ptr = (unsigned char *)os::malloc((size_t)size, mtInternal);
    if (*mem_ptr == NULL__null) {
      return JVMTI_ERROR_OUT_OF_MEMORY;
    }
  }
  return JVMTI_ERROR_NONE;
}

jvmtiError deallocate(unsigned char* mem) {
  if (mem != NULL__null) {
    os::free(mem);
  }
  return JVMTI_ERROR_NONE;
}


// Memory functions
unsigned char* jvmtiMalloc(jlong size);  // don't use this - call allocate

// method to create a local handle
jobject jni_reference(Handle hndl);

// method to create a local handle.
// This function allows caller to specify which
// threads local handle table to use.
jobject jni_reference(JavaThread *thread, Handle hndl);

// method to destroy a local handle
void destroy_jni_reference(jobject jobj);

// method to destroy a local handle.
// This function allows caller to specify which
// threads local handle table to use.
void destroy_jni_reference(JavaThread *thread, jobject jobj);

jvmtiEnv* jvmti_external() { return &_jvmti_external; };

232// Event Dispatch

bool has_callback(jvmtiEvent event_type) {
  assert(event_type >= JVMTI_MIN_EVENT_TYPE_VAL &&do { if (!(event_type >= JVMTI_MIN_EVENT_TYPE_VAL &&
 event_type <= JVMTI_MAX_EVENT_TYPE_VAL)) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.hpp"
, 236, "assert(" "event_type >= JVMTI_MIN_EVENT_TYPE_VAL && event_type <= JVMTI_MAX_EVENT_TYPE_VAL"
 ") failed", "checking"); ::breakpoint(); } } while (0)
         event_type <= JVMTI_MAX_EVENT_TYPE_VAL, "checking")do { if (!(event_type >= JVMTI_MIN_EVENT_TYPE_VAL &&
 event_type <= JVMTI_MAX_EVENT_TYPE_VAL)) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/prims/jvmtiEnvBase.hpp"
, 236, "assert(" "event_type >= JVMTI_MIN_EVENT_TYPE_VAL && event_type <= JVMTI_MAX_EVENT_TYPE_VAL"
 ") failed", "checking"); ::breakpoint(); } } while (0);
  return ((void**)&_event_callbacks)[event_type-JVMTI_MIN_EVENT_TYPE_VAL] != NULL__null;
}

jvmtiEventCallbacks* callbacks() {
  return &_event_callbacks;
}

jvmtiExtEventCallbacks* ext_callbacks() {
  return &_ext_event_callbacks;
}

void set_tag_map(JvmtiTagMap* tag_map) {
  _tag_map = tag_map;
}

JvmtiTagMap* tag_map() {
  return _tag_map;
}

JvmtiTagMap* tag_map_acquire() {
  return Atomic::load_acquire(&_tag_map);
}

void release_set_tag_map(JvmtiTagMap* tag_map) {
  Atomic::release_store(&_tag_map, tag_map);
}

// return true if event is enabled globally or for any thread
// True only if there is a callback for it.
bool is_enabled(jvmtiEvent event_type) {
  return _env_event_enable.is_enabled(event_type);
}

270// Random Utilities

protected:
// helper methods for creating arrays of global JNI Handles from local Handles
// allocated into environment specific storage
jobject * new_jobjectArray(int length, Handle *handles);
jthread * new_jthreadArray(int length, Handle *handles);
jthreadGroup * new_jthreadGroupArray(int length, Handle *handles);

// convert to a jni jclass from a non-null Klass*
jclass get_jni_class_non_null(Klass* k);

jint count_locked_objects(JavaThread *java_thread, Handle hobj);
jvmtiError get_locked_objects_in_frame(JavaThread *calling_thread,
                                 JavaThread* java_thread,
                                 javaVFrame *jvf,
                                 GrowableArray<jvmtiMonitorStackDepthInfo*>* owned_monitors_list,
                                 jint depth);
public:
static vframe* vframeForNoProcess(JavaThread* java_thread, jint depth);

// get a field descriptor for the specified class and field
static bool get_field_descriptor(Klass* k, jfieldID field, fieldDescriptor* fd);

// JVMTI API helper functions which are called when target thread is suspended
// or at safepoint / thread local handshake.
jvmtiError get_frame_count(JvmtiThreadState *state, jint *count_ptr);
jvmtiError get_frame_location(JavaThread* java_thread, jint depth,
                                            jmethodID* method_ptr, jlocation* location_ptr);
jvmtiError get_object_monitor_usage(JavaThread *calling_thread,
                                                  jobject object, jvmtiMonitorUsage* info_ptr);
jvmtiError get_stack_trace(JavaThread *java_thread,
                                         jint stack_depth, jint max_count,
                                         jvmtiFrameInfo* frame_buffer, jint* count_ptr);
jvmtiError get_current_contended_monitor(JavaThread *calling_thread, JavaThread *java_thread,
                                         jobject *monitor_ptr);
jvmtiError get_owned_monitors(JavaThread *calling_thread, JavaThread* java_thread,
                              GrowableArray<jvmtiMonitorStackDepthInfo*> *owned_monitors_list);
static jvmtiError check_top_frame(Thread* current_thread, JavaThread* java_thread,
                                  jvalue value, TosState tos, Handle* ret_ob_h);
jvmtiError force_early_return(JavaThread* java_thread, jvalue value, TosState tos);
311};

313// This class is the only safe means of iterating through environments.
314// Note that this iteratation includes invalid environments pending
315// deallocation -- in fact, some uses depend on this behavior.

317class JvmtiEnvIterator : public StackObj {
private:
bool _entry_was_marked;
public:
JvmtiEnvIterator() {
  if (Threads::number_of_threads() == 0) {
    _entry_was_marked = false; // we are single-threaded, no need
  } else {
    Thread::current()->entering_jvmti_env_iteration();
    _entry_was_marked = true;
  }
}
~JvmtiEnvIterator() {
  if (_entry_was_marked) {
    Thread::current()->leaving_jvmti_env_iteration();
  }
}
JvmtiEnv* first()                 { return JvmtiEnvBase::head_environment(); }
JvmtiEnv* next(JvmtiEnvBase* env) { return env->next_environment(); }
336};

338class JvmtiHandshakeClosure : public HandshakeClosure {
protected:
jvmtiError _result;
public:
JvmtiHandshakeClosure(const char* name)
  : HandshakeClosure(name),
    _result(JVMTI_ERROR_THREAD_NOT_ALIVE) {}
jvmtiError result() { return _result; }
346};

348class SetForceEarlyReturn : public JvmtiHandshakeClosure {
349private:
JvmtiThreadState* _state;
jvalue _value;
TosState _tos;
353public:
SetForceEarlyReturn(JvmtiThreadState* state, jvalue value, TosState tos)
  : JvmtiHandshakeClosure("SetForceEarlyReturn"),
   _state(state),
   _value(value),
   _tos(tos) {}
void do_thread(Thread *target) {
  doit(target, false /* self */);
}
void doit(Thread *target, bool self);
363};

365// HandshakeClosure to update for pop top frame.
366class UpdateForPopTopFrameClosure : public JvmtiHandshakeClosure {
367private:
JvmtiThreadState* _state;

370public:
UpdateForPopTopFrameClosure(JvmtiThreadState* state)
  : JvmtiHandshakeClosure("UpdateForPopTopFrame"),
   _state(state) {}
void do_thread(Thread *target) {
  doit(target, false /* self */);
}
void doit(Thread *target, bool self);
378};

380// HandshakeClosure to set frame pop.
381class SetFramePopClosure : public JvmtiHandshakeClosure {
382private:
JvmtiEnv *_env;
JvmtiThreadState* _state;
jint _depth;

387public:
SetFramePopClosure(JvmtiEnv *env, JvmtiThreadState* state, jint depth)
  : JvmtiHandshakeClosure("SetFramePop"),
    _env(env),
    _state(state),
    _depth(depth) {}
void do_thread(Thread *target) {
  doit(target, false /* self */);
}
void doit(Thread *target, bool self);
397};

399// HandshakeClosure to get monitor information with stack depth.
400class GetOwnedMonitorInfoClosure : public JvmtiHandshakeClosure {
401private:
JavaThread* _calling_thread;
JvmtiEnv *_env;
GrowableArray<jvmtiMonitorStackDepthInfo*> *_owned_monitors_list;

406public:
GetOwnedMonitorInfoClosure(JavaThread* calling_thread, JvmtiEnv* env,
                           GrowableArray<jvmtiMonitorStackDepthInfo*>* owned_monitor_list)
  : JvmtiHandshakeClosure("GetOwnedMonitorInfo"),
    _calling_thread(calling_thread),
    _env(env),
    _owned_monitors_list(owned_monitor_list) {}
void do_thread(Thread *target);
414};


417// VM operation to get object monitor usage.
418class VM_GetObjectMonitorUsage : public VM_Operation {
419private:
JvmtiEnv *_env;
jobject _object;
JavaThread* _calling_thread;
jvmtiMonitorUsage* _info_ptr;
jvmtiError _result;

426public:
VM_GetObjectMonitorUsage(JvmtiEnv *env, JavaThread* calling_thread, jobject object, jvmtiMonitorUsage* info_ptr) {
  _env = env;
  _object = object;
  _calling_thread = calling_thread;
  _info_ptr = info_ptr;
}
VMOp_Type type() const { return VMOp_GetObjectMonitorUsage; }
jvmtiError result() { return _result; }
void doit() {
  _result = ((JvmtiEnvBase*) _env)->get_object_monitor_usage(_calling_thread, _object, _info_ptr);
}

439};

441// HandshakeClosure to get current contended monitor.
442class GetCurrentContendedMonitorClosure : public JvmtiHandshakeClosure {
443private:
JavaThread *_calling_thread;
JvmtiEnv *_env;
jobject *_owned_monitor_ptr;

448public:
GetCurrentContendedMonitorClosure(JavaThread* calling_thread, JvmtiEnv *env, jobject *mon_ptr)
  : JvmtiHandshakeClosure("GetCurrentContendedMonitor"),
    _calling_thread(calling_thread),
    _env(env),
    _owned_monitor_ptr(mon_ptr) {}
void do_thread(Thread *target);
455};

457// HandshakeClosure to get stack trace.
458class GetStackTraceClosure : public JvmtiHandshakeClosure {
459private:
JvmtiEnv *_env;
jint _start_depth;
jint _max_count;
jvmtiFrameInfo *_frame_buffer;
jint *_count_ptr;

466public:
GetStackTraceClosure(JvmtiEnv *env, jint start_depth, jint max_count,
                     jvmtiFrameInfo* frame_buffer, jint* count_ptr)
  : JvmtiHandshakeClosure("GetStackTrace"),
    _env(env),
    _start_depth(start_depth),
    _max_count(max_count),
    _frame_buffer(frame_buffer),
    _count_ptr(count_ptr) {}
void do_thread(Thread *target);
476};

478// forward declaration
479struct StackInfoNode;

481// Get stack trace at safepoint or at direct handshake.
482class MultipleStackTracesCollector {
483private:
JvmtiEnv *_env;
jint _max_frame_count;
jvmtiStackInfo *_stack_info;
jvmtiError _result;
int _frame_count_total;
struct StackInfoNode *_head;

JvmtiEnvBase *env()                 { return (JvmtiEnvBase *)_env; }
jint max_frame_count()              { return _max_frame_count; }
struct StackInfoNode *head()        { return _head; }
void set_head(StackInfoNode *head)  { _head = head; }

496public:
MultipleStackTracesCollector(JvmtiEnv *env, jint max_frame_count)
  : _env(env),
    _max_frame_count(max_frame_count),
    _stack_info(NULL__null),
    _result(JVMTI_ERROR_NONE),
    _frame_count_total(0),
    _head(NULL__null) {
}
void set_result(jvmtiError result)  { _result = result; }
void fill_frames(jthread jt, JavaThread *thr, oop thread_oop);
void allocate_and_fill_stacks(jint thread_count);
jvmtiStackInfo *stack_info()       { return _stack_info; }
jvmtiError result()                { return _result; }
510};


513// VM operation to get stack trace at safepoint.
514class VM_GetAllStackTraces : public VM_Operation {
515private:
JavaThread *_calling_thread;
jint _final_thread_count;
MultipleStackTracesCollector _collector;

520public:
VM_GetAllStackTraces(JvmtiEnv *env, JavaThread *calling_thread,
                     jint max_frame_count)
    : _calling_thread(calling_thread),
      _final_thread_count(0),
      _collector(env, max_frame_count) {
}
VMOp_Type type() const          { return VMOp_GetAllStackTraces; }
void doit();
jint final_thread_count()       { return _final_thread_count; }
jvmtiStackInfo *stack_info()    { return _collector.stack_info(); }
jvmtiError result()             { return _collector.result(); }
532};

534// VM operation to get stack trace at safepoint.
535class VM_GetThreadListStackTraces : public VM_Operation {
536private:
jint _thread_count;
const jthread* _thread_list;
MultipleStackTracesCollector _collector;

541public:
VM_GetThreadListStackTraces(JvmtiEnv *env, jint thread_count, const jthread* thread_list, jint max_frame_count)
    : _thread_count(thread_count),
      _thread_list(thread_list),
      _collector(env, max_frame_count) {
}
VMOp_Type type() const { return VMOp_GetThreadListStackTraces; }
void doit();
jvmtiStackInfo *stack_info()    { return _collector.stack_info(); }
jvmtiError result()             { return _collector.result(); }
551};

553// HandshakeClosure to get single stack trace.
554class GetSingleStackTraceClosure : public HandshakeClosure {
555private:
JavaThread *_calling_thread;
jthread _jthread;
MultipleStackTracesCollector _collector;

560public:
GetSingleStackTraceClosure(JvmtiEnv *env, JavaThread *calling_thread,
                           jthread thread, jint max_frame_count)
  : HandshakeClosure("GetSingleStackTrace"),
    _calling_thread(calling_thread),
    _jthread(thread),
    _collector(env, max_frame_count) {
}
void do_thread(Thread *target);
jvmtiStackInfo *stack_info()    { return _collector.stack_info(); }
jvmtiError result()             { return _collector.result(); }
571};

573// HandshakeClosure to count stack frames.
574class GetFrameCountClosure : public JvmtiHandshakeClosure {
575private:
JvmtiEnv *_env;
JvmtiThreadState *_state;
jint *_count_ptr;

580public:
GetFrameCountClosure(JvmtiEnv *env, JvmtiThreadState *state, jint *count_ptr)
  : JvmtiHandshakeClosure("GetFrameCount"),
    _env(env),
    _state(state),
    _count_ptr(count_ptr) {}
void do_thread(Thread *target);
587};

589// HandshakeClosure to get frame location.
590class GetFrameLocationClosure : public JvmtiHandshakeClosure {
591private:
JvmtiEnv *_env;
jint _depth;
jmethodID* _method_ptr;
jlocation* _location_ptr;

597public:
GetFrameLocationClosure(JvmtiEnv *env, jint depth,
                        jmethodID* method_ptr, jlocation* location_ptr)
  : JvmtiHandshakeClosure("GetFrameLocation"),
    _env(env),
    _depth(depth),
    _method_ptr(method_ptr),
    _location_ptr(location_ptr) {}
void do_thread(Thread *target);
606};


609// ResourceTracker
610//
611// ResourceTracker works a little like a ResourceMark. All allocates
612// using the resource tracker are recorded. If an allocate using the
613// resource tracker fails the destructor will free any resources
614// that were allocated using the tracker.
615// The motive for this class is to avoid messy error recovery code
616// in situations where multiple allocations are done in sequence. If
617// the second or subsequent allocation fails it avoids any code to
618// release memory allocated in the previous calls.
619//
620// Usage :-
621//   ResourceTracker rt(env);
622//   :
623//   err = rt.allocate(1024, &ptr);

625class ResourceTracker : public StackObj {
private:
JvmtiEnv* _env;
GrowableArray<unsigned char*> *_allocations;
bool _failed;
public:
ResourceTracker(JvmtiEnv* env);
~ResourceTracker();
jvmtiError allocate(jlong size, unsigned char** mem_ptr);
unsigned char* allocate(jlong size);
char* strdup(const char* str);
636};


639// Jvmti monitor closure to collect off stack monitors.
640class JvmtiMonitorClosure: public MonitorClosure {
private:
JavaThread *_calling_thread;
GrowableArray<jvmtiMonitorStackDepthInfo*> *_owned_monitors_list;
jvmtiError _error;
JvmtiEnvBase *_env;

public:
JvmtiMonitorClosure(JavaThread *calling_thread,
                    GrowableArray<jvmtiMonitorStackDepthInfo*> *owned_monitors,
                    JvmtiEnvBase *env) {
  _calling_thread = calling_thread;
  _owned_monitors_list = owned_monitors;
  _error = JVMTI_ERROR_NONE;
  _env = env;
}
void do_monitor(ObjectMonitor* mon);
jvmtiError error() { return _error;}
658};


661// Jvmti module closure to collect all modules loaded to the system.
662class JvmtiModuleClosure : public StackObj {
663private:
static GrowableArray<OopHandle> *_tbl; // Protected with Module_lock

static void do_module(ModuleEntry* entry);
667public:
jvmtiError get_all_modules(JvmtiEnv* env, jint* module_count_ptr, jobject** modules_ptr);
669};

671#endif // SHARE_PRIMS_JVMTIENVBASE_HPP