8057777: Cleanup of old and unused VM interfaces
Reviewed-by: coleenp, hseigel, alanb, sherman
This commit is contained in:
parent
db57351f43
commit
94af790733
hotspot
make
aix/makefiles
bsd/makefiles
linux/makefiles
solaris/makefiles
windows/makefiles
src
os
share
tools/ProjectCreator
vm
@ -32,23 +32,12 @@ SUNWprivate_1.1 {
|
||||
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;
|
||||
@ -72,7 +61,6 @@ SUNWprivate_1.1 {
|
||||
JVM_DefineClassWithSource;
|
||||
JVM_DefineClassWithSourceCond;
|
||||
JVM_DesiredAssertionStatus;
|
||||
JVM_DisableCompiler;
|
||||
JVM_DoPrivileged;
|
||||
JVM_DTraceGetVersion;
|
||||
JVM_DTraceActivate;
|
||||
@ -81,8 +69,6 @@ SUNWprivate_1.1 {
|
||||
JVM_DTraceDispose;
|
||||
JVM_DumpAllStacks;
|
||||
JVM_DumpThreads;
|
||||
JVM_EnableCompiler;
|
||||
JVM_Exit;
|
||||
JVM_FillInStackTrace;
|
||||
JVM_FindClassFromClass;
|
||||
JVM_FindClassFromClassLoader;
|
||||
@ -127,16 +113,11 @@ SUNWprivate_1.1 {
|
||||
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;
|
||||
@ -149,29 +130,22 @@ SUNWprivate_1.1 {
|
||||
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_GetTemporaryDirectory;
|
||||
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;
|
||||
@ -179,18 +153,13 @@ SUNWprivate_1.1 {
|
||||
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;
|
||||
@ -201,46 +170,27 @@ SUNWprivate_1.1 {
|
||||
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_SetProtectionDomain;
|
||||
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;
|
||||
|
||||
|
@ -32,23 +32,12 @@ SUNWprivate_1.1 {
|
||||
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;
|
||||
@ -72,7 +61,6 @@ SUNWprivate_1.1 {
|
||||
JVM_DefineClassWithSource;
|
||||
JVM_DefineClassWithSourceCond;
|
||||
JVM_DesiredAssertionStatus;
|
||||
JVM_DisableCompiler;
|
||||
JVM_DoPrivileged;
|
||||
JVM_DTraceGetVersion;
|
||||
JVM_DTraceActivate;
|
||||
@ -81,8 +69,6 @@ SUNWprivate_1.1 {
|
||||
JVM_DTraceDispose;
|
||||
JVM_DumpAllStacks;
|
||||
JVM_DumpThreads;
|
||||
JVM_EnableCompiler;
|
||||
JVM_Exit;
|
||||
JVM_FillInStackTrace;
|
||||
JVM_FindClassFromClass;
|
||||
JVM_FindClassFromClassLoader;
|
||||
@ -127,15 +113,10 @@ SUNWprivate_1.1 {
|
||||
JVM_GetDeclaredClasses;
|
||||
JVM_GetDeclaringClass;
|
||||
JVM_GetEnclosingMethodInfo;
|
||||
JVM_GetFieldAnnotations;
|
||||
JVM_GetFieldIxModifiers;
|
||||
JVM_GetHostName;
|
||||
JVM_GetInheritedAccessControlContext;
|
||||
JVM_GetInterfaceVersion;
|
||||
JVM_GetLastErrorString;
|
||||
JVM_GetManagement;
|
||||
JVM_GetMethodAnnotations;
|
||||
JVM_GetMethodDefaultAnnotationValue;
|
||||
JVM_GetMethodIxArgsSize;
|
||||
JVM_GetMethodIxByteCode;
|
||||
JVM_GetMethodIxByteCodeLength;
|
||||
@ -148,28 +129,21 @@ SUNWprivate_1.1 {
|
||||
JVM_GetMethodIxModifiers;
|
||||
JVM_GetMethodIxNameUTF;
|
||||
JVM_GetMethodIxSignatureUTF;
|
||||
JVM_GetMethodParameterAnnotations;
|
||||
JVM_GetMethodParameters;
|
||||
JVM_GetPrimitiveArrayElement;
|
||||
JVM_GetProtectionDomain;
|
||||
JVM_GetSockName;
|
||||
JVM_GetSockOpt;
|
||||
JVM_GetStackAccessControlContext;
|
||||
JVM_GetStackTraceDepth;
|
||||
JVM_GetStackTraceElement;
|
||||
JVM_GetSystemPackage;
|
||||
JVM_GetSystemPackages;
|
||||
JVM_GetTemporaryDirectory;
|
||||
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;
|
||||
@ -177,18 +151,13 @@ SUNWprivate_1.1 {
|
||||
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;
|
||||
@ -199,46 +168,27 @@ SUNWprivate_1.1 {
|
||||
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_SetProtectionDomain;
|
||||
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;
|
||||
|
||||
|
@ -30,23 +30,12 @@
|
||||
_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
|
||||
@ -70,7 +59,6 @@
|
||||
_JVM_DefineClassWithSource
|
||||
_JVM_DefineClassWithSourceCond
|
||||
_JVM_DesiredAssertionStatus
|
||||
_JVM_DisableCompiler
|
||||
_JVM_DoPrivileged
|
||||
_JVM_DTraceGetVersion
|
||||
_JVM_DTraceActivate
|
||||
@ -79,8 +67,6 @@
|
||||
_JVM_DTraceDispose
|
||||
_JVM_DumpAllStacks
|
||||
_JVM_DumpThreads
|
||||
_JVM_EnableCompiler
|
||||
_JVM_Exit
|
||||
_JVM_FillInStackTrace
|
||||
_JVM_FindClassFromClass
|
||||
_JVM_FindClassFromClassLoader
|
||||
@ -125,16 +111,11 @@
|
||||
_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
|
||||
@ -147,29 +128,22 @@
|
||||
_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_GetTemporaryDirectory
|
||||
_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
|
||||
@ -177,18 +151,13 @@
|
||||
_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
|
||||
@ -199,45 +168,26 @@
|
||||
_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
|
||||
|
||||
|
@ -30,23 +30,12 @@
|
||||
_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
|
||||
@ -70,7 +59,6 @@
|
||||
_JVM_DefineClassWithSource
|
||||
_JVM_DefineClassWithSourceCond
|
||||
_JVM_DesiredAssertionStatus
|
||||
_JVM_DisableCompiler
|
||||
_JVM_DoPrivileged
|
||||
_JVM_DTraceGetVersion
|
||||
_JVM_DTraceActivate
|
||||
@ -79,8 +67,6 @@
|
||||
_JVM_DTraceDispose
|
||||
_JVM_DumpAllStacks
|
||||
_JVM_DumpThreads
|
||||
_JVM_EnableCompiler
|
||||
_JVM_Exit
|
||||
_JVM_FillInStackTrace
|
||||
_JVM_FindClassFromClass
|
||||
_JVM_FindClassFromClassLoader
|
||||
@ -125,16 +111,11 @@
|
||||
_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
|
||||
@ -147,29 +128,22 @@
|
||||
_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_GetTemporaryDirectory
|
||||
_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
|
||||
@ -177,18 +151,13 @@
|
||||
_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
|
||||
@ -199,45 +168,26 @@
|
||||
_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
|
||||
|
||||
|
@ -32,23 +32,12 @@ SUNWprivate_1.1 {
|
||||
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;
|
||||
@ -72,7 +61,6 @@ SUNWprivate_1.1 {
|
||||
JVM_DefineClassWithSource;
|
||||
JVM_DefineClassWithSourceCond;
|
||||
JVM_DesiredAssertionStatus;
|
||||
JVM_DisableCompiler;
|
||||
JVM_DoPrivileged;
|
||||
JVM_DTraceGetVersion;
|
||||
JVM_DTraceActivate;
|
||||
@ -81,8 +69,6 @@ SUNWprivate_1.1 {
|
||||
JVM_DTraceDispose;
|
||||
JVM_DumpAllStacks;
|
||||
JVM_DumpThreads;
|
||||
JVM_EnableCompiler;
|
||||
JVM_Exit;
|
||||
JVM_FillInStackTrace;
|
||||
JVM_FindClassFromClass;
|
||||
JVM_FindClassFromClassLoader;
|
||||
@ -127,16 +113,11 @@ SUNWprivate_1.1 {
|
||||
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;
|
||||
@ -149,29 +130,22 @@ SUNWprivate_1.1 {
|
||||
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_GetTemporaryDirectory;
|
||||
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;
|
||||
@ -179,18 +153,13 @@ SUNWprivate_1.1 {
|
||||
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;
|
||||
@ -201,45 +170,26 @@ SUNWprivate_1.1 {
|
||||
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;
|
||||
|
||||
|
@ -32,23 +32,12 @@ SUNWprivate_1.1 {
|
||||
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;
|
||||
@ -72,7 +61,6 @@ SUNWprivate_1.1 {
|
||||
JVM_DefineClassWithSource;
|
||||
JVM_DefineClassWithSourceCond;
|
||||
JVM_DesiredAssertionStatus;
|
||||
JVM_DisableCompiler;
|
||||
JVM_DoPrivileged;
|
||||
JVM_DTraceGetVersion;
|
||||
JVM_DTraceActivate;
|
||||
@ -81,8 +69,6 @@ SUNWprivate_1.1 {
|
||||
JVM_DTraceDispose;
|
||||
JVM_DumpAllStacks;
|
||||
JVM_DumpThreads;
|
||||
JVM_EnableCompiler;
|
||||
JVM_Exit;
|
||||
JVM_FillInStackTrace;
|
||||
JVM_FindClassFromClass;
|
||||
JVM_FindClassFromClassLoader;
|
||||
@ -127,16 +113,11 @@ SUNWprivate_1.1 {
|
||||
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;
|
||||
@ -149,29 +130,22 @@ SUNWprivate_1.1 {
|
||||
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_GetTemporaryDirectory;
|
||||
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;
|
||||
@ -179,18 +153,13 @@ SUNWprivate_1.1 {
|
||||
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;
|
||||
@ -201,45 +170,26 @@ SUNWprivate_1.1 {
|
||||
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;
|
||||
|
||||
|
@ -32,23 +32,12 @@ SUNWprivate_1.1 {
|
||||
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;
|
||||
@ -72,7 +61,6 @@ SUNWprivate_1.1 {
|
||||
JVM_DefineClassWithSource;
|
||||
JVM_DefineClassWithSourceCond;
|
||||
JVM_DesiredAssertionStatus;
|
||||
JVM_DisableCompiler;
|
||||
JVM_DoPrivileged;
|
||||
JVM_DTraceGetVersion;
|
||||
JVM_DTraceActivate;
|
||||
@ -81,8 +69,6 @@ SUNWprivate_1.1 {
|
||||
JVM_DTraceDispose;
|
||||
JVM_DumpAllStacks;
|
||||
JVM_DumpThreads;
|
||||
JVM_EnableCompiler;
|
||||
JVM_Exit;
|
||||
JVM_FillInStackTrace;
|
||||
JVM_FindClassFromClass;
|
||||
JVM_FindClassFromClassLoader;
|
||||
@ -127,16 +113,11 @@ SUNWprivate_1.1 {
|
||||
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;
|
||||
@ -149,29 +130,22 @@ SUNWprivate_1.1 {
|
||||
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_GetTemporaryDirectory;
|
||||
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;
|
||||
@ -179,18 +153,13 @@ SUNWprivate_1.1 {
|
||||
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;
|
||||
@ -201,45 +170,26 @@ SUNWprivate_1.1 {
|
||||
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;
|
||||
|
||||
|
@ -32,23 +32,12 @@ SUNWprivate_1.1 {
|
||||
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;
|
||||
@ -72,7 +61,6 @@ SUNWprivate_1.1 {
|
||||
JVM_DefineClassWithSource;
|
||||
JVM_DefineClassWithSourceCond;
|
||||
JVM_DesiredAssertionStatus;
|
||||
JVM_DisableCompiler;
|
||||
JVM_DoPrivileged;
|
||||
JVM_DTraceGetVersion;
|
||||
JVM_DTraceActivate;
|
||||
@ -81,8 +69,6 @@ SUNWprivate_1.1 {
|
||||
JVM_DTraceDispose;
|
||||
JVM_DumpAllStacks;
|
||||
JVM_DumpThreads;
|
||||
JVM_EnableCompiler;
|
||||
JVM_Exit;
|
||||
JVM_FillInStackTrace;
|
||||
JVM_FindClassFromClass;
|
||||
JVM_FindClassFromClassLoader;
|
||||
@ -127,16 +113,11 @@ SUNWprivate_1.1 {
|
||||
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;
|
||||
@ -149,29 +130,22 @@ SUNWprivate_1.1 {
|
||||
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_GetTemporaryDirectory;
|
||||
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;
|
||||
@ -179,18 +153,13 @@ SUNWprivate_1.1 {
|
||||
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;
|
||||
@ -201,45 +170,26 @@ SUNWprivate_1.1 {
|
||||
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;
|
||||
|
||||
|
@ -32,23 +32,12 @@ SUNWprivate_1.1 {
|
||||
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;
|
||||
@ -72,7 +61,6 @@ SUNWprivate_1.1 {
|
||||
JVM_DefineClassWithSource;
|
||||
JVM_DefineClassWithSourceCond;
|
||||
JVM_DesiredAssertionStatus;
|
||||
JVM_DisableCompiler;
|
||||
JVM_DoPrivileged;
|
||||
JVM_DTraceGetVersion;
|
||||
JVM_DTraceActivate;
|
||||
@ -81,8 +69,6 @@ SUNWprivate_1.1 {
|
||||
JVM_DTraceDispose;
|
||||
JVM_DumpAllStacks;
|
||||
JVM_DumpThreads;
|
||||
JVM_EnableCompiler;
|
||||
JVM_Exit;
|
||||
JVM_FillInStackTrace;
|
||||
JVM_FindClassFromClass;
|
||||
JVM_FindClassFromClassLoader;
|
||||
@ -127,16 +113,11 @@ SUNWprivate_1.1 {
|
||||
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;
|
||||
@ -149,29 +130,22 @@ SUNWprivate_1.1 {
|
||||
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_GetTemporaryDirectory;
|
||||
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;
|
||||
@ -179,18 +153,13 @@ SUNWprivate_1.1 {
|
||||
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;
|
||||
@ -201,45 +170,26 @@ SUNWprivate_1.1 {
|
||||
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_solaris_signal;
|
||||
|
||||
|
@ -101,8 +101,6 @@ LD_FLAGS=$(LD_FLAGS) $(STACK_SIZE) /subsystem:windows /dll /base:0x8000000 \
|
||||
/export:jio_vsnprintf \
|
||||
$(AGCT_EXPORT) \
|
||||
/export:JVM_GetVersionInfo \
|
||||
/export:JVM_GetThreadStateNames \
|
||||
/export:JVM_GetThreadStateValues \
|
||||
/export:JVM_InitAgentProperties
|
||||
|
||||
CXX_INCLUDE_DIRS=/I "..\generated"
|
||||
|
@ -4025,14 +4025,6 @@ bool os::dir_is_empty(const char* path) {
|
||||
// This code originates from JDK's sysOpen and open64_w
|
||||
// from src/solaris/hpi/src/system_md.c
|
||||
|
||||
#ifndef O_DELETE
|
||||
#define O_DELETE 0x10000
|
||||
#endif
|
||||
|
||||
// Open a file. Unlink the file immediately after open returns
|
||||
// if the specified oflag has the O_DELETE flag set.
|
||||
// O_DELETE is used only in j2se/src/share/native/java/util/zip/ZipFile.c
|
||||
|
||||
int os::open(const char *path, int oflag, int mode) {
|
||||
|
||||
if (strlen(path) > MAX_PATH - 1) {
|
||||
@ -4040,8 +4032,6 @@ int os::open(const char *path, int oflag, int mode) {
|
||||
return -1;
|
||||
}
|
||||
int fd;
|
||||
int o_delete = (oflag & O_DELETE);
|
||||
oflag = oflag & ~O_DELETE;
|
||||
|
||||
fd = ::open64(path, oflag, mode);
|
||||
if (fd == -1) return -1;
|
||||
@ -4092,9 +4082,6 @@ int os::open(const char *path, int oflag, int mode) {
|
||||
}
|
||||
#endif
|
||||
|
||||
if (o_delete != 0) {
|
||||
::unlink(path);
|
||||
}
|
||||
return fd;
|
||||
}
|
||||
|
||||
|
@ -3845,22 +3845,12 @@ bool os::dir_is_empty(const char* path) {
|
||||
// This code originates from JDK's sysOpen and open64_w
|
||||
// from src/solaris/hpi/src/system_md.c
|
||||
|
||||
#ifndef O_DELETE
|
||||
#define O_DELETE 0x10000
|
||||
#endif
|
||||
|
||||
// Open a file. Unlink the file immediately after open returns
|
||||
// if the specified oflag has the O_DELETE flag set.
|
||||
// O_DELETE is used only in j2se/src/share/native/java/util/zip/ZipFile.c
|
||||
|
||||
int os::open(const char *path, int oflag, int mode) {
|
||||
if (strlen(path) > MAX_PATH - 1) {
|
||||
errno = ENAMETOOLONG;
|
||||
return -1;
|
||||
}
|
||||
int fd;
|
||||
int o_delete = (oflag & O_DELETE);
|
||||
oflag = oflag & ~O_DELETE;
|
||||
|
||||
fd = ::open(path, oflag, mode);
|
||||
if (fd == -1) return -1;
|
||||
@ -3913,9 +3903,6 @@ int os::open(const char *path, int oflag, int mode) {
|
||||
}
|
||||
#endif
|
||||
|
||||
if (o_delete != 0) {
|
||||
::unlink(path);
|
||||
}
|
||||
return fd;
|
||||
}
|
||||
|
||||
|
@ -5086,22 +5086,12 @@ bool os::dir_is_empty(const char* path) {
|
||||
// This code originates from JDK's sysOpen and open64_w
|
||||
// from src/solaris/hpi/src/system_md.c
|
||||
|
||||
#ifndef O_DELETE
|
||||
#define O_DELETE 0x10000
|
||||
#endif
|
||||
|
||||
// Open a file. Unlink the file immediately after open returns
|
||||
// if the specified oflag has the O_DELETE flag set.
|
||||
// O_DELETE is used only in j2se/src/share/native/java/util/zip/ZipFile.c
|
||||
|
||||
int os::open(const char *path, int oflag, int mode) {
|
||||
if (strlen(path) > MAX_PATH - 1) {
|
||||
errno = ENAMETOOLONG;
|
||||
return -1;
|
||||
}
|
||||
int fd;
|
||||
int o_delete = (oflag & O_DELETE);
|
||||
oflag = oflag & ~O_DELETE;
|
||||
|
||||
fd = ::open64(path, oflag, mode);
|
||||
if (fd == -1) return -1;
|
||||
@ -5154,9 +5144,6 @@ int os::open(const char *path, int oflag, int mode) {
|
||||
}
|
||||
#endif
|
||||
|
||||
if (o_delete != 0) {
|
||||
::unlink(path);
|
||||
}
|
||||
return fd;
|
||||
}
|
||||
|
||||
|
@ -4807,22 +4807,12 @@ bool os::dir_is_empty(const char* path) {
|
||||
// This code originates from JDK's sysOpen and open64_w
|
||||
// from src/solaris/hpi/src/system_md.c
|
||||
|
||||
#ifndef O_DELETE
|
||||
#define O_DELETE 0x10000
|
||||
#endif
|
||||
|
||||
// Open a file. Unlink the file immediately after open returns
|
||||
// if the specified oflag has the O_DELETE flag set.
|
||||
// O_DELETE is used only in j2se/src/share/native/java/util/zip/ZipFile.c
|
||||
|
||||
int os::open(const char *path, int oflag, int mode) {
|
||||
if (strlen(path) > MAX_PATH - 1) {
|
||||
errno = ENAMETOOLONG;
|
||||
return -1;
|
||||
}
|
||||
int fd;
|
||||
int o_delete = (oflag & O_DELETE);
|
||||
oflag = oflag & ~O_DELETE;
|
||||
|
||||
fd = ::open64(path, oflag, mode);
|
||||
if (fd == -1) return -1;
|
||||
@ -4918,9 +4908,6 @@ int os::open(const char *path, int oflag, int mode) {
|
||||
}
|
||||
#endif
|
||||
|
||||
if (o_delete != 0) {
|
||||
::unlink(path);
|
||||
}
|
||||
return fd;
|
||||
}
|
||||
|
||||
|
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 1998, 2012, Oracle and/or its affiliates. All rights reserved.
|
||||
* Copyright (c) 1998, 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
|
||||
@ -116,7 +116,6 @@ JVM_GetThreadInterruptEvent();
|
||||
#define JVM_O_O_APPEND O_APPEND
|
||||
#define JVM_O_EXCL O_EXCL
|
||||
#define JVM_O_CREAT O_CREAT
|
||||
#define JVM_O_DELETE O_TEMPORARY
|
||||
|
||||
/* Signals */
|
||||
|
||||
|
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 2011, 2013, Oracle and/or its affiliates. All rights reserved.
|
||||
* Copyright (c) 2011, 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
|
||||
@ -410,8 +410,6 @@ class CompilerInterfaceVC10 extends CompilerInterface {
|
||||
"/export:jio_fprintf /export:jio_vfprintf "+
|
||||
"/export:jio_vsnprintf "+
|
||||
"/export:JVM_GetVersionInfo "+
|
||||
"/export:JVM_GetThreadStateNames "+
|
||||
"/export:JVM_GetThreadStateValues "+
|
||||
"/export:JVM_InitAgentProperties");
|
||||
addAttr(rv, "AdditionalDependencies", "kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;Wsock32.lib;winmm.lib;psapi.lib");
|
||||
addAttr(rv, "OutputFile", outDll);
|
||||
|
@ -415,27 +415,12 @@ JVM_END
|
||||
|
||||
extern volatile jint vm_created;
|
||||
|
||||
JVM_ENTRY_NO_ENV(void, JVM_Exit(jint code))
|
||||
if (vm_created != 0 && (code == 0)) {
|
||||
// The VM is about to exit. We call back into Java to check whether finalizers should be run
|
||||
Universe::run_finalizers_on_exit();
|
||||
}
|
||||
before_exit(thread);
|
||||
vm_exit(code);
|
||||
JVM_END
|
||||
|
||||
|
||||
JVM_ENTRY_NO_ENV(void, JVM_Halt(jint code))
|
||||
before_exit(thread);
|
||||
vm_exit(code);
|
||||
JVM_END
|
||||
|
||||
|
||||
JVM_LEAF(void, JVM_OnExit(void (*func)(void)))
|
||||
register_on_exit_function(func);
|
||||
JVM_END
|
||||
|
||||
|
||||
JVM_ENTRY_NO_ENV(void, JVM_GC(void))
|
||||
JVMWrapper("JVM_GC");
|
||||
if (!DisableExplicitGC) {
|
||||
@ -450,15 +435,6 @@ JVM_LEAF(jlong, JVM_MaxObjectInspectionAge(void))
|
||||
JVM_END
|
||||
|
||||
|
||||
JVM_LEAF(void, JVM_TraceInstructions(jboolean on))
|
||||
if (PrintJVMWarnings) warning("JVM_TraceInstructions not supported");
|
||||
JVM_END
|
||||
|
||||
|
||||
JVM_LEAF(void, JVM_TraceMethodCalls(jboolean on))
|
||||
if (PrintJVMWarnings) warning("JVM_TraceMethodCalls not supported");
|
||||
JVM_END
|
||||
|
||||
static inline jlong convert_size_t_to_jlong(size_t val) {
|
||||
// In the 64-bit vm, a size_t can overflow a jlong (which is signed).
|
||||
NOT_LP64 (return (jlong)val;)
|
||||
@ -628,60 +604,6 @@ JVM_ENTRY(jobject, JVM_Clone(JNIEnv* env, jobject handle))
|
||||
return JNIHandles::make_local(env, oop(new_obj));
|
||||
JVM_END
|
||||
|
||||
// java.lang.Compiler ////////////////////////////////////////////////////
|
||||
|
||||
// The initial cuts of the HotSpot VM will not support JITs, and all existing
|
||||
// JITs would need extensive changes to work with HotSpot. The JIT-related JVM
|
||||
// functions are all silently ignored unless JVM warnings are printed.
|
||||
|
||||
JVM_LEAF(void, JVM_InitializeCompiler (JNIEnv *env, jclass compCls))
|
||||
if (PrintJVMWarnings) warning("JVM_InitializeCompiler not supported");
|
||||
JVM_END
|
||||
|
||||
|
||||
JVM_LEAF(jboolean, JVM_IsSilentCompiler(JNIEnv *env, jclass compCls))
|
||||
if (PrintJVMWarnings) warning("JVM_IsSilentCompiler not supported");
|
||||
return JNI_FALSE;
|
||||
JVM_END
|
||||
|
||||
|
||||
JVM_LEAF(jboolean, JVM_CompileClass(JNIEnv *env, jclass compCls, jclass cls))
|
||||
if (PrintJVMWarnings) warning("JVM_CompileClass not supported");
|
||||
return JNI_FALSE;
|
||||
JVM_END
|
||||
|
||||
|
||||
JVM_LEAF(jboolean, JVM_CompileClasses(JNIEnv *env, jclass cls, jstring jname))
|
||||
if (PrintJVMWarnings) warning("JVM_CompileClasses not supported");
|
||||
return JNI_FALSE;
|
||||
JVM_END
|
||||
|
||||
|
||||
JVM_LEAF(jobject, JVM_CompilerCommand(JNIEnv *env, jclass compCls, jobject arg))
|
||||
if (PrintJVMWarnings) warning("JVM_CompilerCommand not supported");
|
||||
return NULL;
|
||||
JVM_END
|
||||
|
||||
|
||||
JVM_LEAF(void, JVM_EnableCompiler(JNIEnv *env, jclass compCls))
|
||||
if (PrintJVMWarnings) warning("JVM_EnableCompiler not supported");
|
||||
JVM_END
|
||||
|
||||
|
||||
JVM_LEAF(void, JVM_DisableCompiler(JNIEnv *env, jclass compCls))
|
||||
if (PrintJVMWarnings) warning("JVM_DisableCompiler not supported");
|
||||
JVM_END
|
||||
|
||||
|
||||
|
||||
// Error message support //////////////////////////////////////////////////////
|
||||
|
||||
JVM_LEAF(jint, JVM_GetLastErrorString(char *buf, int len))
|
||||
JVMWrapper("JVM_GetLastErrorString");
|
||||
return (jint)os::lasterror(buf, len);
|
||||
JVM_END
|
||||
|
||||
|
||||
// java.io.File ///////////////////////////////////////////////////////////////
|
||||
|
||||
JVM_LEAF(char*, JVM_NativePath(char* path))
|
||||
@ -757,12 +679,6 @@ JVM_ENTRY(jclass, JVM_FindPrimitiveClass(JNIEnv* env, const char* utf))
|
||||
JVM_END
|
||||
|
||||
|
||||
JVM_ENTRY(void, JVM_ResolveClass(JNIEnv* env, jclass cls))
|
||||
JVMWrapper("JVM_ResolveClass");
|
||||
if (PrintJVMWarnings) warning("JVM_ResolveClass not implemented");
|
||||
JVM_END
|
||||
|
||||
|
||||
// Returns a class loaded by the bootstrap class loader; or null
|
||||
// if not found. ClassNotFoundException is not thrown.
|
||||
//
|
||||
@ -1614,21 +1530,6 @@ static bool jvm_get_field_common(jobject field, fieldDescriptor& fd, TRAPS) {
|
||||
return true;
|
||||
}
|
||||
|
||||
JVM_ENTRY(jbyteArray, JVM_GetFieldAnnotations(JNIEnv *env, jobject field))
|
||||
// field is a handle to a java.lang.reflect.Field object
|
||||
assert(field != NULL, "illegal field");
|
||||
JVMWrapper("JVM_GetFieldAnnotations");
|
||||
|
||||
fieldDescriptor fd;
|
||||
bool gotFd = jvm_get_field_common(field, fd, CHECK_NULL);
|
||||
if (!gotFd) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return (jbyteArray) JNIHandles::make_local(env, Annotations::make_java_array(fd.annotations(), THREAD));
|
||||
JVM_END
|
||||
|
||||
|
||||
static Method* jvm_get_method_common(jobject method) {
|
||||
// some of this code was adapted from from jni_FromReflectedMethod
|
||||
|
||||
@ -1652,48 +1553,6 @@ static Method* jvm_get_method_common(jobject method) {
|
||||
return m; // caller has to deal with NULL in product mode
|
||||
}
|
||||
|
||||
|
||||
JVM_ENTRY(jbyteArray, JVM_GetMethodAnnotations(JNIEnv *env, jobject method))
|
||||
JVMWrapper("JVM_GetMethodAnnotations");
|
||||
|
||||
// method is a handle to a java.lang.reflect.Method object
|
||||
Method* m = jvm_get_method_common(method);
|
||||
if (m == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return (jbyteArray) JNIHandles::make_local(env,
|
||||
Annotations::make_java_array(m->annotations(), THREAD));
|
||||
JVM_END
|
||||
|
||||
|
||||
JVM_ENTRY(jbyteArray, JVM_GetMethodDefaultAnnotationValue(JNIEnv *env, jobject method))
|
||||
JVMWrapper("JVM_GetMethodDefaultAnnotationValue");
|
||||
|
||||
// method is a handle to a java.lang.reflect.Method object
|
||||
Method* m = jvm_get_method_common(method);
|
||||
if (m == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return (jbyteArray) JNIHandles::make_local(env,
|
||||
Annotations::make_java_array(m->annotation_default(), THREAD));
|
||||
JVM_END
|
||||
|
||||
|
||||
JVM_ENTRY(jbyteArray, JVM_GetMethodParameterAnnotations(JNIEnv *env, jobject method))
|
||||
JVMWrapper("JVM_GetMethodParameterAnnotations");
|
||||
|
||||
// method is a handle to a java.lang.reflect.Method object
|
||||
Method* m = jvm_get_method_common(method);
|
||||
if (m == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return (jbyteArray) JNIHandles::make_local(env,
|
||||
Annotations::make_java_array(m->parameter_annotations(), THREAD));
|
||||
JVM_END
|
||||
|
||||
/* Type use annotations support (JDK 1.8) */
|
||||
|
||||
JVM_ENTRY(jbyteArray, JVM_GetClassTypeAnnotations(JNIEnv *env, jclass cls))
|
||||
@ -2680,77 +2539,6 @@ JVM_ENTRY(jboolean, JVM_IsSameClassPackage(JNIEnv *env, jclass class1, jclass cl
|
||||
return (jboolean) Reflection::is_same_class_package(klass1, klass2);
|
||||
JVM_END
|
||||
|
||||
|
||||
// IO functions ////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
JVM_LEAF(jint, JVM_Open(const char *fname, jint flags, jint mode))
|
||||
JVMWrapper2("JVM_Open (%s)", fname);
|
||||
|
||||
//%note jvm_r6
|
||||
int result = os::open(fname, flags, mode);
|
||||
if (result >= 0) {
|
||||
return result;
|
||||
} else {
|
||||
switch(errno) {
|
||||
case EEXIST:
|
||||
return JVM_EEXIST;
|
||||
default:
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
JVM_END
|
||||
|
||||
|
||||
JVM_LEAF(jint, JVM_Close(jint fd))
|
||||
JVMWrapper2("JVM_Close (0x%x)", fd);
|
||||
//%note jvm_r6
|
||||
return os::close(fd);
|
||||
JVM_END
|
||||
|
||||
|
||||
JVM_LEAF(jint, JVM_Read(jint fd, char *buf, jint nbytes))
|
||||
JVMWrapper2("JVM_Read (0x%x)", fd);
|
||||
|
||||
//%note jvm_r6
|
||||
return (jint)os::restartable_read(fd, buf, nbytes);
|
||||
JVM_END
|
||||
|
||||
|
||||
JVM_LEAF(jint, JVM_Write(jint fd, char *buf, jint nbytes))
|
||||
JVMWrapper2("JVM_Write (0x%x)", fd);
|
||||
|
||||
//%note jvm_r6
|
||||
return (jint)os::write(fd, buf, nbytes);
|
||||
JVM_END
|
||||
|
||||
|
||||
JVM_LEAF(jint, JVM_Available(jint fd, jlong *pbytes))
|
||||
JVMWrapper2("JVM_Available (0x%x)", fd);
|
||||
//%note jvm_r6
|
||||
return os::available(fd, pbytes);
|
||||
JVM_END
|
||||
|
||||
|
||||
JVM_LEAF(jlong, JVM_Lseek(jint fd, jlong offset, jint whence))
|
||||
JVMWrapper4("JVM_Lseek (0x%x, " INT64_FORMAT ", %d)", fd, (int64_t) offset, whence);
|
||||
//%note jvm_r6
|
||||
return os::lseek(fd, offset, whence);
|
||||
JVM_END
|
||||
|
||||
|
||||
JVM_LEAF(jint, JVM_SetLength(jint fd, jlong length))
|
||||
JVMWrapper3("JVM_SetLength (0x%x, " INT64_FORMAT ")", fd, (int64_t) length);
|
||||
return os::ftruncate(fd, length);
|
||||
JVM_END
|
||||
|
||||
|
||||
JVM_LEAF(jint, JVM_Sync(jint fd))
|
||||
JVMWrapper2("JVM_Sync (0x%x)", fd);
|
||||
//%note jvm_r6
|
||||
return os::fsync(fd);
|
||||
JVM_END
|
||||
|
||||
|
||||
// Printing support //////////////////////////////////////////////////
|
||||
extern "C" {
|
||||
|
||||
@ -3422,96 +3210,6 @@ bool force_verify_field_access(Klass* current_class, Klass* field_class, AccessF
|
||||
return (!access.is_private() && InstanceKlass::cast(current_class)->is_same_class_package(field_class));
|
||||
}
|
||||
|
||||
|
||||
// JVM_AllocateNewObject and JVM_AllocateNewArray are unused as of 1.4
|
||||
JVM_ENTRY(jobject, JVM_AllocateNewObject(JNIEnv *env, jobject receiver, jclass currClass, jclass initClass))
|
||||
JVMWrapper("JVM_AllocateNewObject");
|
||||
JvmtiVMObjectAllocEventCollector oam;
|
||||
// Receiver is not used
|
||||
oop curr_mirror = JNIHandles::resolve_non_null(currClass);
|
||||
oop init_mirror = JNIHandles::resolve_non_null(initClass);
|
||||
|
||||
// Cannot instantiate primitive types
|
||||
if (java_lang_Class::is_primitive(curr_mirror) || java_lang_Class::is_primitive(init_mirror)) {
|
||||
ResourceMark rm(THREAD);
|
||||
THROW_0(vmSymbols::java_lang_InvalidClassException());
|
||||
}
|
||||
|
||||
// Arrays not allowed here, must use JVM_AllocateNewArray
|
||||
if (java_lang_Class::as_Klass(curr_mirror)->oop_is_array() ||
|
||||
java_lang_Class::as_Klass(init_mirror)->oop_is_array()) {
|
||||
ResourceMark rm(THREAD);
|
||||
THROW_0(vmSymbols::java_lang_InvalidClassException());
|
||||
}
|
||||
|
||||
instanceKlassHandle curr_klass (THREAD, java_lang_Class::as_Klass(curr_mirror));
|
||||
instanceKlassHandle init_klass (THREAD, java_lang_Class::as_Klass(init_mirror));
|
||||
|
||||
assert(curr_klass->is_subclass_of(init_klass()), "just checking");
|
||||
|
||||
// Interfaces, abstract classes, and java.lang.Class classes cannot be instantiated directly.
|
||||
curr_klass->check_valid_for_instantiation(false, CHECK_NULL);
|
||||
|
||||
// Make sure klass is initialized, since we are about to instantiate one of them.
|
||||
curr_klass->initialize(CHECK_NULL);
|
||||
|
||||
methodHandle m (THREAD,
|
||||
init_klass->find_method(vmSymbols::object_initializer_name(),
|
||||
vmSymbols::void_method_signature()));
|
||||
if (m.is_null()) {
|
||||
ResourceMark rm(THREAD);
|
||||
THROW_MSG_0(vmSymbols::java_lang_NoSuchMethodError(),
|
||||
Method::name_and_sig_as_C_string(init_klass(),
|
||||
vmSymbols::object_initializer_name(),
|
||||
vmSymbols::void_method_signature()));
|
||||
}
|
||||
|
||||
if (curr_klass == init_klass && !m->is_public()) {
|
||||
// Calling the constructor for class 'curr_klass'.
|
||||
// Only allow calls to a public no-arg constructor.
|
||||
// This path corresponds to creating an Externalizable object.
|
||||
THROW_0(vmSymbols::java_lang_IllegalAccessException());
|
||||
}
|
||||
|
||||
if (!force_verify_field_access(curr_klass(), init_klass(), m->access_flags(), false)) {
|
||||
// subclass 'curr_klass' does not have access to no-arg constructor of 'initcb'
|
||||
THROW_0(vmSymbols::java_lang_IllegalAccessException());
|
||||
}
|
||||
|
||||
Handle obj = curr_klass->allocate_instance_handle(CHECK_NULL);
|
||||
// Call constructor m. This might call a constructor higher up in the hierachy
|
||||
JavaCalls::call_default_constructor(thread, m, obj, CHECK_NULL);
|
||||
|
||||
return JNIHandles::make_local(obj());
|
||||
JVM_END
|
||||
|
||||
|
||||
JVM_ENTRY(jobject, JVM_AllocateNewArray(JNIEnv *env, jobject obj, jclass currClass, jint length))
|
||||
JVMWrapper("JVM_AllocateNewArray");
|
||||
JvmtiVMObjectAllocEventCollector oam;
|
||||
oop mirror = JNIHandles::resolve_non_null(currClass);
|
||||
|
||||
if (java_lang_Class::is_primitive(mirror)) {
|
||||
THROW_0(vmSymbols::java_lang_InvalidClassException());
|
||||
}
|
||||
Klass* k = java_lang_Class::as_Klass(mirror);
|
||||
oop result;
|
||||
|
||||
if (k->oop_is_typeArray()) {
|
||||
// typeArray
|
||||
result = TypeArrayKlass::cast(k)->allocate(length, CHECK_NULL);
|
||||
} else if (k->oop_is_objArray()) {
|
||||
// objArray
|
||||
ObjArrayKlass* oak = ObjArrayKlass::cast(k);
|
||||
oak->initialize(CHECK_NULL); // make sure class is initialized (matches Classic VM behavior)
|
||||
result = oak->allocate(length, CHECK_NULL);
|
||||
} else {
|
||||
THROW_0(vmSymbols::java_lang_InvalidClassException());
|
||||
}
|
||||
return JNIHandles::make_local(env, result);
|
||||
JVM_END
|
||||
|
||||
|
||||
// Return the first non-null class loader up the execution stack, or null
|
||||
// if only code from the null class loader is on the stack.
|
||||
|
||||
@ -3527,60 +3225,6 @@ JVM_ENTRY(jobject, JVM_LatestUserDefinedLoader(JNIEnv *env))
|
||||
JVM_END
|
||||
|
||||
|
||||
// Load a class relative to the most recent class on the stack with a non-null
|
||||
// classloader.
|
||||
// This function has been deprecated and should not be considered part of the
|
||||
// specified JVM interface.
|
||||
|
||||
JVM_ENTRY(jclass, JVM_LoadClass0(JNIEnv *env, jobject receiver,
|
||||
jclass currClass, jstring currClassName))
|
||||
JVMWrapper("JVM_LoadClass0");
|
||||
// Receiver is not used
|
||||
ResourceMark rm(THREAD);
|
||||
|
||||
// Class name argument is not guaranteed to be in internal format
|
||||
Handle classname (THREAD, JNIHandles::resolve_non_null(currClassName));
|
||||
Handle string = java_lang_String::internalize_classname(classname, CHECK_NULL);
|
||||
|
||||
const char* str = java_lang_String::as_utf8_string(string());
|
||||
|
||||
if (str == NULL || (int)strlen(str) > Symbol::max_length()) {
|
||||
// It's impossible to create this class; the name cannot fit
|
||||
// into the constant pool.
|
||||
THROW_MSG_0(vmSymbols::java_lang_NoClassDefFoundError(), str);
|
||||
}
|
||||
|
||||
TempNewSymbol name = SymbolTable::new_symbol(str, CHECK_NULL);
|
||||
Handle curr_klass (THREAD, JNIHandles::resolve(currClass));
|
||||
// Find the most recent class on the stack with a non-null classloader
|
||||
oop loader = NULL;
|
||||
oop protection_domain = NULL;
|
||||
if (curr_klass.is_null()) {
|
||||
for (vframeStream vfst(thread);
|
||||
!vfst.at_end() && loader == NULL;
|
||||
vfst.next()) {
|
||||
if (!vfst.method()->is_native()) {
|
||||
InstanceKlass* holder = vfst.method()->method_holder();
|
||||
loader = holder->class_loader();
|
||||
protection_domain = holder->protection_domain();
|
||||
}
|
||||
}
|
||||
} else {
|
||||
Klass* curr_klass_oop = java_lang_Class::as_Klass(curr_klass());
|
||||
loader = InstanceKlass::cast(curr_klass_oop)->class_loader();
|
||||
protection_domain = InstanceKlass::cast(curr_klass_oop)->protection_domain();
|
||||
}
|
||||
Handle h_loader(THREAD, loader);
|
||||
Handle h_prot (THREAD, protection_domain);
|
||||
jclass result = find_class_from_class_loader(env, name, true, h_loader, h_prot,
|
||||
false, thread);
|
||||
if (TraceClassResolution && result != NULL) {
|
||||
trace_class_resolution(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(result)));
|
||||
}
|
||||
return result;
|
||||
JVM_END
|
||||
|
||||
|
||||
// Array ///////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
@ -3676,143 +3320,6 @@ JVM_ENTRY(jobject, JVM_NewMultiArray(JNIEnv *env, jclass eltClass, jintArray dim
|
||||
JVM_END
|
||||
|
||||
|
||||
// Networking library support ////////////////////////////////////////////////////////////////////
|
||||
|
||||
JVM_LEAF(jint, JVM_InitializeSocketLibrary())
|
||||
JVMWrapper("JVM_InitializeSocketLibrary");
|
||||
return 0;
|
||||
JVM_END
|
||||
|
||||
|
||||
JVM_LEAF(jint, JVM_Socket(jint domain, jint type, jint protocol))
|
||||
JVMWrapper("JVM_Socket");
|
||||
return os::socket(domain, type, protocol);
|
||||
JVM_END
|
||||
|
||||
|
||||
JVM_LEAF(jint, JVM_SocketClose(jint fd))
|
||||
JVMWrapper2("JVM_SocketClose (0x%x)", fd);
|
||||
//%note jvm_r6
|
||||
return os::socket_close(fd);
|
||||
JVM_END
|
||||
|
||||
|
||||
JVM_LEAF(jint, JVM_SocketShutdown(jint fd, jint howto))
|
||||
JVMWrapper2("JVM_SocketShutdown (0x%x)", fd);
|
||||
//%note jvm_r6
|
||||
return os::socket_shutdown(fd, howto);
|
||||
JVM_END
|
||||
|
||||
|
||||
JVM_LEAF(jint, JVM_Recv(jint fd, char *buf, jint nBytes, jint flags))
|
||||
JVMWrapper2("JVM_Recv (0x%x)", fd);
|
||||
//%note jvm_r6
|
||||
return os::recv(fd, buf, (size_t)nBytes, (uint)flags);
|
||||
JVM_END
|
||||
|
||||
|
||||
JVM_LEAF(jint, JVM_Send(jint fd, char *buf, jint nBytes, jint flags))
|
||||
JVMWrapper2("JVM_Send (0x%x)", fd);
|
||||
//%note jvm_r6
|
||||
return os::send(fd, buf, (size_t)nBytes, (uint)flags);
|
||||
JVM_END
|
||||
|
||||
|
||||
JVM_LEAF(jint, JVM_Timeout(int fd, long timeout))
|
||||
JVMWrapper2("JVM_Timeout (0x%x)", fd);
|
||||
//%note jvm_r6
|
||||
return os::timeout(fd, timeout);
|
||||
JVM_END
|
||||
|
||||
|
||||
JVM_LEAF(jint, JVM_Listen(jint fd, jint count))
|
||||
JVMWrapper2("JVM_Listen (0x%x)", fd);
|
||||
//%note jvm_r6
|
||||
return os::listen(fd, count);
|
||||
JVM_END
|
||||
|
||||
|
||||
JVM_LEAF(jint, JVM_Connect(jint fd, struct sockaddr *him, jint len))
|
||||
JVMWrapper2("JVM_Connect (0x%x)", fd);
|
||||
//%note jvm_r6
|
||||
return os::connect(fd, him, (socklen_t)len);
|
||||
JVM_END
|
||||
|
||||
|
||||
JVM_LEAF(jint, JVM_Bind(jint fd, struct sockaddr *him, jint len))
|
||||
JVMWrapper2("JVM_Bind (0x%x)", fd);
|
||||
//%note jvm_r6
|
||||
return os::bind(fd, him, (socklen_t)len);
|
||||
JVM_END
|
||||
|
||||
|
||||
JVM_LEAF(jint, JVM_Accept(jint fd, struct sockaddr *him, jint *len))
|
||||
JVMWrapper2("JVM_Accept (0x%x)", fd);
|
||||
//%note jvm_r6
|
||||
socklen_t socklen = (socklen_t)(*len);
|
||||
jint result = os::accept(fd, him, &socklen);
|
||||
*len = (jint)socklen;
|
||||
return result;
|
||||
JVM_END
|
||||
|
||||
|
||||
JVM_LEAF(jint, JVM_RecvFrom(jint fd, char *buf, int nBytes, int flags, struct sockaddr *from, int *fromlen))
|
||||
JVMWrapper2("JVM_RecvFrom (0x%x)", fd);
|
||||
//%note jvm_r6
|
||||
socklen_t socklen = (socklen_t)(*fromlen);
|
||||
jint result = os::recvfrom(fd, buf, (size_t)nBytes, (uint)flags, from, &socklen);
|
||||
*fromlen = (int)socklen;
|
||||
return result;
|
||||
JVM_END
|
||||
|
||||
|
||||
JVM_LEAF(jint, JVM_GetSockName(jint fd, struct sockaddr *him, int *len))
|
||||
JVMWrapper2("JVM_GetSockName (0x%x)", fd);
|
||||
//%note jvm_r6
|
||||
socklen_t socklen = (socklen_t)(*len);
|
||||
jint result = os::get_sock_name(fd, him, &socklen);
|
||||
*len = (int)socklen;
|
||||
return result;
|
||||
JVM_END
|
||||
|
||||
|
||||
JVM_LEAF(jint, JVM_SendTo(jint fd, char *buf, int len, int flags, struct sockaddr *to, int tolen))
|
||||
JVMWrapper2("JVM_SendTo (0x%x)", fd);
|
||||
//%note jvm_r6
|
||||
return os::sendto(fd, buf, (size_t)len, (uint)flags, to, (socklen_t)tolen);
|
||||
JVM_END
|
||||
|
||||
|
||||
JVM_LEAF(jint, JVM_SocketAvailable(jint fd, jint *pbytes))
|
||||
JVMWrapper2("JVM_SocketAvailable (0x%x)", fd);
|
||||
//%note jvm_r6
|
||||
return os::socket_available(fd, pbytes);
|
||||
JVM_END
|
||||
|
||||
|
||||
JVM_LEAF(jint, JVM_GetSockOpt(jint fd, int level, int optname, char *optval, int *optlen))
|
||||
JVMWrapper2("JVM_GetSockOpt (0x%x)", fd);
|
||||
//%note jvm_r6
|
||||
socklen_t socklen = (socklen_t)(*optlen);
|
||||
jint result = os::get_sock_opt(fd, level, optname, optval, &socklen);
|
||||
*optlen = (int)socklen;
|
||||
return result;
|
||||
JVM_END
|
||||
|
||||
|
||||
JVM_LEAF(jint, JVM_SetSockOpt(jint fd, int level, int optname, const char *optval, int optlen))
|
||||
JVMWrapper2("JVM_GetSockOpt (0x%x)", fd);
|
||||
//%note jvm_r6
|
||||
return os::set_sock_opt(fd, level, optname, optval, (socklen_t)optlen);
|
||||
JVM_END
|
||||
|
||||
|
||||
JVM_LEAF(int, JVM_GetHostName(char* name, int namelen))
|
||||
JVMWrapper("JVM_GetHostName");
|
||||
return os::get_host_name(name, namelen);
|
||||
JVM_END
|
||||
|
||||
|
||||
// Library support ///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
JVM_ENTRY_NO_ENV(void*, JVM_LoadLibrary(const char* name))
|
||||
@ -3854,14 +3361,6 @@ JVM_LEAF(void*, JVM_FindLibraryEntry(void* handle, const char* name))
|
||||
JVM_END
|
||||
|
||||
|
||||
// Floating point support ////////////////////////////////////////////////////////////////////
|
||||
|
||||
JVM_LEAF(jboolean, JVM_IsNaN(jdouble a))
|
||||
JVMWrapper("JVM_IsNaN");
|
||||
return g_isnan(a);
|
||||
JVM_END
|
||||
|
||||
|
||||
// JNI version ///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
JVM_LEAF(jboolean, JVM_IsSupportedJNIVersion(jint version))
|
||||
@ -3982,20 +3481,6 @@ JVM_LEAF(jboolean, JVM_SupportsCX8())
|
||||
return VM_Version::supports_cx8();
|
||||
JVM_END
|
||||
|
||||
|
||||
JVM_ENTRY(jboolean, JVM_CX8Field(JNIEnv *env, jobject obj, jfieldID fid, jlong oldVal, jlong newVal))
|
||||
JVMWrapper("JVM_CX8Field");
|
||||
jlong res;
|
||||
oop o = JNIHandles::resolve(obj);
|
||||
intptr_t fldOffs = jfieldIDWorkaround::from_instance_jfieldID(o->klass(), fid);
|
||||
volatile jlong* addr = (volatile jlong*)((address)o + fldOffs);
|
||||
|
||||
assert(VM_Version::supports_cx8(), "cx8 not supported");
|
||||
res = Atomic::cmpxchg(newVal, addr, oldVal);
|
||||
|
||||
return res == oldVal;
|
||||
JVM_END
|
||||
|
||||
// DTrace ///////////////////////////////////////////////////////////////////
|
||||
|
||||
JVM_ENTRY(jint, JVM_DTraceGetVersion(JNIEnv* env))
|
||||
@ -4150,189 +3635,6 @@ JVM_ENTRY(jobjectArray, JVM_GetEnclosingMethodInfo(JNIEnv *env, jclass ofClass))
|
||||
}
|
||||
JVM_END
|
||||
|
||||
JVM_ENTRY(jintArray, JVM_GetThreadStateValues(JNIEnv* env,
|
||||
jint javaThreadState))
|
||||
{
|
||||
// If new thread states are added in future JDK and VM versions,
|
||||
// this should check if the JDK version is compatible with thread
|
||||
// states supported by the VM. Return NULL if not compatible.
|
||||
//
|
||||
// This function must map the VM java_lang_Thread::ThreadStatus
|
||||
// to the Java thread state that the JDK supports.
|
||||
//
|
||||
|
||||
typeArrayHandle values_h;
|
||||
switch (javaThreadState) {
|
||||
case JAVA_THREAD_STATE_NEW : {
|
||||
typeArrayOop r = oopFactory::new_typeArray(T_INT, 1, CHECK_NULL);
|
||||
values_h = typeArrayHandle(THREAD, r);
|
||||
values_h->int_at_put(0, java_lang_Thread::NEW);
|
||||
break;
|
||||
}
|
||||
case JAVA_THREAD_STATE_RUNNABLE : {
|
||||
typeArrayOop r = oopFactory::new_typeArray(T_INT, 1, CHECK_NULL);
|
||||
values_h = typeArrayHandle(THREAD, r);
|
||||
values_h->int_at_put(0, java_lang_Thread::RUNNABLE);
|
||||
break;
|
||||
}
|
||||
case JAVA_THREAD_STATE_BLOCKED : {
|
||||
typeArrayOop r = oopFactory::new_typeArray(T_INT, 1, CHECK_NULL);
|
||||
values_h = typeArrayHandle(THREAD, r);
|
||||
values_h->int_at_put(0, java_lang_Thread::BLOCKED_ON_MONITOR_ENTER);
|
||||
break;
|
||||
}
|
||||
case JAVA_THREAD_STATE_WAITING : {
|
||||
typeArrayOop r = oopFactory::new_typeArray(T_INT, 2, CHECK_NULL);
|
||||
values_h = typeArrayHandle(THREAD, r);
|
||||
values_h->int_at_put(0, java_lang_Thread::IN_OBJECT_WAIT);
|
||||
values_h->int_at_put(1, java_lang_Thread::PARKED);
|
||||
break;
|
||||
}
|
||||
case JAVA_THREAD_STATE_TIMED_WAITING : {
|
||||
typeArrayOop r = oopFactory::new_typeArray(T_INT, 3, CHECK_NULL);
|
||||
values_h = typeArrayHandle(THREAD, r);
|
||||
values_h->int_at_put(0, java_lang_Thread::SLEEPING);
|
||||
values_h->int_at_put(1, java_lang_Thread::IN_OBJECT_WAIT_TIMED);
|
||||
values_h->int_at_put(2, java_lang_Thread::PARKED_TIMED);
|
||||
break;
|
||||
}
|
||||
case JAVA_THREAD_STATE_TERMINATED : {
|
||||
typeArrayOop r = oopFactory::new_typeArray(T_INT, 1, CHECK_NULL);
|
||||
values_h = typeArrayHandle(THREAD, r);
|
||||
values_h->int_at_put(0, java_lang_Thread::TERMINATED);
|
||||
break;
|
||||
}
|
||||
default:
|
||||
// Unknown state - probably incompatible JDK version
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return (jintArray) JNIHandles::make_local(env, values_h());
|
||||
}
|
||||
JVM_END
|
||||
|
||||
|
||||
JVM_ENTRY(jobjectArray, JVM_GetThreadStateNames(JNIEnv* env,
|
||||
jint javaThreadState,
|
||||
jintArray values))
|
||||
{
|
||||
// If new thread states are added in future JDK and VM versions,
|
||||
// this should check if the JDK version is compatible with thread
|
||||
// states supported by the VM. Return NULL if not compatible.
|
||||
//
|
||||
// This function must map the VM java_lang_Thread::ThreadStatus
|
||||
// to the Java thread state that the JDK supports.
|
||||
//
|
||||
|
||||
ResourceMark rm;
|
||||
|
||||
// Check if threads is null
|
||||
if (values == NULL) {
|
||||
THROW_(vmSymbols::java_lang_NullPointerException(), 0);
|
||||
}
|
||||
|
||||
typeArrayOop v = typeArrayOop(JNIHandles::resolve_non_null(values));
|
||||
typeArrayHandle values_h(THREAD, v);
|
||||
|
||||
objArrayHandle names_h;
|
||||
switch (javaThreadState) {
|
||||
case JAVA_THREAD_STATE_NEW : {
|
||||
assert(values_h->length() == 1 &&
|
||||
values_h->int_at(0) == java_lang_Thread::NEW,
|
||||
"Invalid threadStatus value");
|
||||
|
||||
objArrayOop r = oopFactory::new_objArray(SystemDictionary::String_klass(),
|
||||
1, /* only 1 substate */
|
||||
CHECK_NULL);
|
||||
names_h = objArrayHandle(THREAD, r);
|
||||
Handle name = java_lang_String::create_from_str("NEW", CHECK_NULL);
|
||||
names_h->obj_at_put(0, name());
|
||||
break;
|
||||
}
|
||||
case JAVA_THREAD_STATE_RUNNABLE : {
|
||||
assert(values_h->length() == 1 &&
|
||||
values_h->int_at(0) == java_lang_Thread::RUNNABLE,
|
||||
"Invalid threadStatus value");
|
||||
|
||||
objArrayOop r = oopFactory::new_objArray(SystemDictionary::String_klass(),
|
||||
1, /* only 1 substate */
|
||||
CHECK_NULL);
|
||||
names_h = objArrayHandle(THREAD, r);
|
||||
Handle name = java_lang_String::create_from_str("RUNNABLE", CHECK_NULL);
|
||||
names_h->obj_at_put(0, name());
|
||||
break;
|
||||
}
|
||||
case JAVA_THREAD_STATE_BLOCKED : {
|
||||
assert(values_h->length() == 1 &&
|
||||
values_h->int_at(0) == java_lang_Thread::BLOCKED_ON_MONITOR_ENTER,
|
||||
"Invalid threadStatus value");
|
||||
|
||||
objArrayOop r = oopFactory::new_objArray(SystemDictionary::String_klass(),
|
||||
1, /* only 1 substate */
|
||||
CHECK_NULL);
|
||||
names_h = objArrayHandle(THREAD, r);
|
||||
Handle name = java_lang_String::create_from_str("BLOCKED", CHECK_NULL);
|
||||
names_h->obj_at_put(0, name());
|
||||
break;
|
||||
}
|
||||
case JAVA_THREAD_STATE_WAITING : {
|
||||
assert(values_h->length() == 2 &&
|
||||
values_h->int_at(0) == java_lang_Thread::IN_OBJECT_WAIT &&
|
||||
values_h->int_at(1) == java_lang_Thread::PARKED,
|
||||
"Invalid threadStatus value");
|
||||
objArrayOop r = oopFactory::new_objArray(SystemDictionary::String_klass(),
|
||||
2, /* number of substates */
|
||||
CHECK_NULL);
|
||||
names_h = objArrayHandle(THREAD, r);
|
||||
Handle name0 = java_lang_String::create_from_str("WAITING.OBJECT_WAIT",
|
||||
CHECK_NULL);
|
||||
Handle name1 = java_lang_String::create_from_str("WAITING.PARKED",
|
||||
CHECK_NULL);
|
||||
names_h->obj_at_put(0, name0());
|
||||
names_h->obj_at_put(1, name1());
|
||||
break;
|
||||
}
|
||||
case JAVA_THREAD_STATE_TIMED_WAITING : {
|
||||
assert(values_h->length() == 3 &&
|
||||
values_h->int_at(0) == java_lang_Thread::SLEEPING &&
|
||||
values_h->int_at(1) == java_lang_Thread::IN_OBJECT_WAIT_TIMED &&
|
||||
values_h->int_at(2) == java_lang_Thread::PARKED_TIMED,
|
||||
"Invalid threadStatus value");
|
||||
objArrayOop r = oopFactory::new_objArray(SystemDictionary::String_klass(),
|
||||
3, /* number of substates */
|
||||
CHECK_NULL);
|
||||
names_h = objArrayHandle(THREAD, r);
|
||||
Handle name0 = java_lang_String::create_from_str("TIMED_WAITING.SLEEPING",
|
||||
CHECK_NULL);
|
||||
Handle name1 = java_lang_String::create_from_str("TIMED_WAITING.OBJECT_WAIT",
|
||||
CHECK_NULL);
|
||||
Handle name2 = java_lang_String::create_from_str("TIMED_WAITING.PARKED",
|
||||
CHECK_NULL);
|
||||
names_h->obj_at_put(0, name0());
|
||||
names_h->obj_at_put(1, name1());
|
||||
names_h->obj_at_put(2, name2());
|
||||
break;
|
||||
}
|
||||
case JAVA_THREAD_STATE_TERMINATED : {
|
||||
assert(values_h->length() == 1 &&
|
||||
values_h->int_at(0) == java_lang_Thread::TERMINATED,
|
||||
"Invalid threadStatus value");
|
||||
objArrayOop r = oopFactory::new_objArray(SystemDictionary::String_klass(),
|
||||
1, /* only 1 substate */
|
||||
CHECK_NULL);
|
||||
names_h = objArrayHandle(THREAD, r);
|
||||
Handle name = java_lang_String::create_from_str("TERMINATED", CHECK_NULL);
|
||||
names_h->obj_at_put(0, name());
|
||||
break;
|
||||
}
|
||||
default:
|
||||
// Unknown state - probably incompatible JDK version
|
||||
return NULL;
|
||||
}
|
||||
return (jobjectArray) JNIHandles::make_local(env, names_h());
|
||||
}
|
||||
JVM_END
|
||||
|
||||
JVM_ENTRY(void, JVM_GetVersionInfo(JNIEnv* env, jvm_version_info* info, size_t info_size))
|
||||
{
|
||||
memset(info, 0, info_size);
|
||||
|
@ -138,18 +138,6 @@ JVM_ArrayCopy(JNIEnv *env, jclass ignored, jobject src, jint src_pos,
|
||||
JNIEXPORT jobject JNICALL
|
||||
JVM_InitProperties(JNIEnv *env, jobject p);
|
||||
|
||||
/*
|
||||
* java.io.File
|
||||
*/
|
||||
JNIEXPORT void JNICALL
|
||||
JVM_OnExit(void (*func)(void));
|
||||
|
||||
/*
|
||||
* java.lang.Runtime
|
||||
*/
|
||||
JNIEXPORT void JNICALL
|
||||
JVM_Exit(jint code);
|
||||
|
||||
JNIEXPORT void JNICALL
|
||||
JVM_Halt(jint code);
|
||||
|
||||
@ -173,12 +161,6 @@ JVM_GC(void);
|
||||
JNIEXPORT jlong JNICALL
|
||||
JVM_MaxObjectInspectionAge(void);
|
||||
|
||||
JNIEXPORT void JNICALL
|
||||
JVM_TraceInstructions(jboolean on);
|
||||
|
||||
JNIEXPORT void JNICALL
|
||||
JVM_TraceMethodCalls(jboolean on);
|
||||
|
||||
JNIEXPORT jlong JNICALL
|
||||
JVM_TotalMemory(void);
|
||||
|
||||
@ -203,12 +185,6 @@ JVM_FindLibraryEntry(void *handle, const char *name);
|
||||
JNIEXPORT jboolean JNICALL
|
||||
JVM_IsSupportedJNIVersion(jint version);
|
||||
|
||||
/*
|
||||
* java.lang.Float and java.lang.Double
|
||||
*/
|
||||
JNIEXPORT jboolean JNICALL
|
||||
JVM_IsNaN(jdouble d);
|
||||
|
||||
/*
|
||||
* java.lang.Throwable
|
||||
*/
|
||||
@ -221,30 +197,6 @@ JVM_GetStackTraceDepth(JNIEnv *env, jobject throwable);
|
||||
JNIEXPORT jobject JNICALL
|
||||
JVM_GetStackTraceElement(JNIEnv *env, jobject throwable, jint index);
|
||||
|
||||
/*
|
||||
* java.lang.Compiler
|
||||
*/
|
||||
JNIEXPORT void JNICALL
|
||||
JVM_InitializeCompiler (JNIEnv *env, jclass compCls);
|
||||
|
||||
JNIEXPORT jboolean JNICALL
|
||||
JVM_IsSilentCompiler(JNIEnv *env, jclass compCls);
|
||||
|
||||
JNIEXPORT jboolean JNICALL
|
||||
JVM_CompileClass(JNIEnv *env, jclass compCls, jclass cls);
|
||||
|
||||
JNIEXPORT jboolean JNICALL
|
||||
JVM_CompileClasses(JNIEnv *env, jclass cls, jstring jname);
|
||||
|
||||
JNIEXPORT jobject JNICALL
|
||||
JVM_CompilerCommand(JNIEnv *env, jclass compCls, jobject arg);
|
||||
|
||||
JNIEXPORT void JNICALL
|
||||
JVM_EnableCompiler(JNIEnv *env, jclass compCls);
|
||||
|
||||
JNIEXPORT void JNICALL
|
||||
JVM_DisableCompiler(JNIEnv *env, jclass compCls);
|
||||
|
||||
/*
|
||||
* java.lang.Thread
|
||||
*/
|
||||
@ -331,24 +283,8 @@ JVM_GetSystemPackages(JNIEnv *env);
|
||||
* java.io.ObjectInputStream
|
||||
*/
|
||||
JNIEXPORT jobject JNICALL
|
||||
JVM_AllocateNewObject(JNIEnv *env, jobject obj, jclass currClass,
|
||||
jclass initClass);
|
||||
|
||||
JNIEXPORT jobject JNICALL
|
||||
JVM_AllocateNewArray(JNIEnv *env, jobject obj, jclass currClass,
|
||||
jint length);
|
||||
|
||||
JNIEXPORT jobject JNICALL
|
||||
JVM_LatestUserDefinedLoader(JNIEnv *env);
|
||||
|
||||
/*
|
||||
* This function has been deprecated and should not be considered
|
||||
* part of the specified JVM interface.
|
||||
*/
|
||||
JNIEXPORT jclass JNICALL
|
||||
JVM_LoadClass0(JNIEnv *env, jobject obj, jclass currClass,
|
||||
jstring currClassName);
|
||||
|
||||
/*
|
||||
* java.lang.reflect.Array
|
||||
*/
|
||||
@ -398,12 +334,6 @@ JVM_GetCallerClass(JNIEnv *env, int n);
|
||||
JNIEXPORT jclass JNICALL
|
||||
JVM_FindPrimitiveClass(JNIEnv *env, const char *utf);
|
||||
|
||||
/*
|
||||
* Link the class
|
||||
*/
|
||||
JNIEXPORT void JNICALL
|
||||
JVM_ResolveClass(JNIEnv *env, jclass cls);
|
||||
|
||||
/*
|
||||
* Find a class from a given class loader. Throw ClassNotFoundException
|
||||
* or NoClassDefFoundError depending on the value of the last
|
||||
@ -499,22 +429,6 @@ JVM_GetClassAnnotations(JNIEnv *env, jclass cls);
|
||||
|
||||
/* Annotations support (JDK 1.6) */
|
||||
|
||||
// field is a handle to a java.lang.reflect.Field object
|
||||
JNIEXPORT jbyteArray JNICALL
|
||||
JVM_GetFieldAnnotations(JNIEnv *env, jobject field);
|
||||
|
||||
// method is a handle to a java.lang.reflect.Method object
|
||||
JNIEXPORT jbyteArray JNICALL
|
||||
JVM_GetMethodAnnotations(JNIEnv *env, jobject method);
|
||||
|
||||
// method is a handle to a java.lang.reflect.Method object
|
||||
JNIEXPORT jbyteArray JNICALL
|
||||
JVM_GetMethodDefaultAnnotationValue(JNIEnv *env, jobject method);
|
||||
|
||||
// method is a handle to a java.lang.reflect.Method object
|
||||
JNIEXPORT jbyteArray JNICALL
|
||||
JVM_GetMethodParameterAnnotations(JNIEnv *env, jobject method);
|
||||
|
||||
/* Type use annotations support (JDK 1.8) */
|
||||
|
||||
JNIEXPORT jbyteArray JNICALL
|
||||
@ -647,9 +561,6 @@ JVM_AssertionStatusDirectives(JNIEnv *env, jclass unused);
|
||||
JNIEXPORT jboolean JNICALL
|
||||
JVM_SupportsCX8(void);
|
||||
|
||||
JNIEXPORT jboolean JNICALL
|
||||
JVM_CX8Field(JNIEnv *env, jobject obj, jfieldID fldID, jlong oldVal, jlong newVal);
|
||||
|
||||
/*
|
||||
* com.sun.dtrace.jsdt support
|
||||
*/
|
||||
@ -1230,43 +1141,6 @@ typedef int (*canonicalize_fn_t)(JNIEnv *env, char *orig, char *out, int len);
|
||||
PART 3: I/O and Network Support
|
||||
************************************************************************/
|
||||
|
||||
/* Note that the JVM IO functions are expected to return JVM_IO_ERR
|
||||
* when there is any kind of error. The caller can then use the
|
||||
* platform specific support (e.g., errno) to get the detailed
|
||||
* error info. The JVM_GetLastErrorString procedure may also be used
|
||||
* to obtain a descriptive error string.
|
||||
*/
|
||||
#define JVM_IO_ERR (-1)
|
||||
|
||||
/* For interruptible IO. Returning JVM_IO_INTR indicates that an IO
|
||||
* operation has been disrupted by Thread.interrupt. There are a
|
||||
* number of technical difficulties related to interruptible IO that
|
||||
* need to be solved. For example, most existing programs do not handle
|
||||
* InterruptedIOExceptions specially, they simply treat those as any
|
||||
* IOExceptions, which typically indicate fatal errors.
|
||||
*
|
||||
* There are also two modes of operation for interruptible IO. In the
|
||||
* resumption mode, an interrupted IO operation is guaranteed not to
|
||||
* have any side-effects, and can be restarted. In the termination mode,
|
||||
* an interrupted IO operation corrupts the underlying IO stream, so
|
||||
* that the only reasonable operation on an interrupted stream is to
|
||||
* close that stream. The resumption mode seems to be impossible to
|
||||
* implement on Win32 and Solaris. Implementing the termination mode is
|
||||
* easier, but it's not clear that's the right semantics.
|
||||
*
|
||||
* Interruptible IO is not supported on Win32.It can be enabled/disabled
|
||||
* using a compile-time flag on Solaris. Third-party JVM ports do not
|
||||
* need to implement interruptible IO.
|
||||
*/
|
||||
#define JVM_IO_INTR (-2)
|
||||
|
||||
/* Write a string into the given buffer, in the platform's local encoding,
|
||||
* that describes the most recent system-level error to occur in this thread.
|
||||
* Return the length of the string or zero if no error occurred.
|
||||
*/
|
||||
JNIEXPORT jint JNICALL
|
||||
JVM_GetLastErrorString(char *buf, int len);
|
||||
|
||||
/*
|
||||
* Convert a pathname into native format. This function does syntactic
|
||||
* cleanup, such as removing redundant separator characters. It modifies
|
||||
@ -1275,150 +1149,6 @@ JVM_GetLastErrorString(char *buf, int len);
|
||||
JNIEXPORT char * JNICALL
|
||||
JVM_NativePath(char *);
|
||||
|
||||
/*
|
||||
* JVM I/O error codes
|
||||
*/
|
||||
#define JVM_EEXIST -100
|
||||
|
||||
/*
|
||||
* Open a file descriptor. This function returns a negative error code
|
||||
* on error, and a non-negative integer that is the file descriptor on
|
||||
* success.
|
||||
*/
|
||||
JNIEXPORT jint JNICALL
|
||||
JVM_Open(const char *fname, jint flags, jint mode);
|
||||
|
||||
/*
|
||||
* Close a file descriptor. This function returns -1 on error, and 0
|
||||
* on success.
|
||||
*
|
||||
* fd the file descriptor to close.
|
||||
*/
|
||||
JNIEXPORT jint JNICALL
|
||||
JVM_Close(jint fd);
|
||||
|
||||
/*
|
||||
* Read data from a file decriptor into a char array.
|
||||
*
|
||||
* fd the file descriptor to read from.
|
||||
* buf the buffer where to put the read data.
|
||||
* nbytes the number of bytes to read.
|
||||
*
|
||||
* This function returns -1 on error, and 0 on success.
|
||||
*/
|
||||
JNIEXPORT jint JNICALL
|
||||
JVM_Read(jint fd, char *buf, jint nbytes);
|
||||
|
||||
/*
|
||||
* Write data from a char array to a file decriptor.
|
||||
*
|
||||
* fd the file descriptor to read from.
|
||||
* buf the buffer from which to fetch the data.
|
||||
* nbytes the number of bytes to write.
|
||||
*
|
||||
* This function returns -1 on error, and 0 on success.
|
||||
*/
|
||||
JNIEXPORT jint JNICALL
|
||||
JVM_Write(jint fd, char *buf, jint nbytes);
|
||||
|
||||
/*
|
||||
* Returns the number of bytes available for reading from a given file
|
||||
* descriptor
|
||||
*/
|
||||
JNIEXPORT jint JNICALL
|
||||
JVM_Available(jint fd, jlong *pbytes);
|
||||
|
||||
/*
|
||||
* Move the file descriptor pointer from whence by offset.
|
||||
*
|
||||
* fd the file descriptor to move.
|
||||
* offset the number of bytes to move it by.
|
||||
* whence the start from where to move it.
|
||||
*
|
||||
* This function returns the resulting pointer location.
|
||||
*/
|
||||
JNIEXPORT jlong JNICALL
|
||||
JVM_Lseek(jint fd, jlong offset, jint whence);
|
||||
|
||||
/*
|
||||
* Set the length of the file associated with the given descriptor to the given
|
||||
* length. If the new length is longer than the current length then the file
|
||||
* is extended; the contents of the extended portion are not defined. The
|
||||
* value of the file pointer is undefined after this procedure returns.
|
||||
*/
|
||||
JNIEXPORT jint JNICALL
|
||||
JVM_SetLength(jint fd, jlong length);
|
||||
|
||||
/*
|
||||
* Synchronize the file descriptor's in memory state with that of the
|
||||
* physical device. Return of -1 is an error, 0 is OK.
|
||||
*/
|
||||
JNIEXPORT jint JNICALL
|
||||
JVM_Sync(jint fd);
|
||||
|
||||
/*
|
||||
* Networking library support
|
||||
*/
|
||||
|
||||
JNIEXPORT jint JNICALL
|
||||
JVM_InitializeSocketLibrary(void);
|
||||
|
||||
struct sockaddr;
|
||||
|
||||
JNIEXPORT jint JNICALL
|
||||
JVM_Socket(jint domain, jint type, jint protocol);
|
||||
|
||||
JNIEXPORT jint JNICALL
|
||||
JVM_SocketClose(jint fd);
|
||||
|
||||
JNIEXPORT jint JNICALL
|
||||
JVM_SocketShutdown(jint fd, jint howto);
|
||||
|
||||
JNIEXPORT jint JNICALL
|
||||
JVM_Recv(jint fd, char *buf, jint nBytes, jint flags);
|
||||
|
||||
JNIEXPORT jint JNICALL
|
||||
JVM_Send(jint fd, char *buf, jint nBytes, jint flags);
|
||||
|
||||
JNIEXPORT jint JNICALL
|
||||
JVM_Timeout(int fd, long timeout);
|
||||
|
||||
JNIEXPORT jint JNICALL
|
||||
JVM_Listen(jint fd, jint count);
|
||||
|
||||
JNIEXPORT jint JNICALL
|
||||
JVM_Connect(jint fd, struct sockaddr *him, jint len);
|
||||
|
||||
JNIEXPORT jint JNICALL
|
||||
JVM_Bind(jint fd, struct sockaddr *him, jint len);
|
||||
|
||||
JNIEXPORT jint JNICALL
|
||||
JVM_Accept(jint fd, struct sockaddr *him, jint *len);
|
||||
|
||||
JNIEXPORT jint JNICALL
|
||||
JVM_RecvFrom(jint fd, char *buf, int nBytes,
|
||||
int flags, struct sockaddr *from, int *fromlen);
|
||||
|
||||
JNIEXPORT jint JNICALL
|
||||
JVM_SendTo(jint fd, char *buf, int len,
|
||||
int flags, struct sockaddr *to, int tolen);
|
||||
|
||||
JNIEXPORT jint JNICALL
|
||||
JVM_SocketAvailable(jint fd, jint *result);
|
||||
|
||||
|
||||
JNIEXPORT jint JNICALL
|
||||
JVM_GetSockName(jint fd, struct sockaddr *him, int *len);
|
||||
|
||||
JNIEXPORT jint JNICALL
|
||||
JVM_GetSockOpt(jint fd, int level, int optname, char *optval, int *optlen);
|
||||
|
||||
JNIEXPORT jint JNICALL
|
||||
JVM_SetSockOpt(jint fd, int level, int optname, const char *optval, int optlen);
|
||||
|
||||
JNIEXPORT int JNICALL
|
||||
JVM_GetHostName(char* name, int namelen);
|
||||
|
||||
/*
|
||||
* The standard printing functions supported by the Java VM. (Should they
|
||||
* be renamed to JVM_* in the future?
|
||||
@ -1496,39 +1226,6 @@ JVM_GetTemporaryDirectory(JNIEnv *env);
|
||||
JNIEXPORT jobjectArray JNICALL
|
||||
JVM_GetEnclosingMethodInfo(JNIEnv* env, jclass ofClass);
|
||||
|
||||
/*
|
||||
* Java thread state support
|
||||
*/
|
||||
enum {
|
||||
JAVA_THREAD_STATE_NEW = 0,
|
||||
JAVA_THREAD_STATE_RUNNABLE = 1,
|
||||
JAVA_THREAD_STATE_BLOCKED = 2,
|
||||
JAVA_THREAD_STATE_WAITING = 3,
|
||||
JAVA_THREAD_STATE_TIMED_WAITING = 4,
|
||||
JAVA_THREAD_STATE_TERMINATED = 5,
|
||||
JAVA_THREAD_STATE_COUNT = 6
|
||||
};
|
||||
|
||||
/*
|
||||
* Returns an array of the threadStatus values representing the
|
||||
* given Java thread state. Returns NULL if the VM version is
|
||||
* incompatible with the JDK or doesn't support the given
|
||||
* Java thread state.
|
||||
*/
|
||||
JNIEXPORT jintArray JNICALL
|
||||
JVM_GetThreadStateValues(JNIEnv* env, jint javaThreadState);
|
||||
|
||||
/*
|
||||
* Returns an array of the substate names representing the
|
||||
* given Java thread state. Returns NULL if the VM version is
|
||||
* incompatible with the JDK or the VM doesn't support
|
||||
* the given Java thread state.
|
||||
* values must be the jintArray returned from JVM_GetThreadStateValues
|
||||
* and javaThreadState.
|
||||
*/
|
||||
JNIEXPORT jobjectArray JNICALL
|
||||
JVM_GetThreadStateNames(JNIEnv* env, jint javaThreadState, jintArray values);
|
||||
|
||||
/* =========================================================================
|
||||
* The following defines a private JVM interface that the JDK can query
|
||||
* for the JVM version and capabilities. sun.misc.Version defines
|
||||
|
@ -387,46 +387,6 @@ void print_statistics() {
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
// Helper class for registering on_exit calls through JVM_OnExit
|
||||
|
||||
extern "C" {
|
||||
typedef void (*__exit_proc)(void);
|
||||
}
|
||||
|
||||
class ExitProc : public CHeapObj<mtInternal> {
|
||||
private:
|
||||
__exit_proc _proc;
|
||||
// void (*_proc)(void);
|
||||
ExitProc* _next;
|
||||
public:
|
||||
// ExitProc(void (*proc)(void)) {
|
||||
ExitProc(__exit_proc proc) {
|
||||
_proc = proc;
|
||||
_next = NULL;
|
||||
}
|
||||
void evaluate() { _proc(); }
|
||||
ExitProc* next() const { return _next; }
|
||||
void set_next(ExitProc* next) { _next = next; }
|
||||
};
|
||||
|
||||
|
||||
// Linked list of registered on_exit procedures
|
||||
|
||||
static ExitProc* exit_procs = NULL;
|
||||
|
||||
|
||||
extern "C" {
|
||||
void register_on_exit_function(void (*func)(void)) {
|
||||
ExitProc *entry = new ExitProc(func);
|
||||
// Classic vm does not throw an exception in case the allocation failed,
|
||||
if (entry != NULL) {
|
||||
entry->set_next(exit_procs);
|
||||
exit_procs = entry;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Note: before_exit() can be executed only once, if more than one threads
|
||||
// are trying to shutdown the VM at the same time, only one thread
|
||||
// can run before_exit() and all other threads must wait.
|
||||
@ -457,16 +417,6 @@ void before_exit(JavaThread * thread) {
|
||||
}
|
||||
}
|
||||
|
||||
// The only difference between this and Win32's _onexit procs is that
|
||||
// this version is invoked before any threads get killed.
|
||||
ExitProc* current = exit_procs;
|
||||
while (current != NULL) {
|
||||
ExitProc* next = current->next();
|
||||
current->evaluate();
|
||||
delete current;
|
||||
current = next;
|
||||
}
|
||||
|
||||
// Hang forever on exit if we're reporting an error.
|
||||
if (ShowMessageBoxOnError && is_error_reported()) {
|
||||
os::infinite_sleep();
|
||||
|
@ -27,9 +27,6 @@
|
||||
|
||||
#include "runtime/os.hpp"
|
||||
|
||||
// Register function to be called by before_exit
|
||||
extern "C" { void register_on_exit_function(void (*func)(void)) ;}
|
||||
|
||||
// Execute code before all handles are released and thread is killed; prologue to vm_exit
|
||||
extern void before_exit(JavaThread * thread);
|
||||
|
||||
|
@ -173,22 +173,6 @@ static BasicType runtime_type_from(JavaValue* result) {
|
||||
return T_ILLEGAL;
|
||||
}
|
||||
|
||||
// ===== object constructor calls =====
|
||||
|
||||
void JavaCalls::call_default_constructor(JavaThread* thread, methodHandle method, Handle receiver, TRAPS) {
|
||||
assert(method->name() == vmSymbols::object_initializer_name(), "Should only be called for default constructor");
|
||||
assert(method->signature() == vmSymbols::void_method_signature(), "Should only be called for default constructor");
|
||||
|
||||
InstanceKlass* ik = method->method_holder();
|
||||
if (ik->is_initialized() && ik->has_vanilla_constructor()) {
|
||||
// safe to skip constructor call
|
||||
} else {
|
||||
static JavaValue result(T_VOID);
|
||||
JavaCallArguments args(receiver);
|
||||
call(&result, method, &args, CHECK);
|
||||
}
|
||||
}
|
||||
|
||||
// ============ Virtual calls ============
|
||||
|
||||
void JavaCalls::call_virtual(JavaValue* result, KlassHandle spec_klass, Symbol* name, Symbol* signature, JavaCallArguments* args, TRAPS) {
|
||||
|
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
|
||||
* Copyright (c) 1997, 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
|
||||
@ -183,9 +183,6 @@ class JavaCallArguments : public StackObj {
|
||||
class JavaCalls: AllStatic {
|
||||
static void call_helper(JavaValue* result, methodHandle* method, JavaCallArguments* args, TRAPS);
|
||||
public:
|
||||
// Optimized Constuctor call
|
||||
static void call_default_constructor(JavaThread* thread, methodHandle method, Handle receiver, TRAPS);
|
||||
|
||||
// call_special
|
||||
// ------------
|
||||
// The receiver must be first oop in argument list
|
||||
|
Loading…
x
Reference in New Issue
Block a user