#endif // SHARE_VM_PRIMS_JVMTIUTIL_HPP
C:\hotspot-69087d08d473\src\share\vm/prims/jvm_misc.hpp
#ifndef SHARE_VM_PRIMS_JVM_MISC_HPP
#define SHARE_VM_PRIMS_JVM_MISC_HPP
#include "prims/jni.h"
#include "runtime/handles.hpp"
jclass find_class_from_class_loader(JNIEnv* env, Symbol* name, jboolean init, Handle loader, Handle protection_domain, jboolean throwError, TRAPS);
void trace_class_resolution(Klass* to_class);
extern struct JNINativeInterface_* jni_functions_nocheck();
extern struct JNINativeInterface_* jni_functions_check();
extern struct JNINativeInterface_* jni_functions();
extern void copy_jni_function_table(const struct JNINativeInterface_* new_function_table);
extern "C" {
typedef jboolean (JNICALL *GetBooleanField_t)
(JNIEnv *env, jobject obj, jfieldID fieldID);
typedef jbyte (JNICALL *GetByteField_t)
(JNIEnv *env, jobject obj, jfieldID fieldID);
typedef jchar (JNICALL *GetCharField_t)
(JNIEnv *env, jobject obj, jfieldID fieldID);
typedef jshort (JNICALL *GetShortField_t)
(JNIEnv *env, jobject obj, jfieldID fieldID);
typedef jint (JNICALL *GetIntField_t)
(JNIEnv *env, jobject obj, jfieldID fieldID);
typedef jlong (JNICALL *GetLongField_t)
(JNIEnv *env, jobject obj, jfieldID fieldID);
typedef jfloat (JNICALL *GetFloatField_t)
(JNIEnv *env, jobject obj, jfieldID fieldID);
typedef jdouble (JNICALL *GetDoubleField_t)
(JNIEnv *env, jobject obj, jfieldID fieldID);
}
void quicken_jni_functions();
address jni_GetBooleanField_addr();
address jni_GetByteField_addr();
address jni_GetCharField_addr();
address jni_GetShortField_addr();
address jni_GetIntField_addr();
address jni_GetLongField_addr();
address jni_GetFloatField_addr();
address jni_GetDoubleField_addr();
#endif // SHARE_VM_PRIMS_JVM_MISC_HPP
C:\hotspot-69087d08d473\src\share\vm/prims/methodComparator.cpp
#include "precompiled.hpp"
#include "oops/oop.inline.hpp"
#include "oops/symbol.hpp"
#include "prims/jvmtiRedefineClassesTrace.hpp"
#include "prims/methodComparator.hpp"
#include "runtime/handles.inline.hpp"
#include "utilities/globalDefinitions.hpp"
BytecodeStream *MethodComparator::_s_old;
BytecodeStream *MethodComparator::_s_new;
ConstantPool* MethodComparator::_old_cp;
ConstantPool* MethodComparator::_new_cp;
BciMap *MethodComparator::_bci_map;
bool MethodComparator::_switchable_test;
GrowableArray<int> *MethodComparator::_fwd_jmps;
bool MethodComparator::methods_EMCP(Method* old_method, Method* new_method) {
if (old_method->code_size() != new_method->code_size())
return false;
if (check_stack_and_locals_size(old_method, new_method) != 0) {
RC_TRACE(0x00800000, ("Methods %s non-comparable with diagnosis %d",
old_method->name()->as_C_string(),
check_stack_and_locals_size(old_method, new_method)));
return false;
}
_old_cp = old_method->constants();
_new_cp = new_method->constants();
BytecodeStream s_old(old_method);
BytecodeStream s_new(new_method);
_s_old = &s_old;
_s_new = &s_new;
_switchable_test = false;
Bytecodes::Code c_old, c_new;
while ((c_old = s_old.next()) >= 0) {
if ((c_new = s_new.next()) < 0 || c_old != c_new)
return false;
if (! args_same(c_old, c_new))
return false;
}
return true;
}
bool MethodComparator::methods_switchable(Method* old_method, Method* new_method,
BciMap &bci_map) {
if (old_method->code_size() > new_method->code_size())
return false;
if (! check_stack_and_locals_size(old_method, new_method))
return false;
_old_cp = old_method->constants();
_new_cp = new_method->constants();
BytecodeStream s_old(old_method);
BytecodeStream s_new(new_method);
_s_old = &s_old;
_s_new = &s_new;
_bci_map = &bci_map;
_switchable_test = true;
GrowableArray<int> fwd_jmps(16);
_fwd_jmps = &fwd_jmps;
Bytecodes::Code c_old, c_new;
while ((c_old = s_old.next()) >= 0) {
if ((c_new = s_new.next()) < 0)
return false;
if (! (c_old == c_new && args_same(c_old, c_new))) {
int old_bci = s_old.bci();
int new_st_bci = s_new.bci();
bool found_match = false;
do {
c_new = s_new.next();
if (c_new == c_old && args_same(c_old, c_new)) {
found_match = true;
break;
}
} while (c_new >= 0);
if (! found_match)
return false;
int new_end_bci = s_new.bci();
bci_map.store_fragment_location(old_bci, new_st_bci, new_end_bci);
}
}
for (int i = 0; i < fwd_jmps.length() / 2; i++) {
if (! bci_map.old_and_new_locations_same(fwd_jmps.at(i*2), fwd_jmps.at(i*2+1))) {
RC_TRACE(0x00800000,
("Fwd jump miss: old dest = %d, calc new dest = %d, act new dest = %d",
fwd_jmps.at(i*2), bci_map.new_bci_for_old(fwd_jmps.at(i*2)),
fwd_jmps.at(i*2+1)));
return false;
}
}
return true;
}
bool MethodComparator::args_same(Bytecodes::Code c_old, Bytecodes::Code c_new) {
switch (c_old) {
case Bytecodes::_new : // fall through
case Bytecodes::_anewarray : // fall through
case Bytecodes::_multianewarray : // fall through
case Bytecodes::_checkcast : // fall through
case Bytecodes::_instanceof : {
u2 cpi_old = _s_old->get_index_u2();
u2 cpi_new = _s_new->get_index_u2();
if ((_old_cp->klass_at_noresolve(cpi_old) != _new_cp->klass_at_noresolve(cpi_new)))
return false;
if (c_old == Bytecodes::_multianewarray &&
return false;
break;
}
case Bytecodes::_getstatic : // fall through
case Bytecodes::_putstatic : // fall through
case Bytecodes::_getfield : // fall through
case Bytecodes::_putfield : // fall through
case Bytecodes::_invokevirtual : // fall through
case Bytecodes::_invokespecial : // fall through
case Bytecodes::_invokestatic : // fall through
case Bytecodes::_invokeinterface : {
int cpci_old = _s_old->get_index_u2_cpcache();
int cpci_new = _s_new->get_index_u2_cpcache();
if ((_old_cp->klass_ref_at_noresolve(cpci_old) != _new_cp->klass_ref_at_noresolve(cpci_new)) ||
(_old_cp->name_ref_at(cpci_old) != _new_cp->name_ref_at(cpci_new)) ||
(_old_cp->signature_ref_at(cpci_old) != _new_cp->signature_ref_at(cpci_new)))
return false;
break;
}
case Bytecodes::_invokedynamic: {
int cpci_old = _s_old->get_index_u4();
int cpci_new = _s_new->get_index_u4();
if ((_old_cp->name_ref_at(cpci_old) != _new_cp->name_ref_at(cpci_new)) ||
(_old_cp->signature_ref_at(cpci_old) != _new_cp->signature_ref_at(cpci_new)))
return false;
cpci_old = _old_cp->invokedynamic_cp_cache_index(cpci_old);
cpci_new = _new_cp->invokedynamic_cp_cache_index(cpci_new);
int cpi_old = _old_cp->cache()->entry_at(cpci_old)->constant_pool_index();
int cpi_new = _new_cp->cache()->entry_at(cpci_new)->constant_pool_index();
int bsm_old = _old_cp->invoke_dynamic_bootstrap_method_ref_index_at(cpi_old);
int bsm_new = _new_cp->invoke_dynamic_bootstrap_method_ref_index_at(cpi_new);
if (!pool_constants_same(bsm_old, bsm_new))
return false;
int cnt_old = _old_cp->invoke_dynamic_argument_count_at(cpi_old);
int cnt_new = _new_cp->invoke_dynamic_argument_count_at(cpi_new);
if (cnt_old != cnt_new)
return false;
for (int arg_i = 0; arg_i < cnt_old; arg_i++) {
int idx_old = _old_cp->invoke_dynamic_argument_index_at(cpi_old, arg_i);
int idx_new = _new_cp->invoke_dynamic_argument_index_at(cpi_new, arg_i);
if (!pool_constants_same(idx_old, idx_new))
return false;
}
break;
}
case Bytecodes::_ldc : // fall through
case Bytecodes::_ldc_w : {
Bytecode_loadconstant ldc_old(_s_old->method(), _s_old->bci());
Bytecode_loadconstant ldc_new(_s_new->method(), _s_new->bci());
int cpi_old = ldc_old.pool_index();
int cpi_new = ldc_new.pool_index();
if (!pool_constants_same(cpi_old, cpi_new))
return false;
break;
}
case Bytecodes::_ldc2_w : {
u2 cpi_old = _s_old->get_index_u2();
u2 cpi_new = _s_new->get_index_u2();
constantTag tag_old = _old_cp->tag_at(cpi_old);
constantTag tag_new = _new_cp->tag_at(cpi_new);
if (tag_old.value() != tag_new.value())
return false;
if (tag_old.is_long()) {
if (_old_cp->long_at(cpi_old) != _new_cp->long_at(cpi_new))
return false;
} else {
if (jlong_cast(_old_cp->double_at(cpi_old)) != jlong_cast(_new_cp->double_at(cpi_new)))
return false;
}
break;
}
case Bytecodes::_bipush :
if (_s_old->bcp()[1] != _s_new->bcp()[1])
return false;
break;
case Bytecodes::_sipush :
if (_s_old->get_index_u2() != _s_new->get_index_u2())
return false;
break;
case Bytecodes::_aload : // fall through
case Bytecodes::_astore : // fall through
case Bytecodes::_dload : // fall through
case Bytecodes::_dstore : // fall through
case Bytecodes::_fload : // fall through
case Bytecodes::_fstore : // fall through
case Bytecodes::_iload : // fall through
case Bytecodes::_istore : // fall through
case Bytecodes::_lload : // fall through
case Bytecodes::_lstore : // fall through
case Bytecodes::_ret :
if (_s_old->is_wide() != _s_new->is_wide())
return false;
if (_s_old->get_index() != _s_new->get_index())
return false;
break;
case Bytecodes::_goto : // fall through
case Bytecodes::_if_acmpeq : // fall through
case Bytecodes::_if_acmpne : // fall through
case Bytecodes::_if_icmpeq : // fall through
case Bytecodes::_if_icmpne : // fall through
case Bytecodes::_if_icmplt : // fall through
case Bytecodes::_if_icmpge : // fall through
case Bytecodes::_if_icmpgt : // fall through
case Bytecodes::_if_icmple : // fall through
case Bytecodes::_ifeq : // fall through
case Bytecodes::_ifne : // fall through
case Bytecodes::_iflt : // fall through
case Bytecodes::_ifge : // fall through
case Bytecodes::_ifgt : // fall through
case Bytecodes::_ifle : // fall through
case Bytecodes::_ifnonnull : // fall through
case Bytecodes::_ifnull : // fall through
case Bytecodes::_jsr : {
int old_ofs = _s_old->bytecode().get_offset_s2(c_old);
int new_ofs = _s_new->bytecode().get_offset_s2(c_new);
if (_switchable_test) {
int old_dest = _s_old->bci() + old_ofs;
int new_dest = _s_new->bci() + new_ofs;
if (old_ofs < 0 && new_ofs < 0) {
if (! _bci_map->old_and_new_locations_same(old_dest, new_dest))
return false;
} else if (old_ofs > 0 && new_ofs > 0) {
_fwd_jmps->append(old_dest);
_fwd_jmps->append(new_dest);
} else {
return false;
}
} else {
if (old_ofs != new_ofs)
return false;
}
break;
}
case Bytecodes::_iinc :
if (_s_old->is_wide() != _s_new->is_wide())
return false;
if (! _s_old->is_wide()) {
if (Bytes::get_Java_u2(_s_old->bcp() + 1) != Bytes::get_Java_u2(_s_new->bcp() + 1))
return false;
} else {
if (Bytes::get_Java_u4(_s_old->bcp() + 1) != Bytes::get_Java_u4(_s_new->bcp() + 1))
return false;
}
break;
case Bytecodes::_goto_w : // fall through
case Bytecodes::_jsr_w : {
int old_ofs = _s_old->bytecode().get_offset_s4(c_old);
int new_ofs = _s_new->bytecode().get_offset_s4(c_new);
if (_switchable_test) {
int old_dest = _s_old->bci() + old_ofs;
int new_dest = _s_new->bci() + new_ofs;
if (old_ofs < 0 && new_ofs < 0) {
if (! _bci_map->old_and_new_locations_same(old_dest, new_dest))
return false;
} else if (old_ofs > 0 && new_ofs > 0) {
_fwd_jmps->append(old_dest);
_fwd_jmps->append(new_dest);
} else {
return false;
}
} else {
if (old_ofs != new_ofs)
return false;
}
break;
}
case Bytecodes::_lookupswitch : // fall through
case Bytecodes::_tableswitch : {
if (_switchable_test) {
address aligned_bcp_old = (address) round_to((intptr_t)_s_old->bcp() + 1, jintSize);
address aligned_bcp_new = (address) round_to((intptr_t)_s_new->bcp() + 1, jintSize);
int default_old = (int) Bytes::get_Java_u4(aligned_bcp_old);
int default_new = (int) Bytes::get_Java_u4(aligned_bcp_new);
_fwd_jmps->append(_s_old->bci() + default_old);
_fwd_jmps->append(_s_new->bci() + default_new);
if (c_old == Bytecodes::_lookupswitch) {
int npairs_old = (int) Bytes::get_Java_u4(aligned_bcp_old + jintSize);
int npairs_new = (int) Bytes::get_Java_u4(aligned_bcp_new + jintSize);
if (npairs_old != npairs_new)
return false;
for (int i = 0; i < npairs_old; i++) {
int match_old = (int) Bytes::get_Java_u4(aligned_bcp_old + (2+2*i)*jintSize);
int match_new = (int) Bytes::get_Java_u4(aligned_bcp_new + (2+2*i)*jintSize);
if (match_old != match_new)
return false;
int ofs_old = (int) Bytes::get_Java_u4(aligned_bcp_old + (2+2*i+1)*jintSize);
int ofs_new = (int) Bytes::get_Java_u4(aligned_bcp_new + (2+2*i+1)*jintSize);
_fwd_jmps->append(_s_old->bci() + ofs_old);
_fwd_jmps->append(_s_new->bci() + ofs_new);
}
} else if (c_old == Bytecodes::_tableswitch) {
int lo_old = (int) Bytes::get_Java_u4(aligned_bcp_old + jintSize);
int lo_new = (int) Bytes::get_Java_u4(aligned_bcp_new + jintSize);
if (lo_old != lo_new)
return false;
int hi_old = (int) Bytes::get_Java_u4(aligned_bcp_old + 2*jintSize);
int hi_new = (int) Bytes::get_Java_u4(aligned_bcp_new + 2*jintSize);
if (hi_old != hi_new)
return false;
for (int i = 0; i < hi_old - lo_old + 1; i++) {
int ofs_old = (int) Bytes::get_Java_u4(aligned_bcp_old + (3+i)*jintSize);
int ofs_new = (int) Bytes::get_Java_u4(aligned_bcp_new + (3+i)*jintSize);
_fwd_jmps->append(_s_old->bci() + ofs_old);
_fwd_jmps->append(_s_new->bci() + ofs_new);
}
}
} else { // !_switchable_test, can use fast rough compare
int len_old = _s_old->instruction_size();
int len_new = _s_new->instruction_size();
if (len_old != len_new)
return false;
if (memcmp(_s_old->bcp(), _s_new->bcp(), len_old) != 0)
return false;
}
break;
}
}
return true;
}
bool MethodComparator::pool_constants_same(int cpi_old, int cpi_new) {
constantTag tag_old = _old_cp->tag_at(cpi_old);
constantTag tag_new = _new_cp->tag_at(cpi_new);
if (tag_old.is_int() || tag_old.is_float()) {
if (tag_old.value() != tag_new.value())
return false;
if (tag_old.is_int()) {
if (_old_cp->int_at(cpi_old) != _new_cp->int_at(cpi_new))
return false;
} else {
if (jint_cast(_old_cp->float_at(cpi_old)) != jint_cast(_new_cp->float_at(cpi_new)))
return false;
}
} else if (tag_old.is_string() && tag_new.is_string()) {
if (strcmp(_old_cp->string_at_noresolve(cpi_old),
_new_cp->string_at_noresolve(cpi_new)) != 0)
return false;
} else if (tag_old.is_klass() || tag_old.is_unresolved_klass()) {
if (! (tag_new.is_unresolved_klass() || tag_new.is_klass()))
return false;
if (_old_cp->klass_at_noresolve(cpi_old) !=
_new_cp->klass_at_noresolve(cpi_new))
return false;
} else if (tag_old.is_method_type() && tag_new.is_method_type()) {
int mti_old = _old_cp->method_type_index_at(cpi_old);
int mti_new = _new_cp->method_type_index_at(cpi_new);
if ((_old_cp->symbol_at(mti_old) != _new_cp->symbol_at(mti_new)))
return false;
} else if (tag_old.is_method_handle() && tag_new.is_method_handle()) {
if (_old_cp->method_handle_ref_kind_at(cpi_old) !=
_new_cp->method_handle_ref_kind_at(cpi_new))
return false;
int mhi_old = _old_cp->method_handle_index_at(cpi_old);
int mhi_new = _new_cp->method_handle_index_at(cpi_new);
if ((_old_cp->uncached_klass_ref_at_noresolve(mhi_old) != _new_cp->uncached_klass_ref_at_noresolve(mhi_new)) ||
(_old_cp->uncached_name_ref_at(mhi_old) != _new_cp->uncached_name_ref_at(mhi_new)) ||
(_old_cp->uncached_signature_ref_at(mhi_old) != _new_cp->uncached_signature_ref_at(mhi_new)))
return false;
} else {
return false; // unknown tag
}
return true;
}
int MethodComparator::check_stack_and_locals_size(Method* old_method, Method* new_method) {
if (old_method->max_stack() != new_method->max_stack()) {
return 1;
} else if (old_method->max_locals() != new_method->max_locals()) {
return 2;
} else if (old_method->size_of_parameters() != new_method->size_of_parameters()) {
return 3;
} else return 0;
}
C:\hotspot-69087d08d473\src\share\vm/prims/methodComparator.hpp
#ifndef SHARE_VM_PRIMS_METHODCOMPARATOR_HPP
#define SHARE_VM_PRIMS_METHODCOMPARATOR_HPP
#include "interpreter/bytecodeStream.hpp"
#include "oops/constantPool.hpp"
#include "oops/method.hpp"
class BciMap;
class MethodComparator {
private:
static BytecodeStream *_s_old, *_s_new;
static ConstantPool* _old_cp;
static ConstantPool* _new_cp;
static BciMap *_bci_map;
static bool _switchable_test;
static GrowableArray<int> *_fwd_jmps;
static bool args_same(Bytecodes::Code c_old, Bytecodes::Code c_new);
static bool pool_constants_same(int cpi_old, int cpi_new);
static int check_stack_and_locals_size(Method* old_method, Method* new_method);
public:
static bool methods_EMCP(Method* old_method, Method* new_method);
static bool methods_switchable(Method* old_method, Method* new_method, BciMap &bci_map);
};
class BciMap {
private:
int *_old_bci, *_new_st_bci, *_new_end_bci;
int _cur_size, _cur_pos;
int _pos;
public:
BciMap() {
_cur_size = 50;
_old_bci = (int*) malloc(sizeof(int) * _cur_size);
_new_st_bci = (int*) malloc(sizeof(int) * _cur_size);
_new_end_bci = (int*) malloc(sizeof(int) * _cur_size);
_cur_pos = 0;
}
~BciMap() {
free(_old_bci);
free(_new_st_bci);
free(_new_end_bci);
}
void store_fragment_location(int old_bci, int new_st_bci, int new_end_bci) {
if (_cur_pos == _cur_size) {
_cur_size += 10;
_old_bci = (int*) realloc(_old_bci, sizeof(int) * _cur_size);
_new_st_bci = (int*) realloc(_new_st_bci, sizeof(int) * _cur_size);
_new_end_bci = (int*) realloc(_new_end_bci, sizeof(int) * _cur_size);
}
_old_bci[_cur_pos] = old_bci;
_new_st_bci[_cur_pos] = new_st_bci;
_new_end_bci[_cur_pos] = new_end_bci;
_cur_pos++;
}
int new_bci_for_old(int old_bci) {
if (_cur_pos == 0 || old_bci < _old_bci[0]) return old_bci;
_pos = 1;
while (_pos < _cur_pos && old_bci >= _old_bci[_pos])
_pos++;
return _new_end_bci[_pos-1] + (old_bci - _old_bci[_pos-1]);
}
bool old_and_new_locations_same(int old_dest_bci, int new_dest_bci) {
if (new_bci_for_old(old_dest_bci) == new_dest_bci)
return true;
else if (_old_bci[_pos-1] == old_dest_bci)
return (new_dest_bci == _new_st_bci[_pos-1]);
else return false;
}
};
#endif // SHARE_VM_PRIMS_METHODCOMPARATOR_HPP
C:\hotspot-69087d08d473\src\share\vm/prims/methodHandles.cpp
#include "precompiled.hpp"
#include "classfile/symbolTable.hpp"
#include "compiler/compileBroker.hpp"
#include "interpreter/interpreter.hpp"
#include "interpreter/oopMapCache.hpp"
#include "memory/allocation.inline.hpp"
#include "memory/oopFactory.hpp"
#include "prims/methodHandles.hpp"
#include "prims/jvmtiRedefineClassesTrace.hpp"
#include "runtime/compilationPolicy.hpp"
#include "runtime/javaCalls.hpp"
#include "runtime/reflection.hpp"
#include "runtime/signature.hpp"
#include "runtime/stubRoutines.hpp"
bool MethodHandles::_enabled = false; // set true after successful native linkage
MethodHandlesAdapterBlob* MethodHandles::_adapter_code = NULL;
void MethodHandles::generate_adapters() {
if (!EnableInvokeDynamic || SystemDictionary::MethodHandle_klass() == NULL) return;
assert(_adapter_code == NULL, "generate only once");
ResourceMark rm;
TraceTime timer("MethodHandles adapters generation", TraceStartupTime);
_adapter_code = MethodHandlesAdapterBlob::create(adapter_code_size);
if (_adapter_code == NULL)
vm_exit_out_of_memory(adapter_code_size, OOM_MALLOC_ERROR,
"CodeCache: no room for MethodHandles adapters");
{
CodeBuffer code(_adapter_code);
MethodHandlesAdapterGenerator g(&code);
g.generate();
code.log_section_sizes("MethodHandlesAdapterBlob");
}
}
void MethodHandlesAdapterGenerator::generate() {
for (Interpreter::MethodKind mk = Interpreter::method_handle_invoke_FIRST;
mk <= Interpreter::method_handle_invoke_LAST;
mk = Interpreter::MethodKind(1 + (int)mk)) {
vmIntrinsics::ID iid = Interpreter::method_handle_intrinsic(mk);
StubCodeMark mark(this, "MethodHandle::interpreter_entry", vmIntrinsics::name_at(iid));
address entry = MethodHandles::generate_method_handle_interpreter_entry(_masm, iid);
if (entry != NULL) {
Interpreter::set_entry_for_kind(mk, entry);
}
}
}
void MethodHandles::set_enabled(bool z) {
if (_enabled != z) {
guarantee(z && EnableInvokeDynamic, "can only enable once, and only if -XX:+EnableInvokeDynamic");
_enabled = z;
}
}
enum {
IS_METHOD = java_lang_invoke_MemberName::MN_IS_METHOD,
IS_CONSTRUCTOR = java_lang_invoke_MemberName::MN_IS_CONSTRUCTOR,
IS_FIELD = java_lang_invoke_MemberName::MN_IS_FIELD,
IS_TYPE = java_lang_invoke_MemberName::MN_IS_TYPE,
CALLER_SENSITIVE = java_lang_invoke_MemberName::MN_CALLER_SENSITIVE,
REFERENCE_KIND_SHIFT = java_lang_invoke_MemberName::MN_REFERENCE_KIND_SHIFT,
REFERENCE_KIND_MASK = java_lang_invoke_MemberName::MN_REFERENCE_KIND_MASK,
SEARCH_SUPERCLASSES = java_lang_invoke_MemberName::MN_SEARCH_SUPERCLASSES,
SEARCH_INTERFACES = java_lang_invoke_MemberName::MN_SEARCH_INTERFACES,
ALL_KINDS = IS_METHOD | IS_CONSTRUCTOR | IS_FIELD | IS_TYPE
};
Handle MethodHandles::new_MemberName(TRAPS) {
Handle empty;
instanceKlassHandle k(THREAD, SystemDictionary::MemberName_klass());
if (!k->is_initialized()) k->initialize(CHECK_(empty));
return Handle(THREAD, k->allocate_instance(THREAD));
}
oop MethodHandles::init_MemberName(Handle mname, Handle target) {
Thread* thread = Thread::current();
oop target_oop = target();
Klass* target_klass = target_oop->klass();
if (target_klass == SystemDictionary::reflect_Field_klass()) {
oop clazz = java_lang_reflect_Field::clazz(target_oop); // fd.field_holder()
int slot = java_lang_reflect_Field::slot(target_oop); // fd.index()
KlassHandle k(thread, java_lang_Class::as_Klass(clazz));
if (!k.is_null() && k->oop_is_instance()) {
fieldDescriptor fd(InstanceKlass::cast(k()), slot);
oop mname2 = init_field_MemberName(mname, fd);
if (mname2 != NULL) {
if (java_lang_invoke_MemberName::name(mname2) == NULL)
java_lang_invoke_MemberName::set_name(mname2, java_lang_reflect_Field::name(target_oop));
if (java_lang_invoke_MemberName::type(mname2) == NULL)
java_lang_invoke_MemberName::set_type(mname2, java_lang_reflect_Field::type(target_oop));
}
return mname2;
}
} else if (target_klass == SystemDictionary::reflect_Method_klass()) {
oop clazz = java_lang_reflect_Method::clazz(target_oop);
int slot = java_lang_reflect_Method::slot(target_oop);
KlassHandle k(thread, java_lang_Class::as_Klass(clazz));
if (!k.is_null() && k->oop_is_instance()) {
Method* m = InstanceKlass::cast(k())->method_with_idnum(slot);
if (m == NULL || is_signature_polymorphic(m->intrinsic_id()))
return NULL; // do not resolve unless there is a concrete signature
CallInfo info(m, k());
return init_method_MemberName(mname, info);
}
} else if (target_klass == SystemDictionary::reflect_Constructor_klass()) {
oop clazz = java_lang_reflect_Constructor::clazz(target_oop);
int slot = java_lang_reflect_Constructor::slot(target_oop);
KlassHandle k(thread, java_lang_Class::as_Klass(clazz));
if (!k.is_null() && k->oop_is_instance()) {
Method* m = InstanceKlass::cast(k())->method_with_idnum(slot);
if (m == NULL) return NULL;
CallInfo info(m, k());
return init_method_MemberName(mname, info);
}
}
return NULL;
}
oop MethodHandles::init_method_MemberName(Handle mname, CallInfo& info, bool intern) {
assert(info.resolved_appendix().is_null(), "only normal methods here");
methodHandle m = info.resolved_method();
assert(m.not_null(), "null method handle");
KlassHandle m_klass = m->method_holder();
assert(m.not_null(), "null holder for method handle");
int flags = (jushort)( m->access_flags().as_short() & JVM_RECOGNIZED_METHOD_MODIFIERS );
int vmindex = Method::invalid_vtable_index;
switch (info.call_kind()) {
case CallInfo::itable_call:
vmindex = info.itable_index();
assert(m_klass->verify_itable_index(vmindex), "");
flags |= IS_METHOD | (JVM_REF_invokeInterface << REFERENCE_KIND_SHIFT);
if (TraceInvokeDynamic) {
ResourceMark rm;
tty->print_cr("memberName: invokeinterface method_holder::method: %s, itableindex: %d, access_flags:",
Method::name_and_sig_as_C_string(m->method_holder(), m->name(), m->signature()),
vmindex);
m->access_flags().print_on(tty);
if (!m->is_abstract()) {
tty->print("default");
}
tty->cr();
}
break;
case CallInfo::vtable_call:
vmindex = info.vtable_index();
flags |= IS_METHOD | (JVM_REF_invokeVirtual << REFERENCE_KIND_SHIFT);
assert(info.resolved_klass()->is_subtype_of(m_klass()), "virtual call must be type-safe");
if (m_klass->is_interface()) {
KlassHandle m_klass_non_interface = info.resolved_klass();
if (m_klass_non_interface->is_interface()) {
m_klass_non_interface = SystemDictionary::Object_klass();
#ifdef ASSERT
{ ResourceMark rm;
Method* m2 = m_klass_non_interface->vtable()->method_at(vmindex);
assert(m->name() == m2->name() && m->signature() == m2->signature(),
err_msg("at %d, %s != %s", vmindex,
m->name_and_sig_as_C_string(), m2->name_and_sig_as_C_string()));
}
#endif //ASSERT
}
if (!m->is_public()) {
assert(m->is_public(), "virtual call must be to public interface method");
return NULL; // elicit an error later in product build
}
assert(info.resolved_klass()->is_subtype_of(m_klass_non_interface()), "virtual call must be type-safe");
m_klass = m_klass_non_interface;
}
if (TraceInvokeDynamic) {
ResourceMark rm;
tty->print_cr("memberName: invokevirtual method_holder::method: %s, receiver: %s, vtableindex: %d, access_flags:",
Method::name_and_sig_as_C_string(m->method_holder(), m->name(), m->signature()),
m_klass->internal_name(), vmindex);
m->access_flags().print_on(tty);
if (m->is_default_method()) {
tty->print("default");
}
tty->cr();
}
break;
case CallInfo::direct_call:
vmindex = Method::nonvirtual_vtable_index;
if (m->is_static()) {
flags |= IS_METHOD | (JVM_REF_invokeStatic << REFERENCE_KIND_SHIFT);
} else if (m->is_initializer()) {
flags |= IS_CONSTRUCTOR | (JVM_REF_invokeSpecial << REFERENCE_KIND_SHIFT);
} else {
flags |= IS_METHOD | (JVM_REF_invokeSpecial << REFERENCE_KIND_SHIFT);
}
break;
default: assert(false, "bad CallInfo"); return NULL;
}
if (m->caller_sensitive()) {
flags |= CALLER_SENSITIVE;
}
oop mname_oop = mname();
java_lang_invoke_MemberName::set_flags( mname_oop, flags);
java_lang_invoke_MemberName::set_vmtarget(mname_oop, m());
java_lang_invoke_MemberName::set_vmindex( mname_oop, vmindex); // vtable/itable index
java_lang_invoke_MemberName::set_clazz( mname_oop, m_klass->java_mirror());
return m->method_holder()->add_member_name(mname, intern);
}
oop MethodHandles::init_field_MemberName(Handle mname, fieldDescriptor& fd, bool is_setter) {
int flags = (jushort)( fd.access_flags().as_short() & JVM_RECOGNIZED_FIELD_MODIFIERS );
flags |= IS_FIELD | ((fd.is_static() ? JVM_REF_getStatic : JVM_REF_getField) << REFERENCE_KIND_SHIFT);
if (is_setter) flags += ((JVM_REF_putField - JVM_REF_getField) << REFERENCE_KIND_SHIFT);
Metadata* vmtarget = fd.field_holder();
int vmindex = fd.offset(); // determines the field uniquely when combined with static bit
oop mname_oop = mname();
java_lang_invoke_MemberName::set_flags(mname_oop, flags);
java_lang_invoke_MemberName::set_vmtarget(mname_oop, vmtarget);
java_lang_invoke_MemberName::set_vmindex(mname_oop, vmindex);
java_lang_invoke_MemberName::set_clazz(mname_oop, fd.field_holder()->java_mirror());
oop type = field_signature_type_or_null(fd.signature());
oop name = field_name_or_null(fd.name());
if (name != NULL)
java_lang_invoke_MemberName::set_name(mname_oop, name);
if (type != NULL)
java_lang_invoke_MemberName::set_type(mname_oop, type);
return mname();
}
bool MethodHandles::is_method_handle_invoke_name(Klass* klass, Symbol* name) {
if (klass == NULL)
return false;
if (klass->name() != vmSymbols::java_lang_invoke_MethodHandle())
return false;
Symbol* poly_sig = vmSymbols::object_array_object_signature();
Method* m = InstanceKlass::cast(klass)->find_method(name, poly_sig);
if (m == NULL) return false;
int required = JVM_ACC_NATIVE | JVM_ACC_VARARGS;
int flags = m->access_flags().as_int();
return (flags & required) == required;
}
Symbol* MethodHandles::signature_polymorphic_intrinsic_name(vmIntrinsics::ID iid) {
assert(is_signature_polymorphic_intrinsic(iid), err_msg("iid=%d", iid));
switch (iid) {
case vmIntrinsics::_invokeBasic: return vmSymbols::invokeBasic_name();
case vmIntrinsics::_linkToVirtual: return vmSymbols::linkToVirtual_name();
case vmIntrinsics::_linkToStatic: return vmSymbols::linkToStatic_name();
case vmIntrinsics::_linkToSpecial: return vmSymbols::linkToSpecial_name();
case vmIntrinsics::_linkToInterface: return vmSymbols::linkToInterface_name();
}
assert(false, "");
return 0;
}
int MethodHandles::signature_polymorphic_intrinsic_ref_kind(vmIntrinsics::ID iid) {
switch (iid) {
case vmIntrinsics::_invokeBasic: return 0;
case vmIntrinsics::_linkToVirtual: return JVM_REF_invokeVirtual;
case vmIntrinsics::_linkToStatic: return JVM_REF_invokeStatic;
case vmIntrinsics::_linkToSpecial: return JVM_REF_invokeSpecial;
case vmIntrinsics::_linkToInterface: return JVM_REF_invokeInterface;
}
assert(false, err_msg("iid=%d", iid));
return 0;
}
vmIntrinsics::ID MethodHandles::signature_polymorphic_name_id(Symbol* name) {
vmSymbols::SID name_id = vmSymbols::find_sid(name);
switch (name_id) {
case vmSymbols::VM_SYMBOL_ENUM_NAME(invoke_name): return vmIntrinsics::_invokeGeneric;
case vmSymbols::VM_SYMBOL_ENUM_NAME(invokeBasic_name): return vmIntrinsics::_invokeBasic;
case vmSymbols::VM_SYMBOL_ENUM_NAME(linkToVirtual_name): return vmIntrinsics::_linkToVirtual;
case vmSymbols::VM_SYMBOL_ENUM_NAME(linkToStatic_name): return vmIntrinsics::_linkToStatic;
case vmSymbols::VM_SYMBOL_ENUM_NAME(linkToSpecial_name): return vmIntrinsics::_linkToSpecial;
case vmSymbols::VM_SYMBOL_ENUM_NAME(linkToInterface_name): return vmIntrinsics::_linkToInterface;
}
Klass* mh_klass = SystemDictionary::well_known_klass(
SystemDictionary::WK_KLASS_ENUM_NAME(MethodHandle_klass) );
if (mh_klass != NULL && is_method_handle_invoke_name(mh_klass, name))
return vmIntrinsics::_invokeGeneric;
return vmIntrinsics::_none;
}
vmIntrinsics::ID MethodHandles::signature_polymorphic_name_id(Klass* klass, Symbol* name) {
if (klass != NULL &&
klass->name() == vmSymbols::java_lang_invoke_MethodHandle()) {
vmIntrinsics::ID iid = signature_polymorphic_name_id(name);
if (iid != vmIntrinsics::_none)
return iid;
if (is_method_handle_invoke_name(klass, name))
return vmIntrinsics::_invokeGeneric;
}
return vmIntrinsics::_none;
}
Symbol* MethodHandles::lookup_signature(oop type_str, bool intern_if_not_found, TRAPS) {
if (java_lang_invoke_MethodType::is_instance(type_str)) {
return java_lang_invoke_MethodType::as_signature(type_str, intern_if_not_found, THREAD);
} else if (java_lang_Class::is_instance(type_str)) {
return java_lang_Class::as_signature(type_str, false, THREAD);
} else if (java_lang_String::is_instance(type_str)) {
if (intern_if_not_found) {
return java_lang_String::as_symbol(type_str, THREAD);
} else {
return java_lang_String::as_symbol_or_null(type_str);
}
} else {
THROW_MSG_(vmSymbols::java_lang_InternalError(), "unrecognized type", NULL);
}
}
static const char OBJ_SIG[] = "Ljava/lang/Object;";
enum { OBJ_SIG_LEN = 18 };
bool MethodHandles::is_basic_type_signature(Symbol* sig) {
assert(vmSymbols::object_signature()->utf8_length() == (int)OBJ_SIG_LEN, "");
assert(vmSymbols::object_signature()->equals(OBJ_SIG), "");
const int len = sig->utf8_length();
for (int i = 0; i < len; i++) {
switch (sig->byte_at(i)) {
case 'L':
if (sig->index_of_at(i, OBJ_SIG, OBJ_SIG_LEN) != i)
return false;
i += OBJ_SIG_LEN-1; //-1 because of i++ in loop
continue;
case '(': case ')': case 'V':
case 'I': case 'J': case 'F': case 'D':
continue;
default:
return false;
}
}
return true;
}
Symbol* MethodHandles::lookup_basic_type_signature(Symbol* sig, bool keep_last_arg, TRAPS) {
Symbol* bsig = NULL;
if (sig == NULL) {
return sig;
} else if (is_basic_type_signature(sig)) {
sig->increment_refcount();
return sig; // that was easy
} else if (sig->byte_at(0) != '(') {
BasicType bt = char2type(sig->byte_at(0));
if (is_subword_type(bt)) {
bsig = vmSymbols::int_signature();
} else {
assert(bt == T_OBJECT || bt == T_ARRAY, "is_basic_type_signature was false");
bsig = vmSymbols::object_signature();
}
} else {
ResourceMark rm;
stringStream buffer(128);
buffer.put('(');
int arg_pos = 0, keep_arg_pos = -1;
if (keep_last_arg)
keep_arg_pos = ArgumentCount(sig).size() - 1;
for (SignatureStream ss(sig); !ss.is_done(); ss.next()) {
BasicType bt = ss.type();
size_t this_arg_pos = buffer.size();
if (ss.at_return_type()) {
buffer.put(')');
}
if (arg_pos == keep_arg_pos) {
buffer.write((char*) ss.raw_bytes(),
(int) ss.raw_length());
} else if (bt == T_OBJECT || bt == T_ARRAY) {
buffer.write(OBJ_SIG, OBJ_SIG_LEN);
} else {
if (is_subword_type(bt))
bt = T_INT;
buffer.put(type2char(bt));
}
arg_pos++;
}
const char* sigstr = buffer.base();
int siglen = (int) buffer.size();
bsig = SymbolTable::new_symbol(sigstr, siglen, THREAD);
}
assert(is_basic_type_signature(bsig) ||
keep_last_arg, "");
return bsig;
}
void MethodHandles::print_as_basic_type_signature_on(outputStream* st,
Symbol* sig,
bool keep_arrays,
bool keep_basic_names) {
st = st ? st : tty;
int len = sig->utf8_length();
int array = 0;
bool prev_type = false;
for (int i = 0; i < len; i++) {
char ch = sig->byte_at(i);
switch (ch) {
case '(': case ')':
prev_type = false;
st->put(ch);
continue;
case '[':
if (!keep_basic_names && keep_arrays)
st->put(ch);
array++;
continue;
case 'L':
{
if (prev_type) st->put(',');
int start = i+1, slash = start;
while (++i < len && (ch = sig->byte_at(i)) != ';') {
if (ch == '/' || ch == '.' || ch == '$') slash = i+1;
}
if (slash < i) start = slash;
if (!keep_basic_names) {
st->put('L');
} else {
for (int j = start; j < i; j++)
st->put(sig->byte_at(j));
prev_type = true;
}
break;
}
default:
{
if (array && char2type(ch) != T_ILLEGAL && !keep_arrays) {
ch = '[';
array = 0;
}
if (prev_type) st->put(',');
const char* n = NULL;
if (keep_basic_names)
n = type2name(char2type(ch));
if (n == NULL) {
st->put(ch);
} else {
st->print("%s", n);
prev_type = true;
}
break;
}
}
if (prev_type) {
while (array > 0) {
st->print("[]");
--array;
}
}
array = 0;
}
}
static oop object_java_mirror() {
return SystemDictionary::Object_klass()->java_mirror();
}
oop MethodHandles::field_name_or_null(Symbol* s) {
if (s == NULL) return NULL;
return StringTable::lookup(s);
}
oop MethodHandles::field_signature_type_or_null(Symbol* s) {
if (s == NULL) return NULL;
BasicType bt = FieldType::basic_type(s);
if (is_java_primitive(bt)) {
assert(s->utf8_length() == 1, "");
return java_lang_Class::primitive_mirror(bt);
}
if (bt == T_OBJECT) {
if (s == vmSymbols::object_signature()) {
return object_java_mirror();
} else if (s == vmSymbols::class_signature()) {
return SystemDictionary::Class_klass()->java_mirror();
} else if (s == vmSymbols::string_signature()) {
return SystemDictionary::String_klass()->java_mirror();
}
}
return NULL;
}
Handle MethodHandles::resolve_MemberName(Handle mname, KlassHandle caller, TRAPS) {
Handle empty;
assert(java_lang_invoke_MemberName::is_instance(mname()), "");
if (java_lang_invoke_MemberName::vmtarget(mname()) != NULL) {
DEBUG_ONLY(int vmindex = java_lang_invoke_MemberName::vmindex(mname()));
assert(vmindex >= Method::nonvirtual_vtable_index, "");
return mname;
}
Handle defc_oop(THREAD, java_lang_invoke_MemberName::clazz(mname()));
Handle name_str(THREAD, java_lang_invoke_MemberName::name( mname()));
Handle type_str(THREAD, java_lang_invoke_MemberName::type( mname()));
int flags = java_lang_invoke_MemberName::flags(mname());
int ref_kind = (flags >> REFERENCE_KIND_SHIFT) & REFERENCE_KIND_MASK;
if (!ref_kind_is_valid(ref_kind)) {
THROW_MSG_(vmSymbols::java_lang_InternalError(), "obsolete MemberName format", empty);
}
DEBUG_ONLY(int old_vmindex);
assert((old_vmindex = java_lang_invoke_MemberName::vmindex(mname())) == 0, "clean input");
if (defc_oop.is_null() || name_str.is_null() || type_str.is_null()) {
THROW_MSG_(vmSymbols::java_lang_IllegalArgumentException(), "nothing to resolve", empty);
}
instanceKlassHandle defc;
{
Klass* defc_klass = java_lang_Class::as_Klass(defc_oop());
if (defc_klass == NULL) return empty; // a primitive; no resolution possible
if (!defc_klass->oop_is_instance()) {
if (!defc_klass->oop_is_array()) return empty;
defc_klass = SystemDictionary::Object_klass();
}
defc = instanceKlassHandle(THREAD, defc_klass);
}
if (defc.is_null()) {
THROW_MSG_(vmSymbols::java_lang_InternalError(), "primitive class", empty);
}
defc->link_class(CHECK_(empty)); // possible safepoint
TempNewSymbol name = java_lang_String::as_symbol_or_null(name_str());
if (name == NULL) return empty; // no such name
if (name == vmSymbols::class_initializer_name())
return empty; // illegal name
vmIntrinsics::ID mh_invoke_id = vmIntrinsics::_none;
if ((flags & ALL_KINDS) == IS_METHOD &&
(defc() == SystemDictionary::MethodHandle_klass()) &&
(ref_kind == JVM_REF_invokeVirtual ||
ref_kind == JVM_REF_invokeSpecial ||
ref_kind == JVM_REF_invokeStatic)) {
vmIntrinsics::ID iid = signature_polymorphic_name_id(name);
if (iid != vmIntrinsics::_none &&
((ref_kind == JVM_REF_invokeStatic) == is_signature_polymorphic_static(iid))) {
mh_invoke_id = iid;
}
}
TempNewSymbol type = lookup_signature(type_str(), (mh_invoke_id != vmIntrinsics::_none), CHECK_(empty));
if (type == NULL) return empty; // no such signature exists in the VM
switch (flags & ALL_KINDS) {
case IS_METHOD:
{
CallInfo result;
{
assert(!HAS_PENDING_EXCEPTION, "");
if (ref_kind == JVM_REF_invokeStatic) {
LinkResolver::resolve_static_call(result,
defc, name, type, caller, caller.not_null(), false, THREAD);
} else if (ref_kind == JVM_REF_invokeInterface) {
LinkResolver::resolve_interface_call(result, Handle(), defc,
defc, name, type, caller, caller.not_null(), false, THREAD);
} else if (mh_invoke_id != vmIntrinsics::_none) {
assert(!is_signature_polymorphic_static(mh_invoke_id), "");
LinkResolver::resolve_handle_call(result,
defc, name, type, caller, THREAD);
} else if (ref_kind == JVM_REF_invokeSpecial) {
LinkResolver::resolve_special_call(result,
Handle(), defc, name, type, caller, caller.not_null(), THREAD);
} else if (ref_kind == JVM_REF_invokeVirtual) {
LinkResolver::resolve_virtual_call(result, Handle(), defc,
defc, name, type, caller, caller.not_null(), false, THREAD);
} else {
assert(false, err_msg("ref_kind=%d", ref_kind));
}
if (HAS_PENDING_EXCEPTION) {
return empty;
}
}
if (result.resolved_appendix().not_null()) {
THROW_MSG_(vmSymbols::java_lang_InternalError(), "appendix", empty);
}
oop mname2 = init_method_MemberName(mname, result);
return Handle(THREAD, mname2);
}
case IS_CONSTRUCTOR:
{
CallInfo result;
{
assert(!HAS_PENDING_EXCEPTION, "");
if (name == vmSymbols::object_initializer_name()) {
LinkResolver::resolve_special_call(result,
Handle(), defc, name, type, caller, caller.not_null(), THREAD);
} else {
break; // will throw after end of switch
}
if (HAS_PENDING_EXCEPTION) {
return empty;
}
}
assert(result.is_statically_bound(), "");
oop mname2 = init_method_MemberName(mname, result);
return Handle(THREAD, mname2);
}
case IS_FIELD:
{
fieldDescriptor result; // find_field initializes fd if found
{
assert(!HAS_PENDING_EXCEPTION, "");
LinkResolver::resolve_field(result, defc, name, type, caller, Bytecodes::_nop, false, false, THREAD);
if (HAS_PENDING_EXCEPTION) {
return empty;
}
}
oop mname2 = init_field_MemberName(mname, result, ref_kind_is_setter(ref_kind));
return Handle(THREAD, mname2);
}
default:
THROW_MSG_(vmSymbols::java_lang_InternalError(), "unrecognized MemberName format", empty);
}
return empty;
}
void MethodHandles::expand_MemberName(Handle mname, int suppress, TRAPS) {
assert(java_lang_invoke_MemberName::is_instance(mname()), "");
Metadata* vmtarget = java_lang_invoke_MemberName::vmtarget(mname());
int vmindex = java_lang_invoke_MemberName::vmindex(mname());
if (vmtarget == NULL) {
THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "nothing to expand");
}
bool have_defc = (java_lang_invoke_MemberName::clazz(mname()) != NULL);
bool have_name = (java_lang_invoke_MemberName::name(mname()) != NULL);
bool have_type = (java_lang_invoke_MemberName::type(mname()) != NULL);
int flags = java_lang_invoke_MemberName::flags(mname());
if (suppress != 0) {
if (suppress & _suppress_defc) have_defc = true;
if (suppress & _suppress_name) have_name = true;
if (suppress & _suppress_type) have_type = true;
}
if (have_defc && have_name && have_type) return; // nothing needed
switch (flags & ALL_KINDS) {
case IS_METHOD:
case IS_CONSTRUCTOR:
{
assert(vmtarget->is_method(), "method or constructor vmtarget is Method*");
methodHandle m(THREAD, (Method*)vmtarget);
DEBUG_ONLY(vmtarget = NULL); // safety
if (m.is_null()) break;
if (!have_defc) {
InstanceKlass* defc = m->method_holder();
java_lang_invoke_MemberName::set_clazz(mname(), defc->java_mirror());
}
if (!have_name) {
Handle name = StringTable::intern(m->name(), CHECK);
java_lang_invoke_MemberName::set_name(mname(), name());
}
if (!have_type) {
Handle type = java_lang_String::create_from_symbol(m->signature(), CHECK);
java_lang_invoke_MemberName::set_type(mname(), type());
}
return;
}
case IS_FIELD:
{
assert(vmtarget->is_klass(), "field vmtarget is Klass*");
if (!((Klass*) vmtarget)->oop_is_instance()) break;
instanceKlassHandle defc(THREAD, (Klass*) vmtarget);
DEBUG_ONLY(vmtarget = NULL); // safety
bool is_static = ((flags & JVM_ACC_STATIC) != 0);
fieldDescriptor fd; // find_field initializes fd if found
if (!defc->find_field_from_offset(vmindex, is_static, &fd))
break; // cannot expand
if (!have_defc) {
java_lang_invoke_MemberName::set_clazz(mname(), defc->java_mirror());
}
if (!have_name) {
Handle name = StringTable::intern(fd.name(), CHECK);
java_lang_invoke_MemberName::set_name(mname(), name());
}
if (!have_type) {
Handle type = field_signature_type_or_null(fd.signature());
if (type.is_null()) {
java_lang_String::create_from_symbol(fd.signature(), CHECK);
}
java_lang_invoke_MemberName::set_type(mname(), type());
}
return;
}
}
THROW_MSG(vmSymbols::java_lang_InternalError(), "unrecognized MemberName format");
}
int MethodHandles::find_MemberNames(KlassHandle k,
Symbol* name, Symbol* sig,
int mflags, KlassHandle caller,
int skip, objArrayHandle results) {
Thread* thread = Thread::current();
if (k.is_null() || !k->oop_is_instance()) return -1;
int rfill = 0, rlimit = results->length(), rskip = skip;
int overflow = 0, overflow_limit = MAX2(1000, rlimit);
int match_flags = mflags;
bool search_superc = ((match_flags & SEARCH_SUPERCLASSES) != 0);
bool search_intfc = ((match_flags & SEARCH_INTERFACES) != 0);
bool local_only = !(search_superc | search_intfc);
bool classes_only = false;
if (name != NULL) {
if (name->utf8_length() == 0) return 0; // a match is not possible
}
if (sig != NULL) {
if (sig->utf8_length() == 0) return 0; // a match is not possible
if (sig->byte_at(0) == '(')
match_flags &= ~(IS_FIELD | IS_TYPE);
else
match_flags &= ~(IS_CONSTRUCTOR | IS_METHOD);
}
if ((match_flags & IS_TYPE) != 0) {
}
if ((match_flags & IS_FIELD) != 0) {
for (FieldStream st(k(), local_only, !search_intfc); !st.eos(); st.next()) {
if (name != NULL && st.name() != name)
continue;
if (sig != NULL && st.signature() != sig)
continue;
if (rskip > 0) {
--rskip;
} else if (rfill < rlimit) {
Handle result(thread, results->obj_at(rfill++));
if (!java_lang_invoke_MemberName::is_instance(result()))
return -99; // caller bug!
oop saved = MethodHandles::init_field_MemberName(result, st.field_descriptor());
if (saved != result())
results->obj_at_put(rfill-1, saved); // show saved instance to user
} else if (++overflow >= overflow_limit) {
match_flags = 0; break; // got tired of looking at overflow
}
}
}
if ((match_flags & (IS_METHOD | IS_CONSTRUCTOR)) != 0) {
Symbol* init_name = vmSymbols::object_initializer_name();
Symbol* clinit_name = vmSymbols::class_initializer_name();
if (name == clinit_name) clinit_name = NULL; // hack for exposing <clinit>
bool negate_name_test = false;
if (!(match_flags & IS_METHOD)) {
if (name == NULL) {
name = init_name;
} else if (name != init_name) {
return 0; // no constructors of this method name
}
} else if (!(match_flags & IS_CONSTRUCTOR)) {
if (name == NULL) {
name = init_name;
negate_name_test = true; // if we see the name, we *omit* the entry
} else if (name == init_name) {
return 0; // no methods of this constructor name
}
} else {
}
for (MethodStream st(k(), local_only, !search_intfc); !st.eos(); st.next()) {
Method* m = st.method();
Symbol* m_name = m->name();
if (m_name == clinit_name)
continue;
if (name != NULL && ((m_name != name) ^ negate_name_test))
continue;
if (sig != NULL && m->signature() != sig)
continue;
if (rskip > 0) {
--rskip;
} else if (rfill < rlimit) {
Handle result(thread, results->obj_at(rfill++));
if (!java_lang_invoke_MemberName::is_instance(result()))
return -99; // caller bug!
CallInfo info(m);
oop saved = MethodHandles::init_method_MemberName(result, info, /*intern*/false);
if (saved != result())
results->obj_at_put(rfill-1, saved); // show saved instance to user
} else if (++overflow >= overflow_limit) {
match_flags = 0; break; // got tired of looking at overflow
}
}
}
return rfill + overflow;
}
MemberNameTable::MemberNameTable(int methods_cnt)
: GrowableArray<jweak>(methods_cnt, true) {
assert_locked_or_safepoint(MemberNameTable_lock);
}
MemberNameTable::~MemberNameTable() {
assert_locked_or_safepoint(MemberNameTable_lock);
int len = this->length();
for (int idx = 0; idx < len; idx++) {
jweak ref = this->at(idx);
JNIHandles::destroy_weak_global(ref);
}
}
oop MemberNameTable::add_member_name(jweak mem_name_wref) {
assert_locked_or_safepoint(MemberNameTable_lock);
this->push(mem_name_wref);
return JNIHandles::resolve(mem_name_wref);
}
oop MemberNameTable::find_or_add_member_name(jweak mem_name_wref) {
assert_locked_or_safepoint(MemberNameTable_lock);
oop new_mem_name = JNIHandles::resolve(mem_name_wref);
int len = this->length();
int new_index = len;
for (int idx = 0; idx < len; idx++) {
oop mname = JNIHandles::resolve(this->at(idx));
if (mname == NULL) {
new_index = idx;
continue;
}
if (java_lang_invoke_MemberName::equals(new_mem_name, mname)) {
JNIHandles::destroy_weak_global(mem_name_wref);
return mname;
}
}
if (new_index < len) {
assert(JNIHandles::resolve(this->at(new_index)) == NULL, "sanity");
JNIHandles::destroy_weak_global(this->at(new_index));
}
this->at_put_grow(new_index, mem_name_wref);
return new_mem_name;
}
#if INCLUDE_JVMTI
void MemberNameTable::adjust_method_entries(InstanceKlass* holder, bool * trace_name_printed) {
assert(SafepointSynchronize::is_at_safepoint(), "only called at safepoint");
for (int idx = 0; idx < length(); idx++) {
oop mem_name = JNIHandles::resolve(this->at(idx));
if (mem_name == NULL) {
continue;
}
Method* old_method = (Method*)java_lang_invoke_MemberName::vmtarget(mem_name);
if (old_method == NULL || !old_method->is_old()) {
continue; // skip uninteresting entries
}
if (old_method->is_deleted()) {
continue;
}
Method* new_method = holder->method_with_idnum(old_method->orig_method_idnum());
assert(new_method != NULL, "method_with_idnum() should not be NULL");
assert(old_method != new_method, "sanity check");
java_lang_invoke_MemberName::set_vmtarget(mem_name, new_method);
if (RC_TRACE_IN_RANGE(0x00100000, 0x00400000)) {
if (!(*trace_name_printed)) {
RC_TRACE_MESG(("adjust: name=%s",
old_method->method_holder()->external_name()));
}
RC_TRACE(0x00400000, ("MemberName method update: %s(%s)",
new_method->name()->as_C_string(),
new_method->signature()->as_C_string()));
}
}
}
#endif // INCLUDE_JVMTI
JVM_ENTRY(jint, MHN_getConstant(JNIEnv *env, jobject igcls, jint which)) {
switch (which) {
case MethodHandles::GC_COUNT_GWT:
#ifdef COMPILER2
return true;
#else
return false;
#endif
}
return 0;
}
JVM_END
#ifndef PRODUCT
#define EACH_NAMED_CON(template, requirement) \
template(MethodHandles,GC_COUNT_GWT) \
template(java_lang_invoke_MemberName,MN_IS_METHOD) \
template(java_lang_invoke_MemberName,MN_IS_CONSTRUCTOR) \
template(java_lang_invoke_MemberName,MN_IS_FIELD) \
template(java_lang_invoke_MemberName,MN_IS_TYPE) \
template(java_lang_invoke_MemberName,MN_CALLER_SENSITIVE) \
template(java_lang_invoke_MemberName,MN_SEARCH_SUPERCLASSES) \
template(java_lang_invoke_MemberName,MN_SEARCH_INTERFACES) \
template(java_lang_invoke_MemberName,MN_REFERENCE_KIND_SHIFT) \
template(java_lang_invoke_MemberName,MN_REFERENCE_KIND_MASK) \
template(MethodHandles,GC_LAMBDA_SUPPORT) \
#define IGNORE_REQ(req_expr) /* req_expr */
#define ONE_PLUS(scope,value) 1+
static const int con_value_count = EACH_NAMED_CON(ONE_PLUS, IGNORE_REQ) 0;
#define VALUE_COMMA(scope,value) scope::value,
static const int con_values[con_value_count+1] = { EACH_NAMED_CON(VALUE_COMMA, IGNORE_REQ) 0 };
#define STRING_NULL(scope,value) #value "\0"
static const char con_names[] = { EACH_NAMED_CON(STRING_NULL, IGNORE_REQ) };
static bool advertise_con_value(int which) {
if (which < 0) return false;
bool ok = true;
int count = 0;
#define INC_COUNT(scope,value) \
++count;
#define CHECK_REQ(req_expr) \
if (which < count) return ok; \
ok = (req_expr);
EACH_NAMED_CON(INC_COUNT, CHECK_REQ);
#undef INC_COUNT
#undef CHECK_REQ
assert(count == con_value_count, "");
if (which < count) return ok;
return false;
}
#undef ONE_PLUS
#undef VALUE_COMMA
#undef STRING_NULL
#undef EACH_NAMED_CON
#endif // PRODUCT
JVM_ENTRY(jint, MHN_getNamedCon(JNIEnv *env, jobject igcls, jint which, jobjectArray box_jh)) {
#ifndef PRODUCT
if (advertise_con_value(which)) {
assert(which >= 0 && which < con_value_count, "");
int con = con_values[which];
objArrayHandle box(THREAD, (objArrayOop) JNIHandles::resolve(box_jh));
if (box.not_null() && box->klass() == Universe::objectArrayKlassObj() && box->length() > 0) {
const char* str = &con_names[0];
for (int i = 0; i < which; i++)
str += strlen(str) + 1; // skip name and null
oop name = java_lang_String::create_oop_from_str(str, CHECK_0); // possible safepoint
box->obj_at_put(0, name);
}
return con;
}
#endif
return 0;
}
JVM_END
JVM_ENTRY(void, MHN_init_Mem(JNIEnv *env, jobject igcls, jobject mname_jh, jobject target_jh)) {
if (mname_jh == NULL) { THROW_MSG(vmSymbols::java_lang_InternalError(), "mname is null"); }
if (target_jh == NULL) { THROW_MSG(vmSymbols::java_lang_InternalError(), "target is null"); }
Handle mname(THREAD, JNIHandles::resolve_non_null(mname_jh));
Handle target(THREAD, JNIHandles::resolve_non_null(target_jh));
MethodHandles::init_MemberName(mname, target);
}
JVM_END
JVM_ENTRY(void, MHN_expand_Mem(JNIEnv *env, jobject igcls, jobject mname_jh)) {
if (mname_jh == NULL) { THROW_MSG(vmSymbols::java_lang_InternalError(), "mname is null"); }
Handle mname(THREAD, JNIHandles::resolve_non_null(mname_jh));
MethodHandles::expand_MemberName(mname, 0, CHECK);
}
JVM_END
JVM_ENTRY(jobject, MHN_resolve_Mem(JNIEnv *env, jobject igcls, jobject mname_jh, jclass caller_jh)) {
if (mname_jh == NULL) { THROW_MSG_NULL(vmSymbols::java_lang_InternalError(), "mname is null"); }
Handle mname(THREAD, JNIHandles::resolve_non_null(mname_jh));
if (VerifyMethodHandles && caller_jh != NULL &&
java_lang_invoke_MemberName::clazz(mname()) != NULL) {
Klass* reference_klass = java_lang_Class::as_Klass(java_lang_invoke_MemberName::clazz(mname()));
if (reference_klass != NULL && reference_klass->oop_is_objArray()) {
reference_klass = ObjArrayKlass::cast(reference_klass)->bottom_klass();
}
if (reference_klass != NULL && reference_klass->oop_is_instance()) {
Klass* caller = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(caller_jh));
if (!Reflection::verify_class_access(caller,
reference_klass,
true)) {
THROW_MSG_NULL(vmSymbols::java_lang_InternalError(), reference_klass->external_name());
}
}
}
KlassHandle caller(THREAD,
caller_jh == NULL ? (Klass*) NULL :
java_lang_Class::as_Klass(JNIHandles::resolve_non_null(caller_jh)));
Handle resolved = MethodHandles::resolve_MemberName(mname, caller, CHECK_NULL);
if (resolved.is_null()) {
int flags = java_lang_invoke_MemberName::flags(mname());
int ref_kind = (flags >> REFERENCE_KIND_SHIFT) & REFERENCE_KIND_MASK;
if (!MethodHandles::ref_kind_is_valid(ref_kind)) {
THROW_MSG_NULL(vmSymbols::java_lang_InternalError(), "obsolete MemberName format");
}
if ((flags & ALL_KINDS) == IS_FIELD) {
THROW_MSG_NULL(vmSymbols::java_lang_NoSuchMethodError(), "field resolution failed");
} else if ((flags & ALL_KINDS) == IS_METHOD ||
(flags & ALL_KINDS) == IS_CONSTRUCTOR) {
THROW_MSG_NULL(vmSymbols::java_lang_NoSuchFieldError(), "method resolution failed");
} else {
THROW_MSG_NULL(vmSymbols::java_lang_LinkageError(), "resolution failed");
}
}
return JNIHandles::make_local(THREAD, resolved());
}
JVM_END
static jlong find_member_field_offset(oop mname, bool must_be_static, TRAPS) {
if (mname == NULL ||
java_lang_invoke_MemberName::vmtarget(mname) == NULL) {
THROW_MSG_0(vmSymbols::java_lang_InternalError(), "mname not resolved");
} else {
int flags = java_lang_invoke_MemberName::flags(mname);
if ((flags & IS_FIELD) != 0 &&
(must_be_static
? (flags & JVM_ACC_STATIC) != 0
: (flags & JVM_ACC_STATIC) == 0)) {
int vmindex = java_lang_invoke_MemberName::vmindex(mname);
return (jlong) vmindex;
}
}
const char* msg = (must_be_static ? "static field required" : "non-static field required");
THROW_MSG_0(vmSymbols::java_lang_InternalError(), msg);
return 0;
}
JVM_ENTRY(jlong, MHN_objectFieldOffset(JNIEnv *env, jobject igcls, jobject mname_jh)) {
return find_member_field_offset(JNIHandles::resolve(mname_jh), false, THREAD);
}
JVM_END
JVM_ENTRY(jlong, MHN_staticFieldOffset(JNIEnv *env, jobject igcls, jobject mname_jh)) {
return find_member_field_offset(JNIHandles::resolve(mname_jh), true, THREAD);
}
JVM_END
JVM_ENTRY(jobject, MHN_staticFieldBase(JNIEnv *env, jobject igcls, jobject mname_jh)) {
jlong ignore = find_member_field_offset(JNIHandles::resolve(mname_jh), true, CHECK_NULL);
oop clazz = java_lang_invoke_MemberName::clazz(JNIHandles::resolve_non_null(mname_jh));
return JNIHandles::make_local(THREAD, clazz);
}
JVM_END
JVM_ENTRY(jobject, MHN_getMemberVMInfo(JNIEnv *env, jobject igcls, jobject mname_jh)) {
if (mname_jh == NULL) return NULL;
Handle mname(THREAD, JNIHandles::resolve_non_null(mname_jh));
intptr_t vmindex = java_lang_invoke_MemberName::vmindex(mname());
Metadata* vmtarget = java_lang_invoke_MemberName::vmtarget(mname());
objArrayHandle result = oopFactory::new_objArray(SystemDictionary::Object_klass(), 2, CHECK_NULL);
jvalue vmindex_value; vmindex_value.j = (long)vmindex;
oop x = java_lang_boxing_object::create(T_LONG, &vmindex_value, CHECK_NULL);
result->obj_at_put(0, x);
x = NULL;
if (vmtarget == NULL) {
x = NULL;
} else if (vmtarget->is_klass()) {
x = ((Klass*) vmtarget)->java_mirror();
} else if (vmtarget->is_method()) {
x = mname();
}
result->obj_at_put(1, x);
return JNIHandles::make_local(env, result());
}
JVM_END
JVM_ENTRY(jint, MHN_getMembers(JNIEnv *env, jobject igcls,
jclass clazz_jh, jstring name_jh, jstring sig_jh,
int mflags, jclass caller_jh, jint skip, jobjectArray results_jh)) {
if (clazz_jh == NULL || results_jh == NULL) return -1;
KlassHandle k(THREAD, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz_jh)));
objArrayHandle results(THREAD, (objArrayOop) JNIHandles::resolve(results_jh));
if (results.is_null() || !results->is_objArray()) return -1;
TempNewSymbol name = NULL;
TempNewSymbol sig = NULL;
if (name_jh != NULL) {
name = java_lang_String::as_symbol_or_null(JNIHandles::resolve_non_null(name_jh));
if (name == NULL) return 0; // a match is not possible
}
if (sig_jh != NULL) {
sig = java_lang_String::as_symbol_or_null(JNIHandles::resolve_non_null(sig_jh));
if (sig == NULL) return 0; // a match is not possible
}
KlassHandle caller;
if (caller_jh != NULL) {
oop caller_oop = JNIHandles::resolve_non_null(caller_jh);
if (!java_lang_Class::is_instance(caller_oop)) return -1;
caller = KlassHandle(THREAD, java_lang_Class::as_Klass(caller_oop));
}
if (name != NULL && sig != NULL && results.not_null()) {
}
int res = MethodHandles::find_MemberNames(k, name, sig, mflags,
caller, skip, results);
return res;
}
JVM_END
JVM_ENTRY(void, MHN_setCallSiteTargetNormal(JNIEnv* env, jobject igcls, jobject call_site_jh, jobject target_jh)) {
Handle call_site(THREAD, JNIHandles::resolve_non_null(call_site_jh));
Handle target (THREAD, JNIHandles::resolve(target_jh));
{
MutexLocker mu(Compile_lock, thread);
Universe::flush_dependents_on(call_site, target);
java_lang_invoke_CallSite::set_target(call_site(), target());
}
}
JVM_END
JVM_ENTRY(void, MHN_setCallSiteTargetVolatile(JNIEnv* env, jobject igcls, jobject call_site_jh, jobject target_jh)) {
Handle call_site(THREAD, JNIHandles::resolve_non_null(call_site_jh));
Handle target (THREAD, JNIHandles::resolve(target_jh));
{
MutexLocker mu(Compile_lock, thread);
Universe::flush_dependents_on(call_site, target);
java_lang_invoke_CallSite::set_target_volatile(call_site(), target());
}
}
JVM_END
JVM_ENTRY(jobject, MH_invoke_UOE(JNIEnv* env, jobject mh, jobjectArray args)) {
THROW_MSG_NULL(vmSymbols::java_lang_UnsupportedOperationException(), "MethodHandle.invoke cannot be invoked reflectively");
return NULL;
}
JVM_END
JVM_ENTRY(jobject, MH_invokeExact_UOE(JNIEnv* env, jobject mh, jobjectArray args)) {
THROW_MSG_NULL(vmSymbols::java_lang_UnsupportedOperationException(), "MethodHandle.invokeExact cannot be invoked reflectively");
return NULL;
}
JVM_END
#undef CS // Solaris builds complain
#define LANG "Ljava/lang/"
#define JLINV "Ljava/lang/invoke/"
#define OBJ LANG "Object;"
#define CLS LANG "Class;"
#define STRG LANG "String;"
#define CS JLINV "CallSite;"
#define MT JLINV "MethodType;"
#define MH JLINV "MethodHandle;"
#define MEM JLINV "MemberName;"
#define CC (char*) /*cast a literal from (const char*)*/
#define FN_PTR(f) CAST_FROM_FN_PTR(void*, &f)
static JNINativeMethod MHN_methods[] = {
{CC "init", CC "(" MEM "" OBJ ")V", FN_PTR(MHN_init_Mem)},
{CC"expand", CC "(" MEM ")V", FN_PTR(MHN_expand_Mem)},
{CC "resolve", CC "(" MEM "" CLS ")" MEM, FN_PTR(MHN_resolve_Mem)},
{CC "getConstant", CC "(I)I", FN_PTR(MHN_getConstant)},
{CC "getNamedCon", CC "(I[" OBJ ")I", FN_PTR(MHN_getNamedCon)},
{CC "getMembers", CC "(" CLS "" STRG "" STRG "I" CLS "I[" MEM ")I", FN_PTR(MHN_getMembers)},
{CC "objectFieldOffset", CC "(" MEM ")J", FN_PTR(MHN_objectFieldOffset)},
{CC "setCallSiteTargetNormal", CC "(" CS "" MH ")V", FN_PTR(MHN_setCallSiteTargetNormal)},
{CC "setCallSiteTargetVolatile", CC "(" CS "" MH ")V", FN_PTR(MHN_setCallSiteTargetVolatile)},
{CC "staticFieldOffset", CC "(" MEM ")J", FN_PTR(MHN_staticFieldOffset)},
{CC "staticFieldBase", CC "(" MEM ")" OBJ, FN_PTR(MHN_staticFieldBase)},
{CC "getMemberVMInfo", CC "(" MEM ")" OBJ, FN_PTR(MHN_getMemberVMInfo)}
};
static JNINativeMethod MH_methods[] = {
{CC "invoke", CC "([" OBJ ")" OBJ, FN_PTR(MH_invoke_UOE)},
{CC "invokeExact", CC "([" OBJ ")" OBJ, FN_PTR(MH_invokeExact_UOE)}
};
static bool register_natives(JNIEnv* env, jclass clazz, const JNINativeMethod* methods, jint nMethods) {
int status = env->RegisterNatives(clazz, methods, nMethods);
if (status != JNI_OK || env->ExceptionOccurred()) {
warning("JSR 292 method handle code is mismatched to this JVM. Disabling support.");
env->ExceptionClear();
return false;
}
return true;
}
JVM_ENTRY(void, JVM_RegisterMethodHandleMethods(JNIEnv *env, jclass MHN_class)) {
if (!EnableInvokeDynamic) {
warning("JSR 292 is disabled in this JVM. Use -XX:+UnlockDiagnosticVMOptions -XX:+EnableInvokeDynamic to enable.");
return; // bind nothing
}
assert(!MethodHandles::enabled(), "must not be enabled");
bool enable_MH = true;
jclass MH_class = NULL;
if (SystemDictionary::MethodHandle_klass() == NULL) {
enable_MH = false;
} else {
oop mirror = SystemDictionary::MethodHandle_klass()->java_mirror();
MH_class = (jclass) JNIHandles::make_local(env, mirror);
}
if (enable_MH) {
ThreadToNativeFromVM ttnfv(thread);
if (enable_MH) {
enable_MH = register_natives(env, MHN_class, MHN_methods, sizeof(MHN_methods)/sizeof(JNINativeMethod));
}
if (enable_MH) {
enable_MH = register_natives(env, MH_class, MH_methods, sizeof(MH_methods)/sizeof(JNINativeMethod));
}
}
if (TraceInvokeDynamic) {
tty->print_cr("MethodHandle support loaded (using LambdaForms)");
}
if (enable_MH) {
MethodHandles::generate_adapters();
MethodHandles::set_enabled(true);
}
}
JVM_END
C:\hotspot-69087d08d473\src\share\vm/prims/methodHandles.hpp
#ifndef SHARE_VM_PRIMS_METHODHANDLES_HPP
#define SHARE_VM_PRIMS_METHODHANDLES_HPP
#include "classfile/javaClasses.hpp"
#include "classfile/vmSymbols.hpp"
#include "runtime/frame.inline.hpp"
#include "runtime/globals.hpp"
#include "runtime/interfaceSupport.hpp"
class MacroAssembler;
class Label;
class MethodHandles: AllStatic {
public:
public:
static bool enabled() { return _enabled; }
static void set_enabled(bool z);
private:
static bool _enabled;
static MethodHandlesAdapterBlob* _adapter_code;
static oop field_name_or_null(Symbol* s);
static oop field_signature_type_or_null(Symbol* s);
public:
static Handle resolve_MemberName(Handle mname, KlassHandle caller, TRAPS); // compute vmtarget/vmindex from name/type
static void expand_MemberName(Handle mname, int suppress, TRAPS); // expand defc/name/type if missing
static Handle new_MemberName(TRAPS); // must be followed by init_MemberName
static oop init_MemberName(Handle mname_h, Handle target_h); // compute vmtarget/vmindex from target
static oop init_field_MemberName(Handle mname_h, fieldDescriptor& fd, bool is_setter = false);
static oop init_method_MemberName(Handle mname_h, CallInfo& info, bool intern = true);
static int method_ref_kind(Method* m, bool do_dispatch_if_possible = true);
static int find_MemberNames(KlassHandle k, Symbol* name, Symbol* sig,
int mflags, KlassHandle caller,
int skip, objArrayHandle results);
enum { _suppress_defc = 1, _suppress_name = 2, _suppress_type = 4 };
static void generate_adapters();
static address generate_method_handle_interpreter_entry(MacroAssembler* _masm, vmIntrinsics::ID iid);
static void generate_method_handle_dispatch(MacroAssembler* _masm,
vmIntrinsics::ID iid,
Register receiver_reg,
Register member_reg,
bool for_compiler_entry);
static bool is_signature_polymorphic(vmIntrinsics::ID iid) {
return (iid >= vmIntrinsics::FIRST_MH_SIG_POLY &&
iid <= vmIntrinsics::LAST_MH_SIG_POLY);
}
static bool is_signature_polymorphic_intrinsic(vmIntrinsics::ID iid) {
assert(is_signature_polymorphic(iid), "");
return (iid != vmIntrinsics::_invokeGeneric);
}
static bool is_signature_polymorphic_static(vmIntrinsics::ID iid) {
assert(is_signature_polymorphic(iid), "");
return (iid >= vmIntrinsics::FIRST_MH_STATIC &&
iid <= vmIntrinsics::LAST_MH_SIG_POLY);
}
static bool has_member_arg(vmIntrinsics::ID iid) {
assert(is_signature_polymorphic(iid), "");
return (iid >= vmIntrinsics::_linkToVirtual &&
iid <= vmIntrinsics::_linkToInterface);
}
static bool has_member_arg(Symbol* klass, Symbol* name) {
if ((klass == vmSymbols::java_lang_invoke_MethodHandle()) &&
is_signature_polymorphic_name(name)) {
vmIntrinsics::ID iid = signature_polymorphic_name_id(name);
return has_member_arg(iid);
}
return false;
}
static Symbol* signature_polymorphic_intrinsic_name(vmIntrinsics::ID iid);
static int signature_polymorphic_intrinsic_ref_kind(vmIntrinsics::ID iid);
static vmIntrinsics::ID signature_polymorphic_name_id(Klass* klass, Symbol* name);
static vmIntrinsics::ID signature_polymorphic_name_id(Symbol* name);
static bool is_signature_polymorphic_name(Symbol* name) {
return signature_polymorphic_name_id(name) != vmIntrinsics::_none;
}
static bool is_method_handle_invoke_name(Klass* klass, Symbol* name);
static bool is_signature_polymorphic_name(Klass* klass, Symbol* name) {
return signature_polymorphic_name_id(klass, name) != vmIntrinsics::_none;
}
enum {
GC_COUNT_GWT = 4,
GC_LAMBDA_SUPPORT = 5
};
static int get_named_constant(int which, Handle name_box, TRAPS);
public:
static Symbol* lookup_signature(oop type_str, bool polymorphic, TRAPS); // use TempNewSymbol
static Symbol* lookup_basic_type_signature(Symbol* sig, bool keep_last_arg, TRAPS); // use TempNewSymbol
static Symbol* lookup_basic_type_signature(Symbol* sig, TRAPS) {
return lookup_basic_type_signature(sig, false, THREAD);
}
static bool is_basic_type_signature(Symbol* sig);
static Symbol* lookup_method_type(Symbol* msig, Handle mtype, TRAPS);
static void print_as_method_type_on(outputStream* st, Symbol* sig) {
print_as_basic_type_signature_on(st, sig, true, true);
}
static void print_as_basic_type_signature_on(outputStream* st, Symbol* sig, bool keep_arrays = false, bool keep_basic_names = false);
enum { JVM_REF_MIN = JVM_REF_getField, JVM_REF_MAX = JVM_REF_invokeInterface };
static bool ref_kind_is_valid(int ref_kind) {
return (ref_kind >= JVM_REF_MIN && ref_kind <= JVM_REF_MAX);
}
static bool ref_kind_is_field(int ref_kind) {
assert(ref_kind_is_valid(ref_kind), "");
return (ref_kind <= JVM_REF_putStatic);
}
static bool ref_kind_is_getter(int ref_kind) {
assert(ref_kind_is_valid(ref_kind), "");
return (ref_kind <= JVM_REF_getStatic);
}
static bool ref_kind_is_setter(int ref_kind) {
return ref_kind_is_field(ref_kind) && !ref_kind_is_getter(ref_kind);
}
static bool ref_kind_is_method(int ref_kind) {
return !ref_kind_is_field(ref_kind) && (ref_kind != JVM_REF_newInvokeSpecial);
}
static bool ref_kind_has_receiver(int ref_kind) {
assert(ref_kind_is_valid(ref_kind), "");
return (ref_kind & 1) != 0;
}
static bool ref_kind_is_static(int ref_kind) {
return !ref_kind_has_receiver(ref_kind) && (ref_kind != JVM_REF_newInvokeSpecial);
}
static bool ref_kind_does_dispatch(int ref_kind) {
return (ref_kind == JVM_REF_invokeVirtual ||
ref_kind == JVM_REF_invokeInterface);
}
#ifdef TARGET_ARCH_x86
# include "methodHandles_x86.hpp"
#endif
#ifdef TARGET_ARCH_aarch64
# include "methodHandles_aarch64.hpp"
#endif
#ifdef TARGET_ARCH_sparc
# include "methodHandles_sparc.hpp"
#endif
#ifdef TARGET_ARCH_zero
# include "methodHandles_zero.hpp"
#endif
#ifdef TARGET_ARCH_arm
# include "methodHandles_arm.hpp"
#endif
#ifdef TARGET_ARCH_ppc
# include "methodHandles_ppc.hpp"
#endif
static void trace_method_handle(MacroAssembler* _masm, const char* adaptername) PRODUCT_RETURN;
static void trace_method_handle_interpreter_entry(MacroAssembler* _masm, vmIntrinsics::ID iid) {
if (TraceMethodHandles) {
const char* name = vmIntrinsics::name_at(iid);
if (*name == '_') name += 1;
const size_t len = strlen(name) + 50;
char* qname = NEW_C_HEAP_ARRAY(char, len, mtInternal);
const char* suffix = "";
if (is_signature_polymorphic(iid)) {
if (is_signature_polymorphic_static(iid))
suffix = "/static";
else
suffix = "/private";
}
jio_snprintf(qname, len, "MethodHandle::interpreter_entry::%s%s", name, suffix);
trace_method_handle(_masm, qname);
}
}
};
class MethodHandlesAdapterGenerator : public StubCodeGenerator {
public:
MethodHandlesAdapterGenerator(CodeBuffer* code) : StubCodeGenerator(code, PrintMethodHandleStubs) {}
void generate();
};
class MemberNameTable : public GrowableArray<jweak> {
public:
MemberNameTable(int methods_cnt);
~MemberNameTable();
oop add_member_name(jweak mem_name_ref);
oop find_or_add_member_name(jweak mem_name_ref);
#if INCLUDE_JVMTI
void adjust_method_entries(InstanceKlass* holder, bool * trace_name_printed);
#endif // INCLUDE_JVMTI
};
#endif // SHARE_VM_PRIMS_METHODHANDLES_HPP
C:\hotspot-69087d08d473\src\share\vm/prims/nativeLookup.cpp
#include "precompiled.hpp"
#include "classfile/javaClasses.hpp"
#include "classfile/systemDictionary.hpp"
#include "classfile/vmSymbols.hpp"
#include "memory/oopFactory.hpp"
#include "memory/resourceArea.hpp"
#include "memory/universe.inline.hpp"
#include "oops/instanceKlass.hpp"
#include "oops/method.hpp"
#include "oops/oop.inline.hpp"
#include "oops/symbol.hpp"
#include "prims/jvm_misc.hpp"
#include "prims/nativeLookup.hpp"
#include "runtime/arguments.hpp"
#include "runtime/handles.inline.hpp"
#include "runtime/javaCalls.hpp"
#include "runtime/sharedRuntime.hpp"
#include "runtime/signature.hpp"
#include "utilities/macros.hpp"
#if INCLUDE_JFR
#include "jfr/jfr.hpp"
#endif
#ifdef TARGET_OS_FAMILY_linux
# include "os_linux.inline.hpp"
#endif
#ifdef TARGET_OS_FAMILY_solaris
# include "os_solaris.inline.hpp"
#endif
#ifdef TARGET_OS_FAMILY_windows
# include "os_windows.inline.hpp"
#endif
#ifdef TARGET_OS_FAMILY_aix
# include "os_aix.inline.hpp"
#endif
#ifdef TARGET_OS_FAMILY_bsd
# include "os_bsd.inline.hpp"
#endif
The JNI specification defines the mapping from a Java native method name to
a C native library implementation function name as follows:
The mapping produces a native method name by concatenating the following components
derived from a `native` method declaration:
1. the prefix Java_
2. given the binary name, in internal form, of the class which declares the native method:
the result of escaping the name.
3. an underscore ("_")
4. the escaped method name
5. if the native method declaration is overloaded: two underscores ("__") followed by the
escaped parameter descriptor (JVMS 4.3.3) of the method declaration.
Escaping leaves every alphanumeric ASCII character (A-Za-z0-9) unchanged, and replaces each
UTF-16 code unit n the table below with the corresponding escape sequence. If the name to be
escaped contains a surrogate pair, then the high-surrogate code unit and the low-surrogate code
unit are escaped separately. The result of escaping is a string consisting only of the ASCII
characters A-Za-z0-9 and underscore.
------------------------------ ------------------------------------
UTF-16 code unit Escape sequence
------------------------------ ------------------------------------
Forward slash (/, U+002F) _
Underscore (_, U+005F) _1
Semicolon (;, U+003B) _2
Left square bracket ([, U+005B) _3
Any UTF-16 code unit \u_WXYZ_ that does not _0wxyz where w, x, y, and z are the lower-case
represent alphanumeric ASCII (A-Za-z0-9), forms of the hexadecimal digits W, X, Y, and Z.
forward slash, underscore, semicolon, (For example, U+ABCD becomes _0abcd.)
or left square bracket
------------------------------ ------------------------------------
Note that escape sequences can safely begin _0, _1, etc, because class and method
names in Java source code never begin with a number. However, that is not the case in
class files that were not generated from Java source code.
To preserve the 1:1 mapping to a native method name, the VM checks the resulting name as
follows. If the process of escaping any precursor string from the native method declaration
(class or method name, or argument type) causes a "0", "1", "2", or "3" character
from the precursor string to appear unchanged in the result *either* immediately after an
underscore *or* at the beginning of the escaped string (where it will follow an underscore
in the fully assembled name), then the escaping process is said to have "failed".
In such cases, no native library search is performed, and the attempt to link the native
method invocation will throw UnsatisfiedLinkError.
For example:
package/my_class/method
and
package/my/1class/method
both map to
Java_package_my_1class_method
To address this potential conflict we need only check if the character after
/ is a digit 0..3, or if the first character after an injected '_' seperator
is a digit 0..3. If we encounter an invalid identifier we reset the
stringStream and return false. Otherwise the stringStream contains the mapped
name and we return true.
To address legacy compatibility, the UseLegacyJNINameEscaping flag can be set
which skips the extra checks.
static bool map_escaped_name_on(stringStream* st, Symbol* name, int begin, int end) {
char* bytes = (char*)name->bytes() + begin;
char* end_bytes = (char*)name->bytes() + end;
bool check_escape_char = true; // initially true as first character here follows '_'
while (bytes < end_bytes) {
jchar c;
bytes = UTF8::next(bytes, &c);
if (c <= 0x7f && isalnum(c)) {
if (check_escape_char && (c >= '0' && c <= '3') &&
!UseLegacyJNINameEscaping) {
if (PrintJNIResolving) {
ResourceMark rm;
tty->print_cr("[Lookup of native method with non-Java identifier rejected: %s]",
name->as_C_string());
}
st->reset(); // restore to "" on error
return false;
}
st->put((char) c);
check_escape_char = false;
} else {
check_escape_char = false;
if (c == '_') st->print("_1");
else if (c == '/') {
st->print("_");
check_escape_char = true;
}
else if (c == ';') st->print("_2");
else if (c == '[') st->print("_3");
else st->print("_%.5x", c);
}
}
return true;
}
static bool map_escaped_name_on(stringStream* st, Symbol* name) {
return map_escaped_name_on(st, name, 0, name->utf8_length());
}
char* NativeLookup::pure_jni_name(methodHandle method) {
stringStream st;
st.print("Java_");
if (!map_escaped_name_on(&st, method->klass_name())) {
return NULL;
}
st.print("_");
if (!map_escaped_name_on(&st, method->name())) {
return NULL;
}
return st.as_string();
}
char* NativeLookup::critical_jni_name(methodHandle method) {
stringStream st;
st.print("JavaCritical_");
if (!map_escaped_name_on(&st, method->klass_name())) {
return NULL;
}
st.print("_");
if (!map_escaped_name_on(&st, method->name())) {
return NULL;
}
return st.as_string();
}
char* NativeLookup::long_jni_name(methodHandle method) {
stringStream st;
Symbol* signature = method->signature();
st.print("__");
int end;
for (end = 0; end < signature->utf8_length() && signature->byte_at(end) != ')'; end++);
if (!map_escaped_name_on(&st, signature, 1, end)) {
return NULL;
}
return st.as_string();
}
extern "C" {
void JNICALL JVM_RegisterUnsafeMethods(JNIEnv *env, jclass unsafecls);
void JNICALL JVM_RegisterMethodHandleMethods(JNIEnv *env, jclass unsafecls);
void JNICALL JVM_RegisterPerfMethods(JNIEnv *env, jclass perfclass);
void JNICALL JVM_RegisterWhiteBoxMethods(JNIEnv *env, jclass wbclass);
}
#define CC (char*) /* cast a literal from (const char*) */
#define FN_PTR(f) CAST_FROM_FN_PTR(void*, &f)
static JNINativeMethod lookup_special_native_methods[] = {
{ CC"Java_sun_misc_Unsafe_registerNatives", NULL, FN_PTR(JVM_RegisterUnsafeMethods) },
{ CC"Java_java_lang_invoke_MethodHandleNatives_registerNatives", NULL, FN_PTR(JVM_RegisterMethodHandleMethods) },
{ CC"Java_sun_misc_Perf_registerNatives", NULL, FN_PTR(JVM_RegisterPerfMethods) },
{ CC"Java_sun_hotspot_WhiteBox_registerNatives", NULL, FN_PTR(JVM_RegisterWhiteBoxMethods) },
#if INCLUDE_JFR
{ CC"Java_jdk_jfr_internal_JVM_registerNatives", NULL, FN_PTR(jfr_register_natives) },
#endif
};
static address lookup_special_native(char* jni_name) {
int count = sizeof(lookup_special_native_methods) / sizeof(JNINativeMethod);
for (int i = 0; i < count; i++) {
if (strstr(jni_name, lookup_special_native_methods[i].name) != NULL) {
return CAST_FROM_FN_PTR(address, lookup_special_native_methods[i].fnPtr);
}
}
return NULL;
}
address NativeLookup::lookup_style(methodHandle method, char* pure_name, const char* long_name, int args_size, bool os_style, bool& in_base_library, TRAPS) {
address entry;
stringStream st;
if (os_style) os::print_jni_name_prefix_on(&st, args_size);
st.print_raw(pure_name);
st.print_raw(long_name);
if (os_style) os::print_jni_name_suffix_on(&st, args_size);
char* jni_name = st.as_string();
Handle loader(THREAD, method->method_holder()->class_loader());
if (loader.is_null()) {
entry = lookup_special_native(jni_name);
if (entry == NULL) {
entry = (address) os::dll_lookup(os::native_java_library(), jni_name);
}
if (entry != NULL) {
in_base_library = true;
return entry;
}
}
KlassHandle klass (THREAD, SystemDictionary::ClassLoader_klass());
Handle name_arg = java_lang_String::create_from_str(jni_name, CHECK_NULL);
JavaValue result(T_LONG);
JavaCalls::call_static(&result,
klass,
vmSymbols::findNative_name(),
vmSymbols::classloader_string_long_signature(),
loader,
name_arg,
CHECK_NULL);
entry = (address) (intptr_t) result.get_jlong();
if (entry == NULL) {
AgentLibrary* agent;
for (agent = Arguments::agents(); agent != NULL; agent = agent->next()) {
entry = (address) os::dll_lookup(agent->os_lib(), jni_name);
if (entry != NULL) {
return entry;
}
}
}
return entry;
}
address NativeLookup::lookup_critical_style(methodHandle method, char* pure_name, const char* long_name, int args_size, bool os_style) {
if (!method->has_native_function()) {
return NULL;
}
address current_entry = method->native_function();
char dll_name[JVM_MAXPATHLEN];
int offset;
if (os::dll_address_to_library_name(current_entry, dll_name, sizeof(dll_name), &offset)) {
char ebuf[32];
void* dll = os::dll_load(dll_name, ebuf, sizeof(ebuf));
if (dll != NULL) {
stringStream st;
if (os_style) os::print_jni_name_prefix_on(&st, args_size);
st.print_raw(pure_name);
st.print_raw(long_name);
if (os_style) os::print_jni_name_suffix_on(&st, args_size);
char* jni_name = st.as_string();
return (address)os::dll_lookup(dll, jni_name);
}
}
return NULL;
}
address NativeLookup::lookup_entry(methodHandle method, bool& in_base_library, TRAPS) {
address entry = NULL;
in_base_library = false;
char* pure_name = pure_jni_name(method);
if (pure_name == NULL) {
return NULL;
}
int args_size = 1 // JNIEnv
+ (method->is_static() ? 1 : 0) // class for static methods
+ method->size_of_parameters(); // actual parameters
entry = lookup_style(method, pure_name, "", args_size, true, in_base_library, CHECK_NULL);
if (entry != NULL) return entry;
char* long_name = long_jni_name(method);
if (long_name == NULL) {
return NULL;
}
entry = lookup_style(method, pure_name, long_name, args_size, true, in_base_library, CHECK_NULL);
if (entry != NULL) return entry;
entry = lookup_style(method, pure_name, "", args_size, false, in_base_library, CHECK_NULL);
if (entry != NULL) return entry;
entry = lookup_style(method, pure_name, long_name, args_size, false, in_base_library, CHECK_NULL);
return entry; // NULL indicates not found
}
address NativeLookup::lookup_critical_entry(methodHandle method) {
if (!CriticalJNINatives) return NULL;
if (method->is_synchronized() ||
!method->is_static()) {
return NULL;
}
ResourceMark rm;
address entry = NULL;
Symbol* signature = method->signature();
for (int end = 0; end < signature->utf8_length(); end++) {
if (signature->byte_at(end) == 'L') {
return NULL;
}
}
char* critical_name = critical_jni_name(method);
if (critical_name == NULL) {
return NULL;
}
int args_size = 1 // JNIEnv
+ (method->is_static() ? 1 : 0) // class for static methods
+ method->size_of_parameters(); // actual parameters
entry = lookup_critical_style(method, critical_name, "", args_size, true);
if (entry != NULL) return entry;
char* long_name = long_jni_name(method);
if (long_name == NULL) {
return NULL;
}
entry = lookup_critical_style(method, critical_name, long_name, args_size, true);
if (entry != NULL) return entry;
entry = lookup_critical_style(method, critical_name, "", args_size, false);
if (entry != NULL) return entry;
entry = lookup_critical_style(method, critical_name, long_name, args_size, false);
return entry; // NULL indicates not found
}
address NativeLookup::lookup_entry_prefixed(methodHandle method, bool& in_base_library, TRAPS) {
#if INCLUDE_JVMTI
ResourceMark rm(THREAD);
int prefix_count;
char** prefixes = JvmtiExport::get_all_native_method_prefixes(&prefix_count);
char* in_name = method->name()->as_C_string();
char* wrapper_name = in_name;
for (int i = prefix_count-1; i >= 0; i--) {
char* prefix = prefixes[i];
size_t prefix_len = strlen(prefix);
if (strncmp(prefix, wrapper_name, prefix_len) == 0) {
wrapper_name += prefix_len;
}
}
if (wrapper_name != in_name) {
int wrapper_name_len = (int)strlen(wrapper_name);
TempNewSymbol wrapper_symbol = SymbolTable::probe(wrapper_name, wrapper_name_len);
if (wrapper_symbol != NULL) {
KlassHandle kh(method->method_holder());
Method* wrapper_method = kh()->lookup_method(wrapper_symbol,
method->signature());
if (wrapper_method != NULL && !wrapper_method->is_native()) {
method->set_is_prefixed_native();
return lookup_entry(wrapper_method, in_base_library, THREAD);
}
}
}
#endif // INCLUDE_JVMTI
return NULL;
}
address NativeLookup::lookup_base(methodHandle method, bool& in_base_library, TRAPS) {
address entry = NULL;
ResourceMark rm(THREAD);
entry = lookup_entry(method, in_base_library, THREAD);
if (entry != NULL) return entry;
entry = lookup_entry_prefixed(method, in_base_library, THREAD);
if (entry != NULL) return entry;
THROW_MSG_0(vmSymbols::java_lang_UnsatisfiedLinkError(),
method->name_and_sig_as_C_string());
}
address NativeLookup::lookup(methodHandle method, bool& in_base_library, TRAPS) {
if (!method->has_native_function()) {
address entry = lookup_base(method, in_base_library, CHECK_NULL);
method->set_native_function(entry,
Method::native_bind_event_is_interesting);
if (PrintJNIResolving) {
ResourceMark rm(THREAD);
tty->print_cr("[Dynamic-linking native method %s.%s ... JNI]",
method->method_holder()->external_name(),
method->name()->as_C_string());
}
}
return method->native_function();
}
address NativeLookup::base_library_lookup(const char* class_name, const char* method_name, const char* signature) {
EXCEPTION_MARK;
bool in_base_library = true; // SharedRuntime inits some math methods.
TempNewSymbol c_name = SymbolTable::new_symbol(class_name, CATCH);
TempNewSymbol m_name = SymbolTable::new_symbol(method_name, CATCH);
TempNewSymbol s_name = SymbolTable::new_symbol(signature, CATCH);
Klass* k = SystemDictionary::resolve_or_fail(c_name, true, CATCH);
instanceKlassHandle klass (THREAD, k);
methodHandle method (THREAD,
klass->uncached_lookup_method(m_name, s_name, Klass::find_overpass));
address result = lookup(method, in_base_library, CATCH);
assert(in_base_library, "must be in basic library");
guarantee(result != NULL, "must be non NULL");
return result;
}
C:\hotspot-69087d08d473\src\share\vm/prims/nativeLookup.hpp
#ifndef SHARE_VM_PRIMS_NATIVELOOKUP_HPP
#define SHARE_VM_PRIMS_NATIVELOOKUP_HPP
#include "runtime/handles.hpp"
#include "utilities/top.hpp"
class NativeLookup : AllStatic {
private:
static char* pure_jni_name(methodHandle method);
static char* long_jni_name(methodHandle method);
static char* critical_jni_name(methodHandle method);
static address lookup_style(methodHandle method, char* pure_name, const char* long_name, int args_size, bool os_style, bool& in_base_library, TRAPS);
static address lookup_critical_style(methodHandle method, char* pure_name, const char* long_name, int args_size, bool os_style);
static address lookup_base (methodHandle method, bool& in_base_library, TRAPS);
static address lookup_entry(methodHandle method, bool& in_base_library, TRAPS);
static address lookup_entry_prefixed(methodHandle method, bool& in_base_library, TRAPS);
public:
static address lookup(methodHandle method, bool& in_base_library, TRAPS);
static address lookup_critical_entry(methodHandle method);
static address base_library_lookup(const char* class_name, const char* method_name, const char* signature);
};
#endif // SHARE_VM_PRIMS_NATIVELOOKUP_HPP
C:\hotspot-69087d08d473\src\share\vm/prims/perf.cpp
#include "precompiled.hpp"
#include "classfile/vmSymbols.hpp"
#include "memory/allocation.inline.hpp"
#include "memory/resourceArea.hpp"
#include "oops/oop.inline.hpp"
#include "prims/jni.h"
#include "prims/jvm.h"
#include "runtime/interfaceSupport.hpp"
#include "runtime/perfData.hpp"
#include "runtime/perfMemory.hpp"
#define PERF_ENTRY(result_type, header) \
JVM_ENTRY(result_type, header)
#define PERF_END JVM_END
#define PerfWrapper(arg) /* Unimplemented at this time */
static char* jstr_to_utf(JNIEnv *env, jstring str, TRAPS) {
char* utfstr = NULL;
if (str == NULL) {
THROW_0(vmSymbols::java_lang_NullPointerException());
}
int len = env->GetStringUTFLength(str);
int unicode_len = env->GetStringLength(str);
utfstr = NEW_RESOURCE_ARRAY(char, len + 1);
env->GetStringUTFRegion(str, 0, unicode_len, utfstr);
return utfstr;
}
PERF_ENTRY(jobject, Perf_Attach(JNIEnv *env, jobject unused, jstring user, int vmid, int mode))
PerfWrapper("Perf_Attach");
char* address = 0;
size_t capacity = 0;
const char* user_utf = NULL;
ResourceMark rm;
{
ThreadToNativeFromVM ttnfv(thread);
user_utf = user == NULL ? NULL : jstr_to_utf(env, user, CHECK_NULL);
}
if (mode != PerfMemory::PERF_MODE_RO &&
mode != PerfMemory::PERF_MODE_RW) {
THROW_0(vmSymbols::java_lang_IllegalArgumentException());
}
PerfMemory::attach(user_utf, vmid, (PerfMemory::PerfMemoryMode) mode,
&address, &capacity, CHECK_NULL);
{
ThreadToNativeFromVM ttnfv(thread);
return env->NewDirectByteBuffer(address, (jlong)capacity);
}
PERF_END
PERF_ENTRY(void, Perf_Detach(JNIEnv *env, jobject unused, jobject buffer))
PerfWrapper("Perf_Detach");
void* address = 0;
jlong capacity = 0;
{
ThreadToNativeFromVM ttnfv(thread);
address = env->GetDirectBufferAddress(buffer);
capacity = env->GetDirectBufferCapacity(buffer);
}
PerfMemory::detach((char*)address, capacity, CHECK);
PERF_END
PERF_ENTRY(jobject, Perf_CreateLong(JNIEnv *env, jobject perf, jstring name,
int variability, int units, jlong value))
PerfWrapper("Perf_CreateLong");
char* name_utf = NULL;
if (units <= 0 || units > PerfData::U_Last) {
debug_only(warning("unexpected units argument, units = %d", units));
THROW_0(vmSymbols::java_lang_IllegalArgumentException());
}
ResourceMark rm;
{
ThreadToNativeFromVM ttnfv(thread);
name_utf = jstr_to_utf(env, name, CHECK_NULL);
}
PerfLong* pl = NULL;
if (PerfDataManager::exists(name_utf)) {
THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "PerfLong name already exists");
}
switch(variability) {
case PerfData::V_Constant:
pl = PerfDataManager::create_long_constant(NULL_NS, (char *)name_utf,
(PerfData::Units)units, value,
CHECK_NULL);
break;
case PerfData::V_Monotonic:
pl = PerfDataManager::create_long_counter(NULL_NS, (char *)name_utf,
(PerfData::Units)units, value,
CHECK_NULL);
break;
case PerfData::V_Variable:
pl = PerfDataManager::create_long_variable(NULL_NS, (char *)name_utf,
(PerfData::Units)units, value,
CHECK_NULL);
break;
default: /* Illegal Argument */
debug_only(warning("unexpected variability value: %d", variability));
THROW_0(vmSymbols::java_lang_IllegalArgumentException());
break;
}
long* lp = (long*)pl->get_address();
{
ThreadToNativeFromVM ttnfv(thread);
return env->NewDirectByteBuffer(lp, sizeof(jlong));
}
PERF_END
PERF_ENTRY(jobject, Perf_CreateByteArray(JNIEnv *env, jobject perf,
jstring name, jint variability,
jint units, jbyteArray value,
jint maxlength))
PerfWrapper("Perf_CreateByteArray");
if (name == NULL || value == NULL) {
THROW_0(vmSymbols::java_lang_NullPointerException());
}
if (variability != PerfData::V_Constant &&
variability != PerfData::V_Variable) {
debug_only(warning("unexpected variability value: %d", variability));
THROW_0(vmSymbols::java_lang_IllegalArgumentException());
}
if (units != PerfData::U_String) {
debug_only(warning("unexpected units value: %d", variability));
THROW_0(vmSymbols::java_lang_IllegalArgumentException());
}
int value_length;
char* name_utf = NULL;
jbyte* value_local = NULL;
ResourceMark rm;
{
ThreadToNativeFromVM ttnfv(thread);
name_utf = jstr_to_utf(env, name, CHECK_NULL);
value_length = env->GetArrayLength(value);
value_local = NEW_RESOURCE_ARRAY(jbyte, value_length + 1);
env->GetByteArrayRegion(value, 0, value_length, value_local);
}
if (PerfDataManager::exists((char*)name_utf)) {
THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "PerfByteArray name already exists");
}
PerfByteArray* pbv = NULL;
if (units == PerfData::U_String) {
if (variability == PerfData::V_Constant) {
pbv = PerfDataManager::create_string_constant(NULL_NS, (char*)name_utf,
(char*)value_local,
CHECK_NULL);
assert(maxlength == value_length, "string constant length should be == maxlength");
maxlength = value_length;
}
else {
pbv = PerfDataManager::create_string_variable(NULL_NS, (char*)name_utf,
maxlength,
(char*)value_local,
CHECK_NULL);
assert(maxlength >= value_length,"string variable length should be <= maxlength");
}
}
char* cp = (char*)pbv->get_address();
{
ThreadToNativeFromVM ttnfv(thread);
return env->NewDirectByteBuffer(cp, maxlength+1);
}
PERF_END
PERF_ENTRY(jlong, Perf_HighResCounter(JNIEnv *env, jobject perf))
PerfWrapper("Perf_HighResCounter");
return os::elapsed_counter();
PERF_END
PERF_ENTRY(jlong, Perf_HighResFrequency(JNIEnv *env, jobject perf))
PerfWrapper("Perf_HighResFrequency");
return os::elapsed_frequency();
PERF_END
#define CC (char*) /*cast a literal from (const char*)*/
#define FN_PTR(f) CAST_FROM_FN_PTR(void*, &f)
#define BB "Ljava/nio/ByteBuffer;"
#define JLS "Ljava/lang/String;"
#define CL_ARGS CC "(" JLS "IIJ)" BB
#define CBA_ARGS CC "(" JLS "II[BI)" BB
static JNINativeMethod perfmethods[] = {
{CC "attach", CC "(" JLS "II)" BB, FN_PTR(Perf_Attach)},
{CC "detach", CC "(" BB ")V", FN_PTR(Perf_Detach)},
{CC "createLong", CL_ARGS, FN_PTR(Perf_CreateLong)},
{CC "createByteArray", CBA_ARGS, FN_PTR(Perf_CreateByteArray)},
{CC "highResCounter", CC "()J", FN_PTR(Perf_HighResCounter)},
{CC "highResFrequency", CC "()J", FN_PTR(Perf_HighResFrequency)}
};
#undef CBA_ARGS
#undef CL_ARGS
#undef JLS
#undef BB
#undef FN_PTR
#undef CC
JVM_ENTRY(void, JVM_RegisterPerfMethods(JNIEnv *env, jclass perfclass))
PerfWrapper("JVM_RegisterPerfMethods");
{
ThreadToNativeFromVM ttnfv(thread);
int ok = env->RegisterNatives(perfclass, perfmethods, sizeof(perfmethods)/sizeof(JNINativeMethod));
guarantee(ok == 0, "register perf natives");
}
JVM_END
C:\hotspot-69087d08d473\src\share\vm/prims/privilegedStack.cpp
#include "precompiled.hpp"
#include "memory/allocation.inline.hpp"
#include "oops/instanceKlass.hpp"
#include "oops/method.hpp"
#include "oops/oop.inline.hpp"
#include "prims/privilegedStack.hpp"
#include "runtime/vframe.hpp"
PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
void PrivilegedElement::initialize(vframeStream* vfst, oop context, PrivilegedElement* next, TRAPS) {
Method* method = vfst->method();
_klass = method->method_holder();
_privileged_context = context;
#ifdef CHECK_UNHANDLED_OOPS
THREAD->allow_unhandled_oop(&_privileged_context);
#endif // CHECK_UNHANDLED_OOPS
_frame_id = vfst->frame_id();
_next = next;
assert(_privileged_context == NULL || _privileged_context->is_oop(), "must be an oop");
assert(protection_domain() == NULL || protection_domain()->is_oop(), "must be an oop");
}
void PrivilegedElement::oops_do(OopClosure* f) {
PrivilegedElement *cur = this;
do {
f->do_oop((oop*) &cur->_privileged_context);
cur = cur->_next;
} while(cur != NULL);
}
void PrivilegedElement::classes_do(KlassClosure* f) {
PrivilegedElement *cur = this;
do {
f->do_klass(cur->_klass);
cur = cur->_next;
} while(cur != NULL);
}
#ifndef PRODUCT
void PrivilegedElement::print_on(outputStream* st) const {
st->print(" 0x%lx ", _frame_id);
_klass->print_value_on(st);
if (protection_domain() != NULL) {
st->print(" ");
protection_domain()->print_value_on(st);
}
st->cr();
}
bool PrivilegedElement::contains(address addr) {
PrivilegedElement *e = (PrivilegedElement *)addr;
if (e >= this && e < this+1) return true;
if (_next != NULL) {
return _next->contains(addr);
} else {
return false;
}
}
#endif
C:\hotspot-69087d08d473\src\share\vm/prims/privilegedStack.hpp
#ifndef SHARE_VM_PRIMS_PRIVILEGEDSTACK_HPP
#define SHARE_VM_PRIMS_PRIVILEGEDSTACK_HPP
#include "memory/allocation.hpp"
#include "oops/oopsHierarchy.hpp"
#include "runtime/vframe.hpp"
#include "utilities/growableArray.hpp"
class PrivilegedElement VALUE_OBJ_CLASS_SPEC {
private:
Klass* _klass; // klass for method
oop _privileged_context; // context for operation
intptr_t* _frame_id; // location on stack
PrivilegedElement* _next; // Link to next one on stack
public:
void initialize(vframeStream* vf, oop context, PrivilegedElement* next, TRAPS);
void oops_do(OopClosure* f);
void classes_do(KlassClosure* f);
intptr_t* frame_id() const { return _frame_id; }
oop privileged_context() const { return _privileged_context; }
oop class_loader() const { return InstanceKlass::cast(_klass)->class_loader(); }
oop protection_domain() const { return InstanceKlass::cast(_klass)->protection_domain(); }
PrivilegedElement *next() const { return _next; }
void print_on(outputStream* st) const PRODUCT_RETURN;
bool contains(address addr) PRODUCT_RETURN0;
};
#endif // SHARE_VM_PRIMS_PRIVILEGEDSTACK_HPP
C:\hotspot-69087d08d473\src\share\vm/prims/unsafe.cpp
#include "precompiled.hpp"
#include "classfile/vmSymbols.hpp"
#include "utilities/macros.hpp"
#if INCLUDE_ALL_GCS
#include "gc_implementation/g1/g1SATBCardTableModRefBS.hpp"
#endif // INCLUDE_ALL_GCS
#include "jfr/jfrEvents.hpp"
#include "memory/allocation.inline.hpp"
#include "prims/jni.h"
#include "prims/jvm.h"
#include "runtime/globals.hpp"
#include "runtime/interfaceSupport.hpp"
#include "runtime/prefetch.inline.hpp"
#include "runtime/orderAccess.inline.hpp"
#include "runtime/reflection.hpp"
#include "runtime/synchronizer.hpp"
#include "services/threadService.hpp"
#include "utilities/copy.hpp"
#include "utilities/dtrace.hpp"
PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
#ifndef USDT2
HS_DTRACE_PROBE_DECL3(hotspot, thread__park__begin, uintptr_t, int, long long);
HS_DTRACE_PROBE_DECL1(hotspot, thread__park__end, uintptr_t);
HS_DTRACE_PROBE_DECL1(hotspot, thread__unpark, uintptr_t);
#endif /* !USDT2 */
#define MAX_OBJECT_SIZE \
( arrayOopDesc::header_size(T_DOUBLE) * HeapWordSize \
+ ((julong)max_jint * sizeof(double)) )
#define UNSAFE_ENTRY(result_type, header) \
JVM_ENTRY(result_type, header)
#define UNSAFE_END JVM_END
#define UnsafeWrapper(arg) /*nothing, for the present*/
inline void* addr_from_java(jlong addr) {
return (void*)(uintptr_t)addr;
}
inline jlong addr_to_java(void* p) {
assert(p == (void*)(uintptr_t)p, "must not be odd high bits");
return (uintptr_t)p;
}
inline jlong field_offset_to_byte_offset(jlong field_offset) {
return field_offset;
}
inline jlong field_offset_from_byte_offset(jlong byte_offset) {
return byte_offset;
}
inline jint invocation_key_from_method_slot(jint slot) {
return slot;
}
inline jint invocation_key_to_method_slot(jint key) {
return key;
}
inline void* index_oop_from_field_offset_long(oop p, jlong field_offset) {
jlong byte_offset = field_offset_to_byte_offset(field_offset);
#ifdef ASSERT
if (p != NULL) {
assert(byte_offset >= 0 && byte_offset <= (jlong)MAX_OBJECT_SIZE, "sane offset");
if (byte_offset == (jint)byte_offset) {
void* ptr_plus_disp = (address)p + byte_offset;
assert((void*)p->obj_field_addr<oop>((jint)byte_offset) == ptr_plus_disp,
"raw [ptr+disp] must be consistent with oop::field_base");
}
jlong p_size = HeapWordSize * (jlong)(p->size());
assert(byte_offset < p_size, err_msg("Unsafe access: offset " INT64_FORMAT " > object's size " INT64_FORMAT, byte_offset, p_size));
}
#endif
if (sizeof(char*) == sizeof(jint)) // (this constant folds!)
return (address)p + (jint) byte_offset;
else
return (address)p + byte_offset;
}
jlong Unsafe_field_offset_to_byte_offset(jlong field_offset) {
return field_offset;
}
jlong Unsafe_field_offset_from_byte_offset(jlong byte_offset) {
return byte_offset;
}
jint Unsafe_invocation_key_from_method_slot(jint slot) {
return invocation_key_from_method_slot(slot);
}
jint Unsafe_invocation_key_to_method_slot(jint key) {
return invocation_key_to_method_slot(key);
}
#define truncate_jboolean(x) ((x) & 1)
#define truncate_jbyte(x) (x)
#define truncate_jshort(x) (x)
#define truncate_jchar(x) (x)
#define truncate_jint(x) (x)
#define truncate_jlong(x) (x)
#define truncate_jfloat(x) (x)
#define truncate_jdouble(x) (x)
#define GET_FIELD(obj, offset, type_name, v) \
oop p = JNIHandles::resolve(obj); \
type_name v = *(type_name*)index_oop_from_field_offset_long(p, offset)
#define SET_FIELD(obj, offset, type_name, x) \
oop p = JNIHandles::resolve(obj); \
#define GET_FIELD_VOLATILE(obj, offset, type_name, v) \
oop p = JNIHandles::resolve(obj); \
if (support_IRIW_for_not_multiple_copy_atomic_cpu) { \
OrderAccess::fence(); \
} \
volatile type_name v = OrderAccess::load_acquire((volatile type_name*)index_oop_from_field_offset_long(p, offset));
#define SET_FIELD_VOLATILE(obj, offset, type_name, x) \
oop p = JNIHandles::resolve(obj); \
OrderAccess::release_store_fence((volatile type_name*)index_oop_from_field_offset_long(p, offset), truncate_##type_name(x));
#define GET_OOP_FIELD(obj, offset, v) \
oop p = JNIHandles::resolve(obj); \
oop v; \
if (UseCompressedOops) { \
narrowOop n = *(narrowOop*)index_oop_from_field_offset_long(p, offset); \
v = oopDesc::decode_heap_oop(n); \
} else { \
v = *(oop*)index_oop_from_field_offset_long(p, offset); \
}
#if INCLUDE_ALL_GCS
static bool is_java_lang_ref_Reference_access(oop o, jlong offset) {
if (offset == java_lang_ref_Reference::referent_offset && o != NULL) {
Klass* k = o->klass();
if (InstanceKlass::cast(k)->reference_type() != REF_NONE) {
assert(InstanceKlass::cast(k)->is_subclass_of(SystemDictionary::Reference_klass()), "sanity");
return true;
}
}
return false;
}
#endif
static void ensure_satb_referent_alive(oop o, jlong offset, oop v) {
#if INCLUDE_ALL_GCS
if (UseG1GC && v != NULL && is_java_lang_ref_Reference_access(o, offset)) {
G1SATBCardTableModRefBS::enqueue(v);
}
#endif
}
UNSAFE_ENTRY(jobject, Unsafe_GetObject140(JNIEnv *env, jobject unsafe, jobject obj, jint offset))
UnsafeWrapper("Unsafe_GetObject");
if (obj == NULL) THROW_0(vmSymbols::java_lang_NullPointerException());
GET_OOP_FIELD(obj, offset, v)
ensure_satb_referent_alive(p, offset, v);
return JNIHandles::make_local(env, v);
UNSAFE_END
UNSAFE_ENTRY(void, Unsafe_SetObject140(JNIEnv *env, jobject unsafe, jobject obj, jint offset, jobject x_h))
UnsafeWrapper("Unsafe_SetObject");
if (obj == NULL) THROW(vmSymbols::java_lang_NullPointerException());
oop x = JNIHandles::resolve(x_h);
oop p = JNIHandles::resolve(obj);
if (UseCompressedOops) {
if (x != NULL) {
oop_store((narrowOop*)index_oop_from_field_offset_long(p, offset), x);
} else {
narrowOop n = oopDesc::encode_heap_oop_not_null(x);
}
} else {
if (x != NULL) {
oop_store((oop*)index_oop_from_field_offset_long(p, offset), x);
} else {
}
}
UNSAFE_END
UNSAFE_ENTRY(jobject, Unsafe_GetObject(JNIEnv *env, jobject unsafe, jobject obj, jlong offset))
UnsafeWrapper("Unsafe_GetObject");
GET_OOP_FIELD(obj, offset, v)
ensure_satb_referent_alive(p, offset, v);
return JNIHandles::make_local(env, v);
UNSAFE_END
UNSAFE_ENTRY(void, Unsafe_SetObject(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jobject x_h))
UnsafeWrapper("Unsafe_SetObject");
oop x = JNIHandles::resolve(x_h);
oop p = JNIHandles::resolve(obj);
if (UseCompressedOops) {
oop_store((narrowOop*)index_oop_from_field_offset_long(p, offset), x);
} else {
oop_store((oop*)index_oop_from_field_offset_long(p, offset), x);
}
UNSAFE_END
UNSAFE_ENTRY(jobject, Unsafe_GetObjectVolatile(JNIEnv *env, jobject unsafe, jobject obj, jlong offset))
UnsafeWrapper("Unsafe_GetObjectVolatile");
oop p = JNIHandles::resolve(obj);
void* addr = index_oop_from_field_offset_long(p, offset);
volatile oop v;
if (UseCompressedOops) {
volatile narrowOop n = *(volatile narrowOop*) addr;
(void)const_cast<oop&>(v = oopDesc::decode_heap_oop(n));
} else {
(void)const_cast<oop&>(v = *(volatile oop*) addr);
}
ensure_satb_referent_alive(p, offset, v);
OrderAccess::acquire();
return JNIHandles::make_local(env, v);
UNSAFE_END
UNSAFE_ENTRY(void, Unsafe_SetObjectVolatile(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jobject x_h))
UnsafeWrapper("Unsafe_SetObjectVolatile");
oop x = JNIHandles::resolve(x_h);
oop p = JNIHandles::resolve(obj);
void* addr = index_oop_from_field_offset_long(p, offset);
OrderAccess::release();
if (UseCompressedOops) {
oop_store((narrowOop*)addr, x);
} else {
oop_store((oop*)addr, x);
}
OrderAccess::fence();
UNSAFE_END
#ifndef SUPPORTS_NATIVE_CX8
UNSAFE_ENTRY(jlong, Unsafe_GetLongVolatile(JNIEnv *env, jobject unsafe, jobject obj, jlong offset))
UnsafeWrapper("Unsafe_GetLongVolatile");
{
if (VM_Version::supports_cx8()) {
GET_FIELD_VOLATILE(obj, offset, jlong, v);
return v;
}
else {
Handle p (THREAD, JNIHandles::resolve(obj));
jlong* addr = (jlong*)(index_oop_from_field_offset_long(p(), offset));
MutexLockerEx mu(UnsafeJlong_lock, Mutex::_no_safepoint_check_flag);
jlong value = Atomic::load(addr);
return value;
}
}
UNSAFE_END
UNSAFE_ENTRY(void, Unsafe_SetLongVolatile(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jlong x))
UnsafeWrapper("Unsafe_SetLongVolatile");
{
if (VM_Version::supports_cx8()) {
SET_FIELD_VOLATILE(obj, offset, jlong, x);
}
else {
Handle p (THREAD, JNIHandles::resolve(obj));
jlong* addr = (jlong*)(index_oop_from_field_offset_long(p(), offset));
MutexLockerEx mu(UnsafeJlong_lock, Mutex::_no_safepoint_check_flag);
Atomic::store(x, addr);
}
}
UNSAFE_END
#endif // not SUPPORTS_NATIVE_CX8
#define DEFINE_GETSETOOP(jboolean, Boolean) \
\
UNSAFE_ENTRY(jboolean, Unsafe_Get##Boolean##140(JNIEnv *env, jobject unsafe, jobject obj, jint offset)) \
UnsafeWrapper("Unsafe_Get"#Boolean); \
if (obj == NULL) THROW_0(vmSymbols::java_lang_NullPointerException()); \
GET_FIELD(obj, offset, jboolean, v); \
return v; \
UNSAFE_END \
\
UNSAFE_ENTRY(void, Unsafe_Set##Boolean##140(JNIEnv *env, jobject unsafe, jobject obj, jint offset, jboolean x)) \
UnsafeWrapper("Unsafe_Set"#Boolean); \
if (obj == NULL) THROW(vmSymbols::java_lang_NullPointerException()); \
SET_FIELD(obj, offset, jboolean, x); \
UNSAFE_END \
\
UNSAFE_ENTRY(jboolean, Unsafe_Get##Boolean(JNIEnv *env, jobject unsafe, jobject obj, jlong offset)) \
UnsafeWrapper("Unsafe_Get"#Boolean); \
GET_FIELD(obj, offset, jboolean, v); \
return v; \
UNSAFE_END \
\
UNSAFE_ENTRY(void, Unsafe_Set##Boolean(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jboolean x)) \
UnsafeWrapper("Unsafe_Set"#Boolean); \
SET_FIELD(obj, offset, jboolean, x); \
UNSAFE_END \
\
DEFINE_GETSETOOP(jboolean, Boolean)
DEFINE_GETSETOOP(jbyte, Byte)
DEFINE_GETSETOOP(jshort, Short);
DEFINE_GETSETOOP(jchar, Char);
DEFINE_GETSETOOP(jint, Int);
DEFINE_GETSETOOP(jlong, Long);
DEFINE_GETSETOOP(jfloat, Float);
DEFINE_GETSETOOP(jdouble, Double);
#undef DEFINE_GETSETOOP
#define DEFINE_GETSETOOP_VOLATILE(jboolean, Boolean) \
\
UNSAFE_ENTRY(jboolean, Unsafe_Get##Boolean##Volatile(JNIEnv *env, jobject unsafe, jobject obj, jlong offset)) \
UnsafeWrapper("Unsafe_Get"#Boolean); \
GET_FIELD_VOLATILE(obj, offset, jboolean, v); \
return v; \
UNSAFE_END \
\
UNSAFE_ENTRY(void, Unsafe_Set##Boolean##Volatile(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jboolean x)) \
UnsafeWrapper("Unsafe_Set"#Boolean); \
SET_FIELD_VOLATILE(obj, offset, jboolean, x); \
UNSAFE_END \
\
DEFINE_GETSETOOP_VOLATILE(jboolean, Boolean)
DEFINE_GETSETOOP_VOLATILE(jbyte, Byte)
DEFINE_GETSETOOP_VOLATILE(jshort, Short);
DEFINE_GETSETOOP_VOLATILE(jchar, Char);
DEFINE_GETSETOOP_VOLATILE(jint, Int);
DEFINE_GETSETOOP_VOLATILE(jfloat, Float);
DEFINE_GETSETOOP_VOLATILE(jdouble, Double);
#ifdef SUPPORTS_NATIVE_CX8
DEFINE_GETSETOOP_VOLATILE(jlong, Long);
#endif
#undef DEFINE_GETSETOOP_VOLATILE
UNSAFE_ENTRY(void, Unsafe_SetOrderedInt(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jint x))
UnsafeWrapper("Unsafe_SetOrderedInt");
SET_FIELD_VOLATILE(obj, offset, jint, x);
UNSAFE_END
UNSAFE_ENTRY(void, Unsafe_SetOrderedObject(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jobject x_h))
UnsafeWrapper("Unsafe_SetOrderedObject");
oop x = JNIHandles::resolve(x_h);
oop p = JNIHandles::resolve(obj);
void* addr = index_oop_from_field_offset_long(p, offset);
OrderAccess::release();
if (UseCompressedOops) {
oop_store((narrowOop*)addr, x);
} else {
oop_store((oop*)addr, x);
}
OrderAccess::fence();
UNSAFE_END
UNSAFE_ENTRY(void, Unsafe_SetOrderedLong(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jlong x))
UnsafeWrapper("Unsafe_SetOrderedLong");
#ifdef SUPPORTS_NATIVE_CX8
SET_FIELD_VOLATILE(obj, offset, jlong, x);
#else
{
if (VM_Version::supports_cx8()) {
SET_FIELD_VOLATILE(obj, offset, jlong, x);
}
else {
Handle p (THREAD, JNIHandles::resolve(obj));
jlong* addr = (jlong*)(index_oop_from_field_offset_long(p(), offset));
MutexLockerEx mu(UnsafeJlong_lock, Mutex::_no_safepoint_check_flag);
Atomic::store(x, addr);
}
}
#endif
UNSAFE_END
UNSAFE_ENTRY(void, Unsafe_LoadFence(JNIEnv *env, jobject unsafe))
UnsafeWrapper("Unsafe_LoadFence");
OrderAccess::acquire();
UNSAFE_END
UNSAFE_ENTRY(void, Unsafe_StoreFence(JNIEnv *env, jobject unsafe))
UnsafeWrapper("Unsafe_StoreFence");
OrderAccess::release();
UNSAFE_END
UNSAFE_ENTRY(void, Unsafe_FullFence(JNIEnv *env, jobject unsafe))
UnsafeWrapper("Unsafe_FullFence");
OrderAccess::fence();
UNSAFE_END
#define DEFINE_GETSETNATIVE(java_type, Type, native_type) \
\
UNSAFE_ENTRY(java_type, Unsafe_GetNative##Type(JNIEnv *env, jobject unsafe, jlong addr)) \
UnsafeWrapper("Unsafe_GetNative"#Type); \
void* p = addr_from_java(addr); \
JavaThread* t = JavaThread::current(); \
t->set_doing_unsafe_access(true); \
java_type x = *(volatile native_type*)p; \
t->set_doing_unsafe_access(false); \
return x; \
UNSAFE_END \
\
UNSAFE_ENTRY(void, Unsafe_SetNative##Type(JNIEnv *env, jobject unsafe, jlong addr, java_type x)) \
UnsafeWrapper("Unsafe_SetNative"#Type); \
JavaThread* t = JavaThread::current(); \
t->set_doing_unsafe_access(true); \
void* p = addr_from_java(addr); \
t->set_doing_unsafe_access(false); \
UNSAFE_END \
\
DEFINE_GETSETNATIVE(jbyte, Byte, signed char)
DEFINE_GETSETNATIVE(jshort, Short, signed short);
DEFINE_GETSETNATIVE(jchar, Char, unsigned short);
DEFINE_GETSETNATIVE(jint, Int, jint);
DEFINE_GETSETNATIVE(jfloat, Float, float);
DEFINE_GETSETNATIVE(jdouble, Double, double);
#undef DEFINE_GETSETNATIVE
UNSAFE_ENTRY(jlong, Unsafe_GetNativeLong(JNIEnv *env, jobject unsafe, jlong addr))
UnsafeWrapper("Unsafe_GetNativeLong");
JavaThread* t = JavaThread::current();
t->set_doing_unsafe_access(true);
void* p = addr_from_java(addr);
jlong x;
if (((intptr_t)p & 7) == 0) {
x = *(volatile jlong*)p;
} else {
jlong_accessor acc;
acc.words[0] = ((volatile jint*)p)[0];
acc.words[1] = ((volatile jint*)p)[1];
x = acc.long_value;
}
t->set_doing_unsafe_access(false);
return x;
UNSAFE_END
UNSAFE_ENTRY(void, Unsafe_SetNativeLong(JNIEnv *env, jobject unsafe, jlong addr, jlong x))
UnsafeWrapper("Unsafe_SetNativeLong");
JavaThread* t = JavaThread::current();
t->set_doing_unsafe_access(true);
void* p = addr_from_java(addr);
if (((intptr_t)p & 7) == 0) {
} else {
jlong_accessor acc;
acc.long_value = x;
((volatile jint*)p)[0] = acc.words[0];
((volatile jint*)p)[1] = acc.words[1];
}
t->set_doing_unsafe_access(false);
UNSAFE_END
UNSAFE_ENTRY(jlong, Unsafe_GetNativeAddress(JNIEnv *env, jobject unsafe, jlong addr))
UnsafeWrapper("Unsafe_GetNativeAddress");
void* p = addr_from_java(addr);
return addr_to_java(*(void**)p);
UNSAFE_END
UNSAFE_ENTRY(void, Unsafe_SetNativeAddress(JNIEnv *env, jobject unsafe, jlong addr, jlong x))
UnsafeWrapper("Unsafe_SetNativeAddress");
void* p = addr_from_java(addr);
UNSAFE_END
UNSAFE_ENTRY(jobject, Unsafe_AllocateInstance(JNIEnv *env, jobject unsafe, jclass cls))
UnsafeWrapper("Unsafe_AllocateInstance");
{
ThreadToNativeFromVM ttnfv(thread);
return env->AllocObject(cls);
}
UNSAFE_END
UNSAFE_ENTRY(jlong, Unsafe_AllocateMemory(JNIEnv *env, jobject unsafe, jlong size))
UnsafeWrapper("Unsafe_AllocateMemory");
size_t sz = (size_t)size;
if (sz != (julong)size || size < 0) {
THROW_0(vmSymbols::java_lang_IllegalArgumentException());
}
if (sz == 0) {
return 0;
}
sz = round_to(sz, HeapWordSize);
void* x = os::malloc(sz, mtInternal);
if (x == NULL) {
THROW_0(vmSymbols::java_lang_OutOfMemoryError());
}
return addr_to_java(x);
UNSAFE_END
UNSAFE_ENTRY(jlong, Unsafe_ReallocateMemory(JNIEnv *env, jobject unsafe, jlong addr, jlong size))
UnsafeWrapper("Unsafe_ReallocateMemory");
void* p = addr_from_java(addr);
size_t sz = (size_t)size;
if (sz != (julong)size || size < 0) {
THROW_0(vmSymbols::java_lang_IllegalArgumentException());
}
if (sz == 0) {
os::free(p);
return 0;
}
sz = round_to(sz, HeapWordSize);
void* x = (p == NULL) ? os::malloc(sz, mtInternal) : os::realloc(p, sz, mtInternal);
if (x == NULL) {
THROW_0(vmSymbols::java_lang_OutOfMemoryError());
}
return addr_to_java(x);
UNSAFE_END
UNSAFE_ENTRY(void, Unsafe_FreeMemory(JNIEnv *env, jobject unsafe, jlong addr))
UnsafeWrapper("Unsafe_FreeMemory");
void* p = addr_from_java(addr);
if (p == NULL) {
return;
}
os::free(p);
UNSAFE_END
UNSAFE_ENTRY(void, Unsafe_SetMemory(JNIEnv *env, jobject unsafe, jlong addr, jlong size, jbyte value))
UnsafeWrapper("Unsafe_SetMemory");
size_t sz = (size_t)size;
if (sz != (julong)size || size < 0) {
THROW(vmSymbols::java_lang_IllegalArgumentException());
}
char* p = (char*) addr_from_java(addr);
Copy::fill_to_memory_atomic(p, sz, value);
UNSAFE_END
UNSAFE_ENTRY(void, Unsafe_SetMemory2(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jlong size, jbyte value))
UnsafeWrapper("Unsafe_SetMemory");
size_t sz = (size_t)size;
if (sz != (julong)size || size < 0) {
THROW(vmSymbols::java_lang_IllegalArgumentException());
}
oop base = JNIHandles::resolve(obj);
void* p = index_oop_from_field_offset_long(base, offset);
Copy::fill_to_memory_atomic(p, sz, value);
UNSAFE_END
UNSAFE_ENTRY(void, Unsafe_CopyMemory(JNIEnv *env, jobject unsafe, jlong srcAddr, jlong dstAddr, jlong size))
UnsafeWrapper("Unsafe_CopyMemory");
if (size == 0) {
return;
}
size_t sz = (size_t)size;
if (sz != (julong)size || size < 0) {
THROW(vmSymbols::java_lang_IllegalArgumentException());
}
void* src = addr_from_java(srcAddr);
void* dst = addr_from_java(dstAddr);
Copy::conjoint_memory_atomic(src, dst, sz);
UNSAFE_END
UNSAFE_ENTRY(void, Unsafe_CopyMemory2(JNIEnv *env, jobject unsafe, jobject srcObj, jlong srcOffset, jobject dstObj, jlong dstOffset, jlong size))
UnsafeWrapper("Unsafe_CopyMemory");
if (size == 0) {
return;
}
size_t sz = (size_t)size;
if (sz != (julong)size || size < 0) {
THROW(vmSymbols::java_lang_IllegalArgumentException());
}
oop srcp = JNIHandles::resolve(srcObj);
oop dstp = JNIHandles::resolve(dstObj);
if (dstp != NULL && !dstp->is_typeArray()) {
THROW(vmSymbols::java_lang_IllegalArgumentException());
}
void* src = index_oop_from_field_offset_long(srcp, srcOffset);
void* dst = index_oop_from_field_offset_long(dstp, dstOffset);
Copy::conjoint_memory_atomic(src, dst, sz);
UNSAFE_END
UNSAFE_ENTRY(jint, Unsafe_AddressSize(JNIEnv *env, jobject unsafe))
UnsafeWrapper("Unsafe_AddressSize");
return sizeof(void*);
UNSAFE_END
UNSAFE_ENTRY(jint, Unsafe_PageSize(JNIEnv *env, jobject unsafe))
UnsafeWrapper("Unsafe_PageSize");
return os::vm_page_size();
UNSAFE_END
jint find_field_offset(jobject field, int must_be_static, TRAPS) {
if (field == NULL) {
THROW_0(vmSymbols::java_lang_NullPointerException());
}
oop reflected = JNIHandles::resolve_non_null(field);
oop mirror = java_lang_reflect_Field::clazz(reflected);
Klass* k = java_lang_Class::as_Klass(mirror);
int slot = java_lang_reflect_Field::slot(reflected);
int modifiers = java_lang_reflect_Field::modifiers(reflected);
if (must_be_static >= 0) {
int really_is_static = ((modifiers & JVM_ACC_STATIC) != 0);
if (must_be_static != really_is_static) {
THROW_0(vmSymbols::java_lang_IllegalArgumentException());
}
}
int offset = InstanceKlass::cast(k)->field_offset(slot);
return field_offset_from_byte_offset(offset);
}
UNSAFE_ENTRY(jlong, Unsafe_ObjectFieldOffset(JNIEnv *env, jobject unsafe, jobject field))
UnsafeWrapper("Unsafe_ObjectFieldOffset");
return find_field_offset(field, 0, THREAD);
UNSAFE_END
UNSAFE_ENTRY(jlong, Unsafe_StaticFieldOffset(JNIEnv *env, jobject unsafe, jobject field))
UnsafeWrapper("Unsafe_StaticFieldOffset");
return find_field_offset(field, 1, THREAD);
UNSAFE_END
UNSAFE_ENTRY(jobject, Unsafe_StaticFieldBaseFromField(JNIEnv *env, jobject unsafe, jobject field))
UnsafeWrapper("Unsafe_StaticFieldBase");
if (field == NULL) THROW_0(vmSymbols::java_lang_NullPointerException());
oop reflected = JNIHandles::resolve_non_null(field);
oop mirror = java_lang_reflect_Field::clazz(reflected);
int modifiers = java_lang_reflect_Field::modifiers(reflected);
if ((modifiers & JVM_ACC_STATIC) == 0) {
THROW_0(vmSymbols::java_lang_IllegalArgumentException());
}
return JNIHandles::make_local(env, mirror);
UNSAFE_END
UNSAFE_ENTRY(jint, Unsafe_FieldOffset(JNIEnv *env, jobject unsafe, jobject field))
UnsafeWrapper("Unsafe_FieldOffset");
jlong offset = find_field_offset(field, -1, THREAD);
guarantee(offset == (jint)offset, "offset fits in 32 bits");
return (jint)offset;
UNSAFE_END
UNSAFE_ENTRY(jobject, Unsafe_StaticFieldBaseFromClass(JNIEnv *env, jobject unsafe, jobject clazz))
UnsafeWrapper("Unsafe_StaticFieldBase");
if (clazz == NULL) {
THROW_0(vmSymbols::java_lang_NullPointerException());
}
return JNIHandles::make_local(env, JNIHandles::resolve_non_null(clazz));
UNSAFE_END
UNSAFE_ENTRY(void, Unsafe_EnsureClassInitialized(JNIEnv *env, jobject unsafe, jobject clazz)) {
UnsafeWrapper("Unsafe_EnsureClassInitialized");
if (clazz == NULL) {
THROW(vmSymbols::java_lang_NullPointerException());
}
oop mirror = JNIHandles::resolve_non_null(clazz);
Klass* klass = java_lang_Class::as_Klass(mirror);
if (klass != NULL && klass->should_be_initialized()) {
InstanceKlass* k = InstanceKlass::cast(klass);
k->initialize(CHECK);
}
}
UNSAFE_END
UNSAFE_ENTRY(jboolean, Unsafe_ShouldBeInitialized(JNIEnv *env, jobject unsafe, jobject clazz)) {
UnsafeWrapper("Unsafe_ShouldBeInitialized");
if (clazz == NULL) {
THROW_(vmSymbols::java_lang_NullPointerException(), false);
}
oop mirror = JNIHandles::resolve_non_null(clazz);
Klass* klass = java_lang_Class::as_Klass(mirror);
if (klass != NULL && klass->should_be_initialized()) {
return true;
}
return false;
}
UNSAFE_END
static void getBaseAndScale(int& base, int& scale, jclass acls, TRAPS) {
if (acls == NULL) {
THROW(vmSymbols::java_lang_NullPointerException());
}
oop mirror = JNIHandles::resolve_non_null(acls);
Klass* k = java_lang_Class::as_Klass(mirror);
if (k == NULL || !k->oop_is_array()) {
THROW(vmSymbols::java_lang_InvalidClassException());
} else if (k->oop_is_objArray()) {
base = arrayOopDesc::base_offset_in_bytes(T_OBJECT);
scale = heapOopSize;
} else if (k->oop_is_typeArray()) {
TypeArrayKlass* tak = TypeArrayKlass::cast(k);
base = tak->array_header_in_bytes();
assert(base == arrayOopDesc::base_offset_in_bytes(tak->element_type()), "array_header_size semantics ok");
scale = (1 << tak->log2_element_size());
} else {
ShouldNotReachHere();
}
}
UNSAFE_ENTRY(jint, Unsafe_ArrayBaseOffset(JNIEnv *env, jobject unsafe, jclass acls))
UnsafeWrapper("Unsafe_ArrayBaseOffset");
int base = 0, scale = 0;
getBaseAndScale(base, scale, acls, CHECK_0);
return field_offset_from_byte_offset(base);
UNSAFE_END
UNSAFE_ENTRY(jint, Unsafe_ArrayIndexScale(JNIEnv *env, jobject unsafe, jclass acls))
UnsafeWrapper("Unsafe_ArrayIndexScale");
int base = 0, scale = 0;
getBaseAndScale(base, scale, acls, CHECK_0);
return field_offset_from_byte_offset(scale) - field_offset_from_byte_offset(0);
UNSAFE_END
static inline void throw_new(JNIEnv *env, const char *ename) {
char buf[100];
strcpy(buf, "java/lang/");
strcat(buf, ename);
jclass cls = env->FindClass(buf);
if (env->ExceptionCheck()) {
env->ExceptionClear();
tty->print_cr("Unsafe: cannot throw %s because FindClass has failed", buf);
return;
}
char* msg = NULL;
env->ThrowNew(cls, msg);
}
static jclass Unsafe_DefineClass_impl(JNIEnv *env, jstring name, jbyteArray data, int offset, int length, jobject loader, jobject pd) {
{
jbyte *body;
char *utfName;
jclass result = 0;
char buf[128];
if (UsePerfData) {
ClassLoader::unsafe_defineClassCallCounter()->inc();
}
if (data == NULL) {
throw_new(env, "NullPointerException");
return 0;
}
if (length < 0) {
throw_new(env, "ArrayIndexOutOfBoundsException");
return 0;
}
body = NEW_C_HEAP_ARRAY(jbyte, length, mtInternal);
if (body == 0) {
throw_new(env, "OutOfMemoryError");
return 0;
}
env->GetByteArrayRegion(data, offset, length, body);
if (env->ExceptionOccurred())
goto free_body;
if (name != NULL) {
uint len = env->GetStringUTFLength(name);
int unicode_len = env->GetStringLength(name);
if (len >= sizeof(buf)) {
utfName = NEW_C_HEAP_ARRAY(char, len + 1, mtInternal);
if (utfName == NULL) {
throw_new(env, "OutOfMemoryError");
goto free_body;
}
} else {
utfName = buf;
}
env->GetStringUTFRegion(name, 0, unicode_len, utfName);
for (uint i = 0; i < len; i++) {
if (utfName[i] == '.') utfName[i] = '/';
}
} else {
utfName = NULL;
}
result = JVM_DefineClass(env, utfName, loader, body, length, pd);
if (utfName && utfName != buf)
FREE_C_HEAP_ARRAY(char, utfName, mtInternal);
free_body:
FREE_C_HEAP_ARRAY(jbyte, body, mtInternal);
return result;
}
}
UNSAFE_ENTRY(jclass, Unsafe_DefineClass(JNIEnv *env, jobject unsafe, jstring name, jbyteArray data, int offset, int length, jobject loader, jobject pd))
UnsafeWrapper("Unsafe_DefineClass");
{
ThreadToNativeFromVM ttnfv(thread);
return Unsafe_DefineClass_impl(env, name, data, offset, length, loader, pd);
}
UNSAFE_END
UNSAFE_ENTRY(jclass, Unsafe_DefineClass0(JNIEnv *env, jobject unsafe, jstring name, jbyteArray data, int offset, int length))
UnsafeWrapper("Unsafe_DefineClass");
{
ThreadToNativeFromVM ttnfv(thread);
int depthFromDefineClass0 = 1;
jclass caller = JVM_GetCallerClass(env, depthFromDefineClass0);
jobject loader = (caller == NULL) ? NULL : JVM_GetClassLoader(env, caller);
jobject pd = (caller == NULL) ? NULL : JVM_GetProtectionDomain(env, caller);
return Unsafe_DefineClass_impl(env, name, data, offset, length, loader, pd);
}
UNSAFE_END
#define DAC_Args CLS"[B["OBJ
static instanceKlassHandle
Unsafe_DefineAnonymousClass_impl(JNIEnv *env,
jclass host_class, jbyteArray data, jobjectArray cp_patches_jh,
HeapWord* *temp_alloc,
TRAPS) {
if (UsePerfData) {
ClassLoader::unsafe_defineClassCallCounter()->inc();
}
if (data == NULL) {
THROW_0(vmSymbols::java_lang_NullPointerException());
}
jint length = typeArrayOop(JNIHandles::resolve_non_null(data))->length();
jint word_length = (length + sizeof(HeapWord)-1) / sizeof(HeapWord);
HeapWord* body = NEW_C_HEAP_ARRAY(HeapWord, word_length, mtInternal);
if (body == NULL) {
THROW_0(vmSymbols::java_lang_OutOfMemoryError());
}
(*temp_alloc) = body;
{
jbyte* array_base = typeArrayOop(JNIHandles::resolve_non_null(data))->byte_at_addr(0);
Copy::conjoint_words((HeapWord*) array_base, body, word_length);
}
u1* class_bytes = (u1*) body;
int class_bytes_length = (int) length;
if (class_bytes_length < 0) class_bytes_length = 0;
if (class_bytes == NULL
|| host_class == NULL
|| length != class_bytes_length)
THROW_0(vmSymbols::java_lang_IllegalArgumentException());
objArrayHandle cp_patches_h;
if (cp_patches_jh != NULL) {
oop p = JNIHandles::resolve_non_null(cp_patches_jh);
if (!p->is_objArray())
THROW_0(vmSymbols::java_lang_IllegalArgumentException());
cp_patches_h = objArrayHandle(THREAD, (objArrayOop)p);
}
KlassHandle host_klass(THREAD, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(host_class)));
const char* host_source = host_klass->external_name();
Handle host_loader(THREAD, host_klass->class_loader());
Handle host_domain(THREAD, host_klass->protection_domain());
GrowableArray<Handle>* cp_patches = NULL;
if (cp_patches_h.not_null()) {
int alen = cp_patches_h->length();
for (int i = alen-1; i >= 0; i--) {
oop p = cp_patches_h->obj_at(i);
if (p != NULL) {
Handle patch(THREAD, p);
if (cp_patches == NULL)
cp_patches = new GrowableArray<Handle>(i+1, i+1, Handle());
cp_patches->at_put(i, patch);
}
}
}
ClassFileStream st(class_bytes, class_bytes_length, (char*) host_source);
instanceKlassHandle anon_klass;
{
Symbol* no_class_name = NULL;
Klass* anonk = SystemDictionary::parse_stream(no_class_name,
host_loader, host_domain,
&st, host_klass, cp_patches,
CHECK_NULL);
if (anonk == NULL) return NULL;
anon_klass = instanceKlassHandle(THREAD, anonk);
}
return anon_klass;
}
UNSAFE_ENTRY(jclass, Unsafe_DefineAnonymousClass(JNIEnv *env, jobject unsafe, jclass host_class, jbyteArray data, jobjectArray cp_patches_jh))
{
instanceKlassHandle anon_klass;
jobject res_jh = NULL;
UnsafeWrapper("Unsafe_DefineAnonymousClass");
ResourceMark rm(THREAD);
HeapWord* temp_alloc = NULL;
anon_klass = Unsafe_DefineAnonymousClass_impl(env, host_class, data,
cp_patches_jh,
&temp_alloc, THREAD);
if (anon_klass() != NULL)
res_jh = JNIHandles::make_local(env, anon_klass->java_mirror());
if (temp_alloc != NULL) {
FREE_C_HEAP_ARRAY(HeapWord, temp_alloc, mtInternal);
}
if (anon_klass() != NULL) {
anon_klass->class_loader_data()->set_keep_alive(false);
}
return (jclass) res_jh;
}
UNSAFE_END
UNSAFE_ENTRY(void, Unsafe_MonitorEnter(JNIEnv *env, jobject unsafe, jobject jobj))
UnsafeWrapper("Unsafe_MonitorEnter");
{
if (jobj == NULL) {
THROW(vmSymbols::java_lang_NullPointerException());
}
Handle obj(thread, JNIHandles::resolve_non_null(jobj));
ObjectSynchronizer::jni_enter(obj, CHECK);
}
UNSAFE_END
UNSAFE_ENTRY(jboolean, Unsafe_TryMonitorEnter(JNIEnv *env, jobject unsafe, jobject jobj))
UnsafeWrapper("Unsafe_TryMonitorEnter");
{
if (jobj == NULL) {
THROW_(vmSymbols::java_lang_NullPointerException(), JNI_FALSE);
}
Handle obj(thread, JNIHandles::resolve_non_null(jobj));
bool res = ObjectSynchronizer::jni_try_enter(obj, CHECK_0);
return (res ? JNI_TRUE : JNI_FALSE);
}
UNSAFE_END
UNSAFE_ENTRY(void, Unsafe_MonitorExit(JNIEnv *env, jobject unsafe, jobject jobj))
UnsafeWrapper("Unsafe_MonitorExit");
{
if (jobj == NULL) {
THROW(vmSymbols::java_lang_NullPointerException());
}
Handle obj(THREAD, JNIHandles::resolve_non_null(jobj));
ObjectSynchronizer::jni_exit(obj(), CHECK);
}
UNSAFE_END
UNSAFE_ENTRY(void, Unsafe_ThrowException(JNIEnv *env, jobject unsafe, jthrowable thr))
UnsafeWrapper("Unsafe_ThrowException");
{
ThreadToNativeFromVM ttnfv(thread);
env->Throw(thr);
}
UNSAFE_END
UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSwapObject(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jobject e_h, jobject x_h))
UnsafeWrapper("Unsafe_CompareAndSwapObject");
oop x = JNIHandles::resolve(x_h);
oop e = JNIHandles::resolve(e_h);
oop p = JNIHandles::resolve(obj);
HeapWord* addr = (HeapWord *)index_oop_from_field_offset_long(p, offset);
oop res = oopDesc::atomic_compare_exchange_oop(x, addr, e, true);
jboolean success = (res == e);
if (success)
update_barrier_set((void*)addr, x);
return success;
UNSAFE_END
UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSwapInt(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jint e, jint x))
UnsafeWrapper("Unsafe_CompareAndSwapInt");
oop p = JNIHandles::resolve(obj);
jint* addr = (jint *) index_oop_from_field_offset_long(p, offset);
return (jint)(Atomic::cmpxchg(x, addr, e)) == e;
UNSAFE_END
UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSwapLong(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jlong e, jlong x))
UnsafeWrapper("Unsafe_CompareAndSwapLong");
Handle p (THREAD, JNIHandles::resolve(obj));
jlong* addr = (jlong*)(index_oop_from_field_offset_long(p(), offset));
#ifdef SUPPORTS_NATIVE_CX8
return (jlong)(Atomic::cmpxchg(x, addr, e)) == e;
#else
if (VM_Version::supports_cx8())
return (jlong)(Atomic::cmpxchg(x, addr, e)) == e;
else {
jboolean success = false;
MutexLockerEx mu(UnsafeJlong_lock, Mutex::_no_safepoint_check_flag);
jlong val = Atomic::load(addr);
if (val == e) { Atomic::store(x, addr); success = true; }
return success;
}
#endif
UNSAFE_END
static void post_thread_park_event(EventThreadPark* event, const oop obj, jlong timeout_nanos, jlong until_epoch_millis) {
assert(event != NULL, "invariant");
assert(event->should_commit(), "invariant");
event->set_parkedClass((obj != NULL) ? obj->klass() : NULL);
event->set_timeout(timeout_nanos);
event->set_until(until_epoch_millis);
event->set_address((obj != NULL) ? (u8)cast_from_oop<uintptr_t>(obj) : 0);
event->commit();
}
UNSAFE_ENTRY(void, Unsafe_Park(JNIEnv *env, jobject unsafe, jboolean isAbsolute, jlong time))
UnsafeWrapper("Unsafe_Park");
EventThreadPark event;
#ifndef USDT2
HS_DTRACE_PROBE3(hotspot, thread__park__begin, thread->parker(), (int) isAbsolute, time);
#else /* USDT2 */
HOTSPOT_THREAD_PARK_BEGIN(
(uintptr_t) thread->parker(), (int) isAbsolute, time);
#endif /* USDT2 */
JavaThreadParkedState jtps(thread, time != 0);
thread->parker()->park(isAbsolute != 0, time);
#ifndef USDT2
HS_DTRACE_PROBE1(hotspot, thread__park__end, thread->parker());
#else /* USDT2 */
HOTSPOT_THREAD_PARK_END(
(uintptr_t) thread->parker());
#endif /* USDT2 */
if (event.should_commit()) {
const oop obj = thread->current_park_blocker();
if (time == 0) {
post_thread_park_event(&event, obj, min_jlong, min_jlong);
} else {
if (isAbsolute != 0) {
post_thread_park_event(&event, obj, min_jlong, time);
} else {
post_thread_park_event(&event, obj, time, min_jlong);
}
}
}
UNSAFE_END
UNSAFE_ENTRY(void, Unsafe_Unpark(JNIEnv *env, jobject unsafe, jobject jthread))
UnsafeWrapper("Unsafe_Unpark");
Parker* p = NULL;
if (jthread != NULL) {
oop java_thread = JNIHandles::resolve_non_null(jthread);
if (java_thread != NULL) {
jlong lp = java_lang_Thread::park_event(java_thread);
if (lp != 0) {
p = (Parker*)addr_from_java(lp);
} else {
MutexLocker mu(Threads_lock);
java_thread = JNIHandles::resolve_non_null(jthread);
if (java_thread != NULL) {
JavaThread* thr = java_lang_Thread::thread(java_thread);
if (thr != NULL) {
p = thr->parker();
if (p != NULL) { // Bind to Java thread for next time.
java_lang_Thread::set_park_event(java_thread, addr_to_java(p));
}
}
}
}
}
}
if (p != NULL) {
#ifndef USDT2
HS_DTRACE_PROBE1(hotspot, thread__unpark, p);
#else /* USDT2 */
HOTSPOT_THREAD_UNPARK(
(uintptr_t) p);
#endif /* USDT2 */
p->unpark();
}
UNSAFE_END
UNSAFE_ENTRY(jint, Unsafe_Loadavg(JNIEnv *env, jobject unsafe, jdoubleArray loadavg, jint nelem))
UnsafeWrapper("Unsafe_Loadavg");
const int max_nelem = 3;
double la[max_nelem];
jint ret;
typeArrayOop a = typeArrayOop(JNIHandles::resolve_non_null(loadavg));
assert(a->is_typeArray(), "must be type array");
if (nelem < 0 || nelem > max_nelem || a->length() < nelem) {
ThreadToNativeFromVM ttnfv(thread);
throw_new(env, "ArrayIndexOutOfBoundsException");
return -1;
}
ret = os::loadavg(la, nelem);
if (ret == -1) return -1;
assert(ret >= 0 && ret <= max_nelem, "Unexpected loadavg return value");
switch(ret) {
case 3: a->double_at_put(2, (jdouble)la[2]); // fall through
case 2: a->double_at_put(1, (jdouble)la[1]); // fall through
case 1: a->double_at_put(0, (jdouble)la[0]); break;
}
return ret;
UNSAFE_END
UNSAFE_ENTRY(void, Unsafe_PrefetchRead(JNIEnv* env, jclass ignored, jobject obj, jlong offset))
UnsafeWrapper("Unsafe_PrefetchRead");
oop p = JNIHandles::resolve(obj);
void* addr = index_oop_from_field_offset_long(p, 0);
Prefetch::read(addr, (intx)offset);
UNSAFE_END
UNSAFE_ENTRY(void, Unsafe_PrefetchWrite(JNIEnv* env, jclass ignored, jobject obj, jlong offset))
UnsafeWrapper("Unsafe_PrefetchWrite");
oop p = JNIHandles::resolve(obj);
void* addr = index_oop_from_field_offset_long(p, 0);
Prefetch::write(addr, (intx)offset);
UNSAFE_END
#define ADR "J"
#define LANG "Ljava/lang/"
#define OBJ LANG "Object;"
#define CLS LANG "Class;"
#define CTR LANG "reflect/Constructor;"
#define FLD LANG "reflect/Field;"
#define MTH LANG "reflect/Method;"
#define THR LANG "Throwable;"
#define DC0_Args LANG "String;[BII"
#define DC_Args DC0_Args LANG "ClassLoader;" "Ljava/security/ProtectionDomain;"
#define CC (char*) /*cast a literal from (const char*)*/
#define FN_PTR(f) CAST_FROM_FN_PTR(void*, &f)
#define DECLARE_GETSETOOP_140(Boolean, Z) \
{CC "get" #Boolean, CC "(" OBJ "I)" #Z, FN_PTR(Unsafe_Get##Boolean##140)}, \
{CC "put" #Boolean, CC "(" OBJ "I" #Z ")V", FN_PTR(Unsafe_Set##Boolean##140)}
#define DECLARE_GETSETOOP_141(Boolean, Z) \
{CC "get" #Boolean, CC "(" OBJ "J)" #Z, FN_PTR(Unsafe_Get##Boolean)}, \
{CC "put" #Boolean, CC "(" OBJ "J" #Z ")V", FN_PTR(Unsafe_Set##Boolean)}
#define DECLARE_GETSETOOP(Boolean, Z) \
{CC "get" #Boolean, CC "(" OBJ "J)" #Z, FN_PTR(Unsafe_Get##Boolean)}, \
{CC "put" #Boolean, CC "(" OBJ "J" #Z ")V", FN_PTR(Unsafe_Set##Boolean)}, \
{CC "get" #Boolean "Volatile", CC "(" OBJ "J)" #Z, FN_PTR(Unsafe_Get##Boolean##Volatile)}, \
{CC "put" #Boolean "Volatile", CC "(" OBJ "J" #Z ")V", FN_PTR(Unsafe_Set##Boolean##Volatile)}
#define DECLARE_GETSETNATIVE(Byte, B) \
{CC "get" #Byte, CC "(" ADR ")" #B, FN_PTR(Unsafe_GetNative##Byte)}, \
{CC "put" #Byte, CC "(" ADR#B ")V", FN_PTR(Unsafe_SetNative##Byte)}
static JNINativeMethod methods_140[] = {
{CC "getObject", CC "(" OBJ "I)" OBJ "", FN_PTR(Unsafe_GetObject140)},
{CC "putObject", CC "(" OBJ "I" OBJ ")V", FN_PTR(Unsafe_SetObject140)},
DECLARE_GETSETOOP_140(Boolean, Z),
DECLARE_GETSETOOP_140(Byte, B),
DECLARE_GETSETOOP_140(Short, S),
DECLARE_GETSETOOP_140(Char, C),
DECLARE_GETSETOOP_140(Int, I),
DECLARE_GETSETOOP_140(Long, J),
DECLARE_GETSETOOP_140(Float, F),
DECLARE_GETSETOOP_140(Double, D),
DECLARE_GETSETNATIVE(Byte, B),
DECLARE_GETSETNATIVE(Short, S),
DECLARE_GETSETNATIVE(Char, C),
DECLARE_GETSETNATIVE(Int, I),
DECLARE_GETSETNATIVE(Long, J),
DECLARE_GETSETNATIVE(Float, F),
DECLARE_GETSETNATIVE(Double, D),
{CC "getAddress", CC "(" ADR ")" ADR, FN_PTR(Unsafe_GetNativeAddress)},
{CC "putAddress", CC "(" ADR "" ADR ")V", FN_PTR(Unsafe_SetNativeAddress)},
{CC "allocateMemory", CC "(J)" ADR, FN_PTR(Unsafe_AllocateMemory)},
{CC "reallocateMemory", CC "(" ADR "J)" ADR, FN_PTR(Unsafe_ReallocateMemory)},
{CC "freeMemory", CC "(" ADR ")V", FN_PTR(Unsafe_FreeMemory)},
{CC "fieldOffset", CC "(" FLD ")I", FN_PTR(Unsafe_FieldOffset)},
{CC "staticFieldBase", CC "(" CLS ")" OBJ, FN_PTR(Unsafe_StaticFieldBaseFromClass)},
{CC "ensureClassInitialized",CC "(" CLS ")V", FN_PTR(Unsafe_EnsureClassInitialized)},
{CC "arrayBaseOffset", CC "(" CLS ")I", FN_PTR(Unsafe_ArrayBaseOffset)},
{CC "arrayIndexScale", CC "(" CLS ")I", FN_PTR(Unsafe_ArrayIndexScale)},
{CC "addressSize", CC "()I", FN_PTR(Unsafe_AddressSize)},
{CC "pageSize", CC "()I", FN_PTR(Unsafe_PageSize)},
{CC "defineClass", CC "(" DC0_Args ")" CLS, FN_PTR(Unsafe_DefineClass0)},
{CC "defineClass", CC "(" DC_Args ")" CLS, FN_PTR(Unsafe_DefineClass)},
{CC "allocateInstance", CC "(" CLS ")" OBJ, FN_PTR(Unsafe_AllocateInstance)},
{CC "monitorEnter", CC "(" OBJ ")V", FN_PTR(Unsafe_MonitorEnter)},
{CC "monitorExit", CC "(" OBJ ")V", FN_PTR(Unsafe_MonitorExit)},
{CC "throwException", CC "(" THR ")V", FN_PTR(Unsafe_ThrowException)}
};
static JNINativeMethod methods_141[] = {
{CC "getObject", CC "(" OBJ "J)" OBJ "", FN_PTR(Unsafe_GetObject)},
{CC "putObject", CC "(" OBJ "J" OBJ ")V", FN_PTR(Unsafe_SetObject)},
DECLARE_GETSETOOP_141(Boolean, Z),
DECLARE_GETSETOOP_141(Byte, B),
DECLARE_GETSETOOP_141(Short, S),
DECLARE_GETSETOOP_141(Char, C),
DECLARE_GETSETOOP_141(Int, I),
DECLARE_GETSETOOP_141(Long, J),
DECLARE_GETSETOOP_141(Float, F),
DECLARE_GETSETOOP_141(Double, D),
DECLARE_GETSETNATIVE(Byte, B),
DECLARE_GETSETNATIVE(Short, S),
DECLARE_GETSETNATIVE(Char, C),
DECLARE_GETSETNATIVE(Int, I),
DECLARE_GETSETNATIVE(Long, J),
DECLARE_GETSETNATIVE(Float, F),
DECLARE_GETSETNATIVE(Double, D),
{CC "getAddress", CC "(" ADR ")" ADR, FN_PTR(Unsafe_GetNativeAddress)},
{CC "putAddress", CC "(" ADR "" ADR ")V", FN_PTR(Unsafe_SetNativeAddress)},
{CC "allocateMemory", CC "(J)" ADR, FN_PTR(Unsafe_AllocateMemory)},
{CC "reallocateMemory", CC "(" ADR "J)" ADR, FN_PTR(Unsafe_ReallocateMemory)},
{CC "freeMemory", CC "(" ADR ")V", FN_PTR(Unsafe_FreeMemory)},
{CC "objectFieldOffset", CC "(" FLD ")J", FN_PTR(Unsafe_ObjectFieldOffset)},
{CC "staticFieldOffset", CC "(" FLD ")J", FN_PTR(Unsafe_StaticFieldOffset)},
{CC "staticFieldBase", CC "(" FLD ")" OBJ, FN_PTR(Unsafe_StaticFieldBaseFromField)},
{CC "ensureClassInitialized",CC "(" CLS ")V", FN_PTR(Unsafe_EnsureClassInitialized)},
{CC "arrayBaseOffset", CC "(" CLS ")I", FN_PTR(Unsafe_ArrayBaseOffset)},
{CC "arrayIndexScale", CC "(" CLS ")I", FN_PTR(Unsafe_ArrayIndexScale)},
{CC "addressSize", CC "()I", FN_PTR(Unsafe_AddressSize)},
{CC "pageSize", CC "()I", FN_PTR(Unsafe_PageSize)},
{CC "defineClass", CC "(" DC0_Args ")" CLS, FN_PTR(Unsafe_DefineClass0)},
{CC "defineClass", CC "(" DC_Args ")" CLS, FN_PTR(Unsafe_DefineClass)},
{CC "allocateInstance", CC "(" CLS ")" OBJ, FN_PTR(Unsafe_AllocateInstance)},
{CC "monitorEnter", CC "(" OBJ ")V", FN_PTR(Unsafe_MonitorEnter)},
{CC "monitorExit", CC "(" OBJ ")V", FN_PTR(Unsafe_MonitorExit)},
{CC "throwException", CC "(" THR ")V", FN_PTR(Unsafe_ThrowException)}
};
static JNINativeMethod methods_15[] = {
{CC "getObject", CC "(" OBJ "J)" OBJ "", FN_PTR(Unsafe_GetObject)},
{CC "putObject", CC "(" OBJ "J" OBJ ")V", FN_PTR(Unsafe_SetObject)},
{CC "getObjectVolatile",CC "(" OBJ "J)" OBJ "", FN_PTR(Unsafe_GetObjectVolatile)},
{CC "putObjectVolatile",CC "(" OBJ "J" OBJ ")V", FN_PTR(Unsafe_SetObjectVolatile)},
DECLARE_GETSETOOP(Boolean, Z),
DECLARE_GETSETOOP(Byte, B),
DECLARE_GETSETOOP(Short, S),
DECLARE_GETSETOOP(Char, C),
DECLARE_GETSETOOP(Int, I),
DECLARE_GETSETOOP(Long, J),
DECLARE_GETSETOOP(Float, F),
DECLARE_GETSETOOP(Double, D),
DECLARE_GETSETNATIVE(Byte, B),
DECLARE_GETSETNATIVE(Short, S),
DECLARE_GETSETNATIVE(Char, C),
DECLARE_GETSETNATIVE(Int, I),
DECLARE_GETSETNATIVE(Long, J),
DECLARE_GETSETNATIVE(Float, F),
DECLARE_GETSETNATIVE(Double, D),
{CC "getAddress", CC "(" ADR ")" ADR, FN_PTR(Unsafe_GetNativeAddress)},
{CC "putAddress", CC "(" ADR "" ADR ")V", FN_PTR(Unsafe_SetNativeAddress)},
{CC "allocateMemory", CC "(J)" ADR, FN_PTR(Unsafe_AllocateMemory)},
{CC "reallocateMemory", CC "(" ADR "J)" ADR, FN_PTR(Unsafe_ReallocateMemory)},
{CC "freeMemory", CC "(" ADR ")V", FN_PTR(Unsafe_FreeMemory)},
{CC "objectFieldOffset", CC "(" FLD ")J", FN_PTR(Unsafe_ObjectFieldOffset)},
{CC "staticFieldOffset", CC "(" FLD ")J", FN_PTR(Unsafe_StaticFieldOffset)},
{CC "staticFieldBase", CC "(" FLD ")" OBJ, FN_PTR(Unsafe_StaticFieldBaseFromField)},
{CC "ensureClassInitialized",CC "(" CLS ")V", FN_PTR(Unsafe_EnsureClassInitialized)},
{CC "arrayBaseOffset", CC "(" CLS ")I", FN_PTR(Unsafe_ArrayBaseOffset)},
{CC "arrayIndexScale", CC "(" CLS ")I", FN_PTR(Unsafe_ArrayIndexScale)},
{CC "addressSize", CC "()I", FN_PTR(Unsafe_AddressSize)},
{CC "pageSize", CC "()I", FN_PTR(Unsafe_PageSize)},
{CC "defineClass", CC "(" DC0_Args ")" CLS, FN_PTR(Unsafe_DefineClass0)},
{CC "defineClass", CC "(" DC_Args ")" CLS, FN_PTR(Unsafe_DefineClass)},
{CC "allocateInstance", CC "(" CLS ")" OBJ, FN_PTR(Unsafe_AllocateInstance)},
{CC "monitorEnter", CC "(" OBJ ")V", FN_PTR(Unsafe_MonitorEnter)},
{CC "monitorExit", CC "(" OBJ ")V", FN_PTR(Unsafe_MonitorExit)},
{CC "throwException", CC "(" THR ")V", FN_PTR(Unsafe_ThrowException)},
{CC "compareAndSwapObject", CC "(" OBJ "J" OBJ "" OBJ ")Z", FN_PTR(Unsafe_CompareAndSwapObject)},
{CC "compareAndSwapInt", CC "(" OBJ "J""I""I"")Z", FN_PTR(Unsafe_CompareAndSwapInt)},
{CC "compareAndSwapLong", CC "(" OBJ "J""J""J"")Z", FN_PTR(Unsafe_CompareAndSwapLong)},
{CC "park", CC "(ZJ)V", FN_PTR(Unsafe_Park)},
{CC "unpark", CC "(" OBJ ")V", FN_PTR(Unsafe_Unpark)}
};
static JNINativeMethod methods_16[] = {
{CC "getObject", CC "(" OBJ "J)" OBJ "", FN_PTR(Unsafe_GetObject)},
{CC "putObject", CC "(" OBJ "J" OBJ ")V", FN_PTR(Unsafe_SetObject)},
{CC "getObjectVolatile",CC "(" OBJ "J)" OBJ "", FN_PTR(Unsafe_GetObjectVolatile)},
{CC "putObjectVolatile",CC "(" OBJ "J" OBJ ")V", FN_PTR(Unsafe_SetObjectVolatile)},
DECLARE_GETSETOOP(Boolean, Z),
DECLARE_GETSETOOP(Byte, B),
DECLARE_GETSETOOP(Short, S),
DECLARE_GETSETOOP(Char, C),
DECLARE_GETSETOOP(Int, I),
DECLARE_GETSETOOP(Long, J),
DECLARE_GETSETOOP(Float, F),
DECLARE_GETSETOOP(Double, D),
DECLARE_GETSETNATIVE(Byte, B),
DECLARE_GETSETNATIVE(Short, S),
DECLARE_GETSETNATIVE(Char, C),
DECLARE_GETSETNATIVE(Int, I),
DECLARE_GETSETNATIVE(Long, J),
DECLARE_GETSETNATIVE(Float, F),
DECLARE_GETSETNATIVE(Double, D),
{CC "getAddress", CC "(" ADR ")" ADR, FN_PTR(Unsafe_GetNativeAddress)},
{CC "putAddress", CC "(" ADR "" ADR ")V", FN_PTR(Unsafe_SetNativeAddress)},
{CC "allocateMemory", CC "(J)" ADR, FN_PTR(Unsafe_AllocateMemory)},
{CC "reallocateMemory", CC "(" ADR "J)" ADR, FN_PTR(Unsafe_ReallocateMemory)},
{CC "freeMemory", CC "(" ADR ")V", FN_PTR(Unsafe_FreeMemory)},
{CC "objectFieldOffset", CC "(" FLD ")J", FN_PTR(Unsafe_ObjectFieldOffset)},
{CC "staticFieldOffset", CC "(" FLD ")J", FN_PTR(Unsafe_StaticFieldOffset)},
{CC "staticFieldBase", CC "(" FLD ")" OBJ, FN_PTR(Unsafe_StaticFieldBaseFromField)},
{CC "ensureClassInitialized",CC "(" CLS ")V", FN_PTR(Unsafe_EnsureClassInitialized)},
{CC "arrayBaseOffset", CC "(" CLS ")I", FN_PTR(Unsafe_ArrayBaseOffset)},
{CC "arrayIndexScale", CC "(" CLS ")I", FN_PTR(Unsafe_ArrayIndexScale)},
{CC "addressSize", CC "()I", FN_PTR(Unsafe_AddressSize)},
{CC "pageSize", CC "()I", FN_PTR(Unsafe_PageSize)},
{CC "defineClass", CC "(" DC0_Args ")" CLS, FN_PTR(Unsafe_DefineClass0)},
{CC "defineClass", CC "(" DC_Args ")" CLS, FN_PTR(Unsafe_DefineClass)},
{CC "allocateInstance", CC "(" CLS ")" OBJ, FN_PTR(Unsafe_AllocateInstance)},
{CC "monitorEnter", CC "(" OBJ ")V", FN_PTR(Unsafe_MonitorEnter)},
{CC "monitorExit", CC "(" OBJ ")V", FN_PTR(Unsafe_MonitorExit)},
{CC "tryMonitorEnter", CC "(" OBJ ")Z", FN_PTR(Unsafe_TryMonitorEnter)},
{CC "throwException", CC "(" THR ")V", FN_PTR(Unsafe_ThrowException)},
{CC "compareAndSwapObject", CC "(" OBJ "J" OBJ "" OBJ ")Z", FN_PTR(Unsafe_CompareAndSwapObject)},
{CC "compareAndSwapInt", CC "(" OBJ "J""I""I"")Z", FN_PTR(Unsafe_CompareAndSwapInt)},
{CC "compareAndSwapLong", CC "(" OBJ "J""J""J"")Z", FN_PTR(Unsafe_CompareAndSwapLong)},
{CC "putOrderedObject", CC "(" OBJ "J" OBJ ")V", FN_PTR(Unsafe_SetOrderedObject)},
{CC "putOrderedInt", CC "(" OBJ "JI)V", FN_PTR(Unsafe_SetOrderedInt)},
{CC "putOrderedLong", CC "(" OBJ "JJ)V", FN_PTR(Unsafe_SetOrderedLong)},
{CC "park", CC "(ZJ)V", FN_PTR(Unsafe_Park)},
{CC "unpark", CC "(" OBJ ")V", FN_PTR(Unsafe_Unpark)}
};
static JNINativeMethod methods_18[] = {
{CC "getObject", CC "(" OBJ "J)" OBJ "", FN_PTR(Unsafe_GetObject)},
{CC "putObject", CC "(" OBJ "J" OBJ ")V", FN_PTR(Unsafe_SetObject)},
{CC "getObjectVolatile",CC "(" OBJ "J)" OBJ "", FN_PTR(Unsafe_GetObjectVolatile)},
{CC "putObjectVolatile",CC "(" OBJ "J" OBJ ")V", FN_PTR(Unsafe_SetObjectVolatile)},
DECLARE_GETSETOOP(Boolean, Z),
DECLARE_GETSETOOP(Byte, B),
DECLARE_GETSETOOP(Short, S),
DECLARE_GETSETOOP(Char, C),
DECLARE_GETSETOOP(Int, I),
DECLARE_GETSETOOP(Long, J),
DECLARE_GETSETOOP(Float, F),
DECLARE_GETSETOOP(Double, D),
DECLARE_GETSETNATIVE(Byte, B),
DECLARE_GETSETNATIVE(Short, S),
DECLARE_GETSETNATIVE(Char, C),
DECLARE_GETSETNATIVE(Int, I),
DECLARE_GETSETNATIVE(Long, J),
DECLARE_GETSETNATIVE(Float, F),
DECLARE_GETSETNATIVE(Double, D),
{CC "getAddress", CC "(" ADR ")" ADR, FN_PTR(Unsafe_GetNativeAddress)},
{CC "putAddress", CC "(" ADR "" ADR ")V", FN_PTR(Unsafe_SetNativeAddress)},
{CC "allocateMemory", CC "(J)" ADR, FN_PTR(Unsafe_AllocateMemory)},
{CC "reallocateMemory", CC "(" ADR "J)" ADR, FN_PTR(Unsafe_ReallocateMemory)},
{CC "freeMemory", CC "(" ADR ")V", FN_PTR(Unsafe_FreeMemory)},
{CC "objectFieldOffset", CC "(" FLD ")J", FN_PTR(Unsafe_ObjectFieldOffset)},
{CC "staticFieldOffset", CC "(" FLD ")J", FN_PTR(Unsafe_StaticFieldOffset)},
{CC "staticFieldBase", CC "(" FLD ")" OBJ, FN_PTR(Unsafe_StaticFieldBaseFromField)},
{CC "ensureClassInitialized",CC "(" CLS ")V", FN_PTR(Unsafe_EnsureClassInitialized)},
{CC "arrayBaseOffset", CC "(" CLS ")I", FN_PTR(Unsafe_ArrayBaseOffset)},
{CC "arrayIndexScale", CC "(" CLS ")I", FN_PTR(Unsafe_ArrayIndexScale)},
{CC "addressSize", CC "()I", FN_PTR(Unsafe_AddressSize)},
{CC "pageSize", CC "()I", FN_PTR(Unsafe_PageSize)},
{CC "defineClass", CC "(" DC_Args ")" CLS, FN_PTR(Unsafe_DefineClass)},
{CC "allocateInstance", CC "(" CLS ")" OBJ, FN_PTR(Unsafe_AllocateInstance)},
{CC "monitorEnter", CC "(" OBJ ")V", FN_PTR(Unsafe_MonitorEnter)},
{CC "monitorExit", CC "(" OBJ ")V", FN_PTR(Unsafe_MonitorExit)},
{CC "tryMonitorEnter", CC "(" OBJ ")Z", FN_PTR(Unsafe_TryMonitorEnter)},
{CC "throwException", CC "(" THR ")V", FN_PTR(Unsafe_ThrowException)},
{CC "compareAndSwapObject", CC "(" OBJ "J" OBJ "" OBJ ")Z", FN_PTR(Unsafe_CompareAndSwapObject)},
{CC "compareAndSwapInt", CC "(" OBJ "J""I""I"")Z", FN_PTR(Unsafe_CompareAndSwapInt)},
{CC "compareAndSwapLong", CC "(" OBJ "J""J""J"")Z", FN_PTR(Unsafe_CompareAndSwapLong)},
{CC "putOrderedObject", CC "(" OBJ "J" OBJ ")V", FN_PTR(Unsafe_SetOrderedObject)},
{CC "putOrderedInt", CC "(" OBJ "JI)V", FN_PTR(Unsafe_SetOrderedInt)},
{CC "putOrderedLong", CC "(" OBJ "JJ)V", FN_PTR(Unsafe_SetOrderedLong)},
{CC "park", CC "(ZJ)V", FN_PTR(Unsafe_Park)},
{CC "unpark", CC "(" OBJ ")V", FN_PTR(Unsafe_Unpark)}
};
JNINativeMethod loadavg_method[] = {
{CC "getLoadAverage", CC "([DI)I", FN_PTR(Unsafe_Loadavg)}
};
JNINativeMethod prefetch_methods[] = {
{CC "prefetchRead", CC "(" OBJ "J)V", FN_PTR(Unsafe_PrefetchRead)},
{CC "prefetchWrite", CC "(" OBJ "J)V", FN_PTR(Unsafe_PrefetchWrite)},
{CC "prefetchReadStatic", CC "(" OBJ "J)V", FN_PTR(Unsafe_PrefetchRead)},
{CC "prefetchWriteStatic",CC "(" OBJ "J)V", FN_PTR(Unsafe_PrefetchWrite)}
};
JNINativeMethod memcopy_methods_17[] = {
{CC "copyMemory", CC "(" OBJ "J" OBJ "JJ)V", FN_PTR(Unsafe_CopyMemory2)},
{CC "setMemory", CC "(" OBJ "JJB)V", FN_PTR(Unsafe_SetMemory2)}
};
JNINativeMethod memcopy_methods_15[] = {
{CC "setMemory", CC "(" ADR "JB)V", FN_PTR(Unsafe_SetMemory)},
{CC "copyMemory", CC "(" ADR ADR "J)V", FN_PTR(Unsafe_CopyMemory)}
};
JNINativeMethod anonk_methods[] = {
{CC "defineAnonymousClass", CC "(" DAC_Args ")" CLS, FN_PTR(Unsafe_DefineAnonymousClass)},
};
JNINativeMethod lform_methods[] = {
{CC "shouldBeInitialized",CC "(" CLS ")Z", FN_PTR(Unsafe_ShouldBeInitialized)},
};
JNINativeMethod fence_methods[] = {
{CC "loadFence", CC "()V", FN_PTR(Unsafe_LoadFence)},
{CC "storeFence", CC "()V", FN_PTR(Unsafe_StoreFence)},
{CC "fullFence", CC "()V", FN_PTR(Unsafe_FullFence)},
};
#undef CC
#undef FN_PTR
#undef ADR
#undef LANG
#undef OBJ
#undef CLS
#undef CTR
#undef FLD
#undef MTH
#undef THR
#undef DC0_Args
#undef DC_Args
#undef DECLARE_GETSETOOP
#undef DECLARE_GETSETNATIVE
static bool register_natives(const char* message, JNIEnv* env, jclass clazz, const JNINativeMethod* methods, jint nMethods) {
int status = env->RegisterNatives(clazz, methods, nMethods);
if (status < 0 || env->ExceptionOccurred()) {
if (PrintMiscellaneous && (Verbose || WizardMode)) {
tty->print_cr("Unsafe: failed registering %s", message);
}
env->ExceptionClear();
return false;
} else {
if (PrintMiscellaneous && (Verbose || WizardMode)) {
tty->print_cr("Unsafe: successfully registered %s", message);
}
return true;
}
}
JVM_ENTRY(void, JVM_RegisterUnsafeMethods(JNIEnv *env, jclass unsafecls))
UnsafeWrapper("JVM_RegisterUnsafeMethods");
{
ThreadToNativeFromVM ttnfv(thread);
{
bool success = false;
if (!success) {
success = register_natives("1.6 methods", env, unsafecls, methods_16, sizeof(methods_16)/sizeof(JNINativeMethod));
}
if (!success) {
success = register_natives("1.8 methods", env, unsafecls, methods_18, sizeof(methods_18)/sizeof(JNINativeMethod));
}
if (!success) {
success = register_natives("1.5 methods", env, unsafecls, methods_15, sizeof(methods_15)/sizeof(JNINativeMethod));
}
if (!success) {
success = register_natives("1.4.1 methods", env, unsafecls, methods_141, sizeof(methods_141)/sizeof(JNINativeMethod));
}
if (!success) {
success = register_natives("1.4.0 methods", env, unsafecls, methods_140, sizeof(methods_140)/sizeof(JNINativeMethod));
}
guarantee(success, "register unsafe natives");
}
register_natives("1.6 loadavg method", env, unsafecls, loadavg_method, sizeof(loadavg_method)/sizeof(JNINativeMethod));
register_natives("1.6 prefetch methods", env, unsafecls, prefetch_methods, sizeof(prefetch_methods)/sizeof(JNINativeMethod));
{
bool success = false;
if (!success) {
success = register_natives("1.7 memory copy methods", env, unsafecls, memcopy_methods_17, sizeof(memcopy_methods_17)/sizeof(JNINativeMethod));
}
if (!success) {
success = register_natives("1.5 memory copy methods", env, unsafecls, memcopy_methods_15, sizeof(memcopy_methods_15)/sizeof(JNINativeMethod));
}
}
if (EnableInvokeDynamic) {
register_natives("1.7 define anonymous class method", env, unsafecls, anonk_methods, sizeof(anonk_methods)/sizeof(JNINativeMethod));
}
if (EnableInvokeDynamic) {
register_natives("1.7 LambdaForm support", env, unsafecls, lform_methods, sizeof(lform_methods)/sizeof(JNINativeMethod));
}
register_natives("1.8 fence methods", env, unsafecls, fence_methods, sizeof(fence_methods)/sizeof(JNINativeMethod));
}
JVM_END
C:\hotspot-69087d08d473\src\share\vm/prims/wbtestmethods/parserTests.cpp
#include "precompiled.hpp"
#include "classfile/symbolTable.hpp"
#include "prims/jni.h"
#include "prims/whitebox.hpp"
#include "prims/wbtestmethods/parserTests.hpp"
#include "runtime/interfaceSupport.hpp"
#include "memory/oopFactory.hpp"
#include "services/diagnosticArgument.hpp"
#include "services/diagnosticFramework.hpp"
#define VALUE_MAXLEN 256
static const char* lookup_diagnosticArgumentEnum(const char* field_name, oop object) {
Thread* THREAD = Thread::current();
const char* enum_sig = "Lsun/hotspot/parser/DiagnosticCommand$DiagnosticArgumentType;";
TempNewSymbol enumSigSymbol = SymbolTable::lookup(enum_sig, (int) strlen(enum_sig), THREAD);
int offset = WhiteBox::offset_for_field(field_name, object, enumSigSymbol);
oop enumOop = object->obj_field(offset);
const char* ret = WhiteBox::lookup_jstring("name", enumOop);
return ret;
}
static void fill_in_parser(DCmdParser* parser, oop argument)
{
const char* name = WhiteBox::lookup_jstring("name", argument);
const char* desc = WhiteBox::lookup_jstring("desc", argument);
const char* default_value = WhiteBox::lookup_jstring("defaultValue", argument);
bool mandatory = WhiteBox::lookup_bool("mandatory", argument);
const char* type = lookup_diagnosticArgumentEnum("type", argument);
if (strcmp(type, "STRING") == 0) {
DCmdArgument<char*>* argument = new DCmdArgument<char*>(
name, desc,
"STRING", mandatory, default_value);
parser->add_dcmd_option(argument);
} else if (strcmp(type, "NANOTIME") == 0) {
DCmdArgument<NanoTimeArgument>* argument = new DCmdArgument<NanoTimeArgument>(
name, desc,
"NANOTIME", mandatory, default_value);
parser->add_dcmd_option(argument);
} else if (strcmp(type, "JLONG") == 0) {
DCmdArgument<jlong>* argument = new DCmdArgument<jlong>(
name, desc,
"JLONG", mandatory, default_value);
parser->add_dcmd_option(argument);
} else if (strcmp(type, "BOOLEAN") == 0) {
DCmdArgument<bool>* argument = new DCmdArgument<bool>(
name, desc,
"BOOLEAN", mandatory, default_value);
parser->add_dcmd_option(argument);
} else if (strcmp(type, "MEMORYSIZE") == 0) {
DCmdArgument<MemorySizeArgument>* argument = new DCmdArgument<MemorySizeArgument>(
name, desc,
"MEMORY SIZE", mandatory, default_value);
parser->add_dcmd_option(argument);
} else if (strcmp(type, "STRINGARRAY") == 0) {
DCmdArgument<StringArrayArgument*>* argument = new DCmdArgument<StringArrayArgument*>(
name, desc,
"STRING SET", mandatory);
parser->add_dcmd_option(argument);
}
}
WB_ENTRY(jobjectArray, WB_ParseCommandLine(JNIEnv* env, jobject o, jstring j_cmdline, jobjectArray arguments))
ResourceMark rm;
DCmdParser parser;
const char* c_cmdline = java_lang_String::as_utf8_string(JNIHandles::resolve(j_cmdline));
objArrayOop argumentArray = objArrayOop(JNIHandles::resolve_non_null(arguments));
objArrayHandle argumentArray_ah(THREAD, argumentArray);
int length = argumentArray_ah->length();
for (int i = 0; i < length; i++) {
oop argument_oop = argumentArray_ah->obj_at(i);
fill_in_parser(&parser, argument_oop);
}
CmdLine cmdline(c_cmdline, strlen(c_cmdline), true);
parser.parse(&cmdline,',',CHECK_NULL);
Klass* k = SystemDictionary::Object_klass();
objArrayOop returnvalue_array = oopFactory::new_objArray(k, parser.num_arguments() * 2, CHECK_NULL);
objArrayHandle returnvalue_array_ah(THREAD, returnvalue_array);
GrowableArray<const char *>*parsedArgNames = parser.argument_name_array();
for (int i = 0; i < parser.num_arguments(); i++) {
oop parsedName = java_lang_String::create_oop_from_str(parsedArgNames->at(i), CHECK_NULL);
returnvalue_array_ah->obj_at_put(i*2, parsedName);
GenDCmdArgument* arg = parser.lookup_dcmd_option(parsedArgNames->at(i), strlen(parsedArgNames->at(i)));
char buf[VALUE_MAXLEN];
arg->value_as_str(buf, sizeof(buf));
oop parsedValue = java_lang_String::create_oop_from_str(buf, CHECK_NULL);
returnvalue_array_ah->obj_at_put(i*2+1, parsedValue);
}
return (jobjectArray) JNIHandles::make_local(returnvalue_array_ah());
WB_END
C:\hotspot-69087d08d473\src\share\vm/prims/wbtestmethods/parserTests.hpp
#ifndef SHARE_VM_PRIMS_WBTESTMETHODS_PARSERTESTS_H
#define SHARE_VM_PRIMS_WBTESTMETHODS_PARSERTESTS_H
#include "prims/jni.h"
#include "prims/whitebox.hpp"
WB_METHOD_DECLARE(jobjectArray) WB_ParseCommandLine(JNIEnv* env, jobject o, jstring args, jobjectArray arguments);
#endif //SHARE_VM_PRIMS_WBTESTMETHODS_PARSERTESTS_H
C:\hotspot-69087d08d473\src\share\vm/prims/whitebox.cpp
#include "precompiled.hpp"
#include "memory/metadataFactory.hpp"
#include "memory/metaspaceShared.hpp"
#include "memory/iterator.hpp"
#include "memory/universe.hpp"
#include "oops/oop.inline.hpp"
#include "classfile/symbolTable.hpp"
#include "classfile/classLoaderData.hpp"
#include "prims/whitebox.hpp"
#include "prims/wbtestmethods/parserTests.hpp"
#include "runtime/arguments.hpp"
#include "runtime/interfaceSupport.hpp"
#include "runtime/os.hpp"
#include "utilities/array.hpp"
#include "utilities/align.hpp"
#include "utilities/debug.hpp"
#include "utilities/macros.hpp"
#include "utilities/exceptions.hpp"
#if INCLUDE_ALL_GCS
#include "gc_implementation/parallelScavenge/parallelScavengeHeap.inline.hpp"
#include "gc_implementation/g1/concurrentMark.hpp"
#include "gc_implementation/g1/concurrentMarkThread.hpp"
#include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
#include "gc_implementation/g1/heapRegionRemSet.hpp"
#endif // INCLUDE_ALL_GCS
#if INCLUDE_NMT
#include "services/mallocSiteTable.hpp"
#include "services/memTracker.hpp"
#include "utilities/nativeCallStack.hpp"
#endif // INCLUDE_NMT
#include "compiler/compileBroker.hpp"
#include "jvmtifiles/jvmtiEnv.hpp"
#include "runtime/compilationPolicy.hpp"
PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
#define SIZE_T_MAX_VALUE ((size_t) -1)
bool WhiteBox::_used = false;
WB_ENTRY(jlong, WB_GetObjectAddress(JNIEnv* env, jobject o, jobject obj))
return (jlong)(void*)JNIHandles::resolve(obj);
WB_END
WB_ENTRY(jint, WB_GetHeapOopSize(JNIEnv* env, jobject o))
return heapOopSize;
WB_END
WB_ENTRY(jint, WB_GetVMPageSize(JNIEnv* env, jobject o))
return os::vm_page_size();
WB_END
WB_ENTRY(jlong, WB_GetVMLargePageSize(JNIEnv* env, jobject o))
return os::large_page_size();
WB_END
class WBIsKlassAliveClosure : public KlassClosure {
Symbol* _name;
bool _found;
public:
WBIsKlassAliveClosure(Symbol* name) : _name(name), _found(false) {}
void do_klass(Klass* k) {
if (_found) return;
Symbol* ksym = k->name();
if (ksym->fast_compare(_name) == 0) {
_found = true;
}
}
bool found() const {
return _found;
}
};
WB_ENTRY(jboolean, WB_IsClassAlive(JNIEnv* env, jobject target, jstring name))
Handle h_name = JNIHandles::resolve(name);
if (h_name.is_null()) return false;
Symbol* sym = java_lang_String::as_symbol(h_name, CHECK_false);
TempNewSymbol tsym(sym); // Make sure to decrement reference count on sym on return
WBIsKlassAliveClosure closure(sym);
ClassLoaderDataGraph::classes_do(&closure);
return closure.found();
WB_END
WB_ENTRY(jboolean, WB_ClassKnownToNotExist(JNIEnv* env, jobject o, jobject loader, jstring name))
ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
const char* class_name = env->GetStringUTFChars(name, NULL);
jboolean result = JVM_KnownToNotExist(env, loader, class_name);
env->ReleaseStringUTFChars(name, class_name);
return result;
WB_END
WB_ENTRY(jobjectArray, WB_GetLookupCacheURLs(JNIEnv* env, jobject o, jobject loader))
ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
return JVM_GetResourceLookupCacheURLs(env, loader);
WB_END
WB_ENTRY(jintArray, WB_GetLookupCacheMatches(JNIEnv* env, jobject o, jobject loader, jstring name))
ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
const char* resource_name = env->GetStringUTFChars(name, NULL);
jintArray result = JVM_GetResourceLookupCache(env, loader, resource_name);
env->ReleaseStringUTFChars(name, resource_name);
return result;
WB_END
WB_ENTRY(void, WB_AddToBootstrapClassLoaderSearch(JNIEnv* env, jobject o, jstring segment)) {
#if INCLUDE_JVMTI
ResourceMark rm;
const char* seg = java_lang_String::as_utf8_string(JNIHandles::resolve_non_null(segment));
JvmtiEnv* jvmti_env = JvmtiEnv::create_a_jvmti(JVMTI_VERSION);
jvmtiError err = jvmti_env->AddToBootstrapClassLoaderSearch(seg);
assert(err == JVMTI_ERROR_NONE, "must not fail");
#endif
}
WB_END
WB_ENTRY(void, WB_AddToSystemClassLoaderSearch(JNIEnv* env, jobject o, jstring segment)) {
#if INCLUDE_JVMTI
ResourceMark rm;
const char* seg = java_lang_String::as_utf8_string(JNIHandles::resolve_non_null(segment));
JvmtiEnv* jvmti_env = JvmtiEnv::create_a_jvmti(JVMTI_VERSION);
jvmtiError err = jvmti_env->AddToSystemClassLoaderSearch(seg);
assert(err == JVMTI_ERROR_NONE, "must not fail");
#endif
}
WB_END
#ifdef LINUX
#include "utilities/elfFile.hpp"
#include "osContainer_linux.hpp"
#endif
WB_ENTRY(jlong, WB_GetCompressedOopsMaxHeapSize(JNIEnv* env, jobject o)) {
return (jlong)Arguments::max_heap_for_compressed_oops();
}
WB_END
WB_ENTRY(void, WB_PrintHeapSizes(JNIEnv* env, jobject o)) {
CollectorPolicy * p = Universe::heap()->collector_policy();
gclog_or_tty->print_cr("Minimum heap " SIZE_FORMAT " Initial heap "
SIZE_FORMAT " Maximum heap " SIZE_FORMAT " Space alignment " SIZE_FORMAT " Heap alignment " SIZE_FORMAT,
p->min_heap_byte_size(), p->initial_heap_byte_size(), p->max_heap_byte_size(),
p->space_alignment(), p->heap_alignment());
}
WB_END
#ifndef PRODUCT
void TestReservedSpace_test();
void TestReserveMemorySpecial_test();
void TestVirtualSpace_test();
void TestMetaspaceAux_test();
#endif
WB_ENTRY(void, WB_RunMemoryUnitTests(JNIEnv* env, jobject o))
#ifndef PRODUCT
TestReservedSpace_test();
TestReserveMemorySpecial_test();
TestVirtualSpace_test();
TestMetaspaceAux_test();
#endif
WB_END
WB_ENTRY(void, WB_ReadFromNoaccessArea(JNIEnv* env, jobject o))
size_t granularity = os::vm_allocation_granularity();
ReservedHeapSpace rhs(100 * granularity, granularity, false, NULL);
VirtualSpace vs;
vs.initialize(rhs, 50 * granularity);
if (!( UseCompressedOops && rhs.base() != NULL &&
Universe::narrow_oop_base() != NULL &&
Universe::narrow_oop_use_implicit_null_checks() )) {
tty->print_cr("WB_ReadFromNoaccessArea method is useless:\n "
"\tUseCompressedOops is %d\n"
"\trhs.base() is " PTR_FORMAT "\n"
"\tUniverse::narrow_oop_base() is " PTR_FORMAT "\n"
"\tUniverse::narrow_oop_use_implicit_null_checks() is %d",
UseCompressedOops,
rhs.base(),
Universe::narrow_oop_base(),
Universe::narrow_oop_use_implicit_null_checks());
return;
}
tty->print_cr("Reading from no access area... ");
tty->print_cr("*(vs.low_boundary() - rhs.noaccess_prefix() / 2 ) = %c",
WB_END
static jint wb_stress_virtual_space_resize(size_t reserved_space_size,
size_t magnitude, size_t iterations) {
size_t granularity = os::vm_allocation_granularity();
ReservedHeapSpace rhs(reserved_space_size * granularity, granularity, false, NULL);
VirtualSpace vs;
if (!vs.initialize(rhs, 0)) {
tty->print_cr("Failed to initialize VirtualSpace. Can't proceed.");
return 3;
}
long seed = os::random();
tty->print_cr("Random seed is %ld", seed);
os::init_random(seed);
for (size_t i = 0; i < iterations; i++) {
bool shrink = os::random() % 2L == 0;
size_t delta = (size_t)os::random() % magnitude;
if (shrink && vs.committed_size() < delta) {
shrink = false;
}
if (shrink) {
vs.shrink_by(delta);
} else {
vs.expand_by(delta, true);
}
}
return 0;
}
WB_ENTRY(jint, WB_StressVirtualSpaceResize(JNIEnv* env, jobject o,
jlong reserved_space_size, jlong magnitude, jlong iterations))
tty->print_cr("reservedSpaceSize=" JLONG_FORMAT ", magnitude=" JLONG_FORMAT ", "
"iterations=" JLONG_FORMAT "\n", reserved_space_size, magnitude,
iterations);
if (reserved_space_size < 0 || magnitude < 0 || iterations < 0) {
tty->print_cr("One of variables printed above is negative. Can't proceed.\n");
return 1;
}
if (sizeof(size_t) < sizeof(jlong)) {
jlong size_t_max_value = (jlong) SIZE_T_MAX_VALUE;
if (reserved_space_size > size_t_max_value || magnitude > size_t_max_value
|| iterations > size_t_max_value) {
tty->print_cr("One of variables printed above overflows size_t. Can't proceed.\n");
return 2;
}
}
return wb_stress_virtual_space_resize((size_t) reserved_space_size,
(size_t) magnitude, (size_t) iterations);
WB_END
WB_ENTRY(jboolean, WB_isObjectInOldGen(JNIEnv* env, jobject o, jobject obj))
oop p = JNIHandles::resolve(obj);
#if INCLUDE_ALL_GCS
if (UseG1GC) {
G1CollectedHeap* g1 = G1CollectedHeap::heap();
const HeapRegion* hr = g1->heap_region_containing(p);
if (hr == NULL) {
return false;
}
return !(hr->is_young());
} else if (UseParallelGC) {
ParallelScavengeHeap* psh = ParallelScavengeHeap::heap();
return !psh->is_in_young(p);
}
#endif // INCLUDE_ALL_GCS
GenCollectedHeap* gch = GenCollectedHeap::heap();
return !gch->is_in_young(p);
WB_END
WB_ENTRY(jlong, WB_GetObjectSize(JNIEnv* env, jobject o, jobject obj))
oop p = JNIHandles::resolve(obj);
return p->size() * HeapWordSize;
WB_END
#if INCLUDE_ALL_GCS
WB_ENTRY(jboolean, WB_G1IsHumongous(JNIEnv* env, jobject o, jobject obj))
G1CollectedHeap* g1 = G1CollectedHeap::heap();
oop result = JNIHandles::resolve(obj);
const HeapRegion* hr = g1->heap_region_containing(result);
return hr->isHumongous();
WB_END
WB_ENTRY(jlong, WB_G1NumMaxRegions(JNIEnv* env, jobject o))
G1CollectedHeap* g1 = G1CollectedHeap::heap();
size_t nr = g1->max_regions();
return (jlong)nr;
WB_END
WB_ENTRY(jlong, WB_G1NumFreeRegions(JNIEnv* env, jobject o))
G1CollectedHeap* g1 = G1CollectedHeap::heap();
size_t nr = g1->num_free_regions();
return (jlong)nr;
WB_END
WB_ENTRY(jboolean, WB_G1InConcurrentMark(JNIEnv* env, jobject o))
G1CollectedHeap* g1 = G1CollectedHeap::heap();
return g1->concurrent_mark()->cmThread()->during_cycle();
WB_END
WB_ENTRY(jboolean, WB_G1StartMarkCycle(JNIEnv* env, jobject o))
G1CollectedHeap* g1h = G1CollectedHeap::heap();
if (!g1h->concurrent_mark()->cmThread()->during_cycle()) {
g1h->collect(GCCause::_wb_conc_mark);
return true;
}
return false;
WB_END
WB_ENTRY(jint, WB_G1RegionSize(JNIEnv* env, jobject o))
return (jint)HeapRegion::GrainBytes;
WB_END
WB_ENTRY(jobject, WB_G1AuxiliaryMemoryUsage(JNIEnv* env))
ResourceMark rm(THREAD);
G1CollectedHeap* g1h = G1CollectedHeap::heap();
MemoryUsage usage = g1h->get_auxiliary_data_memory_usage();
Handle h = MemoryService::create_MemoryUsage_obj(usage, CHECK_NULL);
return JNIHandles::make_local(env, h());
WB_END
#endif // INCLUDE_ALL_GCS
#if INCLUDE_NMT
WB_ENTRY(jlong, WB_NMTMalloc(JNIEnv* env, jobject o, jlong size))
jlong addr = 0;
addr = (jlong)(uintptr_t)os::malloc(size, mtTest);
return addr;
WB_END
WB_ENTRY(jlong, WB_NMTMallocWithPseudoStack(JNIEnv* env, jobject o, jlong size, jint pseudo_stack))
address pc = (address)(size_t)pseudo_stack;
NativeCallStack stack(&pc, 1);
return (jlong)(uintptr_t)os::malloc(size, mtTest, stack);
WB_END
WB_ENTRY(jlong, WB_NMTMallocWithPseudoStackAndType(JNIEnv* env, jobject o, jlong size, jint pseudo_stack, jint type))
address pc = (address)(size_t)pseudo_stack;
NativeCallStack stack(&pc, 1);
return (jlong)(uintptr_t)os::malloc(size, (MEMFLAGS)type, stack);
WB_END
WB_ENTRY(void, WB_NMTFree(JNIEnv* env, jobject o, jlong mem))
os::free((void*)(uintptr_t)mem, mtTest);
WB_END
WB_ENTRY(jlong, WB_NMTReserveMemory(JNIEnv* env, jobject o, jlong size))
jlong addr = 0;
addr = (jlong)(uintptr_t)os::reserve_memory(size);
MemTracker::record_virtual_memory_type((address)addr, mtTest);
return addr;
WB_END
WB_ENTRY(void, WB_NMTCommitMemory(JNIEnv* env, jobject o, jlong addr, jlong size))
os::commit_memory((char *)(uintptr_t)addr, size, !ExecMem);
MemTracker::record_virtual_memory_type((address)(uintptr_t)addr, mtTest);
WB_END
WB_ENTRY(void, WB_NMTUncommitMemory(JNIEnv* env, jobject o, jlong addr, jlong size))
os::uncommit_memory((char *)(uintptr_t)addr, size);
WB_END
WB_ENTRY(void, WB_NMTReleaseMemory(JNIEnv* env, jobject o, jlong addr, jlong size))
os::release_memory((char *)(uintptr_t)addr, size);
WB_END
WB_ENTRY(jboolean, WB_NMTIsDetailSupported(JNIEnv* env))
return MemTracker::tracking_level() == NMT_detail;
WB_END
WB_ENTRY(jboolean, WB_NMTChangeTrackingLevel(JNIEnv* env))
if (MemTracker::tracking_level() == NMT_off) {
MemTracker::transition_to(NMT_off);
return MemTracker::tracking_level() == NMT_off;
} else {
assert(MemTracker::tracking_level() == NMT_detail, "Should start out as detail tracking");
MemTracker::transition_to(NMT_summary);
assert(MemTracker::tracking_level() == NMT_summary, "Should be summary now");
MemTracker::transition_to(NMT_detail);
assert(MemTracker::tracking_level() == NMT_summary, "Should still be summary now");
MemTracker::shutdown();
assert(MemTracker::tracking_level() == NMT_minimal, "Should be minimal now");
MemTracker::transition_to(NMT_summary);
assert(MemTracker::tracking_level() == NMT_minimal, "Should still be minimal now");
MemTracker::transition_to(NMT_detail);
assert(MemTracker::tracking_level() == NMT_minimal, "Should still be minimal now");
return MemTracker::tracking_level() == NMT_minimal;
}
WB_END
WB_ENTRY(jint, WB_NMTGetHashSize(JNIEnv* env, jobject o))
int hash_size = MallocSiteTable::hash_buckets();
assert(hash_size > 0, "NMT hash_size should be > 0");
return (jint)hash_size;
WB_END
WB_ENTRY(jlong, WB_NMTNewArena(JNIEnv* env, jobject o, jlong init_size))
Arena* arena = new (mtTest) Arena(mtTest, size_t(init_size));
return (jlong)arena;
WB_END
WB_ENTRY(void, WB_NMTFreeArena(JNIEnv* env, jobject o, jlong arena))
Arena* a = (Arena*)arena;
delete a;
WB_END
WB_ENTRY(void, WB_NMTArenaMalloc(JNIEnv* env, jobject o, jlong arena, jlong size))
Arena* a = (Arena*)arena;
a->Amalloc(size_t(size));
WB_END
#endif // INCLUDE_NMT
static jmethodID reflected_method_to_jmid(JavaThread* thread, JNIEnv* env, jobject method) {
assert(method != NULL, "method should not be null");
ThreadToNativeFromVM ttn(thread);
return env->FromReflectedMethod(method);
}
WB_ENTRY(void, WB_DeoptimizeAll(JNIEnv* env, jobject o))
MutexLockerEx mu(Compile_lock);
CodeCache::mark_all_nmethods_for_deoptimization();
VM_Deoptimize op;
VMThread::execute(&op);
WB_END
WB_ENTRY(jint, WB_DeoptimizeMethod(JNIEnv* env, jobject o, jobject method, jboolean is_osr))
jmethodID jmid = reflected_method_to_jmid(thread, env, method);
int result = 0;
CHECK_JNI_EXCEPTION_(env, result);
MutexLockerEx mu(Compile_lock);
methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
if (is_osr) {
result += mh->mark_osr_nmethods();
} else if (mh->code() != NULL) {
mh->code()->mark_for_deoptimization();
++result;
}
result += CodeCache::mark_for_deoptimization(mh());
if (result > 0) {
VM_Deoptimize op;
VMThread::execute(&op);
}
return result;
WB_END
WB_ENTRY(jboolean, WB_IsMethodCompiled(JNIEnv* env, jobject o, jobject method, jboolean is_osr))
jmethodID jmid = reflected_method_to_jmid(thread, env, method);
CHECK_JNI_EXCEPTION_(env, JNI_FALSE);
MutexLockerEx mu(Compile_lock);
methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
nmethod* code = is_osr ? mh->lookup_osr_nmethod_for(InvocationEntryBci, CompLevel_none, false) : mh->code();
if (code == NULL) {
return JNI_FALSE;
}
return (code->is_alive() && !code->is_marked_for_deoptimization());
WB_END
WB_ENTRY(jboolean, WB_IsMethodCompilable(JNIEnv* env, jobject o, jobject method, jint comp_level, jboolean is_osr))
jmethodID jmid = reflected_method_to_jmid(thread, env, method);
CHECK_JNI_EXCEPTION_(env, JNI_FALSE);
MutexLockerEx mu(Compile_lock);
methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
if (is_osr) {
return CompilationPolicy::can_be_osr_compiled(mh, comp_level);
} else {
return CompilationPolicy::can_be_compiled(mh, comp_level);
}
WB_END
WB_ENTRY(jboolean, WB_IsMethodQueuedForCompilation(JNIEnv* env, jobject o, jobject method))
jmethodID jmid = reflected_method_to_jmid(thread, env, method);
CHECK_JNI_EXCEPTION_(env, JNI_FALSE);
MutexLockerEx mu(Compile_lock);
methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
return mh->queued_for_compilation();
WB_END
WB_ENTRY(jint, WB_GetMethodCompilationLevel(JNIEnv* env, jobject o, jobject method, jboolean is_osr))
jmethodID jmid = reflected_method_to_jmid(thread, env, method);
CHECK_JNI_EXCEPTION_(env, CompLevel_none);
methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
nmethod* code = is_osr ? mh->lookup_osr_nmethod_for(InvocationEntryBci, CompLevel_none, false) : mh->code();
return (code != NULL ? code->comp_level() : CompLevel_none);
WB_END
WB_ENTRY(void, WB_MakeMethodNotCompilable(JNIEnv* env, jobject o, jobject method, jint comp_level, jboolean is_osr))
jmethodID jmid = reflected_method_to_jmid(thread, env, method);
CHECK_JNI_EXCEPTION(env);
methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
if (is_osr) {
mh->set_not_osr_compilable(comp_level, true /* report */, "WhiteBox");
} else {
mh->set_not_compilable(comp_level, true /* report */, "WhiteBox");
}
WB_END
WB_ENTRY(jint, WB_GetMethodEntryBci(JNIEnv* env, jobject o, jobject method))
jmethodID jmid = reflected_method_to_jmid(thread, env, method);
CHECK_JNI_EXCEPTION_(env, InvocationEntryBci);
methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
nmethod* code = mh->lookup_osr_nmethod_for(InvocationEntryBci, CompLevel_none, false);
return (code != NULL && code->is_osr_method() ? code->osr_entry_bci() : InvocationEntryBci);
WB_END
WB_ENTRY(jboolean, WB_TestSetDontInlineMethod(JNIEnv* env, jobject o, jobject method, jboolean value))
jmethodID jmid = reflected_method_to_jmid(thread, env, method);
CHECK_JNI_EXCEPTION_(env, JNI_FALSE);
methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
bool result = mh->dont_inline();
mh->set_dont_inline(value == JNI_TRUE);
return result;
WB_END
WB_ENTRY(jint, WB_GetCompileQueueSize(JNIEnv* env, jobject o, jint comp_level))
if (comp_level == CompLevel_any) {
return CompileBroker::queue_size(CompLevel_full_optimization) /* C2 */ +
CompileBroker::queue_size(CompLevel_full_profile) /* C1 */;
} else {
return CompileBroker::queue_size(comp_level);
}
WB_END
WB_ENTRY(jboolean, WB_TestSetForceInlineMethod(JNIEnv* env, jobject o, jobject method, jboolean value))
jmethodID jmid = reflected_method_to_jmid(thread, env, method);
CHECK_JNI_EXCEPTION_(env, JNI_FALSE);
methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
bool result = mh->force_inline();
mh->set_force_inline(value == JNI_TRUE);
return result;
WB_END
bool WhiteBox::compile_method(Method* method, int comp_level, int bci, Thread* THREAD) {
AbstractCompiler* comp = CompileBroker::compiler(comp_level);
if (method == NULL) {
tty->print_cr("WB error: request to compile NULL method");
return false;
}
if (comp_level > MIN2((CompLevel) TieredStopAtLevel, CompLevel_highest_tier)) {
tty->print_cr("WB error: invalid compilation level %d", comp_level);
return false;
}
if (comp == NULL) {
tty->print_cr("WB error: no compiler for requested compilation level %d", comp_level);
return false;
}
methodHandle mh(THREAD, method);
nmethod* nm = CompileBroker::compile_method(mh, bci, comp_level, mh, mh->invocation_count(), "Whitebox", THREAD);
MutexLocker mu(Compile_lock);
bool is_queued = mh->queued_for_compilation();
if (is_queued || nm != NULL) {
return true;
}
tty->print("WB error: failed to compile at level %d method ", comp_level);
mh->print_short_name(tty);
tty->cr();
if (is_queued) {
tty->print_cr("WB error: blocking compilation is still in queue!");
}
return false;
}
WB_ENTRY(jboolean, WB_EnqueueMethodForCompilation(JNIEnv* env, jobject o, jobject method, jint comp_level, jint bci))
jmethodID jmid = reflected_method_to_jmid(thread, env, method);
CHECK_JNI_EXCEPTION_(env, JNI_FALSE);
return WhiteBox::compile_method(Method::checked_resolve_jmethod_id(jmid), comp_level, bci, THREAD);
WB_END
WB_ENTRY(jboolean, WB_EnqueueInitializerForCompilation(JNIEnv* env, jobject o, jclass klass, jint comp_level))
InstanceKlass* ik = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve(klass)));
Method* clinit = ik->class_initializer();
if (clinit == NULL) {
return false;
}
return WhiteBox::compile_method(clinit, comp_level, InvocationEntryBci, THREAD);
WB_END
class VM_WhiteBoxOperation : public VM_Operation {
public:
VM_WhiteBoxOperation() { }
VMOp_Type type() const { return VMOp_WhiteBoxOperation; }
bool allow_nested_vm_operations() const { return true; }
};
static AlwaysFalseClosure always_false;
class VM_WhiteBoxCleanMethodData : public VM_WhiteBoxOperation {
public:
VM_WhiteBoxCleanMethodData(MethodData* mdo) : _mdo(mdo) { }
void doit() {
_mdo->clean_method_data(&always_false);
}
private:
MethodData* _mdo;
};
WB_ENTRY(void, WB_ClearMethodState(JNIEnv* env, jobject o, jobject method))
jmethodID jmid = reflected_method_to_jmid(thread, env, method);
CHECK_JNI_EXCEPTION(env);
methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
MutexLockerEx mu(Compile_lock);
MethodData* mdo = mh->method_data();
MethodCounters* mcs = mh->method_counters();
if (mdo != NULL) {
mdo->init();
ResourceMark rm;
int arg_count = mdo->method()->size_of_parameters();
for (int i = 0; i < arg_count; i++) {
mdo->set_arg_modified(i, 0);
}
VM_WhiteBoxCleanMethodData op(mdo);
VMThread::execute(&op);
}
mh->clear_not_c1_compilable();
mh->clear_not_c2_compilable();
mh->clear_not_c2_osr_compilable();
NOT_PRODUCT(mh->set_compiled_invocation_count(0));
if (mcs != NULL) {
mcs->backedge_counter()->init();
mcs->invocation_counter()->init();
mcs->set_interpreter_invocation_count(0);
mcs->set_interpreter_throwout_count(0);
#ifdef TIERED
mcs->set_rate(0.0F);
mh->set_prev_event_count(0);
mh->set_prev_time(0);
#endif
}
WB_END
WB_ENTRY(void, WB_MarkMethodProfiled(JNIEnv* env, jobject o, jobject method))
jmethodID jmid = reflected_method_to_jmid(thread, env, method);
CHECK_JNI_EXCEPTION(env);
methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
MethodData* mdo = mh->method_data();
if (mdo == NULL) {
Method::build_interpreter_method_data(mh, CHECK_AND_CLEAR);
mdo = mh->method_data();
}
mdo->init();
InvocationCounter* icnt = mdo->invocation_counter();
InvocationCounter* bcnt = mdo->backedge_counter();
icnt->set(InvocationCounter::wait_for_compile, Tier4MinInvocationThreshold + 1);
bcnt->set(InvocationCounter::wait_for_compile, Tier4CompileThreshold + 1);
WB_END
template <typename T>
static bool GetVMFlag(JavaThread* thread, JNIEnv* env, jstring name, T* value, bool (*TAt)(const char*, T*, bool, bool)) {
if (name == NULL) {
return false;
}
ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
const char* flag_name = env->GetStringUTFChars(name, NULL);
bool result = (*TAt)(flag_name, value, true, true);
env->ReleaseStringUTFChars(name, flag_name);
return result;
}
template <typename T>
static bool SetVMFlag(JavaThread* thread, JNIEnv* env, jstring name, T* value, bool (*TAtPut)(const char*, T*, Flag::Flags)) {
if (name == NULL) {
return false;
}
ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
const char* flag_name = env->GetStringUTFChars(name, NULL);
bool result = (*TAtPut)(flag_name, value, Flag::INTERNAL);
env->ReleaseStringUTFChars(name, flag_name);
return result;
}
template <typename T>
static jobject box(JavaThread* thread, JNIEnv* env, Symbol* name, Symbol* sig, T value) {
ResourceMark rm(thread);
jclass clazz = env->FindClass(name->as_C_string());
CHECK_JNI_EXCEPTION_(env, NULL);
jmethodID methodID = env->GetStaticMethodID(clazz,
vmSymbols::valueOf_name()->as_C_string(),
sig->as_C_string());
CHECK_JNI_EXCEPTION_(env, NULL);
jobject result = env->CallStaticObjectMethod(clazz, methodID, value);
CHECK_JNI_EXCEPTION_(env, NULL);
return result;
}
static jobject booleanBox(JavaThread* thread, JNIEnv* env, jboolean value) {
return box(thread, env, vmSymbols::java_lang_Boolean(), vmSymbols::Boolean_valueOf_signature(), value);
}
static jobject integerBox(JavaThread* thread, JNIEnv* env, jint value) {
return box(thread, env, vmSymbols::java_lang_Integer(), vmSymbols::Integer_valueOf_signature(), value);
}
static jobject longBox(JavaThread* thread, JNIEnv* env, jlong value) {
return box(thread, env, vmSymbols::java_lang_Long(), vmSymbols::Long_valueOf_signature(), value);
}
return box(thread, env, vmSymbols::java_lang_Float(), vmSymbols::Float_valueOf_signature(), value);
}*/
static jobject doubleBox(JavaThread* thread, JNIEnv* env, jdouble value) {
return box(thread, env, vmSymbols::java_lang_Double(), vmSymbols::Double_valueOf_signature(), value);
}
WB_ENTRY(jobject, WB_GetBooleanVMFlag(JNIEnv* env, jobject o, jstring name))
bool result;
if (GetVMFlag <bool> (thread, env, name, &result, &CommandLineFlags::boolAt)) {
ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
return booleanBox(thread, env, result);
}
return NULL;
WB_END
WB_ENTRY(jobject, WB_GetIntxVMFlag(JNIEnv* env, jobject o, jstring name))
intx result;
if (GetVMFlag <intx> (thread, env, name, &result, &CommandLineFlags::intxAt)) {
ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
return longBox(thread, env, result);
}
return NULL;
WB_END
WB_ENTRY(jobject, WB_GetUintxVMFlag(JNIEnv* env, jobject o, jstring name))
uintx result;
if (GetVMFlag <uintx> (thread, env, name, &result, &CommandLineFlags::uintxAt)) {
ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
return longBox(thread, env, result);
}
return NULL;
WB_END
WB_ENTRY(jobject, WB_GetUint64VMFlag(JNIEnv* env, jobject o, jstring name))
uint64_t result;
if (GetVMFlag <uint64_t> (thread, env, name, &result, &CommandLineFlags::uint64_tAt)) {
ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
return longBox(thread, env, result);
}
return NULL;
WB_END
WB_ENTRY(jobject, WB_GetDoubleVMFlag(JNIEnv* env, jobject o, jstring name))
double result;
if (GetVMFlag <double> (thread, env, name, &result, &CommandLineFlags::doubleAt)) {
ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
return doubleBox(thread, env, result);
}
return NULL;
WB_END
WB_ENTRY(jstring, WB_GetStringVMFlag(JNIEnv* env, jobject o, jstring name))
ccstr ccstrResult;
if (GetVMFlag <ccstr> (thread, env, name, &ccstrResult, &CommandLineFlags::ccstrAt)) {
ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
jstring result = env->NewStringUTF(ccstrResult);
CHECK_JNI_EXCEPTION_(env, NULL);
return result;
}
return NULL;
WB_END
WB_ENTRY(void, WB_SetBooleanVMFlag(JNIEnv* env, jobject o, jstring name, jboolean value))
bool result = value == JNI_TRUE ? true : false;
SetVMFlag <bool> (thread, env, name, &result, &CommandLineFlags::boolAtPut);
WB_END
WB_ENTRY(void, WB_SetIntxVMFlag(JNIEnv* env, jobject o, jstring name, jlong value))
intx result = value;
SetVMFlag <intx> (thread, env, name, &result, &CommandLineFlags::intxAtPut);
WB_END
WB_ENTRY(void, WB_SetUintxVMFlag(JNIEnv* env, jobject o, jstring name, jlong value))
uintx result = value;
SetVMFlag <uintx> (thread, env, name, &result, &CommandLineFlags::uintxAtPut);
WB_END
WB_ENTRY(void, WB_SetUint64VMFlag(JNIEnv* env, jobject o, jstring name, jlong value))
uint64_t result = value;
SetVMFlag <uint64_t> (thread, env, name, &result, &CommandLineFlags::uint64_tAtPut);
WB_END
WB_ENTRY(void, WB_SetDoubleVMFlag(JNIEnv* env, jobject o, jstring name, jdouble value))
double result = value;
SetVMFlag <double> (thread, env, name, &result, &CommandLineFlags::doubleAtPut);
WB_END
WB_ENTRY(void, WB_SetStringVMFlag(JNIEnv* env, jobject o, jstring name, jstring value))
ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
const char* ccstrValue = (value == NULL) ? NULL : env->GetStringUTFChars(value, NULL);
ccstr ccstrResult = ccstrValue;
bool needFree;
{
ThreadInVMfromNative ttvfn(thread); // back to VM
needFree = SetVMFlag <ccstr> (thread, env, name, &ccstrResult, &CommandLineFlags::ccstrAtPut);
}
if (value != NULL) {
env->ReleaseStringUTFChars(value, ccstrValue);
}
if (needFree) {
FREE_C_HEAP_ARRAY(char, ccstrResult, mtInternal);
}
WB_END
WB_ENTRY(jboolean, WB_IsInStringTable(JNIEnv* env, jobject o, jstring javaString))
ResourceMark rm(THREAD);
int len;
jchar* name = java_lang_String::as_unicode_string(JNIHandles::resolve(javaString), len, CHECK_false);
return (StringTable::lookup(name, len) != NULL);
WB_END
WB_ENTRY(void, WB_FullGC(JNIEnv* env, jobject o))
Universe::heap()->collector_policy()->set_should_clear_all_soft_refs(true);
Universe::heap()->collect(GCCause::_last_ditch_collection);
#if INCLUDE_ALL_GCS
if (UseG1GC) {
Universe::heap()->collector_policy()->set_should_clear_all_soft_refs(false);
}
#endif // INCLUDE_ALL_GCS
WB_END
WB_ENTRY(void, WB_YoungGC(JNIEnv* env, jobject o))
Universe::heap()->collect(GCCause::_wb_young_gc);
WB_END
WB_ENTRY(void, WB_ReadReservedMemory(JNIEnv* env, jobject o))
static char c;
static volatile char* p;
p = os::reserve_memory(os::vm_allocation_granularity(), NULL, 0);
if (p == NULL) {
THROW_MSG(vmSymbols::java_lang_OutOfMemoryError(), "Failed to reserve memory");
}
c = *p;
WB_END
WB_ENTRY(jstring, WB_GetCPUFeatures(JNIEnv* env, jobject o))
const char* cpu_features = VM_Version::cpu_features();
ThreadToNativeFromVM ttn(thread);
jstring features_string = env->NewStringUTF(cpu_features);
CHECK_JNI_EXCEPTION_(env, NULL);
return features_string;
WB_END
int WhiteBox::get_blob_type(const CodeBlob* code) {
guarantee(WhiteBoxAPI, "internal testing API :: WhiteBox has to be enabled");
return CodeBlobType::All;;
}
struct CodeBlobStub {
CodeBlobStub(const CodeBlob* blob) :
name(os::strdup(blob->name())),
size(blob->size()),
blob_type(WhiteBox::get_blob_type(blob)),
address((jlong) blob) { }
~CodeBlobStub() { os::free((void*) name); }
const char* const name;
const jint size;
const jint blob_type;
const jlong address;
};
static jobjectArray codeBlob2objectArray(JavaThread* thread, JNIEnv* env, CodeBlobStub* cb) {
jclass clazz = env->FindClass(vmSymbols::java_lang_Object()->as_C_string());
CHECK_JNI_EXCEPTION_(env, NULL);
jobjectArray result = env->NewObjectArray(4, clazz, NULL);
jstring name = env->NewStringUTF(cb->name);
CHECK_JNI_EXCEPTION_(env, NULL);
env->SetObjectArrayElement(result, 0, name);
jobject obj = integerBox(thread, env, cb->size);
CHECK_JNI_EXCEPTION_(env, NULL);
env->SetObjectArrayElement(result, 1, obj);
obj = integerBox(thread, env, cb->blob_type);
CHECK_JNI_EXCEPTION_(env, NULL);
env->SetObjectArrayElement(result, 2, obj);
obj = longBox(thread, env, cb->address);
CHECK_JNI_EXCEPTION_(env, NULL);
env->SetObjectArrayElement(result, 3, obj);
return result;
}
WB_ENTRY(jobjectArray, WB_GetNMethod(JNIEnv* env, jobject o, jobject method, jboolean is_osr))
ResourceMark rm(THREAD);
jmethodID jmid = reflected_method_to_jmid(thread, env, method);
CHECK_JNI_EXCEPTION_(env, NULL);
methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
nmethod* code = is_osr ? mh->lookup_osr_nmethod_for(InvocationEntryBci, CompLevel_none, false) : mh->code();
jobjectArray result = NULL;
if (code == NULL) {
return result;
}
int insts_size = code->insts_size();
ThreadToNativeFromVM ttn(thread);
jclass clazz = env->FindClass(vmSymbols::java_lang_Object()->as_C_string());
CHECK_JNI_EXCEPTION_(env, NULL);
result = env->NewObjectArray(3, clazz, NULL);
if (result == NULL) {
return result;
}
jobject level = integerBox(thread, env, code->comp_level());
CHECK_JNI_EXCEPTION_(env, NULL);
env->SetObjectArrayElement(result, 0, level);
jobject id = integerBox(thread, env, code->compile_id());
CHECK_JNI_EXCEPTION_(env, NULL);
env->SetObjectArrayElement(result, 1, id);
jbyteArray insts = env->NewByteArray(insts_size);
CHECK_JNI_EXCEPTION_(env, NULL);
env->SetByteArrayRegion(insts, 0, insts_size, (jbyte*) code->insts_begin());
env->SetObjectArrayElement(result, 2, insts);
return result;
WB_END
CodeBlob* WhiteBox::allocate_code_blob(int size, int blob_type) {
guarantee(WhiteBoxAPI, "internal testing API :: WhiteBox has to be enabled");
BufferBlob* blob;
int full_size = CodeBlob::align_code_offset(sizeof(BufferBlob));
if (full_size < size) {
full_size += align_up(size - full_size, oopSize);
}
{
MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
blob = (BufferBlob*) CodeCache::allocate(full_size);
::new (blob) BufferBlob("WB::DummyBlob", full_size);
}
MemoryService::track_code_cache_memory_usage();
return blob;
}
WB_ENTRY(jlong, WB_AllocateCodeBlob(JNIEnv* env, jobject o, jint size, jint blob_type))
if (size < 0) {
THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),
err_msg("WB_AllocateCodeBlob: size is negative: " INT32_FORMAT, size));
}
return (jlong) WhiteBox::allocate_code_blob(size, blob_type);
WB_END
WB_ENTRY(void, WB_FreeCodeBlob(JNIEnv* env, jobject o, jlong addr))
if (addr == 0) {
return;
}
BufferBlob::free((BufferBlob*) addr);
WB_END
WB_ENTRY(jobjectArray, WB_GetCodeBlob(JNIEnv* env, jobject o, jlong addr))
if (addr == 0) {
THROW_MSG_NULL(vmSymbols::java_lang_NullPointerException(),
"WB_GetCodeBlob: addr is null");
}
ThreadToNativeFromVM ttn(thread);
CodeBlobStub stub((CodeBlob*) addr);
return codeBlob2objectArray(thread, env, &stub);
WB_END
int WhiteBox::array_bytes_to_length(size_t bytes) {
return Array<u1>::bytes_to_length(bytes);
}
WB_ENTRY(jlong, WB_AllocateMetaspace(JNIEnv* env, jobject wb, jobject class_loader, jlong size))
if (size < 0) {
THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),
err_msg("WB_AllocateMetaspace: size is negative: " JLONG_FORMAT, size));
}
oop class_loader_oop = JNIHandles::resolve(class_loader);
ClassLoaderData* cld = class_loader_oop != NULL
? java_lang_ClassLoader::loader_data(class_loader_oop)
: ClassLoaderData::the_null_class_loader_data();
void* metadata = MetadataFactory::new_writeable_array<u1>(cld, WhiteBox::array_bytes_to_length((size_t)size), thread);
return (jlong)(uintptr_t)metadata;
WB_END
WB_ENTRY(void, WB_FreeMetaspace(JNIEnv* env, jobject wb, jobject class_loader, jlong addr, jlong size))
oop class_loader_oop = JNIHandles::resolve(class_loader);
ClassLoaderData* cld = class_loader_oop != NULL
? java_lang_ClassLoader::loader_data(class_loader_oop)
: ClassLoaderData::the_null_class_loader_data();
MetadataFactory::free_array(cld, (Array<u1>*)(uintptr_t)addr);
WB_END
WB_ENTRY(jlong, WB_IncMetaspaceCapacityUntilGC(JNIEnv* env, jobject wb, jlong inc))
if (inc < 0) {
THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),
err_msg("WB_IncMetaspaceCapacityUntilGC: inc is negative: " JLONG_FORMAT, inc));
}
jlong max_size_t = (jlong) ((size_t) -1);
if (inc > max_size_t) {
THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),
err_msg("WB_IncMetaspaceCapacityUntilGC: inc does not fit in size_t: " JLONG_FORMAT, inc));
}
size_t new_cap_until_GC = 0;
size_t aligned_inc = align_size_down((size_t) inc, Metaspace::commit_alignment());
bool success = MetaspaceGC::inc_capacity_until_GC(aligned_inc, &new_cap_until_GC);
if (!success) {
THROW_MSG_0(vmSymbols::java_lang_IllegalStateException(),
"WB_IncMetaspaceCapacityUntilGC: could not increase capacity until GC "
"due to contention with another thread");
}
return (jlong) new_cap_until_GC;
WB_END
WB_ENTRY(jlong, WB_MetaspaceCapacityUntilGC(JNIEnv* env, jobject wb))
return (jlong) MetaspaceGC::capacity_until_GC();
WB_END
WB_ENTRY(jboolean, WB_IsSharedClass(JNIEnv* env, jobject wb, jclass clazz))
return (jboolean)MetaspaceShared::is_in_shared_space(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz)));
WB_END
WB_ENTRY(jboolean, WB_IsMonitorInflated(JNIEnv* env, jobject wb, jobject obj))
oop obj_oop = JNIHandles::resolve(obj);
return (jboolean) obj_oop->mark()->has_monitor();
WB_END
WB_ENTRY(void, WB_ForceSafepoint(JNIEnv* env, jobject wb))
VM_ForceSafepoint force_safepoint_op;
VMThread::execute(&force_safepoint_op);
WB_END
WB_ENTRY(jlong, WB_GetHeapAlignment(JNIEnv* env, jobject o))
size_t alignment = Universe::heap()->collector_policy()->heap_alignment();
return (jlong)alignment;
WB_END
int WhiteBox::offset_for_field(const char* field_name, oop object,
Symbol* signature_symbol) {
assert(field_name != NULL && strlen(field_name) > 0, "Field name not valid");
Thread* THREAD = Thread::current();
Klass* arg_klass = object->klass();
InstanceKlass* ik = InstanceKlass::cast(arg_klass);
TempNewSymbol name_symbol = SymbolTable::lookup(field_name, (int) strlen(field_name),
THREAD);
fieldDescriptor fd;
Klass* res = ik->find_field(name_symbol, signature_symbol, &fd);
if (res == NULL) {
tty->print_cr("Invalid layout of %s at %s", ik->external_name(),
name_symbol->as_C_string());
vm_exit_during_initialization("Invalid layout of preloaded class: use -XX:+TraceClassLoading to see the origin of the problem class");
}
int dest_offset = fd.offset();
return dest_offset;
}
const char* WhiteBox::lookup_jstring(const char* field_name, oop object) {
int offset = offset_for_field(field_name, object,
vmSymbols::string_signature());
oop string = object->obj_field(offset);
if (string == NULL) {
return NULL;
}
const char* ret = java_lang_String::as_utf8_string(string);
return ret;
}
bool WhiteBox::lookup_bool(const char* field_name, oop object) {
int offset =
offset_for_field(field_name, object, vmSymbols::bool_signature());
bool ret = (object->bool_field(offset) == JNI_TRUE);
return ret;
}
void WhiteBox::register_methods(JNIEnv* env, jclass wbclass, JavaThread* thread, JNINativeMethod* method_array, int method_count) {
ResourceMark rm;
ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
jclass no_such_method_error_klass = env->FindClass(vmSymbols::java_lang_NoSuchMethodError()->as_C_string());
CHECK_JNI_EXCEPTION(env);
for (int i = 0, n = method_count; i < n; ++i) {
if (method_array[i].fnPtr == NULL) continue;
if (env->RegisterNatives(wbclass, &method_array[i], 1) != 0) {
jthrowable throwable_obj = env->ExceptionOccurred();
if (throwable_obj != NULL) {
env->ExceptionClear();
if (env->IsInstanceOf(throwable_obj, no_such_method_error_klass)) {
tty->print_cr("Warning: 'NoSuchMethodError' on register of sun.hotspot.WhiteBox::%s%s",
method_array[i].name, method_array[i].signature);
}
} else {
tty->print_cr("Warning: unexpected error on register of sun.hotspot.WhiteBox::%s%s. All methods will be unregistered",
method_array[i].name, method_array[i].signature);
env->UnregisterNatives(wbclass);
break;
}
}
}
}
WB_ENTRY(jboolean, WB_CheckLibSpecifiesNoexecstack(JNIEnv* env, jobject o, jstring libfile))
jboolean ret = false;
#ifdef LINUX
ThreadToNativeFromVM ttnfv(thread);
const char* lf = env->GetStringUTFChars(libfile, NULL);
CHECK_JNI_EXCEPTION_(env, 0);
ElfFile ef(lf);
ret = (jboolean) ef.specifies_noexecstack();
env->ReleaseStringUTFChars(libfile, lf);
#endif
return ret;
WB_END
WB_ENTRY(jboolean, WB_IsContainerized(JNIEnv* env, jobject o))
LINUX_ONLY(return OSContainer::is_containerized();)
return false;
WB_END
WB_ENTRY(void, WB_PrintOsInfo(JNIEnv* env, jobject o))
os::print_os_info(tty);
WB_END
#define CC (char*)
static JNINativeMethod methods[] = {
{CC"getObjectAddress", CC"(Ljava/lang/Object;)J", (void*)&WB_GetObjectAddress },
{CC"getObjectSize", CC"(Ljava/lang/Object;)J", (void*)&WB_GetObjectSize },
{CC"isObjectInOldGen", CC"(Ljava/lang/Object;)Z", (void*)&WB_isObjectInOldGen },
{CC"getHeapOopSize", CC"()I", (void*)&WB_GetHeapOopSize },
{CC"getVMPageSize", CC"()I", (void*)&WB_GetVMPageSize },
{CC"getVMLargePageSize", CC"()J", (void*)&WB_GetVMLargePageSize},
{CC"getHeapAlignment", CC"()J", (void*)&WB_GetHeapAlignment },
{CC"isClassAlive0", CC"(Ljava/lang/String;)Z", (void*)&WB_IsClassAlive },
{CC"classKnownToNotExist",
CC"(Ljava/lang/ClassLoader;Ljava/lang/String;)Z",(void*)&WB_ClassKnownToNotExist},
{CC"getLookupCacheURLs", CC"(Ljava/lang/ClassLoader;)[Ljava/net/URL;", (void*)&WB_GetLookupCacheURLs},
{CC"getLookupCacheMatches", CC"(Ljava/lang/ClassLoader;Ljava/lang/String;)[I",
(void*)&WB_GetLookupCacheMatches},
{CC"parseCommandLine",
CC"(Ljava/lang/String;[Lsun/hotspot/parser/DiagnosticCommand;)[Ljava/lang/Object;",
(void*) &WB_ParseCommandLine
},
{CC"addToBootstrapClassLoaderSearch", CC"(Ljava/lang/String;)V",
(void*)&WB_AddToBootstrapClassLoaderSearch},
{CC"addToSystemClassLoaderSearch", CC"(Ljava/lang/String;)V",
(void*)&WB_AddToSystemClassLoaderSearch},
{CC"getCompressedOopsMaxHeapSize", CC"()J",
(void*)&WB_GetCompressedOopsMaxHeapSize},
{CC"printHeapSizes", CC"()V", (void*)&WB_PrintHeapSizes },
{CC"runMemoryUnitTests", CC"()V", (void*)&WB_RunMemoryUnitTests},
{CC"readFromNoaccessArea",CC"()V", (void*)&WB_ReadFromNoaccessArea},
{CC"stressVirtualSpaceResize",CC"(JJJ)I", (void*)&WB_StressVirtualSpaceResize},
{CC"isSharedClass", CC"(Ljava/lang/Class;)Z", (void*)&WB_IsSharedClass },
#if INCLUDE_ALL_GCS
{CC"g1InConcurrentMark", CC"()Z", (void*)&WB_G1InConcurrentMark},
{CC"g1IsHumongous", CC"(Ljava/lang/Object;)Z", (void*)&WB_G1IsHumongous },
{CC"g1NumMaxRegions", CC"()J", (void*)&WB_G1NumMaxRegions },
{CC"g1NumFreeRegions", CC"()J", (void*)&WB_G1NumFreeRegions },
{CC"g1RegionSize", CC"()I", (void*)&WB_G1RegionSize },
{CC"g1StartConcMarkCycle", CC"()Z", (void*)&WB_G1StartMarkCycle },
{CC"g1AuxiliaryMemoryUsage", CC"()Ljava/lang/management/MemoryUsage;",
(void*)&WB_G1AuxiliaryMemoryUsage },
#endif // INCLUDE_ALL_GCS
#if INCLUDE_NMT
{CC"NMTMalloc", CC"(J)J", (void*)&WB_NMTMalloc },
{CC"NMTMallocWithPseudoStack", CC"(JI)J", (void*)&WB_NMTMallocWithPseudoStack},
{CC"NMTMallocWithPseudoStackAndType", CC"(JII)J", (void*)&WB_NMTMallocWithPseudoStackAndType},
{CC"NMTFree", CC"(J)V", (void*)&WB_NMTFree },
{CC"NMTReserveMemory", CC"(J)J", (void*)&WB_NMTReserveMemory },
{CC"NMTCommitMemory", CC"(JJ)V", (void*)&WB_NMTCommitMemory },
{CC"NMTUncommitMemory", CC"(JJ)V", (void*)&WB_NMTUncommitMemory },
{CC"NMTReleaseMemory", CC"(JJ)V", (void*)&WB_NMTReleaseMemory },
{CC"NMTIsDetailSupported",CC"()Z", (void*)&WB_NMTIsDetailSupported},
{CC"NMTChangeTrackingLevel", CC"()Z", (void*)&WB_NMTChangeTrackingLevel},
{CC"NMTGetHashSize", CC"()I", (void*)&WB_NMTGetHashSize },
{CC"NMTNewArena", CC"(J)J", (void*)&WB_NMTNewArena },
{CC"NMTFreeArena", CC"(J)V", (void*)&WB_NMTFreeArena },
{CC"NMTArenaMalloc", CC"(JJ)V", (void*)&WB_NMTArenaMalloc },
#endif // INCLUDE_NMT
{CC"deoptimizeAll", CC"()V", (void*)&WB_DeoptimizeAll },
{CC"deoptimizeMethod", CC"(Ljava/lang/reflect/Executable;Z)I",
(void*)&WB_DeoptimizeMethod },
{CC"isMethodCompiled", CC"(Ljava/lang/reflect/Executable;Z)Z",
(void*)&WB_IsMethodCompiled },
{CC"isMethodCompilable", CC"(Ljava/lang/reflect/Executable;IZ)Z",
(void*)&WB_IsMethodCompilable},
{CC"isMethodQueuedForCompilation",
CC"(Ljava/lang/reflect/Executable;)Z", (void*)&WB_IsMethodQueuedForCompilation},
{CC"makeMethodNotCompilable",
CC"(Ljava/lang/reflect/Executable;IZ)V", (void*)&WB_MakeMethodNotCompilable},
{CC"testSetDontInlineMethod",
CC"(Ljava/lang/reflect/Executable;Z)Z", (void*)&WB_TestSetDontInlineMethod},
{CC"getMethodCompilationLevel",
CC"(Ljava/lang/reflect/Executable;Z)I", (void*)&WB_GetMethodCompilationLevel},
{CC"getMethodEntryBci",
CC"(Ljava/lang/reflect/Executable;)I", (void*)&WB_GetMethodEntryBci},
{CC"getCompileQueueSize",
CC"(I)I", (void*)&WB_GetCompileQueueSize},
{CC"testSetForceInlineMethod",
CC"(Ljava/lang/reflect/Executable;Z)Z", (void*)&WB_TestSetForceInlineMethod},
{CC"enqueueMethodForCompilation0",
CC"(Ljava/lang/reflect/Executable;II)Z", (void*)&WB_EnqueueMethodForCompilation},
{CC"enqueueInitializerForCompilation0",
CC"(Ljava/lang/Class;I)Z", (void*)&WB_EnqueueInitializerForCompilation},
{CC"clearMethodState",
CC"(Ljava/lang/reflect/Executable;)V", (void*)&WB_ClearMethodState},
{CC"markMethodProfiled",
CC"(Ljava/lang/reflect/Executable;)V", (void*)&WB_MarkMethodProfiled},
{CC"setBooleanVMFlag", CC"(Ljava/lang/String;Z)V",(void*)&WB_SetBooleanVMFlag},
{CC"setIntxVMFlag", CC"(Ljava/lang/String;J)V",(void*)&WB_SetIntxVMFlag},
{CC"setUintxVMFlag", CC"(Ljava/lang/String;J)V",(void*)&WB_SetUintxVMFlag},
{CC"setUint64VMFlag", CC"(Ljava/lang/String;J)V",(void*)&WB_SetUint64VMFlag},
{CC"setDoubleVMFlag", CC"(Ljava/lang/String;D)V",(void*)&WB_SetDoubleVMFlag},
{CC"setStringVMFlag", CC"(Ljava/lang/String;Ljava/lang/String;)V",
(void*)&WB_SetStringVMFlag},
{CC"getBooleanVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Boolean;",
(void*)&WB_GetBooleanVMFlag},
{CC"getIntxVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Long;",
(void*)&WB_GetIntxVMFlag},
{CC"getUintxVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Long;",
(void*)&WB_GetUintxVMFlag},
{CC"getUint64VMFlag", CC"(Ljava/lang/String;)Ljava/lang/Long;",
(void*)&WB_GetUint64VMFlag},
{CC"getDoubleVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Double;",
(void*)&WB_GetDoubleVMFlag},
{CC"getStringVMFlag", CC"(Ljava/lang/String;)Ljava/lang/String;",
(void*)&WB_GetStringVMFlag},
{CC"isInStringTable", CC"(Ljava/lang/String;)Z", (void*)&WB_IsInStringTable },
{CC"fullGC", CC"()V", (void*)&WB_FullGC },
{CC"youngGC", CC"()V", (void*)&WB_YoungGC },
{CC"readReservedMemory", CC"()V", (void*)&WB_ReadReservedMemory },
{CC"allocateCodeBlob", CC"(II)J", (void*)&WB_AllocateCodeBlob },
{CC"freeCodeBlob", CC"(J)V", (void*)&WB_FreeCodeBlob },
{CC"getCodeBlob", CC"(J)[Ljava/lang/Object;",(void*)&WB_GetCodeBlob },
{CC"allocateMetaspace",
CC"(Ljava/lang/ClassLoader;J)J", (void*)&WB_AllocateMetaspace },
{CC"freeMetaspace",
CC"(Ljava/lang/ClassLoader;JJ)V", (void*)&WB_FreeMetaspace },
{CC"incMetaspaceCapacityUntilGC", CC"(J)J", (void*)&WB_IncMetaspaceCapacityUntilGC },
{CC"metaspaceCapacityUntilGC", CC"()J", (void*)&WB_MetaspaceCapacityUntilGC },
{CC"getCPUFeatures", CC"()Ljava/lang/String;", (void*)&WB_GetCPUFeatures },
{CC"getNMethod", CC"(Ljava/lang/reflect/Executable;Z)[Ljava/lang/Object;",
(void*)&WB_GetNMethod },
{CC"isMonitorInflated", CC"(Ljava/lang/Object;)Z", (void*)&WB_IsMonitorInflated },
{CC"forceSafepoint", CC"()V", (void*)&WB_ForceSafepoint },
{CC"checkLibSpecifiesNoexecstack", CC"(Ljava/lang/String;)Z",
(void*)&WB_CheckLibSpecifiesNoexecstack},
{CC"isContainerized", CC"()Z", (void*)&WB_IsContainerized },
{CC"printOsInfo", CC"()V", (void*)&WB_PrintOsInfo },
};
#undef CC
JVM_ENTRY(void, JVM_RegisterWhiteBoxMethods(JNIEnv* env, jclass wbclass))
{
if (WhiteBoxAPI) {
instanceKlassHandle ikh = instanceKlassHandle(JNIHandles::resolve(wbclass)->klass());
Handle loader(ikh->class_loader());
if (loader.is_null()) {
WhiteBox::register_methods(env, wbclass, thread, methods, sizeof(methods) / sizeof(methods[0]));
WhiteBox::register_extended(env, wbclass, thread);
WhiteBox::set_used();
}
}
}
JVM_END
C:\hotspot-69087d08d473\src\share\vm/prims/whitebox.hpp
#ifndef SHARE_VM_PRIMS_WHITEBOX_HPP
#define SHARE_VM_PRIMS_WHITEBOX_HPP
#include "prims/jni.h"
#include "memory/allocation.hpp"
#include "oops/oopsHierarchy.hpp"
#include "oops/symbol.hpp"
#include "runtime/interfaceSupport.hpp"
#define WB_ENTRY(result_type, header) JNI_ENTRY(result_type, header)
#define WB_END JNI_END
#define WB_METHOD_DECLARE(result_type) extern "C" result_type JNICALL
#define CHECK_JNI_EXCEPTION_(env, value) \
do { \
JavaThread* THREAD = JavaThread::thread_from_jni_environment(env); \
if (HAS_PENDING_EXCEPTION) { \
return(value); \
} \
} while (0)
#define CHECK_JNI_EXCEPTION(env) \
do { \
JavaThread* THREAD = JavaThread::thread_from_jni_environment(env); \
if (HAS_PENDING_EXCEPTION) { \
return; \
} \
} while (0)
class WhiteBox : public AllStatic {
private:
static bool _used;
public:
static bool used() { return _used; }
static void set_used() { _used = true; }
static int offset_for_field(const char* field_name, oop object,
Symbol* signature_symbol);
static const char* lookup_jstring(const char* field_name, oop object);
static bool lookup_bool(const char* field_name, oop object);
static int get_blob_type(const CodeBlob* code);
static CodeBlob* allocate_code_blob(int size, int blob_type);
static int array_bytes_to_length(size_t bytes);
static void register_methods(JNIEnv* env, jclass wbclass, JavaThread* thread,
JNINativeMethod* method_array, int method_count);
static void register_extended(JNIEnv* env, jclass wbclass, JavaThread* thread);
static bool compile_method(Method* method, int comp_level, int bci, Thread* THREAD);
};
#endif // SHARE_VM_PRIMS_WHITEBOX_HPP
C:\hotspot-69087d08d473\src\share\vm/prims/whitebox_ext.cpp
#include "precompiled.hpp"
#include "prims/whitebox.hpp"
void WhiteBox::register_extended(JNIEnv* env, jclass wbclass, JavaThread* thread) { }
C:\hotspot-69087d08d473\src\share\vm/runtime/advancedThresholdPolicy.cpp
#include "precompiled.hpp"
#include "runtime/advancedThresholdPolicy.hpp"
#include "runtime/simpleThresholdPolicy.inline.hpp"
#ifdef TIERED
void AdvancedThresholdPolicy::print_specific(EventType type, methodHandle mh, methodHandle imh,
int bci, CompLevel level) {
tty->print(" rate=");
if (mh->prev_time() == 0) tty->print("n/a");
else tty->print("%f", mh->rate());
tty->print(" k=%.2lf,%.2lf", threshold_scale(CompLevel_full_profile, Tier3LoadFeedback),
threshold_scale(CompLevel_full_optimization, Tier4LoadFeedback));
}
void AdvancedThresholdPolicy::initialize() {
if (FLAG_IS_DEFAULT(CICompilerCountPerCPU) && FLAG_IS_DEFAULT(CICompilerCount)) {
FLAG_SET_DEFAULT(CICompilerCountPerCPU, true);
}
int count = CICompilerCount;
if (CICompilerCountPerCPU) {
int log_cpu = log2_int(os::active_processor_count());
int loglog_cpu = log2_int(MAX2(log_cpu, 1));
count = MAX2(log_cpu * loglog_cpu, 1) * 3 / 2;
}
set_c1_count(MAX2(count / 3, 1));
set_c2_count(MAX2(count - c1_count(), 1));
FLAG_SET_ERGO(intx, CICompilerCount, c1_count() + c2_count());
#if defined(X86) || defined(AARCH64)
if (FLAG_IS_DEFAULT(InlineSmallCode)) {
FLAG_SET_DEFAULT(InlineSmallCode, 2000);
}
#endif
#ifdef SPARC
if (FLAG_IS_DEFAULT(InlineSmallCode)) {
FLAG_SET_DEFAULT(InlineSmallCode, 2500);
}
#endif
set_increase_threshold_at_ratio();
set_start_time(os::javaTimeMillis());
}
void AdvancedThresholdPolicy::update_rate(jlong t, Method* m) {
if (m->method_counters() == NULL) return;
if (is_old(m)) {
m->set_rate(0);
return;
}
jlong delta_s = t - SafepointSynchronize::end_of_last_safepoint();
jlong delta_t = t - (m->prev_time() != 0 ? m->prev_time() : start_time()); // milliseconds since the last measurement
int event_count = m->invocation_count() + m->backedge_count();
int delta_e = event_count - m->prev_event_count();
if (delta_s >= TieredRateUpdateMinTime) {
if (delta_t >= TieredRateUpdateMinTime && delta_e > 0) {
m->set_prev_time(t);
m->set_prev_event_count(event_count);
m->set_rate((float)delta_e / (float)delta_t); // Rate is events per millisecond
} else {
if (delta_t > TieredRateUpdateMaxTime && delta_e == 0) {
m->set_rate(0);
}
}
}
}
bool AdvancedThresholdPolicy::is_stale(jlong t, jlong timeout, Method* m) {
jlong delta_s = t - SafepointSynchronize::end_of_last_safepoint();
jlong delta_t = t - m->prev_time();
if (delta_t > timeout && delta_s > timeout) {
int event_count = m->invocation_count() + m->backedge_count();
int delta_e = event_count - m->prev_event_count();
return delta_e == 0;
}
return false;
}
bool AdvancedThresholdPolicy::is_old(Method* method) {
return method->invocation_count() > 50000 || method->backedge_count() > 500000;
}
double AdvancedThresholdPolicy::weight(Method* method) {
return (double)(method->rate() + 1) *
(method->invocation_count() + 1) * (method->backedge_count() + 1);
}
bool AdvancedThresholdPolicy::compare_methods(Method* x, Method* y) {
if (x->highest_comp_level() > y->highest_comp_level()) {
return true;
} else
if (x->highest_comp_level() == y->highest_comp_level()) {
if (weight(x) > weight(y)) {
return true;
}
}
return false;
}
bool AdvancedThresholdPolicy::is_method_profiled(Method* method) {
MethodData* mdo = method->method_data();
if (mdo != NULL) {
int i = mdo->invocation_count_delta();
int b = mdo->backedge_count_delta();
return call_predicate_helper<CompLevel_full_profile>(i, b, 1);
}
return false;
}
CompileTask* AdvancedThresholdPolicy::select_task(CompileQueue* compile_queue) {
CompileTask *max_task = NULL;
Method* max_method = NULL;
jlong t = os::javaTimeMillis();
for (CompileTask* task = compile_queue->first(); task != NULL;) {
CompileTask* next_task = task->next();
Method* method = task->method();
update_rate(t, method);
if (max_task == NULL) {
max_task = task;
max_method = method;
} else {
if (is_stale(t, TieredCompileTaskTimeout, method) && !is_old(method)) {
if (PrintTieredEvents) {
print_event(REMOVE_FROM_QUEUE, method, method, task->osr_bci(), (CompLevel)task->comp_level());
}
compile_queue->remove_and_mark_stale(task);
method->clear_queued_for_compilation();
task = next_task;
continue;
}
if (compare_methods(method, max_method)) {
max_task = task;
max_method = method;
}
}
task = next_task;
}
if (max_task->comp_level() == CompLevel_full_profile && TieredStopAtLevel > CompLevel_full_profile
&& is_method_profiled(max_method)) {
if (CompileBroker::compilation_is_complete(max_method, max_task->osr_bci(), CompLevel_limited_profile)) {
if (PrintTieredEvents) {
print_event(REMOVE_FROM_QUEUE, max_method, max_method, max_task->osr_bci(), (CompLevel)max_task->comp_level());
}
compile_queue->remove_and_mark_stale(max_task);
max_method->clear_queued_for_compilation();
return NULL;
}
max_task->set_comp_level(CompLevel_limited_profile);
if (PrintTieredEvents) {
print_event(UPDATE_IN_QUEUE, max_method, max_method, max_task->osr_bci(), (CompLevel)max_task->comp_level());
}
}
return max_task;
}
double AdvancedThresholdPolicy::threshold_scale(CompLevel level, int feedback_k) {
double queue_size = CompileBroker::queue_size(level);
int comp_count = compiler_count(level);
double k = queue_size / (feedback_k * comp_count) + 1;
if ((TieredStopAtLevel == CompLevel_full_optimization) && (level != CompLevel_full_optimization)) {
double current_reverse_free_ratio = CodeCache::reverse_free_ratio();
if (current_reverse_free_ratio > _increase_threshold_at_ratio) {
k *= exp(current_reverse_free_ratio - _increase_threshold_at_ratio);
}
}
return k;
}
bool AdvancedThresholdPolicy::loop_predicate(int i, int b, CompLevel cur_level) {
switch(cur_level) {
case CompLevel_none:
case CompLevel_limited_profile: {
double k = threshold_scale(CompLevel_full_profile, Tier3LoadFeedback);
return loop_predicate_helper<CompLevel_none>(i, b, k);
}
case CompLevel_full_profile: {
double k = threshold_scale(CompLevel_full_optimization, Tier4LoadFeedback);
return loop_predicate_helper<CompLevel_full_profile>(i, b, k);
}
default:
return true;
}
}
bool AdvancedThresholdPolicy::call_predicate(int i, int b, CompLevel cur_level) {
switch(cur_level) {
case CompLevel_none:
case CompLevel_limited_profile: {
double k = threshold_scale(CompLevel_full_profile, Tier3LoadFeedback);
return call_predicate_helper<CompLevel_none>(i, b, k);
}
case CompLevel_full_profile: {
double k = threshold_scale(CompLevel_full_optimization, Tier4LoadFeedback);
return call_predicate_helper<CompLevel_full_profile>(i, b, k);
}
default:
return true;
}
}
bool AdvancedThresholdPolicy::should_create_mdo(Method* method, CompLevel cur_level) {
if (cur_level == CompLevel_none &&
CompileBroker::queue_size(CompLevel_full_optimization) <=
Tier3DelayOn * compiler_count(CompLevel_full_optimization)) {
int i = method->invocation_count();
int b = method->backedge_count();
double k = Tier0ProfilingStartPercentage / 100.0;
return call_predicate_helper<CompLevel_none>(i, b, k) || loop_predicate_helper<CompLevel_none>(i, b, k);
}
return false;
}
bool AdvancedThresholdPolicy::should_not_inline(ciEnv* env, ciMethod* callee) {
CompLevel comp_level = (CompLevel)env->comp_level();
if (comp_level == CompLevel_full_profile ||
comp_level == CompLevel_limited_profile) {
return callee->highest_osr_comp_level() == CompLevel_full_optimization;
}
return false;
}
void AdvancedThresholdPolicy::create_mdo(methodHandle mh, JavaThread* THREAD) {
if (mh->is_native() || mh->is_abstract() || mh->is_accessor()) return;
if (mh->method_data() == NULL) {
Method::build_interpreter_method_data(mh, CHECK_AND_CLEAR);
}
}
CompLevel AdvancedThresholdPolicy::common(Predicate p, Method* method, CompLevel cur_level, bool disable_feedback) {
CompLevel next_level = cur_level;
int i = method->invocation_count();
int b = method->backedge_count();
if (is_trivial(method)) {
next_level = CompLevel_simple;
} else {
switch(cur_level) {
case CompLevel_none:
if (common(p, method, CompLevel_full_profile, disable_feedback) == CompLevel_full_optimization) {
next_level = CompLevel_full_optimization;
} else if ((this->*p)(i, b, cur_level)) {
if (!disable_feedback && CompileBroker::queue_size(CompLevel_full_optimization) >
Tier3DelayOn * compiler_count(CompLevel_full_optimization)) {
next_level = CompLevel_limited_profile;
} else {
next_level = CompLevel_full_profile;
}
}
break;
case CompLevel_limited_profile:
if (is_method_profiled(method)) {
next_level = CompLevel_full_optimization;
} else {
MethodData* mdo = method->method_data();
if (mdo != NULL) {
if (mdo->would_profile()) {
if (disable_feedback || (CompileBroker::queue_size(CompLevel_full_optimization) <=
Tier3DelayOff * compiler_count(CompLevel_full_optimization) &&
(this->*p)(i, b, cur_level))) {
next_level = CompLevel_full_profile;
}
} else {
next_level = CompLevel_full_optimization;
}
}
}
break;
case CompLevel_full_profile:
{
MethodData* mdo = method->method_data();
if (mdo != NULL) {
if (mdo->would_profile()) {
int mdo_i = mdo->invocation_count_delta();
int mdo_b = mdo->backedge_count_delta();
if ((this->*p)(mdo_i, mdo_b, cur_level)) {
next_level = CompLevel_full_optimization;
}
} else {
next_level = CompLevel_full_optimization;
}
}
}
break;
}
}
return MIN2(next_level, (CompLevel)TieredStopAtLevel);
}
CompLevel AdvancedThresholdPolicy::call_event(Method* method, CompLevel cur_level) {
CompLevel osr_level = MIN2((CompLevel) method->highest_osr_comp_level(),
common(&AdvancedThresholdPolicy::loop_predicate, method, cur_level, true));
CompLevel next_level = common(&AdvancedThresholdPolicy::call_predicate, method, cur_level);
if (osr_level == CompLevel_full_optimization && cur_level == CompLevel_full_profile) {
MethodData* mdo = method->method_data();
guarantee(mdo != NULL, "MDO should not be NULL");
if (mdo->invocation_count() >= 1) {
next_level = CompLevel_full_optimization;
}
} else {
next_level = MAX2(osr_level, next_level);
}
return next_level;
}
CompLevel AdvancedThresholdPolicy::loop_event(Method* method, CompLevel cur_level) {
CompLevel next_level = common(&AdvancedThresholdPolicy::loop_predicate, method, cur_level, true);
if (cur_level == CompLevel_none) {
CompLevel osr_level = MIN2((CompLevel)method->highest_osr_comp_level(), next_level);
if (osr_level > CompLevel_none) {
return osr_level;
}
}
return next_level;
}
void AdvancedThresholdPolicy::submit_compile(methodHandle mh, int bci, CompLevel level, JavaThread* thread) {
int hot_count = (bci == InvocationEntryBci) ? mh->invocation_count() : mh->backedge_count();
update_rate(os::javaTimeMillis(), mh());
CompileBroker::compile_method(mh, bci, level, mh, hot_count, "tiered", thread);
}
void AdvancedThresholdPolicy::method_invocation_event(methodHandle mh, methodHandle imh,
CompLevel level, nmethod* nm, JavaThread* thread) {
if (should_create_mdo(mh(), level)) {
create_mdo(mh, thread);
}
if (is_compilation_enabled() && !CompileBroker::compilation_is_in_queue(mh)) {
CompLevel next_level = call_event(mh(), level);
if (next_level != level) {
compile(mh, InvocationEntryBci, next_level, thread);
}
}
}
void AdvancedThresholdPolicy::method_back_branch_event(methodHandle mh, methodHandle imh,
int bci, CompLevel level, nmethod* nm, JavaThread* thread) {
if (should_create_mdo(mh(), level)) {
create_mdo(mh, thread);
}
if (should_create_mdo(imh(), level)) {
create_mdo(imh, thread);
}
if (is_compilation_enabled()) {
CompLevel next_osr_level = loop_event(imh(), level);
CompLevel max_osr_level = (CompLevel)imh->highest_osr_comp_level();
if (!CompileBroker::compilation_is_in_queue(imh) && (next_osr_level != level)) {
compile(imh, bci, next_osr_level, thread);
}
CompLevel cur_level, next_level;
if (mh() != imh()) { // If there is an enclosing method
guarantee(nm != NULL, "Should have nmethod here");
cur_level = comp_level(mh());
next_level = call_event(mh(), cur_level);
if (max_osr_level == CompLevel_full_optimization) {
bool make_not_entrant = false;
if (nm->is_osr_method()) {
make_not_entrant = true;
} else {
if (next_level != CompLevel_full_optimization) {
cur_level = CompLevel_none;
make_not_entrant = true;
}
}
if (make_not_entrant) {
if (PrintTieredEvents) {
int osr_bci = nm->is_osr_method() ? nm->osr_entry_bci() : InvocationEntryBci;
print_event(MAKE_NOT_ENTRANT, mh(), mh(), osr_bci, level);
}
nm->make_not_entrant();
}
}
if (!CompileBroker::compilation_is_in_queue(mh)) {
if (next_level == CompLevel_limited_profile && max_osr_level == CompLevel_full_profile) {
next_level = CompLevel_full_profile;
}
if (cur_level != next_level) {
compile(mh, InvocationEntryBci, next_level, thread);
}
}
} else {
cur_level = comp_level(imh());
next_level = call_event(imh(), cur_level);
if (!CompileBroker::compilation_is_in_queue(imh) && (next_level != cur_level)) {
compile(imh, InvocationEntryBci, next_level, thread);
}
}
}
}
#endif // TIERED
C:\hotspot-69087d08d473\src\share\vm/runtime/advancedThresholdPolicy.hpp
#ifndef SHARE_VM_RUNTIME_ADVANCEDTHRESHOLDPOLICY_HPP
#define SHARE_VM_RUNTIME_ADVANCEDTHRESHOLDPOLICY_HPP
#include "runtime/simpleThresholdPolicy.hpp"
#ifdef TIERED
class CompileTask;
class CompileQueue;
class AdvancedThresholdPolicy : public SimpleThresholdPolicy {
jlong _start_time;
typedef bool (AdvancedThresholdPolicy::*Predicate)(int i, int b, CompLevel cur_level);
bool call_predicate(int i, int b, CompLevel cur_level);
bool loop_predicate(int i, int b, CompLevel cur_level);
CompLevel common(Predicate p, Method* method, CompLevel cur_level, bool disable_feedback = false);
CompLevel call_event(Method* method, CompLevel cur_level);
CompLevel loop_event(Method* method, CompLevel cur_level);
inline bool is_old(Method* method);
inline bool is_stale(jlong t, jlong timeout, Method* m);
inline double weight(Method* method);
inline bool compare_methods(Method* x, Method* y);
inline void update_rate(jlong t, Method* m);
inline double threshold_scale(CompLevel level, int feedback_k);
inline bool should_create_mdo(Method* method, CompLevel cur_level);
void create_mdo(methodHandle mh, JavaThread* thread);
bool is_method_profiled(Method* method);
double _increase_threshold_at_ratio;
protected:
void print_specific(EventType type, methodHandle mh, methodHandle imh, int bci, CompLevel level);
void set_increase_threshold_at_ratio() { _increase_threshold_at_ratio = 100 / (100 - (double)IncreaseFirstTierCompileThresholdAt); }
void set_start_time(jlong t) { _start_time = t; }
jlong start_time() const { return _start_time; }
virtual void submit_compile(methodHandle mh, int bci, CompLevel level, JavaThread* thread);
virtual void method_invocation_event(methodHandle method, methodHandle inlinee,
CompLevel level, nmethod* nm, JavaThread* thread);
virtual void method_back_branch_event(methodHandle method, methodHandle inlinee,
int bci, CompLevel level, nmethod* nm, JavaThread* thread);
public:
AdvancedThresholdPolicy() : _start_time(0) { }
virtual CompileTask* select_task(CompileQueue* compile_queue);
virtual void initialize();
virtual bool should_not_inline(ciEnv* env, ciMethod* callee);
};
#endif // TIERED
#endif // SHARE_VM_RUNTIME_ADVANCEDTHRESHOLDPOLICY_HPP
C:\hotspot-69087d08d473\src\share\vm/runtime/arguments.cpp
#include "precompiled.hpp"
#include "classfile/classLoader.hpp"
#include "classfile/javaAssertions.hpp"
#include "classfile/symbolTable.hpp"
#include "compiler/compilerOracle.hpp"
#include "memory/allocation.inline.hpp"
#include "memory/cardTableRS.hpp"
#include "memory/genCollectedHeap.hpp"
#include "memory/referenceProcessor.hpp"
#include "memory/universe.inline.hpp"
#include "oops/oop.inline.hpp"
#include "prims/jvmtiExport.hpp"
#include "runtime/arguments.hpp"
#include "runtime/arguments_ext.hpp"
#include "runtime/globals_extension.hpp"
#include "runtime/java.hpp"
#include "services/management.hpp"
#include "services/memTracker.hpp"
#include "utilities/defaultStream.hpp"
#include "utilities/macros.hpp"
#include "utilities/stringUtils.hpp"
#include "utilities/taskqueue.hpp"
#if INCLUDE_JFR
#include "jfr/jfr.hpp"
#endif
#ifdef TARGET_OS_FAMILY_linux
# include "os_linux.inline.hpp"
#endif
#ifdef TARGET_OS_FAMILY_solaris
# include "os_solaris.inline.hpp"
#endif
#ifdef TARGET_OS_FAMILY_windows
# include "os_windows.inline.hpp"
#endif
#ifdef TARGET_OS_FAMILY_aix
# include "os_aix.inline.hpp"
#endif
#ifdef TARGET_OS_FAMILY_bsd
# include "os_bsd.inline.hpp"
#endif
#if INCLUDE_ALL_GCS
#include "gc_implementation/concurrentMarkSweep/compactibleFreeListSpace.hpp"
#include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
#include "gc_implementation/parallelScavenge/parallelScavengeHeap.hpp"
#endif // INCLUDE_ALL_GCS
#ifdef VENDOR_URL_VM_BUG
# define DEFAULT_VENDOR_URL_BUG VENDOR_URL_VM_BUG
#else
# define DEFAULT_VENDOR_URL_BUG "http://bugreport.java.com/bugreport/crash.jsp"
#endif
#define DEFAULT_JAVA_LAUNCHER "generic"
#define UNSUPPORTED_OPTION(opt, description) \
do { \
if (opt) { \
if (FLAG_IS_CMDLINE(opt)) { \
warning(description " is disabled in this release."); \
} \
FLAG_SET_DEFAULT(opt, false); \
} \
} while(0)
#define UNSUPPORTED_GC_OPTION(gc) \
do { \
if (gc) { \
if (FLAG_IS_CMDLINE(gc)) { \
warning(#gc " is not supported in this VM. Using Serial GC."); \
} \
FLAG_SET_DEFAULT(gc, false); \
} \
} while(0)
char** Arguments::_jvm_flags_array = NULL;
int Arguments::_num_jvm_flags = 0;
char** Arguments::_jvm_args_array = NULL;
int Arguments::_num_jvm_args = 0;
char* Arguments::_java_command = NULL;
SystemProperty* Arguments::_system_properties = NULL;
const char* Arguments::_gc_log_filename = NULL;
bool Arguments::_has_profile = false;
size_t Arguments::_conservative_max_heap_alignment = 0;
uintx Arguments::_min_heap_size = 0;
uintx Arguments::_min_heap_free_ratio = 0;
uintx Arguments::_max_heap_free_ratio = 0;
Arguments::Mode Arguments::_mode = _mixed;
bool Arguments::_java_compiler = false;
bool Arguments::_xdebug_mode = false;
const char* Arguments::_java_vendor_url_bug = DEFAULT_VENDOR_URL_BUG;
const char* Arguments::_sun_java_launcher = DEFAULT_JAVA_LAUNCHER;
int Arguments::_sun_java_launcher_pid = -1;
bool Arguments::_created_by_gamma_launcher = false;
bool Arguments::_AlwaysCompileLoopMethods = AlwaysCompileLoopMethods;
bool Arguments::_UseOnStackReplacement = UseOnStackReplacement;
bool Arguments::_BackgroundCompilation = BackgroundCompilation;
bool Arguments::_ClipInlining = ClipInlining;
char* Arguments::SharedArchivePath = NULL;
AgentLibraryList Arguments::_libraryList;
AgentLibraryList Arguments::_agentList;
abort_hook_t Arguments::_abort_hook = NULL;
exit_hook_t Arguments::_exit_hook = NULL;
vfprintf_hook_t Arguments::_vfprintf_hook = NULL;
SystemProperty *Arguments::_java_ext_dirs = NULL;
SystemProperty *Arguments::_java_endorsed_dirs = NULL;
SystemProperty *Arguments::_sun_boot_library_path = NULL;
SystemProperty *Arguments::_java_library_path = NULL;
SystemProperty *Arguments::_java_home = NULL;
SystemProperty *Arguments::_java_class_path = NULL;
SystemProperty *Arguments::_sun_boot_class_path = NULL;
char* Arguments::_meta_index_path = NULL;
char* Arguments::_meta_index_dir = NULL;
static bool match_option(const JavaVMOption *option, const char* name,
const char** tail) {
int len = (int)strlen(name);
if (strncmp(option->optionString, name, len) == 0) {
return true;
} else {
return false;
}
}
#if INCLUDE_JFR
static bool match_jfr_option(const JavaVMOption** option) {
assert((*option)->optionString != NULL, "invariant");
char* tail = NULL;
if (match_option(*option, "-XX:StartFlightRecording", (const char**)&tail)) {
return Jfr::on_start_flight_recording_option(option, tail);
} else if (match_option(*option, "-XX:FlightRecorderOptions", (const char**)&tail)) {
return Jfr::on_flight_recorder_option(option, tail);
}
return false;
}
#endif
static void logOption(const char* opt) {
if (PrintVMOptions) {
jio_fprintf(defaultStream::output_stream(), "VM option '%s'\n", opt);
}
}
void Arguments::process_sun_java_launcher_properties(JavaVMInitArgs* args) {
for (int index = 0; index < args->nOptions; index++) {
const JavaVMOption* option = args->options + index;
const char* tail;
if (match_option(option, "-Dsun.java.launcher=", &tail)) {
process_java_launcher_argument(tail, option->extraInfo);
continue;
}
if (match_option(option, "-Dsun.java.launcher.pid=", &tail)) {
_sun_java_launcher_pid = atoi(tail);
continue;
}
}
}
void Arguments::init_system_properties() {
PropertyList_add(&_system_properties, new SystemProperty("java.vm.specification.name",
"Java Virtual Machine Specification", false));
PropertyList_add(&_system_properties, new SystemProperty("java.vm.version", VM_Version::vm_release(), false));
PropertyList_add(&_system_properties, new SystemProperty("java.vm.name", VM_Version::vm_name(), false));
PropertyList_add(&_system_properties, new SystemProperty("java.vm.info", VM_Version::vm_info_string(), true));
_java_ext_dirs = new SystemProperty("java.ext.dirs", NULL, true);
_java_endorsed_dirs = new SystemProperty("java.endorsed.dirs", NULL, true);
_sun_boot_library_path = new SystemProperty("sun.boot.library.path", NULL, true);
_java_library_path = new SystemProperty("java.library.path", NULL, true);
_java_home = new SystemProperty("java.home", NULL, true);
_sun_boot_class_path = new SystemProperty("sun.boot.class.path", NULL, true);
_java_class_path = new SystemProperty("java.class.path", "", true);
PropertyList_add(&_system_properties, _java_ext_dirs);
PropertyList_add(&_system_properties, _java_endorsed_dirs);
PropertyList_add(&_system_properties, _sun_boot_library_path);
PropertyList_add(&_system_properties, _java_library_path);
PropertyList_add(&_system_properties, _java_home);
PropertyList_add(&_system_properties, _java_class_path);
PropertyList_add(&_system_properties, _sun_boot_class_path);
os::init_system_properties_values();
}
void Arguments::init_version_specific_system_properties() {
enum { bufsz = 16 };
char buffer[bufsz];
const char* spec_vendor = "Sun Microsystems Inc.";
uint32_t spec_version = 0;
if (JDK_Version::is_gte_jdk17x_version()) {
spec_vendor = "Oracle Corporation";
spec_version = JDK_Version::current().major_version();
}
jio_snprintf(buffer, bufsz, "1." UINT32_FORMAT, spec_version);
PropertyList_add(&_system_properties,
new SystemProperty("java.vm.specification.vendor", spec_vendor, false));
PropertyList_add(&_system_properties,
new SystemProperty("java.vm.specification.version", buffer, false));
PropertyList_add(&_system_properties,
new SystemProperty("java.vm.vendor", VM_Version::vm_vendor(), false));
}
typedef struct {
const char* name;
JDK_Version obsoleted_in; // when the flag went away
JDK_Version accept_until; // which version to start denying the existence
} ObsoleteFlag;
static ObsoleteFlag obsolete_jvm_flags[] = {
{ "UseTrainGC", JDK_Version::jdk(5), JDK_Version::jdk(7) },
{ "UseSpecialLargeObjectHandling", JDK_Version::jdk(5), JDK_Version::jdk(7) },
{ "UseOversizedCarHandling", JDK_Version::jdk(5), JDK_Version::jdk(7) },
{ "TraceCarAllocation", JDK_Version::jdk(5), JDK_Version::jdk(7) },
{ "PrintTrainGCProcessingStats", JDK_Version::jdk(5), JDK_Version::jdk(7) },
{ "LogOfCarSpaceSize", JDK_Version::jdk(5), JDK_Version::jdk(7) },
{ "OversizedCarThreshold", JDK_Version::jdk(5), JDK_Version::jdk(7) },
{ "MinTickInterval", JDK_Version::jdk(5), JDK_Version::jdk(7) },
{ "DefaultTickInterval", JDK_Version::jdk(5), JDK_Version::jdk(7) },
{ "MaxTickInterval", JDK_Version::jdk(5), JDK_Version::jdk(7) },
{ "DelayTickAdjustment", JDK_Version::jdk(5), JDK_Version::jdk(7) },
{ "ProcessingToTenuringRatio", JDK_Version::jdk(5), JDK_Version::jdk(7) },
{ "MinTrainLength", JDK_Version::jdk(5), JDK_Version::jdk(7) },
{ "AppendRatio", JDK_Version::jdk_update(6,10), JDK_Version::jdk(7) },
{ "DefaultMaxRAM", JDK_Version::jdk_update(6,18), JDK_Version::jdk(7) },
{ "DefaultInitialRAMFraction",
JDK_Version::jdk_update(6,18), JDK_Version::jdk(7) },
{ "UseDepthFirstScavengeOrder",
JDK_Version::jdk_update(6,22), JDK_Version::jdk(7) },
{ "HandlePromotionFailure",
JDK_Version::jdk_update(6,24), JDK_Version::jdk(8) },
{ "MaxLiveObjectEvacuationRatio",
JDK_Version::jdk_update(6,24), JDK_Version::jdk(8) },
{ "ForceSharedSpaces", JDK_Version::jdk_update(6,25), JDK_Version::jdk(8) },
{ "UseParallelOldGCCompacting",
JDK_Version::jdk_update(6,27), JDK_Version::jdk(8) },
{ "UseParallelDensePrefixUpdate",
JDK_Version::jdk_update(6,27), JDK_Version::jdk(8) },
{ "UseParallelOldGCDensePrefix",
JDK_Version::jdk_update(6,27), JDK_Version::jdk(8) },
{ "AllowTransitionalJSR292", JDK_Version::jdk(7), JDK_Version::jdk(8) },
{ "UseCompressedStrings", JDK_Version::jdk(7), JDK_Version::jdk(8) },
{ "CMSPermGenPrecleaningEnabled", JDK_Version::jdk(8), JDK_Version::jdk(9) },
{ "CMSTriggerPermRatio", JDK_Version::jdk(8), JDK_Version::jdk(9) },
{ "CMSInitiatingPermOccupancyFraction", JDK_Version::jdk(8), JDK_Version::jdk(9) },
{ "AdaptivePermSizeWeight", JDK_Version::jdk(8), JDK_Version::jdk(9) },
{ "PermGenPadding", JDK_Version::jdk(8), JDK_Version::jdk(9) },
{ "PermMarkSweepDeadRatio", JDK_Version::jdk(8), JDK_Version::jdk(9) },
{ "PermSize", JDK_Version::jdk(8), JDK_Version::jdk(9) },
{ "MaxPermSize", JDK_Version::jdk(8), JDK_Version::jdk(9) },
{ "MinPermHeapExpansion", JDK_Version::jdk(8), JDK_Version::jdk(9) },
{ "MaxPermHeapExpansion", JDK_Version::jdk(8), JDK_Version::jdk(9) },
{ "CMSRevisitStackSize", JDK_Version::jdk(8), JDK_Version::jdk(9) },
{ "PrintRevisitStats", JDK_Version::jdk(8), JDK_Version::jdk(9) },
{ "UseVectoredExceptions", JDK_Version::jdk(8), JDK_Version::jdk(9) },
{ "UseSplitVerifier", JDK_Version::jdk(8), JDK_Version::jdk(9) },
{ "UseISM", JDK_Version::jdk(8), JDK_Version::jdk(9) },
{ "UsePermISM", JDK_Version::jdk(8), JDK_Version::jdk(9) },
{ "UseMPSS", JDK_Version::jdk(8), JDK_Version::jdk(9) },
{ "UseStringCache", JDK_Version::jdk(8), JDK_Version::jdk(9) },
{ "UseOldInlining", JDK_Version::jdk_update(8, 20), JDK_Version::jdk(10) },
{ "AutoShutdownNMT", JDK_Version::jdk_update(8, 40), JDK_Version::jdk(10) },
{ "CompilationRepeat", JDK_Version::jdk(8), JDK_Version::jdk(9) },
{ "SegmentedHeapDumpThreshold", JDK_Version::jdk_update(8, 252), JDK_Version::jdk(10) },
#ifdef PRODUCT
{ "DesiredMethodLimit",
JDK_Version::jdk_update(7, 2), JDK_Version::jdk(8) },
#endif // PRODUCT
{ NULL, JDK_Version(0), JDK_Version(0) }
};
bool Arguments::is_newly_obsolete(const char *s, JDK_Version* version) {
int i = 0;
assert(version != NULL, "Must provide a version buffer");
while (obsolete_jvm_flags[i].name != NULL) {
const ObsoleteFlag& flag_status = obsolete_jvm_flags[i];
if ((strncmp(flag_status.name, s, strlen(flag_status.name)) == 0) ||
((s[0] == '+' || s[0] == '-') &&
(strncmp(flag_status.name, &s[1], strlen(flag_status.name)) == 0))) {
if (JDK_Version::current().compare(flag_status.accept_until) == -1) {
return true;
}
}
i++;
}
return false;
}
class SysClassPath: public StackObj {
public:
SysClassPath(const char* base);
~SysClassPath();
inline void set_base(const char* base);
inline void add_prefix(const char* prefix);
inline void add_suffix_to_prefix(const char* suffix);
inline void add_suffix(const char* suffix);
inline void reset_path(const char* base);
void expand_endorsed();
inline const char* get_base() const { return _items[_scp_base]; }
inline const char* get_prefix() const { return _items[_scp_prefix]; }
inline const char* get_suffix() const { return _items[_scp_suffix]; }
inline const char* get_endorsed() const { return _items[_scp_endorsed]; }
char* combined_path();
private:
static char* add_to_path(const char* path, const char* str, bool prepend);
static char* add_jars_to_path(char* path, const char* directory);
inline void reset_item_at(int index);
enum {
_scp_prefix, // from -Xbootclasspath/p:...
_scp_endorsed, // the expansion of -Djava.endorsed.dirs=...
_scp_base, // the default sysclasspath
_scp_suffix, // from -Xbootclasspath/a:...
_scp_nitems // the number of items, must be last.
};
const char* _items[_scp_nitems];
DEBUG_ONLY(bool _expansion_done;)
};
SysClassPath::SysClassPath(const char* base) {
memset(_items, 0, sizeof(_items));
_items[_scp_base] = base;
DEBUG_ONLY(_expansion_done = false;)
}
SysClassPath::~SysClassPath() {
for (int i = 0; i < _scp_nitems; ++i) {
if (i != _scp_base) reset_item_at(i);
}
DEBUG_ONLY(_expansion_done = false;)
}
inline void SysClassPath::set_base(const char* base) {
_items[_scp_base] = base;
}
inline void SysClassPath::add_prefix(const char* prefix) {
_items[_scp_prefix] = add_to_path(_items[_scp_prefix], prefix, true);
}
inline void SysClassPath::add_suffix_to_prefix(const char* suffix) {
_items[_scp_prefix] = add_to_path(_items[_scp_prefix], suffix, false);
}
inline void SysClassPath::add_suffix(const char* suffix) {
_items[_scp_suffix] = add_to_path(_items[_scp_suffix], suffix, false);
}
inline void SysClassPath::reset_item_at(int index) {
assert(index < _scp_nitems && index != _scp_base, "just checking");
if (_items[index] != NULL) {
FREE_C_HEAP_ARRAY(char, _items[index], mtInternal);
_items[index] = NULL;
}
}
inline void SysClassPath::reset_path(const char* base) {
reset_item_at(_scp_prefix);
reset_item_at(_scp_suffix);
set_base(base);
}
void SysClassPath::expand_endorsed() {
assert(_items[_scp_endorsed] == NULL, "can only be called once.");
const char* path = Arguments::get_property("java.endorsed.dirs");
if (path == NULL) {
path = Arguments::get_endorsed_dir();
assert(path != NULL, "no default for java.endorsed.dirs");
}
char* expanded_path = NULL;
const char separator = *os::path_separator();
const char* const end = path + strlen(path);
while (path < end) {
const char* tmp_end = strchr(path, separator);
if (tmp_end == NULL) {
expanded_path = add_jars_to_path(expanded_path, path);
path = end;
} else {
char* dirpath = NEW_C_HEAP_ARRAY(char, tmp_end - path + 1, mtInternal);
memcpy(dirpath, path, tmp_end - path);
dirpath[tmp_end - path] = '\0';
expanded_path = add_jars_to_path(expanded_path, dirpath);
FREE_C_HEAP_ARRAY(char, dirpath, mtInternal);
path = tmp_end + 1;
}
}
_items[_scp_endorsed] = expanded_path;
DEBUG_ONLY(_expansion_done = true;)
}
char* SysClassPath::combined_path() {
assert(_items[_scp_base] != NULL, "empty default sysclasspath");
assert(_expansion_done, "must call expand_endorsed() first.");
size_t lengths[_scp_nitems];
size_t total_len = 0;
const char separator = *os::path_separator();
int i;
for (i = 0; i < _scp_nitems; ++i) {
if (_items[i] != NULL) {
lengths[i] = strlen(_items[i]);
total_len += lengths[i] + 1;
}
}
assert(total_len > 0, "empty sysclasspath not allowed");
char* cp = NEW_C_HEAP_ARRAY(char, total_len, mtInternal);
char* cp_tmp = cp;
for (i = 0; i < _scp_nitems; ++i) {
if (_items[i] != NULL) {
memcpy(cp_tmp, _items[i], lengths[i]);
cp_tmp += lengths[i];
}
}
return cp;
}
char*
SysClassPath::add_to_path(const char* path, const char* str, bool prepend) {
char *cp;
assert(str != NULL, "just checking");
if (path == NULL) {
size_t len = strlen(str) + 1;
cp = NEW_C_HEAP_ARRAY(char, len, mtInternal);
memcpy(cp, str, len); // copy the trailing null
} else {
const char separator = *os::path_separator();
size_t old_len = strlen(path);
size_t str_len = strlen(str);
size_t len = old_len + str_len + 2;
if (prepend) {
cp = NEW_C_HEAP_ARRAY(char, len, mtInternal);
char* cp_tmp = cp;
memcpy(cp_tmp, str, str_len);
cp_tmp += str_len;
memcpy(++cp_tmp, path, old_len + 1); // copy the trailing null
FREE_C_HEAP_ARRAY(char, path, mtInternal);
} else {
cp = REALLOC_C_HEAP_ARRAY(char, path, len, mtInternal);
char* cp_tmp = cp + old_len;
memcpy(++cp_tmp, str, str_len + 1); // copy the trailing null
}
}
return cp;
}
char* SysClassPath::add_jars_to_path(char* path, const char* directory) {
DIR* dir = os::opendir(directory);
if (dir == NULL) return path;
char dir_sep[2] = { '\0', '\0' };
size_t directory_len = strlen(directory);
const char fileSep = *os::file_separator();
if (directory[directory_len - 1] != fileSep) dir_sep[0] = fileSep;
struct dirent *entry;
while ((entry = os::readdir(dir)) != NULL) {
const char* name = entry->d_name;
const char* ext = name + strlen(name) - 4;
bool isJarOrZip = ext > name &&
(os::file_name_strcmp(ext, ".jar") == 0 ||
os::file_name_strcmp(ext, ".zip") == 0);
if (isJarOrZip) {
size_t length = directory_len + 2 + strlen(name);
char* jarpath = NEW_C_HEAP_ARRAY(char, length, mtInternal);
jio_snprintf(jarpath, length, "%s%s%s", directory, dir_sep, name);
path = add_to_path(path, jarpath, false);
FREE_C_HEAP_ARRAY(char, jarpath, mtInternal);
}
}
os::closedir(dir);
return path;
}
static bool atomull(const char *s, julong* result) {
julong n = 0;
int args_read = sscanf(s, JULONG_FORMAT, &n);
if (args_read != 1) {
return false;
}
while (*s != '\0' && isdigit(*s)) {
s++;
}
if (strlen(s) > 1) {
return false;
}
switch (*s) {
case 'T': case 't':
if (*result/((julong)G * K) != n) return false;
return true;
case 'G': case 'g':
if (*result/G != n) return false;
return true;
case 'M': case 'm':
if (*result/M != n) return false;
return true;
case 'K': case 'k':
if (*result/K != n) return false;
return true;
case '\0':
return true;
default:
return false;
}
}
Arguments::ArgsRange Arguments::check_memory_size(julong size, julong min_size) {
if (size < min_size) return arg_too_small;
if (size > max_uintx) return arg_too_big;
return arg_in_range;
}
void Arguments::describe_range_error(ArgsRange errcode) {
switch(errcode) {
case arg_too_big:
jio_fprintf(defaultStream::error_stream(),
"The specified size exceeds the maximum "
"representable size.\n");
break;
case arg_too_small:
case arg_unreadable:
case arg_in_range:
break;
default:
ShouldNotReachHere();
}
}
static bool set_bool_flag(char* name, bool value, Flag::Flags origin) {
return CommandLineFlags::boolAtPut(name, &value, origin);
}
static bool set_fp_numeric_flag(char* name, char* value, Flag::Flags origin) {
double v;
if (sscanf(value, "%lf", &v) != 1) {
return false;
}
if (CommandLineFlags::doubleAtPut(name, &v, origin)) {
return true;
}
return false;
}
static bool set_numeric_flag(char* name, char* value, Flag::Flags origin) {
julong v;
intx intx_v;
bool is_neg = false;
if (*value == '-') {
if (!CommandLineFlags::intxAt(name, &intx_v)) {
return false;
}
value++;
is_neg = true;
}
if (!atomull(value, &v)) {
return false;
}
intx_v = (intx) v;
if (is_neg) {
intx_v = -intx_v;
}
if (CommandLineFlags::intxAtPut(name, &intx_v, origin)) {
return true;
}
uintx uintx_v = (uintx) v;
if (!is_neg && CommandLineFlags::uintxAtPut(name, &uintx_v, origin)) {
return true;
}
uint64_t uint64_t_v = (uint64_t) v;
if (!is_neg && CommandLineFlags::uint64_tAtPut(name, &uint64_t_v, origin)) {
return true;
}
return false;
}
static bool set_string_flag(char* name, const char* value, Flag::Flags origin) {
if (!CommandLineFlags::ccstrAtPut(name, &value, origin)) return false;
FREE_C_HEAP_ARRAY(char, value, mtInternal);
return true;
}
static bool append_to_string_flag(char* name, const char* new_value, Flag::Flags origin) {
const char* old_value = "";
if (!CommandLineFlags::ccstrAt(name, &old_value)) return false;
size_t old_len = old_value != NULL ? strlen(old_value) : 0;
size_t new_len = strlen(new_value);
const char* value;
char* free_this_too = NULL;
if (old_len == 0) {
value = new_value;
} else if (new_len == 0) {
value = old_value;
} else {
size_t length = old_len + 1 + new_len + 1;
char* buf = NEW_C_HEAP_ARRAY(char, length, mtInternal);
jio_snprintf(buf, length, "%s\n%s", old_value, new_value);
value = buf;
free_this_too = buf;
}
(void) CommandLineFlags::ccstrAtPut(name, &value, origin);
FREE_C_HEAP_ARRAY(char, value, mtInternal);
if (free_this_too != NULL) {
FREE_C_HEAP_ARRAY(char, free_this_too, mtInternal);
}
return true;
}
08-03
501
501
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
