archive/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2025-09-20 19:14:38 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge

Browse source
This commit is contained in:
Vladimir Kozlov 2014-01-24 09:04:24 -08:00
commit 6e8540ca72
77 changed files with 1733 additions and 925 deletions
Download patch file Download diff file Expand all files Collapse all files

4
hotspot/agent/src/os/linux/symtab.c
View file

@ -214,8 +214,10 @@ static int open_file_from_debug_link(const char *name,
+ 2); + 2);
strcpy(debug_pathname, name); strcpy(debug_pathname, name);
char *last_slash = strrchr(debug_pathname, '/'); char *last_slash = strrchr(debug_pathname, '/');
if (last_slash == NULL) if (last_slash == NULL) {
free(debug_pathname);
return -1; return -1;
}
/* Look in the same directory as the object. */ /* Look in the same directory as the object. */
strcpy(last_slash+1, debug_filename); strcpy(last_slash+1, debug_filename);

31
hotspot/agent/src/share/classes/sun/jvm/hotspot/jdi/ArrayTypeImpl.java
View file

@ -24,19 +24,29 @@
package sun.jvm.hotspot.jdi; package sun.jvm.hotspot.jdi;
import com.sun.jdi.*; import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import sun.jvm.hotspot.oops.ArrayKlass; import sun.jvm.hotspot.oops.ArrayKlass;
import sun.jvm.hotspot.oops.InstanceKlass;
import sun.jvm.hotspot.oops.ObjArrayKlass;
import sun.jvm.hotspot.oops.TypeArrayKlass;
import sun.jvm.hotspot.oops.Klass;
import sun.jvm.hotspot.oops.Instance; import sun.jvm.hotspot.oops.Instance;
import sun.jvm.hotspot.oops.InstanceKlass;
import sun.jvm.hotspot.oops.Klass;
import sun.jvm.hotspot.oops.ObjArrayKlass;
import sun.jvm.hotspot.oops.Symbol; import sun.jvm.hotspot.oops.Symbol;
import java.util.List; import sun.jvm.hotspot.oops.TypeArrayKlass;
import java.util.ArrayList;
import java.util.Iterator; import com.sun.jdi.ArrayReference;
import java.util.Map; import com.sun.jdi.ArrayType;
import com.sun.jdi.ClassLoaderReference;
import com.sun.jdi.ClassNotLoadedException;
import com.sun.jdi.InterfaceType;
import com.sun.jdi.Method;
import com.sun.jdi.PrimitiveType;
import com.sun.jdi.ReferenceType;
import com.sun.jdi.Type;
import com.sun.jdi.VirtualMachine;
public class ArrayTypeImpl extends ReferenceTypeImpl implements ArrayType { public class ArrayTypeImpl extends ReferenceTypeImpl implements ArrayType {
protected ArrayTypeImpl(VirtualMachine aVm, ArrayKlass aRef) { protected ArrayTypeImpl(VirtualMachine aVm, ArrayKlass aRef) {
@ -75,7 +85,8 @@ public class ArrayTypeImpl extends ReferenceTypeImpl implements ArrayType {
} }
} }
void addVisibleMethods(Map methodMap) { @Override
void addVisibleMethods(Map<String, Method> methodMap, Set<InterfaceType> handledInterfaces) {
// arrays don't have methods // arrays don't have methods
} }

38
hotspot/agent/src/share/classes/sun/jvm/hotspot/jdi/ClassTypeImpl.java
View file

@ -24,12 +24,30 @@
package sun.jvm.hotspot.jdi; package sun.jvm.hotspot.jdi;
import com.sun.jdi.*; import java.lang.ref.SoftReference;
import sun.jvm.hotspot.oops.Klass; import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import sun.jvm.hotspot.oops.InstanceKlass; import sun.jvm.hotspot.oops.InstanceKlass;
import java.util.*; import com.sun.jdi.ClassNotLoadedException;
import java.lang.ref.SoftReference; import com.sun.jdi.ClassType;
import com.sun.jdi.Field;
import com.sun.jdi.IncompatibleThreadStateException;
import com.sun.jdi.InterfaceType;
import com.sun.jdi.InvalidTypeException;
import com.sun.jdi.InvocationException;
import com.sun.jdi.Method;
import com.sun.jdi.ObjectReference;
import com.sun.jdi.ReferenceType;
import com.sun.jdi.ThreadReference;
import com.sun.jdi.Value;
import com.sun.jdi.VirtualMachine;
public class ClassTypeImpl extends ReferenceTypeImpl public class ClassTypeImpl extends ReferenceTypeImpl
implements ClassType implements ClassType
@ -195,22 +213,26 @@ public class ClassTypeImpl extends ReferenceTypeImpl
return null; return null;
} }
void addVisibleMethods(Map methodMap) { @Override
void addVisibleMethods(Map<String, Method> methodMap, Set<InterfaceType> seenInterfaces) {
/* /*
* Add methods from * Add methods from
* parent types first, so that the methods in this class will * parent types first, so that the methods in this class will
* overwrite them in the hash table * overwrite them in the hash table
*/ */
Iterator iter = interfaces().iterator(); Iterator<InterfaceType> iter = interfaces().iterator();
while (iter.hasNext()) { while (iter.hasNext()) {
InterfaceTypeImpl interfaze = (InterfaceTypeImpl)iter.next(); InterfaceTypeImpl interfaze = (InterfaceTypeImpl)iter.next();
interfaze.addVisibleMethods(methodMap); if (!seenInterfaces.contains(interfaze)) {
interfaze.addVisibleMethods(methodMap, seenInterfaces);
seenInterfaces.add(interfaze);
}
} }
ClassTypeImpl clazz = (ClassTypeImpl)superclass(); ClassTypeImpl clazz = (ClassTypeImpl)superclass();
if (clazz != null) { if (clazz != null) {
clazz.addVisibleMethods(methodMap); clazz.addVisibleMethods(methodMap, seenInterfaces);
} }
addToMethodMap(methodMap, methods()); addToMethodMap(methodMap, methods());

31
hotspot/agent/src/share/classes/sun/jvm/hotspot/jdi/InterfaceTypeImpl.java
View file

@ -24,15 +24,22 @@
package sun.jvm.hotspot.jdi; package sun.jvm.hotspot.jdi;
import com.sun.jdi.*; import java.lang.ref.SoftReference;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import sun.jvm.hotspot.oops.InstanceKlass; import sun.jvm.hotspot.oops.InstanceKlass;
import java.util.List; import com.sun.jdi.ClassNotPreparedException;
import java.util.ArrayList; import com.sun.jdi.ClassType;
import java.util.Map; import com.sun.jdi.InterfaceType;
import java.util.Iterator; import com.sun.jdi.Method;
import java.util.Collections; import com.sun.jdi.ReferenceType;
import java.lang.ref.SoftReference; import com.sun.jdi.VirtualMachine;
public class InterfaceTypeImpl extends ReferenceTypeImpl public class InterfaceTypeImpl extends ReferenceTypeImpl
implements InterfaceType { implements InterfaceType {
@ -96,16 +103,20 @@ public class InterfaceTypeImpl extends ReferenceTypeImpl
return implementors; return implementors;
} }
void addVisibleMethods(Map methodMap) { @Override
void addVisibleMethods(Map<String, Method> methodMap, Set<InterfaceType> seenInterfaces) {
/* /*
* Add methods from * Add methods from
* parent types first, so that the methods in this class will * parent types first, so that the methods in this class will
* overwrite them in the hash table * overwrite them in the hash table
*/ */
Iterator iter = superinterfaces().iterator(); Iterator<InterfaceType> iter = superinterfaces().iterator();
while (iter.hasNext()) { while (iter.hasNext()) {
InterfaceTypeImpl interfaze = (InterfaceTypeImpl)iter.next(); InterfaceTypeImpl interfaze = (InterfaceTypeImpl)iter.next();
interfaze.addVisibleMethods(methodMap); if (!seenInterfaces.contains(interfaze)) {
interfaze.addVisibleMethods(methodMap, seenInterfaces);
seenInterfaces.add(interfaze);
}
} }
addToMethodMap(methodMap, methods()); addToMethodMap(methodMap, methods());

46
hotspot/agent/src/share/classes/sun/jvm/hotspot/jdi/ReferenceTypeImpl.java
View file

@ -24,24 +24,45 @@
package sun.jvm.hotspot.jdi; package sun.jvm.hotspot.jdi;
import java.io.*; import java.io.ByteArrayOutputStream;
import java.io.IOException;
import com.sun.jdi.*; import java.lang.ref.SoftReference;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import sun.jvm.hotspot.memory.SystemDictionary; import sun.jvm.hotspot.memory.SystemDictionary;
import sun.jvm.hotspot.oops.ArrayKlass;
import sun.jvm.hotspot.oops.DefaultHeapVisitor;
import sun.jvm.hotspot.oops.Instance; import sun.jvm.hotspot.oops.Instance;
import sun.jvm.hotspot.oops.InstanceKlass; import sun.jvm.hotspot.oops.InstanceKlass;
import sun.jvm.hotspot.oops.ArrayKlass;
import sun.jvm.hotspot.oops.JVMDIClassStatus; import sun.jvm.hotspot.oops.JVMDIClassStatus;
import sun.jvm.hotspot.oops.Klass; import sun.jvm.hotspot.oops.Klass;
import sun.jvm.hotspot.oops.ObjArray;
import sun.jvm.hotspot.oops.Oop; import sun.jvm.hotspot.oops.Oop;
import sun.jvm.hotspot.oops.Symbol; import sun.jvm.hotspot.oops.Symbol;
import sun.jvm.hotspot.oops.DefaultHeapVisitor;
import sun.jvm.hotspot.utilities.Assert; import sun.jvm.hotspot.utilities.Assert;
import java.util.*; import com.sun.jdi.AbsentInformationException;
import java.lang.ref.SoftReference; import com.sun.jdi.ArrayType;
import com.sun.jdi.ClassLoaderReference;
import com.sun.jdi.ClassNotLoadedException;
import com.sun.jdi.ClassNotPreparedException;
import com.sun.jdi.ClassObjectReference;
import com.sun.jdi.Field;
import com.sun.jdi.InterfaceType;
import com.sun.jdi.Method;
import com.sun.jdi.ObjectReference;
import com.sun.jdi.PrimitiveType;
import com.sun.jdi.ReferenceType;
import com.sun.jdi.Type;
import com.sun.jdi.Value;
import com.sun.jdi.VirtualMachine;
public abstract class ReferenceTypeImpl extends TypeImpl public abstract class ReferenceTypeImpl extends TypeImpl
implements ReferenceType { implements ReferenceType {
@ -421,7 +442,8 @@ implements ReferenceType {
} }
} }
abstract void addVisibleMethods(Map methodMap); abstract void addVisibleMethods(Map<String, Method> methodMap, Set<InterfaceType> seenInterfaces);
public final List visibleMethods() throws ClassNotPreparedException { public final List visibleMethods() throws ClassNotPreparedException {
checkPrepared(); checkPrepared();
/* /*
@ -430,8 +452,8 @@ implements ReferenceType {
* concatenation of name and signature. * concatenation of name and signature.
*/ */
//System.out.println("jj: RTI: Calling addVisibleMethods for:" + this); //System.out.println("jj: RTI: Calling addVisibleMethods for:" + this);
Map map = new HashMap(); Map<String, Method> map = new HashMap<String, Method>();
addVisibleMethods(map); addVisibleMethods(map, new HashSet<InterfaceType>());
/* /*
* ... but the hash map destroys order. Methods should be * ... but the hash map destroys order. Methods should be
@ -441,7 +463,7 @@ implements ReferenceType {
*/ */
//System.out.println("jj: RTI: Calling allMethods for:" + this); //System.out.println("jj: RTI: Calling allMethods for:" + this);
List list = new ArrayList(allMethods()); List<Method> list = new ArrayList<Method>(allMethods());
//System.out.println("jj: allMethods = " + jjstr(list)); //System.out.println("jj: allMethods = " + jjstr(list));
//System.out.println("jj: map = " + map.toString()); //System.out.println("jj: map = " + map.toString());
//System.out.println("jj: map = " + jjstr(map.values())); //System.out.println("jj: map = " + jjstr(map.values()));

2
hotspot/make/bsd/makefiles/adjust-mflags.sh
View file

@ -64,7 +64,7 @@ MFLAGS=`
echo "$MFLAGS" \ echo "$MFLAGS" \
| sed ' | sed '
s/^-/ -/ s/^-/ -/
s/ -\([^ ][^ ]*\)j/ -\1 -j/ s/ -\([^ I][^ I]*\)j/ -\1 -j/
s/ -j[0-9][0-9]*/ -j/ s/ -j[0-9][0-9]*/ -j/
s/ -j\([^ ]\)/ -j -\1/ s/ -j\([^ ]\)/ -j -\1/
s/ -j/ -j'${HOTSPOT_BUILD_JOBS:-${default_build_jobs}}'/ s/ -j/ -j'${HOTSPOT_BUILD_JOBS:-${default_build_jobs}}'/

3
hotspot/make/bsd/makefiles/debug.make
View file

@ -36,6 +36,9 @@ CFLAGS += $(DEBUG_CFLAGS/BYFILE) -D_NMT_NOINLINE_
# Linker mapfile # Linker mapfile
MAPFILE = $(GAMMADIR)/make/bsd/makefiles/mapfile-vers-debug MAPFILE = $(GAMMADIR)/make/bsd/makefiles/mapfile-vers-debug
ifeq ($(OS_VENDOR), Darwin)
MAPFILE = $(GAMMADIR)/make/bsd/makefiles/mapfile-vers-darwin-debug
endif
VERSION = debug VERSION = debug
SYSDEFS += -DASSERT SYSDEFS += -DASSERT

3
hotspot/make/bsd/makefiles/fastdebug.make
View file

@ -57,6 +57,9 @@ CFLAGS$(HOTSPARC_GENERIC) += $(OPT_CFLAGS/BYFILE)
# Linker mapfile # Linker mapfile
MAPFILE = $(GAMMADIR)/make/bsd/makefiles/mapfile-vers-debug MAPFILE = $(GAMMADIR)/make/bsd/makefiles/mapfile-vers-debug
ifeq ($(OS_VENDOR), Darwin)
MAPFILE = $(GAMMADIR)/make/bsd/makefiles/mapfile-vers-darwin-debug
endif
VERSION = fastdebug VERSION = fastdebug
SYSDEFS += -DASSERT -DCHECK_UNHANDLED_OOPS SYSDEFS += -DASSERT -DCHECK_UNHANDLED_OOPS

256
hotspot/make/bsd/makefiles/mapfile-vers-darwin-debug Normal file
View file

@ -0,0 +1,256 @@
#
# Copyright (c) 2002, 2013, 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.
#
#
# Only used for OSX/Darwin builds
# Define public interface.
# _JNI
_JNI_CreateJavaVM
_JNI_GetCreatedJavaVMs
_JNI_GetDefaultJavaVMInitArgs
# _JVM
_JVM_Accept
_JVM_ActiveProcessorCount
_JVM_AllocateNewArray
_JVM_AllocateNewObject
_JVM_ArrayCopy
_JVM_AssertionStatusDirectives
_JVM_Available
_JVM_Bind
_JVM_ClassDepth
_JVM_ClassLoaderDepth
_JVM_Clone
_JVM_Close
_JVM_CX8Field
_JVM_CompileClass
_JVM_CompileClasses
_JVM_CompilerCommand
_JVM_Connect
_JVM_ConstantPoolGetClassAt
_JVM_ConstantPoolGetClassAtIfLoaded
_JVM_ConstantPoolGetDoubleAt
_JVM_ConstantPoolGetFieldAt
_JVM_ConstantPoolGetFieldAtIfLoaded
_JVM_ConstantPoolGetFloatAt
_JVM_ConstantPoolGetIntAt
_JVM_ConstantPoolGetLongAt
_JVM_ConstantPoolGetMethodAt
_JVM_ConstantPoolGetMethodAtIfLoaded
_JVM_ConstantPoolGetMemberRefInfoAt
_JVM_ConstantPoolGetSize
_JVM_ConstantPoolGetStringAt
_JVM_ConstantPoolGetUTF8At
_JVM_CountStackFrames
_JVM_CurrentClassLoader
_JVM_CurrentLoadedClass
_JVM_CurrentThread
_JVM_CurrentTimeMillis
_JVM_DefineClass
_JVM_DefineClassWithSource
_JVM_DefineClassWithSourceCond
_JVM_DesiredAssertionStatus
_JVM_DisableCompiler
_JVM_DoPrivileged
_JVM_DTraceGetVersion
_JVM_DTraceActivate
_JVM_DTraceIsProbeEnabled
_JVM_DTraceIsSupported
_JVM_DTraceDispose
_JVM_DumpAllStacks
_JVM_DumpThreads
_JVM_EnableCompiler
_JVM_Exit
_JVM_FillInStackTrace
_JVM_FindClassFromClass
_JVM_FindClassFromClassLoader
_JVM_FindClassFromBootLoader
_JVM_FindLibraryEntry
_JVM_FindLoadedClass
_JVM_FindPrimitiveClass
_JVM_FindSignal
_JVM_FreeMemory
_JVM_GC
_JVM_GetAllThreads
_JVM_GetArrayElement
_JVM_GetArrayLength
_JVM_GetCPClassNameUTF
_JVM_GetCPFieldClassNameUTF
_JVM_GetCPFieldModifiers
_JVM_GetCPFieldNameUTF
_JVM_GetCPFieldSignatureUTF
_JVM_GetCPMethodClassNameUTF
_JVM_GetCPMethodModifiers
_JVM_GetCPMethodNameUTF
_JVM_GetCPMethodSignatureUTF
_JVM_GetCallerClass
_JVM_GetClassAccessFlags
_JVM_GetClassAnnotations
_JVM_GetClassCPEntriesCount
_JVM_GetClassCPTypes
_JVM_GetClassConstantPool
_JVM_GetClassContext
_JVM_GetClassDeclaredConstructors
_JVM_GetClassDeclaredFields
_JVM_GetClassDeclaredMethods
_JVM_GetClassFieldsCount
_JVM_GetClassInterfaces
_JVM_GetClassLoader
_JVM_GetClassMethodsCount
_JVM_GetClassModifiers
_JVM_GetClassName
_JVM_GetClassNameUTF
_JVM_GetClassSignature
_JVM_GetClassSigners
_JVM_GetClassTypeAnnotations
_JVM_GetComponentType
_JVM_GetDeclaredClasses
_JVM_GetDeclaringClass
_JVM_GetEnclosingMethodInfo
_JVM_GetFieldAnnotations
_JVM_GetFieldIxModifiers
_JVM_GetFieldTypeAnnotations
_JVM_GetHostName
_JVM_GetInheritedAccessControlContext
_JVM_GetInterfaceVersion
_JVM_GetLastErrorString
_JVM_GetManagement
_JVM_GetMethodAnnotations
_JVM_GetMethodDefaultAnnotationValue
_JVM_GetMethodIxArgsSize
_JVM_GetMethodIxByteCode
_JVM_GetMethodIxByteCodeLength
_JVM_GetMethodIxExceptionIndexes
_JVM_GetMethodIxExceptionTableEntry
_JVM_GetMethodIxExceptionTableLength
_JVM_GetMethodIxExceptionsCount
_JVM_GetMethodIxLocalsCount
_JVM_GetMethodIxMaxStack
_JVM_GetMethodIxModifiers
_JVM_GetMethodIxNameUTF
_JVM_GetMethodIxSignatureUTF
_JVM_GetMethodParameterAnnotations
_JVM_GetMethodParameters
_JVM_GetMethodTypeAnnotations
_JVM_GetPrimitiveArrayElement
_JVM_GetProtectionDomain
_JVM_GetSockName
_JVM_GetSockOpt
_JVM_GetStackAccessControlContext
_JVM_GetStackTraceDepth
_JVM_GetStackTraceElement
_JVM_GetSystemPackage
_JVM_GetSystemPackages
_JVM_GetThreadStateNames
_JVM_GetThreadStateValues
_JVM_GetVersionInfo
_JVM_Halt
_JVM_HoldsLock
_JVM_IHashCode
_JVM_InitAgentProperties
_JVM_InitProperties
_JVM_InitializeCompiler
_JVM_InitializeSocketLibrary
_JVM_InternString
_JVM_Interrupt
_JVM_InvokeMethod
_JVM_IsArrayClass
_JVM_IsConstructorIx
_JVM_IsInterface
_JVM_IsInterrupted
_JVM_IsNaN
_JVM_IsPrimitiveClass
_JVM_IsSameClassPackage
_JVM_IsSilentCompiler
_JVM_IsSupportedJNIVersion
_JVM_IsThreadAlive
_JVM_IsVMGeneratedMethodIx
_JVM_LatestUserDefinedLoader
_JVM_Listen
_JVM_LoadClass0
_JVM_LoadLibrary
_JVM_Lseek
_JVM_MaxObjectInspectionAge
_JVM_MaxMemory
_JVM_MonitorNotify
_JVM_MonitorNotifyAll
_JVM_MonitorWait
_JVM_NanoTime
_JVM_NativePath
_JVM_NewArray
_JVM_NewInstanceFromConstructor
_JVM_NewMultiArray
_JVM_OnExit
_JVM_Open
_JVM_RaiseSignal
_JVM_RawMonitorCreate
_JVM_RawMonitorDestroy
_JVM_RawMonitorEnter
_JVM_RawMonitorExit
_JVM_Read
_JVM_Recv
_JVM_RecvFrom
_JVM_RegisterSignal
_JVM_ReleaseUTF
_JVM_ResolveClass
_JVM_ResumeThread
_JVM_Send
_JVM_SendTo
_JVM_SetArrayElement
_JVM_SetClassSigners
_JVM_SetLength
_JVM_SetNativeThreadName
_JVM_SetPrimitiveArrayElement
_JVM_SetSockOpt
_JVM_SetThreadPriority
_JVM_Sleep
_JVM_Socket
_JVM_SocketAvailable
_JVM_SocketClose
_JVM_SocketShutdown
_JVM_StartThread
_JVM_StopThread
_JVM_SuspendThread
_JVM_SupportsCX8
_JVM_Sync
_JVM_Timeout
_JVM_TotalMemory
_JVM_TraceInstructions
_JVM_TraceMethodCalls
_JVM_UnloadLibrary
_JVM_Write
_JVM_Yield
_JVM_handle_bsd_signal
# miscellaneous functions
_jio_fprintf
_jio_printf
_jio_snprintf
_jio_vfprintf
_jio_vsnprintf
# This is for Forte Analyzer profiling support.
_AsyncGetCallTrace
# INSERT VTABLE SYMBOLS HERE

256
hotspot/make/bsd/makefiles/mapfile-vers-darwin-product Normal file
View file

@ -0,0 +1,256 @@
#
# Copyright (c) 2002, 2013, 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.
#
#
# Only used for OSX/Darwin builds
# Define public interface.
# _JNI
_JNI_CreateJavaVM
_JNI_GetCreatedJavaVMs
_JNI_GetDefaultJavaVMInitArgs
# _JVM
_JVM_Accept
_JVM_ActiveProcessorCount
_JVM_AllocateNewArray
_JVM_AllocateNewObject
_JVM_ArrayCopy
_JVM_AssertionStatusDirectives
_JVM_Available
_JVM_Bind
_JVM_ClassDepth
_JVM_ClassLoaderDepth
_JVM_Clone
_JVM_Close
_JVM_CX8Field
_JVM_CompileClass
_JVM_CompileClasses
_JVM_CompilerCommand
_JVM_Connect
_JVM_ConstantPoolGetClassAt
_JVM_ConstantPoolGetClassAtIfLoaded
_JVM_ConstantPoolGetDoubleAt
_JVM_ConstantPoolGetFieldAt
_JVM_ConstantPoolGetFieldAtIfLoaded
_JVM_ConstantPoolGetFloatAt
_JVM_ConstantPoolGetIntAt
_JVM_ConstantPoolGetLongAt
_JVM_ConstantPoolGetMethodAt
_JVM_ConstantPoolGetMethodAtIfLoaded
_JVM_ConstantPoolGetMemberRefInfoAt
_JVM_ConstantPoolGetSize
_JVM_ConstantPoolGetStringAt
_JVM_ConstantPoolGetUTF8At
_JVM_CountStackFrames
_JVM_CurrentClassLoader
_JVM_CurrentLoadedClass
_JVM_CurrentThread
_JVM_CurrentTimeMillis
_JVM_DefineClass
_JVM_DefineClassWithSource
_JVM_DefineClassWithSourceCond
_JVM_DesiredAssertionStatus
_JVM_DisableCompiler
_JVM_DoPrivileged
_JVM_DTraceGetVersion
_JVM_DTraceActivate
_JVM_DTraceIsProbeEnabled
_JVM_DTraceIsSupported
_JVM_DTraceDispose
_JVM_DumpAllStacks
_JVM_DumpThreads
_JVM_EnableCompiler
_JVM_Exit
_JVM_FillInStackTrace
_JVM_FindClassFromClass
_JVM_FindClassFromClassLoader
_JVM_FindClassFromBootLoader
_JVM_FindLibraryEntry
_JVM_FindLoadedClass
_JVM_FindPrimitiveClass
_JVM_FindSignal
_JVM_FreeMemory
_JVM_GC
_JVM_GetAllThreads
_JVM_GetArrayElement
_JVM_GetArrayLength
_JVM_GetCPClassNameUTF
_JVM_GetCPFieldClassNameUTF
_JVM_GetCPFieldModifiers
_JVM_GetCPFieldNameUTF
_JVM_GetCPFieldSignatureUTF
_JVM_GetCPMethodClassNameUTF
_JVM_GetCPMethodModifiers
_JVM_GetCPMethodNameUTF
_JVM_GetCPMethodSignatureUTF
_JVM_GetCallerClass
_JVM_GetClassAccessFlags
_JVM_GetClassAnnotations
_JVM_GetClassCPEntriesCount
_JVM_GetClassCPTypes
_JVM_GetClassConstantPool
_JVM_GetClassContext
_JVM_GetClassDeclaredConstructors
_JVM_GetClassDeclaredFields
_JVM_GetClassDeclaredMethods
_JVM_GetClassFieldsCount
_JVM_GetClassInterfaces
_JVM_GetClassLoader
_JVM_GetClassMethodsCount
_JVM_GetClassModifiers
_JVM_GetClassName
_JVM_GetClassNameUTF
_JVM_GetClassSignature
_JVM_GetClassSigners
_JVM_GetClassTypeAnnotations
_JVM_GetComponentType
_JVM_GetDeclaredClasses
_JVM_GetDeclaringClass
_JVM_GetEnclosingMethodInfo
_JVM_GetFieldAnnotations
_JVM_GetFieldIxModifiers
_JVM_GetFieldTypeAnnotations
_JVM_GetHostName
_JVM_GetInheritedAccessControlContext
_JVM_GetInterfaceVersion
_JVM_GetLastErrorString
_JVM_GetManagement
_JVM_GetMethodAnnotations
_JVM_GetMethodDefaultAnnotationValue
_JVM_GetMethodIxArgsSize
_JVM_GetMethodIxByteCode
_JVM_GetMethodIxByteCodeLength
_JVM_GetMethodIxExceptionIndexes
_JVM_GetMethodIxExceptionTableEntry
_JVM_GetMethodIxExceptionTableLength
_JVM_GetMethodIxExceptionsCount
_JVM_GetMethodIxLocalsCount
_JVM_GetMethodIxMaxStack
_JVM_GetMethodIxModifiers
_JVM_GetMethodIxNameUTF
_JVM_GetMethodIxSignatureUTF
_JVM_GetMethodParameterAnnotations
_JVM_GetMethodParameters
_JVM_GetMethodTypeAnnotations
_JVM_GetPrimitiveArrayElement
_JVM_GetProtectionDomain
_JVM_GetSockName
_JVM_GetSockOpt
_JVM_GetStackAccessControlContext
_JVM_GetStackTraceDepth
_JVM_GetStackTraceElement
_JVM_GetSystemPackage
_JVM_GetSystemPackages
_JVM_GetThreadStateNames
_JVM_GetThreadStateValues
_JVM_GetVersionInfo
_JVM_Halt
_JVM_HoldsLock
_JVM_IHashCode
_JVM_InitAgentProperties
_JVM_InitProperties
_JVM_InitializeCompiler
_JVM_InitializeSocketLibrary
_JVM_InternString
_JVM_Interrupt
_JVM_InvokeMethod
_JVM_IsArrayClass
_JVM_IsConstructorIx
_JVM_IsInterface
_JVM_IsInterrupted
_JVM_IsNaN
_JVM_IsPrimitiveClass
_JVM_IsSameClassPackage
_JVM_IsSilentCompiler
_JVM_IsSupportedJNIVersion
_JVM_IsThreadAlive
_JVM_IsVMGeneratedMethodIx
_JVM_LatestUserDefinedLoader
_JVM_Listen
_JVM_LoadClass0
_JVM_LoadLibrary
_JVM_Lseek
_JVM_MaxObjectInspectionAge
_JVM_MaxMemory
_JVM_MonitorNotify
_JVM_MonitorNotifyAll
_JVM_MonitorWait
_JVM_NanoTime
_JVM_NativePath
_JVM_NewArray
_JVM_NewInstanceFromConstructor
_JVM_NewMultiArray
_JVM_OnExit
_JVM_Open
_JVM_RaiseSignal
_JVM_RawMonitorCreate
_JVM_RawMonitorDestroy
_JVM_RawMonitorEnter
_JVM_RawMonitorExit
_JVM_Read
_JVM_Recv
_JVM_RecvFrom
_JVM_RegisterSignal
_JVM_ReleaseUTF
_JVM_ResolveClass
_JVM_ResumeThread
_JVM_Send
_JVM_SendTo
_JVM_SetArrayElement
_JVM_SetClassSigners
_JVM_SetLength
_JVM_SetNativeThreadName
_JVM_SetPrimitiveArrayElement
_JVM_SetSockOpt
_JVM_SetThreadPriority
_JVM_Sleep
_JVM_Socket
_JVM_SocketAvailable
_JVM_SocketClose
_JVM_SocketShutdown
_JVM_StartThread
_JVM_StopThread
_JVM_SuspendThread
_JVM_SupportsCX8
_JVM_Sync
_JVM_Timeout
_JVM_TotalMemory
_JVM_TraceInstructions
_JVM_TraceMethodCalls
_JVM_UnloadLibrary
_JVM_Write
_JVM_Yield
_JVM_handle_bsd_signal
# miscellaneous functions
_jio_fprintf
_jio_printf
_jio_snprintf
_jio_vfprintf
_jio_vsnprintf
# This is for Forte Analyzer profiling support.
_AsyncGetCallTrace
# INSERT VTABLE SYMBOLS HERE

465
hotspot/make/bsd/makefiles/mapfile-vers-debug
View file

@ -19,243 +19,250 @@
# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 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 # or visit www.oracle.com if you need additional information or have any
# questions. # questions.
#
# #
#
# Only used for OSX/Darwin builds
# Define public interface. # Define public interface.
# _JNI
_JNI_CreateJavaVM
_JNI_GetCreatedJavaVMs
_JNI_GetDefaultJavaVMInitArgs
# _JVM SUNWprivate_1.1 {
_JVM_Accept global:
_JVM_ActiveProcessorCount # JNI
_JVM_AllocateNewArray JNI_CreateJavaVM;
_JVM_AllocateNewObject JNI_GetCreatedJavaVMs;
_JVM_ArrayCopy JNI_GetDefaultJavaVMInitArgs;
_JVM_AssertionStatusDirectives
_JVM_Available
_JVM_Bind
_JVM_ClassDepth
_JVM_ClassLoaderDepth
_JVM_Clone
_JVM_Close
_JVM_CX8Field
_JVM_CompileClass
_JVM_CompileClasses
_JVM_CompilerCommand
_JVM_Connect
_JVM_ConstantPoolGetClassAt
_JVM_ConstantPoolGetClassAtIfLoaded
_JVM_ConstantPoolGetDoubleAt
_JVM_ConstantPoolGetFieldAt
_JVM_ConstantPoolGetFieldAtIfLoaded
_JVM_ConstantPoolGetFloatAt
_JVM_ConstantPoolGetIntAt
_JVM_ConstantPoolGetLongAt
_JVM_ConstantPoolGetMethodAt
_JVM_ConstantPoolGetMethodAtIfLoaded
_JVM_ConstantPoolGetMemberRefInfoAt
_JVM_ConstantPoolGetSize
_JVM_ConstantPoolGetStringAt
_JVM_ConstantPoolGetUTF8At
_JVM_CountStackFrames
_JVM_CurrentClassLoader
_JVM_CurrentLoadedClass
_JVM_CurrentThread
_JVM_CurrentTimeMillis
_JVM_DefineClass
_JVM_DefineClassWithSource
_JVM_DefineClassWithSourceCond
_JVM_DesiredAssertionStatus
_JVM_DisableCompiler
_JVM_DoPrivileged
_JVM_DTraceGetVersion
_JVM_DTraceActivate
_JVM_DTraceIsProbeEnabled
_JVM_DTraceIsSupported
_JVM_DTraceDispose
_JVM_DumpAllStacks
_JVM_DumpThreads
_JVM_EnableCompiler
_JVM_Exit
_JVM_FillInStackTrace
_JVM_FindClassFromClass
_JVM_FindClassFromClassLoader
_JVM_FindClassFromBootLoader
_JVM_FindLibraryEntry
_JVM_FindLoadedClass
_JVM_FindPrimitiveClass
_JVM_FindSignal
_JVM_FreeMemory
_JVM_GC
_JVM_GetAllThreads
_JVM_GetArrayElement
_JVM_GetArrayLength
_JVM_GetCPClassNameUTF
_JVM_GetCPFieldClassNameUTF
_JVM_GetCPFieldModifiers
_JVM_GetCPFieldNameUTF
_JVM_GetCPFieldSignatureUTF
_JVM_GetCPMethodClassNameUTF
_JVM_GetCPMethodModifiers
_JVM_GetCPMethodNameUTF
_JVM_GetCPMethodSignatureUTF
_JVM_GetCallerClass
_JVM_GetClassAccessFlags
_JVM_GetClassAnnotations
_JVM_GetClassCPEntriesCount
_JVM_GetClassCPTypes
_JVM_GetClassConstantPool
_JVM_GetClassContext
_JVM_GetClassDeclaredConstructors
_JVM_GetClassDeclaredFields
_JVM_GetClassDeclaredMethods
_JVM_GetClassFieldsCount
_JVM_GetClassInterfaces
_JVM_GetClassLoader
_JVM_GetClassMethodsCount
_JVM_GetClassModifiers
_JVM_GetClassName
_JVM_GetClassNameUTF
_JVM_GetClassSignature
_JVM_GetClassSigners
_JVM_GetClassTypeAnnotations
_JVM_GetComponentType
_JVM_GetDeclaredClasses
_JVM_GetDeclaringClass
_JVM_GetEnclosingMethodInfo
_JVM_GetFieldAnnotations
_JVM_GetFieldIxModifiers
_JVM_GetFieldTypeAnnotations
_JVM_GetHostName
_JVM_GetInheritedAccessControlContext
_JVM_GetInterfaceVersion
_JVM_GetLastErrorString
_JVM_GetManagement
_JVM_GetMethodAnnotations
_JVM_GetMethodDefaultAnnotationValue
_JVM_GetMethodIxArgsSize
_JVM_GetMethodIxByteCode
_JVM_GetMethodIxByteCodeLength
_JVM_GetMethodIxExceptionIndexes
_JVM_GetMethodIxExceptionTableEntry
_JVM_GetMethodIxExceptionTableLength
_JVM_GetMethodIxExceptionsCount
_JVM_GetMethodIxLocalsCount
_JVM_GetMethodIxMaxStack
_JVM_GetMethodIxModifiers
_JVM_GetMethodIxNameUTF
_JVM_GetMethodIxSignatureUTF
_JVM_GetMethodParameterAnnotations
_JVM_GetMethodParameters
_JVM_GetMethodTypeAnnotations
_JVM_GetPrimitiveArrayElement
_JVM_GetProtectionDomain
_JVM_GetSockName
_JVM_GetSockOpt
_JVM_GetStackAccessControlContext
_JVM_GetStackTraceDepth
_JVM_GetStackTraceElement
_JVM_GetSystemPackage
_JVM_GetSystemPackages
_JVM_GetThreadStateNames
_JVM_GetThreadStateValues
_JVM_GetVersionInfo
_JVM_Halt
_JVM_HoldsLock
_JVM_IHashCode
_JVM_InitAgentProperties
_JVM_InitProperties
_JVM_InitializeCompiler
_JVM_InitializeSocketLibrary
_JVM_InternString
_JVM_Interrupt
_JVM_InvokeMethod
_JVM_IsArrayClass
_JVM_IsConstructorIx
_JVM_IsInterface
_JVM_IsInterrupted
_JVM_IsNaN
_JVM_IsPrimitiveClass
_JVM_IsSameClassPackage
_JVM_IsSilentCompiler
_JVM_IsSupportedJNIVersion
_JVM_IsThreadAlive
_JVM_IsVMGeneratedMethodIx
_JVM_LatestUserDefinedLoader
_JVM_Listen
_JVM_LoadClass0
_JVM_LoadLibrary
_JVM_Lseek
_JVM_MaxObjectInspectionAge
_JVM_MaxMemory
_JVM_MonitorNotify
_JVM_MonitorNotifyAll
_JVM_MonitorWait
_JVM_NanoTime
_JVM_NativePath
_JVM_NewArray
_JVM_NewInstanceFromConstructor
_JVM_NewMultiArray
_JVM_OnExit
_JVM_Open
_JVM_RaiseSignal
_JVM_RawMonitorCreate
_JVM_RawMonitorDestroy
_JVM_RawMonitorEnter
_JVM_RawMonitorExit
_JVM_Read
_JVM_Recv
_JVM_RecvFrom
_JVM_RegisterSignal
_JVM_ReleaseUTF
_JVM_ResolveClass
_JVM_ResumeThread
_JVM_Send
_JVM_SendTo
_JVM_SetArrayElement
_JVM_SetClassSigners
_JVM_SetLength
_JVM_SetNativeThreadName
_JVM_SetPrimitiveArrayElement
_JVM_SetSockOpt
_JVM_SetThreadPriority
_JVM_Sleep
_JVM_Socket
_JVM_SocketAvailable
_JVM_SocketClose
_JVM_SocketShutdown
_JVM_StartThread
_JVM_StopThread
_JVM_SuspendThread
_JVM_SupportsCX8
_JVM_Sync
_JVM_Timeout
_JVM_TotalMemory
_JVM_TraceInstructions
_JVM_TraceMethodCalls
_JVM_UnloadLibrary
_JVM_Write
_JVM_Yield
_JVM_handle_bsd_signal
# debug _JVM # JVM
_JVM_AccessVMBooleanFlag JVM_Accept;
_JVM_AccessVMIntFlag JVM_ActiveProcessorCount;
_JVM_VMBreakPoint JVM_AllocateNewArray;
JVM_AllocateNewObject;
JVM_ArrayCopy;
JVM_AssertionStatusDirectives;
JVM_Available;
JVM_Bind;
JVM_ClassDepth;
JVM_ClassLoaderDepth;
JVM_Clone;
JVM_Close;
JVM_CX8Field;
JVM_CompileClass;
JVM_CompileClasses;
JVM_CompilerCommand;
JVM_Connect;
JVM_ConstantPoolGetClassAt;
JVM_ConstantPoolGetClassAtIfLoaded;
JVM_ConstantPoolGetDoubleAt;
JVM_ConstantPoolGetFieldAt;
JVM_ConstantPoolGetFieldAtIfLoaded;
JVM_ConstantPoolGetFloatAt;
JVM_ConstantPoolGetIntAt;
JVM_ConstantPoolGetLongAt;
JVM_ConstantPoolGetMethodAt;
JVM_ConstantPoolGetMethodAtIfLoaded;
JVM_ConstantPoolGetMemberRefInfoAt;
JVM_ConstantPoolGetSize;
JVM_ConstantPoolGetStringAt;
JVM_ConstantPoolGetUTF8At;
JVM_CountStackFrames;
JVM_CurrentClassLoader;
JVM_CurrentLoadedClass;
JVM_CurrentThread;
JVM_CurrentTimeMillis;
JVM_DefineClass;
JVM_DefineClassWithSource;
JVM_DefineClassWithSourceCond;
JVM_DesiredAssertionStatus;
JVM_DisableCompiler;
JVM_DoPrivileged;
JVM_DTraceGetVersion;
JVM_DTraceActivate;
JVM_DTraceIsProbeEnabled;
JVM_DTraceIsSupported;
JVM_DTraceDispose;
JVM_DumpAllStacks;
JVM_DumpThreads;
JVM_EnableCompiler;
JVM_Exit;
JVM_FillInStackTrace;
JVM_FindClassFromClass;
JVM_FindClassFromClassLoader;
JVM_FindClassFromBootLoader;
JVM_FindLibraryEntry;
JVM_FindLoadedClass;
JVM_FindPrimitiveClass;
JVM_FindSignal;
JVM_FreeMemory;
JVM_GC;
JVM_GetAllThreads;
JVM_GetArrayElement;
JVM_GetArrayLength;
JVM_GetCPClassNameUTF;
JVM_GetCPFieldClassNameUTF;
JVM_GetCPFieldModifiers;
JVM_GetCPFieldNameUTF;
JVM_GetCPFieldSignatureUTF;
JVM_GetCPMethodClassNameUTF;
JVM_GetCPMethodModifiers;
JVM_GetCPMethodNameUTF;
JVM_GetCPMethodSignatureUTF;
JVM_GetCallerClass;
JVM_GetClassAccessFlags;
JVM_GetClassAnnotations;
JVM_GetClassCPEntriesCount;
JVM_GetClassCPTypes;
JVM_GetClassConstantPool;
JVM_GetClassContext;
JVM_GetClassDeclaredConstructors;
JVM_GetClassDeclaredFields;
JVM_GetClassDeclaredMethods;
JVM_GetClassFieldsCount;
JVM_GetClassInterfaces;
JVM_GetClassLoader;
JVM_GetClassMethodsCount;
JVM_GetClassModifiers;
JVM_GetClassName;
JVM_GetClassNameUTF;
JVM_GetClassSignature;
JVM_GetClassSigners;
JVM_GetClassTypeAnnotations;
JVM_GetComponentType;
JVM_GetDeclaredClasses;
JVM_GetDeclaringClass;
JVM_GetEnclosingMethodInfo;
JVM_GetFieldAnnotations;
JVM_GetFieldIxModifiers;
JVM_GetFieldTypeAnnotations;
JVM_GetHostName;
JVM_GetInheritedAccessControlContext;
JVM_GetInterfaceVersion;
JVM_GetLastErrorString;
JVM_GetManagement;
JVM_GetMethodAnnotations;
JVM_GetMethodDefaultAnnotationValue;
JVM_GetMethodIxArgsSize;
JVM_GetMethodIxByteCode;
JVM_GetMethodIxByteCodeLength;
JVM_GetMethodIxExceptionIndexes;
JVM_GetMethodIxExceptionTableEntry;
JVM_GetMethodIxExceptionTableLength;
JVM_GetMethodIxExceptionsCount;
JVM_GetMethodIxLocalsCount;
JVM_GetMethodIxMaxStack;
JVM_GetMethodIxModifiers;
JVM_GetMethodIxNameUTF;
JVM_GetMethodIxSignatureUTF;
JVM_GetMethodParameterAnnotations;
JVM_GetMethodParameters;
JVM_GetMethodTypeAnnotations;
JVM_GetPrimitiveArrayElement;
JVM_GetProtectionDomain;
JVM_GetSockName;
JVM_GetSockOpt;
JVM_GetStackAccessControlContext;
JVM_GetStackTraceDepth;
JVM_GetStackTraceElement;
JVM_GetSystemPackage;
JVM_GetSystemPackages;
JVM_GetThreadStateNames;
JVM_GetThreadStateValues;
JVM_GetVersionInfo;
JVM_Halt;
JVM_HoldsLock;
JVM_IHashCode;
JVM_InitAgentProperties;
JVM_InitProperties;
JVM_InitializeCompiler;
JVM_InitializeSocketLibrary;
JVM_InternString;
JVM_Interrupt;
JVM_InvokeMethod;
JVM_IsArrayClass;
JVM_IsConstructorIx;
JVM_IsInterface;
JVM_IsInterrupted;
JVM_IsNaN;
JVM_IsPrimitiveClass;
JVM_IsSameClassPackage;
JVM_IsSilentCompiler;
JVM_IsSupportedJNIVersion;
JVM_IsThreadAlive;
JVM_IsVMGeneratedMethodIx;
JVM_LatestUserDefinedLoader;
JVM_Listen;
JVM_LoadClass0;
JVM_LoadLibrary;
JVM_Lseek;
JVM_MaxObjectInspectionAge;
JVM_MaxMemory;
JVM_MonitorNotify;
JVM_MonitorNotifyAll;
JVM_MonitorWait;
JVM_NanoTime;
JVM_NativePath;
JVM_NewArray;
JVM_NewInstanceFromConstructor;
JVM_NewMultiArray;
JVM_OnExit;
JVM_Open;
JVM_RaiseSignal;
JVM_RawMonitorCreate;
JVM_RawMonitorDestroy;
JVM_RawMonitorEnter;
JVM_RawMonitorExit;
JVM_Read;
JVM_Recv;
JVM_RecvFrom;
JVM_RegisterSignal;
JVM_ReleaseUTF;
JVM_ResolveClass;
JVM_ResumeThread;
JVM_Send;
JVM_SendTo;
JVM_SetArrayElement;
JVM_SetClassSigners;
JVM_SetLength;
JVM_SetNativeThreadName;
JVM_SetPrimitiveArrayElement;
JVM_SetSockOpt;
JVM_SetThreadPriority;
JVM_Sleep;
JVM_Socket;
JVM_SocketAvailable;
JVM_SocketClose;
JVM_SocketShutdown;
JVM_StartThread;
JVM_StopThread;
JVM_SuspendThread;
JVM_SupportsCX8;
JVM_Sync;
JVM_Timeout;
JVM_TotalMemory;
JVM_TraceInstructions;
JVM_TraceMethodCalls;
JVM_UnloadLibrary;
JVM_Write;
JVM_Yield;
JVM_handle_linux_signal;
# miscellaneous functions # miscellaneous functions
_jio_fprintf jio_fprintf;
_jio_printf jio_printf;
_jio_snprintf jio_snprintf;
_jio_vfprintf jio_vfprintf;
_jio_vsnprintf jio_vsnprintf;
fork1;
numa_warn;
numa_error;
# Needed because there is no JVM interface for this.
sysThreadAvailableStackWithSlack;
# This is for Forte Analyzer profiling support. # This is for Forte Analyzer profiling support.
_AsyncGetCallTrace AsyncGetCallTrace;
# INSERT VTABLE SYMBOLS HERE # INSERT VTABLE SYMBOLS HERE
local:
*;
};

462
hotspot/make/bsd/makefiles/mapfile-vers-product
View file

@ -19,238 +19,250 @@
# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 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 # or visit www.oracle.com if you need additional information or have any
# questions. # questions.
#
# #
#
# Only used for OSX/Darwin builds
# Define public interface. # Define public interface.
# _JNI
_JNI_CreateJavaVM
_JNI_GetCreatedJavaVMs
_JNI_GetDefaultJavaVMInitArgs
# _JVM SUNWprivate_1.1 {
_JVM_Accept global:
_JVM_ActiveProcessorCount # JNI
_JVM_AllocateNewArray JNI_CreateJavaVM;
_JVM_AllocateNewObject JNI_GetCreatedJavaVMs;
_JVM_ArrayCopy JNI_GetDefaultJavaVMInitArgs;
_JVM_AssertionStatusDirectives
_JVM_Available # JVM
_JVM_Bind JVM_Accept;
_JVM_ClassDepth JVM_ActiveProcessorCount;
_JVM_ClassLoaderDepth JVM_AllocateNewArray;
_JVM_Clone JVM_AllocateNewObject;
_JVM_Close JVM_ArrayCopy;
_JVM_CX8Field JVM_AssertionStatusDirectives;
_JVM_CompileClass JVM_Available;
_JVM_CompileClasses JVM_Bind;
_JVM_CompilerCommand JVM_ClassDepth;
_JVM_Connect JVM_ClassLoaderDepth;
_JVM_ConstantPoolGetClassAt JVM_Clone;
_JVM_ConstantPoolGetClassAtIfLoaded JVM_Close;
_JVM_ConstantPoolGetDoubleAt JVM_CX8Field;
_JVM_ConstantPoolGetFieldAt JVM_CompileClass;
_JVM_ConstantPoolGetFieldAtIfLoaded JVM_CompileClasses;
_JVM_ConstantPoolGetFloatAt JVM_CompilerCommand;
_JVM_ConstantPoolGetIntAt JVM_Connect;
_JVM_ConstantPoolGetLongAt JVM_ConstantPoolGetClassAt;
_JVM_ConstantPoolGetMethodAt JVM_ConstantPoolGetClassAtIfLoaded;
_JVM_ConstantPoolGetMethodAtIfLoaded JVM_ConstantPoolGetDoubleAt;
_JVM_ConstantPoolGetMemberRefInfoAt JVM_ConstantPoolGetFieldAt;
_JVM_ConstantPoolGetSize JVM_ConstantPoolGetFieldAtIfLoaded;
_JVM_ConstantPoolGetStringAt JVM_ConstantPoolGetFloatAt;
_JVM_ConstantPoolGetUTF8At JVM_ConstantPoolGetIntAt;
_JVM_CountStackFrames JVM_ConstantPoolGetLongAt;
_JVM_CurrentClassLoader JVM_ConstantPoolGetMethodAt;
_JVM_CurrentLoadedClass JVM_ConstantPoolGetMethodAtIfLoaded;
_JVM_CurrentThread JVM_ConstantPoolGetMemberRefInfoAt;
_JVM_CurrentTimeMillis JVM_ConstantPoolGetSize;
_JVM_DefineClass JVM_ConstantPoolGetStringAt;
_JVM_DefineClassWithSource JVM_ConstantPoolGetUTF8At;
_JVM_DefineClassWithSourceCond JVM_CountStackFrames;
_JVM_DesiredAssertionStatus JVM_CurrentClassLoader;
_JVM_DisableCompiler JVM_CurrentLoadedClass;
_JVM_DoPrivileged JVM_CurrentThread;
_JVM_DTraceGetVersion JVM_CurrentTimeMillis;
_JVM_DTraceActivate JVM_DefineClass;
_JVM_DTraceIsProbeEnabled JVM_DefineClassWithSource;
_JVM_DTraceIsSupported JVM_DefineClassWithSourceCond;
_JVM_DTraceDispose JVM_DesiredAssertionStatus;
_JVM_DumpAllStacks JVM_DisableCompiler;
_JVM_DumpThreads JVM_DoPrivileged;
_JVM_EnableCompiler JVM_DTraceGetVersion;
_JVM_Exit JVM_DTraceActivate;
_JVM_FillInStackTrace JVM_DTraceIsProbeEnabled;
_JVM_FindClassFromClass JVM_DTraceIsSupported;
_JVM_FindClassFromClassLoader JVM_DTraceDispose;
_JVM_FindClassFromBootLoader JVM_DumpAllStacks;
_JVM_FindLibraryEntry JVM_DumpThreads;
_JVM_FindLoadedClass JVM_EnableCompiler;
_JVM_FindPrimitiveClass JVM_Exit;
_JVM_FindSignal JVM_FillInStackTrace;
_JVM_FreeMemory JVM_FindClassFromClass;
_JVM_GC JVM_FindClassFromClassLoader;
_JVM_GetAllThreads JVM_FindClassFromBootLoader;
_JVM_GetArrayElement JVM_FindLibraryEntry;
_JVM_GetArrayLength JVM_FindLoadedClass;
_JVM_GetCPClassNameUTF JVM_FindPrimitiveClass;
_JVM_GetCPFieldClassNameUTF JVM_FindSignal;
_JVM_GetCPFieldModifiers JVM_FreeMemory;
_JVM_GetCPFieldNameUTF JVM_GC;
_JVM_GetCPFieldSignatureUTF JVM_GetAllThreads;
_JVM_GetCPMethodClassNameUTF JVM_GetArrayElement;
_JVM_GetCPMethodModifiers JVM_GetArrayLength;
_JVM_GetCPMethodNameUTF JVM_GetCPClassNameUTF;
_JVM_GetCPMethodSignatureUTF JVM_GetCPFieldClassNameUTF;
_JVM_GetCallerClass JVM_GetCPFieldModifiers;
_JVM_GetClassAccessFlags JVM_GetCPFieldNameUTF;
_JVM_GetClassAnnotations JVM_GetCPFieldSignatureUTF;
_JVM_GetClassCPEntriesCount JVM_GetCPMethodClassNameUTF;
_JVM_GetClassCPTypes JVM_GetCPMethodModifiers;
_JVM_GetClassConstantPool JVM_GetCPMethodNameUTF;
_JVM_GetClassContext JVM_GetCPMethodSignatureUTF;
_JVM_GetClassDeclaredConstructors JVM_GetCallerClass;
_JVM_GetClassDeclaredFields JVM_GetClassAccessFlags;
_JVM_GetClassDeclaredMethods JVM_GetClassAnnotations;
_JVM_GetClassFieldsCount JVM_GetClassCPEntriesCount;
_JVM_GetClassInterfaces JVM_GetClassCPTypes;
_JVM_GetClassLoader JVM_GetClassConstantPool;
_JVM_GetClassMethodsCount JVM_GetClassContext;
_JVM_GetClassModifiers JVM_GetClassDeclaredConstructors;
_JVM_GetClassName JVM_GetClassDeclaredFields;
_JVM_GetClassNameUTF JVM_GetClassDeclaredMethods;
_JVM_GetClassSignature JVM_GetClassFieldsCount;
_JVM_GetClassSigners JVM_GetClassInterfaces;
_JVM_GetClassTypeAnnotations JVM_GetClassLoader;
_JVM_GetComponentType JVM_GetClassMethodsCount;
_JVM_GetDeclaredClasses JVM_GetClassModifiers;
_JVM_GetDeclaringClass JVM_GetClassName;
_JVM_GetEnclosingMethodInfo JVM_GetClassNameUTF;
_JVM_GetFieldAnnotations JVM_GetClassSignature;
_JVM_GetFieldIxModifiers JVM_GetClassSigners;
_JVM_GetFieldTypeAnnotations JVM_GetClassTypeAnnotations;
_JVM_GetHostName JVM_GetComponentType;
_JVM_GetInheritedAccessControlContext JVM_GetDeclaredClasses;
_JVM_GetInterfaceVersion JVM_GetDeclaringClass;
_JVM_GetLastErrorString JVM_GetEnclosingMethodInfo;
_JVM_GetManagement JVM_GetFieldAnnotations;
_JVM_GetMethodAnnotations JVM_GetFieldIxModifiers;
_JVM_GetMethodDefaultAnnotationValue JVM_GetFieldTypeAnnotations;
_JVM_GetMethodIxArgsSize JVM_GetHostName;
_JVM_GetMethodIxByteCode JVM_GetInheritedAccessControlContext;
_JVM_GetMethodIxByteCodeLength JVM_GetInterfaceVersion;
_JVM_GetMethodIxExceptionIndexes JVM_GetLastErrorString;
_JVM_GetMethodIxExceptionTableEntry JVM_GetManagement;
_JVM_GetMethodIxExceptionTableLength JVM_GetMethodAnnotations;
_JVM_GetMethodIxExceptionsCount JVM_GetMethodDefaultAnnotationValue;
_JVM_GetMethodIxLocalsCount JVM_GetMethodIxArgsSize;
_JVM_GetMethodIxMaxStack JVM_GetMethodIxByteCode;
_JVM_GetMethodIxModifiers JVM_GetMethodIxByteCodeLength;
_JVM_GetMethodIxNameUTF JVM_GetMethodIxExceptionIndexes;
_JVM_GetMethodIxSignatureUTF JVM_GetMethodIxExceptionTableEntry;
_JVM_GetMethodParameterAnnotations JVM_GetMethodIxExceptionTableLength;
_JVM_GetMethodParameters JVM_GetMethodIxExceptionsCount;
_JVM_GetMethodTypeAnnotations JVM_GetMethodIxLocalsCount;
_JVM_GetPrimitiveArrayElement JVM_GetMethodIxMaxStack;
_JVM_GetProtectionDomain JVM_GetMethodIxModifiers;
_JVM_GetSockName JVM_GetMethodIxNameUTF;
_JVM_GetSockOpt JVM_GetMethodIxSignatureUTF;
_JVM_GetStackAccessControlContext JVM_GetMethodParameterAnnotations;
_JVM_GetStackTraceDepth JVM_GetMethodParameters;
_JVM_GetStackTraceElement JVM_GetMethodTypeAnnotations;
_JVM_GetSystemPackage JVM_GetPrimitiveArrayElement;
_JVM_GetSystemPackages JVM_GetProtectionDomain;
_JVM_GetThreadStateNames JVM_GetSockName;
_JVM_GetThreadStateValues JVM_GetSockOpt;
_JVM_GetVersionInfo JVM_GetStackAccessControlContext;
_JVM_Halt JVM_GetStackTraceDepth;
_JVM_HoldsLock JVM_GetStackTraceElement;
_JVM_IHashCode JVM_GetSystemPackage;
_JVM_InitAgentProperties JVM_GetSystemPackages;
_JVM_InitProperties JVM_GetThreadStateNames;
_JVM_InitializeCompiler JVM_GetThreadStateValues;
_JVM_InitializeSocketLibrary JVM_GetVersionInfo;
_JVM_InternString JVM_Halt;
_JVM_Interrupt JVM_HoldsLock;
_JVM_InvokeMethod JVM_IHashCode;
_JVM_IsArrayClass JVM_InitAgentProperties;
_JVM_IsConstructorIx JVM_InitProperties;
_JVM_IsInterface JVM_InitializeCompiler;
_JVM_IsInterrupted JVM_InitializeSocketLibrary;
_JVM_IsNaN JVM_InternString;
_JVM_IsPrimitiveClass JVM_Interrupt;
_JVM_IsSameClassPackage JVM_InvokeMethod;
_JVM_IsSilentCompiler JVM_IsArrayClass;
_JVM_IsSupportedJNIVersion JVM_IsConstructorIx;
_JVM_IsThreadAlive JVM_IsInterface;
_JVM_IsVMGeneratedMethodIx JVM_IsInterrupted;
_JVM_LatestUserDefinedLoader JVM_IsNaN;
_JVM_Listen JVM_IsPrimitiveClass;
_JVM_LoadClass0 JVM_IsSameClassPackage;
_JVM_LoadLibrary JVM_IsSilentCompiler;
_JVM_Lseek JVM_IsSupportedJNIVersion;
_JVM_MaxObjectInspectionAge JVM_IsThreadAlive;
_JVM_MaxMemory JVM_IsVMGeneratedMethodIx;
_JVM_MonitorNotify JVM_LatestUserDefinedLoader;
_JVM_MonitorNotifyAll JVM_Listen;
_JVM_MonitorWait JVM_LoadClass0;
_JVM_NanoTime JVM_LoadLibrary;
_JVM_NativePath JVM_Lseek;
_JVM_NewArray JVM_MaxObjectInspectionAge;
_JVM_NewInstanceFromConstructor JVM_MaxMemory;
_JVM_NewMultiArray JVM_MonitorNotify;
_JVM_OnExit JVM_MonitorNotifyAll;
_JVM_Open JVM_MonitorWait;
_JVM_RaiseSignal JVM_NanoTime;
_JVM_RawMonitorCreate JVM_NativePath;
_JVM_RawMonitorDestroy JVM_NewArray;
_JVM_RawMonitorEnter JVM_NewInstanceFromConstructor;
_JVM_RawMonitorExit JVM_NewMultiArray;
_JVM_Read JVM_OnExit;
_JVM_Recv JVM_Open;
_JVM_RecvFrom JVM_RaiseSignal;
_JVM_RegisterSignal JVM_RawMonitorCreate;
_JVM_ReleaseUTF JVM_RawMonitorDestroy;
_JVM_ResolveClass JVM_RawMonitorEnter;
_JVM_ResumeThread JVM_RawMonitorExit;
_JVM_Send JVM_Read;
_JVM_SendTo JVM_Recv;
_JVM_SetArrayElement JVM_RecvFrom;
_JVM_SetClassSigners JVM_RegisterSignal;
_JVM_SetLength JVM_ReleaseUTF;
_JVM_SetNativeThreadName JVM_ResolveClass;
_JVM_SetPrimitiveArrayElement JVM_ResumeThread;
_JVM_SetSockOpt JVM_Send;
_JVM_SetThreadPriority JVM_SendTo;
_JVM_Sleep JVM_SetArrayElement;
_JVM_Socket JVM_SetClassSigners;
_JVM_SocketAvailable JVM_SetLength;
_JVM_SocketClose JVM_SetNativeThreadName;
_JVM_SocketShutdown JVM_SetPrimitiveArrayElement;
_JVM_StartThread JVM_SetSockOpt;
_JVM_StopThread JVM_SetThreadPriority;
_JVM_SuspendThread JVM_Sleep;
_JVM_SupportsCX8 JVM_Socket;
_JVM_Sync JVM_SocketAvailable;
_JVM_Timeout JVM_SocketClose;
_JVM_TotalMemory JVM_SocketShutdown;
_JVM_TraceInstructions JVM_StartThread;
_JVM_TraceMethodCalls JVM_StopThread;
_JVM_UnloadLibrary JVM_SuspendThread;
_JVM_Write JVM_SupportsCX8;
_JVM_Yield JVM_Sync;
_JVM_handle_bsd_signal JVM_Timeout;
JVM_TotalMemory;
JVM_TraceInstructions;
JVM_TraceMethodCalls;
JVM_UnloadLibrary;
JVM_Write;
JVM_Yield;
JVM_handle_linux_signal;
# miscellaneous functions # miscellaneous functions
_jio_fprintf jio_fprintf;
_jio_printf jio_printf;
_jio_snprintf jio_snprintf;
_jio_vfprintf jio_vfprintf;
_jio_vsnprintf jio_vsnprintf;
fork1;
numa_warn;
numa_error;
# Needed because there is no JVM interface for this.
sysThreadAvailableStackWithSlack;
# This is for Forte Analyzer profiling support. # This is for Forte Analyzer profiling support.
_AsyncGetCallTrace AsyncGetCallTrace;
# INSERT VTABLE SYMBOLS HERE # INSERT VTABLE SYMBOLS HERE
local:
*;
};

3
hotspot/make/bsd/makefiles/optimized.make
View file

@ -39,5 +39,8 @@ CFLAGS$(HOTSPARC_GENERIC) += $(OPT_CFLAGS/BYFILE)
# Linker mapfile # Linker mapfile
MAPFILE = $(GAMMADIR)/make/bsd/makefiles/mapfile-vers-debug MAPFILE = $(GAMMADIR)/make/bsd/makefiles/mapfile-vers-debug
ifeq ($(OS_VENDOR), Darwin)
MAPFILE = $(GAMMADIR)/make/bsd/makefiles/mapfile-vers-darwin-debug
endif
VERSION = optimized VERSION = optimized

3
hotspot/make/bsd/makefiles/product.make
View file

@ -39,6 +39,9 @@ CFLAGS$(HOTSPARC_GENERIC) += $(OPT_CFLAGS/BYFILE)
# Linker mapfile # Linker mapfile
MAPFILE = $(GAMMADIR)/make/bsd/makefiles/mapfile-vers-product MAPFILE = $(GAMMADIR)/make/bsd/makefiles/mapfile-vers-product
ifeq ($(OS_VENDOR), Darwin)
MAPFILE = $(GAMMADIR)/make/bsd/makefiles/mapfile-vers-darwin-product
endif
SYSDEFS += -DPRODUCT SYSDEFS += -DPRODUCT
VERSION = optimized VERSION = optimized

2
hotspot/make/linux/makefiles/adjust-mflags.sh
View file

@ -64,7 +64,7 @@ MFLAGS=`
echo "$MFLAGS" \ echo "$MFLAGS" \
| sed ' | sed '
s/^-/ -/ s/^-/ -/
s/ -\([^ ][^ ]*\)j/ -\1 -j/ s/ -\([^ I][^ I]*\)j/ -\1 -j/
s/ -j[0-9][0-9]*/ -j/ s/ -j[0-9][0-9]*/ -j/
s/ -j\([^ ]\)/ -j -\1/ s/ -j\([^ ]\)/ -j -\1/
s/ -j/ -j'${HOTSPOT_BUILD_JOBS:-${default_build_jobs}}'/ s/ -j/ -j'${HOTSPOT_BUILD_JOBS:-${default_build_jobs}}'/

5
hotspot/make/linux/makefiles/mapfile-vers-debug
View file

@ -244,11 +244,6 @@ SUNWprivate_1.1 {
JVM_Yield; JVM_Yield;
JVM_handle_linux_signal; JVM_handle_linux_signal;
# debug JVM
JVM_AccessVMBooleanFlag;
JVM_AccessVMIntFlag;
JVM_VMBreakPoint;
# miscellaneous functions # miscellaneous functions
jio_fprintf; jio_fprintf;
jio_printf; jio_printf;

2
hotspot/make/solaris/makefiles/adjust-mflags.sh
View file

@ -64,7 +64,7 @@ MFLAGS=`
echo "$MFLAGS" \ echo "$MFLAGS" \
| sed ' | sed '
s/^-/ -/ s/^-/ -/
s/ -\([^ ][^ ]*\)j/ -\1 -j/ s/ -\([^ I][^ I]*\)j/ -\1 -j/
s/ -j[0-9][0-9]*/ -j/ s/ -j[0-9][0-9]*/ -j/
s/ -j\([^ ]\)/ -j -\1/ s/ -j\([^ ]\)/ -j -\1/
s/ -j/ -j'${HOTSPOT_BUILD_JOBS:-${default_build_jobs}}'/ s/ -j/ -j'${HOTSPOT_BUILD_JOBS:-${default_build_jobs}}'/

4
hotspot/make/solaris/makefiles/mapfile-vers-debug
View file

@ -28,10 +28,6 @@
SUNWprivate_1.1 { SUNWprivate_1.1 {
global: global:
# debug JVM
JVM_AccessVMBooleanFlag;
JVM_AccessVMIntFlag;
JVM_VMBreakPoint;
# miscellaneous # miscellaneous
}; };

2
hotspot/make/windows/makefiles/sa.make
View file

@ -94,7 +94,7 @@ SA_CFLAGS = -nologo $(MS_RUNTIME_OPTION) -W3 $(GX_OPTION) -Od -D "WIN32" -D "WIN
SA_LD_FLAGS = bufferoverflowU.lib SA_LD_FLAGS = bufferoverflowU.lib
!endif !endif
!else !else
SA_CFLAGS = -nologo $(MS_RUNTIME_OPTION) -W3 -Gm $(GX_OPTION) -Od -D "WIN32" -D "_WINDOWS" -D "_DEBUG" -D "_CONSOLE" -D "_MBCS" -YX -FD -GZ -c SA_CFLAGS = -nologo $(MS_RUNTIME_OPTION) -W3 $(GX_OPTION) -Od -D "WIN32" -D "_WINDOWS" -D "_DEBUG" -D "_CONSOLE" -D "_MBCS" -FD -RTC1 -c
!if "$(ENABLE_FULL_DEBUG_SYMBOLS)" == "1" !if "$(ENABLE_FULL_DEBUG_SYMBOLS)" == "1"
SA_CFLAGS = $(SA_CFLAGS) -ZI SA_CFLAGS = $(SA_CFLAGS) -ZI
!endif !endif

6
hotspot/src/os/bsd/dtrace/hotspot.d
View file

@ -47,8 +47,8 @@ provider hotspot {
probe mem__pool__gc__end( probe mem__pool__gc__end(
char*, uintptr_t, char*, uintptr_t, char*, uintptr_t, char*, uintptr_t,
uintptr_t, uintptr_t, uintptr_t, uintptr_t); uintptr_t, uintptr_t, uintptr_t, uintptr_t);
probe thread__probe__start(char*, uintptr_t, uintptr_t, uintptr_t, uintptr_t); probe thread__start(char*, uintptr_t, uintptr_t, uintptr_t, uintptr_t);
probe thread__probe__stop(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__begin(long long);
probe thread__sleep__end(int); probe thread__sleep__end(int);
probe thread__yield(); probe thread__yield();
@ -68,7 +68,7 @@ provider hotspot {
probe monitor__contended__entered(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__contended__exit(uintptr_t, uintptr_t, char*, uintptr_t);
probe monitor__wait(uintptr_t, uintptr_t, char*, uintptr_t, uintptr_t); probe monitor__wait(uintptr_t, uintptr_t, char*, uintptr_t, uintptr_t);
probe monitor__probe__waited(uintptr_t, uintptr_t, char*, uintptr_t); probe monitor__waited(uintptr_t, uintptr_t, char*, uintptr_t);
probe monitor__notify(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 monitor__notifyAll(uintptr_t, uintptr_t, char*, uintptr_t);

24
hotspot/src/os/windows/vm/os_windows.cpp
View file

@ -166,12 +166,10 @@ void os::run_periodic_checks() {
return; return;
} }
#ifndef _WIN64
// previous UnhandledExceptionFilter, if there is one // previous UnhandledExceptionFilter, if there is one
static LPTOP_LEVEL_EXCEPTION_FILTER prev_uef_handler = NULL; static LPTOP_LEVEL_EXCEPTION_FILTER prev_uef_handler = NULL;
LONG WINAPI Handle_FLT_Exception(struct _EXCEPTION_POINTERS* exceptionInfo); LONG WINAPI Handle_FLT_Exception(struct _EXCEPTION_POINTERS* exceptionInfo);
#endif
void os::init_system_properties_values() { void os::init_system_properties_values() {
/* sysclasspath, java_home, dll_dir */ /* sysclasspath, java_home, dll_dir */
{ {
@ -2240,11 +2238,11 @@ LONG Handle_IDiv_Exception(struct _EXCEPTION_POINTERS* exceptionInfo) {
return EXCEPTION_CONTINUE_EXECUTION; return EXCEPTION_CONTINUE_EXECUTION;
} }
#ifndef _WIN64
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
LONG WINAPI Handle_FLT_Exception(struct _EXCEPTION_POINTERS* exceptionInfo) { LONG WINAPI Handle_FLT_Exception(struct _EXCEPTION_POINTERS* exceptionInfo) {
// handle exception caused by native method modifying control word
PCONTEXT ctx = exceptionInfo->ContextRecord; PCONTEXT ctx = exceptionInfo->ContextRecord;
#ifndef _WIN64
// handle exception caused by native method modifying control word
DWORD exception_code = exceptionInfo->ExceptionRecord->ExceptionCode; DWORD exception_code = exceptionInfo->ExceptionRecord->ExceptionCode;
switch (exception_code) { switch (exception_code) {
@ -2270,17 +2268,11 @@ LONG WINAPI Handle_FLT_Exception(struct _EXCEPTION_POINTERS* exceptionInfo) {
// UnhandledExceptionFilter. // UnhandledExceptionFilter.
return (prev_uef_handler)(exceptionInfo); return (prev_uef_handler)(exceptionInfo);
} }
#else // !_WIN64
return EXCEPTION_CONTINUE_SEARCH;
}
#else //_WIN64
/* /*
On Windows, the mxcsr control bits are non-volatile across calls On Windows, the mxcsr control bits are non-volatile across calls
See also CR 6192333 See also CR 6192333
If EXCEPTION_FLT_* happened after some native method modified */
mxcsr - it is not a jvm fault.
However should we decide to restore of mxcsr after a faulty
native method we can uncomment following code
jint MxCsr = INITIAL_MXCSR; jint MxCsr = INITIAL_MXCSR;
// we can't use StubRoutines::addr_mxcsr_std() // we can't use StubRoutines::addr_mxcsr_std()
// because in Win64 mxcsr is not saved there // because in Win64 mxcsr is not saved there
@ -2288,10 +2280,10 @@ LONG WINAPI Handle_FLT_Exception(struct _EXCEPTION_POINTERS* exceptionInfo) {
ctx->MxCsr = MxCsr; ctx->MxCsr = MxCsr;
return EXCEPTION_CONTINUE_EXECUTION; return EXCEPTION_CONTINUE_EXECUTION;
} }
#endif // !_WIN64
*/ return EXCEPTION_CONTINUE_SEARCH;
#endif //_WIN64 }
// Fatal error reporting is single threaded so we can make this a // Fatal error reporting is single threaded so we can make this a
// static and preallocated. If it's more than MAX_PATH silently ignore // static and preallocated. If it's more than MAX_PATH silently ignore
@ -2640,7 +2632,6 @@ LONG WINAPI topLevelExceptionFilter(struct _EXCEPTION_POINTERS* exceptionInfo) {
} // switch } // switch
} }
#ifndef _WIN64
if (((thread->thread_state() == _thread_in_Java) || if (((thread->thread_state() == _thread_in_Java) ||
(thread->thread_state() == _thread_in_native)) && (thread->thread_state() == _thread_in_native)) &&
exception_code != EXCEPTION_UNCAUGHT_CXX_EXCEPTION) exception_code != EXCEPTION_UNCAUGHT_CXX_EXCEPTION)
@ -2648,7 +2639,6 @@ LONG WINAPI topLevelExceptionFilter(struct _EXCEPTION_POINTERS* exceptionInfo) {
LONG result=Handle_FLT_Exception(exceptionInfo); LONG result=Handle_FLT_Exception(exceptionInfo);
if (result==EXCEPTION_CONTINUE_EXECUTION) return result; if (result==EXCEPTION_CONTINUE_EXECUTION) return result;
} }
#endif //_WIN64
} }
if (exception_code != EXCEPTION_BREAKPOINT) { if (exception_code != EXCEPTION_BREAKPOINT) {

8
hotspot/src/share/vm/classfile/classFileParser.cpp
View file

@ -4098,8 +4098,12 @@ instanceKlassHandle ClassFileParser::parseClassFile(Symbol* name,
tty->print("[Loaded %s from %s]\n", this_klass->external_name(), tty->print("[Loaded %s from %s]\n", this_klass->external_name(),
cfs->source()); cfs->source());
} else if (class_loader.is_null()) { } else if (class_loader.is_null()) {
if (THREAD->is_Java_thread()) { Klass* caller =
Klass* caller = ((JavaThread*)THREAD)->security_get_caller_class(1); THREAD->is_Java_thread()
? ((JavaThread*)THREAD)->security_get_caller_class(1)
: NULL;
// caller can be NULL, for example, during a JVMTI VM_Init hook
if (caller != NULL) {
tty->print("[Loaded %s by instance of %s]\n", tty->print("[Loaded %s by instance of %s]\n",
this_klass->external_name(), this_klass->external_name(),
InstanceKlass::cast(caller)->external_name()); InstanceKlass::cast(caller)->external_name());

21
hotspot/src/share/vm/classfile/classLoaderData.cpp
View file

@ -648,12 +648,12 @@ GrowableArray<ClassLoaderData*>* ClassLoaderDataGraph::new_clds() {
return array; return array;
} }
#ifndef PRODUCT // For profiling and hsfind() only. Otherwise, this is unsafe (and slow). This
// for debugging and hsfind(x) // is done lock free to avoid lock inversion problems. It is safe because
bool ClassLoaderDataGraph::contains(address x) { // new ClassLoaderData are added to the end of the CLDG, and only removed at
// I think we need the _metaspace_lock taken here because the class loader // safepoint. The _unloading list can be deallocated concurrently with CMS so
// data graph could be changing while we are walking it (new entries added, // this doesn't look in metaspace for classes that have been unloaded.
// new entries being unloaded, etc). bool ClassLoaderDataGraph::contains(const void* x) {
if (DumpSharedSpaces) { if (DumpSharedSpaces) {
// There are only two metaspaces to worry about. // There are only two metaspaces to worry about.
ClassLoaderData* ncld = ClassLoaderData::the_null_class_loader_data(); ClassLoaderData* ncld = ClassLoaderData::the_null_class_loader_data();
@ -670,16 +670,11 @@ bool ClassLoaderDataGraph::contains(address x) {
} }
} }
// Could also be on an unloading list which is okay, ie. still allocated // Do not check unloading list because deallocation can be concurrent.
// for a little while.
for (ClassLoaderData* ucld = _unloading; ucld != NULL; ucld = ucld->next()) {
if (ucld->metaspace_or_null() != NULL && ucld->metaspace_or_null()->contains(x)) {
return true;
}
}
return false; return false;
} }
#ifndef PRODUCT
bool ClassLoaderDataGraph::contains_loader_data(ClassLoaderData* loader_data) { bool ClassLoaderDataGraph::contains_loader_data(ClassLoaderData* loader_data) {
for (ClassLoaderData* data = _head; data != NULL; data = data->next()) { for (ClassLoaderData* data = _head; data != NULL; data = data->next()) {
if (loader_data == data) { if (loader_data == data) {

4
hotspot/src/share/vm/classfile/classLoaderData.hpp
View file

@ -90,9 +90,9 @@ class ClassLoaderDataGraph : public AllStatic {
static void dump() { dump_on(tty); } static void dump() { dump_on(tty); }
static void verify(); static void verify();
#ifndef PRODUCT
// expensive test for pointer in metaspace for debugging // expensive test for pointer in metaspace for debugging
static bool contains(address x); static bool contains(const void* x);
#ifndef PRODUCT
static bool contains_loader_data(ClassLoaderData* loader_data); static bool contains_loader_data(ClassLoaderData* loader_data);
#endif #endif

41
hotspot/src/share/vm/classfile/defaultMethods.cpp
View file

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 2012, 2014, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* *
* This code is free software; you can redistribute it and/or modify it * This code is free software; you can redistribute it and/or modify it
@ -390,6 +390,20 @@ class MethodFamily : public ResourceObj {
Symbol* get_exception_message() { return _exception_message; } Symbol* get_exception_message() { return _exception_message; }
Symbol* get_exception_name() { return _exception_name; } Symbol* get_exception_name() { return _exception_name; }
// Return true if the specified klass has a static method that matches
// the name and signature of the target method.
bool has_matching_static(InstanceKlass* root) {
if (_members.length() > 0) {
Pair<Method*,QualifiedState> entry = _members.at(0);
Method* impl = root->find_method(entry.first->name(),
entry.first->signature());
if ((impl != NULL) && impl->is_static()) {
return true;
}
}
return false;
}
// Either sets the target or the exception error message // Either sets the target or the exception error message
void determine_target(InstanceKlass* root, TRAPS) { void determine_target(InstanceKlass* root, TRAPS) {
if (has_target() || throws_exception()) { if (has_target() || throws_exception()) {
@ -416,19 +430,26 @@ class MethodFamily : public ResourceObj {
} }
if (num_defaults == 0) { if (num_defaults == 0) {
if (qualified_methods.length() == 0) { // If the root klass has a static method with matching name and signature
_exception_message = generate_no_defaults_message(CHECK); // then do not generate an overpass method because it will hide the
} else { // static method during resolution.
assert(root != NULL, "Null root class"); if (!has_matching_static(root)) {
_exception_message = generate_method_message(root->name(), qualified_methods.at(0), CHECK); if (qualified_methods.length() == 0) {
_exception_message = generate_no_defaults_message(CHECK);
} else {
assert(root != NULL, "Null root class");
_exception_message = generate_method_message(root->name(), qualified_methods.at(0), CHECK);
}
_exception_name = vmSymbols::java_lang_AbstractMethodError();
} }
_exception_name = vmSymbols::java_lang_AbstractMethodError();
// If only one qualified method is default, select that // If only one qualified method is default, select that
} else if (num_defaults == 1) { } else if (num_defaults == 1) {
_selected_target = qualified_methods.at(default_index); _selected_target = qualified_methods.at(default_index);
} else if (num_defaults > 1) {
_exception_message = generate_conflicts_message(&qualified_methods,CHECK); } else if (num_defaults > 1 && !has_matching_static(root)) {
_exception_name = vmSymbols::java_lang_IncompatibleClassChangeError(); _exception_message = generate_conflicts_message(&qualified_methods,CHECK);
_exception_name = vmSymbols::java_lang_IncompatibleClassChangeError();
if (TraceDefaultMethods) { if (TraceDefaultMethods) {
_exception_message->print_value_on(tty); _exception_message->print_value_on(tty);
tty->print_cr(""); tty->print_cr("");

2
hotspot/src/share/vm/classfile/javaClasses.cpp
View file

@ -3286,7 +3286,7 @@ void JavaClasses::compute_offsets() {
sun_reflect_ConstantPool::compute_offsets(); sun_reflect_ConstantPool::compute_offsets();
sun_reflect_UnsafeStaticFieldAccessorImpl::compute_offsets(); sun_reflect_UnsafeStaticFieldAccessorImpl::compute_offsets();
} }
if (JDK_Version::is_jdk18x_version()) if (JDK_Version::is_gte_jdk18x_version())
java_lang_reflect_Parameter::compute_offsets(); java_lang_reflect_Parameter::compute_offsets();
// generated interpreter code wants to know about the offsets we just computed: // generated interpreter code wants to know about the offsets we just computed:

2
hotspot/src/share/vm/code/dependencies.cpp
View file

@ -655,8 +655,6 @@ inline Metadata* Dependencies::DepStream::recorded_metadata_at(int i) {
} else { } else {
o = _deps->oop_recorder()->metadata_at(i); o = _deps->oop_recorder()->metadata_at(i);
} }
assert(o == NULL || o->is_metaspace_object(),
err_msg("Should be metadata " PTR_FORMAT, o));
return o; return o;
} }

19
hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp
View file

@ -2376,25 +2376,6 @@ size_t G1CollectedHeap::recalculate_used() const {
return blk.result(); return blk.result();
} }
size_t G1CollectedHeap::unsafe_max_alloc() {
if (free_regions() > 0) return HeapRegion::GrainBytes;
// otherwise, is there space in the current allocation region?
// We need to store the current allocation region in a local variable
// here. The problem is that this method doesn't take any locks and
// there may be other threads which overwrite the current allocation
// region field. attempt_allocation(), for example, sets it to NULL
// and this can happen *after* the NULL check here but before the call
// to free(), resulting in a SIGSEGV. Note that this doesn't appear
// to be a problem in the optimized build, since the two loads of the
// current allocation region field are optimized away.
HeapRegion* hr = _mutator_alloc_region.get();
if (hr == NULL) {
return 0;
}
return hr->free();
}
bool G1CollectedHeap::should_do_concurrent_full_gc(GCCause::Cause cause) { bool G1CollectedHeap::should_do_concurrent_full_gc(GCCause::Cause cause) {
switch (cause) { switch (cause) {
case GCCause::_gc_locker: return GCLockerInvokesConcurrent; case GCCause::_gc_locker: return GCLockerInvokesConcurrent;

9
hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp
View file

@ -1183,15 +1183,6 @@ public:
// end fields defining the extent of the contiguous allocation region.) // end fields defining the extent of the contiguous allocation region.)
// But G1CollectedHeap doesn't yet support this. // But G1CollectedHeap doesn't yet support this.
// Return an estimate of the maximum allocation that could be performed
// without triggering any collection or expansion activity. In a
// generational collector, for example, this is probably the largest
// allocation that could be supported (without expansion) in the youngest
// generation. It is "unsafe" because no locks are taken; the result
// should be treated as an approximation, not a guarantee, for use in
// heuristic resizing decisions.
virtual size_t unsafe_max_alloc();
virtual bool is_maximal_no_gc() const { virtual bool is_maximal_no_gc() const {
return _g1_storage.uncommitted_size() == 0; return _g1_storage.uncommitted_size() == 0;
} }

82
hotspot/src/share/vm/gc_implementation/g1/satbQueue.cpp
View file

@ -219,58 +219,52 @@ void SATBMarkQueueSet::handle_zero_index_for_thread(JavaThread* t) {
} }
#ifdef ASSERT #ifdef ASSERT
void SATBMarkQueueSet::dump_active_values(JavaThread* first, void SATBMarkQueueSet::dump_active_states(bool expected_active) {
bool expected_active) { gclog_or_tty->print_cr("Expected SATB active state: %s",
gclog_or_tty->print_cr("SATB queue active values for Java Threads"); expected_active ? "ACTIVE" : "INACTIVE");
gclog_or_tty->print_cr(" SATB queue set: active is %s", gclog_or_tty->print_cr("Actual SATB active states:");
(is_active()) ? "TRUE" : "FALSE"); gclog_or_tty->print_cr(" Queue set: %s", is_active() ? "ACTIVE" : "INACTIVE");
gclog_or_tty->print_cr(" expected_active is %s", for (JavaThread* t = Threads::first(); t; t = t->next()) {
(expected_active) ? "TRUE" : "FALSE"); gclog_or_tty->print_cr(" Thread \"%s\" queue: %s", t->name(),
for (JavaThread* t = first; t; t = t->next()) { t->satb_mark_queue().is_active() ? "ACTIVE" : "INACTIVE");
bool active = t->satb_mark_queue().is_active(); }
gclog_or_tty->print_cr(" thread %s, active is %s", gclog_or_tty->print_cr(" Shared queue: %s",
t->name(), (active) ? "TRUE" : "FALSE"); shared_satb_queue()->is_active() ? "ACTIVE" : "INACTIVE");
}
void SATBMarkQueueSet::verify_active_states(bool expected_active) {
// Verify queue set state
if (is_active() != expected_active) {
dump_active_states(expected_active);
guarantee(false, "SATB queue set has an unexpected active state");
}
// Verify thread queue states
for (JavaThread* t = Threads::first(); t; t = t->next()) {
if (t->satb_mark_queue().is_active() != expected_active) {
dump_active_states(expected_active);
guarantee(false, "Thread SATB queue has an unexpected active state");
}
}
// Verify shared queue state
if (shared_satb_queue()->is_active() != expected_active) {
dump_active_states(expected_active);
guarantee(false, "Shared SATB queue has an unexpected active state");
} }
} }
#endif // ASSERT #endif // ASSERT
void SATBMarkQueueSet::set_active_all_threads(bool b, void SATBMarkQueueSet::set_active_all_threads(bool active, bool expected_active) {
bool expected_active) {
assert(SafepointSynchronize::is_at_safepoint(), "Must be at safepoint."); assert(SafepointSynchronize::is_at_safepoint(), "Must be at safepoint.");
JavaThread* first = Threads::first();
#ifdef ASSERT #ifdef ASSERT
if (_all_active != expected_active) { verify_active_states(expected_active);
dump_active_values(first, expected_active);
// I leave this here as a guarantee, instead of an assert, so
// that it will still be compiled in if we choose to uncomment
// the #ifdef ASSERT in a product build. The whole block is
// within an #ifdef ASSERT so the guarantee will not be compiled
// in a product build anyway.
guarantee(false,
"SATB queue set has an unexpected active value");
}
#endif // ASSERT #endif // ASSERT
_all_active = b; _all_active = active;
for (JavaThread* t = Threads::first(); t; t = t->next()) {
for (JavaThread* t = first; t; t = t->next()) { t->satb_mark_queue().set_active(active);
#ifdef ASSERT
bool active = t->satb_mark_queue().is_active();
if (active != expected_active) {
dump_active_values(first, expected_active);
// I leave this here as a guarantee, instead of an assert, so
// that it will still be compiled in if we choose to uncomment
// the #ifdef ASSERT in a product build. The whole block is
// within an #ifdef ASSERT so the guarantee will not be compiled
// in a product build anyway.
guarantee(false,
"thread has an unexpected active value in its SATB queue");
}
#endif // ASSERT
t->satb_mark_queue().set_active(b);
} }
shared_satb_queue()->set_active(active);
} }
void SATBMarkQueueSet::filter_thread_buffers() { void SATBMarkQueueSet::filter_thread_buffers() {

7
hotspot/src/share/vm/gc_implementation/g1/satbQueue.hpp
View file

@ -87,7 +87,8 @@ class SATBMarkQueueSet: public PtrQueueSet {
bool apply_closure_to_completed_buffer_work(bool par, int worker); bool apply_closure_to_completed_buffer_work(bool par, int worker);
#ifdef ASSERT #ifdef ASSERT
void dump_active_values(JavaThread* first, bool expected_active); void dump_active_states(bool expected_active);
void verify_active_states(bool expected_active);
#endif // ASSERT #endif // ASSERT
public: public:
@ -99,11 +100,11 @@ public:
static void handle_zero_index_for_thread(JavaThread* t); static void handle_zero_index_for_thread(JavaThread* t);
// Apply "set_active(b)" to all Java threads' SATB queues. It should be // Apply "set_active(active)" to all SATB queues in the set. It should be
// called only with the world stopped. The method will assert that the // called only with the world stopped. The method will assert that the
// SATB queues of all threads it visits, as well as the SATB queue // SATB queues of all threads it visits, as well as the SATB queue
// set itself, has an active value same as expected_active. // set itself, has an active value same as expected_active.
void set_active_all_threads(bool b, bool expected_active); void set_active_all_threads(bool active, bool expected_active);
// Filter all the currently-active SATB buffers. // Filter all the currently-active SATB buffers.
void filter_thread_buffers(); void filter_thread_buffers();

4
hotspot/src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.cpp
View file

@ -484,10 +484,6 @@ void ParallelScavengeHeap::ensure_parsability(bool retire_tlabs) {
young_gen()->eden_space()->ensure_parsability(); young_gen()->eden_space()->ensure_parsability();
} }
size_t ParallelScavengeHeap::unsafe_max_alloc() {
return young_gen()->eden_space()->free_in_bytes();
}
size_t ParallelScavengeHeap::tlab_capacity(Thread* thr) const { size_t ParallelScavengeHeap::tlab_capacity(Thread* thr) const {
return young_gen()->eden_space()->tlab_capacity(thr); return young_gen()->eden_space()->tlab_capacity(thr);
} }

2
hotspot/src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.hpp
View file

@ -184,8 +184,6 @@ class ParallelScavengeHeap : public CollectedHeap {
void accumulate_statistics_all_tlabs(); void accumulate_statistics_all_tlabs();
void resize_all_tlabs(); void resize_all_tlabs();
size_t unsafe_max_alloc();
bool supports_tlab_allocation() const { return true; } bool supports_tlab_allocation() const { return true; }
size_t tlab_capacity(Thread* thr) const; size_t tlab_capacity(Thread* thr) const;

12
hotspot/src/share/vm/gc_implementation/parallelScavenge/psScavenge.cpp
View file

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2002, 2013, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 2002, 2014, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* *
* This code is free software; you can redistribute it and/or modify it * This code is free software; you can redistribute it and/or modify it
@ -466,10 +466,12 @@ bool PSScavenge::invoke_no_policy() {
} }
} }
GCTraceTime tm("StringTable", false, false, &_gc_timer); {
// Unlink any dead interned Strings and process the remaining live ones. GCTraceTime tm("StringTable", false, false, &_gc_timer);
PSScavengeRootsClosure root_closure(promotion_manager); // Unlink any dead interned Strings and process the remaining live ones.
StringTable::unlink_or_oops_do(&_is_alive_closure, &root_closure); PSScavengeRootsClosure root_closure(promotion_manager);
StringTable::unlink_or_oops_do(&_is_alive_closure, &root_closure);
}
// Finally, flush the promotion_manager's labs, and deallocate its stacks. // Finally, flush the promotion_manager's labs, and deallocate its stacks.
promotion_failure_occurred = PSPromotionManager::post_scavenge(_gc_tracer); promotion_failure_occurred = PSPromotionManager::post_scavenge(_gc_tracer);

9
hotspot/src/share/vm/gc_interface/collectedHeap.hpp
View file

@ -389,15 +389,6 @@ class CollectedHeap : public CHeapObj<mtInternal> {
// allocation from them and necessitating allocation of new TLABs. // allocation from them and necessitating allocation of new TLABs.
virtual void ensure_parsability(bool retire_tlabs); virtual void ensure_parsability(bool retire_tlabs);
// Return an estimate of the maximum allocation that could be performed
// without triggering any collection or expansion activity. In a
// generational collector, for example, this is probably the largest
// allocation that could be supported (without expansion) in the youngest
// generation. It is "unsafe" because no locks are taken; the result
// should be treated as an approximation, not a guarantee, for use in
// heuristic resizing decisions.
virtual size_t unsafe_max_alloc() = 0;
// Section on thread-local allocation buffers (TLABs) // Section on thread-local allocation buffers (TLABs)
// If the heap supports thread-local allocation buffers, it should override // If the heap supports thread-local allocation buffers, it should override
// the following methods: // the following methods:

3
hotspot/src/share/vm/memory/allocation.cpp
View file

@ -71,9 +71,8 @@ bool MetaspaceObj::is_shared() const {
return MetaspaceShared::is_in_shared_space(this); return MetaspaceShared::is_in_shared_space(this);
} }
bool MetaspaceObj::is_metaspace_object() const { bool MetaspaceObj::is_metaspace_object() const {
return Metaspace::contains((void*)this); return ClassLoaderDataGraph::contains((void*)this);
} }
void MetaspaceObj::print_address_on(outputStream* st) const { void MetaspaceObj::print_address_on(outputStream* st) const {

2
hotspot/src/share/vm/memory/allocation.hpp
View file

@ -264,7 +264,7 @@ class ClassLoaderData;
class MetaspaceObj { class MetaspaceObj {
public: public:
bool is_metaspace_object() const; // more specific test but slower bool is_metaspace_object() const;
bool is_shared() const; bool is_shared() const;
void print_address_on(outputStream* st) const; // nonvirtual address printing void print_address_on(outputStream* st) const; // nonvirtual address printing

6
hotspot/src/share/vm/memory/defNewGeneration.cpp
View file

@ -667,9 +667,6 @@ void DefNewGeneration::collect(bool full,
// for full GC's. // for full GC's.
AdaptiveSizePolicy* size_policy = gch->gen_policy()->size_policy(); AdaptiveSizePolicy* size_policy = gch->gen_policy()->size_policy();
size_policy->reset_gc_overhead_limit_count(); size_policy->reset_gc_overhead_limit_count();
if (PrintGC && !PrintGCDetails) {
gch->print_heap_change(gch_prev_used);
}
assert(!gch->incremental_collection_failed(), "Should be clear"); assert(!gch->incremental_collection_failed(), "Should be clear");
} else { } else {
assert(_promo_failure_scan_stack.is_empty(), "post condition"); assert(_promo_failure_scan_stack.is_empty(), "post condition");
@ -695,6 +692,9 @@ void DefNewGeneration::collect(bool full,
// Reset the PromotionFailureALot counters. // Reset the PromotionFailureALot counters.
NOT_PRODUCT(Universe::heap()->reset_promotion_should_fail();) NOT_PRODUCT(Universe::heap()->reset_promotion_should_fail();)
} }
if (PrintGC && !PrintGCDetails) {
gch->print_heap_change(gch_prev_used);
}
// set new iteration safe limit for the survivor spaces // set new iteration safe limit for the survivor spaces
from()->set_concurrent_iteration_safe_limit(from()->top()); from()->set_concurrent_iteration_safe_limit(from()->top());
to()->set_concurrent_iteration_safe_limit(to()->top()); to()->set_concurrent_iteration_safe_limit(to()->top());

4
hotspot/src/share/vm/memory/genCollectedHeap.cpp
View file

@ -673,10 +673,6 @@ HeapWord** GenCollectedHeap::end_addr() const {
return _gens[0]->end_addr(); return _gens[0]->end_addr();
} }
size_t GenCollectedHeap::unsafe_max_alloc() {
return _gens[0]->unsafe_max_alloc_nogc();
}
// public collection interfaces // public collection interfaces
void GenCollectedHeap::collect(GCCause::Cause cause) { void GenCollectedHeap::collect(GCCause::Cause cause) {

8
hotspot/src/share/vm/memory/genCollectedHeap.hpp
View file

@ -166,14 +166,6 @@ public:
HeapWord** top_addr() const; HeapWord** top_addr() const;
HeapWord** end_addr() const; HeapWord** end_addr() const;
// Return an estimate of the maximum allocation that could be performed
// without triggering any collection activity. In a generational
// collector, for example, this is probably the largest allocation that
// could be supported in the youngest generation. It is "unsafe" because
// no locks are taken; the result should be treated as an approximation,
// not a guarantee.
size_t unsafe_max_alloc();
// Does this heap support heap inspection? (+PrintClassHistogram) // Does this heap support heap inspection? (+PrintClassHistogram)
virtual bool supports_heap_inspection() const { return true; } virtual bool supports_heap_inspection() const { return true; }

2
hotspot/src/share/vm/memory/metachunk.hpp
View file

@ -143,6 +143,8 @@ class Metachunk : public Metabase<Metachunk> {
void set_is_tagged_free(bool v) { _is_tagged_free = v; } void set_is_tagged_free(bool v) { _is_tagged_free = v; }
#endif #endif
bool contains(const void* ptr) { return bottom() <= ptr && ptr < _top; }
NOT_PRODUCT(void mangle();) NOT_PRODUCT(void mangle();)
void print_on(outputStream* st) const; void print_on(outputStream* st) const;

62
hotspot/src/share/vm/memory/metaspace.cpp
View file

@ -513,8 +513,6 @@ class VirtualSpaceList : public CHeapObj<mtClass> {
// Unlink empty VirtualSpaceNodes and free it. // Unlink empty VirtualSpaceNodes and free it.
void purge(ChunkManager* chunk_manager); void purge(ChunkManager* chunk_manager);
bool contains(const void *ptr);
void print_on(outputStream* st) const; void print_on(outputStream* st) const;
class VirtualSpaceListIterator : public StackObj { class VirtualSpaceListIterator : public StackObj {
@ -558,7 +556,7 @@ class SpaceManager : public CHeapObj<mtClass> {
private: private:
// protects allocations and contains. // protects allocations
Mutex* const _lock; Mutex* const _lock;
// Type of metadata allocated. // Type of metadata allocated.
@ -595,7 +593,11 @@ class SpaceManager : public CHeapObj<mtClass> {
private: private:
// Accessors // Accessors
Metachunk* chunks_in_use(ChunkIndex index) const { return _chunks_in_use[index]; } Metachunk* chunks_in_use(ChunkIndex index) const { return _chunks_in_use[index]; }
void set_chunks_in_use(ChunkIndex index, Metachunk* v) { _chunks_in_use[index] = v; } void set_chunks_in_use(ChunkIndex index, Metachunk* v) {
// ensure lock-free iteration sees fully initialized node
OrderAccess::storestore();
_chunks_in_use[index] = v;
}
BlockFreelist* block_freelists() const { BlockFreelist* block_freelists() const {
return (BlockFreelist*) &_block_freelists; return (BlockFreelist*) &_block_freelists;
@ -708,6 +710,8 @@ class SpaceManager : public CHeapObj<mtClass> {
void print_on(outputStream* st) const; void print_on(outputStream* st) const;
void locked_print_chunks_in_use_on(outputStream* st) const; void locked_print_chunks_in_use_on(outputStream* st) const;
bool contains(const void *ptr);
void verify(); void verify();
void verify_chunk_size(Metachunk* chunk); void verify_chunk_size(Metachunk* chunk);
NOT_PRODUCT(void mangle_freed_chunks();) NOT_PRODUCT(void mangle_freed_chunks();)
@ -1159,8 +1163,6 @@ bool VirtualSpaceList::create_new_virtual_space(size_t vs_word_size) {
} else { } else {
assert(new_entry->reserved_words() == vs_word_size, assert(new_entry->reserved_words() == vs_word_size,
"Reserved memory size differs from requested memory size"); "Reserved memory size differs from requested memory size");
// ensure lock-free iteration sees fully initialized node
OrderAccess::storestore();
link_vs(new_entry); link_vs(new_entry);
return true; return true;
} }
@ -1287,19 +1289,6 @@ void VirtualSpaceList::print_on(outputStream* st) const {
} }
} }
bool VirtualSpaceList::contains(const void *ptr) {
VirtualSpaceNode* list = virtual_space_list();
VirtualSpaceListIterator iter(list);
while (iter.repeat()) {
VirtualSpaceNode* node = iter.get_next();
if (node->reserved()->contains(ptr)) {
return true;
}
}
return false;
}
// MetaspaceGC methods // MetaspaceGC methods
// VM_CollectForMetadataAllocation is the vm operation used to GC. // VM_CollectForMetadataAllocation is the vm operation used to GC.
@ -1466,9 +1455,10 @@ void MetaspaceGC::compute_new_size() {
// No expansion, now see if we want to shrink // No expansion, now see if we want to shrink
// We would never want to shrink more than this // We would never want to shrink more than this
assert(capacity_until_GC >= minimum_desired_capacity,
err_msg(SIZE_FORMAT " >= " SIZE_FORMAT,
capacity_until_GC, minimum_desired_capacity));
size_t max_shrink_bytes = capacity_until_GC - minimum_desired_capacity; size_t max_shrink_bytes = capacity_until_GC - minimum_desired_capacity;
assert(max_shrink_bytes >= 0, err_msg("max_shrink_bytes " SIZE_FORMAT,
max_shrink_bytes));
// Should shrinking be considered? // Should shrinking be considered?
if (MaxMetaspaceFreeRatio < 100) { if (MaxMetaspaceFreeRatio < 100) {
@ -2392,6 +2382,21 @@ MetaWord* SpaceManager::allocate_work(size_t word_size) {
return result; return result;
} }
// This function looks at the chunks in the metaspace without locking.
// The chunks are added with store ordering and not deleted except for at
// unloading time.
bool SpaceManager::contains(const void *ptr) {
for (ChunkIndex i = ZeroIndex; i < NumberOfInUseLists; i = next_chunk_index(i))
{
Metachunk* curr = chunks_in_use(i);
while (curr != NULL) {
if (curr->contains(ptr)) return true;
curr = curr->next();
}
}
return false;
}
void SpaceManager::verify() { void SpaceManager::verify() {
// If there are blocks in the dictionary, then // If there are blocks in the dictionary, then
// verfication of chunks does not work since // verfication of chunks does not work since
@ -3463,17 +3468,12 @@ void Metaspace::print_on(outputStream* out) const {
} }
} }
bool Metaspace::contains(const void * ptr) { bool Metaspace::contains(const void* ptr) {
if (MetaspaceShared::is_in_shared_space(ptr)) { if (vsm()->contains(ptr)) return true;
return true; if (using_class_space()) {
return class_vsm()->contains(ptr);
} }
// This is checked while unlocked. As long as the virtualspaces are added return false;
// at the end, the pointer will be in one of them. The virtual spaces
// aren't deleted presently. When they are, some sort of locking might
// be needed. Note, locking this can cause inversion problems with the
// caller in MetaspaceObj::is_metadata() function.
return space_list()->contains(ptr) ||
(using_class_space() && class_space_list()->contains(ptr));
} }
void Metaspace::verify() { void Metaspace::verify() {

2
hotspot/src/share/vm/memory/metaspace.hpp
View file

@ -225,7 +225,7 @@ class Metaspace : public CHeapObj<mtClass> {
MetaWord* expand_and_allocate(size_t size, MetaWord* expand_and_allocate(size_t size,
MetadataType mdtype); MetadataType mdtype);
static bool contains(const void *ptr); bool contains(const void* ptr);
void dump(outputStream* const out) const; void dump(outputStream* const out) const;
// Free empty virtualspaces // Free empty virtualspaces

44
hotspot/src/share/vm/memory/referenceProcessor.cpp
View file

@ -100,7 +100,6 @@ ReferenceProcessor::ReferenceProcessor(MemRegion span,
_enqueuing_is_done(false), _enqueuing_is_done(false),
_is_alive_non_header(is_alive_non_header), _is_alive_non_header(is_alive_non_header),
_discovered_list_needs_barrier(discovered_list_needs_barrier), _discovered_list_needs_barrier(discovered_list_needs_barrier),
_bs(NULL),
_processing_is_mt(mt_processing), _processing_is_mt(mt_processing),
_next_id(0) _next_id(0)
{ {
@ -126,10 +125,6 @@ ReferenceProcessor::ReferenceProcessor(MemRegion span,
_discovered_refs[i].set_length(0); _discovered_refs[i].set_length(0);
} }
// If we do barriers, cache a copy of the barrier set.
if (discovered_list_needs_barrier) {
_bs = Universe::heap()->barrier_set();
}
setup_policy(false /* default soft ref policy */); setup_policy(false /* default soft ref policy */);
} }
@ -317,13 +312,9 @@ bool enqueue_discovered_ref_helper(ReferenceProcessor* ref,
// Enqueue references that are not made active again, and // Enqueue references that are not made active again, and
// clear the decks for the next collection (cycle). // clear the decks for the next collection (cycle).
ref->enqueue_discovered_reflists((HeapWord*)pending_list_addr, task_executor); ref->enqueue_discovered_reflists((HeapWord*)pending_list_addr, task_executor);
// Do the oop-check on pending_list_addr missed in // Do the post-barrier on pending_list_addr missed in
// enqueue_discovered_reflist. We should probably // enqueue_discovered_reflist.
// do a raw oop_check so that future such idempotent oopDesc::bs()->write_ref_field(pending_list_addr, oopDesc::load_decode_heap_oop(pending_list_addr));
// oop_stores relying on the oop-check side-effect
// may be elided automatically and safely without
// affecting correctness.
oop_store(pending_list_addr, oopDesc::load_decode_heap_oop(pending_list_addr));
// Stop treating discovered references specially. // Stop treating discovered references specially.
ref->disable_discovery(); ref->disable_discovery();
@ -372,15 +363,17 @@ void ReferenceProcessor::enqueue_discovered_reflist(DiscoveredList& refs_list,
assert(java_lang_ref_Reference::next(obj) == NULL, assert(java_lang_ref_Reference::next(obj) == NULL,
"Reference not active; should not be discovered"); "Reference not active; should not be discovered");
// Self-loop next, so as to make Ref not active. // Self-loop next, so as to make Ref not active.
java_lang_ref_Reference::set_next(obj, obj); // Post-barrier not needed when looping to self.
java_lang_ref_Reference::set_next_raw(obj, obj);
if (next_d == obj) { // obj is last if (next_d == obj) { // obj is last
// Swap refs_list into pendling_list_addr and // Swap refs_list into pendling_list_addr and
// set obj's discovered to what we read from pending_list_addr. // set obj's discovered to what we read from pending_list_addr.
oop old = oopDesc::atomic_exchange_oop(refs_list.head(), pending_list_addr); oop old = oopDesc::atomic_exchange_oop(refs_list.head(), pending_list_addr);
// Need oop_check on pending_list_addr above; // Need post-barrier on pending_list_addr above;
// see special oop-check code at the end of // see special post-barrier code at the end of
// enqueue_discovered_reflists() further below. // enqueue_discovered_reflists() further below.
java_lang_ref_Reference::set_discovered(obj, old); // old may be NULL java_lang_ref_Reference::set_discovered_raw(obj, old); // old may be NULL
oopDesc::bs()->write_ref_field(java_lang_ref_Reference::discovered_addr(obj), old);
} }
} }
} else { // Old behaviour } else { // Old behaviour
@ -516,13 +509,11 @@ void DiscoveredListIterator::make_active() {
// the reference object and will fail // the reference object and will fail
// CT verification. // CT verification.
if (UseG1GC) { if (UseG1GC) {
BarrierSet* bs = oopDesc::bs();
HeapWord* next_addr = java_lang_ref_Reference::next_addr(_ref); HeapWord* next_addr = java_lang_ref_Reference::next_addr(_ref);
if (UseCompressedOops) { if (UseCompressedOops) {
bs->write_ref_field_pre((narrowOop*)next_addr, NULL); oopDesc::bs()->write_ref_field_pre((narrowOop*)next_addr, NULL);
} else { } else {
bs->write_ref_field_pre((oop*)next_addr, NULL); oopDesc::bs()->write_ref_field_pre((oop*)next_addr, NULL);
} }
java_lang_ref_Reference::set_next_raw(_ref, NULL); java_lang_ref_Reference::set_next_raw(_ref, NULL);
} else { } else {
@ -790,10 +781,9 @@ private:
}; };
void ReferenceProcessor::set_discovered(oop ref, oop value) { void ReferenceProcessor::set_discovered(oop ref, oop value) {
java_lang_ref_Reference::set_discovered_raw(ref, value);
if (_discovered_list_needs_barrier) { if (_discovered_list_needs_barrier) {
java_lang_ref_Reference::set_discovered(ref, value); oopDesc::bs()->write_ref_field(ref, value);
} else {
java_lang_ref_Reference::set_discovered_raw(ref, value);
} }
} }
@ -1085,7 +1075,7 @@ ReferenceProcessor::add_to_discovered_list_mt(DiscoveredList& refs_list,
// so this will expand to nothing. As a result, we have manually // so this will expand to nothing. As a result, we have manually
// elided this out for G1, but left in the test for some future // elided this out for G1, but left in the test for some future
// collector that might have need for a pre-barrier here, e.g.:- // collector that might have need for a pre-barrier here, e.g.:-
// _bs->write_ref_field_pre((oop* or narrowOop*)discovered_addr, next_discovered); // oopDesc::bs()->write_ref_field_pre((oop* or narrowOop*)discovered_addr, next_discovered);
assert(!_discovered_list_needs_barrier || UseG1GC, assert(!_discovered_list_needs_barrier || UseG1GC,
"Need to check non-G1 collector: " "Need to check non-G1 collector: "
"may need a pre-write-barrier for CAS from NULL below"); "may need a pre-write-barrier for CAS from NULL below");
@ -1098,7 +1088,7 @@ ReferenceProcessor::add_to_discovered_list_mt(DiscoveredList& refs_list,
refs_list.set_head(obj); refs_list.set_head(obj);
refs_list.inc_length(1); refs_list.inc_length(1);
if (_discovered_list_needs_barrier) { if (_discovered_list_needs_barrier) {
_bs->write_ref_field((void*)discovered_addr, next_discovered); oopDesc::bs()->write_ref_field((void*)discovered_addr, next_discovered);
} }
if (TraceReferenceGC) { if (TraceReferenceGC) {
@ -1260,13 +1250,13 @@ bool ReferenceProcessor::discover_reference(oop obj, ReferenceType rt) {
// As in the case further above, since we are over-writing a NULL // As in the case further above, since we are over-writing a NULL
// pre-value, we can safely elide the pre-barrier here for the case of G1. // pre-value, we can safely elide the pre-barrier here for the case of G1.
// e.g.:- _bs->write_ref_field_pre((oop* or narrowOop*)discovered_addr, next_discovered); // e.g.:- oopDesc::bs()->write_ref_field_pre((oop* or narrowOop*)discovered_addr, next_discovered);
assert(discovered == NULL, "control point invariant"); assert(discovered == NULL, "control point invariant");
assert(!_discovered_list_needs_barrier || UseG1GC, assert(!_discovered_list_needs_barrier || UseG1GC,
"For non-G1 collector, may need a pre-write-barrier for CAS from NULL below"); "For non-G1 collector, may need a pre-write-barrier for CAS from NULL below");
oop_store_raw(discovered_addr, next_discovered); oop_store_raw(discovered_addr, next_discovered);
if (_discovered_list_needs_barrier) { if (_discovered_list_needs_barrier) {
_bs->write_ref_field((void*)discovered_addr, next_discovered); oopDesc::bs()->write_ref_field((void*)discovered_addr, next_discovered);
} }
list->set_head(obj); list->set_head(obj);
list->inc_length(1); list->inc_length(1);

20
hotspot/src/share/vm/memory/referenceProcessor.hpp
View file

@ -235,7 +235,6 @@ class ReferenceProcessor : public CHeapObj<mtGC> {
// discovery.) // discovery.)
bool _discovered_list_needs_barrier; bool _discovered_list_needs_barrier;
BarrierSet* _bs; // Cached copy of BarrierSet.
bool _enqueuing_is_done; // true if all weak references enqueued bool _enqueuing_is_done; // true if all weak references enqueued
bool _processing_is_mt; // true during phases when bool _processing_is_mt; // true during phases when
// reference processing is MT. // reference processing is MT.
@ -420,25 +419,6 @@ class ReferenceProcessor : public CHeapObj<mtGC> {
void update_soft_ref_master_clock(); void update_soft_ref_master_clock();
public: public:
// constructor
ReferenceProcessor():
_span((HeapWord*)NULL, (HeapWord*)NULL),
_discovered_refs(NULL),
_discoveredSoftRefs(NULL), _discoveredWeakRefs(NULL),
_discoveredFinalRefs(NULL), _discoveredPhantomRefs(NULL),
_discovering_refs(false),
_discovery_is_atomic(true),
_enqueuing_is_done(false),
_discovery_is_mt(false),
_discovered_list_needs_barrier(false),
_bs(NULL),
_is_alive_non_header(NULL),
_num_q(0),
_max_num_q(0),
_processing_is_mt(false),
_next_id(0)
{ }
// Default parameters give you a vanilla reference processor. // Default parameters give you a vanilla reference processor.
ReferenceProcessor(MemRegion span, ReferenceProcessor(MemRegion span,
bool mt_processing = false, uint mt_processing_degree = 1, bool mt_processing = false, uint mt_processing_degree = 1,

2
hotspot/src/share/vm/oops/klass.cpp
View file

@ -376,8 +376,6 @@ void Klass::append_to_sibling_list() {
} }
bool Klass::is_loader_alive(BoolObjectClosure* is_alive) { bool Klass::is_loader_alive(BoolObjectClosure* is_alive) {
assert(ClassLoaderDataGraph::contains((address)this), "is in the metaspace");
#ifdef ASSERT #ifdef ASSERT
// The class is alive iff the class loader is alive. // The class is alive iff the class loader is alive.
oop loader = class_loader(); oop loader = class_loader();

74
hotspot/src/share/vm/prims/jni.cpp
View file

@ -1804,34 +1804,34 @@ JNI_END
// the runtime type of subword integral basic types is integer // the runtime type of subword integral basic types is integer
DEFINE_CALLMETHODV(jboolean, Boolean, T_BOOLEAN DEFINE_CALLMETHODV(jboolean, Boolean, T_BOOLEAN
, HOTSPOT_JNI_CALLBOOLEANMETHOD_ENTRY(env, obj, (uintptr_t)methodID), , HOTSPOT_JNI_CALLBOOLEANMETHODV_ENTRY(env, obj, (uintptr_t)methodID),
HOTSPOT_JNI_CALLBOOLEANMETHOD_RETURN(_ret_ref)) HOTSPOT_JNI_CALLBOOLEANMETHODV_RETURN(_ret_ref))
DEFINE_CALLMETHODV(jbyte, Byte, T_BYTE DEFINE_CALLMETHODV(jbyte, Byte, T_BYTE
, HOTSPOT_JNI_CALLBYTEMETHOD_ENTRY(env, obj, (uintptr_t)methodID), , HOTSPOT_JNI_CALLBYTEMETHODV_ENTRY(env, obj, (uintptr_t)methodID),
HOTSPOT_JNI_CALLBYTEMETHOD_RETURN(_ret_ref)) HOTSPOT_JNI_CALLBYTEMETHODV_RETURN(_ret_ref))
DEFINE_CALLMETHODV(jchar, Char, T_CHAR DEFINE_CALLMETHODV(jchar, Char, T_CHAR
, HOTSPOT_JNI_CALLCHARMETHOD_ENTRY(env, obj, (uintptr_t)methodID), , HOTSPOT_JNI_CALLCHARMETHODV_ENTRY(env, obj, (uintptr_t)methodID),
HOTSPOT_JNI_CALLCHARMETHOD_RETURN(_ret_ref)) HOTSPOT_JNI_CALLCHARMETHODV_RETURN(_ret_ref))
DEFINE_CALLMETHODV(jshort, Short, T_SHORT DEFINE_CALLMETHODV(jshort, Short, T_SHORT
, HOTSPOT_JNI_CALLSHORTMETHOD_ENTRY(env, obj, (uintptr_t)methodID), , HOTSPOT_JNI_CALLSHORTMETHODV_ENTRY(env, obj, (uintptr_t)methodID),
HOTSPOT_JNI_CALLSHORTMETHOD_RETURN(_ret_ref)) HOTSPOT_JNI_CALLSHORTMETHODV_RETURN(_ret_ref))
DEFINE_CALLMETHODV(jobject, Object, T_OBJECT DEFINE_CALLMETHODV(jobject, Object, T_OBJECT
, HOTSPOT_JNI_CALLOBJECTMETHOD_ENTRY(env, obj, (uintptr_t)methodID), , HOTSPOT_JNI_CALLOBJECTMETHODV_ENTRY(env, obj, (uintptr_t)methodID),
HOTSPOT_JNI_CALLOBJECTMETHOD_RETURN(_ret_ref)) HOTSPOT_JNI_CALLOBJECTMETHODV_RETURN(_ret_ref))
DEFINE_CALLMETHODV(jint, Int, T_INT, DEFINE_CALLMETHODV(jint, Int, T_INT,
HOTSPOT_JNI_CALLINTMETHOD_ENTRY(env, obj, (uintptr_t)methodID), HOTSPOT_JNI_CALLINTMETHODV_ENTRY(env, obj, (uintptr_t)methodID),
HOTSPOT_JNI_CALLINTMETHOD_RETURN(_ret_ref)) HOTSPOT_JNI_CALLINTMETHODV_RETURN(_ret_ref))
DEFINE_CALLMETHODV(jlong, Long, T_LONG DEFINE_CALLMETHODV(jlong, Long, T_LONG
, HOTSPOT_JNI_CALLLONGMETHOD_ENTRY(env, obj, (uintptr_t)methodID), , HOTSPOT_JNI_CALLLONGMETHODV_ENTRY(env, obj, (uintptr_t)methodID),
HOTSPOT_JNI_CALLLONGMETHOD_RETURN(_ret_ref)) HOTSPOT_JNI_CALLLONGMETHODV_RETURN(_ret_ref))
// Float and double probes don't return value because dtrace doesn't currently support it // Float and double probes don't return value because dtrace doesn't currently support it
DEFINE_CALLMETHODV(jfloat, Float, T_FLOAT DEFINE_CALLMETHODV(jfloat, Float, T_FLOAT
, HOTSPOT_JNI_CALLFLOATMETHOD_ENTRY(env, obj, (uintptr_t)methodID), , HOTSPOT_JNI_CALLFLOATMETHODV_ENTRY(env, obj, (uintptr_t)methodID),
HOTSPOT_JNI_CALLFLOATMETHOD_RETURN()) HOTSPOT_JNI_CALLFLOATMETHODV_RETURN())
DEFINE_CALLMETHODV(jdouble, Double, T_DOUBLE DEFINE_CALLMETHODV(jdouble, Double, T_DOUBLE
, HOTSPOT_JNI_CALLDOUBLEMETHOD_ENTRY(env, obj, (uintptr_t)methodID), , HOTSPOT_JNI_CALLDOUBLEMETHODV_ENTRY(env, obj, (uintptr_t)methodID),
HOTSPOT_JNI_CALLDOUBLEMETHOD_RETURN()) HOTSPOT_JNI_CALLDOUBLEMETHODV_RETURN())
#define DEFINE_CALLMETHODA(ResultType, Result, Tag \ #define DEFINE_CALLMETHODA(ResultType, Result, Tag \
, EntryProbe, ReturnProbe) \ , EntryProbe, ReturnProbe) \
@ -1856,34 +1856,34 @@ JNI_END
// the runtime type of subword integral basic types is integer // the runtime type of subword integral basic types is integer
DEFINE_CALLMETHODA(jboolean, Boolean, T_BOOLEAN DEFINE_CALLMETHODA(jboolean, Boolean, T_BOOLEAN
, HOTSPOT_JNI_CALLBOOLEANMETHOD_ENTRY(env, obj, (uintptr_t)methodID), , HOTSPOT_JNI_CALLBOOLEANMETHODA_ENTRY(env, obj, (uintptr_t)methodID),
HOTSPOT_JNI_CALLBOOLEANMETHOD_RETURN(_ret_ref)) HOTSPOT_JNI_CALLBOOLEANMETHODA_RETURN(_ret_ref))
DEFINE_CALLMETHODA(jbyte, Byte, T_BYTE DEFINE_CALLMETHODA(jbyte, Byte, T_BYTE
, HOTSPOT_JNI_CALLBYTEMETHOD_ENTRY(env, obj, (uintptr_t)methodID), , HOTSPOT_JNI_CALLBYTEMETHODA_ENTRY(env, obj, (uintptr_t)methodID),
HOTSPOT_JNI_CALLBYTEMETHOD_RETURN(_ret_ref)) HOTSPOT_JNI_CALLBYTEMETHODA_RETURN(_ret_ref))
DEFINE_CALLMETHODA(jchar, Char, T_CHAR DEFINE_CALLMETHODA(jchar, Char, T_CHAR
, HOTSPOT_JNI_CALLCHARMETHOD_ENTRY(env, obj, (uintptr_t)methodID), , HOTSPOT_JNI_CALLCHARMETHODA_ENTRY(env, obj, (uintptr_t)methodID),
HOTSPOT_JNI_CALLCHARMETHOD_RETURN(_ret_ref)) HOTSPOT_JNI_CALLCHARMETHODA_RETURN(_ret_ref))
DEFINE_CALLMETHODA(jshort, Short, T_SHORT DEFINE_CALLMETHODA(jshort, Short, T_SHORT
, HOTSPOT_JNI_CALLSHORTMETHOD_ENTRY(env, obj, (uintptr_t)methodID), , HOTSPOT_JNI_CALLSHORTMETHODA_ENTRY(env, obj, (uintptr_t)methodID),
HOTSPOT_JNI_CALLSHORTMETHOD_RETURN(_ret_ref)) HOTSPOT_JNI_CALLSHORTMETHODA_RETURN(_ret_ref))
DEFINE_CALLMETHODA(jobject, Object, T_OBJECT DEFINE_CALLMETHODA(jobject, Object, T_OBJECT
, HOTSPOT_JNI_CALLOBJECTMETHOD_ENTRY(env, obj, (uintptr_t)methodID), , HOTSPOT_JNI_CALLOBJECTMETHODA_ENTRY(env, obj, (uintptr_t)methodID),
HOTSPOT_JNI_CALLOBJECTMETHOD_RETURN(_ret_ref)) HOTSPOT_JNI_CALLOBJECTMETHODA_RETURN(_ret_ref))
DEFINE_CALLMETHODA(jint, Int, T_INT, DEFINE_CALLMETHODA(jint, Int, T_INT,
HOTSPOT_JNI_CALLINTMETHOD_ENTRY(env, obj, (uintptr_t)methodID), HOTSPOT_JNI_CALLINTMETHODA_ENTRY(env, obj, (uintptr_t)methodID),
HOTSPOT_JNI_CALLINTMETHOD_RETURN(_ret_ref)) HOTSPOT_JNI_CALLINTMETHODA_RETURN(_ret_ref))
DEFINE_CALLMETHODA(jlong, Long, T_LONG DEFINE_CALLMETHODA(jlong, Long, T_LONG
, HOTSPOT_JNI_CALLLONGMETHOD_ENTRY(env, obj, (uintptr_t)methodID), , HOTSPOT_JNI_CALLLONGMETHODA_ENTRY(env, obj, (uintptr_t)methodID),
HOTSPOT_JNI_CALLLONGMETHOD_RETURN(_ret_ref)) HOTSPOT_JNI_CALLLONGMETHODA_RETURN(_ret_ref))
// Float and double probes don't return value because dtrace doesn't currently support it // Float and double probes don't return value because dtrace doesn't currently support it
DEFINE_CALLMETHODA(jfloat, Float, T_FLOAT DEFINE_CALLMETHODA(jfloat, Float, T_FLOAT
, HOTSPOT_JNI_CALLFLOATMETHOD_ENTRY(env, obj, (uintptr_t)methodID), , HOTSPOT_JNI_CALLFLOATMETHODA_ENTRY(env, obj, (uintptr_t)methodID),
HOTSPOT_JNI_CALLFLOATMETHOD_RETURN()) HOTSPOT_JNI_CALLFLOATMETHODA_RETURN())
DEFINE_CALLMETHODA(jdouble, Double, T_DOUBLE DEFINE_CALLMETHODA(jdouble, Double, T_DOUBLE
, HOTSPOT_JNI_CALLDOUBLEMETHOD_ENTRY(env, obj, (uintptr_t)methodID), , HOTSPOT_JNI_CALLDOUBLEMETHODA_ENTRY(env, obj, (uintptr_t)methodID),
HOTSPOT_JNI_CALLDOUBLEMETHOD_RETURN()) HOTSPOT_JNI_CALLDOUBLEMETHODA_RETURN())
DT_VOID_RETURN_MARK_DECL(CallVoidMethod, HOTSPOT_JNI_CALLVOIDMETHOD_RETURN()); DT_VOID_RETURN_MARK_DECL(CallVoidMethod, HOTSPOT_JNI_CALLVOIDMETHOD_RETURN());
DT_VOID_RETURN_MARK_DECL(CallVoidMethodV, HOTSPOT_JNI_CALLVOIDMETHODV_RETURN()); DT_VOID_RETURN_MARK_DECL(CallVoidMethodV, HOTSPOT_JNI_CALLVOIDMETHODV_RETURN());
@ -3145,7 +3145,7 @@ JNI_ENTRY(void, jni_SetStatic##Result##Field(JNIEnv *env, jclass clazz, jfieldID
JNI_END JNI_END
DEFINE_SETSTATICFIELD(jboolean, bool, Boolean, 'Z', z DEFINE_SETSTATICFIELD(jboolean, bool, Boolean, 'Z', z
, HOTSPOT_JNI_SETBOOLEANFIELD_ENTRY(env, clazz, (uintptr_t)fieldID, value), , HOTSPOT_JNI_SETSTATICBOOLEANFIELD_ENTRY(env, clazz, (uintptr_t)fieldID, value),
HOTSPOT_JNI_SETBOOLEANFIELD_RETURN()) HOTSPOT_JNI_SETBOOLEANFIELD_RETURN())
DEFINE_SETSTATICFIELD(jbyte, byte, Byte, 'B', b DEFINE_SETSTATICFIELD(jbyte, byte, Byte, 'B', b
, HOTSPOT_JNI_SETSTATICBYTEFIELD_ENTRY(env, clazz, (uintptr_t) fieldID, value), , HOTSPOT_JNI_SETSTATICBYTEFIELD_ENTRY(env, clazz, (uintptr_t) fieldID, value),

34
hotspot/src/share/vm/prims/jvm.cpp
View file

@ -3971,40 +3971,6 @@ jclass find_class_from_class_loader(JNIEnv* env, Symbol* name, jboolean init, Ha
} }
// Internal SQE debugging support ///////////////////////////////////////////////////////////
#ifndef PRODUCT
extern "C" {
JNIEXPORT jboolean JNICALL JVM_AccessVMBooleanFlag(const char* name, jboolean* value, jboolean is_get);
JNIEXPORT jboolean JNICALL JVM_AccessVMIntFlag(const char* name, jint* value, jboolean is_get);
JNIEXPORT void JNICALL JVM_VMBreakPoint(JNIEnv *env, jobject obj);
}
JVM_LEAF(jboolean, JVM_AccessVMBooleanFlag(const char* name, jboolean* value, jboolean is_get))
JVMWrapper("JVM_AccessBoolVMFlag");
return is_get ? CommandLineFlags::boolAt((char*) name, (bool*) value) : CommandLineFlags::boolAtPut((char*) name, (bool*) value, Flag::INTERNAL);
JVM_END
JVM_LEAF(jboolean, JVM_AccessVMIntFlag(const char* name, jint* value, jboolean is_get))
JVMWrapper("JVM_AccessVMIntFlag");
intx v;
jboolean result = is_get ? CommandLineFlags::intxAt((char*) name, &v) : CommandLineFlags::intxAtPut((char*) name, &v, Flag::INTERNAL);
*value = (jint)v;
return result;
JVM_END
JVM_ENTRY(void, JVM_VMBreakPoint(JNIEnv *env, jobject obj))
JVMWrapper("JVM_VMBreakPoint");
oop the_obj = JNIHandles::resolve(obj);
BREAKPOINT;
JVM_END
#endif
// Method /////////////////////////////////////////////////////////////////////////////////////////// // Method ///////////////////////////////////////////////////////////////////////////////////////////
JVM_ENTRY(jobject, JVM_InvokeMethod(JNIEnv *env, jobject method, jobject obj, jobjectArray args0)) JVM_ENTRY(jobject, JVM_InvokeMethod(JNIEnv *env, jobject method, jobject obj, jobjectArray args0))

66
hotspot/src/share/vm/prims/methodHandles.cpp
View file

@ -175,8 +175,8 @@ oop MethodHandles::init_MemberName(Handle mname, Handle target) {
oop MethodHandles::init_method_MemberName(Handle mname, CallInfo& info) { oop MethodHandles::init_method_MemberName(Handle mname, CallInfo& info) {
assert(info.resolved_appendix().is_null(), "only normal methods here"); assert(info.resolved_appendix().is_null(), "only normal methods here");
KlassHandle receiver_limit = info.resolved_klass();
methodHandle m = info.resolved_method(); methodHandle m = info.resolved_method();
KlassHandle m_klass = m->method_holder();
int flags = (jushort)( m->access_flags().as_short() & JVM_RECOGNIZED_METHOD_MODIFIERS ); int flags = (jushort)( m->access_flags().as_short() & JVM_RECOGNIZED_METHOD_MODIFIERS );
int vmindex = Method::invalid_vtable_index; int vmindex = Method::invalid_vtable_index;
@ -184,14 +184,13 @@ oop MethodHandles::init_method_MemberName(Handle mname, CallInfo& info) {
case CallInfo::itable_call: case CallInfo::itable_call:
vmindex = info.itable_index(); vmindex = info.itable_index();
// More importantly, the itable index only works with the method holder. // More importantly, the itable index only works with the method holder.
receiver_limit = m->method_holder(); assert(m_klass->verify_itable_index(vmindex), "");
assert(receiver_limit->verify_itable_index(vmindex), "");
flags |= IS_METHOD | (JVM_REF_invokeInterface << REFERENCE_KIND_SHIFT); flags |= IS_METHOD | (JVM_REF_invokeInterface << REFERENCE_KIND_SHIFT);
if (TraceInvokeDynamic) { if (TraceInvokeDynamic) {
ResourceMark rm; ResourceMark rm;
tty->print_cr("memberName: invokeinterface method_holder::method: %s, receiver: %s, itableindex: %d, access_flags:", tty->print_cr("memberName: invokeinterface method_holder::method: %s, itableindex: %d, access_flags:",
Method::name_and_sig_as_C_string(receiver_limit(), m->name(), m->signature()), Method::name_and_sig_as_C_string(m->method_holder(), m->name(), m->signature()),
receiver_limit()->internal_name(), vmindex); vmindex);
m->access_flags().print_on(tty); m->access_flags().print_on(tty);
if (!m->is_abstract()) { if (!m->is_abstract()) {
tty->print("default"); tty->print("default");
@ -203,12 +202,35 @@ oop MethodHandles::init_method_MemberName(Handle mname, CallInfo& info) {
case CallInfo::vtable_call: case CallInfo::vtable_call:
vmindex = info.vtable_index(); vmindex = info.vtable_index();
flags |= IS_METHOD | (JVM_REF_invokeVirtual << REFERENCE_KIND_SHIFT); flags |= IS_METHOD | (JVM_REF_invokeVirtual << REFERENCE_KIND_SHIFT);
assert(receiver_limit->is_subtype_of(m->method_holder()), "virtual call must be type-safe"); assert(info.resolved_klass()->is_subtype_of(m_klass()), "virtual call must be type-safe");
if (m_klass->is_interface()) {
// This is a vtable call to an interface method (abstract "miranda method" or default method).
// The vtable index is meaningless without a class (not interface) receiver type, so get one.
// (LinkResolver should help us figure this out.)
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) { if (TraceInvokeDynamic) {
ResourceMark rm; ResourceMark rm;
tty->print_cr("memberName: invokevirtual method_holder::method: %s, receiver: %s, vtableindex: %d, access_flags:", tty->print_cr("memberName: invokevirtual method_holder::method: %s, receiver: %s, vtableindex: %d, access_flags:",
Method::name_and_sig_as_C_string(receiver_limit(), m->name(), m->signature()), Method::name_and_sig_as_C_string(m->method_holder(), m->name(), m->signature()),
receiver_limit()->internal_name(), vmindex); m_klass->internal_name(), vmindex);
m->access_flags().print_on(tty); m->access_flags().print_on(tty);
if (m->is_default_method()) { if (m->is_default_method()) {
tty->print("default"); tty->print("default");
@ -223,10 +245,8 @@ oop MethodHandles::init_method_MemberName(Handle mname, CallInfo& info) {
flags |= IS_METHOD | (JVM_REF_invokeStatic << REFERENCE_KIND_SHIFT); flags |= IS_METHOD | (JVM_REF_invokeStatic << REFERENCE_KIND_SHIFT);
} else if (m->is_initializer()) { } else if (m->is_initializer()) {
flags |= IS_CONSTRUCTOR | (JVM_REF_invokeSpecial << REFERENCE_KIND_SHIFT); flags |= IS_CONSTRUCTOR | (JVM_REF_invokeSpecial << REFERENCE_KIND_SHIFT);
assert(receiver_limit == m->method_holder(), "constructor call must be exactly typed");
} else { } else {
flags |= IS_METHOD | (JVM_REF_invokeSpecial << REFERENCE_KIND_SHIFT); flags |= IS_METHOD | (JVM_REF_invokeSpecial << REFERENCE_KIND_SHIFT);
assert(receiver_limit->is_subtype_of(m->method_holder()), "special call must be type-safe");
} }
break; break;
@ -242,7 +262,7 @@ oop MethodHandles::init_method_MemberName(Handle mname, CallInfo& info) {
java_lang_invoke_MemberName::set_flags( mname_oop, flags); java_lang_invoke_MemberName::set_flags( mname_oop, flags);
java_lang_invoke_MemberName::set_vmtarget(mname_oop, m()); 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_vmindex( mname_oop, vmindex); // vtable/itable index
java_lang_invoke_MemberName::set_clazz( mname_oop, receiver_limit->java_mirror()); java_lang_invoke_MemberName::set_clazz( mname_oop, m_klass->java_mirror());
// Note: name and type can be lazily computed by resolve_MemberName, // Note: name and type can be lazily computed by resolve_MemberName,
// if Java code needs them as resolved String and MethodType objects. // if Java code needs them as resolved String and MethodType objects.
// The clazz must be eagerly stored, because it provides a GC // The clazz must be eagerly stored, because it provides a GC
@ -569,7 +589,7 @@ oop MethodHandles::field_signature_type_or_null(Symbol* s) {
// An unresolved member name is a mere symbolic reference. // An unresolved member name is a mere symbolic reference.
// Resolving it plants a vmtarget/vmindex in it, // Resolving it plants a vmtarget/vmindex in it,
// which refers directly to JVM internals. // which refers directly to JVM internals.
Handle MethodHandles::resolve_MemberName(Handle mname, TRAPS) { Handle MethodHandles::resolve_MemberName(Handle mname, KlassHandle caller, TRAPS) {
Handle empty; Handle empty;
assert(java_lang_invoke_MemberName::is_instance(mname()), ""); assert(java_lang_invoke_MemberName::is_instance(mname()), "");
@ -646,20 +666,20 @@ Handle MethodHandles::resolve_MemberName(Handle mname, TRAPS) {
assert(!HAS_PENDING_EXCEPTION, ""); assert(!HAS_PENDING_EXCEPTION, "");
if (ref_kind == JVM_REF_invokeStatic) { if (ref_kind == JVM_REF_invokeStatic) {
LinkResolver::resolve_static_call(result, LinkResolver::resolve_static_call(result,
defc, name, type, KlassHandle(), false, false, THREAD); defc, name, type, caller, caller.not_null(), false, THREAD);
} else if (ref_kind == JVM_REF_invokeInterface) { } else if (ref_kind == JVM_REF_invokeInterface) {
LinkResolver::resolve_interface_call(result, Handle(), defc, LinkResolver::resolve_interface_call(result, Handle(), defc,
defc, name, type, KlassHandle(), false, false, THREAD); defc, name, type, caller, caller.not_null(), false, THREAD);
} else if (mh_invoke_id != vmIntrinsics::_none) { } else if (mh_invoke_id != vmIntrinsics::_none) {
assert(!is_signature_polymorphic_static(mh_invoke_id), ""); assert(!is_signature_polymorphic_static(mh_invoke_id), "");
LinkResolver::resolve_handle_call(result, LinkResolver::resolve_handle_call(result,
defc, name, type, KlassHandle(), THREAD); defc, name, type, caller, THREAD);
} else if (ref_kind == JVM_REF_invokeSpecial) { } else if (ref_kind == JVM_REF_invokeSpecial) {
LinkResolver::resolve_special_call(result, LinkResolver::resolve_special_call(result,
defc, name, type, KlassHandle(), false, THREAD); defc, name, type, caller, caller.not_null(), THREAD);
} else if (ref_kind == JVM_REF_invokeVirtual) { } else if (ref_kind == JVM_REF_invokeVirtual) {
LinkResolver::resolve_virtual_call(result, Handle(), defc, LinkResolver::resolve_virtual_call(result, Handle(), defc,
defc, name, type, KlassHandle(), false, false, THREAD); defc, name, type, caller, caller.not_null(), false, THREAD);
} else { } else {
assert(false, err_msg("ref_kind=%d", ref_kind)); assert(false, err_msg("ref_kind=%d", ref_kind));
} }
@ -683,7 +703,7 @@ Handle MethodHandles::resolve_MemberName(Handle mname, TRAPS) {
assert(!HAS_PENDING_EXCEPTION, ""); assert(!HAS_PENDING_EXCEPTION, "");
if (name == vmSymbols::object_initializer_name()) { if (name == vmSymbols::object_initializer_name()) {
LinkResolver::resolve_special_call(result, LinkResolver::resolve_special_call(result,
defc, name, type, KlassHandle(), false, THREAD); defc, name, type, caller, caller.not_null(), THREAD);
} else { } else {
break; // will throw after end of switch break; // will throw after end of switch
} }
@ -700,7 +720,7 @@ Handle MethodHandles::resolve_MemberName(Handle mname, TRAPS) {
fieldDescriptor result; // find_field initializes fd if found fieldDescriptor result; // find_field initializes fd if found
{ {
assert(!HAS_PENDING_EXCEPTION, ""); assert(!HAS_PENDING_EXCEPTION, "");
LinkResolver::resolve_field(result, defc, name, type, KlassHandle(), Bytecodes::_nop, false, false, THREAD); LinkResolver::resolve_field(result, defc, name, type, caller, Bytecodes::_nop, false, false, THREAD);
if (HAS_PENDING_EXCEPTION) { if (HAS_PENDING_EXCEPTION) {
return empty; return empty;
} }
@ -1121,7 +1141,11 @@ JVM_ENTRY(jobject, MHN_resolve_Mem(JNIEnv *env, jobject igcls, jobject mname_jh,
} }
} }
Handle resolved = MethodHandles::resolve_MemberName(mname, CHECK_NULL); 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()) { if (resolved.is_null()) {
int flags = java_lang_invoke_MemberName::flags(mname()); int flags = java_lang_invoke_MemberName::flags(mname());
int ref_kind = (flags >> REFERENCE_KIND_SHIFT) & REFERENCE_KIND_MASK; int ref_kind = (flags >> REFERENCE_KIND_SHIFT) & REFERENCE_KIND_MASK;

2
hotspot/src/share/vm/prims/methodHandles.hpp
View file

@ -55,7 +55,7 @@ class MethodHandles: AllStatic {
public: public:
// working with member names // working with member names
static Handle resolve_MemberName(Handle mname, TRAPS); // compute vmtarget/vmindex from name/type 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 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 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_MemberName(Handle mname_h, Handle target_h); // compute vmtarget/vmindex from target

5
hotspot/src/share/vm/runtime/globals.cpp
View file

@ -295,7 +295,7 @@ void Flag::print_on(outputStream* st, bool withComments) {
else st->print("%-16s", ""); else st->print("%-16s", "");
} }
st->print("%-20"); st->print("%-20s", " ");
print_kind(st); print_kind(st);
if (withComments) { if (withComments) {
@ -702,8 +702,6 @@ bool CommandLineFlags::ccstrAt(char* name, size_t len, ccstr* value) {
return true; return true;
} }
// Contract: Flag will make private copy of the incoming value.
// Outgoing value is always malloc-ed, and caller MUST call free.
bool CommandLineFlags::ccstrAtPut(char* name, size_t len, ccstr* value, Flag::Flags origin) { bool CommandLineFlags::ccstrAtPut(char* name, size_t len, ccstr* value, Flag::Flags origin) {
Flag* result = Flag::find_flag(name, len); Flag* result = Flag::find_flag(name, len);
if (result == NULL) return false; if (result == NULL) return false;
@ -726,7 +724,6 @@ bool CommandLineFlags::ccstrAtPut(char* name, size_t len, ccstr* value, Flag::Fl
return true; return true;
} }
// Contract: Flag will make private copy of the incoming value.
void CommandLineFlagsEx::ccstrAtPut(CommandLineFlagWithType flag, ccstr value, Flag::Flags origin) { void CommandLineFlagsEx::ccstrAtPut(CommandLineFlagWithType flag, ccstr value, Flag::Flags origin) {
Flag* faddr = address_of_flag(flag); Flag* faddr = address_of_flag(flag);
guarantee(faddr != NULL && faddr->is_ccstr(), "wrong flag type"); guarantee(faddr != NULL && faddr->is_ccstr(), "wrong flag type");

2
hotspot/src/share/vm/runtime/globals.hpp
View file

@ -376,6 +376,8 @@ class CommandLineFlags {
static bool ccstrAt(char* name, size_t len, ccstr* value); static bool ccstrAt(char* name, size_t len, ccstr* value);
static bool ccstrAt(char* name, ccstr* value) { return ccstrAt(name, strlen(name), value); } static bool ccstrAt(char* name, ccstr* value) { return ccstrAt(name, strlen(name), value); }
// Contract: Flag will make private copy of the incoming value.
// Outgoing value is always malloc-ed, and caller MUST call free.
static bool ccstrAtPut(char* name, size_t len, ccstr* value, Flag::Flags origin); static bool ccstrAtPut(char* name, size_t len, ccstr* value, Flag::Flags origin);
static bool ccstrAtPut(char* name, ccstr* value, Flag::Flags origin) { return ccstrAtPut(name, strlen(name), value, origin); } static bool ccstrAtPut(char* name, ccstr* value, Flag::Flags origin) { return ccstrAtPut(name, strlen(name), value, origin); }

1
hotspot/src/share/vm/runtime/globals_extension.hpp
View file

@ -201,6 +201,7 @@ class CommandLineFlagsEx : CommandLineFlags {
static void uintxAtPut(CommandLineFlagWithType flag, uintx value, Flag::Flags origin); static void uintxAtPut(CommandLineFlagWithType flag, uintx value, Flag::Flags origin);
static void uint64_tAtPut(CommandLineFlagWithType flag, uint64_t value, Flag::Flags origin); static void uint64_tAtPut(CommandLineFlagWithType flag, uint64_t value, Flag::Flags origin);
static void doubleAtPut(CommandLineFlagWithType flag, double value, Flag::Flags origin); static void doubleAtPut(CommandLineFlagWithType flag, double value, Flag::Flags origin);
// Contract: Flag will make private copy of the incoming value
static void ccstrAtPut(CommandLineFlagWithType flag, ccstr value, Flag::Flags origin); static void ccstrAtPut(CommandLineFlagWithType flag, ccstr value, Flag::Flags origin);
static bool is_default(CommandLineFlag flag); static bool is_default(CommandLineFlag flag);

5
hotspot/src/share/vm/runtime/os.cpp
View file

@ -1081,7 +1081,6 @@ void os::print_location(outputStream* st, intptr_t x, bool verbose) {
} }
#ifndef PRODUCT
// Check if in metaspace. // Check if in metaspace.
if (ClassLoaderDataGraph::contains((address)addr)) { if (ClassLoaderDataGraph::contains((address)addr)) {
// Use addr->print() from the debugger instead (not here) // Use addr->print() from the debugger instead (not here)
@ -1089,7 +1088,6 @@ void os::print_location(outputStream* st, intptr_t x, bool verbose) {
" is pointing into metadata", addr); " is pointing into metadata", addr);
return; return;
} }
#endif
// Try an OS specific find // Try an OS specific find
if (os::find(addr, st)) { if (os::find(addr, st)) {
@ -1264,9 +1262,6 @@ bool os::set_boot_path(char fileSep, char pathSep) {
"%/lib/jce.jar:" "%/lib/jce.jar:"
"%/lib/charsets.jar:" "%/lib/charsets.jar:"
"%/lib/jfr.jar:" "%/lib/jfr.jar:"
#ifdef __APPLE__
"%/lib/JObjC.jar:"
#endif
"%/classes"; "%/classes";
char* sysclasspath = format_boot_path(classpath_format, home, home_len, fileSep, pathSep); char* sysclasspath = format_boot_path(classpath_format, home, home_len, fileSep, pathSep);
if (sysclasspath == NULL) return false; if (sysclasspath == NULL) return false;

4
hotspot/src/share/vm/runtime/perfMemory.cpp
View file

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 2001, 2014, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* *
* This code is free software; you can redistribute it and/or modify it * This code is free software; you can redistribute it and/or modify it
@ -155,7 +155,7 @@ void PerfMemory::initialize() {
void PerfMemory::destroy() { void PerfMemory::destroy() {
assert(_prologue != NULL, "prologue pointer must be initialized"); if (_prologue == NULL) return;
if (_start != NULL && _prologue->overflow != 0) { if (_start != NULL && _prologue->overflow != 0) {

2
hotspot/src/share/vm/runtime/synchronizer.cpp
View file

@ -119,7 +119,7 @@ HS_DTRACE_PROBE_DECL4(hotspot, monitor__waited,
} \ } \
} }
#define HOTSPOT_MONITOR_PROBE_waited HOTSPOT_MONITOR_PROBE_WAITED #define HOTSPOT_MONITOR_PROBE_waited HOTSPOT_MONITOR_WAITED
#define DTRACE_MONITOR_PROBE(probe, monitor, obj, thread) \ #define DTRACE_MONITOR_PROBE(probe, monitor, obj, thread) \
{ \ { \

4
hotspot/src/share/vm/runtime/thread.cpp
View file

@ -135,8 +135,8 @@ HS_DTRACE_PROBE_DECL5(hotspot, thread__stop, char*, intptr_t,
#else /* USDT2 */ #else /* USDT2 */
#define HOTSPOT_THREAD_PROBE_start HOTSPOT_THREAD_PROBE_START #define HOTSPOT_THREAD_PROBE_start HOTSPOT_THREAD_START
#define HOTSPOT_THREAD_PROBE_stop HOTSPOT_THREAD_PROBE_STOP #define HOTSPOT_THREAD_PROBE_stop HOTSPOT_THREAD_STOP
#define DTRACE_THREAD_PROBE(probe, javathread) \ #define DTRACE_THREAD_PROBE(probe, javathread) \
{ \ { \

47
hotspot/src/share/vm/services/attachListener.cpp
View file

@ -451,15 +451,39 @@ static void attach_listener_thread_entry(JavaThread* thread, TRAPS) {
} }
} }
bool AttachListener::has_init_error(TRAPS) {
if (HAS_PENDING_EXCEPTION) {
tty->print_cr("Exception in VM (AttachListener::init) : ");
java_lang_Throwable::print(PENDING_EXCEPTION, tty);
tty->cr();
CLEAR_PENDING_EXCEPTION;
return true;
} else {
return false;
}
}
// Starts the Attach Listener thread // Starts the Attach Listener thread
void AttachListener::init() { void AttachListener::init() {
EXCEPTION_MARK; EXCEPTION_MARK;
Klass* k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_Thread(), true, CHECK); Klass* k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_Thread(), true, THREAD);
if (has_init_error(THREAD)) {
return;
}
instanceKlassHandle klass (THREAD, k); instanceKlassHandle klass (THREAD, k);
instanceHandle thread_oop = klass->allocate_instance_handle(CHECK); instanceHandle thread_oop = klass->allocate_instance_handle(THREAD);
if (has_init_error(THREAD)) {
return;
}
const char thread_name[] = "Attach Listener"; const char thread_name[] = "Attach Listener";
Handle string = java_lang_String::create_from_str(thread_name, CHECK); Handle string = java_lang_String::create_from_str(thread_name, THREAD);
if (has_init_error(THREAD)) {
return;
}
// Initialize thread_oop to put it into the system threadGroup // Initialize thread_oop to put it into the system threadGroup
Handle thread_group (THREAD, Universe::system_thread_group()); Handle thread_group (THREAD, Universe::system_thread_group());
@ -472,13 +496,7 @@ void AttachListener::init() {
string, string,
THREAD); THREAD);
if (HAS_PENDING_EXCEPTION) { if (has_init_error(THREAD)) {
tty->print_cr("Exception in VM (AttachListener::init) : ");
java_lang_Throwable::print(PENDING_EXCEPTION, tty);
tty->cr();
CLEAR_PENDING_EXCEPTION;
return; return;
} }
@ -490,14 +508,7 @@ void AttachListener::init() {
vmSymbols::thread_void_signature(), vmSymbols::thread_void_signature(),
thread_oop, // ARG 1 thread_oop, // ARG 1
THREAD); THREAD);
if (has_init_error(THREAD)) {
if (HAS_PENDING_EXCEPTION) {
tty->print_cr("Exception in VM (AttachListener::init) : ");
java_lang_Throwable::print(PENDING_EXCEPTION, tty);
tty->cr();
CLEAR_PENDING_EXCEPTION;
return; return;
} }

3
hotspot/src/share/vm/services/attachListener.hpp
View file

@ -94,6 +94,9 @@ class AttachListener: AllStatic {
// dequeue the next operation // dequeue the next operation
static AttachOperation* dequeue(); static AttachOperation* dequeue();
#endif // !INCLUDE_SERVICES #endif // !INCLUDE_SERVICES
private:
static bool has_init_error(TRAPS);
}; };
#if INCLUDE_SERVICES #if INCLUDE_SERVICES

15
hotspot/src/share/vm/services/diagnosticCommand.cpp
View file

@ -25,6 +25,7 @@
#include "precompiled.hpp" #include "precompiled.hpp"
#include "gc_implementation/shared/vmGCOperations.hpp" #include "gc_implementation/shared/vmGCOperations.hpp"
#include "runtime/javaCalls.hpp" #include "runtime/javaCalls.hpp"
#include "runtime/os.hpp"
#include "services/diagnosticArgument.hpp" #include "services/diagnosticArgument.hpp"
#include "services/diagnosticCommand.hpp" #include "services/diagnosticCommand.hpp"
#include "services/diagnosticFramework.hpp" #include "services/diagnosticFramework.hpp"
@ -44,6 +45,7 @@ void DCmdRegistrant::register_dcmds(){
DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<CommandLineDCmd>(full_export, true, false)); DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<CommandLineDCmd>(full_export, true, false));
DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<PrintSystemPropertiesDCmd>(full_export, true, false)); DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<PrintSystemPropertiesDCmd>(full_export, true, false));
DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<PrintVMFlagsDCmd>(full_export, true, false)); DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<PrintVMFlagsDCmd>(full_export, true, false));
DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<VMDynamicLibrariesDCmd>(full_export, true, false));
DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<VMUptimeDCmd>(full_export, true, false)); DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<VMUptimeDCmd>(full_export, true, false));
DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<SystemGCDCmd>(full_export, true, false)); DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<SystemGCDCmd>(full_export, true, false));
DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<RunFinalizationDCmd>(full_export, true, false)); DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<RunFinalizationDCmd>(full_export, true, false));
@ -610,8 +612,7 @@ void JMXStartRemoteDCmd::execute(DCmdSource source, TRAPS) {
} }
JMXStartLocalDCmd::JMXStartLocalDCmd(outputStream *output, bool heap_allocated) : JMXStartLocalDCmd::JMXStartLocalDCmd(outputStream *output, bool heap_allocated) :
DCmd(output, heap_allocated) DCmd(output, heap_allocated) {
{
// do nothing // do nothing
} }
@ -632,7 +633,6 @@ void JMXStartLocalDCmd::execute(DCmdSource source, TRAPS) {
JavaCalls::call_static(&result, ik, vmSymbols::startLocalAgent_name(), vmSymbols::void_method_signature(), CHECK); JavaCalls::call_static(&result, ik, vmSymbols::startLocalAgent_name(), vmSymbols::void_method_signature(), CHECK);
} }
void JMXStopRemoteDCmd::execute(DCmdSource source, TRAPS) { void JMXStopRemoteDCmd::execute(DCmdSource source, TRAPS) {
ResourceMark rm(THREAD); ResourceMark rm(THREAD);
HandleMark hm(THREAD); HandleMark hm(THREAD);
@ -650,3 +650,12 @@ void JMXStopRemoteDCmd::execute(DCmdSource source, TRAPS) {
JavaCalls::call_static(&result, ik, vmSymbols::stopRemoteAgent_name(), vmSymbols::void_method_signature(), CHECK); JavaCalls::call_static(&result, ik, vmSymbols::stopRemoteAgent_name(), vmSymbols::void_method_signature(), CHECK);
} }
VMDynamicLibrariesDCmd::VMDynamicLibrariesDCmd(outputStream *output, bool heap_allocated) :
DCmd(output, heap_allocated) {
// do nothing
}
void VMDynamicLibrariesDCmd::execute(DCmdSource source, TRAPS) {
os::print_dll_info(output());
output()->cr();
}

23
hotspot/src/share/vm/services/diagnosticCommand.hpp
View file

@ -132,6 +132,29 @@ public:
virtual void execute(DCmdSource source, TRAPS); virtual void execute(DCmdSource source, TRAPS);
}; };
class VMDynamicLibrariesDCmd : public DCmd {
public:
VMDynamicLibrariesDCmd(outputStream* output, bool heap);
static const char* name() {
return "VM.dynlibs";
}
static const char* description() {
return "Print loaded dynamic libraries.";
}
static const char* impact() {
return "Low";
}
static const JavaPermission permission() {
JavaPermission p = {"java.lang.management.ManagementPermission",
"monitor", NULL};
return p;
}
static int num_arguments() {
return 0;
};
virtual void execute(DCmdSource source, TRAPS);
};
class VMUptimeDCmd : public DCmdWithParser { class VMUptimeDCmd : public DCmdWithParser {
protected: protected:
DCmdArgument<bool> _date; DCmdArgument<bool> _date;

1
hotspot/src/share/vm/services/jmm.h
View file

@ -153,6 +153,7 @@ typedef enum {
JMM_VMGLOBAL_ORIGIN_ENVIRON_VAR = 4, /* Set via environment variables */ JMM_VMGLOBAL_ORIGIN_ENVIRON_VAR = 4, /* Set via environment variables */
JMM_VMGLOBAL_ORIGIN_CONFIG_FILE = 5, /* Set via config file (such as .hotspotrc) */ JMM_VMGLOBAL_ORIGIN_CONFIG_FILE = 5, /* Set via config file (such as .hotspotrc) */
JMM_VMGLOBAL_ORIGIN_ERGONOMIC = 6, /* Set via ergonomic */ JMM_VMGLOBAL_ORIGIN_ERGONOMIC = 6, /* Set via ergonomic */
JMM_VMGLOBAL_ORIGIN_ATTACH_ON_DEMAND = 7, /* Set via attach */
JMM_VMGLOBAL_ORIGIN_OTHER = 99 /* Set via some other mechanism */ JMM_VMGLOBAL_ORIGIN_OTHER = 99 /* Set via some other mechanism */
} jmmVMGlobalOrigin; } jmmVMGlobalOrigin;

8
hotspot/src/share/vm/services/management.cpp
View file

@ -1724,6 +1724,9 @@ bool add_global_entry(JNIEnv* env, Handle name, jmmVMGlobal *global, Flag *flag,
case Flag::ERGONOMIC: case Flag::ERGONOMIC:
global->origin = JMM_VMGLOBAL_ORIGIN_ERGONOMIC; global->origin = JMM_VMGLOBAL_ORIGIN_ERGONOMIC;
break; break;
case Flag::ATTACH_ON_DEMAND:
global->origin = JMM_VMGLOBAL_ORIGIN_ATTACH_ON_DEMAND;
break;
default: default:
global->origin = JMM_VMGLOBAL_ORIGIN_OTHER; global->origin = JMM_VMGLOBAL_ORIGIN_OTHER;
} }
@ -1821,7 +1824,7 @@ JVM_ENTRY(void, jmm_SetVMGlobal(JNIEnv *env, jstring flag_name, jvalue new_value
"This flag is not writeable."); "This flag is not writeable.");
} }
bool succeed; bool succeed = false;
if (flag->is_bool()) { if (flag->is_bool()) {
bool bvalue = (new_value.z == JNI_TRUE ? true : false); bool bvalue = (new_value.z == JNI_TRUE ? true : false);
succeed = CommandLineFlags::boolAtPut(name, &bvalue, Flag::MANAGEMENT); succeed = CommandLineFlags::boolAtPut(name, &bvalue, Flag::MANAGEMENT);
@ -1841,6 +1844,9 @@ JVM_ENTRY(void, jmm_SetVMGlobal(JNIEnv *env, jstring flag_name, jvalue new_value
} }
ccstr svalue = java_lang_String::as_utf8_string(str); ccstr svalue = java_lang_String::as_utf8_string(str);
succeed = CommandLineFlags::ccstrAtPut(name, &svalue, Flag::MANAGEMENT); succeed = CommandLineFlags::ccstrAtPut(name, &svalue, Flag::MANAGEMENT);
if (succeed) {
FREE_C_HEAP_ARRAY(char, svalue, mtInternal);
}
} }
assert(succeed, "Setting flag should succeed"); assert(succeed, "Setting flag should succeed");
JVM_END JVM_END

17
hotspot/src/share/vm/trace/tracetypes.xml
View file

@ -85,12 +85,6 @@ Now we can use the content + data type in declaring event fields.
<value type="UTF8" field="name" label="Name"/> <value type="UTF8" field="name" label="Name"/>
</content_type> </content_type>
<content_type id="StackTrace" hr_name="Stacktrace"
type="U8" builtin_type="STACKTRACE">
<value type="BOOLEAN" field="truncated" label="Truncated"/>
<structarray type="StackFrame" field="frames" label="Stack frames"/>
</content_type>
<content_type id="Class" hr_name="Java class" <content_type id="Class" hr_name="Java class"
type="U8" builtin_type="CLASS"> type="U8" builtin_type="CLASS">
<value type="CLASS" field="loaderClass" label="ClassLoader"/> <value type="CLASS" field="loaderClass" label="ClassLoader"/>
@ -116,17 +110,6 @@ Now we can use the content + data type in declaring event fields.
<value type="UTF8" field="name" label="Name"/> <value type="UTF8" field="name" label="Name"/>
</content_type> </content_type>
<content_type id="FrameType" hr_name="Frame type"
type="U1" jvm_type="FRAMETYPE">
<value type="UTF8" field="desc" label="Description"/>
</content_type>
<struct_type id="StackFrame">
<value type="METHOD" field="method" label="Java Method"/>
<value type="INTEGER" field="line" label="Line number"/>
<value type="FRAMETYPE" field="type" label="Frame type"/>
</struct_type>
<content_type id="GCName" hr_name="GC Name" <content_type id="GCName" hr_name="GC Name"
type="U1" jvm_type="GCNAME"> type="U1" jvm_type="GCNAME">
<value type="UTF8" field="name" label="name" /> <value type="UTF8" field="name" label="name" />

3
hotspot/test/TEST.groups
View file

@ -86,7 +86,8 @@ needs_jdk = \
runtime/RedefineObject/TestRedefineObject.java \ runtime/RedefineObject/TestRedefineObject.java \
runtime/XCheckJniJsig/XCheckJSig.java \ runtime/XCheckJniJsig/XCheckJSig.java \
serviceability/attach/AttachWithStalePidFile.java \ serviceability/attach/AttachWithStalePidFile.java \
serviceability/sa/jmap-hprof/JMapHProfLargeHeapTest.java serviceability/sa/jmap-hprof/JMapHProfLargeHeapTest.java \
serviceability/dcmd/DynLibDcmdTest.java
# JRE adds further tests to compact3 # JRE adds further tests to compact3

81
hotspot/test/gc/defnew/HeapChangeLogging.java Normal file
View file

@ -0,0 +1,81 @@
/*
* Copyright (c) 2013, 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 HeapChangeLogging.java
* @bug 8027440
* @library /testlibrary
* @build HeapChangeLogging
* @summary Allocate to get a promotion failure and verify that that heap change logging is present.
* @run main HeapChangeLogging
*
* Test the output of G1SummarizeRSetStats in conjunction with G1SummarizeRSetStatsPeriod.
*/
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import com.oracle.java.testlibrary.*;
public class HeapChangeLogging {
public static void main(String[] args) throws Exception {
ProcessBuilder pb = ProcessTools.createJavaProcessBuilder("-Xmx128m", "-Xmn100m", "-XX:+UseSerialGC", "-XX:+PrintGC", "HeapFiller");
OutputAnalyzer output = new OutputAnalyzer(pb.start());
String stdout = output.getStdout();
System.out.println(stdout);
Matcher stdoutMatcher = Pattern.compile("\\[GC .Allocation Failure.*K->.*K\\(.*K\\), .* secs\\]", Pattern.MULTILINE).matcher(stdout);
if (!stdoutMatcher.find()) {
throw new RuntimeException("No proper GC log line found");
}
output.shouldHaveExitValue(0);
}
}
class HeapFiller {
public static Entry root;
private static final int PAYLOAD_SIZE = 1000;
public static void main(String[] args) {
root = new Entry(PAYLOAD_SIZE, null);
Entry current = root;
try {
while (true) {
Entry newEntry = new Entry(PAYLOAD_SIZE, current);
current = newEntry;
}
} catch (OutOfMemoryError e) {
root = null;
}
}
}
class Entry {
public Entry previous;
public byte[] payload;
Entry(int payloadSize, Entry previous) {
payload = new byte[payloadSize];
this.previous = previous;
}
}

3
hotspot/test/runtime/LoadClass/LoadClassNegative.java
View file

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 2013, 2014, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* *
* This code is free software; you can redistribute it and/or modify it * This code is free software; you can redistribute it and/or modify it
@ -22,7 +22,6 @@
*/ */
/* /*
* @ignore 8028095
* @test * @test
* @key regression * @key regression
* @bug 8020675 * @bug 8020675

3
hotspot/test/runtime/NMT/CommandLineDetail.java
View file

@ -24,7 +24,7 @@
/* /*
* @test * @test
* @key nmt * @key nmt
* @summary Running with NMT detail should not result in an error or warning * @summary Running with NMT detail should not result in an error
* @library /testlibrary * @library /testlibrary
*/ */
@ -39,7 +39,6 @@ public class CommandLineDetail {
"-version"); "-version");
OutputAnalyzer output = new OutputAnalyzer(pb.start()); OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldNotContain("error"); output.shouldNotContain("error");
output.shouldNotContain("warning");
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);
} }
} }

3
hotspot/test/runtime/NMT/CommandLineSummary.java
View file

@ -24,7 +24,7 @@
/* /*
* @test * @test
* @key nmt * @key nmt
* @summary Running with NMT summary should not result in an error or warning * @summary Running with NMT summary should not result in an error
* @library /testlibrary * @library /testlibrary
*/ */
@ -39,7 +39,6 @@ public class CommandLineSummary {
"-version"); "-version");
OutputAnalyzer output = new OutputAnalyzer(pb.start()); OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldNotContain("error"); output.shouldNotContain("error");
output.shouldNotContain("warning");
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);
} }
} }

3
hotspot/test/runtime/NMT/CommandLineTurnOffNMT.java
View file

@ -24,7 +24,7 @@
/* /*
* @test * @test
* @key nmt * @key nmt
* @summary Turning off NMT should not result in an error or warning * @summary Turning off NMT should not result in an error
* @library /testlibrary * @library /testlibrary
*/ */
@ -38,7 +38,6 @@ public class CommandLineTurnOffNMT {
"-version"); "-version");
OutputAnalyzer output = new OutputAnalyzer(pb.start()); OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldNotContain("error"); output.shouldNotContain("error");
output.shouldNotContain("warning");
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);
} }
} }

1
hotspot/test/runtime/NMT/PrintNMTStatistics.java
View file

@ -64,7 +64,6 @@ public class PrintNMTStatistics {
OutputAnalyzer output = new OutputAnalyzer(pb.start()); OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldContain("Java Heap (reserved="); output.shouldContain("Java Heap (reserved=");
output.shouldNotContain("error"); output.shouldNotContain("error");
output.shouldNotContain("warning");
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);
} }
} }

42
hotspot/test/runtime/PerfMemDestroy/PerfMemDestroy.java Normal file
View file

@ -0,0 +1,42 @@
/*
* 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 8030955
* @summary Allow multiple calls to PerfMemory::destroy() without asserting.
* @library /testlibrary
* @run main PerfMemDestroy
*/
import java.io.File;
import java.util.Map;
import com.oracle.java.testlibrary.*;
public class PerfMemDestroy {
public static void main(String args[]) throws Throwable {
ProcessBuilder pb = ProcessTools.createJavaProcessBuilder("-XX:+PerfAllowAtExitRegistration", "-version");
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldHaveExitValue(0);
}
}

33
hotspot/test/runtime/XCheckJniJsig/XCheckJSig.java
View file

@ -22,7 +22,6 @@
*/ */
/* /*
* @ignore 8023735
* @test * @test
* @bug 7051189 8023393 * @bug 7051189 8023393
* @summary Need to suppress info message if -Xcheck:jni is used with libjsig.so * @summary Need to suppress info message if -Xcheck:jni is used with libjsig.so
@ -30,7 +29,8 @@
* @run main XCheckJSig * @run main XCheckJSig
*/ */
import java.util.*; import java.io.File;
import java.util.Map;
import com.oracle.java.testlibrary.*; import com.oracle.java.testlibrary.*;
public class XCheckJSig { public class XCheckJSig {
@ -47,33 +47,36 @@ public class XCheckJSig {
String libjsig; String libjsig;
String env_var; String env_var;
if (Platform.isOSX()) { if (Platform.isOSX()) {
libjsig = jdk_path + "/jre/lib/server/libjsig.dylib";
env_var = "DYLD_INSERT_LIBRARIES"; env_var = "DYLD_INSERT_LIBRARIES";
libjsig = jdk_path + "/jre/lib/libjsig.dylib"; // jdk location
if (!(new File(libjsig).exists())) {
libjsig = jdk_path + "/lib/libjsig.dylib"; // jre location
}
} else { } else {
libjsig = jdk_path + "/jre/lib/" + os_arch + "/libjsig.so";
env_var = "LD_PRELOAD"; env_var = "LD_PRELOAD";
} libjsig = jdk_path + "/jre/lib/" + os_arch + "/libjsig.so"; // jdk location
String java_program; if (!(new File(libjsig).exists())) {
if (Platform.isSolaris()) { libjsig = jdk_path + "/lib/" + os_arch + "/libjsig.so"; // jre location
// On Solaris, need to call the 64-bit Java directly in order for }
// LD_PRELOAD to work because libjsig.so is 64-bit.
java_program = jdk_path + "/jre/bin/" + os_arch + "/java";
} else {
java_program = JDKToolFinder.getJDKTool("java");
} }
// If this test fails, these might be useful to know. // If this test fails, these might be useful to know.
System.out.println("libjsig: " + libjsig); System.out.println("libjsig: " + libjsig);
System.out.println("osArch: " + os_arch); System.out.println("osArch: " + os_arch);
System.out.println("java_program: " + java_program);
ProcessBuilder pb = new ProcessBuilder(java_program, "-Xcheck:jni", "-version"); // Make sure the libjsig file exists.
if (!(new File(libjsig).exists())) {
System.out.println("File " + libjsig + " not found, skipping");
return;
}
ProcessBuilder pb = ProcessTools.createJavaProcessBuilder("-Xcheck:jni", "-version");
Map<String, String> env = pb.environment(); Map<String, String> env = pb.environment();
env.put(env_var, libjsig); env.put(env_var, libjsig);
OutputAnalyzer output = new OutputAnalyzer(pb.start()); OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldNotContain("libjsig is activated"); output.shouldNotContain("libjsig is activated");
output.shouldHaveExitValue(0); output.shouldHaveExitValue(0);
pb = new ProcessBuilder(java_program, "-Xcheck:jni", "-verbose:jni", "-version"); pb = ProcessTools.createJavaProcessBuilder("-Xcheck:jni", "-verbose:jni", "-version");
env = pb.environment(); env = pb.environment();
env.put(env_var, libjsig); env.put(env_var, libjsig);
output = new OutputAnalyzer(pb.start()); output = new OutputAnalyzer(pb.start());

7
hotspot/test/runtime/jsig/Test8017498.sh
View file

@ -1,7 +1,7 @@
#!/bin/sh #!/bin/sh
# #
# Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved. # Copyright (c) 2013, 2014, Oracle and/or its affiliates. All rights reserved.
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
# #
# This code is free software; you can redistribute it and/or modify it # This code is free software; you can redistribute it and/or modify it
@ -29,6 +29,7 @@
## @bug 8017498 ## @bug 8017498
## @bug 8020791 ## @bug 8020791
## @bug 8021296 ## @bug 8021296
## @bug 8022301
## @summary sigaction(sig) results in process hang/timed-out if sig is much greater than SIGRTMAX ## @summary sigaction(sig) results in process hang/timed-out if sig is much greater than SIGRTMAX
## @run shell/timeout=30 Test8017498.sh ## @run shell/timeout=30 Test8017498.sh
## ##
@ -42,6 +43,8 @@ echo "TESTSRC=${TESTSRC}"
## Adding common setup Variables for running shell tests. ## Adding common setup Variables for running shell tests.
. ${TESTSRC}/../../test_env.sh . ${TESTSRC}/../../test_env.sh
EXTRA_CFLAG=
# set platform-dependent variables # set platform-dependent variables
OS=`uname -s` OS=`uname -s`
case "$OS" in case "$OS" in
@ -57,6 +60,7 @@ case "$OS" in
MY_LD_PRELOAD=${TESTJAVA}${FS}jre${FS}lib${FS}amd64${FS}libjsig.so MY_LD_PRELOAD=${TESTJAVA}${FS}jre${FS}lib${FS}amd64${FS}libjsig.so
else else
MY_LD_PRELOAD=${TESTJAVA}${FS}jre${FS}lib${FS}i386${FS}libjsig.so MY_LD_PRELOAD=${TESTJAVA}${FS}jre${FS}lib${FS}i386${FS}libjsig.so
EXTRA_CFLAG=-m32
fi fi
echo MY_LD_PRELOAD = ${MY_LD_PRELOAD} echo MY_LD_PRELOAD = ${MY_LD_PRELOAD}
;; ;;
@ -72,6 +76,7 @@ cp ${TESTSRC}${FS}*.java ${THIS_DIR}
${TESTJAVA}${FS}bin${FS}javac *.java ${TESTJAVA}${FS}bin${FS}javac *.java
$gcc_cmd -DLINUX -fPIC -shared \ $gcc_cmd -DLINUX -fPIC -shared \
${EXTRA_CFLAG} -z noexecstack \
-o ${TESTSRC}${FS}libTestJNI.so \ -o ${TESTSRC}${FS}libTestJNI.so \
-I${TESTJAVA}${FS}include \ -I${TESTJAVA}${FS}include \
-I${TESTJAVA}${FS}include${FS}linux \ -I${TESTJAVA}${FS}include${FS}linux \

1
hotspot/test/runtime/memory/ReadFromNoaccessArea.java
View file

@ -22,7 +22,6 @@
*/ */
/* /*
* @ignore 8028398
* @test * @test
* @summary Test that touching noaccess area in class ReservedHeapSpace results in SIGSEGV/ACCESS_VIOLATION * @summary Test that touching noaccess area in class ReservedHeapSpace results in SIGSEGV/ACCESS_VIOLATION
* @library /testlibrary /testlibrary/whitebox * @library /testlibrary /testlibrary/whitebox

73
hotspot/test/serviceability/dcmd/DcmdUtil.java Normal file
View file

@ -0,0 +1,73 @@
/*
* Copyright (c) 2013 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.
*/
import sun.management.ManagementFactoryHelper;
import com.sun.management.DiagnosticCommandMBean;
public class DcmdUtil
{
public static String executeDcmd(String cmd, String ... args) {
DiagnosticCommandMBean dcmd = ManagementFactoryHelper.getDiagnosticCommandMBean();
Object[] dcmdArgs = {args};
String[] signature = {String[].class.getName()};
try {
System.out.print("> " + cmd + " ");
for (String s : args) {
System.out.print(s + " ");
}
System.out.println(":");
String result = (String) dcmd.invoke(transform(cmd), dcmdArgs, signature);
System.out.println(result);
return result;
} catch(Exception ex) {
ex.printStackTrace();
}
return null;
}
private static String transform(String name) {
StringBuilder sb = new StringBuilder();
boolean toLower = true;
boolean toUpper = false;
for (int i = 0; i < name.length(); i++) {
char c = name.charAt(i);
if (c == '.' || c == '_') {
toLower = false;
toUpper = true;
} else {
if (toUpper) {
toUpper = false;
sb.append(Character.toUpperCase(c));
} else if(toLower) {
sb.append(Character.toLowerCase(c));
} else {
sb.append(c);
}
}
}
return sb.toString();
}
}

67
hotspot/test/serviceability/dcmd/DynLibDcmdTest.java Normal file
View file

@ -0,0 +1,67 @@
import java.util.HashSet;
import java.util.Set;
import com.oracle.java.testlibrary.Platform;
/*
* Copyright (c) 2013, 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
* @summary Test of VM.dynlib diagnostic command via MBean
* @library /testlibrary
* @compile DcmdUtil.java
* @run main DynLibDcmdTest
*/
public class DynLibDcmdTest {
public static void main(String[] args) throws Exception {
String result = DcmdUtil.executeDcmd("VM.dynlibs");
String osDependentBaseString = null;
if (Platform.isSolaris()) {
osDependentBaseString = "lib%s.so";
} else if (Platform.isWindows()) {
osDependentBaseString = "%s.dll";
} else if (Platform.isOSX()) {
osDependentBaseString = "lib%s.dylib";
} else if (Platform.isLinux()) {
osDependentBaseString = "lib%s.so";
}
if (osDependentBaseString == null) {
throw new Exception("Unsupported OS");
}
Set<String> expectedContent = new HashSet<>();
expectedContent.add(String.format(osDependentBaseString, "jvm"));
expectedContent.add(String.format(osDependentBaseString, "java"));
expectedContent.add(String.format(osDependentBaseString, "management"));
for(String expected : expectedContent) {
if (!result.contains(expected)) {
throw new Exception("Dynamic library list output did not contain the expected string: '" + expected + "'");
}
}
}
}