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

Merge

Browse source
This commit is contained in:
Erik Helin 2013-06-28 18:28:17 +02:00
commit f72bcd09ec
49 changed files with 1379 additions and 974 deletions
Download patch file Download diff file Expand all files Collapse all files

4
hotspot/make/bsd/makefiles/build_vm_def.sh
View file

@ -7,6 +7,6 @@ else
NM=nm
fi
$NM --defined-only $* | awk '
{ if ($3 ~ /^_ZTV/ || $3 ~ /^gHotSpotVM/) print "\t" $3 ";" }
$NM -Uj $* | awk '
{ if ($3 ~ /^_ZTV/ || $3 ~ /^gHotSpotVM/) print "\t" $3 }
'

6
hotspot/make/bsd/makefiles/gcc.make
View file

@ -1,5 +1,5 @@
#
# Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved.
# Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
#
# This code is free software; you can redistribute it and/or modify it
@ -368,8 +368,8 @@ ifeq ($(OS_VENDOR), Darwin)
# Standard linker flags
LFLAGS +=
# Darwin doesn't use ELF and doesn't support version scripts
LDNOMAP = true
# The apple linker has its own variant of mapfiles/version-scripts
MAPFLAG = -Xlinker -exported_symbols_list -Xlinker FILENAME
# Use $(SONAMEFLAG:SONAME=soname) to specify the intrinsic name of a shared obj
SONAMEFLAG =

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

@ -1,7 +1,3 @@
#
# @(#)mapfile-vers-debug 1.18 07/10/25 16:47:35
#
#
# Copyright (c) 2002, 2013, Oracle and/or its affiliates. All rights reserved.
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
@ -23,273 +19,244 @@
# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
# or visit www.oracle.com if you need additional information or have any
# questions.
#
#
#
# Only used for OSX/Darwin builds
# Define public interface.
# _JNI
_JNI_CreateJavaVM
_JNI_GetCreatedJavaVMs
_JNI_GetDefaultJavaVMInitArgs
SUNWprivate_1.1 {
global:
# JNI
JNI_CreateJavaVM;
JNI_GetCreatedJavaVMs;
JNI_GetDefaultJavaVMInitArgs;
# _JVM
_JVM_Accept
_JVM_ActiveProcessorCount
_JVM_AllocateNewArray
_JVM_AllocateNewObject
_JVM_ArrayCopy
_JVM_AssertionStatusDirectives
_JVM_Available
_JVM_Bind
_JVM_ClassDepth
_JVM_ClassLoaderDepth
_JVM_Clone
_JVM_Close
_JVM_CX8Field
_JVM_CompileClass
_JVM_CompileClasses
_JVM_CompilerCommand
_JVM_Connect
_JVM_ConstantPoolGetClassAt
_JVM_ConstantPoolGetClassAtIfLoaded
_JVM_ConstantPoolGetDoubleAt
_JVM_ConstantPoolGetFieldAt
_JVM_ConstantPoolGetFieldAtIfLoaded
_JVM_ConstantPoolGetFloatAt
_JVM_ConstantPoolGetIntAt
_JVM_ConstantPoolGetLongAt
_JVM_ConstantPoolGetMethodAt
_JVM_ConstantPoolGetMethodAtIfLoaded
_JVM_ConstantPoolGetMemberRefInfoAt
_JVM_ConstantPoolGetSize
_JVM_ConstantPoolGetStringAt
_JVM_ConstantPoolGetUTF8At
_JVM_CountStackFrames
_JVM_CurrentClassLoader
_JVM_CurrentLoadedClass
_JVM_CurrentThread
_JVM_CurrentTimeMillis
_JVM_DefineClass
_JVM_DefineClassWithSource
_JVM_DefineClassWithSourceCond
_JVM_DesiredAssertionStatus
_JVM_DisableCompiler
_JVM_DoPrivileged
_JVM_DTraceGetVersion
_JVM_DTraceActivate
_JVM_DTraceIsProbeEnabled
_JVM_DTraceIsSupported
_JVM_DTraceDispose
_JVM_DumpAllStacks
_JVM_DumpThreads
_JVM_EnableCompiler
_JVM_Exit
_JVM_FillInStackTrace
_JVM_FindClassFromClass
_JVM_FindClassFromClassLoader
_JVM_FindClassFromBootLoader
_JVM_FindLibraryEntry
_JVM_FindLoadedClass
_JVM_FindPrimitiveClass
_JVM_FindSignal
_JVM_FreeMemory
_JVM_GC
_JVM_GetAllThreads
_JVM_GetArrayElement
_JVM_GetArrayLength
_JVM_GetCPClassNameUTF
_JVM_GetCPFieldClassNameUTF
_JVM_GetCPFieldModifiers
_JVM_GetCPFieldNameUTF
_JVM_GetCPFieldSignatureUTF
_JVM_GetCPMethodClassNameUTF
_JVM_GetCPMethodModifiers
_JVM_GetCPMethodNameUTF
_JVM_GetCPMethodSignatureUTF
_JVM_GetCallerClass
_JVM_GetClassAccessFlags
_JVM_GetClassAnnotations
_JVM_GetClassCPEntriesCount
_JVM_GetClassCPTypes
_JVM_GetClassConstantPool
_JVM_GetClassContext
_JVM_GetClassDeclaredConstructors
_JVM_GetClassDeclaredFields
_JVM_GetClassDeclaredMethods
_JVM_GetClassFieldsCount
_JVM_GetClassInterfaces
_JVM_GetClassLoader
_JVM_GetClassMethodsCount
_JVM_GetClassModifiers
_JVM_GetClassName
_JVM_GetClassNameUTF
_JVM_GetClassSignature
_JVM_GetClassSigners
_JVM_GetClassTypeAnnotations
_JVM_GetComponentType
_JVM_GetDeclaredClasses
_JVM_GetDeclaringClass
_JVM_GetEnclosingMethodInfo
_JVM_GetFieldAnnotations
_JVM_GetFieldIxModifiers
_JVM_GetFieldTypeAnnotations
_JVM_GetHostName
_JVM_GetInheritedAccessControlContext
_JVM_GetInterfaceVersion
_JVM_GetLastErrorString
_JVM_GetManagement
_JVM_GetMethodAnnotations
_JVM_GetMethodDefaultAnnotationValue
_JVM_GetMethodIxArgsSize
_JVM_GetMethodIxByteCode
_JVM_GetMethodIxByteCodeLength
_JVM_GetMethodIxExceptionIndexes
_JVM_GetMethodIxExceptionTableEntry
_JVM_GetMethodIxExceptionTableLength
_JVM_GetMethodIxExceptionsCount
_JVM_GetMethodIxLocalsCount
_JVM_GetMethodIxMaxStack
_JVM_GetMethodIxModifiers
_JVM_GetMethodIxNameUTF
_JVM_GetMethodIxSignatureUTF
_JVM_GetMethodParameterAnnotations
_JVM_GetMethodParameters
_JVM_GetMethodTypeAnnotations
_JVM_GetPrimitiveArrayElement
_JVM_GetProtectionDomain
_JVM_GetSockName
_JVM_GetSockOpt
_JVM_GetStackAccessControlContext
_JVM_GetStackTraceDepth
_JVM_GetStackTraceElement
_JVM_GetSystemPackage
_JVM_GetSystemPackages
_JVM_GetThreadStateNames
_JVM_GetThreadStateValues
_JVM_GetVersionInfo
_JVM_Halt
_JVM_HoldsLock
_JVM_IHashCode
_JVM_InitAgentProperties
_JVM_InitProperties
_JVM_InitializeCompiler
_JVM_InitializeSocketLibrary
_JVM_InternString
_JVM_Interrupt
_JVM_InvokeMethod
_JVM_IsArrayClass
_JVM_IsConstructorIx
_JVM_IsInterface
_JVM_IsInterrupted
_JVM_IsNaN
_JVM_IsPrimitiveClass
_JVM_IsSameClassPackage
_JVM_IsSilentCompiler
_JVM_IsSupportedJNIVersion
_JVM_IsThreadAlive
_JVM_IsVMGeneratedMethodIx
_JVM_LatestUserDefinedLoader
_JVM_Listen
_JVM_LoadClass0
_JVM_LoadLibrary
_JVM_Lseek
_JVM_MaxObjectInspectionAge
_JVM_MaxMemory
_JVM_MonitorNotify
_JVM_MonitorNotifyAll
_JVM_MonitorWait
_JVM_NanoTime
_JVM_NativePath
_JVM_NewArray
_JVM_NewInstanceFromConstructor
_JVM_NewMultiArray
_JVM_OnExit
_JVM_Open
_JVM_RaiseSignal
_JVM_RawMonitorCreate
_JVM_RawMonitorDestroy
_JVM_RawMonitorEnter
_JVM_RawMonitorExit
_JVM_Read
_JVM_Recv
_JVM_RecvFrom
_JVM_RegisterSignal
_JVM_ReleaseUTF
_JVM_ResolveClass
_JVM_ResumeThread
_JVM_Send
_JVM_SendTo
_JVM_SetArrayElement
_JVM_SetClassSigners
_JVM_SetLength
_JVM_SetNativeThreadName
_JVM_SetPrimitiveArrayElement
_JVM_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_bsd_signal
# JVM
JVM_Accept;
JVM_ActiveProcessorCount;
JVM_AllocateNewArray;
JVM_AllocateNewObject;
JVM_ArrayCopy;
JVM_AssertionStatusDirectives;
JVM_Available;
JVM_Bind;
JVM_ClassDepth;
JVM_ClassLoaderDepth;
JVM_Clone;
JVM_Close;
JVM_CX8Field;
JVM_CompileClass;
JVM_CompileClasses;
JVM_CompilerCommand;
JVM_Connect;
JVM_ConstantPoolGetClassAt;
JVM_ConstantPoolGetClassAtIfLoaded;
JVM_ConstantPoolGetDoubleAt;
JVM_ConstantPoolGetFieldAt;
JVM_ConstantPoolGetFieldAtIfLoaded;
JVM_ConstantPoolGetFloatAt;
JVM_ConstantPoolGetIntAt;
JVM_ConstantPoolGetLongAt;
JVM_ConstantPoolGetMethodAt;
JVM_ConstantPoolGetMethodAtIfLoaded;
JVM_ConstantPoolGetMemberRefInfoAt;
JVM_ConstantPoolGetSize;
JVM_ConstantPoolGetStringAt;
JVM_ConstantPoolGetUTF8At;
JVM_CountStackFrames;
JVM_CurrentClassLoader;
JVM_CurrentLoadedClass;
JVM_CurrentThread;
JVM_CurrentTimeMillis;
JVM_DefineClass;
JVM_DefineClassWithSource;
JVM_DefineClassWithSourceCond;
JVM_DesiredAssertionStatus;
JVM_DisableCompiler;
JVM_DoPrivileged;
JVM_DTraceGetVersion;
JVM_DTraceActivate;
JVM_DTraceIsProbeEnabled;
JVM_DTraceIsSupported;
JVM_DTraceDispose;
JVM_DumpAllStacks;
JVM_DumpThreads;
JVM_EnableCompiler;
JVM_Exit;
JVM_FillInStackTrace;
JVM_FindClassFromClass;
JVM_FindClassFromClassLoader;
JVM_FindClassFromBootLoader;
JVM_FindLibraryEntry;
JVM_FindLoadedClass;
JVM_FindPrimitiveClass;
JVM_FindSignal;
JVM_FreeMemory;
JVM_GC;
JVM_GetAllThreads;
JVM_GetArrayElement;
JVM_GetArrayLength;
JVM_GetCPClassNameUTF;
JVM_GetCPFieldClassNameUTF;
JVM_GetCPFieldModifiers;
JVM_GetCPFieldNameUTF;
JVM_GetCPFieldSignatureUTF;
JVM_GetCPMethodClassNameUTF;
JVM_GetCPMethodModifiers;
JVM_GetCPMethodNameUTF;
JVM_GetCPMethodSignatureUTF;
JVM_GetCallerClass;
JVM_GetClassAccessFlags;
JVM_GetClassAnnotations;
JVM_GetClassCPEntriesCount;
JVM_GetClassCPTypes;
JVM_GetClassConstantPool;
JVM_GetClassContext;
JVM_GetClassDeclaredConstructors;
JVM_GetClassDeclaredFields;
JVM_GetClassDeclaredMethods;
JVM_GetClassFieldsCount;
JVM_GetClassInterfaces;
JVM_GetClassLoader;
JVM_GetClassMethodsCount;
JVM_GetClassModifiers;
JVM_GetClassName;
JVM_GetClassNameUTF;
JVM_GetClassSignature;
JVM_GetClassSigners;
JVM_GetClassTypeAnnotations;
JVM_GetComponentType;
JVM_GetDeclaredClasses;
JVM_GetDeclaringClass;
JVM_GetEnclosingMethodInfo;
JVM_GetFieldAnnotations;
JVM_GetFieldIxModifiers;
JVM_GetFieldTypeAnnotations;
JVM_GetHostName;
JVM_GetInheritedAccessControlContext;
JVM_GetInterfaceVersion;
JVM_GetLastErrorString;
JVM_GetManagement;
JVM_GetMethodAnnotations;
JVM_GetMethodDefaultAnnotationValue;
JVM_GetMethodIxArgsSize;
JVM_GetMethodIxByteCode;
JVM_GetMethodIxByteCodeLength;
JVM_GetMethodIxExceptionIndexes;
JVM_GetMethodIxExceptionTableEntry;
JVM_GetMethodIxExceptionTableLength;
JVM_GetMethodIxExceptionsCount;
JVM_GetMethodIxLocalsCount;
JVM_GetMethodIxMaxStack;
JVM_GetMethodIxModifiers;
JVM_GetMethodIxNameUTF;
JVM_GetMethodIxSignatureUTF;
JVM_GetMethodParameterAnnotations;
JVM_GetMethodParameters;
JVM_GetMethodTypeAnnotations;
JVM_GetPrimitiveArrayElement;
JVM_GetProtectionDomain;
JVM_GetSockName;
JVM_GetSockOpt;
JVM_GetStackAccessControlContext;
JVM_GetStackTraceDepth;
JVM_GetStackTraceElement;
JVM_GetSystemPackage;
JVM_GetSystemPackages;
JVM_GetThreadStateNames;
JVM_GetThreadStateValues;
JVM_GetVersionInfo;
JVM_Halt;
JVM_HoldsLock;
JVM_IHashCode;
JVM_InitAgentProperties;
JVM_InitProperties;
JVM_InitializeCompiler;
JVM_InitializeSocketLibrary;
JVM_InternString;
JVM_Interrupt;
JVM_InvokeMethod;
JVM_IsArrayClass;
JVM_IsConstructorIx;
JVM_IsInterface;
JVM_IsInterrupted;
JVM_IsNaN;
JVM_IsPrimitiveClass;
JVM_IsSameClassPackage;
JVM_IsSilentCompiler;
JVM_IsSupportedJNIVersion;
JVM_IsThreadAlive;
JVM_IsVMGeneratedMethodIx;
JVM_LatestUserDefinedLoader;
JVM_Listen;
JVM_LoadClass0;
JVM_LoadLibrary;
JVM_Lseek;
JVM_MaxObjectInspectionAge;
JVM_MaxMemory;
JVM_MonitorNotify;
JVM_MonitorNotifyAll;
JVM_MonitorWait;
JVM_NanoTime;
JVM_NativePath;
JVM_NewArray;
JVM_NewInstanceFromConstructor;
JVM_NewMultiArray;
JVM_OnExit;
JVM_Open;
JVM_RaiseSignal;
JVM_RawMonitorCreate;
JVM_RawMonitorDestroy;
JVM_RawMonitorEnter;
JVM_RawMonitorExit;
JVM_Read;
JVM_Recv;
JVM_RecvFrom;
JVM_RegisterSignal;
JVM_ReleaseUTF;
JVM_ResolveClass;
JVM_ResumeThread;
JVM_Send;
JVM_SendTo;
JVM_SetArrayElement;
JVM_SetClassSigners;
JVM_SetLength;
JVM_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_bsd_signal;
# Old reflection routines
# These do not need to be present in the product build in JDK 1.4
# but their code has not been removed yet because there will not
# be a substantial code savings until JVM_InvokeMethod and
# JVM_NewInstanceFromConstructor can also be removed; see
# reflectionCompat.hpp.
JVM_GetClassConstructor;
JVM_GetClassConstructors;
JVM_GetClassField;
JVM_GetClassFields;
JVM_GetClassMethod;
JVM_GetClassMethods;
JVM_GetField;
JVM_GetPrimitiveField;
JVM_NewInstance;
JVM_SetField;
JVM_SetPrimitiveField;
# debug JVM
JVM_AccessVMBooleanFlag;
JVM_AccessVMIntFlag;
JVM_VMBreakPoint;
# debug _JVM
_JVM_AccessVMBooleanFlag
_JVM_AccessVMIntFlag
_JVM_VMBreakPoint
# miscellaneous functions
jio_fprintf;
jio_printf;
jio_snprintf;
jio_vfprintf;
jio_vsnprintf;
fork1;
numa_warn;
numa_error;
# Needed because there is no JVM interface for this.
sysThreadAvailableStackWithSlack;
_jio_fprintf
_jio_printf
_jio_snprintf
_jio_vfprintf
_jio_vsnprintf
# This is for Forte Analyzer profiling support.
AsyncGetCallTrace;
_AsyncGetCallTrace
# INSERT VTABLE SYMBOLS HERE
local:
*;
};

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

@ -1,7 +1,3 @@
#
# @(#)mapfile-vers-product 1.19 08/02/12 10:56:37
#
#
# Copyright (c) 2002, 2013, Oracle and/or its affiliates. All rights reserved.
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
@ -23,268 +19,239 @@
# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
# or visit www.oracle.com if you need additional information or have any
# questions.
#
#
#
# Only used for OSX/Darwin builds
# Define public interface.
# _JNI
_JNI_CreateJavaVM
_JNI_GetCreatedJavaVMs
_JNI_GetDefaultJavaVMInitArgs
SUNWprivate_1.1 {
global:
# JNI
JNI_CreateJavaVM;
JNI_GetCreatedJavaVMs;
JNI_GetDefaultJavaVMInitArgs;
# JVM
JVM_Accept;
JVM_ActiveProcessorCount;
JVM_AllocateNewArray;
JVM_AllocateNewObject;
JVM_ArrayCopy;
JVM_AssertionStatusDirectives;
JVM_Available;
JVM_Bind;
JVM_ClassDepth;
JVM_ClassLoaderDepth;
JVM_Clone;
JVM_Close;
JVM_CX8Field;
JVM_CompileClass;
JVM_CompileClasses;
JVM_CompilerCommand;
JVM_Connect;
JVM_ConstantPoolGetClassAt;
JVM_ConstantPoolGetClassAtIfLoaded;
JVM_ConstantPoolGetDoubleAt;
JVM_ConstantPoolGetFieldAt;
JVM_ConstantPoolGetFieldAtIfLoaded;
JVM_ConstantPoolGetFloatAt;
JVM_ConstantPoolGetIntAt;
JVM_ConstantPoolGetLongAt;
JVM_ConstantPoolGetMethodAt;
JVM_ConstantPoolGetMethodAtIfLoaded;
JVM_ConstantPoolGetMemberRefInfoAt;
JVM_ConstantPoolGetSize;
JVM_ConstantPoolGetStringAt;
JVM_ConstantPoolGetUTF8At;
JVM_CountStackFrames;
JVM_CurrentClassLoader;
JVM_CurrentLoadedClass;
JVM_CurrentThread;
JVM_CurrentTimeMillis;
JVM_DefineClass;
JVM_DefineClassWithSource;
JVM_DefineClassWithSourceCond;
JVM_DesiredAssertionStatus;
JVM_DisableCompiler;
JVM_DoPrivileged;
JVM_DTraceGetVersion;
JVM_DTraceActivate;
JVM_DTraceIsProbeEnabled;
JVM_DTraceIsSupported;
JVM_DTraceDispose;
JVM_DumpAllStacks;
JVM_DumpThreads;
JVM_EnableCompiler;
JVM_Exit;
JVM_FillInStackTrace;
JVM_FindClassFromClass;
JVM_FindClassFromClassLoader;
JVM_FindClassFromBootLoader;
JVM_FindLibraryEntry;
JVM_FindLoadedClass;
JVM_FindPrimitiveClass;
JVM_FindSignal;
JVM_FreeMemory;
JVM_GC;
JVM_GetAllThreads;
JVM_GetArrayElement;
JVM_GetArrayLength;
JVM_GetCPClassNameUTF;
JVM_GetCPFieldClassNameUTF;
JVM_GetCPFieldModifiers;
JVM_GetCPFieldNameUTF;
JVM_GetCPFieldSignatureUTF;
JVM_GetCPMethodClassNameUTF;
JVM_GetCPMethodModifiers;
JVM_GetCPMethodNameUTF;
JVM_GetCPMethodSignatureUTF;
JVM_GetCallerClass;
JVM_GetClassAccessFlags;
JVM_GetClassAnnotations;
JVM_GetClassCPEntriesCount;
JVM_GetClassCPTypes;
JVM_GetClassConstantPool;
JVM_GetClassContext;
JVM_GetClassDeclaredConstructors;
JVM_GetClassDeclaredFields;
JVM_GetClassDeclaredMethods;
JVM_GetClassFieldsCount;
JVM_GetClassInterfaces;
JVM_GetClassLoader;
JVM_GetClassMethodsCount;
JVM_GetClassModifiers;
JVM_GetClassName;
JVM_GetClassNameUTF;
JVM_GetClassSignature;
JVM_GetClassSigners;
JVM_GetClassTypeAnnotations;
JVM_GetComponentType;
JVM_GetDeclaredClasses;
JVM_GetDeclaringClass;
JVM_GetEnclosingMethodInfo;
JVM_GetFieldAnnotations;
JVM_GetFieldIxModifiers;
JVM_GetFieldTypeAnnotations;
JVM_GetHostName;
JVM_GetInheritedAccessControlContext;
JVM_GetInterfaceVersion;
JVM_GetLastErrorString;
JVM_GetManagement;
JVM_GetMethodAnnotations;
JVM_GetMethodDefaultAnnotationValue;
JVM_GetMethodIxArgsSize;
JVM_GetMethodIxByteCode;
JVM_GetMethodIxByteCodeLength;
JVM_GetMethodIxExceptionIndexes;
JVM_GetMethodIxExceptionTableEntry;
JVM_GetMethodIxExceptionTableLength;
JVM_GetMethodIxExceptionsCount;
JVM_GetMethodIxLocalsCount;
JVM_GetMethodIxMaxStack;
JVM_GetMethodIxModifiers;
JVM_GetMethodIxNameUTF;
JVM_GetMethodIxSignatureUTF;
JVM_GetMethodParameterAnnotations;
JVM_GetMethodParameters;
JVM_GetMethodTypeAnnotations;
JVM_GetPrimitiveArrayElement;
JVM_GetProtectionDomain;
JVM_GetSockName;
JVM_GetSockOpt;
JVM_GetStackAccessControlContext;
JVM_GetStackTraceDepth;
JVM_GetStackTraceElement;
JVM_GetSystemPackage;
JVM_GetSystemPackages;
JVM_GetThreadStateNames;
JVM_GetThreadStateValues;
JVM_GetVersionInfo;
JVM_Halt;
JVM_HoldsLock;
JVM_IHashCode;
JVM_InitAgentProperties;
JVM_InitProperties;
JVM_InitializeCompiler;
JVM_InitializeSocketLibrary;
JVM_InternString;
JVM_Interrupt;
JVM_InvokeMethod;
JVM_IsArrayClass;
JVM_IsConstructorIx;
JVM_IsInterface;
JVM_IsInterrupted;
JVM_IsNaN;
JVM_IsPrimitiveClass;
JVM_IsSameClassPackage;
JVM_IsSilentCompiler;
JVM_IsSupportedJNIVersion;
JVM_IsThreadAlive;
JVM_IsVMGeneratedMethodIx;
JVM_LatestUserDefinedLoader;
JVM_Listen;
JVM_LoadClass0;
JVM_LoadLibrary;
JVM_Lseek;
JVM_MaxObjectInspectionAge;
JVM_MaxMemory;
JVM_MonitorNotify;
JVM_MonitorNotifyAll;
JVM_MonitorWait;
JVM_NanoTime;
JVM_NativePath;
JVM_NewArray;
JVM_NewInstanceFromConstructor;
JVM_NewMultiArray;
JVM_OnExit;
JVM_Open;
JVM_RaiseSignal;
JVM_RawMonitorCreate;
JVM_RawMonitorDestroy;
JVM_RawMonitorEnter;
JVM_RawMonitorExit;
JVM_Read;
JVM_Recv;
JVM_RecvFrom;
JVM_RegisterSignal;
JVM_ReleaseUTF;
JVM_ResolveClass;
JVM_ResumeThread;
JVM_Send;
JVM_SendTo;
JVM_SetArrayElement;
JVM_SetClassSigners;
JVM_SetLength;
JVM_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_bsd_signal;
# Old reflection routines
# These do not need to be present in the product build in JDK 1.4
# but their code has not been removed yet because there will not
# be a substantial code savings until JVM_InvokeMethod and
# JVM_NewInstanceFromConstructor can also be removed; see
# reflectionCompat.hpp.
JVM_GetClassConstructor;
JVM_GetClassConstructors;
JVM_GetClassField;
JVM_GetClassFields;
JVM_GetClassMethod;
JVM_GetClassMethods;
JVM_GetField;
JVM_GetPrimitiveField;
JVM_NewInstance;
JVM_SetField;
JVM_SetPrimitiveField;
# _JVM
_JVM_Accept
_JVM_ActiveProcessorCount
_JVM_AllocateNewArray
_JVM_AllocateNewObject
_JVM_ArrayCopy
_JVM_AssertionStatusDirectives
_JVM_Available
_JVM_Bind
_JVM_ClassDepth
_JVM_ClassLoaderDepth
_JVM_Clone
_JVM_Close
_JVM_CX8Field
_JVM_CompileClass
_JVM_CompileClasses
_JVM_CompilerCommand
_JVM_Connect
_JVM_ConstantPoolGetClassAt
_JVM_ConstantPoolGetClassAtIfLoaded
_JVM_ConstantPoolGetDoubleAt
_JVM_ConstantPoolGetFieldAt
_JVM_ConstantPoolGetFieldAtIfLoaded
_JVM_ConstantPoolGetFloatAt
_JVM_ConstantPoolGetIntAt
_JVM_ConstantPoolGetLongAt
_JVM_ConstantPoolGetMethodAt
_JVM_ConstantPoolGetMethodAtIfLoaded
_JVM_ConstantPoolGetMemberRefInfoAt
_JVM_ConstantPoolGetSize
_JVM_ConstantPoolGetStringAt
_JVM_ConstantPoolGetUTF8At
_JVM_CountStackFrames
_JVM_CurrentClassLoader
_JVM_CurrentLoadedClass
_JVM_CurrentThread
_JVM_CurrentTimeMillis
_JVM_DefineClass
_JVM_DefineClassWithSource
_JVM_DefineClassWithSourceCond
_JVM_DesiredAssertionStatus
_JVM_DisableCompiler
_JVM_DoPrivileged
_JVM_DTraceGetVersion
_JVM_DTraceActivate
_JVM_DTraceIsProbeEnabled
_JVM_DTraceIsSupported
_JVM_DTraceDispose
_JVM_DumpAllStacks
_JVM_DumpThreads
_JVM_EnableCompiler
_JVM_Exit
_JVM_FillInStackTrace
_JVM_FindClassFromClass
_JVM_FindClassFromClassLoader
_JVM_FindClassFromBootLoader
_JVM_FindLibraryEntry
_JVM_FindLoadedClass
_JVM_FindPrimitiveClass
_JVM_FindSignal
_JVM_FreeMemory
_JVM_GC
_JVM_GetAllThreads
_JVM_GetArrayElement
_JVM_GetArrayLength
_JVM_GetCPClassNameUTF
_JVM_GetCPFieldClassNameUTF
_JVM_GetCPFieldModifiers
_JVM_GetCPFieldNameUTF
_JVM_GetCPFieldSignatureUTF
_JVM_GetCPMethodClassNameUTF
_JVM_GetCPMethodModifiers
_JVM_GetCPMethodNameUTF
_JVM_GetCPMethodSignatureUTF
_JVM_GetCallerClass
_JVM_GetClassAccessFlags
_JVM_GetClassAnnotations
_JVM_GetClassCPEntriesCount
_JVM_GetClassCPTypes
_JVM_GetClassConstantPool
_JVM_GetClassContext
_JVM_GetClassDeclaredConstructors
_JVM_GetClassDeclaredFields
_JVM_GetClassDeclaredMethods
_JVM_GetClassFieldsCount
_JVM_GetClassInterfaces
_JVM_GetClassLoader
_JVM_GetClassMethodsCount
_JVM_GetClassModifiers
_JVM_GetClassName
_JVM_GetClassNameUTF
_JVM_GetClassSignature
_JVM_GetClassSigners
_JVM_GetClassTypeAnnotations
_JVM_GetComponentType
_JVM_GetDeclaredClasses
_JVM_GetDeclaringClass
_JVM_GetEnclosingMethodInfo
_JVM_GetFieldAnnotations
_JVM_GetFieldIxModifiers
_JVM_GetFieldTypeAnnotations
_JVM_GetHostName
_JVM_GetInheritedAccessControlContext
_JVM_GetInterfaceVersion
_JVM_GetLastErrorString
_JVM_GetManagement
_JVM_GetMethodAnnotations
_JVM_GetMethodDefaultAnnotationValue
_JVM_GetMethodIxArgsSize
_JVM_GetMethodIxByteCode
_JVM_GetMethodIxByteCodeLength
_JVM_GetMethodIxExceptionIndexes
_JVM_GetMethodIxExceptionTableEntry
_JVM_GetMethodIxExceptionTableLength
_JVM_GetMethodIxExceptionsCount
_JVM_GetMethodIxLocalsCount
_JVM_GetMethodIxMaxStack
_JVM_GetMethodIxModifiers
_JVM_GetMethodIxNameUTF
_JVM_GetMethodIxSignatureUTF
_JVM_GetMethodParameterAnnotations
_JVM_GetMethodParameters
_JVM_GetMethodTypeAnnotations
_JVM_GetPrimitiveArrayElement
_JVM_GetProtectionDomain
_JVM_GetSockName
_JVM_GetSockOpt
_JVM_GetStackAccessControlContext
_JVM_GetStackTraceDepth
_JVM_GetStackTraceElement
_JVM_GetSystemPackage
_JVM_GetSystemPackages
_JVM_GetThreadStateNames
_JVM_GetThreadStateValues
_JVM_GetVersionInfo
_JVM_Halt
_JVM_HoldsLock
_JVM_IHashCode
_JVM_InitAgentProperties
_JVM_InitProperties
_JVM_InitializeCompiler
_JVM_InitializeSocketLibrary
_JVM_InternString
_JVM_Interrupt
_JVM_InvokeMethod
_JVM_IsArrayClass
_JVM_IsConstructorIx
_JVM_IsInterface
_JVM_IsInterrupted
_JVM_IsNaN
_JVM_IsPrimitiveClass
_JVM_IsSameClassPackage
_JVM_IsSilentCompiler
_JVM_IsSupportedJNIVersion
_JVM_IsThreadAlive
_JVM_IsVMGeneratedMethodIx
_JVM_LatestUserDefinedLoader
_JVM_Listen
_JVM_LoadClass0
_JVM_LoadLibrary
_JVM_Lseek
_JVM_MaxObjectInspectionAge
_JVM_MaxMemory
_JVM_MonitorNotify
_JVM_MonitorNotifyAll
_JVM_MonitorWait
_JVM_NanoTime
_JVM_NativePath
_JVM_NewArray
_JVM_NewInstanceFromConstructor
_JVM_NewMultiArray
_JVM_OnExit
_JVM_Open
_JVM_RaiseSignal
_JVM_RawMonitorCreate
_JVM_RawMonitorDestroy
_JVM_RawMonitorEnter
_JVM_RawMonitorExit
_JVM_Read
_JVM_Recv
_JVM_RecvFrom
_JVM_RegisterSignal
_JVM_ReleaseUTF
_JVM_ResolveClass
_JVM_ResumeThread
_JVM_Send
_JVM_SendTo
_JVM_SetArrayElement
_JVM_SetClassSigners
_JVM_SetLength
_JVM_SetNativeThreadName
_JVM_SetPrimitiveArrayElement
_JVM_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_bsd_signal
# miscellaneous functions
jio_fprintf;
jio_printf;
jio_snprintf;
jio_vfprintf;
jio_vsnprintf;
fork1;
numa_warn;
numa_error;
# Needed because there is no JVM interface for this.
sysThreadAvailableStackWithSlack;
_jio_fprintf
_jio_printf
_jio_snprintf
_jio_vfprintf
_jio_vsnprintf
# This is for Forte Analyzer profiling support.
AsyncGetCallTrace;
_AsyncGetCallTrace
# INSERT VTABLE SYMBOLS HERE
local:
*;
};
# INSERT VTABLE SYMBOLS HERE

