mirror of
https://github.com/openjdk/jdk.git
synced 2025-09-20 19:14:38 +02:00
Merge
This commit is contained in:
Vladimir Kozlov
commit
6e8540ca72
77 changed files with 1733 additions and 925 deletions
|
|
@ -214,8 +214,10 @@ static int open_file_from_debug_link(const char *name,
|
|||
+ 2);
|
||||
strcpy(debug_pathname, name);
|
||||
char *last_slash = strrchr(debug_pathname, '/');
|
||||
if (last_slash == NULL)
|
||||
if (last_slash == NULL) {
|
||||
free(debug_pathname);
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* Look in the same directory as the object. */
|
||||
strcpy(last_slash+1, debug_filename);
|
||||
|
|
|
|||
|
|
@ -24,19 +24,29 @@
|
|||
|
||||
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.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.InstanceKlass;
|
||||
import sun.jvm.hotspot.oops.Klass;
|
||||
import sun.jvm.hotspot.oops.ObjArrayKlass;
|
||||
import sun.jvm.hotspot.oops.Symbol;
|
||||
import java.util.List;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Iterator;
|
||||
import java.util.Map;
|
||||
import sun.jvm.hotspot.oops.TypeArrayKlass;
|
||||
|
||||
import com.sun.jdi.ArrayReference;
|
||||
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 {
|
||||
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
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -24,12 +24,30 @@
|
|||
|
||||
package sun.jvm.hotspot.jdi;
|
||||
|
||||
import com.sun.jdi.*;
|
||||
import sun.jvm.hotspot.oops.Klass;
|
||||
import java.lang.ref.SoftReference;
|
||||
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 java.util.*;
|
||||
import java.lang.ref.SoftReference;
|
||||
import com.sun.jdi.ClassNotLoadedException;
|
||||
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
|
||||
implements ClassType
|
||||
|
|
@ -195,22 +213,26 @@ public class ClassTypeImpl extends ReferenceTypeImpl
|
|||
return null;
|
||||
}
|
||||
|
||||
void addVisibleMethods(Map methodMap) {
|
||||
@Override
|
||||
void addVisibleMethods(Map<String, Method> methodMap, Set<InterfaceType> seenInterfaces) {
|
||||
/*
|
||||
* Add methods from
|
||||
* parent types first, so that the methods in this class will
|
||||
* overwrite them in the hash table
|
||||
*/
|
||||
|
||||
Iterator iter = interfaces().iterator();
|
||||
Iterator<InterfaceType> iter = interfaces().iterator();
|
||||
while (iter.hasNext()) {
|
||||
InterfaceTypeImpl interfaze = (InterfaceTypeImpl)iter.next();
|
||||
interfaze.addVisibleMethods(methodMap);
|
||||
if (!seenInterfaces.contains(interfaze)) {
|
||||
interfaze.addVisibleMethods(methodMap, seenInterfaces);
|
||||
seenInterfaces.add(interfaze);
|
||||
}
|
||||
}
|
||||
|
||||
ClassTypeImpl clazz = (ClassTypeImpl)superclass();
|
||||
if (clazz != null) {
|
||||
clazz.addVisibleMethods(methodMap);
|
||||
clazz.addVisibleMethods(methodMap, seenInterfaces);
|
||||
}
|
||||
|
||||
addToMethodMap(methodMap, methods());
|
||||
|
|
|
|||
|
|
@ -24,15 +24,22 @@
|
|||
|
||||
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 java.util.List;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Map;
|
||||
import java.util.Iterator;
|
||||
import java.util.Collections;
|
||||
import java.lang.ref.SoftReference;
|
||||
import com.sun.jdi.ClassNotPreparedException;
|
||||
import com.sun.jdi.ClassType;
|
||||
import com.sun.jdi.InterfaceType;
|
||||
import com.sun.jdi.Method;
|
||||
import com.sun.jdi.ReferenceType;
|
||||
import com.sun.jdi.VirtualMachine;
|
||||
|
||||
public class InterfaceTypeImpl extends ReferenceTypeImpl
|
||||
implements InterfaceType {
|
||||
|
|
@ -96,16 +103,20 @@ public class InterfaceTypeImpl extends ReferenceTypeImpl
|
|||
return implementors;
|
||||
}
|
||||
|
||||
void addVisibleMethods(Map methodMap) {
|
||||
@Override
|
||||
void addVisibleMethods(Map<String, Method> methodMap, Set<InterfaceType> seenInterfaces) {
|
||||
/*
|
||||
* Add methods from
|
||||
* parent types first, so that the methods in this class will
|
||||
* overwrite them in the hash table
|
||||
*/
|
||||
Iterator iter = superinterfaces().iterator();
|
||||
Iterator<InterfaceType> iter = superinterfaces().iterator();
|
||||
while (iter.hasNext()) {
|
||||
InterfaceTypeImpl interfaze = (InterfaceTypeImpl)iter.next();
|
||||
interfaze.addVisibleMethods(methodMap);
|
||||
if (!seenInterfaces.contains(interfaze)) {
|
||||
interfaze.addVisibleMethods(methodMap, seenInterfaces);
|
||||
seenInterfaces.add(interfaze);
|
||||
}
|
||||
}
|
||||
|
||||
addToMethodMap(methodMap, methods());
|
||||
|
|
|
|||
|
|
@ -24,24 +24,45 @@
|
|||
|
||||
package sun.jvm.hotspot.jdi;
|
||||
|
||||
import java.io.*;
|
||||
|
||||
import com.sun.jdi.*;
|
||||
import java.io.ByteArrayOutputStream;
|
||||
import java.io.IOException;
|
||||
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.oops.ArrayKlass;
|
||||
import sun.jvm.hotspot.oops.DefaultHeapVisitor;
|
||||
import sun.jvm.hotspot.oops.Instance;
|
||||
import sun.jvm.hotspot.oops.InstanceKlass;
|
||||
import sun.jvm.hotspot.oops.ArrayKlass;
|
||||
import sun.jvm.hotspot.oops.JVMDIClassStatus;
|
||||
import sun.jvm.hotspot.oops.Klass;
|
||||
import sun.jvm.hotspot.oops.ObjArray;
|
||||
import sun.jvm.hotspot.oops.Oop;
|
||||
import sun.jvm.hotspot.oops.Symbol;
|
||||
import sun.jvm.hotspot.oops.DefaultHeapVisitor;
|
||||
import sun.jvm.hotspot.utilities.Assert;
|
||||
|
||||
import java.util.*;
|
||||
import java.lang.ref.SoftReference;
|
||||
import com.sun.jdi.AbsentInformationException;
|
||||
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
|
||||
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 {
|
||||
checkPrepared();
|
||||
/*
|
||||
|
|
@ -430,8 +452,8 @@ implements ReferenceType {
|
|||
* concatenation of name and signature.
|
||||
*/
|
||||
//System.out.println("jj: RTI: Calling addVisibleMethods for:" + this);
|
||||
Map map = new HashMap();
|
||||
addVisibleMethods(map);
|
||||
Map<String, Method> map = new HashMap<String, Method>();
|
||||
addVisibleMethods(map, new HashSet<InterfaceType>());
|
||||
|
||||
/*
|
||||
* ... but the hash map destroys order. Methods should be
|
||||
|
|
@ -441,7 +463,7 @@ implements ReferenceType {
|
|||
*/
|
||||
//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: map = " + map.toString());
|
||||
//System.out.println("jj: map = " + jjstr(map.values()));
|
||||
|
|
|
|||
|
|
@ -64,7 +64,7 @@ MFLAGS=`
|
|||
echo "$MFLAGS" \
|
||||
| sed '
|
||||
s/^-/ -/
|
||||
s/ -\([^ ][^ ]*\)j/ -\1 -j/
|
||||
s/ -\([^ I][^ I]*\)j/ -\1 -j/
|
||||
s/ -j[0-9][0-9]*/ -j/
|
||||
s/ -j\([^ ]\)/ -j -\1/
|
||||
s/ -j/ -j'${HOTSPOT_BUILD_JOBS:-${default_build_jobs}}'/
|
||||
|
|
|
|||
|
|
@ -36,6 +36,9 @@ CFLAGS += $(DEBUG_CFLAGS/BYFILE) -D_NMT_NOINLINE_
|
|||
|
||||
# Linker mapfile
|
||||
MAPFILE = $(GAMMADIR)/make/bsd/makefiles/mapfile-vers-debug
|
||||
ifeq ($(OS_VENDOR), Darwin)
|
||||
MAPFILE = $(GAMMADIR)/make/bsd/makefiles/mapfile-vers-darwin-debug
|
||||
endif
|
||||
|
||||
VERSION = debug
|
||||
SYSDEFS += -DASSERT
|
||||
|
|
|
|||
|
|
@ -57,6 +57,9 @@ CFLAGS$(HOTSPARC_GENERIC) += $(OPT_CFLAGS/BYFILE)
|
|||
|
||||
# Linker mapfile
|
||||
MAPFILE = $(GAMMADIR)/make/bsd/makefiles/mapfile-vers-debug
|
||||
ifeq ($(OS_VENDOR), Darwin)
|
||||
MAPFILE = $(GAMMADIR)/make/bsd/makefiles/mapfile-vers-darwin-debug
|
||||
endif
|
||||
|
||||
VERSION = fastdebug
|
||||
SYSDEFS += -DASSERT -DCHECK_UNHANDLED_OOPS
|
||||
|
|
|
|||
256
hotspot/make/bsd/makefiles/mapfile-vers-darwin-debug
Normal file
256
hotspot/make/bsd/makefiles/mapfile-vers-darwin-debug
Normal 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
256
hotspot/make/bsd/makefiles/mapfile-vers-darwin-product
Normal 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
|
||||
|
||||
|
|
@ -21,241 +21,248 @@
|
|||
# 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
|
||||
SUNWprivate_1.1 {
|
||||
global:
|
||||
# JNI
|
||||
JNI_CreateJavaVM;
|
||||
JNI_GetCreatedJavaVMs;
|
||||
JNI_GetDefaultJavaVMInitArgs;
|
||||
|
||||
# debug _JVM
|
||||
_JVM_AccessVMBooleanFlag
|
||||
_JVM_AccessVMIntFlag
|
||||
_JVM_VMBreakPoint
|
||||
# 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_linux_signal;
|
||||
|
||||
# miscellaneous functions
|
||||
_jio_fprintf
|
||||
_jio_printf
|
||||
_jio_snprintf
|
||||
_jio_vfprintf
|
||||
_jio_vsnprintf
|
||||
jio_fprintf;
|
||||
jio_printf;
|
||||
jio_snprintf;
|
||||
jio_vfprintf;
|
||||
jio_vsnprintf;
|
||||
fork1;
|
||||
numa_warn;
|
||||
numa_error;
|
||||
|
||||
# Needed because there is no JVM interface for this.
|
||||
sysThreadAvailableStackWithSlack;
|
||||
|
||||
# This is for Forte Analyzer profiling support.
|
||||
_AsyncGetCallTrace
|
||||
AsyncGetCallTrace;
|
||||
|
||||
# INSERT VTABLE SYMBOLS HERE
|
||||
|
||||
local:
|
||||
*;
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -21,236 +21,248 @@
|
|||
# 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
|
||||
SUNWprivate_1.1 {
|
||||
global:
|
||||
# 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_linux_signal;
|
||||
|
||||
# miscellaneous functions
|
||||
_jio_fprintf
|
||||
_jio_printf
|
||||
_jio_snprintf
|
||||
_jio_vfprintf
|
||||
_jio_vsnprintf
|
||||
jio_fprintf;
|
||||
jio_printf;
|
||||
jio_snprintf;
|
||||
jio_vfprintf;
|
||||
jio_vsnprintf;
|
||||
fork1;
|
||||
numa_warn;
|
||||
numa_error;
|
||||
|
||||
# Needed because there is no JVM interface for this.
|
||||
sysThreadAvailableStackWithSlack;
|
||||
|
||||
# This is for Forte Analyzer profiling support.
|
||||
_AsyncGetCallTrace
|
||||
AsyncGetCallTrace;
|
||||
|
||||
# INSERT VTABLE SYMBOLS HERE
|
||||
|
||||
local:
|
||||
*;
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -39,5 +39,8 @@ CFLAGS$(HOTSPARC_GENERIC) += $(OPT_CFLAGS/BYFILE)
|
|||
|
||||
# Linker mapfile
|
||||
MAPFILE = $(GAMMADIR)/make/bsd/makefiles/mapfile-vers-debug
|
||||
ifeq ($(OS_VENDOR), Darwin)
|
||||
MAPFILE = $(GAMMADIR)/make/bsd/makefiles/mapfile-vers-darwin-debug
|
||||
endif
|
||||
|
||||
VERSION = optimized
|
||||
|
|
|
|||
|
|
@ -39,6 +39,9 @@ CFLAGS$(HOTSPARC_GENERIC) += $(OPT_CFLAGS/BYFILE)
|
|||
|
||||
# Linker mapfile
|
||||
MAPFILE = $(GAMMADIR)/make/bsd/makefiles/mapfile-vers-product
|
||||
ifeq ($(OS_VENDOR), Darwin)
|
||||
MAPFILE = $(GAMMADIR)/make/bsd/makefiles/mapfile-vers-darwin-product
|
||||
endif
|
||||
|
||||
SYSDEFS += -DPRODUCT
|
||||
VERSION = optimized
|
||||
|
|
|
|||
|
|
@ -64,7 +64,7 @@ MFLAGS=`
|
|||
echo "$MFLAGS" \
|
||||
| sed '
|
||||
s/^-/ -/
|
||||
s/ -\([^ ][^ ]*\)j/ -\1 -j/
|
||||
s/ -\([^ I][^ I]*\)j/ -\1 -j/
|
||||
s/ -j[0-9][0-9]*/ -j/
|
||||
s/ -j\([^ ]\)/ -j -\1/
|
||||
s/ -j/ -j'${HOTSPOT_BUILD_JOBS:-${default_build_jobs}}'/
|
||||
|
|
|
|||
|
|
@ -244,11 +244,6 @@ SUNWprivate_1.1 {
|
|||
JVM_Yield;
|
||||
JVM_handle_linux_signal;
|
||||
|
||||
# debug JVM
|
||||
JVM_AccessVMBooleanFlag;
|
||||
JVM_AccessVMIntFlag;
|
||||
JVM_VMBreakPoint;
|
||||
|
||||
# miscellaneous functions
|
||||
jio_fprintf;
|
||||
jio_printf;
|
||||
|
|
|
|||
|
|
@ -64,7 +64,7 @@ MFLAGS=`
|
|||
echo "$MFLAGS" \
|
||||
| sed '
|
||||
s/^-/ -/
|
||||
s/ -\([^ ][^ ]*\)j/ -\1 -j/
|
||||
s/ -\([^ I][^ I]*\)j/ -\1 -j/
|
||||
s/ -j[0-9][0-9]*/ -j/
|
||||
s/ -j\([^ ]\)/ -j -\1/
|
||||
s/ -j/ -j'${HOTSPOT_BUILD_JOBS:-${default_build_jobs}}'/
|
||||
|
|
|
|||
|
|
@ -28,10 +28,6 @@
|
|||
|
||||
SUNWprivate_1.1 {
|
||||
global:
|
||||
# debug JVM
|
||||
JVM_AccessVMBooleanFlag;
|
||||
JVM_AccessVMIntFlag;
|
||||
JVM_VMBreakPoint;
|
||||
|
||||
# miscellaneous
|
||||
};
|
||||
|
|
|
|||
|
|
@ -94,7 +94,7 @@ SA_CFLAGS = -nologo $(MS_RUNTIME_OPTION) -W3 $(GX_OPTION) -Od -D "WIN32" -D "WIN
|
|||
SA_LD_FLAGS = bufferoverflowU.lib
|
||||
!endif
|
||||
!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"
|
||||
SA_CFLAGS = $(SA_CFLAGS) -ZI
|
||||
!endif
|
||||
|
|
|
|||
|
|
@ -47,8 +47,8 @@ provider hotspot {
|
|||
probe mem__pool__gc__end(
|
||||
char*, uintptr_t, char*, 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__probe__stop(char*, uintptr_t, uintptr_t, uintptr_t, uintptr_t);
|
||||
probe thread__start(char*, uintptr_t, uintptr_t, uintptr_t, uintptr_t);
|
||||
probe thread__stop(char*, uintptr_t, uintptr_t, uintptr_t, uintptr_t);
|
||||
probe thread__sleep__begin(long long);
|
||||
probe thread__sleep__end(int);
|
||||
probe thread__yield();
|
||||
|
|
@ -68,7 +68,7 @@ provider hotspot {
|
|||
probe monitor__contended__entered(uintptr_t, uintptr_t, char*, uintptr_t);
|
||||
probe monitor__contended__exit(uintptr_t, uintptr_t, char*, uintptr_t);
|
||||
probe monitor__wait(uintptr_t, uintptr_t, char*, uintptr_t, uintptr_t);
|
||||
probe monitor__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__notifyAll(uintptr_t, uintptr_t, char*, uintptr_t);
|
||||
|
||||
|
|
|
|||
|
|
@ -166,12 +166,10 @@ void os::run_periodic_checks() {
|
|||
return;
|
||||
}
|
||||
|
||||
#ifndef _WIN64
|
||||
// previous UnhandledExceptionFilter, if there is one
|
||||
static LPTOP_LEVEL_EXCEPTION_FILTER prev_uef_handler = NULL;
|
||||
|
||||
LONG WINAPI Handle_FLT_Exception(struct _EXCEPTION_POINTERS* exceptionInfo);
|
||||
#endif
|
||||
void os::init_system_properties_values() {
|
||||
/* sysclasspath, java_home, dll_dir */
|
||||
{
|
||||
|
|
@ -2240,11 +2238,11 @@ LONG Handle_IDiv_Exception(struct _EXCEPTION_POINTERS* exceptionInfo) {
|
|||
return EXCEPTION_CONTINUE_EXECUTION;
|
||||
}
|
||||
|
||||
#ifndef _WIN64
|
||||
//-----------------------------------------------------------------------------
|
||||
LONG WINAPI Handle_FLT_Exception(struct _EXCEPTION_POINTERS* exceptionInfo) {
|
||||
// handle exception caused by native method modifying control word
|
||||
PCONTEXT ctx = exceptionInfo->ContextRecord;
|
||||
#ifndef _WIN64
|
||||
// handle exception caused by native method modifying control word
|
||||
DWORD exception_code = exceptionInfo->ExceptionRecord->ExceptionCode;
|
||||
|
||||
switch (exception_code) {
|
||||
|
|
@ -2270,17 +2268,11 @@ LONG WINAPI Handle_FLT_Exception(struct _EXCEPTION_POINTERS* exceptionInfo) {
|
|||
// UnhandledExceptionFilter.
|
||||
return (prev_uef_handler)(exceptionInfo);
|
||||
}
|
||||
|
||||
return EXCEPTION_CONTINUE_SEARCH;
|
||||
}
|
||||
#else //_WIN64
|
||||
#else // !_WIN64
|
||||
/*
|
||||
On Windows, the mxcsr control bits are non-volatile across calls
|
||||
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;
|
||||
// we can't use StubRoutines::addr_mxcsr_std()
|
||||
// because in Win64 mxcsr is not saved there
|
||||
|
|
@ -2288,10 +2280,10 @@ LONG WINAPI Handle_FLT_Exception(struct _EXCEPTION_POINTERS* exceptionInfo) {
|
|||
ctx->MxCsr = MxCsr;
|
||||
return EXCEPTION_CONTINUE_EXECUTION;
|
||||
}
|
||||
#endif // !_WIN64
|
||||
|
||||
*/
|
||||
#endif //_WIN64
|
||||
|
||||
return EXCEPTION_CONTINUE_SEARCH;
|
||||
}
|
||||
|
||||
// Fatal error reporting is single threaded so we can make this a
|
||||
// static and preallocated. If it's more than MAX_PATH silently ignore
|
||||
|
|
@ -2640,7 +2632,6 @@ LONG WINAPI topLevelExceptionFilter(struct _EXCEPTION_POINTERS* exceptionInfo) {
|
|||
|
||||
} // switch
|
||||
}
|
||||
#ifndef _WIN64
|
||||
if (((thread->thread_state() == _thread_in_Java) ||
|
||||
(thread->thread_state() == _thread_in_native)) &&
|
||||
exception_code != EXCEPTION_UNCAUGHT_CXX_EXCEPTION)
|
||||
|
|
@ -2648,7 +2639,6 @@ LONG WINAPI topLevelExceptionFilter(struct _EXCEPTION_POINTERS* exceptionInfo) {
|
|||
LONG result=Handle_FLT_Exception(exceptionInfo);
|
||||
if (result==EXCEPTION_CONTINUE_EXECUTION) return result;
|
||||
}
|
||||
#endif //_WIN64
|
||||
}
|
||||
|
||||
if (exception_code != EXCEPTION_BREAKPOINT) {
|
||||
|
|
|
|||
|
|
@ -4098,8 +4098,12 @@ instanceKlassHandle ClassFileParser::parseClassFile(Symbol* name,
|
|||
tty->print("[Loaded %s from %s]\n", this_klass->external_name(),
|
||||
cfs->source());
|
||||
} else if (class_loader.is_null()) {
|
||||
if (THREAD->is_Java_thread()) {
|
||||
Klass* caller = ((JavaThread*)THREAD)->security_get_caller_class(1);
|
||||
Klass* caller =
|
||||
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",
|
||||
this_klass->external_name(),
|
||||
InstanceKlass::cast(caller)->external_name());
|
||||
|
|
|
|||
|
|
@ -648,12 +648,12 @@ GrowableArray<ClassLoaderData*>* ClassLoaderDataGraph::new_clds() {
|
|||
return array;
|
||||
}
|
||||
|
||||
#ifndef PRODUCT
|
||||
// for debugging and hsfind(x)
|
||||
bool ClassLoaderDataGraph::contains(address x) {
|
||||
// I think we need the _metaspace_lock taken here because the class loader
|
||||
// data graph could be changing while we are walking it (new entries added,
|
||||
// new entries being unloaded, etc).
|
||||
// For profiling and hsfind() only. Otherwise, this is unsafe (and slow). This
|
||||
// is done lock free to avoid lock inversion problems. It is safe because
|
||||
// new ClassLoaderData are added to the end of the CLDG, and only removed at
|
||||
// safepoint. The _unloading list can be deallocated concurrently with CMS so
|
||||
// this doesn't look in metaspace for classes that have been unloaded.
|
||||
bool ClassLoaderDataGraph::contains(const void* x) {
|
||||
if (DumpSharedSpaces) {
|
||||
// There are only two metaspaces to worry about.
|
||||
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
|
||||
// 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;
|
||||
}
|
||||
}
|
||||
// Do not check unloading list because deallocation can be concurrent.
|
||||
return false;
|
||||
}
|
||||
|
||||
#ifndef PRODUCT
|
||||
bool ClassLoaderDataGraph::contains_loader_data(ClassLoaderData* loader_data) {
|
||||
for (ClassLoaderData* data = _head; data != NULL; data = data->next()) {
|
||||
if (loader_data == data) {
|
||||
|
|
|
|||
|
|
@ -90,9 +90,9 @@ class ClassLoaderDataGraph : public AllStatic {
|
|||
static void dump() { dump_on(tty); }
|
||||
static void verify();
|
||||
|
||||
#ifndef PRODUCT
|
||||
// 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);
|
||||
#endif
|
||||
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
*
|
||||
* 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_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
|
||||
void determine_target(InstanceKlass* root, TRAPS) {
|
||||
if (has_target() || throws_exception()) {
|
||||
|
|
@ -416,6 +430,10 @@ class MethodFamily : public ResourceObj {
|
|||
}
|
||||
|
||||
if (num_defaults == 0) {
|
||||
// If the root klass has a static method with matching name and signature
|
||||
// then do not generate an overpass method because it will hide the
|
||||
// static method during resolution.
|
||||
if (!has_matching_static(root)) {
|
||||
if (qualified_methods.length() == 0) {
|
||||
_exception_message = generate_no_defaults_message(CHECK);
|
||||
} else {
|
||||
|
|
@ -423,10 +441,13 @@ class MethodFamily : public ResourceObj {
|
|||
_exception_message = generate_method_message(root->name(), qualified_methods.at(0), CHECK);
|
||||
}
|
||||
_exception_name = vmSymbols::java_lang_AbstractMethodError();
|
||||
}
|
||||
|
||||
// If only one qualified method is default, select that
|
||||
} else if (num_defaults == 1) {
|
||||
_selected_target = qualified_methods.at(default_index);
|
||||
} else if (num_defaults > 1) {
|
||||
|
||||
} else if (num_defaults > 1 && !has_matching_static(root)) {
|
||||
_exception_message = generate_conflicts_message(&qualified_methods,CHECK);
|
||||
_exception_name = vmSymbols::java_lang_IncompatibleClassChangeError();
|
||||
if (TraceDefaultMethods) {
|
||||
|
|
|
|||
|
|
@ -3286,7 +3286,7 @@ void JavaClasses::compute_offsets() {
|
|||
sun_reflect_ConstantPool::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();
|
||||
|
||||
// generated interpreter code wants to know about the offsets we just computed:
|
||||
|
|
|
|||
|
|
@ -655,8 +655,6 @@ inline Metadata* Dependencies::DepStream::recorded_metadata_at(int i) {
|
|||
} else {
|
||||
o = _deps->oop_recorder()->metadata_at(i);
|
||||
}
|
||||
assert(o == NULL || o->is_metaspace_object(),
|
||||
err_msg("Should be metadata " PTR_FORMAT, o));
|
||||
return o;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -2376,25 +2376,6 @@ size_t G1CollectedHeap::recalculate_used() const {
|
|||
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) {
|
||||
switch (cause) {
|
||||
case GCCause::_gc_locker: return GCLockerInvokesConcurrent;
|
||||
|
|
|
|||
|
|
@ -1183,15 +1183,6 @@ public:
|
|||
// end fields defining the extent of the contiguous allocation region.)
|
||||
// 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 {
|
||||
return _g1_storage.uncommitted_size() == 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -219,58 +219,52 @@ void SATBMarkQueueSet::handle_zero_index_for_thread(JavaThread* t) {
|
|||
}
|
||||
|
||||
#ifdef ASSERT
|
||||
void SATBMarkQueueSet::dump_active_values(JavaThread* first,
|
||||
bool expected_active) {
|
||||
gclog_or_tty->print_cr("SATB queue active values for Java Threads");
|
||||
gclog_or_tty->print_cr(" SATB queue set: active is %s",
|
||||
(is_active()) ? "TRUE" : "FALSE");
|
||||
gclog_or_tty->print_cr(" expected_active is %s",
|
||||
(expected_active) ? "TRUE" : "FALSE");
|
||||
for (JavaThread* t = first; t; t = t->next()) {
|
||||
bool active = t->satb_mark_queue().is_active();
|
||||
gclog_or_tty->print_cr(" thread %s, active is %s",
|
||||
t->name(), (active) ? "TRUE" : "FALSE");
|
||||
void SATBMarkQueueSet::dump_active_states(bool expected_active) {
|
||||
gclog_or_tty->print_cr("Expected SATB active state: %s",
|
||||
expected_active ? "ACTIVE" : "INACTIVE");
|
||||
gclog_or_tty->print_cr("Actual SATB active states:");
|
||||
gclog_or_tty->print_cr(" Queue set: %s", is_active() ? "ACTIVE" : "INACTIVE");
|
||||
for (JavaThread* t = Threads::first(); t; t = t->next()) {
|
||||
gclog_or_tty->print_cr(" Thread \"%s\" queue: %s", t->name(),
|
||||
t->satb_mark_queue().is_active() ? "ACTIVE" : "INACTIVE");
|
||||
}
|
||||
gclog_or_tty->print_cr(" Shared queue: %s",
|
||||
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
|
||||
|
||||
void SATBMarkQueueSet::set_active_all_threads(bool b,
|
||||
bool expected_active) {
|
||||
void SATBMarkQueueSet::set_active_all_threads(bool active, bool expected_active) {
|
||||
assert(SafepointSynchronize::is_at_safepoint(), "Must be at safepoint.");
|
||||
JavaThread* first = Threads::first();
|
||||
|
||||
#ifdef ASSERT
|
||||
if (_all_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,
|
||||
"SATB queue set has an unexpected active value");
|
||||
}
|
||||
verify_active_states(expected_active);
|
||||
#endif // ASSERT
|
||||
_all_active = b;
|
||||
|
||||
for (JavaThread* t = first; t; t = t->next()) {
|
||||
#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);
|
||||
_all_active = active;
|
||||
for (JavaThread* t = Threads::first(); t; t = t->next()) {
|
||||
t->satb_mark_queue().set_active(active);
|
||||
}
|
||||
shared_satb_queue()->set_active(active);
|
||||
}
|
||||
|
||||
void SATBMarkQueueSet::filter_thread_buffers() {
|
||||
|
|
|
|||
|
|
@ -87,7 +87,8 @@ class SATBMarkQueueSet: public PtrQueueSet {
|
|||
bool apply_closure_to_completed_buffer_work(bool par, int worker);
|
||||
|
||||
#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
|
||||
|
||||
public:
|
||||
|
|
@ -99,11 +100,11 @@ public:
|
|||
|
||||
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
|
||||
// SATB queues of all threads it visits, as well as the SATB queue
|
||||
// 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.
|
||||
void filter_thread_buffers();
|
||||
|
|
|
|||
|
|
@ -484,10 +484,6 @@ void ParallelScavengeHeap::ensure_parsability(bool retire_tlabs) {
|
|||
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 {
|
||||
return young_gen()->eden_space()->tlab_capacity(thr);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -184,8 +184,6 @@ class ParallelScavengeHeap : public CollectedHeap {
|
|||
void accumulate_statistics_all_tlabs();
|
||||
void resize_all_tlabs();
|
||||
|
||||
size_t unsafe_max_alloc();
|
||||
|
||||
bool supports_tlab_allocation() const { return true; }
|
||||
|
||||
size_t tlab_capacity(Thread* thr) const;
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
*
|
||||
* 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.
|
||||
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.
|
||||
promotion_failure_occurred = PSPromotionManager::post_scavenge(_gc_tracer);
|
||||
|
|
|
|||
|
|
@ -389,15 +389,6 @@ class CollectedHeap : public CHeapObj<mtInternal> {
|
|||
// allocation from them and necessitating allocation of new 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)
|
||||
// If the heap supports thread-local allocation buffers, it should override
|
||||
// the following methods:
|
||||
|
|
|
|||
|
|
@ -71,9 +71,8 @@ bool MetaspaceObj::is_shared() const {
|
|||
return MetaspaceShared::is_in_shared_space(this);
|
||||
}
|
||||
|
||||
|
||||
bool MetaspaceObj::is_metaspace_object() const {
|
||||
return Metaspace::contains((void*)this);
|
||||
return ClassLoaderDataGraph::contains((void*)this);
|
||||
}
|
||||
|
||||
void MetaspaceObj::print_address_on(outputStream* st) const {
|
||||
|
|
|
|||
|
|
@ -264,7 +264,7 @@ class ClassLoaderData;
|
|||
|
||||
class MetaspaceObj {
|
||||
public:
|
||||
bool is_metaspace_object() const; // more specific test but slower
|
||||
bool is_metaspace_object() const;
|
||||
bool is_shared() const;
|
||||
void print_address_on(outputStream* st) const; // nonvirtual address printing
|
||||
|
||||
|
|
|
|||
|
|
@ -667,9 +667,6 @@ void DefNewGeneration::collect(bool full,
|
|||
// for full GC's.
|
||||
AdaptiveSizePolicy* size_policy = gch->gen_policy()->size_policy();
|
||||
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");
|
||||
} else {
|
||||
assert(_promo_failure_scan_stack.is_empty(), "post condition");
|
||||
|
|
@ -695,6 +692,9 @@ void DefNewGeneration::collect(bool full,
|
|||
// Reset the PromotionFailureALot counters.
|
||||
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
|
||||
from()->set_concurrent_iteration_safe_limit(from()->top());
|
||||
to()->set_concurrent_iteration_safe_limit(to()->top());
|
||||
|
|
|
|||
|
|
@ -673,10 +673,6 @@ HeapWord** GenCollectedHeap::end_addr() const {
|
|||
return _gens[0]->end_addr();
|
||||
}
|
||||
|
||||
size_t GenCollectedHeap::unsafe_max_alloc() {
|
||||
return _gens[0]->unsafe_max_alloc_nogc();
|
||||
}
|
||||
|
||||
// public collection interfaces
|
||||
|
||||
void GenCollectedHeap::collect(GCCause::Cause cause) {
|
||||
|
|
|
|||
|
|
@ -166,14 +166,6 @@ public:
|
|||
HeapWord** top_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)
|
||||
virtual bool supports_heap_inspection() const { return true; }
|
||||
|
||||
|
|
|
|||
|
|
@ -143,6 +143,8 @@ class Metachunk : public Metabase<Metachunk> {
|
|||
void set_is_tagged_free(bool v) { _is_tagged_free = v; }
|
||||
#endif
|
||||
|
||||
bool contains(const void* ptr) { return bottom() <= ptr && ptr < _top; }
|
||||
|
||||
NOT_PRODUCT(void mangle();)
|
||||
|
||||
void print_on(outputStream* st) const;
|
||||
|
|
|
|||
|
|
@ -513,8 +513,6 @@ class VirtualSpaceList : public CHeapObj<mtClass> {
|
|||
// Unlink empty VirtualSpaceNodes and free it.
|
||||
void purge(ChunkManager* chunk_manager);
|
||||
|
||||
bool contains(const void *ptr);
|
||||
|
||||
void print_on(outputStream* st) const;
|
||||
|
||||
class VirtualSpaceListIterator : public StackObj {
|
||||
|
|
@ -558,7 +556,7 @@ class SpaceManager : public CHeapObj<mtClass> {
|
|||
|
||||
private:
|
||||
|
||||
// protects allocations and contains.
|
||||
// protects allocations
|
||||
Mutex* const _lock;
|
||||
|
||||
// Type of metadata allocated.
|
||||
|
|
@ -595,7 +593,11 @@ class SpaceManager : public CHeapObj<mtClass> {
|
|||
private:
|
||||
// Accessors
|
||||
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 {
|
||||
return (BlockFreelist*) &_block_freelists;
|
||||
|
|
@ -708,6 +710,8 @@ class SpaceManager : public CHeapObj<mtClass> {
|
|||
void print_on(outputStream* st) const;
|
||||
void locked_print_chunks_in_use_on(outputStream* st) const;
|
||||
|
||||
bool contains(const void *ptr);
|
||||
|
||||
void verify();
|
||||
void verify_chunk_size(Metachunk* chunk);
|
||||
NOT_PRODUCT(void mangle_freed_chunks();)
|
||||
|
|
@ -1159,8 +1163,6 @@ bool VirtualSpaceList::create_new_virtual_space(size_t vs_word_size) {
|
|||
} else {
|
||||
assert(new_entry->reserved_words() == vs_word_size,
|
||||
"Reserved memory size differs from requested memory size");
|
||||
// ensure lock-free iteration sees fully initialized node
|
||||
OrderAccess::storestore();
|
||||
link_vs(new_entry);
|
||||
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
|
||||
|
||||
// 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
|
||||
// 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;
|
||||
assert(max_shrink_bytes >= 0, err_msg("max_shrink_bytes " SIZE_FORMAT,
|
||||
max_shrink_bytes));
|
||||
|
||||
// Should shrinking be considered?
|
||||
if (MaxMetaspaceFreeRatio < 100) {
|
||||
|
|
@ -2392,6 +2382,21 @@ MetaWord* SpaceManager::allocate_work(size_t word_size) {
|
|||
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() {
|
||||
// If there are blocks in the dictionary, then
|
||||
// verfication of chunks does not work since
|
||||
|
|
@ -3464,16 +3469,11 @@ void Metaspace::print_on(outputStream* out) const {
|
|||
}
|
||||
|
||||
bool Metaspace::contains(const void* ptr) {
|
||||
if (MetaspaceShared::is_in_shared_space(ptr)) {
|
||||
return true;
|
||||
if (vsm()->contains(ptr)) return true;
|
||||
if (using_class_space()) {
|
||||
return class_vsm()->contains(ptr);
|
||||
}
|
||||
// This is checked while unlocked. As long as the virtualspaces are added
|
||||
// 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));
|
||||
return false;
|
||||
}
|
||||
|
||||
void Metaspace::verify() {
|
||||
|
|
|
|||
|
|
@ -225,7 +225,7 @@ class Metaspace : public CHeapObj<mtClass> {
|
|||
MetaWord* expand_and_allocate(size_t size,
|
||||
MetadataType mdtype);
|
||||
|
||||
static bool contains(const void *ptr);
|
||||
bool contains(const void* ptr);
|
||||
void dump(outputStream* const out) const;
|
||||
|
||||
// Free empty virtualspaces
|
||||
|
|
|
|||
|
|
@ -100,7 +100,6 @@ ReferenceProcessor::ReferenceProcessor(MemRegion span,
|
|||
_enqueuing_is_done(false),
|
||||
_is_alive_non_header(is_alive_non_header),
|
||||
_discovered_list_needs_barrier(discovered_list_needs_barrier),
|
||||
_bs(NULL),
|
||||
_processing_is_mt(mt_processing),
|
||||
_next_id(0)
|
||||
{
|
||||
|
|
@ -126,10 +125,6 @@ ReferenceProcessor::ReferenceProcessor(MemRegion span,
|
|||
_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 */);
|
||||
}
|
||||
|
||||
|
|
@ -317,13 +312,9 @@ bool enqueue_discovered_ref_helper(ReferenceProcessor* ref,
|
|||
// Enqueue references that are not made active again, and
|
||||
// clear the decks for the next collection (cycle).
|
||||
ref->enqueue_discovered_reflists((HeapWord*)pending_list_addr, task_executor);
|
||||
// Do the oop-check on pending_list_addr missed in
|
||||
// enqueue_discovered_reflist. We should probably
|
||||
// do a raw oop_check so that future such idempotent
|
||||
// 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));
|
||||
// Do the post-barrier on pending_list_addr missed in
|
||||
// enqueue_discovered_reflist.
|
||||
oopDesc::bs()->write_ref_field(pending_list_addr, oopDesc::load_decode_heap_oop(pending_list_addr));
|
||||
|
||||
// Stop treating discovered references specially.
|
||||
ref->disable_discovery();
|
||||
|
|
@ -372,15 +363,17 @@ void ReferenceProcessor::enqueue_discovered_reflist(DiscoveredList& refs_list,
|
|||
assert(java_lang_ref_Reference::next(obj) == NULL,
|
||||
"Reference not active; should not be discovered");
|
||||
// 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
|
||||
// Swap refs_list into pendling_list_addr and
|
||||
// set obj's discovered to what we read from pending_list_addr.
|
||||
oop old = oopDesc::atomic_exchange_oop(refs_list.head(), pending_list_addr);
|
||||
// Need oop_check on pending_list_addr above;
|
||||
// see special oop-check code at the end of
|
||||
// Need post-barrier on pending_list_addr above;
|
||||
// see special post-barrier code at the end of
|
||||
// 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
|
||||
|
|
@ -516,13 +509,11 @@ void DiscoveredListIterator::make_active() {
|
|||
// the reference object and will fail
|
||||
// CT verification.
|
||||
if (UseG1GC) {
|
||||
BarrierSet* bs = oopDesc::bs();
|
||||
HeapWord* next_addr = java_lang_ref_Reference::next_addr(_ref);
|
||||
|
||||
if (UseCompressedOops) {
|
||||
bs->write_ref_field_pre((narrowOop*)next_addr, NULL);
|
||||
oopDesc::bs()->write_ref_field_pre((narrowOop*)next_addr, NULL);
|
||||
} 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);
|
||||
} else {
|
||||
|
|
@ -790,10 +781,9 @@ private:
|
|||
};
|
||||
|
||||
void ReferenceProcessor::set_discovered(oop ref, oop value) {
|
||||
if (_discovered_list_needs_barrier) {
|
||||
java_lang_ref_Reference::set_discovered(ref, value);
|
||||
} else {
|
||||
java_lang_ref_Reference::set_discovered_raw(ref, value);
|
||||
if (_discovered_list_needs_barrier) {
|
||||
oopDesc::bs()->write_ref_field(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
|
||||
// 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.:-
|
||||
// _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,
|
||||
"Need to check non-G1 collector: "
|
||||
"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.inc_length(1);
|
||||
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) {
|
||||
|
|
@ -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
|
||||
// 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_list_needs_barrier || UseG1GC,
|
||||
"For non-G1 collector, may need a pre-write-barrier for CAS from NULL below");
|
||||
oop_store_raw(discovered_addr, next_discovered);
|
||||
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->inc_length(1);
|
||||
|
|
|
|||
|
|
@ -235,7 +235,6 @@ class ReferenceProcessor : public CHeapObj<mtGC> {
|
|||
// discovery.)
|
||||
bool _discovered_list_needs_barrier;
|
||||
|
||||
BarrierSet* _bs; // Cached copy of BarrierSet.
|
||||
bool _enqueuing_is_done; // true if all weak references enqueued
|
||||
bool _processing_is_mt; // true during phases when
|
||||
// reference processing is MT.
|
||||
|
|
@ -420,25 +419,6 @@ class ReferenceProcessor : public CHeapObj<mtGC> {
|
|||
void update_soft_ref_master_clock();
|
||||
|
||||
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.
|
||||
ReferenceProcessor(MemRegion span,
|
||||
bool mt_processing = false, uint mt_processing_degree = 1,
|
||||
|
|
|
|||
|
|
@ -376,8 +376,6 @@ void Klass::append_to_sibling_list() {
|
|||
}
|
||||
|
||||
bool Klass::is_loader_alive(BoolObjectClosure* is_alive) {
|
||||
assert(ClassLoaderDataGraph::contains((address)this), "is in the metaspace");
|
||||
|
||||
#ifdef ASSERT
|
||||
// The class is alive iff the class loader is alive.
|
||||
oop loader = class_loader();
|
||||
|
|
|
|||
|
|
@ -1804,34 +1804,34 @@ JNI_END
|
|||
|
||||
// the runtime type of subword integral basic types is integer
|
||||
DEFINE_CALLMETHODV(jboolean, Boolean, T_BOOLEAN
|
||||
, HOTSPOT_JNI_CALLBOOLEANMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
|
||||
HOTSPOT_JNI_CALLBOOLEANMETHOD_RETURN(_ret_ref))
|
||||
, HOTSPOT_JNI_CALLBOOLEANMETHODV_ENTRY(env, obj, (uintptr_t)methodID),
|
||||
HOTSPOT_JNI_CALLBOOLEANMETHODV_RETURN(_ret_ref))
|
||||
DEFINE_CALLMETHODV(jbyte, Byte, T_BYTE
|
||||
, HOTSPOT_JNI_CALLBYTEMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
|
||||
HOTSPOT_JNI_CALLBYTEMETHOD_RETURN(_ret_ref))
|
||||
, HOTSPOT_JNI_CALLBYTEMETHODV_ENTRY(env, obj, (uintptr_t)methodID),
|
||||
HOTSPOT_JNI_CALLBYTEMETHODV_RETURN(_ret_ref))
|
||||
DEFINE_CALLMETHODV(jchar, Char, T_CHAR
|
||||
, HOTSPOT_JNI_CALLCHARMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
|
||||
HOTSPOT_JNI_CALLCHARMETHOD_RETURN(_ret_ref))
|
||||
, HOTSPOT_JNI_CALLCHARMETHODV_ENTRY(env, obj, (uintptr_t)methodID),
|
||||
HOTSPOT_JNI_CALLCHARMETHODV_RETURN(_ret_ref))
|
||||
DEFINE_CALLMETHODV(jshort, Short, T_SHORT
|
||||
, HOTSPOT_JNI_CALLSHORTMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
|
||||
HOTSPOT_JNI_CALLSHORTMETHOD_RETURN(_ret_ref))
|
||||
, HOTSPOT_JNI_CALLSHORTMETHODV_ENTRY(env, obj, (uintptr_t)methodID),
|
||||
HOTSPOT_JNI_CALLSHORTMETHODV_RETURN(_ret_ref))
|
||||
|
||||
DEFINE_CALLMETHODV(jobject, Object, T_OBJECT
|
||||
, HOTSPOT_JNI_CALLOBJECTMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
|
||||
HOTSPOT_JNI_CALLOBJECTMETHOD_RETURN(_ret_ref))
|
||||
, HOTSPOT_JNI_CALLOBJECTMETHODV_ENTRY(env, obj, (uintptr_t)methodID),
|
||||
HOTSPOT_JNI_CALLOBJECTMETHODV_RETURN(_ret_ref))
|
||||
DEFINE_CALLMETHODV(jint, Int, T_INT,
|
||||
HOTSPOT_JNI_CALLINTMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
|
||||
HOTSPOT_JNI_CALLINTMETHOD_RETURN(_ret_ref))
|
||||
HOTSPOT_JNI_CALLINTMETHODV_ENTRY(env, obj, (uintptr_t)methodID),
|
||||
HOTSPOT_JNI_CALLINTMETHODV_RETURN(_ret_ref))
|
||||
DEFINE_CALLMETHODV(jlong, Long, T_LONG
|
||||
, HOTSPOT_JNI_CALLLONGMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
|
||||
HOTSPOT_JNI_CALLLONGMETHOD_RETURN(_ret_ref))
|
||||
, HOTSPOT_JNI_CALLLONGMETHODV_ENTRY(env, obj, (uintptr_t)methodID),
|
||||
HOTSPOT_JNI_CALLLONGMETHODV_RETURN(_ret_ref))
|
||||
// Float and double probes don't return value because dtrace doesn't currently support it
|
||||
DEFINE_CALLMETHODV(jfloat, Float, T_FLOAT
|
||||
, HOTSPOT_JNI_CALLFLOATMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
|
||||
HOTSPOT_JNI_CALLFLOATMETHOD_RETURN())
|
||||
, HOTSPOT_JNI_CALLFLOATMETHODV_ENTRY(env, obj, (uintptr_t)methodID),
|
||||
HOTSPOT_JNI_CALLFLOATMETHODV_RETURN())
|
||||
DEFINE_CALLMETHODV(jdouble, Double, T_DOUBLE
|
||||
, HOTSPOT_JNI_CALLDOUBLEMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
|
||||
HOTSPOT_JNI_CALLDOUBLEMETHOD_RETURN())
|
||||
, HOTSPOT_JNI_CALLDOUBLEMETHODV_ENTRY(env, obj, (uintptr_t)methodID),
|
||||
HOTSPOT_JNI_CALLDOUBLEMETHODV_RETURN())
|
||||
|
||||
#define DEFINE_CALLMETHODA(ResultType, Result, Tag \
|
||||
, EntryProbe, ReturnProbe) \
|
||||
|
|
@ -1856,34 +1856,34 @@ JNI_END
|
|||
|
||||
// the runtime type of subword integral basic types is integer
|
||||
DEFINE_CALLMETHODA(jboolean, Boolean, T_BOOLEAN
|
||||
, HOTSPOT_JNI_CALLBOOLEANMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
|
||||
HOTSPOT_JNI_CALLBOOLEANMETHOD_RETURN(_ret_ref))
|
||||
, HOTSPOT_JNI_CALLBOOLEANMETHODA_ENTRY(env, obj, (uintptr_t)methodID),
|
||||
HOTSPOT_JNI_CALLBOOLEANMETHODA_RETURN(_ret_ref))
|
||||
DEFINE_CALLMETHODA(jbyte, Byte, T_BYTE
|
||||
, HOTSPOT_JNI_CALLBYTEMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
|
||||
HOTSPOT_JNI_CALLBYTEMETHOD_RETURN(_ret_ref))
|
||||
, HOTSPOT_JNI_CALLBYTEMETHODA_ENTRY(env, obj, (uintptr_t)methodID),
|
||||
HOTSPOT_JNI_CALLBYTEMETHODA_RETURN(_ret_ref))
|
||||
DEFINE_CALLMETHODA(jchar, Char, T_CHAR
|
||||
, HOTSPOT_JNI_CALLCHARMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
|
||||
HOTSPOT_JNI_CALLCHARMETHOD_RETURN(_ret_ref))
|
||||
, HOTSPOT_JNI_CALLCHARMETHODA_ENTRY(env, obj, (uintptr_t)methodID),
|
||||
HOTSPOT_JNI_CALLCHARMETHODA_RETURN(_ret_ref))
|
||||
DEFINE_CALLMETHODA(jshort, Short, T_SHORT
|
||||
, HOTSPOT_JNI_CALLSHORTMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
|
||||
HOTSPOT_JNI_CALLSHORTMETHOD_RETURN(_ret_ref))
|
||||
, HOTSPOT_JNI_CALLSHORTMETHODA_ENTRY(env, obj, (uintptr_t)methodID),
|
||||
HOTSPOT_JNI_CALLSHORTMETHODA_RETURN(_ret_ref))
|
||||
|
||||
DEFINE_CALLMETHODA(jobject, Object, T_OBJECT
|
||||
, HOTSPOT_JNI_CALLOBJECTMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
|
||||
HOTSPOT_JNI_CALLOBJECTMETHOD_RETURN(_ret_ref))
|
||||
, HOTSPOT_JNI_CALLOBJECTMETHODA_ENTRY(env, obj, (uintptr_t)methodID),
|
||||
HOTSPOT_JNI_CALLOBJECTMETHODA_RETURN(_ret_ref))
|
||||
DEFINE_CALLMETHODA(jint, Int, T_INT,
|
||||
HOTSPOT_JNI_CALLINTMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
|
||||
HOTSPOT_JNI_CALLINTMETHOD_RETURN(_ret_ref))
|
||||
HOTSPOT_JNI_CALLINTMETHODA_ENTRY(env, obj, (uintptr_t)methodID),
|
||||
HOTSPOT_JNI_CALLINTMETHODA_RETURN(_ret_ref))
|
||||
DEFINE_CALLMETHODA(jlong, Long, T_LONG
|
||||
, HOTSPOT_JNI_CALLLONGMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
|
||||
HOTSPOT_JNI_CALLLONGMETHOD_RETURN(_ret_ref))
|
||||
, HOTSPOT_JNI_CALLLONGMETHODA_ENTRY(env, obj, (uintptr_t)methodID),
|
||||
HOTSPOT_JNI_CALLLONGMETHODA_RETURN(_ret_ref))
|
||||
// Float and double probes don't return value because dtrace doesn't currently support it
|
||||
DEFINE_CALLMETHODA(jfloat, Float, T_FLOAT
|
||||
, HOTSPOT_JNI_CALLFLOATMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
|
||||
HOTSPOT_JNI_CALLFLOATMETHOD_RETURN())
|
||||
, HOTSPOT_JNI_CALLFLOATMETHODA_ENTRY(env, obj, (uintptr_t)methodID),
|
||||
HOTSPOT_JNI_CALLFLOATMETHODA_RETURN())
|
||||
DEFINE_CALLMETHODA(jdouble, Double, T_DOUBLE
|
||||
, HOTSPOT_JNI_CALLDOUBLEMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
|
||||
HOTSPOT_JNI_CALLDOUBLEMETHOD_RETURN())
|
||||
, HOTSPOT_JNI_CALLDOUBLEMETHODA_ENTRY(env, obj, (uintptr_t)methodID),
|
||||
HOTSPOT_JNI_CALLDOUBLEMETHODA_RETURN())
|
||||
|
||||
DT_VOID_RETURN_MARK_DECL(CallVoidMethod, HOTSPOT_JNI_CALLVOIDMETHOD_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
|
||||
|
||||
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())
|
||||
DEFINE_SETSTATICFIELD(jbyte, byte, Byte, 'B', b
|
||||
, HOTSPOT_JNI_SETSTATICBYTEFIELD_ENTRY(env, clazz, (uintptr_t) fieldID, value),
|
||||
|
|
|
|||
|
|
@ -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 ///////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
JVM_ENTRY(jobject, JVM_InvokeMethod(JNIEnv *env, jobject method, jobject obj, jobjectArray args0))
|
||||
|
|
|
|||
|
|
@ -175,8 +175,8 @@ oop MethodHandles::init_MemberName(Handle mname, Handle target) {
|
|||
|
||||
oop MethodHandles::init_method_MemberName(Handle mname, CallInfo& info) {
|
||||
assert(info.resolved_appendix().is_null(), "only normal methods here");
|
||||
KlassHandle receiver_limit = info.resolved_klass();
|
||||
methodHandle m = info.resolved_method();
|
||||
KlassHandle m_klass = m->method_holder();
|
||||
int flags = (jushort)( m->access_flags().as_short() & JVM_RECOGNIZED_METHOD_MODIFIERS );
|
||||
int vmindex = Method::invalid_vtable_index;
|
||||
|
||||
|
|
@ -184,14 +184,13 @@ oop MethodHandles::init_method_MemberName(Handle mname, CallInfo& info) {
|
|||
case CallInfo::itable_call:
|
||||
vmindex = info.itable_index();
|
||||
// More importantly, the itable index only works with the method holder.
|
||||
receiver_limit = m->method_holder();
|
||||
assert(receiver_limit->verify_itable_index(vmindex), "");
|
||||
assert(m_klass->verify_itable_index(vmindex), "");
|
||||
flags |= IS_METHOD | (JVM_REF_invokeInterface << REFERENCE_KIND_SHIFT);
|
||||
if (TraceInvokeDynamic) {
|
||||
ResourceMark rm;
|
||||
tty->print_cr("memberName: invokeinterface method_holder::method: %s, receiver: %s, itableindex: %d, access_flags:",
|
||||
Method::name_and_sig_as_C_string(receiver_limit(), m->name(), m->signature()),
|
||||
receiver_limit()->internal_name(), vmindex);
|
||||
tty->print_cr("memberName: invokeinterface method_holder::method: %s, itableindex: %d, access_flags:",
|
||||
Method::name_and_sig_as_C_string(m->method_holder(), m->name(), m->signature()),
|
||||
vmindex);
|
||||
m->access_flags().print_on(tty);
|
||||
if (!m->is_abstract()) {
|
||||
tty->print("default");
|
||||
|
|
@ -203,12 +202,35 @@ oop MethodHandles::init_method_MemberName(Handle mname, CallInfo& info) {
|
|||
case CallInfo::vtable_call:
|
||||
vmindex = info.vtable_index();
|
||||
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) {
|
||||
ResourceMark rm;
|
||||
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()),
|
||||
receiver_limit()->internal_name(), vmindex);
|
||||
Method::name_and_sig_as_C_string(m->method_holder(), m->name(), m->signature()),
|
||||
m_klass->internal_name(), vmindex);
|
||||
m->access_flags().print_on(tty);
|
||||
if (m->is_default_method()) {
|
||||
tty->print("default");
|
||||
|
|
@ -223,10 +245,8 @@ oop MethodHandles::init_method_MemberName(Handle mname, CallInfo& info) {
|
|||
flags |= IS_METHOD | (JVM_REF_invokeStatic << REFERENCE_KIND_SHIFT);
|
||||
} else if (m->is_initializer()) {
|
||||
flags |= IS_CONSTRUCTOR | (JVM_REF_invokeSpecial << REFERENCE_KIND_SHIFT);
|
||||
assert(receiver_limit == m->method_holder(), "constructor call must be exactly typed");
|
||||
} else {
|
||||
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;
|
||||
|
||||
|
|
@ -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_vmtarget(mname_oop, m());
|
||||
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,
|
||||
// if Java code needs them as resolved String and MethodType objects.
|
||||
// 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.
|
||||
// Resolving it plants a vmtarget/vmindex in it,
|
||||
// which refers directly to JVM internals.
|
||||
Handle MethodHandles::resolve_MemberName(Handle mname, TRAPS) {
|
||||
Handle MethodHandles::resolve_MemberName(Handle mname, KlassHandle caller, TRAPS) {
|
||||
Handle empty;
|
||||
assert(java_lang_invoke_MemberName::is_instance(mname()), "");
|
||||
|
||||
|
|
@ -646,20 +666,20 @@ Handle MethodHandles::resolve_MemberName(Handle mname, TRAPS) {
|
|||
assert(!HAS_PENDING_EXCEPTION, "");
|
||||
if (ref_kind == JVM_REF_invokeStatic) {
|
||||
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) {
|
||||
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) {
|
||||
assert(!is_signature_polymorphic_static(mh_invoke_id), "");
|
||||
LinkResolver::resolve_handle_call(result,
|
||||
defc, name, type, KlassHandle(), THREAD);
|
||||
defc, name, type, caller, THREAD);
|
||||
} else if (ref_kind == JVM_REF_invokeSpecial) {
|
||||
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) {
|
||||
LinkResolver::resolve_virtual_call(result, Handle(), defc,
|
||||
defc, name, type, KlassHandle(), false, false, THREAD);
|
||||
defc, name, type, caller, caller.not_null(), false, THREAD);
|
||||
} else {
|
||||
assert(false, err_msg("ref_kind=%d", ref_kind));
|
||||
}
|
||||
|
|
@ -683,7 +703,7 @@ Handle MethodHandles::resolve_MemberName(Handle mname, TRAPS) {
|
|||
assert(!HAS_PENDING_EXCEPTION, "");
|
||||
if (name == vmSymbols::object_initializer_name()) {
|
||||
LinkResolver::resolve_special_call(result,
|
||||
defc, name, type, KlassHandle(), false, THREAD);
|
||||
defc, name, type, caller, caller.not_null(), THREAD);
|
||||
} else {
|
||||
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
|
||||
{
|
||||
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) {
|
||||
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()) {
|
||||
int flags = java_lang_invoke_MemberName::flags(mname());
|
||||
int ref_kind = (flags >> REFERENCE_KIND_SHIFT) & REFERENCE_KIND_MASK;
|
||||
|
|
|
|||
|
|
@ -55,7 +55,7 @@ class MethodHandles: AllStatic {
|
|||
|
||||
public:
|
||||
// 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 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
|
||||
|
|
|
|||
|
|
@ -295,7 +295,7 @@ void Flag::print_on(outputStream* st, bool withComments) {
|
|||
else st->print("%-16s", "");
|
||||
}
|
||||
|
||||
st->print("%-20");
|
||||
st->print("%-20s", " ");
|
||||
print_kind(st);
|
||||
|
||||
if (withComments) {
|
||||
|
|
@ -702,8 +702,6 @@ bool CommandLineFlags::ccstrAt(char* name, size_t len, ccstr* value) {
|
|||
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) {
|
||||
Flag* result = Flag::find_flag(name, len);
|
||||
if (result == NULL) return false;
|
||||
|
|
@ -726,7 +724,6 @@ bool CommandLineFlags::ccstrAtPut(char* name, size_t len, ccstr* value, Flag::Fl
|
|||
return true;
|
||||
}
|
||||
|
||||
// Contract: Flag will make private copy of the incoming value.
|
||||
void CommandLineFlagsEx::ccstrAtPut(CommandLineFlagWithType flag, ccstr value, Flag::Flags origin) {
|
||||
Flag* faddr = address_of_flag(flag);
|
||||
guarantee(faddr != NULL && faddr->is_ccstr(), "wrong flag type");
|
||||
|
|
|
|||
|
|
@ -376,6 +376,8 @@ class CommandLineFlags {
|
|||
|
||||
static bool ccstrAt(char* name, size_t len, ccstr* 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, ccstr* value, Flag::Flags origin) { return ccstrAtPut(name, strlen(name), value, origin); }
|
||||
|
||||
|
|
|
|||
|
|
@ -201,6 +201,7 @@ class CommandLineFlagsEx : CommandLineFlags {
|
|||
static void uintxAtPut(CommandLineFlagWithType flag, uintx 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);
|
||||
// Contract: Flag will make private copy of the incoming value
|
||||
static void ccstrAtPut(CommandLineFlagWithType flag, ccstr value, Flag::Flags origin);
|
||||
|
||||
static bool is_default(CommandLineFlag flag);
|
||||
|
|
|
|||
|
|
@ -1081,7 +1081,6 @@ void os::print_location(outputStream* st, intptr_t x, bool verbose) {
|
|||
|
||||
}
|
||||
|
||||
#ifndef PRODUCT
|
||||
// Check if in metaspace.
|
||||
if (ClassLoaderDataGraph::contains((address)addr)) {
|
||||
// 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);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
|
||||
// Try an OS specific find
|
||||
if (os::find(addr, st)) {
|
||||
|
|
@ -1264,9 +1262,6 @@ bool os::set_boot_path(char fileSep, char pathSep) {
|
|||
"%/lib/jce.jar:"
|
||||
"%/lib/charsets.jar:"
|
||||
"%/lib/jfr.jar:"
|
||||
#ifdef __APPLE__
|
||||
"%/lib/JObjC.jar:"
|
||||
#endif
|
||||
"%/classes";
|
||||
char* sysclasspath = format_boot_path(classpath_format, home, home_len, fileSep, pathSep);
|
||||
if (sysclasspath == NULL) return false;
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
*
|
||||
* This code is free software; you can redistribute it and/or modify it
|
||||
|
|
@ -155,7 +155,7 @@ void PerfMemory::initialize() {
|
|||
|
||||
void PerfMemory::destroy() {
|
||||
|
||||
assert(_prologue != NULL, "prologue pointer must be initialized");
|
||||
if (_prologue == NULL) return;
|
||||
|
||||
if (_start != NULL && _prologue->overflow != 0) {
|
||||
|
||||
|
|
|
|||
|
|
@ -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) \
|
||||
{ \
|
||||
|
|
|
|||
|
|
@ -135,8 +135,8 @@ HS_DTRACE_PROBE_DECL5(hotspot, thread__stop, char*, intptr_t,
|
|||
|
||||
#else /* USDT2 */
|
||||
|
||||
#define HOTSPOT_THREAD_PROBE_start HOTSPOT_THREAD_PROBE_START
|
||||
#define HOTSPOT_THREAD_PROBE_stop HOTSPOT_THREAD_PROBE_STOP
|
||||
#define HOTSPOT_THREAD_PROBE_start HOTSPOT_THREAD_START
|
||||
#define HOTSPOT_THREAD_PROBE_stop HOTSPOT_THREAD_STOP
|
||||
|
||||
#define DTRACE_THREAD_PROBE(probe, javathread) \
|
||||
{ \
|
||||
|
|
|
|||
|
|
@ -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
|
||||
void AttachListener::init() {
|
||||
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);
|
||||
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";
|
||||
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
|
||||
Handle thread_group (THREAD, Universe::system_thread_group());
|
||||
|
|
@ -472,13 +496,7 @@ void AttachListener::init() {
|
|||
string,
|
||||
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;
|
||||
|
||||
if (has_init_error(THREAD)) {
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -490,14 +508,7 @@ void AttachListener::init() {
|
|||
vmSymbols::thread_void_signature(),
|
||||
thread_oop, // ARG 1
|
||||
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;
|
||||
|
||||
if (has_init_error(THREAD)) {
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -94,6 +94,9 @@ class AttachListener: AllStatic {
|
|||
// dequeue the next operation
|
||||
static AttachOperation* dequeue();
|
||||
#endif // !INCLUDE_SERVICES
|
||||
|
||||
private:
|
||||
static bool has_init_error(TRAPS);
|
||||
};
|
||||
|
||||
#if INCLUDE_SERVICES
|
||||
|
|
|
|||
|
|
@ -25,6 +25,7 @@
|
|||
#include "precompiled.hpp"
|
||||
#include "gc_implementation/shared/vmGCOperations.hpp"
|
||||
#include "runtime/javaCalls.hpp"
|
||||
#include "runtime/os.hpp"
|
||||
#include "services/diagnosticArgument.hpp"
|
||||
#include "services/diagnosticCommand.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<PrintSystemPropertiesDCmd>(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<SystemGCDCmd>(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) :
|
||||
DCmd(output, heap_allocated)
|
||||
{
|
||||
DCmd(output, heap_allocated) {
|
||||
// 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);
|
||||
}
|
||||
|
||||
|
||||
void JMXStopRemoteDCmd::execute(DCmdSource source, TRAPS) {
|
||||
ResourceMark rm(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);
|
||||
}
|
||||
|
||||
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();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -132,6 +132,29 @@ public:
|
|||
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 {
|
||||
protected:
|
||||
DCmdArgument<bool> _date;
|
||||
|
|
|
|||
|
|
@ -153,6 +153,7 @@ typedef enum {
|
|||
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_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 */
|
||||
} jmmVMGlobalOrigin;
|
||||
|
||||
|
|
|
|||
|
|
@ -1724,6 +1724,9 @@ bool add_global_entry(JNIEnv* env, Handle name, jmmVMGlobal *global, Flag *flag,
|
|||
case Flag::ERGONOMIC:
|
||||
global->origin = JMM_VMGLOBAL_ORIGIN_ERGONOMIC;
|
||||
break;
|
||||
case Flag::ATTACH_ON_DEMAND:
|
||||
global->origin = JMM_VMGLOBAL_ORIGIN_ATTACH_ON_DEMAND;
|
||||
break;
|
||||
default:
|
||||
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.");
|
||||
}
|
||||
|
||||
bool succeed;
|
||||
bool succeed = false;
|
||||
if (flag->is_bool()) {
|
||||
bool bvalue = (new_value.z == JNI_TRUE ? true : false);
|
||||
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);
|
||||
succeed = CommandLineFlags::ccstrAtPut(name, &svalue, Flag::MANAGEMENT);
|
||||
if (succeed) {
|
||||
FREE_C_HEAP_ARRAY(char, svalue, mtInternal);
|
||||
}
|
||||
}
|
||||
assert(succeed, "Setting flag should succeed");
|
||||
JVM_END
|
||||
|
|
|
|||
|
|
@ -85,12 +85,6 @@ Now we can use the content + data type in declaring event fields.
|
|||
<value type="UTF8" field="name" label="Name"/>
|
||||
</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"
|
||||
type="U8" builtin_type="CLASS">
|
||||
<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"/>
|
||||
</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"
|
||||
type="U1" jvm_type="GCNAME">
|
||||
<value type="UTF8" field="name" label="name" />
|
||||
|
|
|
|||
|
|
@ -86,7 +86,8 @@ needs_jdk = \
|
|||
runtime/RedefineObject/TestRedefineObject.java \
|
||||
runtime/XCheckJniJsig/XCheckJSig.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
|
||||
|
|
|
|||
81
hotspot/test/gc/defnew/HeapChangeLogging.java
Normal file
81
hotspot/test/gc/defnew/HeapChangeLogging.java
Normal 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;
|
||||
}
|
||||
}
|
||||
|
|
@ -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.
|
||||
*
|
||||
* This code is free software; you can redistribute it and/or modify it
|
||||
|
|
@ -22,7 +22,6 @@
|
|||
*/
|
||||
|
||||
/*
|
||||
* @ignore 8028095
|
||||
* @test
|
||||
* @key regression
|
||||
* @bug 8020675
|
||||
|
|
|
|||
|
|
@ -24,7 +24,7 @@
|
|||
/*
|
||||
* @test
|
||||
* @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
|
||||
*/
|
||||
|
||||
|
|
@ -39,7 +39,6 @@ public class CommandLineDetail {
|
|||
"-version");
|
||||
OutputAnalyzer output = new OutputAnalyzer(pb.start());
|
||||
output.shouldNotContain("error");
|
||||
output.shouldNotContain("warning");
|
||||
output.shouldHaveExitValue(0);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -24,7 +24,7 @@
|
|||
/*
|
||||
* @test
|
||||
* @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
|
||||
*/
|
||||
|
||||
|
|
@ -39,7 +39,6 @@ public class CommandLineSummary {
|
|||
"-version");
|
||||
OutputAnalyzer output = new OutputAnalyzer(pb.start());
|
||||
output.shouldNotContain("error");
|
||||
output.shouldNotContain("warning");
|
||||
output.shouldHaveExitValue(0);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -24,7 +24,7 @@
|
|||
/*
|
||||
* @test
|
||||
* @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
|
||||
*/
|
||||
|
||||
|
|
@ -38,7 +38,6 @@ public class CommandLineTurnOffNMT {
|
|||
"-version");
|
||||
OutputAnalyzer output = new OutputAnalyzer(pb.start());
|
||||
output.shouldNotContain("error");
|
||||
output.shouldNotContain("warning");
|
||||
output.shouldHaveExitValue(0);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -64,7 +64,6 @@ public class PrintNMTStatistics {
|
|||
OutputAnalyzer output = new OutputAnalyzer(pb.start());
|
||||
output.shouldContain("Java Heap (reserved=");
|
||||
output.shouldNotContain("error");
|
||||
output.shouldNotContain("warning");
|
||||
output.shouldHaveExitValue(0);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
42
hotspot/test/runtime/PerfMemDestroy/PerfMemDestroy.java
Normal file
42
hotspot/test/runtime/PerfMemDestroy/PerfMemDestroy.java
Normal 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);
|
||||
}
|
||||
}
|
||||
|
|
@ -22,7 +22,6 @@
|
|||
*/
|
||||
|
||||
/*
|
||||
* @ignore 8023735
|
||||
* @test
|
||||
* @bug 7051189 8023393
|
||||
* @summary Need to suppress info message if -Xcheck:jni is used with libjsig.so
|
||||
|
|
@ -30,7 +29,8 @@
|
|||
* @run main XCheckJSig
|
||||
*/
|
||||
|
||||
import java.util.*;
|
||||
import java.io.File;
|
||||
import java.util.Map;
|
||||
import com.oracle.java.testlibrary.*;
|
||||
|
||||
public class XCheckJSig {
|
||||
|
|
@ -47,33 +47,36 @@ public class XCheckJSig {
|
|||
String libjsig;
|
||||
String env_var;
|
||||
if (Platform.isOSX()) {
|
||||
libjsig = jdk_path + "/jre/lib/server/libjsig.dylib";
|
||||
env_var = "DYLD_INSERT_LIBRARIES";
|
||||
} else {
|
||||
libjsig = jdk_path + "/jre/lib/" + os_arch + "/libjsig.so";
|
||||
env_var = "LD_PRELOAD";
|
||||
libjsig = jdk_path + "/jre/lib/libjsig.dylib"; // jdk location
|
||||
if (!(new File(libjsig).exists())) {
|
||||
libjsig = jdk_path + "/lib/libjsig.dylib"; // jre location
|
||||
}
|
||||
String java_program;
|
||||
if (Platform.isSolaris()) {
|
||||
// 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");
|
||||
env_var = "LD_PRELOAD";
|
||||
libjsig = jdk_path + "/jre/lib/" + os_arch + "/libjsig.so"; // jdk location
|
||||
if (!(new File(libjsig).exists())) {
|
||||
libjsig = jdk_path + "/lib/" + os_arch + "/libjsig.so"; // jre location
|
||||
}
|
||||
}
|
||||
// If this test fails, these might be useful to know.
|
||||
System.out.println("libjsig: " + libjsig);
|
||||
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();
|
||||
env.put(env_var, libjsig);
|
||||
OutputAnalyzer output = new OutputAnalyzer(pb.start());
|
||||
output.shouldNotContain("libjsig is activated");
|
||||
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.put(env_var, libjsig);
|
||||
output = new OutputAnalyzer(pb.start());
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
#!/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.
|
||||
#
|
||||
# This code is free software; you can redistribute it and/or modify it
|
||||
|
|
@ -29,6 +29,7 @@
|
|||
## @bug 8017498
|
||||
## @bug 8020791
|
||||
## @bug 8021296
|
||||
## @bug 8022301
|
||||
## @summary sigaction(sig) results in process hang/timed-out if sig is much greater than SIGRTMAX
|
||||
## @run shell/timeout=30 Test8017498.sh
|
||||
##
|
||||
|
|
@ -42,6 +43,8 @@ echo "TESTSRC=${TESTSRC}"
|
|||
## Adding common setup Variables for running shell tests.
|
||||
. ${TESTSRC}/../../test_env.sh
|
||||
|
||||
EXTRA_CFLAG=
|
||||
|
||||
# set platform-dependent variables
|
||||
OS=`uname -s`
|
||||
case "$OS" in
|
||||
|
|
@ -57,6 +60,7 @@ case "$OS" in
|
|||
MY_LD_PRELOAD=${TESTJAVA}${FS}jre${FS}lib${FS}amd64${FS}libjsig.so
|
||||
else
|
||||
MY_LD_PRELOAD=${TESTJAVA}${FS}jre${FS}lib${FS}i386${FS}libjsig.so
|
||||
EXTRA_CFLAG=-m32
|
||||
fi
|
||||
echo MY_LD_PRELOAD = ${MY_LD_PRELOAD}
|
||||
;;
|
||||
|
|
@ -72,6 +76,7 @@ cp ${TESTSRC}${FS}*.java ${THIS_DIR}
|
|||
${TESTJAVA}${FS}bin${FS}javac *.java
|
||||
|
||||
$gcc_cmd -DLINUX -fPIC -shared \
|
||||
${EXTRA_CFLAG} -z noexecstack \
|
||||
-o ${TESTSRC}${FS}libTestJNI.so \
|
||||
-I${TESTJAVA}${FS}include \
|
||||
-I${TESTJAVA}${FS}include${FS}linux \
|
||||
|
|
|
|||
|
|
@ -22,7 +22,6 @@
|
|||
*/
|
||||
|
||||
/*
|
||||
* @ignore 8028398
|
||||
* @test
|
||||
* @summary Test that touching noaccess area in class ReservedHeapSpace results in SIGSEGV/ACCESS_VIOLATION
|
||||
* @library /testlibrary /testlibrary/whitebox
|
||||
|
|
|
|||
73
hotspot/test/serviceability/dcmd/DcmdUtil.java
Normal file
73
hotspot/test/serviceability/dcmd/DcmdUtil.java
Normal 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
67
hotspot/test/serviceability/dcmd/DynLibDcmdTest.java
Normal 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 + "'");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue