mirror of
https://github.com/openjdk/jdk.git
synced 2026-02-15 12:55:07 +00:00
Merge
This commit is contained in:
Alejandro Murillo
commit
9b7378e4fa
@ -103,11 +103,12 @@ public class ClassLoaderStats extends Tool {
|
||||
}
|
||||
|
||||
SystemDictionary dict = VM.getVM().getSystemDictionary();
|
||||
dict.classesDo(new SystemDictionary.ClassAndLoaderVisitor() {
|
||||
public void visit(Klass k, Oop loader) {
|
||||
dict.classesDo(new SystemDictionary.ClassVisitor() {
|
||||
public void visit(Klass k) {
|
||||
if (! (k instanceof InstanceKlass)) {
|
||||
return;
|
||||
}
|
||||
Oop loader = ((InstanceKlass) k).getClassLoader();
|
||||
LoaderData ld = (loader != null) ? (LoaderData)loaderMap.get(loader)
|
||||
: bootstrapLoaderData;
|
||||
if (ld != null) {
|
||||
|
||||
@ -557,11 +557,11 @@ $(JDK_IMAGE_DIR)/jre/lib/rt.jar:
|
||||
|
||||
|
||||
# Testing the built JVM
|
||||
RUN_JVM=JAVA_HOME=$(JDK_IMPORT_PATH) $(JDK_IMPORT_PATH)/bin/java -d$(ARCH_DATA_MODEL) -Dsun.java.launcher=gamma
|
||||
RUN_JVM=JAVA_HOME=$(JDK_IMPORT_PATH) $(JDK_IMPORT_PATH)/bin/java -d$(ARCH_DATA_MODEL) -XXaltjvm=$(ALTJVM_DIR) -Dsun.java.launcher.is_altjvm=true
|
||||
generic_test:
|
||||
@$(ECHO) "Running with: $(ALTJVM_DIR)"
|
||||
@$(RUN_JVM) -XXaltjvm=$(ALTJVM_DIR) -Xinternalversion
|
||||
@$(RUN_JVM) -XXaltjvm=$(ALTJVM_DIR) -showversion -help
|
||||
@$(RUN_JVM) -Xinternalversion
|
||||
@$(RUN_JVM) -showversion -help
|
||||
|
||||
# C2 test targets
|
||||
test_product test_optimized test_fastdebug test_debug:
|
||||
|
||||
@ -53,6 +53,7 @@ JVMOFFS.o = $(JVMOFFS).o
|
||||
GENOFFS = generate$(JVMOFFS)
|
||||
|
||||
DTRACE_SRCDIR = $(GAMMADIR)/src/os/$(Platform_os_family)/dtrace
|
||||
DTRACE_COMMON_SRCDIR = $(GAMMADIR)/src/os/posix/dtrace
|
||||
DTRACE = dtrace
|
||||
DTRACE.o = $(DTRACE).o
|
||||
|
||||
@ -262,14 +263,14 @@ endif
|
||||
$(DtraceOutDir):
|
||||
mkdir $(DtraceOutDir)
|
||||
|
||||
$(DtraceOutDir)/hotspot.h: $(DTRACE_SRCDIR)/hotspot.d | $(DtraceOutDir)
|
||||
$(QUIETLY) $(DTRACE_PROG) $(DTRACE_OPTS) -C -I. -h -o $@ -s $(DTRACE_SRCDIR)/hotspot.d
|
||||
$(DtraceOutDir)/hotspot.h: $(DTRACE_COMMON_SRCDIR)/hotspot.d | $(DtraceOutDir)
|
||||
$(QUIETLY) $(DTRACE_PROG) $(DTRACE_OPTS) -C -I. -h -o $@ -s $(DTRACE_COMMON_SRCDIR)/hotspot.d
|
||||
|
||||
$(DtraceOutDir)/hotspot_jni.h: $(DTRACE_SRCDIR)/hotspot_jni.d | $(DtraceOutDir)
|
||||
$(QUIETLY) $(DTRACE_PROG) $(DTRACE_OPTS) -C -I. -h -o $@ -s $(DTRACE_SRCDIR)/hotspot_jni.d
|
||||
$(DtraceOutDir)/hotspot_jni.h: $(DTRACE_COMMON_SRCDIR)/hotspot_jni.d | $(DtraceOutDir)
|
||||
$(QUIETLY) $(DTRACE_PROG) $(DTRACE_OPTS) -C -I. -h -o $@ -s $(DTRACE_COMMON_SRCDIR)/hotspot_jni.d
|
||||
|
||||
$(DtraceOutDir)/hs_private.h: $(DTRACE_SRCDIR)/hs_private.d | $(DtraceOutDir)
|
||||
$(QUIETLY) $(DTRACE_PROG) $(DTRACE_OPTS) -C -I. -h -o $@ -s $(DTRACE_SRCDIR)/hs_private.d
|
||||
$(DtraceOutDir)/hs_private.h: $(DTRACE_COMMON_SRCDIR)/hs_private.d | $(DtraceOutDir)
|
||||
$(QUIETLY) $(DTRACE_PROG) $(DTRACE_OPTS) -C -I. -h -o $@ -s $(DTRACE_COMMON_SRCDIR)/hs_private.d
|
||||
|
||||
dtrace_gen_headers: $(DtraceOutDir)/hotspot.h $(DtraceOutDir)/hotspot_jni.h $(DtraceOutDir)/hs_private.h
|
||||
|
||||
|
||||
@ -49,7 +49,7 @@ then
|
||||
GDB=gdb
|
||||
fi
|
||||
|
||||
# This is the name of the gdb binary to use
|
||||
# This is the name of the dbx binary to use
|
||||
if [ ! "$DBX" ]
|
||||
then
|
||||
DBX=dbx
|
||||
@ -68,9 +68,16 @@ EMACS=emacs
|
||||
# End of user changeable parameters -----------------------------------------
|
||||
#
|
||||
|
||||
OS=`uname -s`
|
||||
|
||||
# Make sure the paths are fully specified, i.e. they must begin with /.
|
||||
REL_MYDIR=`dirname $0`
|
||||
MYDIR=`cd $REL_MYDIR && pwd`
|
||||
case "$OS" in
|
||||
CYGWIN*)
|
||||
MYDIR=`cygpath -m "$MYDIR"`
|
||||
;;
|
||||
esac
|
||||
|
||||
#
|
||||
# Look whether the user wants to run inside gdb
|
||||
@ -102,8 +109,17 @@ else
|
||||
JDK=@@JDK_IMPORT_PATH@@
|
||||
fi
|
||||
|
||||
if [ "${JDK}" = "" ]; then
|
||||
echo "Failed to find JDK. Either ALT_JAVA_HOME is not set or JDK_IMPORT_PATH is empty."
|
||||
if [ "${JDK}" != "" ]; then
|
||||
case "$OS" in
|
||||
CYGWIN*)
|
||||
JDK=`cygpath -m "$JDK"`
|
||||
;;
|
||||
esac
|
||||
|
||||
else
|
||||
echo "Failed to find JDK." \
|
||||
"Either ALT_JAVA_HOME is not set or JDK_IMPORT_PATH is empty."
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# We will set the LD_LIBRARY_PATH as follows:
|
||||
@ -120,7 +136,6 @@ SBP=${MYDIR}:${JRE}/lib/${ARCH}
|
||||
|
||||
|
||||
# Set up a suitable LD_LIBRARY_PATH or DYLD_LIBRARY_PATH
|
||||
OS=`uname -s`
|
||||
if [ "${OS}" = "Darwin" ]
|
||||
then
|
||||
if [ -z "$DYLD_LIBRARY_PATH" ]
|
||||
@ -141,7 +156,7 @@ else
|
||||
export LD_LIBRARY_PATH
|
||||
fi
|
||||
|
||||
JPARMS="-Dsun.java.launcher=gamma -XXaltjvm=$MYDIR $@ $JAVA_ARGS";
|
||||
JPARMS="-XXaltjvm=$MYDIR -Dsun.java.launcher.is_altjvm=true $@ $JAVA_ARGS";
|
||||
|
||||
# Locate the java launcher
|
||||
LAUNCHER=$JDK/bin/java
|
||||
@ -152,6 +167,11 @@ fi
|
||||
|
||||
GDBSRCDIR=$MYDIR
|
||||
BASEDIR=`cd $MYDIR/../../.. && pwd`
|
||||
case "$OS" in
|
||||
CYGWIN*)
|
||||
BASEDIR=`cygpath -m "$BASEDIR"`
|
||||
;;
|
||||
esac
|
||||
|
||||
init_gdb() {
|
||||
# Create a gdb script in case we should run inside gdb
|
||||
|
||||
@ -124,7 +124,7 @@ SUBMAKE_DIRS = $(addprefix $(PLATFORM_DIR)/,$(TARGETS))
|
||||
# For dependencies and recursive makes.
|
||||
BUILDTREE_MAKE = $(GAMMADIR)/make/$(OS_FAMILY)/makefiles/buildtree.make
|
||||
|
||||
BUILDTREE_TARGETS = Makefile flags.make flags_vm.make vm.make adlc.make jvmti.make trace.make sa.make
|
||||
BUILDTREE_TARGETS = Makefile flags.make flags_vm.make vm.make adlc.make jvmti.make trace.make sa.make dtrace.make
|
||||
|
||||
BUILDTREE_VARS = GAMMADIR=$(GAMMADIR) OS_FAMILY=$(OS_FAMILY) \
|
||||
SRCARCH=$(SRCARCH) BUILDARCH=$(BUILDARCH) LIBARCH=$(LIBARCH) VARIANT=$(VARIANT)
|
||||
@ -361,6 +361,16 @@ sa.make: $(BUILDTREE_MAKE)
|
||||
echo "include \$$(GAMMADIR)/make/$(OS_FAMILY)/makefiles/$(@F)"; \
|
||||
) > $@
|
||||
|
||||
dtrace.make: $(BUILDTREE_MAKE)
|
||||
@echo Creating $@ ...
|
||||
$(QUIETLY) ( \
|
||||
$(BUILDTREE_COMMENT); \
|
||||
echo; \
|
||||
echo include flags.make; \
|
||||
echo; \
|
||||
echo "include \$$(GAMMADIR)/make/$(OS_FAMILY)/makefiles/$(@F)"; \
|
||||
) > $@
|
||||
|
||||
FORCE:
|
||||
|
||||
.PHONY: all FORCE
|
||||
|
||||
@ -42,18 +42,39 @@ ifneq ($(ALT_SDT_H),)
|
||||
else
|
||||
SDT_H_FILE = /usr/include/sys/sdt.h
|
||||
endif
|
||||
|
||||
DTRACE_ENABLED = $(shell test -f $(SDT_H_FILE) && echo $(SDT_H_FILE))
|
||||
REASON = "$(SDT_H_FILE) not found"
|
||||
|
||||
ifneq ($(DTRACE_ENABLED),)
|
||||
CFLAGS += -DDTRACE_ENABLED
|
||||
endif
|
||||
endif # GCC version
|
||||
endif # OPENJDK
|
||||
|
||||
endif
|
||||
|
||||
DTRACE_COMMON_SRCDIR = $(GAMMADIR)/src/os/posix/dtrace
|
||||
DTRACE_PROG = dtrace
|
||||
DtraceOutDir = $(GENERATED)/dtracefiles
|
||||
|
||||
$(DtraceOutDir):
|
||||
mkdir $(DtraceOutDir)
|
||||
|
||||
$(DtraceOutDir)/hotspot.h: $(DTRACE_COMMON_SRCDIR)/hotspot.d | $(DtraceOutDir)
|
||||
$(QUIETLY) $(DTRACE_PROG) $(DTRACE_OPTS) -C -I. -h -o $@ -s $(DTRACE_COMMON_SRCDIR)/hotspot.d
|
||||
|
||||
$(DtraceOutDir)/hotspot_jni.h: $(DTRACE_COMMON_SRCDIR)/hotspot_jni.d | $(DtraceOutDir)
|
||||
$(QUIETLY) $(DTRACE_PROG) $(DTRACE_OPTS) -C -I. -h -o $@ -s $(DTRACE_COMMON_SRCDIR)/hotspot_jni.d
|
||||
|
||||
$(DtraceOutDir)/hs_private.h: $(DTRACE_COMMON_SRCDIR)/hs_private.d | $(DtraceOutDir)
|
||||
$(QUIETLY) $(DTRACE_PROG) $(DTRACE_OPTS) -C -I. -h -o $@ -s $(DTRACE_COMMON_SRCDIR)/hs_private.d
|
||||
|
||||
ifneq ($(DTRACE_ENABLED),)
|
||||
CFLAGS += -DDTRACE_ENABLED
|
||||
dtrace_gen_headers: $(DtraceOutDir)/hotspot.h $(DtraceOutDir)/hotspot_jni.h $(DtraceOutDir)/hs_private.h
|
||||
else
|
||||
dtrace_gen_headers:
|
||||
$(QUIETLY) echo "**NOTICE** Dtrace support disabled: $(REASON)"
|
||||
endif
|
||||
|
||||
# Phony target used in vm.make build target to check whether enabled.
|
||||
.PHONY: dtraceCheck
|
||||
ifeq ($(DTRACE_ENABLED),)
|
||||
dtraceCheck:
|
||||
$(QUIETLY) echo "**NOTICE** Dtrace support disabled: $(REASON)"
|
||||
@ -61,5 +82,7 @@ else
|
||||
dtraceCheck:
|
||||
endif
|
||||
|
||||
.PHONY: dtrace_gen_headers dtraceCheck
|
||||
|
||||
# It doesn't support HAVE_DTRACE_H though.
|
||||
|
||||
|
||||
@ -80,7 +80,7 @@ default: vm_build_preliminaries the_vm
|
||||
@echo All done.
|
||||
|
||||
# This is an explicit dependency for the sake of parallel makes.
|
||||
vm_build_preliminaries: checks $(Cached_plat) $(AD_Files_If_Required) trace_stuff jvmti_stuff sa_stuff
|
||||
vm_build_preliminaries: checks $(Cached_plat) $(AD_Files_If_Required) trace_stuff jvmti_stuff sa_stuff dtrace_stuff
|
||||
@# We need a null action here, so implicit rules don't get consulted.
|
||||
|
||||
$(Cached_plat): $(Plat_File)
|
||||
@ -102,6 +102,9 @@ trace_stuff: jvmti_stuff $(Cached_plat) $(adjust-mflags)
|
||||
sa_stuff:
|
||||
@$(MAKE) -f sa.make $(MFLAGS-adjusted)
|
||||
|
||||
dtrace_stuff: $(Cached_plat) $(adjust-mflags)
|
||||
@$(MAKE) -f dtrace.make dtrace_gen_headers $(MFLAGS-adjusted) GENERATED=$(GENERATED)
|
||||
|
||||
# and the VM: must use other makefile with dependencies included
|
||||
|
||||
# We have to go to great lengths to get control over the -jN argument
|
||||
|
||||
@ -55,6 +55,7 @@ JVMOFFS.o = $(JVMOFFS).o
|
||||
GENOFFS = generate$(JVMOFFS)
|
||||
|
||||
DTRACE_SRCDIR = $(GAMMADIR)/src/os/$(Platform_os_family)/dtrace
|
||||
DTRACE_COMMON_SRCDIR = $(GAMMADIR)/src/os/posix/dtrace
|
||||
DTRACE = dtrace
|
||||
DTRACE.o = $(DTRACE).o
|
||||
|
||||
@ -253,8 +254,8 @@ ifeq ($(ENABLE_FULL_DEBUG_SYMBOLS),1)
|
||||
endif
|
||||
endif
|
||||
|
||||
$(DTRACE).d: $(DTRACE_SRCDIR)/hotspot.d $(DTRACE_SRCDIR)/hotspot_jni.d \
|
||||
$(DTRACE_SRCDIR)/hs_private.d $(DTRACE_SRCDIR)/jhelper.d
|
||||
$(DTRACE).d: $(DTRACE_COMMON_SRCDIR)/hotspot.d $(DTRACE_COMMON_SRCDIR)/hotspot_jni.d \
|
||||
$(DTRACE_COMMON_SRCDIR)/hs_private.d $(DTRACE_SRCDIR)/jhelper.d
|
||||
$(QUIETLY) cat $^ > $@
|
||||
|
||||
DTraced_Files = ciEnv.o \
|
||||
@ -332,14 +333,14 @@ $(DTRACE.o): $(DTRACE).d $(JVMOFFS).h $(JVMOFFS)Index.h $(DTraced_Files)
|
||||
$(DtraceOutDir):
|
||||
mkdir $(DtraceOutDir)
|
||||
|
||||
$(DtraceOutDir)/hotspot.h: $(DTRACE_SRCDIR)/hotspot.d | $(DtraceOutDir)
|
||||
$(QUIETLY) $(DTRACE_PROG) $(DTRACE_OPTS) -C -I. -h -o $@ -s $(DTRACE_SRCDIR)/hotspot.d
|
||||
$(DtraceOutDir)/hotspot.h: $(DTRACE_COMMON_SRCDIR)/hotspot.d | $(DtraceOutDir)
|
||||
$(QUIETLY) $(DTRACE_PROG) $(DTRACE_OPTS) -C -I. -h -o $@ -s $(DTRACE_COMMON_SRCDIR)/hotspot.d
|
||||
|
||||
$(DtraceOutDir)/hotspot_jni.h: $(DTRACE_SRCDIR)/hotspot_jni.d | $(DtraceOutDir)
|
||||
$(QUIETLY) $(DTRACE_PROG) $(DTRACE_OPTS) -C -I. -h -o $@ -s $(DTRACE_SRCDIR)/hotspot_jni.d
|
||||
$(DtraceOutDir)/hotspot_jni.h: $(DTRACE_COMMON_SRCDIR)/hotspot_jni.d | $(DtraceOutDir)
|
||||
$(QUIETLY) $(DTRACE_PROG) $(DTRACE_OPTS) -C -I. -h -o $@ -s $(DTRACE_COMMON_SRCDIR)/hotspot_jni.d
|
||||
|
||||
$(DtraceOutDir)/hs_private.h: $(DTRACE_SRCDIR)/hs_private.d | $(DtraceOutDir)
|
||||
$(QUIETLY) $(DTRACE_PROG) $(DTRACE_OPTS) -C -I. -h -o $@ -s $(DTRACE_SRCDIR)/hs_private.d
|
||||
$(DtraceOutDir)/hs_private.h: $(DTRACE_COMMON_SRCDIR)/hs_private.d | $(DtraceOutDir)
|
||||
$(QUIETLY) $(DTRACE_PROG) $(DTRACE_OPTS) -C -I. -h -o $@ -s $(DTRACE_COMMON_SRCDIR)/hs_private.d
|
||||
|
||||
dtrace_gen_headers: $(DtraceOutDir)/hotspot.h $(DtraceOutDir)/hotspot_jni.h $(DtraceOutDir)/hs_private.h
|
||||
|
||||
|
||||
@ -1,40 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2005, Oracle and/or its affiliates. All rights reserved.
|
||||
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
||||
*
|
||||
* This code is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU General Public License version 2 only, as
|
||||
* published by the Free Software Foundation.
|
||||
*
|
||||
* This code is distributed in the hope that it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
* version 2 for more details (a copy is included in the LICENSE file that
|
||||
* accompanied this code).
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License version
|
||||
* 2 along with this work; if not, write to the Free Software Foundation,
|
||||
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*
|
||||
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
||||
* or visit www.oracle.com if you need additional information or have any
|
||||
* questions.
|
||||
*
|
||||
*/
|
||||
|
||||
provider hs_private {
|
||||
probe hashtable__new_entry(void*, uint32_t, uintptr_t, void*);
|
||||
probe safepoint__begin();
|
||||
probe safepoint__end();
|
||||
probe cms__initmark__begin();
|
||||
probe cms__initmark__end();
|
||||
probe cms__remark__begin();
|
||||
probe cms__remark__end();
|
||||
};
|
||||
|
||||
#pragma D attributes Private/Private/Common provider hs_private provider
|
||||
#pragma D attributes Private/Private/Unknown provider hs_private module
|
||||
#pragma D attributes Private/Private/Unknown provider hs_private function
|
||||
#pragma D attributes Private/Private/Common provider hs_private name
|
||||
#pragma D attributes Private/Private/Common provider hs_private args
|
||||
|
||||
@ -1788,12 +1788,14 @@ void os::jvm_path(char *buf, jint buflen) {
|
||||
if (rp == NULL)
|
||||
return;
|
||||
|
||||
if (Arguments::created_by_gamma_launcher()) {
|
||||
// Support for the gamma launcher. Typical value for buf is
|
||||
// "<JAVA_HOME>/jre/lib/<arch>/<vmtype>/libjvm". If "/jre/lib/" appears at
|
||||
// the right place in the string, then assume we are installed in a JDK and
|
||||
// we're done. Otherwise, check for a JAVA_HOME environment variable and
|
||||
// construct a path to the JVM being overridden.
|
||||
if (Arguments::sun_java_launcher_is_altjvm()) {
|
||||
// Support for the java launcher's '-XXaltjvm=<path>' option. Typical
|
||||
// value for buf is "<JAVA_HOME>/jre/lib/<arch>/<vmtype>/libjvm.so"
|
||||
// or "<JAVA_HOME>/jre/lib/<vmtype>/libjvm.dylib". If "/jre/lib/"
|
||||
// appears at the right place in the string, then assume we are
|
||||
// installed in a JDK and we're done. Otherwise, check for a
|
||||
// JAVA_HOME environment variable and construct a path to the JVM
|
||||
// being overridden.
|
||||
|
||||
const char *p = buf + strlen(buf) - 1;
|
||||
for (int count = 0; p > buf && count < 5; ++count) {
|
||||
|
||||
@ -2371,13 +2371,14 @@ void os::jvm_path(char *buf, jint buflen) {
|
||||
if (rp == NULL)
|
||||
return;
|
||||
|
||||
if (Arguments::created_by_gamma_launcher()) {
|
||||
// Support for the gamma launcher. Typical value for buf is
|
||||
// "<JAVA_HOME>/jre/lib/<arch>/<vmtype>/libjvm.so". If "/jre/lib/" appears at
|
||||
// the right place in the string, then assume we are installed in a JDK and
|
||||
// we're done. Otherwise, check for a JAVA_HOME environment variable and fix
|
||||
// up the path so it looks like libjvm.so is installed there (append a
|
||||
// fake suffix hotspot/libjvm.so).
|
||||
if (Arguments::sun_java_launcher_is_altjvm()) {
|
||||
// Support for the java launcher's '-XXaltjvm=<path>' option. Typical
|
||||
// value for buf is "<JAVA_HOME>/jre/lib/<arch>/<vmtype>/libjvm.so".
|
||||
// If "/jre/lib/" appears at the right place in the string, then
|
||||
// assume we are installed in a JDK and we're done. Otherwise, check
|
||||
// for a JAVA_HOME environment variable and fix up the path so it
|
||||
// looks like libjvm.so is installed there (append a fake suffix
|
||||
// hotspot/libjvm.so).
|
||||
const char *p = buf + strlen(buf) - 1;
|
||||
for (int count = 0; p > buf && count < 5; ++count) {
|
||||
for (--p; p > buf && *p != '/'; --p)
|
||||
|
||||
@ -1,86 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
|
||||
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
||||
*
|
||||
* This code is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU General Public License version 2 only, as
|
||||
* published by the Free Software Foundation.
|
||||
*
|
||||
* This code is distributed in the hope that it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
* version 2 for more details (a copy is included in the LICENSE file that
|
||||
* accompanied this code).
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License version
|
||||
* 2 along with this work; if not, write to the Free Software Foundation,
|
||||
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*
|
||||
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
||||
* or visit www.oracle.com if you need additional information or have any
|
||||
* questions.
|
||||
*
|
||||
*/
|
||||
|
||||
provider hotspot {
|
||||
probe class__loaded(char*, uintptr_t, void*, uintptr_t);
|
||||
probe class__unloaded(char*, uintptr_t, void*, uintptr_t);
|
||||
probe class__initialization__required(char*, uintptr_t, void*, intptr_t);
|
||||
probe class__initialization__recursive(char*, uintptr_t, void*, intptr_t,int);
|
||||
probe class__initialization__concurrent(char*, uintptr_t, void*, intptr_t,int);
|
||||
probe class__initialization__erroneous(char*, uintptr_t, void*, intptr_t, int);
|
||||
probe class__initialization__super__failed(char*, uintptr_t, void*, intptr_t,int);
|
||||
probe class__initialization__clinit(char*, uintptr_t, void*, intptr_t,int);
|
||||
probe class__initialization__error(char*, uintptr_t, void*, intptr_t,int);
|
||||
probe class__initialization__end(char*, uintptr_t, void*, intptr_t,int);
|
||||
probe vm__init__begin();
|
||||
probe vm__init__end();
|
||||
probe vm__shutdown();
|
||||
probe vmops__request(char*, uintptr_t, int);
|
||||
probe vmops__begin(char*, uintptr_t, int);
|
||||
probe vmops__end(char*, uintptr_t, int);
|
||||
probe gc__begin(uintptr_t);
|
||||
probe gc__end();
|
||||
probe mem__pool__gc__begin(
|
||||
char*, uintptr_t, char*, uintptr_t,
|
||||
uintptr_t, uintptr_t, uintptr_t, uintptr_t);
|
||||
probe mem__pool__gc__end(
|
||||
char*, uintptr_t, char*, uintptr_t,
|
||||
uintptr_t, uintptr_t, uintptr_t, uintptr_t);
|
||||
probe thread__start(char*, uintptr_t, uintptr_t, uintptr_t, uintptr_t);
|
||||
probe thread__stop(char*, uintptr_t, uintptr_t, uintptr_t, uintptr_t);
|
||||
probe thread__sleep__begin(long long);
|
||||
probe thread__sleep__end(int);
|
||||
probe thread__yield();
|
||||
probe thread__park__begin(uintptr_t, int, long long);
|
||||
probe thread__park__end(uintptr_t);
|
||||
probe thread__unpark(uintptr_t);
|
||||
probe method__compile__begin(
|
||||
char*, uintptr_t, char*, uintptr_t, char*, uintptr_t, char*, uintptr_t);
|
||||
probe method__compile__end(
|
||||
char*, uintptr_t, char*, uintptr_t, char*, uintptr_t,
|
||||
char*, uintptr_t, uintptr_t);
|
||||
probe compiled__method__load(
|
||||
char*, uintptr_t, char*, uintptr_t, char*, uintptr_t, void*, uintptr_t);
|
||||
probe compiled__method__unload(
|
||||
char*, uintptr_t, char*, uintptr_t, char*, uintptr_t);
|
||||
probe monitor__contended__enter(uintptr_t, uintptr_t, char*, uintptr_t);
|
||||
probe monitor__contended__entered(uintptr_t, uintptr_t, char*, uintptr_t);
|
||||
probe monitor__contended__exit(uintptr_t, uintptr_t, char*, uintptr_t);
|
||||
probe monitor__wait(uintptr_t, uintptr_t, char*, uintptr_t, uintptr_t);
|
||||
probe monitor__waited(uintptr_t, uintptr_t, char*, uintptr_t);
|
||||
probe monitor__notify(uintptr_t, uintptr_t, char*, uintptr_t);
|
||||
probe monitor__notifyAll(uintptr_t, uintptr_t, char*, uintptr_t);
|
||||
|
||||
probe object__alloc(int, char*, uintptr_t, uintptr_t);
|
||||
probe method__entry(
|
||||
int, char*, int, char*, int, char*, int);
|
||||
probe method__return(
|
||||
int, char*, int, char*, int, char*, int);
|
||||
};
|
||||
|
||||
#pragma D attributes Evolving/Evolving/Common provider hotspot provider
|
||||
#pragma D attributes Private/Private/Unknown provider hotspot module
|
||||
#pragma D attributes Private/Private/Unknown provider hotspot function
|
||||
#pragma D attributes Evolving/Evolving/Common provider hotspot name
|
||||
#pragma D attributes Evolving/Evolving/Common provider hotspot args
|
||||
@ -1,506 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2005, Oracle and/or its affiliates. All rights reserved.
|
||||
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
||||
*
|
||||
* This code is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU General Public License version 2 only, as
|
||||
* published by the Free Software Foundation.
|
||||
*
|
||||
* This code is distributed in the hope that it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
* version 2 for more details (a copy is included in the LICENSE file that
|
||||
* accompanied this code).
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License version
|
||||
* 2 along with this work; if not, write to the Free Software Foundation,
|
||||
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*
|
||||
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
||||
* or visit www.oracle.com if you need additional information or have any
|
||||
* questions.
|
||||
*
|
||||
*/
|
||||
|
||||
provider hotspot_jni {
|
||||
probe AllocObject__entry(void*, void*);
|
||||
probe AllocObject__return(void*);
|
||||
probe AttachCurrentThreadAsDaemon__entry(void*, void**, void*);
|
||||
probe AttachCurrentThreadAsDaemon__return(uint32_t);
|
||||
probe AttachCurrentThread__entry(void*, void**, void*);
|
||||
probe AttachCurrentThread__return(uint32_t);
|
||||
probe CallBooleanMethodA__entry(void*, void*, uintptr_t);
|
||||
probe CallBooleanMethodA__return(uintptr_t);
|
||||
probe CallBooleanMethod__entry(void*, void*, uintptr_t);
|
||||
probe CallBooleanMethod__return(uintptr_t);
|
||||
probe CallBooleanMethodV__entry(void*, void*, uintptr_t);
|
||||
probe CallBooleanMethodV__return(uintptr_t);
|
||||
probe CallByteMethodA__entry(void*, void*, uintptr_t);
|
||||
probe CallByteMethodA__return(char);
|
||||
probe CallByteMethod__entry(void*, void*, uintptr_t);
|
||||
probe CallByteMethod__return(char);
|
||||
probe CallByteMethodV__entry(void*, void*, uintptr_t);
|
||||
probe CallByteMethodV__return(char);
|
||||
probe CallCharMethodA__entry(void*, void*, uintptr_t);
|
||||
probe CallCharMethodA__return(uint16_t);
|
||||
probe CallCharMethod__entry(void*, void*, uintptr_t);
|
||||
probe CallCharMethod__return(uint16_t);
|
||||
probe CallCharMethodV__entry(void*, void*, uintptr_t);
|
||||
probe CallCharMethodV__return(uint16_t);
|
||||
probe CallDoubleMethodA__entry(void*, void*, uintptr_t);
|
||||
probe CallDoubleMethodA__return();
|
||||
probe CallDoubleMethod__entry(void*, void*, uintptr_t);
|
||||
probe CallDoubleMethod__return();
|
||||
probe CallDoubleMethodV__entry(void*, void*, uintptr_t);
|
||||
probe CallDoubleMethodV__return();
|
||||
probe CallFloatMethodA__entry(void*, void*, uintptr_t);
|
||||
probe CallFloatMethodA__return();
|
||||
probe CallFloatMethod__entry(void*, void*, uintptr_t);
|
||||
probe CallFloatMethod__return();
|
||||
probe CallFloatMethodV__entry(void*, void*, uintptr_t);
|
||||
probe CallFloatMethodV__return();
|
||||
probe CallIntMethodA__entry(void*, void*, uintptr_t);
|
||||
probe CallIntMethodA__return(uint32_t);
|
||||
probe CallIntMethod__entry(void*, void*, uintptr_t);
|
||||
probe CallIntMethod__return(uint32_t);
|
||||
probe CallIntMethodV__entry(void*, void*, uintptr_t);
|
||||
probe CallIntMethodV__return(uint32_t);
|
||||
probe CallLongMethodA__entry(void*, void*, uintptr_t);
|
||||
probe CallLongMethodA__return(uintptr_t);
|
||||
probe CallLongMethod__entry(void*, void*, uintptr_t);
|
||||
probe CallLongMethod__return(uintptr_t);
|
||||
probe CallLongMethodV__entry(void*, void*, uintptr_t);
|
||||
probe CallLongMethodV__return(uintptr_t);
|
||||
probe CallNonvirtualBooleanMethodA__entry(void*, void*, void*, uintptr_t);
|
||||
probe CallNonvirtualBooleanMethodA__return(uintptr_t);
|
||||
probe CallNonvirtualBooleanMethod__entry(void*, void*, void*, uintptr_t);
|
||||
probe CallNonvirtualBooleanMethod__return(uintptr_t);
|
||||
probe CallNonvirtualBooleanMethodV__entry(void*, void*, void*, uintptr_t);
|
||||
probe CallNonvirtualBooleanMethodV__return(uintptr_t);
|
||||
probe CallNonvirtualByteMethodA__entry(void*, void*, void*, uintptr_t);
|
||||
probe CallNonvirtualByteMethodA__return(char);
|
||||
probe CallNonvirtualByteMethod__entry(void*, void*, void*, uintptr_t);
|
||||
probe CallNonvirtualByteMethod__return(char);
|
||||
probe CallNonvirtualByteMethodV__entry(void*, void*, void*, uintptr_t);
|
||||
probe CallNonvirtualByteMethodV__return(char);
|
||||
probe CallNonvirtualCharMethodA__entry(void*, void*, void*, uintptr_t);
|
||||
probe CallNonvirtualCharMethodA__return(uint16_t);
|
||||
probe CallNonvirtualCharMethod__entry(void*, void*, void*, uintptr_t);
|
||||
probe CallNonvirtualCharMethod__return(uint16_t);
|
||||
probe CallNonvirtualCharMethodV__entry(void*, void*, void*, uintptr_t);
|
||||
probe CallNonvirtualCharMethodV__return(uint16_t);
|
||||
probe CallNonvirtualDoubleMethodA__entry(void*, void*, void*, uintptr_t);
|
||||
probe CallNonvirtualDoubleMethodA__return();
|
||||
probe CallNonvirtualDoubleMethod__entry(void*, void*, void*, uintptr_t);
|
||||
probe CallNonvirtualDoubleMethod__return();
|
||||
probe CallNonvirtualDoubleMethodV__entry(void*, void*, void*, uintptr_t);
|
||||
probe CallNonvirtualDoubleMethodV__return();
|
||||
probe CallNonvirtualFloatMethodA__entry(void*, void*, void*, uintptr_t);
|
||||
probe CallNonvirtualFloatMethodA__return();
|
||||
probe CallNonvirtualFloatMethod__entry(void*, void*, void*, uintptr_t);
|
||||
probe CallNonvirtualFloatMethod__return();
|
||||
probe CallNonvirtualFloatMethodV__entry(void*, void*, void*, uintptr_t);
|
||||
probe CallNonvirtualFloatMethodV__return();
|
||||
probe CallNonvirtualIntMethodA__entry(void*, void*, void*, uintptr_t);
|
||||
probe CallNonvirtualIntMethodA__return(uint32_t);
|
||||
probe CallNonvirtualIntMethod__entry(void*, void*, void*, uintptr_t);
|
||||
probe CallNonvirtualIntMethod__return(uint32_t);
|
||||
probe CallNonvirtualIntMethodV__entry(void*, void*, void*, uintptr_t);
|
||||
probe CallNonvirtualIntMethodV__return(uint32_t);
|
||||
probe CallNonvirtualLongMethodA__entry(void*, void*, void*, uintptr_t);
|
||||
probe CallNonvirtualLongMethodA__return(uintptr_t);
|
||||
probe CallNonvirtualLongMethod__entry(void*, void*, void*, uintptr_t);
|
||||
probe CallNonvirtualLongMethod__return(uintptr_t);
|
||||
probe CallNonvirtualLongMethodV__entry(void*, void*, void*, uintptr_t);
|
||||
probe CallNonvirtualLongMethodV__return(uintptr_t);
|
||||
probe CallNonvirtualObjectMethodA__entry(void*, void*, void*, uintptr_t);
|
||||
probe CallNonvirtualObjectMethodA__return(void*);
|
||||
probe CallNonvirtualObjectMethod__entry(void*, void*, void*, uintptr_t);
|
||||
probe CallNonvirtualObjectMethod__return(void*);
|
||||
probe CallNonvirtualObjectMethodV__entry(void*, void*, void*, uintptr_t);
|
||||
probe CallNonvirtualObjectMethodV__return(void*);
|
||||
probe CallNonvirtualShortMethodA__entry(void*, void*, void*, uintptr_t);
|
||||
probe CallNonvirtualShortMethodA__return(uint16_t);
|
||||
probe CallNonvirtualShortMethod__entry(void*, void*, void*, uintptr_t);
|
||||
probe CallNonvirtualShortMethod__return(uint16_t);
|
||||
probe CallNonvirtualShortMethodV__entry(void*, void*, void*, uintptr_t);
|
||||
probe CallNonvirtualShortMethodV__return(uint16_t);
|
||||
probe CallNonvirtualVoidMethodA__entry(void*, void*, void*, uintptr_t);
|
||||
probe CallNonvirtualVoidMethodA__return();
|
||||
probe CallNonvirtualVoidMethod__entry(void*, void*, void*, uintptr_t);
|
||||
probe CallNonvirtualVoidMethod__return();
|
||||
probe CallNonvirtualVoidMethodV__entry(void*, void*, void*, uintptr_t);
|
||||
probe CallNonvirtualVoidMethodV__return();
|
||||
probe CallObjectMethodA__entry(void*, void*, uintptr_t);
|
||||
probe CallObjectMethodA__return(void*);
|
||||
probe CallObjectMethod__entry(void*, void*, uintptr_t);
|
||||
probe CallObjectMethod__return(void*);
|
||||
probe CallObjectMethodV__entry(void*, void*, uintptr_t);
|
||||
probe CallObjectMethodV__return(void*);
|
||||
probe CallShortMethodA__entry(void*, void*, uintptr_t);
|
||||
probe CallShortMethodA__return(uint16_t);
|
||||
probe CallShortMethod__entry(void*, void*, uintptr_t);
|
||||
probe CallShortMethod__return(uint16_t);
|
||||
probe CallShortMethodV__entry(void*, void*, uintptr_t);
|
||||
probe CallShortMethodV__return(uint16_t);
|
||||
probe CallStaticBooleanMethodA__entry(void*, void*, uintptr_t);
|
||||
probe CallStaticBooleanMethodA__return(uintptr_t);
|
||||
probe CallStaticBooleanMethod__entry(void*, void*, uintptr_t);
|
||||
probe CallStaticBooleanMethod__return(uintptr_t);
|
||||
probe CallStaticBooleanMethodV__entry(void*, void*, uintptr_t);
|
||||
probe CallStaticBooleanMethodV__return(uintptr_t);
|
||||
probe CallStaticByteMethodA__entry(void*, void*, uintptr_t);
|
||||
probe CallStaticByteMethodA__return(char);
|
||||
probe CallStaticByteMethod__entry(void*, void*, uintptr_t);
|
||||
probe CallStaticByteMethod__return(char);
|
||||
probe CallStaticByteMethodV__entry(void*, void*, uintptr_t);
|
||||
probe CallStaticByteMethodV__return(char);
|
||||
probe CallStaticCharMethodA__entry(void*, void*, uintptr_t);
|
||||
probe CallStaticCharMethodA__return(uint16_t);
|
||||
probe CallStaticCharMethod__entry(void*, void*, uintptr_t);
|
||||
probe CallStaticCharMethod__return(uint16_t);
|
||||
probe CallStaticCharMethodV__entry(void*, void*, uintptr_t);
|
||||
probe CallStaticCharMethodV__return(uint16_t);
|
||||
probe CallStaticDoubleMethodA__entry(void*, void*, uintptr_t);
|
||||
probe CallStaticDoubleMethodA__return();
|
||||
probe CallStaticDoubleMethod__entry(void*, void*, uintptr_t);
|
||||
probe CallStaticDoubleMethod__return();
|
||||
probe CallStaticDoubleMethodV__entry(void*, void*, uintptr_t);
|
||||
probe CallStaticDoubleMethodV__return();
|
||||
probe CallStaticFloatMethodA__entry(void*, void*, uintptr_t);
|
||||
probe CallStaticFloatMethodA__return();
|
||||
probe CallStaticFloatMethod__entry(void*, void*, uintptr_t);
|
||||
probe CallStaticFloatMethod__return();
|
||||
probe CallStaticFloatMethodV__entry(void*, void*, uintptr_t);
|
||||
probe CallStaticFloatMethodV__return();
|
||||
probe CallStaticIntMethodA__entry(void*, void*, uintptr_t);
|
||||
probe CallStaticIntMethodA__return(uint32_t);
|
||||
probe CallStaticIntMethod__entry(void*, void*, uintptr_t);
|
||||
probe CallStaticIntMethod__return(uint32_t);
|
||||
probe CallStaticIntMethodV__entry(void*, void*, uintptr_t);
|
||||
probe CallStaticIntMethodV__return(uint32_t);
|
||||
probe CallStaticLongMethodA__entry(void*, void*, uintptr_t);
|
||||
probe CallStaticLongMethodA__return(uintptr_t);
|
||||
probe CallStaticLongMethod__entry(void*, void*, uintptr_t);
|
||||
probe CallStaticLongMethod__return(uintptr_t);
|
||||
probe CallStaticLongMethodV__entry(void*, void*, uintptr_t);
|
||||
probe CallStaticLongMethodV__return(uintptr_t);
|
||||
probe CallStaticObjectMethodA__entry(void*, void*, uintptr_t);
|
||||
probe CallStaticObjectMethodA__return(void*);
|
||||
probe CallStaticObjectMethod__entry(void*, void*, uintptr_t);
|
||||
probe CallStaticObjectMethod__return(void*);
|
||||
probe CallStaticObjectMethodV__entry(void*, void*, uintptr_t);
|
||||
probe CallStaticObjectMethodV__return(void*);
|
||||
probe CallStaticShortMethodA__entry(void*, void*, uintptr_t);
|
||||
probe CallStaticShortMethodA__return(uint16_t);
|
||||
probe CallStaticShortMethod__entry(void*, void*, uintptr_t);
|
||||
probe CallStaticShortMethod__return(uint16_t);
|
||||
probe CallStaticShortMethodV__entry(void*, void*, uintptr_t);
|
||||
probe CallStaticShortMethodV__return(uint16_t);
|
||||
probe CallStaticVoidMethodA__entry(void*, void*, uintptr_t);
|
||||
probe CallStaticVoidMethodA__return();
|
||||
probe CallStaticVoidMethod__entry(void*, void*, uintptr_t);
|
||||
probe CallStaticVoidMethod__return();
|
||||
probe CallStaticVoidMethodV__entry(void*, void*, uintptr_t);
|
||||
probe CallStaticVoidMethodV__return();
|
||||
probe CallVoidMethodA__entry(void*, void*, uintptr_t);
|
||||
probe CallVoidMethodA__return();
|
||||
probe CallVoidMethod__entry(void*, void*, uintptr_t);
|
||||
probe CallVoidMethod__return();
|
||||
probe CallVoidMethodV__entry(void*, void*, uintptr_t);
|
||||
probe CallVoidMethodV__return();
|
||||
probe CreateJavaVM__entry(void**, void**, void*);
|
||||
probe CreateJavaVM__return(uint32_t);
|
||||
probe DefineClass__entry(void*, const char*, void*, char*, uintptr_t);
|
||||
probe DefineClass__return(void*);
|
||||
probe DeleteGlobalRef__entry(void*, void*);
|
||||
probe DeleteGlobalRef__return();
|
||||
probe DeleteLocalRef__entry(void*, void*);
|
||||
probe DeleteLocalRef__return();
|
||||
probe DeleteWeakGlobalRef__entry(void*, void*);
|
||||
probe DeleteWeakGlobalRef__return();
|
||||
probe DestroyJavaVM__entry(void*);
|
||||
probe DestroyJavaVM__return(uint32_t);
|
||||
probe DetachCurrentThread__entry(void*);
|
||||
probe DetachCurrentThread__return(uint32_t);
|
||||
probe EnsureLocalCapacity__entry(void*, uint32_t);
|
||||
probe EnsureLocalCapacity__return(uint32_t);
|
||||
probe ExceptionCheck__entry(void*);
|
||||
probe ExceptionCheck__return(uintptr_t);
|
||||
probe ExceptionClear__entry(void*);
|
||||
probe ExceptionClear__return();
|
||||
probe ExceptionDescribe__entry(void*);
|
||||
probe ExceptionDescribe__return();
|
||||
probe ExceptionOccurred__entry(void*);
|
||||
probe ExceptionOccurred__return(void*);
|
||||
probe FatalError__entry(void* env, const char*);
|
||||
probe FindClass__entry(void*, const char*);
|
||||
probe FindClass__return(void*);
|
||||
probe FromReflectedField__entry(void*, void*);
|
||||
probe FromReflectedField__return(uintptr_t);
|
||||
probe FromReflectedMethod__entry(void*, void*);
|
||||
probe FromReflectedMethod__return(uintptr_t);
|
||||
probe GetArrayLength__entry(void*, void*);
|
||||
probe GetArrayLength__return(uintptr_t);
|
||||
probe GetBooleanArrayElements__entry(void*, void*, uintptr_t*);
|
||||
probe GetBooleanArrayElements__return(uintptr_t*);
|
||||
probe GetBooleanArrayRegion__entry(void*, void*, uintptr_t, uintptr_t, uintptr_t*);
|
||||
probe GetBooleanArrayRegion__return();
|
||||
probe GetBooleanField__entry(void*, void*, uintptr_t);
|
||||
probe GetBooleanField__return(uintptr_t);
|
||||
probe GetByteArrayElements__entry(void*, void*, uintptr_t*);
|
||||
probe GetByteArrayElements__return(char*);
|
||||
probe GetByteArrayRegion__entry(void*, void*, uintptr_t, uintptr_t, char*);
|
||||
probe GetByteArrayRegion__return();
|
||||
probe GetByteField__entry(void*, void*, uintptr_t);
|
||||
probe GetByteField__return(char);
|
||||
probe GetCharArrayElements__entry(void*, void*, uintptr_t*);
|
||||
probe GetCharArrayElements__return(uint16_t*);
|
||||
probe GetCharArrayRegion__entry(void*, void*, uintptr_t, uintptr_t, uint16_t*);
|
||||
probe GetCharArrayRegion__return();
|
||||
probe GetCharField__entry(void*, void*, uintptr_t);
|
||||
probe GetCharField__return(uint16_t);
|
||||
probe GetCreatedJavaVMs__entry(void**, uintptr_t, uintptr_t*);
|
||||
probe GetCreatedJavaVMs__return(uintptr_t);
|
||||
probe GetDefaultJavaVMInitArgs__entry(void*);
|
||||
probe GetDefaultJavaVMInitArgs__return(uint32_t);
|
||||
probe GetDirectBufferAddress__entry(void*, void*);
|
||||
probe GetDirectBufferAddress__return(void*);
|
||||
probe GetDirectBufferCapacity__entry(void*, void*);
|
||||
probe GetDirectBufferCapacity__return(uintptr_t);
|
||||
probe GetDoubleArrayElements__entry(void*, void*, uintptr_t*);
|
||||
probe GetDoubleArrayElements__return(double*);
|
||||
probe GetDoubleArrayRegion__entry(void*, void*, uintptr_t, uintptr_t, double*);
|
||||
probe GetDoubleArrayRegion__return();
|
||||
probe GetDoubleField__entry(void*, void*, uintptr_t);
|
||||
probe GetDoubleField__return();
|
||||
probe GetEnv__entry(void*, void*, uint32_t);
|
||||
probe GetEnv__return(uint32_t);
|
||||
probe GetFieldID__entry(void*, void*, const char*, const char*);
|
||||
probe GetFieldID__return(uintptr_t);
|
||||
probe GetFloatArrayElements__entry(void*, void*, uintptr_t*);
|
||||
probe GetFloatArrayElements__return(float*);
|
||||
probe GetFloatArrayRegion__entry(void*, void*, uintptr_t, uintptr_t, float*);
|
||||
probe GetFloatArrayRegion__return();
|
||||
probe GetFloatField__entry(void*, void*, uintptr_t);
|
||||
probe GetFloatField__return();
|
||||
probe GetIntArrayElements__entry(void*, void*, uintptr_t*);
|
||||
probe GetIntArrayElements__return(uint32_t*);
|
||||
probe GetIntArrayRegion__entry(void*, void*, uintptr_t, uintptr_t, uint32_t*);
|
||||
probe GetIntArrayRegion__return();
|
||||
probe GetIntField__entry(void*, void*, uintptr_t);
|
||||
probe GetIntField__return(uint32_t);
|
||||
probe GetJavaVM__entry(void*, void**);
|
||||
probe GetJavaVM__return(uint32_t);
|
||||
probe GetLongArrayElements__entry(void*, void*, uintptr_t*);
|
||||
probe GetLongArrayElements__return(uintptr_t*);
|
||||
probe GetLongArrayRegion__entry(void*, void*, uintptr_t, uintptr_t, uintptr_t*);
|
||||
probe GetLongArrayRegion__return();
|
||||
probe GetLongField__entry(void*, void*, uintptr_t);
|
||||
probe GetLongField__return(uintptr_t);
|
||||
probe GetMethodID__entry(void*, void*, const char*, const char*);
|
||||
probe GetMethodID__return(uintptr_t);
|
||||
probe GetObjectArrayElement__entry(void*, void*, uintptr_t);
|
||||
probe GetObjectArrayElement__return(void*);
|
||||
probe GetObjectClass__entry(void*, void*);
|
||||
probe GetObjectClass__return(void*);
|
||||
probe GetObjectField__entry(void*, void*, uintptr_t);
|
||||
probe GetObjectField__return(void*);
|
||||
probe GetObjectRefType__entry(void*, void*);
|
||||
probe GetObjectRefType__return(void*);
|
||||
probe GetPrimitiveArrayCritical__entry(void*, void*, uintptr_t*);
|
||||
probe GetPrimitiveArrayCritical__return(void*);
|
||||
probe GetShortArrayElements__entry(void*, void*, uintptr_t*);
|
||||
probe GetShortArrayElements__return(uint16_t*);
|
||||
probe GetShortArrayRegion__entry(void*, void*, uintptr_t, uintptr_t, uint16_t*);
|
||||
probe GetShortArrayRegion__return();
|
||||
probe GetShortField__entry(void*, void*, uintptr_t);
|
||||
probe GetShortField__return(uint16_t);
|
||||
probe GetStaticBooleanField__entry(void*, void*, uintptr_t);
|
||||
probe GetStaticBooleanField__return(uintptr_t);
|
||||
probe GetStaticByteField__entry(void*, void*, uintptr_t);
|
||||
probe GetStaticByteField__return(char);
|
||||
probe GetStaticCharField__entry(void*, void*, uintptr_t);
|
||||
probe GetStaticCharField__return(uint16_t);
|
||||
probe GetStaticDoubleField__entry(void*, void*, uintptr_t);
|
||||
probe GetStaticDoubleField__return();
|
||||
probe GetStaticFieldID__entry(void*, void*, const char*, const char*);
|
||||
probe GetStaticFieldID__return(uintptr_t);
|
||||
probe GetStaticFloatField__entry(void*, void*, uintptr_t);
|
||||
probe GetStaticFloatField__return();
|
||||
probe GetStaticIntField__entry(void*, void*, uintptr_t);
|
||||
probe GetStaticIntField__return(uint32_t);
|
||||
probe GetStaticLongField__entry(void*, void*, uintptr_t);
|
||||
probe GetStaticLongField__return(uintptr_t);
|
||||
probe GetStaticMethodID__entry(void*, void*, const char*, const char*);
|
||||
probe GetStaticMethodID__return(uintptr_t);
|
||||
probe GetStaticObjectField__entry(void*, void*, uintptr_t);
|
||||
probe GetStaticObjectField__return(void*);
|
||||
probe GetStaticShortField__entry(void*, void*, uintptr_t);
|
||||
probe GetStaticShortField__return(uint16_t);
|
||||
probe GetStringChars__entry(void*, void*, uintptr_t*);
|
||||
probe GetStringChars__return(const uint16_t*);
|
||||
probe GetStringCritical__entry(void*, void*, uintptr_t*);
|
||||
probe GetStringCritical__return(const uint16_t*);
|
||||
probe GetStringLength__entry(void*, void*);
|
||||
probe GetStringLength__return(uintptr_t);
|
||||
probe GetStringRegion__entry(void*, void*, uintptr_t, uintptr_t, uint16_t*);
|
||||
probe GetStringRegion__return();
|
||||
probe GetStringUTFChars__entry(void*, void*, uintptr_t*);
|
||||
probe GetStringUTFChars__return(const char*);
|
||||
probe GetStringUTFLength__entry(void*, void*);
|
||||
probe GetStringUTFLength__return(uintptr_t);
|
||||
probe GetStringUTFRegion__entry(void*, void*, uintptr_t, uintptr_t, char*);
|
||||
probe GetStringUTFRegion__return();
|
||||
probe GetSuperclass__entry(void*, void*);
|
||||
probe GetSuperclass__return(void*);
|
||||
probe GetVersion__entry(void*);
|
||||
probe GetVersion__return(uint32_t);
|
||||
probe IsAssignableFrom__entry(void*, void*, void*);
|
||||
probe IsAssignableFrom__return(uintptr_t);
|
||||
probe IsInstanceOf__entry(void*, void*, void*);
|
||||
probe IsInstanceOf__return(uintptr_t);
|
||||
probe IsSameObject__entry(void*, void*, void*);
|
||||
probe IsSameObject__return(uintptr_t);
|
||||
probe MonitorEnter__entry(void*, void*);
|
||||
probe MonitorEnter__return(uint32_t);
|
||||
probe MonitorExit__entry(void*, void*);
|
||||
probe MonitorExit__return(uint32_t);
|
||||
probe NewBooleanArray__entry(void*, uintptr_t);
|
||||
probe NewBooleanArray__return(void*);
|
||||
probe NewByteArray__entry(void*, uintptr_t);
|
||||
probe NewByteArray__return(void*);
|
||||
probe NewCharArray__entry(void*, uintptr_t);
|
||||
probe NewCharArray__return(void*);
|
||||
probe NewDirectByteBuffer__entry(void*, void*, uintptr_t);
|
||||
probe NewDirectByteBuffer__return(void*);
|
||||
probe NewDoubleArray__entry(void*, uintptr_t);
|
||||
probe NewDoubleArray__return(void*);
|
||||
probe NewFloatArray__entry(void*, uintptr_t);
|
||||
probe NewFloatArray__return(void*);
|
||||
probe NewGlobalRef__entry(void*, void*);
|
||||
probe NewGlobalRef__return(void*);
|
||||
probe NewIntArray__entry(void*, uintptr_t);
|
||||
probe NewIntArray__return(void*);
|
||||
probe NewLocalRef__entry(void*, void*);
|
||||
probe NewLocalRef__return(void*);
|
||||
probe NewLongArray__entry(void*, uintptr_t);
|
||||
probe NewLongArray__return(void*);
|
||||
probe NewObjectA__entry(void*, void*, uintptr_t);
|
||||
probe NewObjectA__return(void*);
|
||||
probe NewObjectArray__entry(void*, uintptr_t, void*, void*);
|
||||
probe NewObjectArray__return(void*);
|
||||
probe NewObject__entry(void*, void*, uintptr_t);
|
||||
probe NewObject__return(void*);
|
||||
probe NewObjectV__entry(void*, void*, uintptr_t);
|
||||
probe NewObjectV__return(void*);
|
||||
probe NewShortArray__entry(void*, uintptr_t);
|
||||
probe NewShortArray__return(void*);
|
||||
probe NewString__entry(void*, const uint16_t*, uintptr_t);
|
||||
probe NewString__return(void*);
|
||||
probe NewStringUTF__entry(void*, const char*);
|
||||
probe NewStringUTF__return(void*);
|
||||
probe NewWeakGlobalRef__entry(void*, void*);
|
||||
probe NewWeakGlobalRef__return(void*);
|
||||
probe PopLocalFrame__entry(void*, void*);
|
||||
probe PopLocalFrame__return(void*);
|
||||
probe PushLocalFrame__entry(void*, uint32_t);
|
||||
probe PushLocalFrame__return(uint32_t);
|
||||
probe RegisterNatives__entry(void*, void*, const void*, uint32_t);
|
||||
probe RegisterNatives__return(uint32_t);
|
||||
probe ReleaseBooleanArrayElements__entry(void*, void*, uintptr_t*, uint32_t);
|
||||
probe ReleaseBooleanArrayElements__return();
|
||||
probe ReleaseByteArrayElements__entry(void*, void*, char*, uint32_t);
|
||||
probe ReleaseByteArrayElements__return();
|
||||
probe ReleaseCharArrayElements__entry(void*, void*, uint16_t*, uint32_t);
|
||||
probe ReleaseCharArrayElements__return();
|
||||
probe ReleaseDoubleArrayElements__entry(void*, void*, double*, uint32_t);
|
||||
probe ReleaseDoubleArrayElements__return();
|
||||
probe ReleaseFloatArrayElements__entry(void*, void*, float*, uint32_t);
|
||||
probe ReleaseFloatArrayElements__return();
|
||||
probe ReleaseIntArrayElements__entry(void*, void*, uint32_t*, uint32_t);
|
||||
probe ReleaseIntArrayElements__return();
|
||||
probe ReleaseLongArrayElements__entry(void*, void*, uintptr_t*, uint32_t);
|
||||
probe ReleaseLongArrayElements__return();
|
||||
probe ReleasePrimitiveArrayCritical__entry(void*, void*, void*, uint32_t);
|
||||
probe ReleasePrimitiveArrayCritical__return();
|
||||
probe ReleaseShortArrayElements__entry(void*, void*, uint16_t*, uint32_t);
|
||||
probe ReleaseShortArrayElements__return();
|
||||
probe ReleaseStringChars__entry(void*, void*, const uint16_t*);
|
||||
probe ReleaseStringChars__return();
|
||||
probe ReleaseStringCritical__entry(void*, void*, const uint16_t*);
|
||||
probe ReleaseStringCritical__return();
|
||||
probe ReleaseStringUTFChars__entry(void*, void*, const char*);
|
||||
probe ReleaseStringUTFChars__return();
|
||||
probe SetBooleanArrayRegion__entry(void*, void*, uintptr_t, uintptr_t, const uintptr_t*);
|
||||
probe SetBooleanArrayRegion__return();
|
||||
probe SetBooleanField__entry(void*, void*, uintptr_t, uintptr_t);
|
||||
probe SetBooleanField__return();
|
||||
probe SetByteArrayRegion__entry(void*, void*, uintptr_t, uintptr_t, const char*);
|
||||
probe SetByteArrayRegion__return();
|
||||
probe SetByteField__entry(void*, void*, uintptr_t, char);
|
||||
probe SetByteField__return();
|
||||
probe SetCharArrayRegion__entry(void*, void*, uintptr_t, uintptr_t, const uint16_t*);
|
||||
probe SetCharArrayRegion__return();
|
||||
probe SetCharField__entry(void*, void*, uintptr_t, uint16_t);
|
||||
probe SetCharField__return();
|
||||
probe SetDoubleArrayRegion__entry(void*, void*, uintptr_t, uintptr_t, const double*);
|
||||
probe SetDoubleArrayRegion__return();
|
||||
probe SetDoubleField__entry(void*, void*, uintptr_t);
|
||||
probe SetDoubleField__return();
|
||||
probe SetFloatArrayRegion__entry(void*, void*, uintptr_t, uintptr_t, const float*);
|
||||
probe SetFloatArrayRegion__return();
|
||||
probe SetFloatField__entry(void*, void*, uintptr_t);
|
||||
probe SetFloatField__return();
|
||||
probe SetIntArrayRegion__entry(void*, void*, uintptr_t, uintptr_t, const uint32_t*);
|
||||
probe SetIntArrayRegion__return();
|
||||
probe SetIntField__entry(void*, void*, uintptr_t, uint32_t);
|
||||
probe SetIntField__return();
|
||||
probe SetLongArrayRegion__entry(void*, void*, uintptr_t, uintptr_t, const uintptr_t*);
|
||||
probe SetLongArrayRegion__return();
|
||||
probe SetLongField__entry(void*, void*, uintptr_t, uintptr_t);
|
||||
probe SetLongField__return();
|
||||
probe SetObjectArrayElement__entry(void*, void*, uintptr_t, void*);
|
||||
probe SetObjectArrayElement__return();
|
||||
probe SetObjectField__entry(void*, void*, uintptr_t, void*);
|
||||
probe SetObjectField__return();
|
||||
probe SetShortArrayRegion__entry(void*, void*, uintptr_t, uintptr_t, const uint16_t*);
|
||||
probe SetShortArrayRegion__return();
|
||||
probe SetShortField__entry(void*, void*, uintptr_t, uint16_t);
|
||||
probe SetShortField__return();
|
||||
probe SetStaticBooleanField__entry(void*, void*, uintptr_t, uintptr_t);
|
||||
probe SetStaticBooleanField__return();
|
||||
probe SetStaticByteField__entry(void*, void*, uintptr_t, char);
|
||||
probe SetStaticByteField__return();
|
||||
probe SetStaticCharField__entry(void*, void*, uintptr_t, uint16_t);
|
||||
probe SetStaticCharField__return();
|
||||
probe SetStaticDoubleField__entry(void*, void*, uintptr_t);
|
||||
probe SetStaticDoubleField__return();
|
||||
probe SetStaticFloatField__entry(void*, void*, uintptr_t);
|
||||
probe SetStaticFloatField__return();
|
||||
probe SetStaticIntField__entry(void*, void*, uintptr_t, uint32_t);
|
||||
probe SetStaticIntField__return();
|
||||
probe SetStaticLongField__entry(void*, void*, uintptr_t, uintptr_t);
|
||||
probe SetStaticLongField__return();
|
||||
probe SetStaticObjectField__entry(void*, void*, uintptr_t, void*);
|
||||
probe SetStaticObjectField__return();
|
||||
probe SetStaticShortField__entry(void*, void*, uintptr_t, uint16_t);
|
||||
probe SetStaticShortField__return();
|
||||
probe Throw__entry(void*, void*);
|
||||
probe Throw__return(intptr_t);
|
||||
probe ThrowNew__entry(void*, void*, const char*);
|
||||
probe ThrowNew__return(intptr_t);
|
||||
probe ToReflectedField__entry(void*, void*, uintptr_t, uintptr_t);
|
||||
probe ToReflectedField__return(void*);
|
||||
probe ToReflectedMethod__entry(void*, void*, uintptr_t, uintptr_t);
|
||||
probe ToReflectedMethod__return(void*);
|
||||
probe UnregisterNatives__entry(void*, void*);
|
||||
probe UnregisterNatives__return(uint32_t);
|
||||
};
|
||||
|
||||
#pragma D attributes Standard/Standard/Common provider hotspot_jni provider
|
||||
#pragma D attributes Private/Private/Unknown provider hotspot_jni module
|
||||
#pragma D attributes Private/Private/Unknown provider hotspot_jni function
|
||||
#pragma D attributes Standard/Standard/Common provider hotspot_jni name
|
||||
#pragma D attributes Evolving/Evolving/Common provider hotspot_jni args
|
||||
|
||||
@ -2441,13 +2441,14 @@ void os::jvm_path(char *buf, jint buflen) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (Arguments::created_by_gamma_launcher()) {
|
||||
// Support for the gamma launcher. Typical value for buf is
|
||||
// "<JAVA_HOME>/jre/lib/<arch>/<vmtype>/libjvm.so". If "/jre/lib/" appears at
|
||||
// the right place in the string, then assume we are installed in a JDK and
|
||||
// we're done. Otherwise, check for a JAVA_HOME environment variable and fix
|
||||
// up the path so it looks like libjvm.so is installed there (append a
|
||||
// fake suffix hotspot/libjvm.so).
|
||||
if (Arguments::sun_java_launcher_is_altjvm()) {
|
||||
// Support for the java launcher's '-XXaltjvm=<path>' option. Typical
|
||||
// value for buf is "<JAVA_HOME>/jre/lib/<arch>/<vmtype>/libjvm.so".
|
||||
// If "/jre/lib/" appears at the right place in the string, then
|
||||
// assume we are installed in a JDK and we're done. Otherwise, check
|
||||
// for a JAVA_HOME environment variable and fix up the path so it
|
||||
// looks like libjvm.so is installed there (append a fake suffix
|
||||
// hotspot/libjvm.so).
|
||||
const char *p = buf + strlen(buf) - 1;
|
||||
for (int count = 0; p > buf && count < 5; ++count) {
|
||||
for (--p; p > buf && *p != '/'; --p)
|
||||
|
||||
@ -1810,32 +1810,30 @@ void os::jvm_path(char *buf, jint buflen) {
|
||||
}
|
||||
|
||||
buf[0] = '\0';
|
||||
if (Arguments::created_by_gamma_launcher()) {
|
||||
// Support for the gamma launcher. Check for an
|
||||
// JAVA_HOME environment variable
|
||||
// and fix up the path so it looks like
|
||||
// libjvm.so is installed there (append a fake suffix
|
||||
// hotspot/libjvm.so).
|
||||
char* java_home_var = ::getenv("JAVA_HOME");
|
||||
if (java_home_var != NULL && java_home_var[0] != 0) {
|
||||
if (Arguments::sun_java_launcher_is_altjvm()) {
|
||||
// Support for the java launcher's '-XXaltjvm=<path>' option. Check
|
||||
// for a JAVA_HOME environment variable and fix up the path so it
|
||||
// looks like jvm.dll is installed there (append a fake suffix
|
||||
// hotspot/jvm.dll).
|
||||
char* java_home_var = ::getenv("JAVA_HOME");
|
||||
if (java_home_var != NULL && java_home_var[0] != 0) {
|
||||
strncpy(buf, java_home_var, buflen);
|
||||
|
||||
strncpy(buf, java_home_var, buflen);
|
||||
|
||||
// determine if this is a legacy image or modules image
|
||||
// modules image doesn't have "jre" subdirectory
|
||||
size_t len = strlen(buf);
|
||||
char* jrebin_p = buf + len;
|
||||
jio_snprintf(jrebin_p, buflen-len, "\\jre\\bin\\");
|
||||
if (0 != _access(buf, 0)) {
|
||||
jio_snprintf(jrebin_p, buflen-len, "\\bin\\");
|
||||
}
|
||||
len = strlen(buf);
|
||||
jio_snprintf(buf + len, buflen-len, "hotspot\\jvm.dll");
|
||||
}
|
||||
// determine if this is a legacy image or modules image
|
||||
// modules image doesn't have "jre" subdirectory
|
||||
size_t len = strlen(buf);
|
||||
char* jrebin_p = buf + len;
|
||||
jio_snprintf(jrebin_p, buflen-len, "\\jre\\bin\\");
|
||||
if (0 != _access(buf, 0)) {
|
||||
jio_snprintf(jrebin_p, buflen-len, "\\bin\\");
|
||||
}
|
||||
len = strlen(buf);
|
||||
jio_snprintf(buf + len, buflen-len, "hotspot\\jvm.dll");
|
||||
}
|
||||
}
|
||||
|
||||
if(buf[0] == '\0') {
|
||||
GetModuleFileName(vm_lib_handle, buf, buflen);
|
||||
if (buf[0] == '\0') {
|
||||
GetModuleFileName(vm_lib_handle, buf, buflen);
|
||||
}
|
||||
strcpy(saved_jvm_path, buf);
|
||||
}
|
||||
|
||||
@ -161,7 +161,18 @@ public class WinGammaPlatformVC10 extends WinGammaPlatformVC7 {
|
||||
for (BuildConfig cfg : allConfigs) {
|
||||
startTag(cfg, "PropertyGroup");
|
||||
tagData("LocalDebuggerCommand", cfg.get("JdkTargetRoot") + "\\bin\\java.exe");
|
||||
tagData("LocalDebuggerCommandArguments", "-XXaltjvm=$(TargetDir) -Dsun.java.launcher=gamma");
|
||||
// The JVM loads some libraries using a path relative to
|
||||
// itself because it expects to be in a JRE or a JDK. The java
|
||||
// launcher's '-XXaltjvm=' option allows the JVM to be outside
|
||||
// the JRE or JDK so '-Dsun.java.launcher.is_altjvm=true'
|
||||
// forces a fake JAVA_HOME relative path to be used to
|
||||
// find the other libraries. The '-XX:+PauseAtExit' option
|
||||
// causes the VM to wait for key press before exiting; this
|
||||
// allows any stdout or stderr messages to be seen before
|
||||
// the cmdtool exits.
|
||||
tagData("LocalDebuggerCommandArguments", "-XXaltjvm=$(TargetDir) "
|
||||
+ "-Dsun.java.launcher.is_altjvm=true "
|
||||
+ "-XX:+UnlockDiagnosticVMOptions -XX:+PauseAtExit");
|
||||
tagData("LocalDebuggerEnvironment", "JAVA_HOME=" + cfg.get("JdkTargetRoot"));
|
||||
endTag();
|
||||
}
|
||||
|
||||
@ -564,16 +564,7 @@ void LinkResolver::resolve_method(methodHandle& resolved_method, KlassHandle res
|
||||
}
|
||||
}
|
||||
|
||||
// 5. check if method is concrete
|
||||
if (resolved_method->is_abstract() && !resolved_klass->is_abstract()) {
|
||||
ResourceMark rm(THREAD);
|
||||
THROW_MSG(vmSymbols::java_lang_AbstractMethodError(),
|
||||
Method::name_and_sig_as_C_string(resolved_klass(),
|
||||
method_name,
|
||||
method_signature));
|
||||
}
|
||||
|
||||
// 6. access checks, access checking may be turned off when calling from within the VM.
|
||||
// 5. access checks, access checking may be turned off when calling from within the VM.
|
||||
if (check_access) {
|
||||
assert(current_klass.not_null() , "current_klass should not be null");
|
||||
|
||||
|
||||
@ -1320,9 +1320,13 @@ static void jni_invoke_nonstatic(JNIEnv *env, JavaValue* result, jobject receive
|
||||
// interface call
|
||||
KlassHandle h_holder(THREAD, holder);
|
||||
|
||||
int itbl_index = m->itable_index();
|
||||
Klass* k = h_recv->klass();
|
||||
selected_method = InstanceKlass::cast(k)->method_at_itable(h_holder(), itbl_index, CHECK);
|
||||
if (call_type == JNI_VIRTUAL) {
|
||||
int itbl_index = m->itable_index();
|
||||
Klass* k = h_recv->klass();
|
||||
selected_method = InstanceKlass::cast(k)->method_at_itable(h_holder(), itbl_index, CHECK);
|
||||
} else {
|
||||
selected_method = m;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -1360,8 +1360,10 @@ JvmtiEnv::GetFrameCount(JavaThread* java_thread, jint* count_ptr) {
|
||||
if (state == NULL) {
|
||||
return JVMTI_ERROR_THREAD_NOT_ALIVE;
|
||||
}
|
||||
uint32_t debug_bits = 0;
|
||||
if (is_thread_fully_suspended(java_thread, true, &debug_bits)) {
|
||||
|
||||
// It is only safe to perform the direct operation on the current
|
||||
// thread. All other usage needs to use a vm-safepoint-op for safety.
|
||||
if (java_thread == JavaThread::current()) {
|
||||
err = get_frame_count(state, count_ptr);
|
||||
} else {
|
||||
// get java stack frame count at safepoint.
|
||||
@ -1476,9 +1478,10 @@ JvmtiEnv::PopFrame(JavaThread* java_thread) {
|
||||
jvmtiError
|
||||
JvmtiEnv::GetFrameLocation(JavaThread* java_thread, jint depth, jmethodID* method_ptr, jlocation* location_ptr) {
|
||||
jvmtiError err = JVMTI_ERROR_NONE;
|
||||
uint32_t debug_bits = 0;
|
||||
|
||||
if (is_thread_fully_suspended(java_thread, true, &debug_bits)) {
|
||||
// It is only safe to perform the direct operation on the current
|
||||
// thread. All other usage needs to use a vm-safepoint-op for safety.
|
||||
if (java_thread == JavaThread::current()) {
|
||||
err = get_frame_location(java_thread, depth, method_ptr, location_ptr);
|
||||
} else {
|
||||
// JVMTI get java stack frame location at safepoint.
|
||||
|
||||
@ -533,7 +533,11 @@ public:
|
||||
VMOp_Type type() const { return VMOp_GetFrameCount; }
|
||||
jvmtiError result() { return _result; }
|
||||
void doit() {
|
||||
_result = ((JvmtiEnvBase*)_env)->get_frame_count(_state, _count_ptr);
|
||||
_result = JVMTI_ERROR_THREAD_NOT_ALIVE;
|
||||
JavaThread* jt = _state->get_thread();
|
||||
if (Threads::includes(jt) && !jt->is_exiting() && jt->threadObj() != NULL) {
|
||||
_result = ((JvmtiEnvBase*)_env)->get_frame_count(_state, _count_ptr);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
@ -559,8 +563,12 @@ public:
|
||||
VMOp_Type type() const { return VMOp_GetFrameLocation; }
|
||||
jvmtiError result() { return _result; }
|
||||
void doit() {
|
||||
_result = ((JvmtiEnvBase*)_env)->get_frame_location(_java_thread, _depth,
|
||||
_method_ptr, _location_ptr);
|
||||
_result = JVMTI_ERROR_THREAD_NOT_ALIVE;
|
||||
if (Threads::includes(_java_thread) && !_java_thread->is_exiting() &&
|
||||
_java_thread->threadObj() != NULL) {
|
||||
_result = ((JvmtiEnvBase*)_env)->get_frame_location(_java_thread, _depth,
|
||||
_method_ptr, _location_ptr);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
@ -101,7 +101,7 @@ 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::_sun_java_launcher_is_altjvm = false;
|
||||
|
||||
// These parameters are reset in method parse_vm_init_args(JavaVMInitArgs*)
|
||||
bool Arguments::_AlwaysCompileLoopMethods = AlwaysCompileLoopMethods;
|
||||
@ -151,7 +151,8 @@ static void logOption(const char* opt) {
|
||||
|
||||
// Process java launcher properties.
|
||||
void Arguments::process_sun_java_launcher_properties(JavaVMInitArgs* args) {
|
||||
// See if sun.java.launcher or sun.java.launcher.pid is defined.
|
||||
// See if sun.java.launcher, sun.java.launcher.is_altjvm or
|
||||
// sun.java.launcher.pid is defined.
|
||||
// Must do this before setting up other system properties,
|
||||
// as some of them may depend on launcher type.
|
||||
for (int index = 0; index < args->nOptions; index++) {
|
||||
@ -162,6 +163,12 @@ void Arguments::process_sun_java_launcher_properties(JavaVMInitArgs* args) {
|
||||
process_java_launcher_argument(tail, option->extraInfo);
|
||||
continue;
|
||||
}
|
||||
if (match_option(option, "-Dsun.java.launcher.is_altjvm=", &tail)) {
|
||||
if (strcmp(tail, "true") == 0) {
|
||||
_sun_java_launcher_is_altjvm = true;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
if (match_option(option, "-Dsun.java.launcher.pid=", &tail)) {
|
||||
_sun_java_launcher_pid = atoi(tail);
|
||||
continue;
|
||||
@ -1013,9 +1020,10 @@ bool Arguments::add_property(const char* prop) {
|
||||
_java_command = value;
|
||||
|
||||
// Record value in Arguments, but let it get passed to Java.
|
||||
} else if (strcmp(key, "sun.java.launcher.pid") == 0) {
|
||||
// launcher.pid property is private and is processed
|
||||
// in process_sun_java_launcher_properties();
|
||||
} else if (strcmp(key, "sun.java.launcher.is_altjvm") == 0 ||
|
||||
strcmp(key, "sun.java.launcher.pid") == 0) {
|
||||
// sun.java.launcher.is_altjvm and sun.java.launcher.pid property are
|
||||
// private and are processed in process_sun_java_launcher_properties();
|
||||
// the sun.java.launcher property is passed on to the java application
|
||||
FreeHeap(key);
|
||||
if (eq != NULL) {
|
||||
@ -1810,9 +1818,6 @@ void Arguments::process_java_compiler_argument(char* arg) {
|
||||
|
||||
void Arguments::process_java_launcher_argument(const char* launcher, void* extra_info) {
|
||||
_sun_java_launcher = strdup(launcher);
|
||||
if (strcmp("gamma", _sun_java_launcher) == 0) {
|
||||
_created_by_gamma_launcher = true;
|
||||
}
|
||||
}
|
||||
|
||||
bool Arguments::created_by_java_launcher() {
|
||||
@ -1820,8 +1825,8 @@ bool Arguments::created_by_java_launcher() {
|
||||
return strcmp(DEFAULT_JAVA_LAUNCHER, _sun_java_launcher) != 0;
|
||||
}
|
||||
|
||||
bool Arguments::created_by_gamma_launcher() {
|
||||
return _created_by_gamma_launcher;
|
||||
bool Arguments::sun_java_launcher_is_altjvm() {
|
||||
return _sun_java_launcher_is_altjvm;
|
||||
}
|
||||
|
||||
//===========================================================================================================
|
||||
@ -3809,16 +3814,6 @@ jint Arguments::apply_ergo() {
|
||||
}
|
||||
}
|
||||
|
||||
// set PauseAtExit if the gamma launcher was used and a debugger is attached
|
||||
// but only if not already set on the commandline
|
||||
if (Arguments::created_by_gamma_launcher() && os::is_debugger_attached()) {
|
||||
bool set = false;
|
||||
CommandLineFlags::wasSetOnCmdline("PauseAtExit", &set);
|
||||
if (!set) {
|
||||
FLAG_SET_DEFAULT(PauseAtExit, true);
|
||||
}
|
||||
}
|
||||
|
||||
return JNI_OK;
|
||||
}
|
||||
|
||||
|
||||
@ -269,14 +269,14 @@ class Arguments : AllStatic {
|
||||
static const char* _java_vendor_url_bug;
|
||||
|
||||
// sun.java.launcher, private property to provide information about
|
||||
// java/gamma launcher
|
||||
// java launcher
|
||||
static const char* _sun_java_launcher;
|
||||
|
||||
// sun.java.launcher.pid, private property
|
||||
static int _sun_java_launcher_pid;
|
||||
|
||||
// was this VM created by the gamma launcher
|
||||
static bool _created_by_gamma_launcher;
|
||||
// was this VM created via the -XXaltjvm=<path> option
|
||||
static bool _sun_java_launcher_is_altjvm;
|
||||
|
||||
// Option flags
|
||||
static bool _has_profile;
|
||||
@ -498,8 +498,8 @@ class Arguments : AllStatic {
|
||||
static const char* sun_java_launcher() { return _sun_java_launcher; }
|
||||
// Was VM created by a Java launcher?
|
||||
static bool created_by_java_launcher();
|
||||
// Was VM created by the gamma Java launcher?
|
||||
static bool created_by_gamma_launcher();
|
||||
// -Dsun.java.launcher.is_altjvm
|
||||
static bool sun_java_launcher_is_altjvm();
|
||||
// -Dsun.java.launcher.pid
|
||||
static int sun_java_launcher_pid() { return _sun_java_launcher_pid; }
|
||||
|
||||
|
||||
@ -38,24 +38,20 @@
|
||||
#define HS_DTRACE_WORKAROUND_TAIL_CALL_BUG() \
|
||||
do { volatile size_t dtrace_workaround_tail_call_bug = 1; } while (0)
|
||||
|
||||
#define USDT2 1
|
||||
#include "dtracefiles/hotspot.h"
|
||||
#include "dtracefiles/hotspot_jni.h"
|
||||
#include "dtracefiles/hs_private.h"
|
||||
#elif defined(LINUX)
|
||||
#define HS_DTRACE_WORKAROUND_TAIL_CALL_BUG()
|
||||
#define USDT1 1
|
||||
#elif defined(__APPLE__)
|
||||
#define HS_DTRACE_WORKAROUND_TAIL_CALL_BUG()
|
||||
#define USDT2 1
|
||||
#include <sys/types.h>
|
||||
#include "dtracefiles/hotspot.h"
|
||||
#include "dtracefiles/hotspot_jni.h"
|
||||
#include "dtracefiles/hs_private.h"
|
||||
#else
|
||||
#error "dtrace enabled for unknown os"
|
||||
#endif /* defined(SOLARIS) */
|
||||
|
||||
#define USDT2 1
|
||||
#include "dtracefiles/hotspot.h"
|
||||
#include "dtracefiles/hotspot_jni.h"
|
||||
#include "dtracefiles/hs_private.h"
|
||||
|
||||
#else /* defined(DTRACE_ENABLED) */
|
||||
|
||||
#define DTRACE_ONLY(x)
|
||||
|
||||
@ -0,0 +1,181 @@
|
||||
/*
|
||||
* Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
|
||||
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
||||
*
|
||||
* This code is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU General Public License version 2 only, as
|
||||
* published by the Free Software Foundation.
|
||||
*
|
||||
* This code is distributed in the hope that it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
* version 2 for more details (a copy is included in the LICENSE file that
|
||||
* accompanied this code).
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License version
|
||||
* 2 along with this work; if not, write to the Free Software Foundation,
|
||||
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*
|
||||
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
||||
* or visit www.oracle.com if you need additional information or have any
|
||||
* questions.
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* @test
|
||||
* @bug 8032010
|
||||
* @summary method lookup on an abstract method in a concrete class should be successful
|
||||
* @run main TestConcreteClassWithAbstractMethod
|
||||
*/
|
||||
|
||||
import jdk.internal.org.objectweb.asm.ClassWriter;
|
||||
import jdk.internal.org.objectweb.asm.MethodVisitor;
|
||||
|
||||
import static jdk.internal.org.objectweb.asm.Opcodes.*;
|
||||
|
||||
/*
|
||||
* class T1 { public int m() {} }
|
||||
* class T2 { public abstract int m(); }
|
||||
* class T3 { public int m() {} }
|
||||
*
|
||||
* Call site: T3.test() { invokevirtual T2.m() }
|
||||
* T3.m() should be invoked
|
||||
*/
|
||||
public class TestConcreteClassWithAbstractMethod {
|
||||
static final String classT1 = "p1.T1";
|
||||
static final String classT2 = "p1.T2";
|
||||
static final String classT3 = "p1.T3";
|
||||
|
||||
static final String callerName = classT3;
|
||||
|
||||
public static void main(String[] args) throws Exception {
|
||||
ClassLoader cl = new ClassLoader() {
|
||||
public Class<?> loadClass(String name) throws ClassNotFoundException {
|
||||
if (findLoadedClass(name) != null) {
|
||||
return findLoadedClass(name);
|
||||
}
|
||||
|
||||
if (classT1.equals(name)) {
|
||||
byte[] classFile = dumpT1();
|
||||
return defineClass(classT1, classFile, 0, classFile.length);
|
||||
}
|
||||
if (classT2.equals(name)) {
|
||||
byte[] classFile = dumpT2();
|
||||
return defineClass(classT2, classFile, 0, classFile.length);
|
||||
}
|
||||
if (classT3.equals(name)) {
|
||||
byte[] classFile = dumpT3();
|
||||
return defineClass(classT3, classFile, 0, classFile.length);
|
||||
}
|
||||
|
||||
return super.loadClass(name);
|
||||
}
|
||||
};
|
||||
|
||||
cl.loadClass(classT1);
|
||||
cl.loadClass(classT2);
|
||||
cl.loadClass(classT3);
|
||||
|
||||
//cl.loadClass(callerName).getDeclaredMethod("m");
|
||||
cl.loadClass(callerName).newInstance();
|
||||
|
||||
int result = (Integer)cl.loadClass(callerName).getDeclaredMethod("test").invoke(null);
|
||||
System.out.println(""+result);
|
||||
}
|
||||
|
||||
public static byte[] dumpT1() {
|
||||
ClassWriter cw = new ClassWriter(0);
|
||||
MethodVisitor mv;
|
||||
|
||||
cw.visit(52, ACC_PUBLIC | ACC_SUPER, "p1/T1", null, "java/lang/Object", null);
|
||||
{
|
||||
mv = cw.visitMethod(ACC_PUBLIC, "<init>", "()V", null, null);
|
||||
mv.visitCode();
|
||||
mv.visitVarInsn(ALOAD, 0);
|
||||
mv.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
|
||||
mv.visitInsn(RETURN);
|
||||
mv.visitMaxs(1, 1);
|
||||
mv.visitEnd();
|
||||
}
|
||||
{
|
||||
mv = cw.visitMethod(ACC_PUBLIC, "m", "()I", null, null);
|
||||
mv.visitCode();
|
||||
mv.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
|
||||
mv.visitLdcInsn("p1/T1.m()");
|
||||
mv.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "print", "(Ljava/lang/String;)V", false);
|
||||
mv.visitIntInsn(BIPUSH, 3);
|
||||
mv.visitInsn(IRETURN);
|
||||
mv.visitMaxs(2, 1);
|
||||
mv.visitEnd();
|
||||
}
|
||||
cw.visitEnd();
|
||||
|
||||
return cw.toByteArray();
|
||||
}
|
||||
|
||||
public static byte[] dumpT2() {
|
||||
ClassWriter cw = new ClassWriter(0);
|
||||
MethodVisitor mv;
|
||||
|
||||
cw.visit(52, ACC_PUBLIC | ACC_SUPER, "p1/T2", null, "p1/T1", null);
|
||||
{
|
||||
mv = cw.visitMethod(ACC_PUBLIC, "<init>", "()V", null, null);
|
||||
mv.visitCode();
|
||||
mv.visitVarInsn(ALOAD, 0);
|
||||
mv.visitMethodInsn(INVOKESPECIAL, "p1/T1", "<init>", "()V", false);
|
||||
mv.visitInsn(RETURN);
|
||||
mv.visitMaxs(1, 1);
|
||||
mv.visitEnd();
|
||||
}
|
||||
{
|
||||
mv = cw.visitMethod(ACC_PUBLIC + ACC_ABSTRACT, "m", "()I", null, null);
|
||||
mv.visitEnd();
|
||||
}
|
||||
cw.visitEnd();
|
||||
|
||||
return cw.toByteArray();
|
||||
}
|
||||
|
||||
public static byte[] dumpT3() {
|
||||
ClassWriter cw = new ClassWriter(0);
|
||||
MethodVisitor mv;
|
||||
|
||||
cw.visit(52, ACC_PUBLIC + ACC_SUPER, "p1/T3", null, "p1/T2", null);
|
||||
|
||||
{
|
||||
mv = cw.visitMethod(ACC_PUBLIC, "<init>", "()V", null, null);
|
||||
mv.visitCode();
|
||||
mv.visitVarInsn(ALOAD, 0);
|
||||
mv.visitMethodInsn(INVOKESPECIAL, "p1/T2", "<init>", "()V", false);
|
||||
mv.visitInsn(RETURN);
|
||||
mv.visitMaxs(1, 1);
|
||||
mv.visitEnd();
|
||||
}
|
||||
{
|
||||
mv = cw.visitMethod(ACC_PUBLIC, "m", "()I", null, null);
|
||||
mv.visitCode();
|
||||
mv.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
|
||||
mv.visitLdcInsn("p1/T3.m()");
|
||||
mv.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "print", "(Ljava/lang/String;)V", false);
|
||||
mv.visitIntInsn(BIPUSH, 2);
|
||||
mv.visitInsn(IRETURN);
|
||||
mv.visitMaxs(2, 1);
|
||||
mv.visitEnd();
|
||||
}
|
||||
{
|
||||
mv = cw.visitMethod(ACC_PUBLIC + ACC_STATIC, "test", "()I", null, null);
|
||||
mv.visitCode();
|
||||
mv.visitTypeInsn(NEW, "p1/T3");
|
||||
mv.visitInsn(DUP);
|
||||
mv.visitMethodInsn(INVOKESPECIAL, "p1/T3", "<init>", "()V", false);
|
||||
mv.visitMethodInsn(INVOKEVIRTUAL, "p1/T2", "m", "()I", false);
|
||||
mv.visitInsn(IRETURN);
|
||||
mv.visitMaxs(3, 2);
|
||||
mv.visitEnd();
|
||||
}
|
||||
cw.visitEnd();
|
||||
|
||||
return cw.toByteArray();
|
||||
}
|
||||
}
|
||||
Loading…
x
Reference in New Issue
Block a user