2
hotspot/make/excludeSrc.make
View file

@ -112,3 +112,5 @@ ifeq ($(INCLUDE_NMT), false)
endif
-include $(HS_ALT_MAKE)/excludeSrc.make
.PHONY: $(HS_ALT_MAKE)/excludeSrc.make

8
hotspot/make/linux/makefiles/gcc.make
View file

@ -350,9 +350,9 @@ else
ifeq ($(DEBUG_CFLAGS/$(BUILDARCH)),)
ifeq ($(USE_CLANG), true)
# Clang doesn't understand -gstabs
OPT_CFLAGS += -g
DEBUG_CFLAGS += -g
else
OPT_CFLAGS += -gstabs
DEBUG_CFLAGS += -gstabs
endif
endif
@ -365,9 +365,9 @@ else
ifeq ($(FASTDEBUG_CFLAGS/$(BUILDARCH)),)
ifeq ($(USE_CLANG), true)
# Clang doesn't understand -gstabs
OPT_CFLAGS += -g
FASTDEBUG_CFLAGS += -g
else
OPT_CFLAGS += -gstabs
FASTDEBUG_CFLAGS += -gstabs
endif
endif

2
hotspot/src/cpu/sparc/vm/frame_sparc.cpp
View file

@ -680,7 +680,7 @@ bool frame::is_interpreted_frame_valid(JavaThread* thread) const {
// validate ConstantPoolCache*
ConstantPoolCache* cp = *interpreter_frame_cache_addr();
if (cp == NULL || !cp->is_metadata()) return false;
if (cp == NULL || !cp->is_metaspace_object()) return false;
// validate locals

6
hotspot/src/cpu/sparc/vm/macroAssembler_sparc.cpp
View file

@ -1161,12 +1161,6 @@ void MacroAssembler::align(int modulus) {
while (offset() % modulus != 0) nop();
}
void MacroAssembler::safepoint() {
relocate(breakpoint_Relocation::spec(breakpoint_Relocation::safepoint));
}
void RegistersForDebugging::print(outputStream* s) {
FlagSetting fs(Debugging, true);
int j;

30
hotspot/src/cpu/sparc/vm/relocInfo_sparc.cpp
View file

@ -193,36 +193,6 @@ address Relocation::pd_get_address_from_code() {
return *(address*)addr();
}
int Relocation::pd_breakpoint_size() {
// minimum breakpoint size, in short words
return NativeIllegalInstruction::instruction_size / sizeof(short);
}
void Relocation::pd_swap_in_breakpoint(address x, short* instrs, int instrlen) {
Untested("pd_swap_in_breakpoint");
// %%% probably do not need a general instrlen; just use the trap size
if (instrs != NULL) {
assert(instrlen * sizeof(short) == NativeIllegalInstruction::instruction_size, "enough instrlen in reloc. data");
for (int i = 0; i < instrlen; i++) {
instrs[i] = ((short*)x)[i];
}
}
NativeIllegalInstruction::insert(x);
}
void Relocation::pd_swap_out_breakpoint(address x, short* instrs, int instrlen) {
Untested("pd_swap_out_breakpoint");
assert(instrlen * sizeof(short) == sizeof(int), "enough buf");
union { int l; short s[1]; } u;
for (int i = 0; i < instrlen; i++) {
u.s[i] = instrs[i];
}
NativeInstruction* ni = nativeInstruction_at(x);
ni->set_long_at(0, u.l);
}
void poll_Relocation::fix_relocation_after_move(const CodeBuffer* src, CodeBuffer* dest) {
}

2
hotspot/src/cpu/x86/vm/frame_x86.cpp
View file

@ -587,7 +587,7 @@ bool frame::is_interpreted_frame_valid(JavaThread* thread) const {
// validate ConstantPoolCache*
ConstantPoolCache* cp = *interpreter_frame_cache_addr();
if (cp == NULL || !cp->is_metadata()) return false;
if (cp == NULL || !cp->is_metaspace_object()) return false;
// validate locals

24
hotspot/src/cpu/x86/vm/relocInfo_x86.cpp
View file

@ -177,30 +177,6 @@ address Relocation::pd_get_address_from_code() {
return *pd_address_in_code();
}
int Relocation::pd_breakpoint_size() {
// minimum breakpoint size, in short words
return NativeIllegalInstruction::instruction_size / sizeof(short);
}
void Relocation::pd_swap_in_breakpoint(address x, short* instrs, int instrlen) {
Untested("pd_swap_in_breakpoint");
if (instrs != NULL) {
assert(instrlen * sizeof(short) == NativeIllegalInstruction::instruction_size, "enough instrlen in reloc. data");
for (int i = 0; i < instrlen; i++) {
instrs[i] = ((short*)x)[i];
}
}
NativeIllegalInstruction::insert(x);
}
void Relocation::pd_swap_out_breakpoint(address x, short* instrs, int instrlen) {
Untested("pd_swap_out_breakpoint");
assert(NativeIllegalInstruction::instruction_size == sizeof(short), "right address unit for update");
NativeInstruction* ni = nativeInstruction_at(x);
*(short*)ni->addr_at(0) = instrs[0];
}
void poll_Relocation::fix_relocation_after_move(const CodeBuffer* src, CodeBuffer* dest) {
#ifdef _LP64
if (!Assembler::is_polling_page_far()) {

16
hotspot/src/cpu/zero/vm/relocInfo_zero.cpp
View file

@ -52,22 +52,6 @@ address* Relocation::pd_address_in_code() {
return (address *) addr();
}
int Relocation::pd_breakpoint_size() {
ShouldNotCallThis();
}
void Relocation::pd_swap_in_breakpoint(address x,
short* instrs,
int instrlen) {
ShouldNotCallThis();
}
void Relocation::pd_swap_out_breakpoint(address x,
short* instrs,
int instrlen) {
ShouldNotCallThis();
}
void poll_Relocation::fix_relocation_after_move(const CodeBuffer* src,
CodeBuffer* dst) {
ShouldNotCallThis();

10
hotspot/src/os_cpu/linux_x86/vm/os_linux_x86.cpp
View file

@ -289,6 +289,16 @@ JVM_handle_linux_signal(int sig,
}
#endif // AMD64
#ifndef AMD64
// Halt if SI_KERNEL before more crashes get misdiagnosed as Java bugs
// This can happen in any running code (currently more frequently in
// interpreter code but has been seen in compiled code)
if (sig == SIGSEGV && info->si_addr == 0 && info->si_code == SI_KERNEL) {
fatal("An irrecoverable SI_KERNEL SIGSEGV has occurred due "
"to unstable signal handling in this distribution.");
}
#endif // AMD64
// Handle ALL stack overflow variations here
if (sig == SIGSEGV) {
address addr = (address) info->si_addr;

2
hotspot/src/share/vm/ci/ciObjectFactory.cpp
View file

@ -265,8 +265,6 @@ ciObject* ciObjectFactory::get(oop key) {
ciMetadata* ciObjectFactory::get_metadata(Metadata* key) {
ASSERT_IN_VM;
assert(key == NULL || key->is_metadata(), "must be");
#ifdef ASSERT
if (CIObjectFactoryVerify) {
Metadata* last = NULL;

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

@ -555,7 +555,7 @@ void Dictionary::verify() {
loader_data->class_loader() == NULL ||
loader_data->class_loader()->is_instance(),
"checking type of class_loader");
e->verify();
e->verify(/*check_dictionary*/false);
probe->verify_protection_domain_set();
element_count++;
}

2
hotspot/src/share/vm/code/debugInfo.hpp
View file

@ -274,7 +274,7 @@ class DebugInfoReadStream : public CompressedReadStream {
Method* read_method() {
Method* o = (Method*)(code()->metadata_at(read_int()));
assert(o == NULL ||
o->is_metadata(), "meta data only");
o->is_metaspace_object(), "meta data only");
return o;
}
ScopeValue* read_object_value();

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

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

5
hotspot/src/share/vm/code/nmethod.cpp
View file

@ -1081,11 +1081,6 @@ void nmethod::fix_oop_relocations(address begin, address end, bool initialize_im
metadata_Relocation* reloc = iter.metadata_reloc();
reloc->fix_metadata_relocation();
}
// There must not be any interfering patches or breakpoints.
assert(!(iter.type() == relocInfo::breakpoint_type
&& iter.breakpoint_reloc()->active()),
"no active breakpoint");
}
}

145
hotspot/src/share/vm/code/relocInfo.cpp
View file

@ -338,31 +338,6 @@ void RelocIterator::set_limit(address limit) {
_limit = limit;
}
void PatchingRelocIterator:: prepass() {
// turn breakpoints off during patching
_init_state = (*this); // save cursor
while (next()) {
if (type() == relocInfo::breakpoint_type) {
breakpoint_reloc()->set_active(false);
}
}
(RelocIterator&)(*this) = _init_state; // reset cursor for client
}
void PatchingRelocIterator:: postpass() {
// turn breakpoints back on after patching
(RelocIterator&)(*this) = _init_state; // reset cursor again
while (next()) {
if (type() == relocInfo::breakpoint_type) {
breakpoint_Relocation* bpt = breakpoint_reloc();
bpt->set_active(bpt->enabled());
}
}
}
// All the strange bit-encodings are in here.
// The idea is to encode relocation data which are small integers
// very efficiently (a single extra halfword). Larger chunks of
@ -704,51 +679,6 @@ void section_word_Relocation::unpack_data() {
_target = address_from_scaled_offset(offset, base);
}
void breakpoint_Relocation::pack_data_to(CodeSection* dest) {
short* p = (short*) dest->locs_end();
address point = dest->locs_point();
*p++ = _bits;
assert(_target != NULL, "sanity");
if (internal()) normalize_address(_target, dest);
jint target_bits =
(jint)( internal() ? scaled_offset (_target, point)
: runtime_address_to_index(_target) );
if (settable()) {
// save space for set_target later
p = add_jint(p, target_bits);
} else {
p = add_var_int(p, target_bits);
}
for (int i = 0; i < instrlen(); i++) {
// put placeholder words until bytes can be saved
p = add_short(p, (short)0x7777);
}
dest->set_locs_end((relocInfo*) p);
}
void breakpoint_Relocation::unpack_data() {
_bits = live_bits();
int targetlen = datalen() - 1 - instrlen();
jint target_bits = 0;
if (targetlen == 0) target_bits = 0;
else if (targetlen == 1) target_bits = *(data()+1);
else if (targetlen == 2) target_bits = relocInfo::jint_from_data(data()+1);
else { ShouldNotReachHere(); }
_target = internal() ? address_from_scaled_offset(target_bits, addr())
: index_to_runtime_address (target_bits);
}
//// miscellaneous methods
oop* oop_Relocation::oop_addr() {
int n = _oop_index;
@ -933,81 +863,6 @@ address internal_word_Relocation::target() {
return target;
}
breakpoint_Relocation::breakpoint_Relocation(int kind, address target, bool internal) {
bool active = false;
bool enabled = (kind == initialization);
bool removable = (kind != safepoint);
bool settable = (target == NULL);
int bits = kind;
if (enabled) bits |= enabled_state;
if (internal) bits |= internal_attr;
if (removable) bits |= removable_attr;
if (settable) bits |= settable_attr;
_bits = bits | high_bit;
_target = target;
assert(this->kind() == kind, "kind encoded");
assert(this->enabled() == enabled, "enabled encoded");
assert(this->active() == active, "active encoded");
assert(this->internal() == internal, "internal encoded");
assert(this->removable() == removable, "removable encoded");
assert(this->settable() == settable, "settable encoded");
}
address breakpoint_Relocation::target() const {
return _target;
}
void breakpoint_Relocation::set_target(address x) {
assert(settable(), "must be settable");
jint target_bits =
(jint)(internal() ? scaled_offset (x, addr())
: runtime_address_to_index(x));
short* p = &live_bits() + 1;
p = add_jint(p, target_bits);
assert(p == instrs(), "new target must fit");
_target = x;
}
void breakpoint_Relocation::set_enabled(bool b) {
if (enabled() == b) return;
if (b) {
set_bits(bits() | enabled_state);
} else {
set_active(false); // remove the actual breakpoint insn, if any
set_bits(bits() & ~enabled_state);
}
}
void breakpoint_Relocation::set_active(bool b) {
assert(!b || enabled(), "cannot activate a disabled breakpoint");
if (active() == b) return;
// %%% should probably seize a lock here (might not be the right lock)
//MutexLockerEx ml_patch(Patching_lock, true);
//if (active() == b) return; // recheck state after locking
if (b) {
set_bits(bits() | active_state);
if (instrlen() == 0)
fatal("breakpoints in original code must be undoable");
pd_swap_in_breakpoint (addr(), instrs(), instrlen());
} else {
set_bits(bits() & ~active_state);
pd_swap_out_breakpoint(addr(), instrs(), instrlen());
}
}
//---------------------------------------------------------------------------------
// Non-product code

126
hotspot/src/share/vm/code/relocInfo.hpp
View file

@ -49,9 +49,6 @@ class NativeMovConstReg;
// RelocIterator
// A StackObj which iterates over the relocations associated with
// a range of code addresses. Can be used to operate a copy of code.
// PatchingRelocIterator
// Specialized subtype of RelocIterator which removes breakpoints
// temporarily during iteration, then restores them.
// BoundRelocation
// An _internal_ type shared by packers and unpackers of relocations.
// It pastes together a RelocationHolder with some pointers into
@ -204,15 +201,6 @@ class NativeMovConstReg;
// immediate field must not straddle a unit of memory coherence.
// //%note reloc_3
//
// relocInfo::breakpoint_type -- a conditional breakpoint in the code
// Value: none
// Instruction types: any whatsoever
// Data: [b [T]t i...]
// The b is a bit-packed word representing the breakpoint's attributes.
// The t is a target address which the breakpoint calls (when it is enabled).
// The i... is a place to store one or two instruction words overwritten
// by a trap, so that the breakpoint may be subsequently removed.
//
// relocInfo::static_stub_type -- an extra stub for each static_call_type
// Value: none
// Instruction types: a virtual call: { set_oop; jump; }
@ -271,8 +259,8 @@ class relocInfo VALUE_OBJ_CLASS_SPEC {
section_word_type = 9, // internal, but a cross-section reference
poll_type = 10, // polling instruction for safepoints
poll_return_type = 11, // polling instruction for safepoints at return
breakpoint_type = 12, // an initialization barrier or safepoint
metadata_type = 13, // metadata that used to be oops
metadata_type = 12, // metadata that used to be oops
yet_unused_type_1 = 13, // Still unused
yet_unused_type_2 = 14, // Still unused
data_prefix_tag = 15, // tag for a prefix (carries data arguments)
type_mask = 15 // A mask which selects only the above values
@ -312,7 +300,6 @@ class relocInfo VALUE_OBJ_CLASS_SPEC {
visitor(internal_word) \
visitor(poll) \
visitor(poll_return) \
visitor(breakpoint) \
visitor(section_word) \
@ -454,7 +441,7 @@ class relocInfo VALUE_OBJ_CLASS_SPEC {
public:
enum {
// Conservatively large estimate of maximum length (in shorts)
// of any relocation record (probably breakpoints are largest).
// of any relocation record.
// Extended format is length prefix, data words, and tag/offset suffix.
length_limit = 1 + 1 + (3*BytesPerWord/BytesPerShort) + 1,
have_format = format_width > 0
@ -571,8 +558,6 @@ class RelocIterator : public StackObj {
void initialize(nmethod* nm, address begin, address limit);
friend class PatchingRelocIterator;
// make an uninitialized one, for PatchingRelocIterator:
RelocIterator() { initialize_misc(); }
public:
@ -779,9 +764,6 @@ class Relocation VALUE_OBJ_CLASS_SPEC {
void pd_verify_data_value (address x, intptr_t off) { pd_set_data_value(x, off, true); }
address pd_call_destination (address orig_addr = NULL);
void pd_set_call_destination (address x);
void pd_swap_in_breakpoint (address x, short* instrs, int instrlen);
void pd_swap_out_breakpoint (address x, short* instrs, int instrlen);
static int pd_breakpoint_size ();
// this extracts the address of an address in the code stream instead of the reloc data
address* pd_address_in_code ();
@ -1302,87 +1284,6 @@ class poll_return_Relocation : public Relocation {
void fix_relocation_after_move(const CodeBuffer* src, CodeBuffer* dest);
};
class breakpoint_Relocation : public Relocation {
relocInfo::relocType type() { return relocInfo::breakpoint_type; }
enum {
// attributes which affect the interpretation of the data:
removable_attr = 0x0010, // buffer [i...] allows for undoing the trap
internal_attr = 0x0020, // the target is an internal addr (local stub)
settable_attr = 0x0040, // the target is settable
// states which can change over time:
enabled_state = 0x0100, // breakpoint must be active in running code
active_state = 0x0200, // breakpoint instruction actually in code
kind_mask = 0x000F, // mask for extracting kind
high_bit = 0x4000 // extra bit which is always set
};
public:
enum {
// kinds:
initialization = 1,
safepoint = 2
};
// If target is NULL, 32 bits are reserved for a later set_target().
static RelocationHolder spec(int kind, address target = NULL, bool internal_target = false) {
RelocationHolder rh = newHolder();
new(rh) breakpoint_Relocation(kind, target, internal_target);
return rh;
}
private:
// We require every bits value to NOT to fit into relocInfo::datalen_width,
// because we are going to actually store state in the reloc, and so
// cannot allow it to be compressed (and hence copied by the iterator).
short _bits; // bit-encoded kind, attrs, & state
address _target;
breakpoint_Relocation(int kind, address target, bool internal_target);
friend class RelocIterator;
breakpoint_Relocation() { }
short bits() const { return _bits; }
short& live_bits() const { return data()[0]; }
short* instrs() const { return data() + datalen() - instrlen(); }
int instrlen() const { return removable() ? pd_breakpoint_size() : 0; }
void set_bits(short x) {
assert(live_bits() == _bits, "must be the only mutator of reloc info");
live_bits() = _bits = x;
}
public:
address target() const;
void set_target(address x);
int kind() const { return bits() & kind_mask; }
bool enabled() const { return (bits() & enabled_state) != 0; }
bool active() const { return (bits() & active_state) != 0; }
bool internal() const { return (bits() & internal_attr) != 0; }
bool removable() const { return (bits() & removable_attr) != 0; }
bool settable() const { return (bits() & settable_attr) != 0; }
void set_enabled(bool b); // to activate, you must also say set_active
void set_active(bool b); // actually inserts bpt (must be enabled 1st)
// data is packed as 16 bits, followed by the target (1 or 2 words), followed
// if necessary by empty storage for saving away original instruction bytes.
void pack_data_to(CodeSection* dest);
void unpack_data();
// during certain operations, breakpoints must be out of the way:
void fix_relocation_after_move(const CodeBuffer* src, CodeBuffer* dest) {
assert(!active(), "cannot perform relocation on enabled breakpoints");
}
};
// We know all the xxx_Relocation classes, so now we can define these:
#define EACH_CASE(name) \
inline name##_Relocation* RelocIterator::name##_reloc() { \
@ -1401,25 +1302,4 @@ inline RelocIterator::RelocIterator(nmethod* nm, address begin, address limit) {
initialize(nm, begin, limit);
}
// if you are going to patch code, you should use this subclass of
// RelocIterator
class PatchingRelocIterator : public RelocIterator {
private:
RelocIterator _init_state;
void prepass(); // deactivates all breakpoints
void postpass(); // reactivates all enabled breakpoints
// do not copy these puppies; it would have unpredictable side effects
// these are private and have no bodies defined because they should not be called
PatchingRelocIterator(const RelocIterator&);
void operator=(const RelocIterator&);
public:
PatchingRelocIterator(nmethod* nm, address begin = NULL, address limit = NULL)
: RelocIterator(nm, begin, limit) { prepass(); }
~PatchingRelocIterator() { postpass(); }
};
#endif // SHARE_VM_CODE_RELOCINFO_HPP

2
hotspot/src/share/vm/gc_implementation/g1/heapRegion.cpp
View file

@ -798,7 +798,7 @@ void HeapRegion::verify(VerifyOption vo,
if (!g1->is_obj_dead_cond(obj, this, vo)) {
if (obj->is_oop()) {
Klass* klass = obj->klass();
if (!klass->is_metadata()) {
if (!klass->is_metaspace_object()) {
gclog_or_tty->print_cr("klass "PTR_FORMAT" of object "PTR_FORMAT" "
"not metadata", klass, obj);
*failures = true;

9
hotspot/src/share/vm/interpreter/bytecodeInterpreter.cpp
View file

@ -481,9 +481,9 @@ BytecodeInterpreter::run(interpreterState istate) {
// So we have a second version of the assertion which handles the case where EnableInvokeDynamic was
// switched off because of the wrong classes.
if (EnableInvokeDynamic || FLAG_IS_CMDLINE(EnableInvokeDynamic)) {
assert(abs(istate->_stack_base - istate->_stack_limit) == (istate->_method->max_stack() + 1), "bad stack limit");
assert(labs(istate->_stack_base - istate->_stack_limit) == (istate->_method->max_stack() + 1), "bad stack limit");
} else {
const int extra_stack_entries = Method::extra_stack_entries_for_indy;
const int extra_stack_entries = Method::extra_stack_entries_for_jsr292;
assert(labs(istate->_stack_base - istate->_stack_limit) == (istate->_method->max_stack() + extra_stack_entries
+ 1), "bad stack limit");
}
@ -2233,7 +2233,7 @@ run:
}
Method* method = cache->f1_as_method();
VERIFY_OOP(method);
if (VerifyOops) method->verify();
if (cache->has_appendix()) {
ConstantPool* constants = METHOD->constants();
@ -2265,8 +2265,7 @@ run:
}
Method* method = cache->f1_as_method();
VERIFY_OOP(method);
if (VerifyOops) method->verify();
if (cache->has_appendix()) {
ConstantPool* constants = METHOD->constants();

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

@ -71,13 +71,6 @@ bool MetaspaceObj::is_shared() const {
return MetaspaceShared::is_in_shared_space(this);
}
bool MetaspaceObj::is_metadata() const {
// GC Verify checks use this in guarantees.
// TODO: either replace them with is_metaspace_object() or remove them.
// is_metaspace_object() is slower than this test. This test doesn't
// seem very useful for metaspace objects anymore though.
return !Universe::heap()->is_in_reserved(this);
}
bool MetaspaceObj::is_metaspace_object() const {
return Metaspace::contains((void*)this);

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

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

1
hotspot/src/share/vm/memory/heapInspection.cpp
View file

@ -157,7 +157,6 @@ KlassInfoTable::~KlassInfoTable() {
}
uint KlassInfoTable::hash(const Klass* p) {
assert(p->is_metadata(), "all klasses are metadata");
return (uint)(((uintptr_t)p - (uintptr_t)_ref) >> 2);
}

4
hotspot/src/share/vm/oops/arrayKlass.cpp
View file

@ -221,8 +221,8 @@ void ArrayKlass::oop_print_on(oop obj, outputStream* st) {
// Verification
void ArrayKlass::verify_on(outputStream* st) {
Klass::verify_on(st);
void ArrayKlass::verify_on(outputStream* st, bool check_dictionary) {
Klass::verify_on(st, check_dictionary);
if (component_mirror() != NULL) {
guarantee(component_mirror()->klass() != NULL, "should have a class");

2
hotspot/src/share/vm/oops/arrayKlass.hpp
View file

@ -152,7 +152,7 @@ class ArrayKlass: public Klass {
void oop_print_on(oop obj, outputStream* st);
// Verification
void verify_on(outputStream* st);
void verify_on(outputStream* st, bool check_dictionary);
void oop_verify_on(oop obj, outputStream* st);
};

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

@ -48,8 +48,6 @@ void CompiledICHolder::print_value_on(outputStream* st) const {
// Verification
void CompiledICHolder::verify_on(outputStream* st) {
guarantee(holder_method()->is_metadata(), "should be in metaspace");
guarantee(holder_method()->is_method(), "should be method");
guarantee(holder_klass()->is_metadata(), "should be in metaspace");
guarantee(holder_klass()->is_klass(), "should be klass");
}

1
hotspot/src/share/vm/oops/constMethod.cpp
View file

@ -440,7 +440,6 @@ void ConstMethod::collect_statistics(KlassSizeStats *sz) const {
void ConstMethod::verify_on(outputStream* st) {
guarantee(is_constMethod(), "object must be constMethod");
guarantee(is_metadata(), err_msg("Should be metadata " PTR_FORMAT, this));
// Verification can occur during oop construction before the method or
// other fields have been initialized.

4
hotspot/src/share/vm/oops/constantPool.cpp
View file

@ -2095,12 +2095,10 @@ void ConstantPool::verify_on(outputStream* st) {
CPSlot entry = slot_at(i);
if (tag.is_klass()) {
if (entry.is_resolved()) {
guarantee(entry.get_klass()->is_metadata(), "should be metadata");
guarantee(entry.get_klass()->is_klass(), "should be klass");
}
} else if (tag.is_unresolved_klass()) {
if (entry.is_resolved()) {
guarantee(entry.get_klass()->is_metadata(), "should be metadata");
guarantee(entry.get_klass()->is_klass(), "should be klass");
}
} else if (tag.is_symbol()) {
@ -2112,13 +2110,11 @@ void ConstantPool::verify_on(outputStream* st) {
if (cache() != NULL) {
// Note: cache() can be NULL before a class is completely setup or
// in temporary constant pools used during constant pool merging
guarantee(cache()->is_metadata(), "should be metadata");
guarantee(cache()->is_constantPoolCache(), "should be constant pool cache");
}
if (pool_holder() != NULL) {
// Note: pool_holder() can be NULL in temporary constant pools
// used during constant pool merging
guarantee(pool_holder()->is_metadata(), "should be metadata");
guarantee(pool_holder()->is_klass(), "should be klass");
}
}

27
hotspot/src/share/vm/oops/instanceKlass.cpp
View file

@ -3088,27 +3088,26 @@ class VerifyFieldClosure: public OopClosure {
virtual void do_oop(narrowOop* p) { VerifyFieldClosure::do_oop_work(p); }
};
void InstanceKlass::verify_on(outputStream* st) {
Klass::verify_on(st);
Thread *thread = Thread::current();
void InstanceKlass::verify_on(outputStream* st, bool check_dictionary) {
#ifndef PRODUCT
// Avoid redundant verifies
// Avoid redundant verifies, this really should be in product.
if (_verify_count == Universe::verify_count()) return;
_verify_count = Universe::verify_count();
#endif
// Verify that klass is present in SystemDictionary
if (is_loaded() && !is_anonymous()) {
// Verify Klass
Klass::verify_on(st, check_dictionary);
// Verify that klass is present in SystemDictionary if not already
// verifying the SystemDictionary.
if (is_loaded() && !is_anonymous() && check_dictionary) {
Symbol* h_name = name();
SystemDictionary::verify_obj_klass_present(h_name, class_loader_data());
}
// Verify static fields
VerifyFieldClosure blk;
// Verify vtables
if (is_linked()) {
ResourceMark rm(thread);
ResourceMark rm;
// $$$ This used to be done only for m/s collections. Doing it
// always seemed a valid generalization. (DLD -- 6/00)
vtable()->verify(st);
@ -3116,7 +3115,6 @@ void InstanceKlass::verify_on(outputStream* st) {
// Verify first subklass
if (subklass_oop() != NULL) {
guarantee(subklass_oop()->is_metadata(), "should be in metaspace");
guarantee(subklass_oop()->is_klass(), "should be klass");
}
@ -3128,7 +3126,6 @@ void InstanceKlass::verify_on(outputStream* st) {
fatal(err_msg("subclass points to itself " PTR_FORMAT, sib));
}
guarantee(sib->is_metadata(), "should be in metaspace");
guarantee(sib->is_klass(), "should be klass");
guarantee(sib->super() == super, "siblings should have same superklass");
}
@ -3164,7 +3161,6 @@ void InstanceKlass::verify_on(outputStream* st) {
if (methods() != NULL) {
Array<Method*>* methods = this->methods();
for (int j = 0; j < methods->length(); j++) {
guarantee(methods->at(j)->is_metadata(), "should be in metaspace");
guarantee(methods->at(j)->is_method(), "non-method in methods array");
}
for (int j = 0; j < methods->length() - 1; j++) {
@ -3202,16 +3198,13 @@ void InstanceKlass::verify_on(outputStream* st) {
// Verify other fields
if (array_klasses() != NULL) {
guarantee(array_klasses()->is_metadata(), "should be in metaspace");
guarantee(array_klasses()->is_klass(), "should be klass");
}
if (constants() != NULL) {
guarantee(constants()->is_metadata(), "should be in metaspace");
guarantee(constants()->is_constantPool(), "should be constant pool");
}
const Klass* host = host_klass();
if (host != NULL) {
guarantee(host->is_metadata(), "should be in metaspace");
guarantee(host->is_klass(), "should be klass");
}
}

2
hotspot/src/share/vm/oops/instanceKlass.hpp
View file

@ -1050,7 +1050,7 @@ public:
const char* internal_name() const;
// Verification
void verify_on(outputStream* st);
void verify_on(outputStream* st, bool check_dictionary);
void oop_verify_on(oop obj, outputStream* st);
};

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

@ -377,7 +377,6 @@ void Klass::append_to_sibling_list() {
}
bool Klass::is_loader_alive(BoolObjectClosure* is_alive) {
assert(is_metadata(), "p is not meta-data");
assert(ClassLoaderDataGraph::contains((address)this), "is in the metaspace");
#ifdef ASSERT
@ -648,27 +647,24 @@ void Klass::collect_statistics(KlassSizeStats *sz) const {
// Verification
void Klass::verify_on(outputStream* st) {
guarantee(!Universe::heap()->is_in_reserved(this), "Shouldn't be");
guarantee(this->is_metadata(), "should be in metaspace");
void Klass::verify_on(outputStream* st, bool check_dictionary) {
// This can be expensive, but it is worth checking that this klass is actually
// in the CLD graph but not in production.
assert(ClassLoaderDataGraph::contains((address)this), "Should be");
guarantee(this->is_klass(),"should be klass");
if (super() != NULL) {
guarantee(super()->is_metadata(), "should be in metaspace");
guarantee(super()->is_klass(), "should be klass");
}
if (secondary_super_cache() != NULL) {
Klass* ko = secondary_super_cache();
guarantee(ko->is_metadata(), "should be in metaspace");
guarantee(ko->is_klass(), "should be klass");
}
for ( uint i = 0; i < primary_super_limit(); i++ ) {
Klass* ko = _primary_supers[i];
if (ko != NULL) {
guarantee(ko->is_metadata(), "should be in metaspace");
guarantee(ko->is_klass(), "should be klass");
}
}
@ -680,7 +676,6 @@ void Klass::verify_on(outputStream* st) {
void Klass::oop_verify_on(oop obj, outputStream* st) {
guarantee(obj->is_oop(), "should be oop");
guarantee(obj->klass()->is_metadata(), "should not be in Java heap");
guarantee(obj->klass()->is_klass(), "klass field is not a klass");
}

4
hotspot/src/share/vm/oops/klass.hpp
View file

@ -703,8 +703,8 @@ class Klass : public Metadata {
virtual const char* internal_name() const = 0;
// Verification
virtual void verify_on(outputStream* st);
void verify() { verify_on(tty); }
virtual void verify_on(outputStream* st, bool check_dictionary);
void verify(bool check_dictionary = true) { verify_on(tty, check_dictionary); }
#ifndef PRODUCT
void verify_vtable_index(int index);

5
hotspot/src/share/vm/oops/method.cpp
View file

@ -1969,14 +1969,9 @@ void Method::collect_statistics(KlassSizeStats *sz) const {
void Method::verify_on(outputStream* st) {
guarantee(is_method(), "object must be method");
guarantee(is_metadata(), "should be metadata");
guarantee(constants()->is_constantPool(), "should be constant pool");
guarantee(constants()->is_metadata(), "should be metadata");
guarantee(constMethod()->is_constMethod(), "should be ConstMethod*");
guarantee(constMethod()->is_metadata(), "should be metadata");
MethodData* md = method_data();
guarantee(md == NULL ||
md->is_metadata(), "should be metadata");
guarantee(md == NULL ||
md->is_methodData(), "should be method data");
}

6
hotspot/src/share/vm/oops/objArrayKlass.cpp
View file

@ -676,11 +676,9 @@ const char* ObjArrayKlass::internal_name() const {
// Verification
void ObjArrayKlass::verify_on(outputStream* st) {
ArrayKlass::verify_on(st);
guarantee(element_klass()->is_metadata(), "should be in metaspace");
void ObjArrayKlass::verify_on(outputStream* st, bool check_dictionary) {
ArrayKlass::verify_on(st, check_dictionary);
guarantee(element_klass()->is_klass(), "should be klass");
guarantee(bottom_klass()->is_metadata(), "should be in metaspace");
guarantee(bottom_klass()->is_klass(), "should be klass");
Klass* bk = bottom_klass();
guarantee(bk->oop_is_instance() || bk->oop_is_typeArray(), "invalid bottom klass");

2
hotspot/src/share/vm/oops/objArrayKlass.hpp
View file

@ -151,7 +151,7 @@ class ObjArrayKlass : public ArrayKlass {
const char* internal_name() const;
// Verification
void verify_on(outputStream* st);
void verify_on(outputStream* st, bool check_dictionary);
void oop_verify_on(oop obj, outputStream* st);
};

4
hotspot/src/share/vm/oops/symbol.cpp
View file

@ -32,7 +32,9 @@
#include "memory/allocation.inline.hpp"
#include "memory/resourceArea.hpp"
Symbol::Symbol(const u1* name, int length, int refcount) : _refcount(refcount), _length(length) {
Symbol::Symbol(const u1* name, int length, int refcount) {
_refcount = refcount;
_length = length;
_identity_hash = os::random();
for (int i = 0; i < _length; i++) {
byte_at_put(i, name[i]);

19
hotspot/src/share/vm/oops/symbol.hpp
View file

@ -27,6 +27,7 @@
#include "utilities/utf8.hpp"
#include "memory/allocation.hpp"
#include "runtime/atomic.hpp"
// A Symbol is a canonicalized string.
// All Symbols reside in global SymbolTable and are reference counted.
@ -101,14 +102,22 @@
// type without virtual functions.
class ClassLoaderData;
class Symbol : public MetaspaceObj {
// We separate the fields in SymbolBase from Symbol::_body so that
// Symbol::size(int) can correctly calculate the space needed.
class SymbolBase : public MetaspaceObj {
public:
ATOMIC_SHORT_PAIR(
volatile short _refcount, // needs atomic operation
unsigned short _length // number of UTF8 characters in the symbol (does not need atomic op)
);
int _identity_hash;
};
class Symbol : private SymbolBase {
friend class VMStructs;
friend class SymbolTable;
friend class MoveSymbols;
private:
volatile int _refcount;
int _identity_hash;
unsigned short _length; // number of UTF8 characters in the symbol
jbyte _body[1];
enum {
@ -117,7 +126,7 @@ class Symbol : public MetaspaceObj {
};
static int size(int length) {
size_t sz = heap_word_size(sizeof(Symbol) + (length > 0 ? length - 1 : 0));
size_t sz = heap_word_size(sizeof(SymbolBase) + (length > 0 ? length : 0));
return align_object_size(sz);
}

18
hotspot/src/share/vm/opto/memnode.cpp
View file

@ -2943,11 +2943,19 @@ Node *MemBarNode::Ideal(PhaseGVN *phase, bool can_reshape) {
Node* my_mem = in(MemBarNode::Precedent);
// The MembarAquire may keep an unused LoadNode alive through the Precedent edge
if ((my_mem != NULL) && (opc == Op_MemBarAcquire) && (my_mem->outcnt() == 1)) {
assert(my_mem->unique_out() == this, "sanity");
phase->hash_delete(this);
del_req(Precedent);
phase->is_IterGVN()->_worklist.push(my_mem); // remove dead node later
my_mem = NULL;
// if the Precedent is a decodeN and its input (a Load) is used at more than one place,
// replace this Precedent (decodeN) with the Load instead.
if ((my_mem->Opcode() == Op_DecodeN) && (my_mem->in(1)->outcnt() > 1)) {
Node* load_node = my_mem->in(1);
set_req(MemBarNode::Precedent, load_node);
phase->is_IterGVN()->_worklist.push(my_mem);
my_mem = load_node;
} else {
assert(my_mem->unique_out() == this, "sanity");
del_req(Precedent);
phase->is_IterGVN()->_worklist.push(my_mem); // remove dead node later
my_mem = NULL;
}
}
if (my_mem != NULL && my_mem->is_Mem()) {
const TypeOopPtr* t_oop = my_mem->in(MemNode::Address)->bottom_type()->isa_oopptr();

29
hotspot/src/share/vm/runtime/atomic.cpp
View file

@ -80,3 +80,32 @@ jlong Atomic::add(jlong add_value, volatile jlong* dest) {
}
return old;
}
void Atomic::inc(volatile short* dest) {
// Most platforms do not support atomic increment on a 2-byte value. However,
// if the value occupies the most significant 16 bits of an aligned 32-bit
// word, then we can do this with an atomic add of 0x10000 to the 32-bit word.
//
// The least significant parts of this 32-bit word will never be affected, even
// in case of overflow/underflow.
//
// Use the ATOMIC_SHORT_PAIR macro to get the desired alignment.
#ifdef VM_LITTLE_ENDIAN
assert((intx(dest) & 0x03) == 0x02, "wrong alignment");
(void)Atomic::add(0x10000, (volatile int*)(dest-1));
#else
assert((intx(dest) & 0x03) == 0x00, "wrong alignment");
(void)Atomic::add(0x10000, (volatile int*)(dest));
#endif
}
void Atomic::dec(volatile short* dest) {
#ifdef VM_LITTLE_ENDIAN
assert((intx(dest) & 0x03) == 0x02, "wrong alignment");
(void)Atomic::add(-0x10000, (volatile int*)(dest-1));
#else
assert((intx(dest) & 0x03) == 0x00, "wrong alignment");
(void)Atomic::add(-0x10000, (volatile int*)(dest));
#endif
}

22
hotspot/src/share/vm/runtime/atomic.hpp
View file

@ -64,11 +64,13 @@ class Atomic : AllStatic {
// Atomically increment location
inline static void inc (volatile jint* dest);
static void inc (volatile jshort* dest);
inline static void inc_ptr(volatile intptr_t* dest);
inline static void inc_ptr(volatile void* dest);
// Atomically decrement a location
inline static void dec (volatile jint* dest);
static void dec (volatile jshort* dest);
inline static void dec_ptr(volatile intptr_t* dest);
inline static void dec_ptr(volatile void* dest);
@ -95,4 +97,24 @@ class Atomic : AllStatic {
inline static void* cmpxchg_ptr(void* exchange_value, volatile void* dest, void* compare_value);
};
// To use Atomic::inc(jshort* dest) and Atomic::dec(jshort* dest), the address must be specially
// aligned, such that (*dest) occupies the upper 16 bits of an aligned 32-bit word. The best way to
// achieve is to place your short value next to another short value, which doesn't need atomic ops.
//
// Example
// ATOMIC_SHORT_PAIR(
// volatile short _refcount, // needs atomic operation
// unsigned short _length // number of UTF8 characters in the symbol (does not need atomic op)
// );
#ifdef VM_LITTLE_ENDIAN
#define ATOMIC_SHORT_PAIR(atomic_decl, non_atomic_decl) \
non_atomic_decl; \
atomic_decl
#else
#define ATOMIC_SHORT_PAIR(atomic_decl, non_atomic_decl) \
atomic_decl ; \
non_atomic_decl
#endif
#endif // SHARE_VM_RUNTIME_ATOMIC_HPP

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

@ -387,7 +387,6 @@ void frame::interpreter_frame_set_locals(intptr_t* locs) {
Method* frame::interpreter_frame_method() const {
assert(is_interpreted_frame(), "interpreted frame expected");
Method* m = *interpreter_frame_method_addr();
assert(m->is_metadata(), "bad Method* in interpreter frame");
assert(m->is_method(), "not a Method*");
return m;
}
@ -713,7 +712,8 @@ void frame::print_on_error(outputStream* st, char* buf, int buflen, bool verbose
Method* m = ((nmethod *)_cb)->method();
if (m != NULL) {
m->name_and_sig_as_C_string(buf, buflen);
st->print("J %s", buf);
st->print("J %s @ " PTR_FORMAT " [" PTR_FORMAT "+" SIZE_FORMAT "]",
buf, _pc, _cb->code_begin(), _pc - _cb->code_begin());
} else {
st->print("J " PTR_FORMAT, pc());
}

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

@ -73,12 +73,6 @@ bool Flag::is_unlocked() const {
strcmp(kind, "{C2 diagnostic}") == 0 ||
strcmp(kind, "{ARCH diagnostic}") == 0 ||
strcmp(kind, "{Shark diagnostic}") == 0) {
if (strcmp(name, "EnableInvokeDynamic") == 0 && UnlockExperimentalVMOptions && !UnlockDiagnosticVMOptions) {
// transitional logic to allow tests to run until they are changed
static int warned;
if (++warned == 1) warning("Use -XX:+UnlockDiagnosticVMOptions before EnableInvokeDynamic flag");
return true;
}
return UnlockDiagnosticVMOptions;
} else if (strcmp(kind, "{experimental}") == 0 ||
strcmp(kind, "{C2 experimental}") == 0 ||

7
hotspot/src/share/vm/runtime/sharedRuntime.cpp
View file

@ -813,8 +813,11 @@ address SharedRuntime::continuation_for_implicit_exception(JavaThread* thread,
// 3. Implict null exception in nmethod
if (!cb->is_nmethod()) {
guarantee(cb->is_adapter_blob() || cb->is_method_handles_adapter_blob(),
"exception happened outside interpreter, nmethods and vtable stubs (1)");
bool is_in_blob = cb->is_adapter_blob() || cb->is_method_handles_adapter_blob();
if (!is_in_blob) {
cb->print();
fatal(err_msg("exception happened outside interpreter, nmethods and vtable stubs at pc " INTPTR_FORMAT, pc));
}
Events::log_exception(thread, "NullPointerException in code blob at " INTPTR_FORMAT, pc);
// There is no handler here, so we will simply unwind.
return StubRoutines::throw_NullPointerException_at_call_entry();

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

@ -220,7 +220,7 @@ Thread::Thread() {
set_osthread(NULL);
set_resource_area(new (mtThread)ResourceArea());
set_handle_area(new (mtThread) HandleArea(NULL));
set_metadata_handles(new (ResourceObj::C_HEAP, mtClass) GrowableArray<Metadata*>(300, true));
set_metadata_handles(new (ResourceObj::C_HEAP, mtClass) GrowableArray<Metadata*>(30, true));
set_active_handles(NULL);
set_free_handle_block(NULL);
set_last_handle_mark(NULL);

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

@ -379,7 +379,7 @@ typedef BinaryTreeDictionary<Metablock, FreeList> MetablockTreeDictionary;
nonstatic_field(ConstMethod, _size_of_parameters, u2) \
nonstatic_field(ObjArrayKlass, _element_klass, Klass*) \
nonstatic_field(ObjArrayKlass, _bottom_klass, Klass*) \
volatile_nonstatic_field(Symbol, _refcount, int) \
volatile_nonstatic_field(Symbol, _refcount, short) \
nonstatic_field(Symbol, _identity_hash, int) \
nonstatic_field(Symbol, _length, unsigned short) \
unchecked_nonstatic_field(Symbol, _body, sizeof(jbyte)) /* NOTE: no type */ \

2
hotspot/src/share/vm/shark/sharkBuilder.cpp
View file

@ -471,7 +471,7 @@ Value* SharkBuilder::CreateInlineOop(jobject object, const char* name) {
Value* SharkBuilder::CreateInlineMetadata(Metadata* metadata, llvm::PointerType* type, const char* name) {
assert(metadata != NULL, "inlined metadata must not be NULL");
assert(metadata->is_metadata(), "sanity check");
assert(metadata->is_metaspace_object(), "sanity check");
return CreateLoad(
CreateIntToPtr(
code_buffer_address(code_buffer()->inline_Metadata(metadata)),

776
hotspot/test/compiler/8005956/PolynomialRoot.java Normal file
View file

@ -0,0 +1,776 @@
//package com.polytechnik.utils;
/*
* (C) Vladislav Malyshkin 2010
* This file is under GPL version 3.
*
*/
/** Polynomial root.
* @version $Id: PolynomialRoot.java,v 1.105 2012/08/18 00:00:05 mal Exp $
* @author Vladislav Malyshkin mal@gromco.com
*/
/**
* @test
* @bug 8005956
* @summary C2: assert(!def_outside->member(r)) failed: Use of external LRG overlaps the same LRG defined in this block
*
* @run main PolynomialRoot
*/
public class PolynomialRoot {
public static int findPolynomialRoots(final int n,
final double [] p,
final double [] re_root,
final double [] im_root)
{
if(n==4)
{
return root4(p,re_root,im_root);
}
else if(n==3)
{
return root3(p,re_root,im_root);
}
else if(n==2)
{
return root2(p,re_root,im_root);
}
else if(n==1)
{
return root1(p,re_root,im_root);
}
else
{
throw new RuntimeException("n="+n+" is not supported yet");
}
}
static final double SQRT3=Math.sqrt(3.0),SQRT2=Math.sqrt(2.0);
private static final boolean PRINT_DEBUG=false;
public static int root4(final double [] p,final double [] re_root,final double [] im_root)
{
if(PRINT_DEBUG) System.err.println("=====================root4:p="+java.util.Arrays.toString(p));
final double vs=p[4];
if(PRINT_DEBUG) System.err.println("p[4]="+p[4]);
if(!(Math.abs(vs)>EPS))
{
re_root[0]=re_root[1]=re_root[2]=re_root[3]=
im_root[0]=im_root[1]=im_root[2]=im_root[3]=Double.NaN;
return -1;
}
/* zsolve_quartic.c - finds the complex roots of
* x^4 + a x^3 + b x^2 + c x + d = 0
*/
final double a=p[3]/vs,b=p[2]/vs,c=p[1]/vs,d=p[0]/vs;
if(PRINT_DEBUG) System.err.println("input a="+a+" b="+b+" c="+c+" d="+d);
final double r4 = 1.0 / 4.0;
final double q2 = 1.0 / 2.0, q4 = 1.0 / 4.0, q8 = 1.0 / 8.0;
final double q1 = 3.0 / 8.0, q3 = 3.0 / 16.0;
final int mt;
/* Deal easily with the cases where the quartic is degenerate. The
* ordering of solutions is done explicitly. */
if (0 == b && 0 == c)
{
if (0 == d)
{
re_root[0]=-a;
im_root[0]=im_root[1]=im_root[2]=im_root[3]=0;
re_root[1]=re_root[2]=re_root[3]=0;
return 4;
}
else if (0 == a)
{
if (d > 0)
{
final double sq4 = Math.sqrt(Math.sqrt(d));
re_root[0]=sq4*SQRT2/2;
im_root[0]=re_root[0];
re_root[1]=-re_root[0];
im_root[1]=re_root[0];
re_root[2]=-re_root[0];
im_root[2]=-re_root[0];
re_root[3]=re_root[0];
im_root[3]=-re_root[0];
if(PRINT_DEBUG) System.err.println("Path a=0 d>0");
}
else
{
final double sq4 = Math.sqrt(Math.sqrt(-d));
re_root[0]=sq4;
im_root[0]=0;
re_root[1]=0;
im_root[1]=sq4;
re_root[2]=0;
im_root[2]=-sq4;
re_root[3]=-sq4;
im_root[3]=0;
if(PRINT_DEBUG) System.err.println("Path a=0 d<0");
}
return 4;
}
}
if (0.0 == c && 0.0 == d)
{
root2(new double []{p[2],p[3],p[4]},re_root,im_root);
re_root[2]=im_root[2]=re_root[3]=im_root[3]=0;
return 4;
}
if(PRINT_DEBUG) System.err.println("G Path c="+c+" d="+d);
final double [] u=new double[3];
if(PRINT_DEBUG) System.err.println("Generic Path");
/* For non-degenerate solutions, proceed by constructing and
* solving the resolvent cubic */
final double aa = a * a;
final double pp = b - q1 * aa;
final double qq = c - q2 * a * (b - q4 * aa);
final double rr = d - q4 * a * (c - q4 * a * (b - q3 * aa));
final double rc = q2 * pp , rc3 = rc / 3;
final double sc = q4 * (q4 * pp * pp - rr);
final double tc = -(q8 * qq * q8 * qq);
if(PRINT_DEBUG) System.err.println("aa="+aa+" pp="+pp+" qq="+qq+" rr="+rr+" rc="+rc+" sc="+sc+" tc="+tc);
final boolean flag_realroots;
/* This code solves the resolvent cubic in a convenient fashion
* for this implementation of the quartic. If there are three real
* roots, then they are placed directly into u[]. If two are
* complex, then the real root is put into u[0] and the real
* and imaginary part of the complex roots are placed into
* u[1] and u[2], respectively. */
{
final double qcub = (rc * rc - 3 * sc);
final double rcub = (rc*(2 * rc * rc - 9 * sc) + 27 * tc);
final double Q = qcub / 9;
final double R = rcub / 54;
final double Q3 = Q * Q * Q;
final double R2 = R * R;
final double CR2 = 729 * rcub * rcub;
final double CQ3 = 2916 * qcub * qcub * qcub;
if(PRINT_DEBUG) System.err.println("CR2="+CR2+" CQ3="+CQ3+" R="+R+" Q="+Q);
if (0 == R && 0 == Q)
{
flag_realroots=true;
u[0] = -rc3;
u[1] = -rc3;
u[2] = -rc3;
}
else if (CR2 == CQ3)
{
flag_realroots=true;
final double sqrtQ = Math.sqrt (Q);
if (R > 0)
{
u[0] = -2 * sqrtQ - rc3;
u[1] = sqrtQ - rc3;
u[2] = sqrtQ - rc3;
}
else
{
u[0] = -sqrtQ - rc3;
u[1] = -sqrtQ - rc3;
u[2] = 2 * sqrtQ - rc3;
}
}
else if (R2 < Q3)
{
flag_realroots=true;
final double ratio = (R >= 0?1:-1) * Math.sqrt (R2 / Q3);
final double theta = Math.acos (ratio);
final double norm = -2 * Math.sqrt (Q);
u[0] = norm * Math.cos (theta / 3) - rc3;
u[1] = norm * Math.cos ((theta + 2.0 * Math.PI) / 3) - rc3;
u[2] = norm * Math.cos ((theta - 2.0 * Math.PI) / 3) - rc3;
}
else
{
flag_realroots=false;
final double A = -(R >= 0?1:-1)*Math.pow(Math.abs(R)+Math.sqrt(R2-Q3),1.0/3.0);
final double B = Q / A;
u[0] = A + B - rc3;
u[1] = -0.5 * (A + B) - rc3;
u[2] = -(SQRT3*0.5) * Math.abs (A - B);
}
if(PRINT_DEBUG) System.err.println("u[0]="+u[0]+" u[1]="+u[1]+" u[2]="+u[2]+" qq="+qq+" disc="+((CR2 - CQ3) / 2125764.0));
}
/* End of solution to resolvent cubic */
/* Combine the square roots of the roots of the cubic
* resolvent appropriately. Also, calculate 'mt' which
* designates the nature of the roots:
* mt=1 : 4 real roots
* mt=2 : 0 real roots
* mt=3 : 2 real roots
*/
final double w1_re,w1_im,w2_re,w2_im,w3_re,w3_im,mod_w1w2,mod_w1w2_squared;
if (flag_realroots)
{
mod_w1w2=-1;
mt = 2;
int jmin=0;
double vmin=Math.abs(u[jmin]);
for(int j=1;j<3;j++)
{
final double vx=Math.abs(u[j]);
if(vx<vmin)
{
vmin=vx;
jmin=j;
}
}
final double u1=u[(jmin+1)%3],u2=u[(jmin+2)%3];
mod_w1w2_squared=Math.abs(u1*u2);
if(u1>=0)
{
w1_re=Math.sqrt(u1);
w1_im=0;
}
else
{
w1_re=0;
w1_im=Math.sqrt(-u1);
}
if(u2>=0)
{
w2_re=Math.sqrt(u2);
w2_im=0;
}
else
{
w2_re=0;
w2_im=Math.sqrt(-u2);
}
if(PRINT_DEBUG) System.err.println("u1="+u1+" u2="+u2+" jmin="+jmin);
}
else
{
mt = 3;
final double w_mod2_sq=u[1]*u[1]+u[2]*u[2],w_mod2=Math.sqrt(w_mod2_sq),w_mod=Math.sqrt(w_mod2);
if(w_mod2_sq<=0)
{
w1_re=w1_im=0;
}
else
{
// calculate square root of a complex number (u[1],u[2])
// the result is in the (w1_re,w1_im)
final double absu1=Math.abs(u[1]),absu2=Math.abs(u[2]),w;
if(absu1>=absu2)
{
final double t=absu2/absu1;
w=Math.sqrt(absu1*0.5 * (1.0 + Math.sqrt(1.0 + t * t)));
if(PRINT_DEBUG) System.err.println(" Path1 ");
}
else
{
final double t=absu1/absu2;
w=Math.sqrt(absu2*0.5 * (t + Math.sqrt(1.0 + t * t)));
if(PRINT_DEBUG) System.err.println(" Path1a ");
}
if(u[1]>=0)
{
w1_re=w;
w1_im=u[2]/(2*w);
if(PRINT_DEBUG) System.err.println(" Path2 ");
}
else
{
final double vi = (u[2] >= 0) ? w : -w;
w1_re=u[2]/(2*vi);
w1_im=vi;
if(PRINT_DEBUG) System.err.println(" Path2a ");
}
}
final double absu0=Math.abs(u[0]);
if(w_mod2>=absu0)
{
mod_w1w2=w_mod2;
mod_w1w2_squared=w_mod2_sq;
w2_re=w1_re;
w2_im=-w1_im;
}
else
{
mod_w1w2=-1;
mod_w1w2_squared=w_mod2*absu0;
if(u[0]>=0)
{
w2_re=Math.sqrt(absu0);
w2_im=0;
}
else
{
w2_re=0;
w2_im=Math.sqrt(absu0);
}
}
if(PRINT_DEBUG) System.err.println("u[0]="+u[0]+"u[1]="+u[1]+" u[2]="+u[2]+" absu0="+absu0+" w_mod="+w_mod+" w_mod2="+w_mod2);
}
/* Solve the quadratic in order to obtain the roots
* to the quartic */
if(mod_w1w2>0)
{
// a shorcut to reduce rounding error
w3_re=qq/(-8)/mod_w1w2;
w3_im=0;
}
else if(mod_w1w2_squared>0)
{
// regular path
final double mqq8n=qq/(-8)/mod_w1w2_squared;
w3_re=mqq8n*(w1_re*w2_re-w1_im*w2_im);
w3_im=-mqq8n*(w1_re*w2_im+w2_re*w1_im);
}
else
{
// typically occur when qq==0
w3_re=w3_im=0;
}
final double h = r4 * a;
if(PRINT_DEBUG) System.err.println("w1_re="+w1_re+" w1_im="+w1_im+" w2_re="+w2_re+" w2_im="+w2_im+" w3_re="+w3_re+" w3_im="+w3_im+" h="+h);
re_root[0]=w1_re+w2_re+w3_re-h;
im_root[0]=w1_im+w2_im+w3_im;
re_root[1]=-(w1_re+w2_re)+w3_re-h;
im_root[1]=-(w1_im+w2_im)+w3_im;
re_root[2]=w2_re-w1_re-w3_re-h;
im_root[2]=w2_im-w1_im-w3_im;
re_root[3]=w1_re-w2_re-w3_re-h;
im_root[3]=w1_im-w2_im-w3_im;
return 4;
}
static void setRandomP(final double [] p,final int n,java.util.Random r)
{
if(r.nextDouble()<0.1)
{
// integer coefficiens
for(int j=0;j<p.length;j++)
{
if(j<=n)
{
p[j]=(r.nextInt(2)<=0?-1:1)*r.nextInt(10);
}
else
{
p[j]=0;
}
}
}
else
{
// real coefficiens
for(int j=0;j<p.length;j++)
{
if(j<=n)
{
p[j]=-1+2*r.nextDouble();
}
else
{
p[j]=0;
}
}
}
if(Math.abs(p[n])<1e-2)
{
p[n]=(r.nextInt(2)<=0?-1:1)*(0.1+r.nextDouble());
}
}
static void checkValues(final double [] p,
final int n,
final double rex,
final double imx,
final double eps,
final String txt)
{
double res=0,ims=0,sabs=0;
final double xabs=Math.abs(rex)+Math.abs(imx);
for(int k=n;k>=0;k--)
{
final double res1=(res*rex-ims*imx)+p[k];
final double ims1=(ims*rex+res*imx);
res=res1;
ims=ims1;
sabs+=xabs*sabs+p[k];
}
sabs=Math.abs(sabs);
if(false && sabs>1/eps?
(!(Math.abs(res/sabs)<=eps)||!(Math.abs(ims/sabs)<=eps))
:
(!(Math.abs(res)<=eps)||!(Math.abs(ims)<=eps)))
{
throw new RuntimeException(
getPolinomTXT(p)+"\n"+
"\t x.r="+rex+" x.i="+imx+"\n"+
"res/sabs="+(res/sabs)+" ims/sabs="+(ims/sabs)+
" sabs="+sabs+
"\nres="+res+" ims="+ims+" n="+n+" eps="+eps+" "+
" sabs>1/eps="+(sabs>1/eps)+
" f1="+(!(Math.abs(res/sabs)<=eps)||!(Math.abs(ims/sabs)<=eps))+
" f2="+(!(Math.abs(res)<=eps)||!(Math.abs(ims)<=eps))+
" "+txt);
}
}
static String getPolinomTXT(final double [] p)
{
final StringBuilder buf=new StringBuilder();
buf.append("order="+(p.length-1)+"\t");
for(int k=0;k<p.length;k++)
{
buf.append("p["+k+"]="+p[k]+";");
}
return buf.toString();
}
static String getRootsTXT(int nr,final double [] re,final double [] im)
{
final StringBuilder buf=new StringBuilder();
for(int k=0;k<nr;k++)
{
buf.append("x."+k+"("+re[k]+","+im[k]+")\n");
}
return buf.toString();
}
static void testRoots(final int n,
final int n_tests,
final java.util.Random rn,
final double eps)
{
final double [] p=new double [n+1];
final double [] rex=new double [n],imx=new double [n];
for(int i=0;i<n_tests;i++)
{
for(int dg=n;dg-->-1;)
{
for(int dr=3;dr-->0;)
{
setRandomP(p,n,rn);
for(int j=0;j<=dg;j++)
{
p[j]=0;
}
if(dr==0)
{
p[0]=-1+2.0*rn.nextDouble();
}
else if(dr==1)
{
p[0]=p[1]=0;
}
findPolynomialRoots(n,p,rex,imx);
for(int j=0;j<n;j++)
{
//System.err.println("j="+j);
checkValues(p,n,rex[j],imx[j],eps," t="+i);
}
}
}
}
System.err.println("testRoots(): n_tests="+n_tests+" OK, dim="+n);
}
static final double EPS=0;
public static int root1(final double [] p,final double [] re_root,final double [] im_root)
{
if(!(Math.abs(p[1])>EPS))
{
re_root[0]=im_root[0]=Double.NaN;
return -1;
}
re_root[0]=-p[0]/p[1];
im_root[0]=0;
return 1;
}
public static int root2(final double [] p,final double [] re_root,final double [] im_root)
{
if(!(Math.abs(p[2])>EPS))
{
re_root[0]=re_root[1]=im_root[0]=im_root[1]=Double.NaN;
return -1;
}
final double b2=0.5*(p[1]/p[2]),c=p[0]/p[2],d=b2*b2-c;
if(d>=0)
{
final double sq=Math.sqrt(d);
if(b2<0)
{
re_root[1]=-b2+sq;
re_root[0]=c/re_root[1];
}
else if(b2>0)
{
re_root[0]=-b2-sq;
re_root[1]=c/re_root[0];
}
else
{
re_root[0]=-b2-sq;
re_root[1]=-b2+sq;
}
im_root[0]=im_root[1]=0;
}
else
{
final double sq=Math.sqrt(-d);
re_root[0]=re_root[1]=-b2;
im_root[0]=sq;
im_root[1]=-sq;
}
return 2;
}
public static int root3(final double [] p,final double [] re_root,final double [] im_root)
{
final double vs=p[3];
if(!(Math.abs(vs)>EPS))
{
re_root[0]=re_root[1]=re_root[2]=
im_root[0]=im_root[1]=im_root[2]=Double.NaN;
return -1;
}
final double a=p[2]/vs,b=p[1]/vs,c=p[0]/vs;
/* zsolve_cubic.c - finds the complex roots of x^3 + a x^2 + b x + c = 0
*/
final double q = (a * a - 3 * b);
final double r = (a*(2 * a * a - 9 * b) + 27 * c);
final double Q = q / 9;
final double R = r / 54;
final double Q3 = Q * Q * Q;
final double R2 = R * R;
final double CR2 = 729 * r * r;
final double CQ3 = 2916 * q * q * q;
final double a3=a/3;
if (R == 0 && Q == 0)
{
re_root[0]=re_root[1]=re_root[2]=-a3;
im_root[0]=im_root[1]=im_root[2]=0;
return 3;
}
else if (CR2 == CQ3)
{
/* this test is actually R2 == Q3, written in a form suitable
for exact computation with integers */
/* Due to finite precision some double roots may be missed, and
will be considered to be a pair of complex roots z = x +/-
epsilon i close to the real axis. */
final double sqrtQ = Math.sqrt (Q);
if (R > 0)
{
re_root[0] = -2 * sqrtQ - a3;
re_root[1]=re_root[2]=sqrtQ - a3;
im_root[0]=im_root[1]=im_root[2]=0;
}
else
{
re_root[0]=re_root[1] = -sqrtQ - a3;
re_root[2]=2 * sqrtQ - a3;
im_root[0]=im_root[1]=im_root[2]=0;
}
return 3;
}
else if (R2 < Q3)
{
final double sgnR = (R >= 0 ? 1 : -1);
final double ratio = sgnR * Math.sqrt (R2 / Q3);
final double theta = Math.acos (ratio);
final double norm = -2 * Math.sqrt (Q);
final double r0 = norm * Math.cos (theta/3) - a3;
final double r1 = norm * Math.cos ((theta + 2.0 * Math.PI) / 3) - a3;
final double r2 = norm * Math.cos ((theta - 2.0 * Math.PI) / 3) - a3;
re_root[0]=r0;
re_root[1]=r1;
re_root[2]=r2;
im_root[0]=im_root[1]=im_root[2]=0;
return 3;
}
else
{
final double sgnR = (R >= 0 ? 1 : -1);
final double A = -sgnR * Math.pow (Math.abs (R) + Math.sqrt (R2 - Q3), 1.0 / 3.0);
final double B = Q / A;
re_root[0]=A + B - a3;
im_root[0]=0;
re_root[1]=-0.5 * (A + B) - a3;
im_root[1]=-(SQRT3*0.5) * Math.abs(A - B);
re_root[2]=re_root[1];
im_root[2]=-im_root[1];
return 3;
}
}
static void root3a(final double [] p,final double [] re_root,final double [] im_root)
{
if(Math.abs(p[3])>EPS)
{
final double v=p[3],
a=p[2]/v,b=p[1]/v,c=p[0]/v,
a3=a/3,a3a=a3*a,
pd3=(b-a3a)/3,
qd2=a3*(a3a/3-0.5*b)+0.5*c,
Q=pd3*pd3*pd3+qd2*qd2;
if(Q<0)
{
// three real roots
final double SQ=Math.sqrt(-Q);
final double th=Math.atan2(SQ,-qd2);
im_root[0]=im_root[1]=im_root[2]=0;
final double f=2*Math.sqrt(-pd3);
re_root[0]=f*Math.cos(th/3)-a3;
re_root[1]=f*Math.cos((th+2*Math.PI)/3)-a3;
re_root[2]=f*Math.cos((th+4*Math.PI)/3)-a3;
//System.err.println("3r");
}
else
{
// one real & two complex roots
final double SQ=Math.sqrt(Q);
final double r1=-qd2+SQ,r2=-qd2-SQ;
final double v1=Math.signum(r1)*Math.pow(Math.abs(r1),1.0/3),
v2=Math.signum(r2)*Math.pow(Math.abs(r2),1.0/3),
sv=v1+v2;
// real root
re_root[0]=sv-a3;
im_root[0]=0;
// complex roots
re_root[1]=re_root[2]=-0.5*sv-a3;
im_root[1]=(v1-v2)*(SQRT3*0.5);
im_root[2]=-im_root[1];
//System.err.println("1r2c");
}
}
else
{
re_root[0]=re_root[1]=re_root[2]=im_root[0]=im_root[1]=im_root[2]=Double.NaN;
}
}
static void printSpecialValues()
{
for(int st=0;st<6;st++)
{
//final double [] p=new double []{8,1,3,3.6,1};
final double [] re_root=new double [4],im_root=new double [4];
final double [] p;
final int n;
if(st<=3)
{
if(st<=0)
{
p=new double []{2,-4,6,-4,1};
//p=new double []{-6,6,-6,8,-2};
}
else if(st==1)
{
p=new double []{0,-4,8,3,-9};
}
else if(st==2)
{
p=new double []{-1,0,2,0,-1};
}
else
{
p=new double []{-5,2,8,-2,-3};
}
root4(p,re_root,im_root);
n=4;
}
else
{
p=new double []{0,2,0,1};
if(st==4)
{
p[1]=-p[1];
}
root3(p,re_root,im_root);
n=3;
}
System.err.println("======== n="+n);
for(int i=0;i<=n;i++)
{
if(i<n)
{
System.err.println(String.valueOf(i)+"\t"+
p[i]+"\t"+
re_root[i]+"\t"+
im_root[i]);
}
else
{
System.err.println(String.valueOf(i)+"\t"+p[i]+"\t");
}
}
}
}
public static void main(final String [] args)
{
final long t0=System.currentTimeMillis();
final double eps=1e-6;
//checkRoots();
final java.util.Random r=new java.util.Random(-1381923);
printSpecialValues();
final int n_tests=10000000;
//testRoots(2,n_tests,r,eps);
//testRoots(3,n_tests,r,eps);
testRoots(4,n_tests,r,eps);
final long t1=System.currentTimeMillis();
System.err.println("PolynomialRoot.main: "+n_tests+" tests OK done in "+(t1-t0)+" milliseconds. ver=$Id: PolynomialRoot.java,v 1.105 2012/08/18 00:00:05 mal Exp $");
}
}