Merge
This commit is contained in:
Lana Steuck
commit
170f727b62
2
.hgtags
2
.hgtags
@ -227,3 +227,5 @@ bbe43d712fe08e650808d774861b256ccb34e500 jdk8-b102
|
||||
30a1d677a20c6a95f98043d8f20ce570304e3818 jdk8-b103
|
||||
b5ed503c26ad38869c247c5e32debec217fd056b jdk8-b104
|
||||
589f4fdc584e373a47cde0162e9eceec9165c381 jdk8-b105
|
||||
514b0b69fb9683ef52062fd962a3e0644431f64d jdk8-b106
|
||||
892889f445755790ae90e61775bfb59ddc6182b5 jdk8-b107
|
||||
|
||||
@ -227,3 +227,5 @@ d2dcb110e9dbaf9903c05b211df800e78e4b394e jdk8-b100
|
||||
b7e64be81c8a7690703df5711f4fc2375da8a9cb jdk8-b103
|
||||
96c1b9b7524b52c3fcefc90ffad4c767396727c8 jdk8-b104
|
||||
5166118c59178b5d31001bc4058e92486ee07d9b jdk8-b105
|
||||
8e7b4d9fb00fdf1334376aeac050c9bca6d1b383 jdk8-b106
|
||||
0874bb4707b723d5bb108d379c557cf41529d1a7 jdk8-b107
|
||||
|
||||
12
Makefile
12
Makefile
@ -404,7 +404,6 @@ COMPILER_PATH.desc = Compiler install directory
|
||||
CACERTS_FILE.desc = Location of certificates file
|
||||
DEVTOOLS_PATH.desc = Directory containing zip and gnumake
|
||||
CUPS_HEADERS_PATH.desc = Include directory location for CUPS header files
|
||||
DXSDK_PATH.desc = Root directory of DirectX SDK
|
||||
|
||||
# Make variables to print out (description and value)
|
||||
VARIABLE_PRINTVAL_LIST += \
|
||||
@ -429,17 +428,6 @@ VARIABLE_CHECKDIR_LIST += \
|
||||
VARIABLE_CHECKFIL_LIST += \
|
||||
CACERTS_FILE
|
||||
|
||||
# Some are windows specific
|
||||
ifeq ($(PLATFORM), windows)
|
||||
|
||||
VARIABLE_PRINTVAL_LIST += \
|
||||
DXSDK_PATH
|
||||
|
||||
VARIABLE_CHECKDIR_LIST += \
|
||||
DXSDK_PATH
|
||||
|
||||
endif
|
||||
|
||||
# For pattern rules below, so all are treated the same
|
||||
DO_PRINTVAL_LIST=$(VARIABLE_PRINTVAL_LIST:%=%.printval)
|
||||
DO_CHECKDIR_LIST=$(VARIABLE_CHECKDIR_LIST:%=%.checkdir)
|
||||
|
||||
@ -444,10 +444,6 @@
|
||||
Install
|
||||
<a href="#vs2010">Visual Studio 2010</a>
|
||||
</li>
|
||||
<li>
|
||||
Install the
|
||||
<a href="#dxsdk">Microsoft DirectX SDK</a>
|
||||
</li>
|
||||
</ul>
|
||||
</td>
|
||||
<td>
|
||||
@ -971,25 +967,6 @@
|
||||
developer install location
|
||||
</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><b><code>--with-dxsdk=</code></b><i>path</i></td>
|
||||
<td>
|
||||
select location of the Windows Direct X SDK install
|
||||
<br>
|
||||
The <a name="dxsdk">Microsoft DirectX 9.0 SDK</a>
|
||||
header files and libraries
|
||||
from the Summer 2004 edition
|
||||
are required for building OpenJDK.
|
||||
This SDK can be downloaded from
|
||||
<a href="http://www.microsoft.com/downloads/details.aspx?FamilyId=FD044A42-9912-42A3-9A9E-D857199F888E&displaylang=en" target="_blank">
|
||||
Microsoft DirectX 9.0 SDK (Summer 2004)</a>.
|
||||
If the link above becomes obsolete, the SDK can be found from
|
||||
<a href="http://download.microsoft.com" target="_blank">the Microsoft Download Site</a>
|
||||
(search with "DirectX 9.0 SDK Update Summer 2004").
|
||||
Installation usually will set the environment variable
|
||||
<code>DXSDK_DIR</code> to it's install location.
|
||||
</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><b><code>--with-freetype=</code></b><i>path</i></td>
|
||||
<td>
|
||||
|
||||
@ -203,6 +203,15 @@ AC_DEFUN([BASIC_REMOVE_SYMBOLIC_LINKS],
|
||||
fi
|
||||
])
|
||||
|
||||
# Register a --with argument but mark it as deprecated
|
||||
# $1: The name of the with argument to deprecate, not including --with-
|
||||
AC_DEFUN([BASIC_DEPRECATED_ARG_WITH],
|
||||
[
|
||||
AC_ARG_WITH($1, [AS_HELP_STRING([--with-$1],
|
||||
[Deprecated. Option is kept for backwards compatibility and is ignored])],
|
||||
[AC_MSG_WARN([Option --with-$1 is deprecated and will be ignored.])])
|
||||
])
|
||||
|
||||
AC_DEFUN_ONCE([BASIC_INIT],
|
||||
[
|
||||
# Save the original command line. This is passed to us by the wrapper configure script.
|
||||
|
||||
@ -211,7 +211,7 @@ AC_DEFUN([BASIC_FIXUP_EXECUTABLE_CYGWIN],
|
||||
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
||||
# "foo.exe" is OK but "foo" is an error.
|
||||
#
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
||||
# It is also a way to make sure we got the proper file name for the real test later on.
|
||||
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
||||
if test "x$test_shortpath" = x; then
|
||||
|
||||
@ -26,10 +26,10 @@
|
||||
|
||||
# Attempt to guess a canonical system name.
|
||||
# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
|
||||
# 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
|
||||
# Free Software Foundation, Inc.
|
||||
# 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
|
||||
# 2011, 2012 Free Software Foundation, Inc.
|
||||
|
||||
timestamp='2008-01-23'
|
||||
timestamp='2012-02-10'
|
||||
|
||||
# This file is free software; you can redistribute it and/or modify it
|
||||
# under the terms of the GNU General Public License as published by
|
||||
@ -42,9 +42,7 @@ timestamp='2008-01-23'
|
||||
# General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program; if not, write to the Free Software
|
||||
# Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
|
||||
# 02110-1301, USA.
|
||||
# along with this program; if not, see <http://www.gnu.org/licenses/>.
|
||||
#
|
||||
# As a special exception to the GNU General Public License, if you
|
||||
# distribute this file as part of a program that contains a
|
||||
@ -52,16 +50,16 @@ timestamp='2008-01-23'
|
||||
# the same distribution terms that you use for the rest of that program.
|
||||
|
||||
|
||||
# Originally written by Per Bothner <per@bothner.com>.
|
||||
# Please send patches to <config-patches@gnu.org>. Submit a context
|
||||
# diff and a properly formatted ChangeLog entry.
|
||||
# Originally written by Per Bothner. Please send patches (context
|
||||
# diff format) to <config-patches@gnu.org> and include a ChangeLog
|
||||
# entry.
|
||||
#
|
||||
# This script attempts to guess a canonical system name similar to
|
||||
# config.sub. If it succeeds, it prints the system name on stdout, and
|
||||
# exits with 0. Otherwise, it exits with 1.
|
||||
#
|
||||
# The plan is that this can be called by configure scripts if you
|
||||
# don't specify an explicit build system type.
|
||||
# You can get the latest version of this script from:
|
||||
# http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess;hb=HEAD
|
||||
|
||||
me=`echo "$0" | sed -e 's,.*/,,'`
|
||||
|
||||
@ -81,8 +79,9 @@ version="\
|
||||
GNU config.guess ($timestamp)
|
||||
|
||||
Originally written by Per Bothner.
|
||||
Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
|
||||
2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
|
||||
Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
|
||||
2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
|
||||
Free Software Foundation, Inc.
|
||||
|
||||
This is free software; see the source for copying conditions. There is NO
|
||||
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
|
||||
@ -169,7 +168,7 @@ UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown
|
||||
case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
|
||||
*:NetBSD:*:*)
|
||||
# NetBSD (nbsd) targets should (where applicable) match one or
|
||||
# more of the tupples: *-*-netbsdelf*, *-*-netbsdaout*,
|
||||
# more of the tuples: *-*-netbsdelf*, *-*-netbsdaout*,
|
||||
# *-*-netbsdecoff* and *-*-netbsd*. For targets that recently
|
||||
# switched to ELF, *-*-netbsd* would select the old
|
||||
# object file format. This provides both forward
|
||||
@ -195,7 +194,7 @@ case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
|
||||
arm*|i386|m68k|ns32k|sh3*|sparc|vax)
|
||||
eval $set_cc_for_build
|
||||
if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \
|
||||
| grep __ELF__ >/dev/null
|
||||
| grep -q __ELF__
|
||||
then
|
||||
# Once all utilities can be ECOFF (netbsdecoff) or a.out (netbsdaout).
|
||||
# Return netbsd for either. FIX?
|
||||
@ -205,7 +204,7 @@ case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
|
||||
fi
|
||||
;;
|
||||
*)
|
||||
os=netbsd
|
||||
os=netbsd
|
||||
;;
|
||||
esac
|
||||
# The OS release
|
||||
@ -248,7 +247,7 @@ case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
|
||||
UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'`
|
||||
;;
|
||||
*5.*)
|
||||
UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $4}'`
|
||||
UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $4}'`
|
||||
;;
|
||||
esac
|
||||
# According to Compaq, /usr/sbin/psrinfo has been available on
|
||||
@ -294,7 +293,10 @@ case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
|
||||
# A Xn.n version is an unreleased experimental baselevel.
|
||||
# 1.2 uses "1.2" for uname -r.
|
||||
echo ${UNAME_MACHINE}-dec-osf`echo ${UNAME_RELEASE} | sed -e 's/^[PVTX]//' | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
||||
exit ;;
|
||||
# Reset EXIT trap before exiting to avoid spurious non-zero exit code.
|
||||
exitcode=$?
|
||||
trap '' 0
|
||||
exit $exitcode ;;
|
||||
Alpha\ *:Windows_NT*:*)
|
||||
# How do we know it's Interix rather than the generic POSIX subsystem?
|
||||
# Should we change UNAME_MACHINE based on the output of uname instead
|
||||
@ -320,7 +322,7 @@ case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
|
||||
echo s390-ibm-zvmoe
|
||||
exit ;;
|
||||
*:OS400:*:*)
|
||||
echo powerpc-ibm-os400
|
||||
echo powerpc-ibm-os400
|
||||
exit ;;
|
||||
arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*)
|
||||
echo arm-acorn-riscix${UNAME_RELEASE}
|
||||
@ -349,14 +351,33 @@ case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
|
||||
case `/usr/bin/uname -p` in
|
||||
sparc) echo sparc-icl-nx7; exit ;;
|
||||
esac ;;
|
||||
s390x:SunOS:*:*)
|
||||
echo ${UNAME_MACHINE}-ibm-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
|
||||
exit ;;
|
||||
sun4H:SunOS:5.*:*)
|
||||
echo sparc-hal-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
|
||||
exit ;;
|
||||
sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*)
|
||||
echo sparc-sun-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
|
||||
exit ;;
|
||||
i86pc:AuroraUX:5.*:* | i86xen:AuroraUX:5.*:*)
|
||||
echo i386-pc-auroraux${UNAME_RELEASE}
|
||||
exit ;;
|
||||
i86pc:SunOS:5.*:* | i86xen:SunOS:5.*:*)
|
||||
echo i386-pc-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
|
||||
eval $set_cc_for_build
|
||||
SUN_ARCH="i386"
|
||||
# If there is a compiler, see if it is configured for 64-bit objects.
|
||||
# Note that the Sun cc does not turn __LP64__ into 1 like gcc does.
|
||||
# This test works for both compilers.
|
||||
if [ "$CC_FOR_BUILD" != 'no_compiler_found' ]; then
|
||||
if (echo '#ifdef __amd64'; echo IS_64BIT_ARCH; echo '#endif') | \
|
||||
(CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | \
|
||||
grep IS_64BIT_ARCH >/dev/null
|
||||
then
|
||||
SUN_ARCH="x86_64"
|
||||
fi
|
||||
fi
|
||||
echo ${SUN_ARCH}-pc-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
|
||||
exit ;;
|
||||
sun4*:SunOS:6*:*)
|
||||
# According to config.sub, this is the proper way to canonicalize
|
||||
@ -400,23 +421,23 @@ case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
|
||||
# MiNT. But MiNT is downward compatible to TOS, so this should
|
||||
# be no problem.
|
||||
atarist[e]:*MiNT:*:* | atarist[e]:*mint:*:* | atarist[e]:*TOS:*:*)
|
||||
echo m68k-atari-mint${UNAME_RELEASE}
|
||||
echo m68k-atari-mint${UNAME_RELEASE}
|
||||
exit ;;
|
||||
atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*)
|
||||
echo m68k-atari-mint${UNAME_RELEASE}
|
||||
exit ;;
|
||||
exit ;;
|
||||
*falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*)
|
||||
echo m68k-atari-mint${UNAME_RELEASE}
|
||||
echo m68k-atari-mint${UNAME_RELEASE}
|
||||
exit ;;
|
||||
milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*)
|
||||
echo m68k-milan-mint${UNAME_RELEASE}
|
||||
exit ;;
|
||||
echo m68k-milan-mint${UNAME_RELEASE}
|
||||
exit ;;
|
||||
hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*)
|
||||
echo m68k-hades-mint${UNAME_RELEASE}
|
||||
exit ;;
|
||||
echo m68k-hades-mint${UNAME_RELEASE}
|
||||
exit ;;
|
||||
*:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*)
|
||||
echo m68k-unknown-mint${UNAME_RELEASE}
|
||||
exit ;;
|
||||
echo m68k-unknown-mint${UNAME_RELEASE}
|
||||
exit ;;
|
||||
m68k:machten:*:*)
|
||||
echo m68k-apple-machten${UNAME_RELEASE}
|
||||
exit ;;
|
||||
@ -486,8 +507,8 @@ EOF
|
||||
echo m88k-motorola-sysv3
|
||||
exit ;;
|
||||
AViiON:dgux:*:*)
|
||||
# DG/UX returns AViiON for all architectures
|
||||
UNAME_PROCESSOR=`/usr/bin/uname -p`
|
||||
# DG/UX returns AViiON for all architectures
|
||||
UNAME_PROCESSOR=`/usr/bin/uname -p`
|
||||
if [ $UNAME_PROCESSOR = mc88100 ] || [ $UNAME_PROCESSOR = mc88110 ]
|
||||
then
|
||||
if [ ${TARGET_BINARY_INTERFACE}x = m88kdguxelfx ] || \
|
||||
@ -500,7 +521,7 @@ EOF
|
||||
else
|
||||
echo i586-dg-dgux${UNAME_RELEASE}
|
||||
fi
|
||||
exit ;;
|
||||
exit ;;
|
||||
M88*:DolphinOS:*:*) # DolphinOS (SVR3)
|
||||
echo m88k-dolphin-sysv3
|
||||
exit ;;
|
||||
@ -557,7 +578,7 @@ EOF
|
||||
echo rs6000-ibm-aix3.2
|
||||
fi
|
||||
exit ;;
|
||||
*:AIX:*:[456])
|
||||
*:AIX:*:[4567])
|
||||
IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }'`
|
||||
if /usr/sbin/lsattr -El ${IBM_CPU_ID} | grep ' POWER' >/dev/null 2>&1; then
|
||||
IBM_ARCH=rs6000
|
||||
@ -600,52 +621,52 @@ EOF
|
||||
9000/[678][0-9][0-9])
|
||||
if [ -x /usr/bin/getconf ]; then
|
||||
sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null`
|
||||
sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null`
|
||||
case "${sc_cpu_version}" in
|
||||
523) HP_ARCH="hppa1.0" ;; # CPU_PA_RISC1_0
|
||||
528) HP_ARCH="hppa1.1" ;; # CPU_PA_RISC1_1
|
||||
532) # CPU_PA_RISC2_0
|
||||
case "${sc_kernel_bits}" in
|
||||
32) HP_ARCH="hppa2.0n" ;;
|
||||
64) HP_ARCH="hppa2.0w" ;;
|
||||
sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null`
|
||||
case "${sc_cpu_version}" in
|
||||
523) HP_ARCH="hppa1.0" ;; # CPU_PA_RISC1_0
|
||||
528) HP_ARCH="hppa1.1" ;; # CPU_PA_RISC1_1
|
||||
532) # CPU_PA_RISC2_0
|
||||
case "${sc_kernel_bits}" in
|
||||
32) HP_ARCH="hppa2.0n" ;;
|
||||
64) HP_ARCH="hppa2.0w" ;;
|
||||
'') HP_ARCH="hppa2.0" ;; # HP-UX 10.20
|
||||
esac ;;
|
||||
esac
|
||||
esac ;;
|
||||
esac
|
||||
fi
|
||||
if [ "${HP_ARCH}" = "" ]; then
|
||||
eval $set_cc_for_build
|
||||
sed 's/^ //' << EOF >$dummy.c
|
||||
sed 's/^ //' << EOF >$dummy.c
|
||||
|
||||
#define _HPUX_SOURCE
|
||||
#include <stdlib.h>
|
||||
#include <unistd.h>
|
||||
#define _HPUX_SOURCE
|
||||
#include <stdlib.h>
|
||||
#include <unistd.h>
|
||||
|
||||
int main ()
|
||||
{
|
||||
#if defined(_SC_KERNEL_BITS)
|
||||
long bits = sysconf(_SC_KERNEL_BITS);
|
||||
#endif
|
||||
long cpu = sysconf (_SC_CPU_VERSION);
|
||||
int main ()
|
||||
{
|
||||
#if defined(_SC_KERNEL_BITS)
|
||||
long bits = sysconf(_SC_KERNEL_BITS);
|
||||
#endif
|
||||
long cpu = sysconf (_SC_CPU_VERSION);
|
||||
|
||||
switch (cpu)
|
||||
{
|
||||
case CPU_PA_RISC1_0: puts ("hppa1.0"); break;
|
||||
case CPU_PA_RISC1_1: puts ("hppa1.1"); break;
|
||||
case CPU_PA_RISC2_0:
|
||||
#if defined(_SC_KERNEL_BITS)
|
||||
switch (bits)
|
||||
{
|
||||
case 64: puts ("hppa2.0w"); break;
|
||||
case 32: puts ("hppa2.0n"); break;
|
||||
default: puts ("hppa2.0"); break;
|
||||
} break;
|
||||
#else /* !defined(_SC_KERNEL_BITS) */
|
||||
puts ("hppa2.0"); break;
|
||||
#endif
|
||||
default: puts ("hppa1.0"); break;
|
||||
}
|
||||
exit (0);
|
||||
}
|
||||
switch (cpu)
|
||||
{
|
||||
case CPU_PA_RISC1_0: puts ("hppa1.0"); break;
|
||||
case CPU_PA_RISC1_1: puts ("hppa1.1"); break;
|
||||
case CPU_PA_RISC2_0:
|
||||
#if defined(_SC_KERNEL_BITS)
|
||||
switch (bits)
|
||||
{
|
||||
case 64: puts ("hppa2.0w"); break;
|
||||
case 32: puts ("hppa2.0n"); break;
|
||||
default: puts ("hppa2.0"); break;
|
||||
} break;
|
||||
#else /* !defined(_SC_KERNEL_BITS) */
|
||||
puts ("hppa2.0"); break;
|
||||
#endif
|
||||
default: puts ("hppa1.0"); break;
|
||||
}
|
||||
exit (0);
|
||||
}
|
||||
EOF
|
||||
(CCOPTS= $CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null) && HP_ARCH=`$dummy`
|
||||
test -z "$HP_ARCH" && HP_ARCH=hppa
|
||||
@ -665,7 +686,7 @@ EOF
|
||||
# => hppa64-hp-hpux11.23
|
||||
|
||||
if echo __LP64__ | (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) |
|
||||
grep __LP64__ >/dev/null
|
||||
grep -q __LP64__
|
||||
then
|
||||
HP_ARCH="hppa2.0w"
|
||||
else
|
||||
@ -736,22 +757,22 @@ EOF
|
||||
exit ;;
|
||||
C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*)
|
||||
echo c1-convex-bsd
|
||||
exit ;;
|
||||
exit ;;
|
||||
C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*)
|
||||
if getsysinfo -f scalar_acc
|
||||
then echo c32-convex-bsd
|
||||
else echo c2-convex-bsd
|
||||
fi
|
||||
exit ;;
|
||||
exit ;;
|
||||
C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*)
|
||||
echo c34-convex-bsd
|
||||
exit ;;
|
||||
exit ;;
|
||||
C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*)
|
||||
echo c38-convex-bsd
|
||||
exit ;;
|
||||
exit ;;
|
||||
C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*)
|
||||
echo c4-convex-bsd
|
||||
exit ;;
|
||||
exit ;;
|
||||
CRAY*Y-MP:*:*:*)
|
||||
echo ymp-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
|
||||
exit ;;
|
||||
@ -775,14 +796,14 @@ EOF
|
||||
exit ;;
|
||||
F30[01]:UNIX_System_V:*:* | F700:UNIX_System_V:*:*)
|
||||
FUJITSU_PROC=`uname -m | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
||||
FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'`
|
||||
FUJITSU_REL=`echo ${UNAME_RELEASE} | sed -e 's/ /_/'`
|
||||
echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
|
||||
exit ;;
|
||||
FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'`
|
||||
FUJITSU_REL=`echo ${UNAME_RELEASE} | sed -e 's/ /_/'`
|
||||
echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
|
||||
exit ;;
|
||||
5000:UNIX_System_V:4.*:*)
|
||||
FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'`
|
||||
FUJITSU_REL=`echo ${UNAME_RELEASE} | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/ /_/'`
|
||||
echo "sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
|
||||
FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'`
|
||||
FUJITSU_REL=`echo ${UNAME_RELEASE} | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/ /_/'`
|
||||
echo "sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
|
||||
exit ;;
|
||||
i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*)
|
||||
echo ${UNAME_MACHINE}-pc-bsdi${UNAME_RELEASE}
|
||||
@ -794,13 +815,12 @@ EOF
|
||||
echo ${UNAME_MACHINE}-unknown-bsdi${UNAME_RELEASE}
|
||||
exit ;;
|
||||
*:FreeBSD:*:*)
|
||||
case ${UNAME_MACHINE} in
|
||||
pc98)
|
||||
echo i386-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;;
|
||||
UNAME_PROCESSOR=`/usr/bin/uname -p`
|
||||
case ${UNAME_PROCESSOR} in
|
||||
amd64)
|
||||
echo x86_64-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;;
|
||||
*)
|
||||
echo ${UNAME_MACHINE}-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;;
|
||||
echo ${UNAME_PROCESSOR}-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;;
|
||||
esac
|
||||
exit ;;
|
||||
i*:CYGWIN*:*)
|
||||
@ -809,19 +829,22 @@ EOF
|
||||
*:MINGW*:*)
|
||||
echo ${UNAME_MACHINE}-pc-mingw32
|
||||
exit ;;
|
||||
i*:MSYS*:*)
|
||||
echo ${UNAME_MACHINE}-pc-msys
|
||||
exit ;;
|
||||
i*:windows32*:*)
|
||||
# uname -m includes "-pc" on this system.
|
||||
echo ${UNAME_MACHINE}-mingw32
|
||||
# uname -m includes "-pc" on this system.
|
||||
echo ${UNAME_MACHINE}-mingw32
|
||||
exit ;;
|
||||
i*:PW*:*)
|
||||
echo ${UNAME_MACHINE}-pc-pw32
|
||||
exit ;;
|
||||
*:Interix*:[3456]*)
|
||||
case ${UNAME_MACHINE} in
|
||||
*:Interix*:*)
|
||||
case ${UNAME_MACHINE} in
|
||||
x86)
|
||||
echo i586-pc-interix${UNAME_RELEASE}
|
||||
exit ;;
|
||||
EM64T | authenticamd)
|
||||
authenticamd | genuineintel | EM64T)
|
||||
echo x86_64-unknown-interix${UNAME_RELEASE}
|
||||
exit ;;
|
||||
IA64)
|
||||
@ -831,6 +854,9 @@ EOF
|
||||
[345]86:Windows_95:* | [345]86:Windows_98:* | [345]86:Windows_NT:*)
|
||||
echo i${UNAME_MACHINE}-pc-mks
|
||||
exit ;;
|
||||
8664:Windows_NT:*)
|
||||
echo x86_64-pc-mks
|
||||
exit ;;
|
||||
i*:Windows_NT*:* | Pentium*:Windows_NT*:*)
|
||||
# How do we know it's Interix rather than the generic POSIX subsystem?
|
||||
# It also conflicts with pre-2.0 versions of AT&T UWIN. Should we
|
||||
@ -860,92 +886,13 @@ EOF
|
||||
i*86:Minix:*:*)
|
||||
echo ${UNAME_MACHINE}-pc-minix
|
||||
exit ;;
|
||||
arm*:Linux:*:*)
|
||||
eval $set_cc_for_build
|
||||
if echo __ARM_EABI__ | $CC_FOR_BUILD -E - 2>/dev/null \
|
||||
| grep -q __ARM_EABI__
|
||||
then
|
||||
echo ${UNAME_MACHINE}-unknown-linux-gnu
|
||||
else
|
||||
echo ${UNAME_MACHINE}-unknown-linux-gnueabi
|
||||
fi
|
||||
exit ;;
|
||||
avr32*:Linux:*:*)
|
||||
aarch64:Linux:*:*)
|
||||
echo ${UNAME_MACHINE}-unknown-linux-gnu
|
||||
exit ;;
|
||||
cris:Linux:*:*)
|
||||
echo cris-axis-linux-gnu
|
||||
exit ;;
|
||||
crisv32:Linux:*:*)
|
||||
echo crisv32-axis-linux-gnu
|
||||
exit ;;
|
||||
frv:Linux:*:*)
|
||||
echo frv-unknown-linux-gnu
|
||||
exit ;;
|
||||
ia64:Linux:*:*)
|
||||
aarch64_be:Linux:*:*)
|
||||
UNAME_MACHINE=aarch64_be
|
||||
echo ${UNAME_MACHINE}-unknown-linux-gnu
|
||||
exit ;;
|
||||
m32r*:Linux:*:*)
|
||||
echo ${UNAME_MACHINE}-unknown-linux-gnu
|
||||
exit ;;
|
||||
m68*:Linux:*:*)
|
||||
echo ${UNAME_MACHINE}-unknown-linux-gnu
|
||||
exit ;;
|
||||
mips:Linux:*:*)
|
||||
eval $set_cc_for_build
|
||||
sed 's/^ //' << EOF >$dummy.c
|
||||
#undef CPU
|
||||
#undef mips
|
||||
#undef mipsel
|
||||
#if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL)
|
||||
CPU=mipsel
|
||||
#else
|
||||
#if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB)
|
||||
CPU=mips
|
||||
#else
|
||||
CPU=
|
||||
#endif
|
||||
#endif
|
||||
EOF
|
||||
eval "`$CC_FOR_BUILD -E $dummy.c 2>/dev/null | sed -n '
|
||||
/^CPU/{
|
||||
s: ::g
|
||||
p
|
||||
}'`"
|
||||
test x"${CPU}" != x && { echo "${CPU}-unknown-linux-gnu"; exit; }
|
||||
;;
|
||||
mips64:Linux:*:*)
|
||||
eval $set_cc_for_build
|
||||
sed 's/^ //' << EOF >$dummy.c
|
||||
#undef CPU
|
||||
#undef mips64
|
||||
#undef mips64el
|
||||
#if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL)
|
||||
CPU=mips64el
|
||||
#else
|
||||
#if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB)
|
||||
CPU=mips64
|
||||
#else
|
||||
CPU=
|
||||
#endif
|
||||
#endif
|
||||
EOF
|
||||
eval "`$CC_FOR_BUILD -E $dummy.c 2>/dev/null | sed -n '
|
||||
/^CPU/{
|
||||
s: ::g
|
||||
p
|
||||
}'`"
|
||||
test x"${CPU}" != x && { echo "${CPU}-unknown-linux-gnu"; exit; }
|
||||
;;
|
||||
or32:Linux:*:*)
|
||||
echo or32-unknown-linux-gnu
|
||||
exit ;;
|
||||
ppc:Linux:*:*)
|
||||
echo powerpc-unknown-linux-gnu
|
||||
exit ;;
|
||||
ppc64:Linux:*:*)
|
||||
echo powerpc64-unknown-linux-gnu
|
||||
exit ;;
|
||||
alpha:Linux:*:*)
|
||||
case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' < /proc/cpuinfo` in
|
||||
EV5) UNAME_MACHINE=alphaev5 ;;
|
||||
@ -955,11 +902,90 @@ EOF
|
||||
EV6) UNAME_MACHINE=alphaev6 ;;
|
||||
EV67) UNAME_MACHINE=alphaev67 ;;
|
||||
EV68*) UNAME_MACHINE=alphaev68 ;;
|
||||
esac
|
||||
objdump --private-headers /bin/sh | grep ld.so.1 >/dev/null
|
||||
esac
|
||||
objdump --private-headers /bin/sh | grep -q ld.so.1
|
||||
if test "$?" = 0 ; then LIBC="libc1" ; else LIBC="" ; fi
|
||||
echo ${UNAME_MACHINE}-unknown-linux-gnu${LIBC}
|
||||
exit ;;
|
||||
arm*:Linux:*:*)
|
||||
eval $set_cc_for_build
|
||||
if echo __ARM_EABI__ | $CC_FOR_BUILD -E - 2>/dev/null \
|
||||
| grep -q __ARM_EABI__
|
||||
then
|
||||
echo ${UNAME_MACHINE}-unknown-linux-gnu
|
||||
else
|
||||
if echo __ARM_PCS_VFP | $CC_FOR_BUILD -E - 2>/dev/null \
|
||||
| grep -q __ARM_PCS_VFP
|
||||
then
|
||||
echo ${UNAME_MACHINE}-unknown-linux-gnueabi
|
||||
else
|
||||
echo ${UNAME_MACHINE}-unknown-linux-gnueabihf
|
||||
fi
|
||||
fi
|
||||
exit ;;
|
||||
avr32*:Linux:*:*)
|
||||
echo ${UNAME_MACHINE}-unknown-linux-gnu
|
||||
exit ;;
|
||||
cris:Linux:*:*)
|
||||
echo ${UNAME_MACHINE}-axis-linux-gnu
|
||||
exit ;;
|
||||
crisv32:Linux:*:*)
|
||||
echo ${UNAME_MACHINE}-axis-linux-gnu
|
||||
exit ;;
|
||||
frv:Linux:*:*)
|
||||
echo ${UNAME_MACHINE}-unknown-linux-gnu
|
||||
exit ;;
|
||||
hexagon:Linux:*:*)
|
||||
echo ${UNAME_MACHINE}-unknown-linux-gnu
|
||||
exit ;;
|
||||
i*86:Linux:*:*)
|
||||
LIBC=gnu
|
||||
eval $set_cc_for_build
|
||||
sed 's/^ //' << EOF >$dummy.c
|
||||
#ifdef __dietlibc__
|
||||
LIBC=dietlibc
|
||||
#endif
|
||||
EOF
|
||||
eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep '^LIBC'`
|
||||
echo "${UNAME_MACHINE}-pc-linux-${LIBC}"
|
||||
exit ;;
|
||||
ia64:Linux:*:*)
|
||||
echo ${UNAME_MACHINE}-unknown-linux-gnu
|
||||
exit ;;
|
||||
m32r*:Linux:*:*)
|
||||
echo ${UNAME_MACHINE}-unknown-linux-gnu
|
||||
exit ;;
|
||||
m68*:Linux:*:*)
|
||||
echo ${UNAME_MACHINE}-unknown-linux-gnu
|
||||
exit ;;
|
||||
mips:Linux:*:* | mips64:Linux:*:*)
|
||||
eval $set_cc_for_build
|
||||
sed 's/^ //' << EOF >$dummy.c
|
||||
#undef CPU
|
||||
#undef ${UNAME_MACHINE}
|
||||
#undef ${UNAME_MACHINE}el
|
||||
#if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL)
|
||||
CPU=${UNAME_MACHINE}el
|
||||
#else
|
||||
#if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB)
|
||||
CPU=${UNAME_MACHINE}
|
||||
#else
|
||||
CPU=
|
||||
#endif
|
||||
#endif
|
||||
EOF
|
||||
eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep '^CPU'`
|
||||
test x"${CPU}" != x && { echo "${CPU}-unknown-linux-gnu"; exit; }
|
||||
;;
|
||||
or32:Linux:*:*)
|
||||
echo ${UNAME_MACHINE}-unknown-linux-gnu
|
||||
exit ;;
|
||||
padre:Linux:*:*)
|
||||
echo sparc-unknown-linux-gnu
|
||||
exit ;;
|
||||
parisc64:Linux:*:* | hppa64:Linux:*:*)
|
||||
echo hppa64-unknown-linux-gnu
|
||||
exit ;;
|
||||
parisc:Linux:*:* | hppa:Linux:*:*)
|
||||
# Look for CPU level
|
||||
case `grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2` in
|
||||
@ -968,14 +994,17 @@ EOF
|
||||
*) echo hppa-unknown-linux-gnu ;;
|
||||
esac
|
||||
exit ;;
|
||||
parisc64:Linux:*:* | hppa64:Linux:*:*)
|
||||
echo hppa64-unknown-linux-gnu
|
||||
ppc64:Linux:*:*)
|
||||
echo powerpc64-unknown-linux-gnu
|
||||
exit ;;
|
||||
ppc:Linux:*:*)
|
||||
echo powerpc-unknown-linux-gnu
|
||||
exit ;;
|
||||
s390:Linux:*:* | s390x:Linux:*:*)
|
||||
echo ${UNAME_MACHINE}-ibm-linux
|
||||
exit ;;
|
||||
sh64*:Linux:*:*)
|
||||
echo ${UNAME_MACHINE}-unknown-linux-gnu
|
||||
echo ${UNAME_MACHINE}-unknown-linux-gnu
|
||||
exit ;;
|
||||
sh*:Linux:*:*)
|
||||
echo ${UNAME_MACHINE}-unknown-linux-gnu
|
||||
@ -983,78 +1012,18 @@ EOF
|
||||
sparc:Linux:*:* | sparc64:Linux:*:*)
|
||||
echo ${UNAME_MACHINE}-unknown-linux-gnu
|
||||
exit ;;
|
||||
tile*:Linux:*:*)
|
||||
echo ${UNAME_MACHINE}-unknown-linux-gnu
|
||||
exit ;;
|
||||
vax:Linux:*:*)
|
||||
echo ${UNAME_MACHINE}-dec-linux-gnu
|
||||
exit ;;
|
||||
x86_64:Linux:*:*)
|
||||
echo x86_64-unknown-linux-gnu
|
||||
echo ${UNAME_MACHINE}-unknown-linux-gnu
|
||||
exit ;;
|
||||
xtensa*:Linux:*:*)
|
||||
echo ${UNAME_MACHINE}-unknown-linux-gnu
|
||||
echo ${UNAME_MACHINE}-unknown-linux-gnu
|
||||
exit ;;
|
||||
i*86:Linux:*:*)
|
||||
# The BFD linker knows what the default object file format is, so
|
||||
# first see if it will tell us. cd to the root directory to prevent
|
||||
# problems with other programs or directories called `ld' in the path.
|
||||
# Set LC_ALL=C to ensure ld outputs messages in English.
|
||||
ld_supported_targets=`cd /; LC_ALL=C ld --help 2>&1 \
|
||||
| sed -ne '/supported targets:/!d
|
||||
s/[ ][ ]*/ /g
|
||||
s/.*supported targets: *//
|
||||
s/ .*//
|
||||
p'`
|
||||
case "$ld_supported_targets" in
|
||||
elf32-i386)
|
||||
TENTATIVE="${UNAME_MACHINE}-pc-linux-gnu"
|
||||
;;
|
||||
a.out-i386-linux)
|
||||
echo "${UNAME_MACHINE}-pc-linux-gnuaout"
|
||||
exit ;;
|
||||
coff-i386)
|
||||
echo "${UNAME_MACHINE}-pc-linux-gnucoff"
|
||||
exit ;;
|
||||
"")
|
||||
# Either a pre-BFD a.out linker (linux-gnuoldld) or
|
||||
# one that does not give us useful --help.
|
||||
echo "${UNAME_MACHINE}-pc-linux-gnuoldld"
|
||||
exit ;;
|
||||
esac
|
||||
# Determine whether the default compiler is a.out or elf
|
||||
eval $set_cc_for_build
|
||||
sed 's/^ //' << EOF >$dummy.c
|
||||
#include <features.h>
|
||||
#ifdef __ELF__
|
||||
# ifdef __GLIBC__
|
||||
# if __GLIBC__ >= 2
|
||||
LIBC=gnu
|
||||
# else
|
||||
LIBC=gnulibc1
|
||||
# endif
|
||||
# else
|
||||
LIBC=gnulibc1
|
||||
# endif
|
||||
#else
|
||||
#if defined(__INTEL_COMPILER) || defined(__PGI) || defined(__SUNPRO_C) || defined(__SUNPRO_CC)
|
||||
LIBC=gnu
|
||||
#else
|
||||
LIBC=gnuaout
|
||||
#endif
|
||||
#endif
|
||||
#ifdef __dietlibc__
|
||||
LIBC=dietlibc
|
||||
#endif
|
||||
EOF
|
||||
eval "`$CC_FOR_BUILD -E $dummy.c 2>/dev/null | sed -n '
|
||||
/^LIBC/{
|
||||
s: ::g
|
||||
p
|
||||
}'`"
|
||||
test x"${LIBC}" != x && {
|
||||
echo "${UNAME_MACHINE}-pc-linux-${LIBC}"
|
||||
exit
|
||||
}
|
||||
test x"${TENTATIVE}" != x && { echo "${TENTATIVE}"; exit; }
|
||||
;;
|
||||
i*86:DYNIX/ptx:4*:*)
|
||||
# ptx 4.0 does uname -s correctly, with DYNIX/ptx in there.
|
||||
# earlier versions are messed up and put the nodename in both
|
||||
@ -1062,11 +1031,11 @@ EOF
|
||||
echo i386-sequent-sysv4
|
||||
exit ;;
|
||||
i*86:UNIX_SV:4.2MP:2.*)
|
||||
# Unixware is an offshoot of SVR4, but it has its own version
|
||||
# number series starting with 2...
|
||||
# I am not positive that other SVR4 systems won't match this,
|
||||
# Unixware is an offshoot of SVR4, but it has its own version
|
||||
# number series starting with 2...
|
||||
# I am not positive that other SVR4 systems won't match this,
|
||||
# I just have to hope. -- rms.
|
||||
# Use sysv4.2uw... so that sysv4* matches it.
|
||||
# Use sysv4.2uw... so that sysv4* matches it.
|
||||
echo ${UNAME_MACHINE}-pc-sysv4.2uw${UNAME_VERSION}
|
||||
exit ;;
|
||||
i*86:OS/2:*:*)
|
||||
@ -1083,7 +1052,7 @@ EOF
|
||||
i*86:syllable:*:*)
|
||||
echo ${UNAME_MACHINE}-pc-syllable
|
||||
exit ;;
|
||||
i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.0*:*)
|
||||
i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.[02]*:*)
|
||||
echo i386-unknown-lynxos${UNAME_RELEASE}
|
||||
exit ;;
|
||||
i*86:*DOS:*:*)
|
||||
@ -1098,7 +1067,7 @@ EOF
|
||||
fi
|
||||
exit ;;
|
||||
i*86:*:5:[678]*)
|
||||
# UnixWare 7.x, OpenUNIX and OpenServer 6.
|
||||
# UnixWare 7.x, OpenUNIX and OpenServer 6.
|
||||
case `/bin/uname -X | grep "^Machine"` in
|
||||
*486*) UNAME_MACHINE=i486 ;;
|
||||
*Pentium) UNAME_MACHINE=i586 ;;
|
||||
@ -1126,10 +1095,13 @@ EOF
|
||||
exit ;;
|
||||
pc:*:*:*)
|
||||
# Left here for compatibility:
|
||||
# uname -m prints for DJGPP always 'pc', but it prints nothing about
|
||||
# the processor, so we play safe by assuming i386.
|
||||
echo i386-pc-msdosdjgpp
|
||||
exit ;;
|
||||
# uname -m prints for DJGPP always 'pc', but it prints nothing about
|
||||
# the processor, so we play safe by assuming i586.
|
||||
# Note: whatever this is, it MUST be the same as what config.sub
|
||||
# prints for the "djgpp" host, or else GDB configury will decide that
|
||||
# this is a cross-build.
|
||||
echo i586-pc-msdosdjgpp
|
||||
exit ;;
|
||||
Intel:Mach:3*:*)
|
||||
echo i386-pc-mach3
|
||||
exit ;;
|
||||
@ -1164,8 +1136,18 @@ EOF
|
||||
/bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \
|
||||
&& { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;;
|
||||
3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*)
|
||||
/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
|
||||
&& { echo i486-ncr-sysv4; exit; } ;;
|
||||
/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
|
||||
&& { echo i486-ncr-sysv4; exit; } ;;
|
||||
NCR*:*:4.2:* | MPRAS*:*:4.2:*)
|
||||
OS_REL='.3'
|
||||
test -r /etc/.relid \
|
||||
&& OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid`
|
||||
/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
|
||||
&& { echo i486-ncr-sysv4.3${OS_REL}; exit; }
|
||||
/bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \
|
||||
&& { echo i586-ncr-sysv4.3${OS_REL}; exit; }
|
||||
/bin/uname -p 2>/dev/null | /bin/grep pteron >/dev/null \
|
||||
&& { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;;
|
||||
m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*)
|
||||
echo m68k-unknown-lynxos${UNAME_RELEASE}
|
||||
exit ;;
|
||||
@ -1178,7 +1160,7 @@ EOF
|
||||
rs6000:LynxOS:2.*:*)
|
||||
echo rs6000-unknown-lynxos${UNAME_RELEASE}
|
||||
exit ;;
|
||||
PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.0*:*)
|
||||
PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.[02]*:*)
|
||||
echo powerpc-unknown-lynxos${UNAME_RELEASE}
|
||||
exit ;;
|
||||
SM[BE]S:UNIX_SV:*:*)
|
||||
@ -1198,10 +1180,10 @@ EOF
|
||||
echo ns32k-sni-sysv
|
||||
fi
|
||||
exit ;;
|
||||
PENTIUM:*:4.0*:*) # Unisys `ClearPath HMP IX 4000' SVR4/MP effort
|
||||
# says <Richard.M.Bartel@ccMail.Census.GOV>
|
||||
echo i586-unisys-sysv4
|
||||
exit ;;
|
||||
PENTIUM:*:4.0*:*) # Unisys `ClearPath HMP IX 4000' SVR4/MP effort
|
||||
# says <Richard.M.Bartel@ccMail.Census.GOV>
|
||||
echo i586-unisys-sysv4
|
||||
exit ;;
|
||||
*:UNIX_System_V:4*:FTX*)
|
||||
# From Gerald Hewes <hewes@openmarket.com>.
|
||||
# How about differentiating between stratus architectures? -djm
|
||||
@ -1227,11 +1209,11 @@ EOF
|
||||
exit ;;
|
||||
R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*)
|
||||
if [ -d /usr/nec ]; then
|
||||
echo mips-nec-sysv${UNAME_RELEASE}
|
||||
echo mips-nec-sysv${UNAME_RELEASE}
|
||||
else
|
||||
echo mips-unknown-sysv${UNAME_RELEASE}
|
||||
echo mips-unknown-sysv${UNAME_RELEASE}
|
||||
fi
|
||||
exit ;;
|
||||
exit ;;
|
||||
BeBox:BeOS:*:*) # BeOS running on hardware made by Be, PPC only.
|
||||
echo powerpc-be-beos
|
||||
exit ;;
|
||||
@ -1241,6 +1223,9 @@ EOF
|
||||
BePC:BeOS:*:*) # BeOS running on Intel PC compatible.
|
||||
echo i586-pc-beos
|
||||
exit ;;
|
||||
BePC:Haiku:*:*) # Haiku running on Intel PC compatible.
|
||||
echo i586-pc-haiku
|
||||
exit ;;
|
||||
SX-4:SUPER-UX:*:*)
|
||||
echo sx4-nec-superux${UNAME_RELEASE}
|
||||
exit ;;
|
||||
@ -1267,12 +1252,17 @@ EOF
|
||||
exit ;;
|
||||
*:Darwin:*:*)
|
||||
UNAME_PROCESSOR=`uname -p` || UNAME_PROCESSOR=unknown
|
||||
eval $set_cc_for_build
|
||||
echo "int main(){}" > $dummy.c
|
||||
if test "`$CC_FOR_BUILD -o $dummy $dummy.c; file $dummy | grep -c x86_64`" = 1 ; then
|
||||
UNAME_PROCESSOR=x86_64
|
||||
fi
|
||||
case $UNAME_PROCESSOR in
|
||||
i386)
|
||||
eval $set_cc_for_build
|
||||
if [ "$CC_FOR_BUILD" != 'no_compiler_found' ]; then
|
||||
if (echo '#ifdef __LP64__'; echo IS_64BIT_ARCH; echo '#endif') | \
|
||||
(CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | \
|
||||
grep IS_64BIT_ARCH >/dev/null
|
||||
then
|
||||
UNAME_PROCESSOR="x86_64"
|
||||
fi
|
||||
fi ;;
|
||||
unknown) UNAME_PROCESSOR=powerpc ;;
|
||||
esac
|
||||
echo ${UNAME_PROCESSOR}-apple-darwin${UNAME_RELEASE}
|
||||
@ -1288,6 +1278,9 @@ EOF
|
||||
*:QNX:*:4*)
|
||||
echo i386-pc-qnx
|
||||
exit ;;
|
||||
NEO-?:NONSTOP_KERNEL:*:*)
|
||||
echo neo-tandem-nsk${UNAME_RELEASE}
|
||||
exit ;;
|
||||
NSE-?:NONSTOP_KERNEL:*:*)
|
||||
echo nse-tandem-nsk${UNAME_RELEASE}
|
||||
exit ;;
|
||||
@ -1333,13 +1326,13 @@ EOF
|
||||
echo pdp10-unknown-its
|
||||
exit ;;
|
||||
SEI:*:*:SEIUX)
|
||||
echo mips-sei-seiux${UNAME_RELEASE}
|
||||
echo mips-sei-seiux${UNAME_RELEASE}
|
||||
exit ;;
|
||||
*:DragonFly:*:*)
|
||||
echo ${UNAME_MACHINE}-unknown-dragonfly`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`
|
||||
exit ;;
|
||||
*:*VMS:*:*)
|
||||
UNAME_MACHINE=`(uname -p) 2>/dev/null`
|
||||
UNAME_MACHINE=`(uname -p) 2>/dev/null`
|
||||
case "${UNAME_MACHINE}" in
|
||||
A*) echo alpha-dec-vms ; exit ;;
|
||||
I*) echo ia64-dec-vms ; exit ;;
|
||||
@ -1354,6 +1347,12 @@ EOF
|
||||
i*86:rdos:*:*)
|
||||
echo ${UNAME_MACHINE}-pc-rdos
|
||||
exit ;;
|
||||
i*86:AROS:*:*)
|
||||
echo ${UNAME_MACHINE}-pc-aros
|
||||
exit ;;
|
||||
x86_64:VMkernel:*:*)
|
||||
echo ${UNAME_MACHINE}-unknown-esx
|
||||
exit ;;
|
||||
esac
|
||||
|
||||
#echo '(No uname command or uname output not recognized.)' 1>&2
|
||||
@ -1376,11 +1375,11 @@ main ()
|
||||
#include <sys/param.h>
|
||||
printf ("m68k-sony-newsos%s\n",
|
||||
#ifdef NEWSOS4
|
||||
"4"
|
||||
"4"
|
||||
#else
|
||||
""
|
||||
""
|
||||
#endif
|
||||
); exit (0);
|
||||
); exit (0);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
5
common/autoconf/configure
vendored
5
common/autoconf/configure
vendored
@ -219,9 +219,4 @@ else
|
||||
echo configure exiting with result code $conf_result_code
|
||||
fi
|
||||
|
||||
# Move the log file to the output root, if this was successfully created
|
||||
if test -d "$OUTPUT_ROOT"; then
|
||||
mv -f config.log "$OUTPUT_ROOT" 2> /dev/null
|
||||
fi
|
||||
|
||||
exit $conf_result_code
|
||||
|
||||
@ -232,9 +232,15 @@ CUSTOM_LATE_HOOK
|
||||
# We're messing a bit with internal autoconf variables to put the config.status
|
||||
# in the output directory instead of the current directory.
|
||||
CONFIG_STATUS="$OUTPUT_ROOT/config.status"
|
||||
|
||||
# Create the actual output files. Now the main work of configure is done.
|
||||
AC_OUTPUT
|
||||
|
||||
# Try to move the config.log file to the output directory.
|
||||
if test -e ./config.log; then
|
||||
$MV -f ./config.log "$OUTPUT_ROOT/config.log" 2> /dev/null
|
||||
fi
|
||||
|
||||
# Make the compare script executable
|
||||
$CHMOD +x $OUTPUT_ROOT/compare.sh
|
||||
|
||||
|
||||
@ -709,7 +709,6 @@ STATIC_LIBRARY
|
||||
SHARED_LIBRARY
|
||||
OBJ_SUFFIX
|
||||
COMPILER_NAME
|
||||
TARGET_BITS_FLAG
|
||||
JT_HOME
|
||||
JTREGEXE
|
||||
LIPO
|
||||
@ -766,8 +765,6 @@ BUILD_LD
|
||||
BUILD_CXX
|
||||
BUILD_CC
|
||||
MSVCR_DLL
|
||||
DXSDK_INCLUDE_PATH
|
||||
DXSDK_LIB_PATH
|
||||
VS_PATH
|
||||
VS_LIB
|
||||
VS_INCLUDE
|
||||
@ -1031,6 +1028,7 @@ with_override_corba
|
||||
with_override_jaxp
|
||||
with_override_jaxws
|
||||
with_override_hotspot
|
||||
with_override_nashorn
|
||||
with_override_jdk
|
||||
with_import_hotspot
|
||||
with_msvcr_dll
|
||||
@ -1784,17 +1782,19 @@ Optional Packages:
|
||||
--with-override-jaxp use this jaxp dir for the build
|
||||
--with-override-jaxws use this jaxws dir for the build
|
||||
--with-override-hotspot use this hotspot dir for the build
|
||||
--with-override-nashorn use this nashorn dir for the build
|
||||
--with-override-jdk use this jdk dir for the build
|
||||
--with-import-hotspot import hotspot binaries from this jdk image or
|
||||
hotspot build dist dir instead of building from
|
||||
source
|
||||
--with-msvcr-dll copy this msvcr100.dll into the built JDK (Windows
|
||||
only) [probed]
|
||||
--with-dxsdk the DirectX SDK (Windows only) [probed]
|
||||
--with-dxsdk-lib the DirectX SDK lib directory (Windows only)
|
||||
[probed]
|
||||
--with-dxsdk-include the DirectX SDK include directory (Windows only)
|
||||
[probed]
|
||||
--with-dxsdk Deprecated. Option is kept for backwards
|
||||
compatibility and is ignored
|
||||
--with-dxsdk-lib Deprecated. Option is kept for backwards
|
||||
compatibility and is ignored
|
||||
--with-dxsdk-include Deprecated. Option is kept for backwards
|
||||
compatibility and is ignored
|
||||
--with-jtreg Regression Test Harness [probed]
|
||||
--with-extra-cflags extra flags to be used when compiling jdk c-files
|
||||
--with-extra-cxxflags extra flags to be used when compiling jdk c++-files
|
||||
@ -3144,6 +3144,10 @@ ac_configure="$SHELL $ac_aux_dir/configure" # Please don't use this var.
|
||||
|
||||
|
||||
|
||||
# Register a --with argument but mark it as deprecated
|
||||
# $1: The name of the with argument to deprecate, not including --with-
|
||||
|
||||
|
||||
|
||||
|
||||
# Test that variable $1 denoting a program is not empty. If empty, exit with an error.
|
||||
@ -3805,10 +3809,6 @@ fi
|
||||
|
||||
|
||||
|
||||
# Setup the DXSDK paths
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@ -3818,7 +3818,7 @@ fi
|
||||
#CUSTOM_AUTOCONF_INCLUDE
|
||||
|
||||
# Do not change or remove the following line, it is needed for consistency checks:
|
||||
DATE_WHEN_GENERATED=1377850299
|
||||
DATE_WHEN_GENERATED=1379504921
|
||||
|
||||
###############################################################################
|
||||
#
|
||||
@ -6775,6 +6775,18 @@ test -n "$target_alias" &&
|
||||
VAR_CPU_BITS=64
|
||||
VAR_CPU_ENDIAN=big
|
||||
;;
|
||||
s390)
|
||||
VAR_CPU=s390
|
||||
VAR_CPU_ARCH=s390
|
||||
VAR_CPU_BITS=32
|
||||
VAR_CPU_ENDIAN=big
|
||||
;;
|
||||
s390x)
|
||||
VAR_CPU=s390x
|
||||
VAR_CPU_ARCH=s390
|
||||
VAR_CPU_BITS=64
|
||||
VAR_CPU_ENDIAN=big
|
||||
;;
|
||||
sparc)
|
||||
VAR_CPU=sparc
|
||||
VAR_CPU_ARCH=sparc
|
||||
@ -6883,6 +6895,18 @@ $as_echo "$OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&6; }
|
||||
VAR_CPU_BITS=64
|
||||
VAR_CPU_ENDIAN=big
|
||||
;;
|
||||
s390)
|
||||
VAR_CPU=s390
|
||||
VAR_CPU_ARCH=s390
|
||||
VAR_CPU_BITS=32
|
||||
VAR_CPU_ENDIAN=big
|
||||
;;
|
||||
s390x)
|
||||
VAR_CPU=s390x
|
||||
VAR_CPU_ARCH=s390
|
||||
VAR_CPU_BITS=64
|
||||
VAR_CPU_ENDIAN=big
|
||||
;;
|
||||
sparc)
|
||||
VAR_CPU=sparc
|
||||
VAR_CPU_ARCH=sparc
|
||||
@ -8328,7 +8352,7 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
|
||||
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
||||
# "foo.exe" is OK but "foo" is an error.
|
||||
#
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
||||
# It is also a way to make sure we got the proper file name for the real test later on.
|
||||
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
||||
if test "x$test_shortpath" = x; then
|
||||
@ -8685,7 +8709,7 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
|
||||
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
||||
# "foo.exe" is OK but "foo" is an error.
|
||||
#
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
||||
# It is also a way to make sure we got the proper file name for the real test later on.
|
||||
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
||||
if test "x$test_shortpath" = x; then
|
||||
@ -9039,7 +9063,7 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
|
||||
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
||||
# "foo.exe" is OK but "foo" is an error.
|
||||
#
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
||||
# It is also a way to make sure we got the proper file name for the real test later on.
|
||||
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
||||
if test "x$test_shortpath" = x; then
|
||||
@ -9398,7 +9422,7 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
|
||||
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
||||
# "foo.exe" is OK but "foo" is an error.
|
||||
#
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
||||
# It is also a way to make sure we got the proper file name for the real test later on.
|
||||
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
||||
if test "x$test_shortpath" = x; then
|
||||
@ -9751,7 +9775,7 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
|
||||
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
||||
# "foo.exe" is OK but "foo" is an error.
|
||||
#
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
||||
# It is also a way to make sure we got the proper file name for the real test later on.
|
||||
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
||||
if test "x$test_shortpath" = x; then
|
||||
@ -11051,7 +11075,7 @@ elif test "x$with_user_release_suffix" != x; then
|
||||
else
|
||||
BUILD_DATE=`date '+%Y_%m_%d_%H_%M'`
|
||||
# Avoid [:alnum:] since it depends on the locale.
|
||||
CLEAN_USERNAME=`echo "$USER" | $TR -d -c 'abcdefghijklmnopqrstuvqxyz0123456789'`
|
||||
CLEAN_USERNAME=`echo "$USER" | $TR -d -c 'abcdefghijklmnopqrstuvqxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'`
|
||||
USER_RELEASE_SUFFIX=`echo "${CLEAN_USERNAME}_${BUILD_DATE}" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
||||
fi
|
||||
|
||||
@ -16078,6 +16102,10 @@ if test "x$with_add_source_root" != x; then
|
||||
test -f $with_add_source_root/hotspot/make/Makefile; then
|
||||
as_fn_error $? "Your add source root seems to contain a full hotspot repo! An add source root should only contain additional sources." "$LINENO" 5
|
||||
fi
|
||||
if test -f $with_add_source_root/nashorn/makefiles/Makefile || \
|
||||
test -f $with_add_source_root/nashorn/make/Makefile; then
|
||||
as_fn_error $? "Your add source root seems to contain a full nashorn repo! An add source root should only contain additional sources." "$LINENO" 5
|
||||
fi
|
||||
if test -f $with_add_source_root/jdk/makefiles/Makefile || \
|
||||
test -f $with_add_source_root/jdk/make/Makefile; then
|
||||
as_fn_error $? "Your add source root seems to contain a full JDK repo! An add source root should only contain additional sources." "$LINENO" 5
|
||||
@ -16113,6 +16141,10 @@ if test "x$with_override_source_root" != x; then
|
||||
test -f $with_override_source_root/hotspot/make/Makefile; then
|
||||
as_fn_error $? "Your override source root seems to contain a full hotspot repo! An override source root should only contain sources that override." "$LINENO" 5
|
||||
fi
|
||||
if test -f $with_override_source_root/nashorn/makefiles/Makefile || \
|
||||
test -f $with_override_source_root/nashorn/make/Makefile; then
|
||||
as_fn_error $? "Your override source root seems to contain a full nashorn repo! An override source root should only contain sources that override." "$LINENO" 5
|
||||
fi
|
||||
if test -f $with_override_source_root/jdk/makefiles/Makefile || \
|
||||
test -f $with_override_source_root/jdk/make/Makefile; then
|
||||
as_fn_error $? "Your override source root seems to contain a full JDK repo! An override source root should only contain sources that override." "$LINENO" 5
|
||||
@ -16175,6 +16207,13 @@ fi
|
||||
|
||||
|
||||
|
||||
# Check whether --with-override-nashorn was given.
|
||||
if test "${with_override_nashorn+set}" = set; then :
|
||||
withval=$with_override_nashorn;
|
||||
fi
|
||||
|
||||
|
||||
|
||||
# Check whether --with-override-jdk was given.
|
||||
if test "${with_override_jdk+set}" = set; then :
|
||||
withval=$with_override_jdk;
|
||||
@ -16252,7 +16291,7 @@ if test "x$with_override_nashorn" != x; then
|
||||
cd "$with_override_nashorn"
|
||||
NASHORN_TOPDIR="`pwd`"
|
||||
cd "$CURDIR"
|
||||
if ! test -f $NASHORN_TOPDIR/makefiles/BuildNashorn.gmk; then
|
||||
if ! test -f $NASHORN_TOPDIR/makefiles/Makefile; then
|
||||
as_fn_error $? "You have to override nashorn with a full nashorn repo!" "$LINENO" 5
|
||||
fi
|
||||
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if nashorn should be overridden" >&5
|
||||
@ -17062,7 +17101,7 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
|
||||
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
||||
# "foo.exe" is OK but "foo" is an error.
|
||||
#
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
||||
# It is also a way to make sure we got the proper file name for the real test later on.
|
||||
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
||||
if test "x$test_shortpath" = x; then
|
||||
@ -17562,437 +17601,29 @@ $as_echo "$as_me: The path of MSVCR_DLL, which resolves as \"$path\", is invalid
|
||||
|
||||
# Check whether --with-dxsdk was given.
|
||||
if test "${with_dxsdk+set}" = set; then :
|
||||
withval=$with_dxsdk;
|
||||
withval=$with_dxsdk; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-dxsdk is deprecated and will be ignored." >&5
|
||||
$as_echo "$as_me: WARNING: Option --with-dxsdk is deprecated and will be ignored." >&2;}
|
||||
fi
|
||||
|
||||
|
||||
|
||||
|
||||
# Check whether --with-dxsdk-lib was given.
|
||||
if test "${with_dxsdk_lib+set}" = set; then :
|
||||
withval=$with_dxsdk_lib;
|
||||
withval=$with_dxsdk_lib; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-dxsdk-lib is deprecated and will be ignored." >&5
|
||||
$as_echo "$as_me: WARNING: Option --with-dxsdk-lib is deprecated and will be ignored." >&2;}
|
||||
fi
|
||||
|
||||
|
||||
|
||||
|
||||
# Check whether --with-dxsdk-include was given.
|
||||
if test "${with_dxsdk_include+set}" = set; then :
|
||||
withval=$with_dxsdk_include;
|
||||
withval=$with_dxsdk_include; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-dxsdk-include is deprecated and will be ignored." >&5
|
||||
$as_echo "$as_me: WARNING: Option --with-dxsdk-include is deprecated and will be ignored." >&2;}
|
||||
fi
|
||||
|
||||
|
||||
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for DirectX SDK" >&5
|
||||
$as_echo_n "checking for DirectX SDK... " >&6; }
|
||||
|
||||
if test "x$with_dxsdk" != x; then
|
||||
dxsdk_path="$with_dxsdk"
|
||||
elif test "x$DXSDK_DIR" != x; then
|
||||
dxsdk_path="$DXSDK_DIR"
|
||||
elif test -d "C:/DXSDK"; then
|
||||
dxsdk_path="C:/DXSDK"
|
||||
else
|
||||
as_fn_error $? "Could not find the DirectX SDK" "$LINENO" 5
|
||||
fi
|
||||
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $dxsdk_path" >&5
|
||||
$as_echo "$dxsdk_path" >&6; }
|
||||
|
||||
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
||||
|
||||
# Input might be given as Windows format, start by converting to
|
||||
# unix format.
|
||||
path="$dxsdk_path"
|
||||
new_path=`$CYGPATH -u "$path"`
|
||||
|
||||
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
||||
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
||||
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
||||
# "foo.exe" is OK but "foo" is an error.
|
||||
#
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
||||
# It is also a way to make sure we got the proper file name for the real test later on.
|
||||
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
||||
if test "x$test_shortpath" = x; then
|
||||
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of dxsdk_path, which resolves as \"$path\", is invalid." >&5
|
||||
$as_echo "$as_me: The path of dxsdk_path, which resolves as \"$path\", is invalid." >&6;}
|
||||
as_fn_error $? "Cannot locate the the path of dxsdk_path" "$LINENO" 5
|
||||
fi
|
||||
|
||||
# Call helper function which possibly converts this using DOS-style short mode.
|
||||
# If so, the updated path is stored in $new_path.
|
||||
|
||||
input_path="$new_path"
|
||||
# Check if we need to convert this using DOS-style short mode. If the path
|
||||
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
||||
# take no chances and rewrite it.
|
||||
# Note: m4 eats our [], so we need to use [ and ] instead.
|
||||
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
||||
if test "x$has_forbidden_chars" != x; then
|
||||
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
||||
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
||||
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
||||
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
||||
# Going to short mode and back again did indeed matter. Since short mode is
|
||||
# case insensitive, let's make it lowercase to improve readability.
|
||||
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
||||
# Now convert it back to Unix-stile (cygpath)
|
||||
input_path=`$CYGPATH -u "$shortmode_path"`
|
||||
new_path="$input_path"
|
||||
fi
|
||||
fi
|
||||
|
||||
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
||||
if test "x$test_cygdrive_prefix" = x; then
|
||||
# As a simple fix, exclude /usr/bin since it's not a real path.
|
||||
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
||||
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
||||
# a path prefixed by /cygdrive for fixpath to work.
|
||||
new_path="$CYGWIN_ROOT_PATH$input_path"
|
||||
fi
|
||||
fi
|
||||
|
||||
|
||||
if test "x$path" != "x$new_path"; then
|
||||
dxsdk_path="$new_path"
|
||||
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting dxsdk_path to \"$new_path\"" >&5
|
||||
$as_echo "$as_me: Rewriting dxsdk_path to \"$new_path\"" >&6;}
|
||||
fi
|
||||
|
||||
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
||||
|
||||
path="$dxsdk_path"
|
||||
has_colon=`$ECHO $path | $GREP ^.:`
|
||||
new_path="$path"
|
||||
if test "x$has_colon" = x; then
|
||||
# Not in mixed or Windows style, start by that.
|
||||
new_path=`cmd //c echo $path`
|
||||
fi
|
||||
|
||||
|
||||
input_path="$new_path"
|
||||
# Check if we need to convert this using DOS-style short mode. If the path
|
||||
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
||||
# take no chances and rewrite it.
|
||||
# Note: m4 eats our [], so we need to use [ and ] instead.
|
||||
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
||||
if test "x$has_forbidden_chars" != x; then
|
||||
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
||||
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
||||
fi
|
||||
|
||||
|
||||
windows_path="$new_path"
|
||||
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
||||
unix_path=`$CYGPATH -u "$windows_path"`
|
||||
new_path="$unix_path"
|
||||
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
||||
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
||||
new_path="$unix_path"
|
||||
fi
|
||||
|
||||
if test "x$path" != "x$new_path"; then
|
||||
dxsdk_path="$new_path"
|
||||
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting dxsdk_path to \"$new_path\"" >&5
|
||||
$as_echo "$as_me: Rewriting dxsdk_path to \"$new_path\"" >&6;}
|
||||
fi
|
||||
|
||||
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
||||
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
||||
|
||||
else
|
||||
# We're on a posix platform. Hooray! :)
|
||||
path="$dxsdk_path"
|
||||
has_space=`$ECHO "$path" | $GREP " "`
|
||||
if test "x$has_space" != x; then
|
||||
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of dxsdk_path, which resolves as \"$path\", is invalid." >&5
|
||||
$as_echo "$as_me: The path of dxsdk_path, which resolves as \"$path\", is invalid." >&6;}
|
||||
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
||||
fi
|
||||
|
||||
# Use eval to expand a potential ~
|
||||
eval path="$path"
|
||||
if test ! -f "$path" && test ! -d "$path"; then
|
||||
as_fn_error $? "The path of dxsdk_path, which resolves as \"$path\", is not found." "$LINENO" 5
|
||||
fi
|
||||
|
||||
dxsdk_path="`cd "$path"; $THEPWDCMD -L`"
|
||||
fi
|
||||
|
||||
|
||||
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for DirectX SDK lib dir" >&5
|
||||
$as_echo_n "checking for DirectX SDK lib dir... " >&6; }
|
||||
if test "x$with_dxsdk_lib" != x; then
|
||||
DXSDK_LIB_PATH="$with_dxsdk_lib"
|
||||
elif test "x$OPENJDK_TARGET_CPU" = "xx86_64"; then
|
||||
DXSDK_LIB_PATH="$dxsdk_path/Lib/x64"
|
||||
else
|
||||
DXSDK_LIB_PATH="$dxsdk_path/Lib"
|
||||
fi
|
||||
# dsound.lib is linked to in jsoundds
|
||||
if test ! -f "$DXSDK_LIB_PATH/dsound.lib"; then
|
||||
as_fn_error $? "Invalid DirectX SDK lib dir" "$LINENO" 5
|
||||
fi
|
||||
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $DXSDK_LIB_PATH" >&5
|
||||
$as_echo "$DXSDK_LIB_PATH" >&6; }
|
||||
|
||||
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
||||
|
||||
# Input might be given as Windows format, start by converting to
|
||||
# unix format.
|
||||
path="$DXSDK_LIB_PATH"
|
||||
new_path=`$CYGPATH -u "$path"`
|
||||
|
||||
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
||||
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
||||
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
||||
# "foo.exe" is OK but "foo" is an error.
|
||||
#
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
||||
# It is also a way to make sure we got the proper file name for the real test later on.
|
||||
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
||||
if test "x$test_shortpath" = x; then
|
||||
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of DXSDK_LIB_PATH, which resolves as \"$path\", is invalid." >&5
|
||||
$as_echo "$as_me: The path of DXSDK_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
|
||||
as_fn_error $? "Cannot locate the the path of DXSDK_LIB_PATH" "$LINENO" 5
|
||||
fi
|
||||
|
||||
# Call helper function which possibly converts this using DOS-style short mode.
|
||||
# If so, the updated path is stored in $new_path.
|
||||
|
||||
input_path="$new_path"
|
||||
# Check if we need to convert this using DOS-style short mode. If the path
|
||||
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
||||
# take no chances and rewrite it.
|
||||
# Note: m4 eats our [], so we need to use [ and ] instead.
|
||||
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
||||
if test "x$has_forbidden_chars" != x; then
|
||||
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
||||
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
||||
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
||||
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
||||
# Going to short mode and back again did indeed matter. Since short mode is
|
||||
# case insensitive, let's make it lowercase to improve readability.
|
||||
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
||||
# Now convert it back to Unix-stile (cygpath)
|
||||
input_path=`$CYGPATH -u "$shortmode_path"`
|
||||
new_path="$input_path"
|
||||
fi
|
||||
fi
|
||||
|
||||
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
||||
if test "x$test_cygdrive_prefix" = x; then
|
||||
# As a simple fix, exclude /usr/bin since it's not a real path.
|
||||
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
||||
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
||||
# a path prefixed by /cygdrive for fixpath to work.
|
||||
new_path="$CYGWIN_ROOT_PATH$input_path"
|
||||
fi
|
||||
fi
|
||||
|
||||
|
||||
if test "x$path" != "x$new_path"; then
|
||||
DXSDK_LIB_PATH="$new_path"
|
||||
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting DXSDK_LIB_PATH to \"$new_path\"" >&5
|
||||
$as_echo "$as_me: Rewriting DXSDK_LIB_PATH to \"$new_path\"" >&6;}
|
||||
fi
|
||||
|
||||
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
||||
|
||||
path="$DXSDK_LIB_PATH"
|
||||
has_colon=`$ECHO $path | $GREP ^.:`
|
||||
new_path="$path"
|
||||
if test "x$has_colon" = x; then
|
||||
# Not in mixed or Windows style, start by that.
|
||||
new_path=`cmd //c echo $path`
|
||||
fi
|
||||
|
||||
|
||||
input_path="$new_path"
|
||||
# Check if we need to convert this using DOS-style short mode. If the path
|
||||
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
||||
# take no chances and rewrite it.
|
||||
# Note: m4 eats our [], so we need to use [ and ] instead.
|
||||
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
||||
if test "x$has_forbidden_chars" != x; then
|
||||
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
||||
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
||||
fi
|
||||
|
||||
|
||||
windows_path="$new_path"
|
||||
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
||||
unix_path=`$CYGPATH -u "$windows_path"`
|
||||
new_path="$unix_path"
|
||||
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
||||
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
||||
new_path="$unix_path"
|
||||
fi
|
||||
|
||||
if test "x$path" != "x$new_path"; then
|
||||
DXSDK_LIB_PATH="$new_path"
|
||||
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting DXSDK_LIB_PATH to \"$new_path\"" >&5
|
||||
$as_echo "$as_me: Rewriting DXSDK_LIB_PATH to \"$new_path\"" >&6;}
|
||||
fi
|
||||
|
||||
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
||||
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
||||
|
||||
else
|
||||
# We're on a posix platform. Hooray! :)
|
||||
path="$DXSDK_LIB_PATH"
|
||||
has_space=`$ECHO "$path" | $GREP " "`
|
||||
if test "x$has_space" != x; then
|
||||
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of DXSDK_LIB_PATH, which resolves as \"$path\", is invalid." >&5
|
||||
$as_echo "$as_me: The path of DXSDK_LIB_PATH, which resolves as \"$path\", is invalid." >&6;}
|
||||
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
||||
fi
|
||||
|
||||
# Use eval to expand a potential ~
|
||||
eval path="$path"
|
||||
if test ! -f "$path" && test ! -d "$path"; then
|
||||
as_fn_error $? "The path of DXSDK_LIB_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
|
||||
fi
|
||||
|
||||
DXSDK_LIB_PATH="`cd "$path"; $THEPWDCMD -L`"
|
||||
fi
|
||||
|
||||
|
||||
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for DirectX SDK include dir" >&5
|
||||
$as_echo_n "checking for DirectX SDK include dir... " >&6; }
|
||||
if test "x$with_dxsdk_include" != x; then
|
||||
DXSDK_INCLUDE_PATH="$with_dxsdk_include"
|
||||
else
|
||||
DXSDK_INCLUDE_PATH="$dxsdk_path/Include"
|
||||
fi
|
||||
# dsound.h is included in jsoundds
|
||||
if test ! -f "$DXSDK_INCLUDE_PATH/dsound.h"; then
|
||||
as_fn_error $? "Invalid DirectX SDK lib dir" "$LINENO" 5
|
||||
fi
|
||||
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $DXSDK_INCLUDE_PATH" >&5
|
||||
$as_echo "$DXSDK_INCLUDE_PATH" >&6; }
|
||||
|
||||
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
||||
|
||||
# Input might be given as Windows format, start by converting to
|
||||
# unix format.
|
||||
path="$DXSDK_INCLUDE_PATH"
|
||||
new_path=`$CYGPATH -u "$path"`
|
||||
|
||||
# Cygwin tries to hide some aspects of the Windows file system, such that binaries are
|
||||
# named .exe but called without that suffix. Therefore, "foo" and "foo.exe" are considered
|
||||
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
||||
# "foo.exe" is OK but "foo" is an error.
|
||||
#
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
||||
# It is also a way to make sure we got the proper file name for the real test later on.
|
||||
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
||||
if test "x$test_shortpath" = x; then
|
||||
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of DXSDK_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
|
||||
$as_echo "$as_me: The path of DXSDK_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
|
||||
as_fn_error $? "Cannot locate the the path of DXSDK_INCLUDE_PATH" "$LINENO" 5
|
||||
fi
|
||||
|
||||
# Call helper function which possibly converts this using DOS-style short mode.
|
||||
# If so, the updated path is stored in $new_path.
|
||||
|
||||
input_path="$new_path"
|
||||
# Check if we need to convert this using DOS-style short mode. If the path
|
||||
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
||||
# take no chances and rewrite it.
|
||||
# Note: m4 eats our [], so we need to use [ and ] instead.
|
||||
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-._/a-zA-Z0-9]`
|
||||
if test "x$has_forbidden_chars" != x; then
|
||||
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
||||
shortmode_path=`$CYGPATH -s -m -a "$input_path"`
|
||||
path_after_shortmode=`$CYGPATH -u "$shortmode_path"`
|
||||
if test "x$path_after_shortmode" != "x$input_to_shortpath"; then
|
||||
# Going to short mode and back again did indeed matter. Since short mode is
|
||||
# case insensitive, let's make it lowercase to improve readability.
|
||||
shortmode_path=`$ECHO "$shortmode_path" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
||||
# Now convert it back to Unix-stile (cygpath)
|
||||
input_path=`$CYGPATH -u "$shortmode_path"`
|
||||
new_path="$input_path"
|
||||
fi
|
||||
fi
|
||||
|
||||
test_cygdrive_prefix=`$ECHO $input_path | $GREP ^/cygdrive/`
|
||||
if test "x$test_cygdrive_prefix" = x; then
|
||||
# As a simple fix, exclude /usr/bin since it's not a real path.
|
||||
if test "x`$ECHO $new_path | $GREP ^/usr/bin/`" = x; then
|
||||
# The path is in a Cygwin special directory (e.g. /home). We need this converted to
|
||||
# a path prefixed by /cygdrive for fixpath to work.
|
||||
new_path="$CYGWIN_ROOT_PATH$input_path"
|
||||
fi
|
||||
fi
|
||||
|
||||
|
||||
if test "x$path" != "x$new_path"; then
|
||||
DXSDK_INCLUDE_PATH="$new_path"
|
||||
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting DXSDK_INCLUDE_PATH to \"$new_path\"" >&5
|
||||
$as_echo "$as_me: Rewriting DXSDK_INCLUDE_PATH to \"$new_path\"" >&6;}
|
||||
fi
|
||||
|
||||
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
||||
|
||||
path="$DXSDK_INCLUDE_PATH"
|
||||
has_colon=`$ECHO $path | $GREP ^.:`
|
||||
new_path="$path"
|
||||
if test "x$has_colon" = x; then
|
||||
# Not in mixed or Windows style, start by that.
|
||||
new_path=`cmd //c echo $path`
|
||||
fi
|
||||
|
||||
|
||||
input_path="$new_path"
|
||||
# Check if we need to convert this using DOS-style short mode. If the path
|
||||
# contains just simple characters, use it. Otherwise (spaces, weird characters),
|
||||
# take no chances and rewrite it.
|
||||
# Note: m4 eats our [], so we need to use [ and ] instead.
|
||||
has_forbidden_chars=`$ECHO "$input_path" | $GREP [^-_/:a-zA-Z0-9]`
|
||||
if test "x$has_forbidden_chars" != x; then
|
||||
# Now convert it to mixed DOS-style, short mode (no spaces, and / instead of \)
|
||||
new_path=`cmd /c "for %A in (\"$input_path\") do @echo %~sA"|$TR \\\\\\\\ / | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
||||
fi
|
||||
|
||||
|
||||
windows_path="$new_path"
|
||||
if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
|
||||
unix_path=`$CYGPATH -u "$windows_path"`
|
||||
new_path="$unix_path"
|
||||
elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
|
||||
unix_path=`$ECHO "$windows_path" | $SED -e 's,^\\(.\\):,/\\1,g' -e 's,\\\\,/,g'`
|
||||
new_path="$unix_path"
|
||||
fi
|
||||
|
||||
if test "x$path" != "x$new_path"; then
|
||||
DXSDK_INCLUDE_PATH="$new_path"
|
||||
{ $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting DXSDK_INCLUDE_PATH to \"$new_path\"" >&5
|
||||
$as_echo "$as_me: Rewriting DXSDK_INCLUDE_PATH to \"$new_path\"" >&6;}
|
||||
fi
|
||||
|
||||
# Save the first 10 bytes of this path to the storage, so fixpath can work.
|
||||
all_fixpath_prefixes=("${all_fixpath_prefixes[@]}" "${new_path:0:10}")
|
||||
|
||||
else
|
||||
# We're on a posix platform. Hooray! :)
|
||||
path="$DXSDK_INCLUDE_PATH"
|
||||
has_space=`$ECHO "$path" | $GREP " "`
|
||||
if test "x$has_space" != x; then
|
||||
{ $as_echo "$as_me:${as_lineno-$LINENO}: The path of DXSDK_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&5
|
||||
$as_echo "$as_me: The path of DXSDK_INCLUDE_PATH, which resolves as \"$path\", is invalid." >&6;}
|
||||
as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
|
||||
fi
|
||||
|
||||
# Use eval to expand a potential ~
|
||||
eval path="$path"
|
||||
if test ! -f "$path" && test ! -d "$path"; then
|
||||
as_fn_error $? "The path of DXSDK_INCLUDE_PATH, which resolves as \"$path\", is not found." "$LINENO" 5
|
||||
fi
|
||||
|
||||
DXSDK_INCLUDE_PATH="`cd "$path"; $THEPWDCMD -L`"
|
||||
fi
|
||||
|
||||
|
||||
|
||||
|
||||
LDFLAGS_JDK="$LDFLAGS_JDK -libpath:$DXSDK_LIB_PATH"
|
||||
|
||||
fi
|
||||
|
||||
|
||||
@ -18116,7 +17747,7 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
|
||||
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
||||
# "foo.exe" is OK but "foo" is an error.
|
||||
#
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
||||
# It is also a way to make sure we got the proper file name for the real test later on.
|
||||
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
||||
if test "x$test_shortpath" = x; then
|
||||
@ -18427,7 +18058,7 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
|
||||
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
||||
# "foo.exe" is OK but "foo" is an error.
|
||||
#
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
||||
# It is also a way to make sure we got the proper file name for the real test later on.
|
||||
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
||||
if test "x$test_shortpath" = x; then
|
||||
@ -18733,7 +18364,7 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
|
||||
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
||||
# "foo.exe" is OK but "foo" is an error.
|
||||
#
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
||||
# It is also a way to make sure we got the proper file name for the real test later on.
|
||||
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
||||
if test "x$test_shortpath" = x; then
|
||||
@ -19326,7 +18957,7 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
|
||||
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
||||
# "foo.exe" is OK but "foo" is an error.
|
||||
#
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
||||
# It is also a way to make sure we got the proper file name for the real test later on.
|
||||
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
||||
if test "x$test_shortpath" = x; then
|
||||
@ -19762,7 +19393,7 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
|
||||
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
||||
# "foo.exe" is OK but "foo" is an error.
|
||||
#
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
||||
# It is also a way to make sure we got the proper file name for the real test later on.
|
||||
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
||||
if test "x$test_shortpath" = x; then
|
||||
@ -20898,7 +20529,7 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
|
||||
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
||||
# "foo.exe" is OK but "foo" is an error.
|
||||
#
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
||||
# It is also a way to make sure we got the proper file name for the real test later on.
|
||||
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
||||
if test "x$test_shortpath" = x; then
|
||||
@ -21334,7 +20965,7 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
|
||||
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
||||
# "foo.exe" is OK but "foo" is an error.
|
||||
#
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
||||
# It is also a way to make sure we got the proper file name for the real test later on.
|
||||
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
||||
if test "x$test_shortpath" = x; then
|
||||
@ -22235,7 +21866,7 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
|
||||
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
||||
# "foo.exe" is OK but "foo" is an error.
|
||||
#
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
||||
# It is also a way to make sure we got the proper file name for the real test later on.
|
||||
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
||||
if test "x$test_shortpath" = x; then
|
||||
@ -22616,7 +22247,7 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
|
||||
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
||||
# "foo.exe" is OK but "foo" is an error.
|
||||
#
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
||||
# It is also a way to make sure we got the proper file name for the real test later on.
|
||||
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
||||
if test "x$test_shortpath" = x; then
|
||||
@ -22963,7 +22594,7 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
|
||||
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
||||
# "foo.exe" is OK but "foo" is an error.
|
||||
#
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
||||
# It is also a way to make sure we got the proper file name for the real test later on.
|
||||
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
||||
if test "x$test_shortpath" = x; then
|
||||
@ -23300,7 +22931,7 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
|
||||
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
||||
# "foo.exe" is OK but "foo" is an error.
|
||||
#
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
||||
# It is also a way to make sure we got the proper file name for the real test later on.
|
||||
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
||||
if test "x$test_shortpath" = x; then
|
||||
@ -23621,7 +23252,7 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
|
||||
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
||||
# "foo.exe" is OK but "foo" is an error.
|
||||
#
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
||||
# It is also a way to make sure we got the proper file name for the real test later on.
|
||||
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
||||
if test "x$test_shortpath" = x; then
|
||||
@ -23996,7 +23627,7 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
|
||||
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
||||
# "foo.exe" is OK but "foo" is an error.
|
||||
#
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
||||
# It is also a way to make sure we got the proper file name for the real test later on.
|
||||
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
||||
if test "x$test_shortpath" = x; then
|
||||
@ -24302,7 +23933,7 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
|
||||
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
||||
# "foo.exe" is OK but "foo" is an error.
|
||||
#
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
||||
# It is also a way to make sure we got the proper file name for the real test later on.
|
||||
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
||||
if test "x$test_shortpath" = x; then
|
||||
@ -24713,7 +24344,7 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
|
||||
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
||||
# "foo.exe" is OK but "foo" is an error.
|
||||
#
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
||||
# It is also a way to make sure we got the proper file name for the real test later on.
|
||||
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
||||
if test "x$test_shortpath" = x; then
|
||||
@ -25113,7 +24744,7 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
|
||||
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
||||
# "foo.exe" is OK but "foo" is an error.
|
||||
#
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
||||
# It is also a way to make sure we got the proper file name for the real test later on.
|
||||
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
||||
if test "x$test_shortpath" = x; then
|
||||
@ -25442,7 +25073,7 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
|
||||
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
||||
# "foo.exe" is OK but "foo" is an error.
|
||||
#
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
||||
# It is also a way to make sure we got the proper file name for the real test later on.
|
||||
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
||||
if test "x$test_shortpath" = x; then
|
||||
@ -25754,7 +25385,7 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
|
||||
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
||||
# "foo.exe" is OK but "foo" is an error.
|
||||
#
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
||||
# It is also a way to make sure we got the proper file name for the real test later on.
|
||||
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
||||
if test "x$test_shortpath" = x; then
|
||||
@ -26060,7 +25691,7 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
|
||||
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
||||
# "foo.exe" is OK but "foo" is an error.
|
||||
#
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
||||
# It is also a way to make sure we got the proper file name for the real test later on.
|
||||
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
||||
if test "x$test_shortpath" = x; then
|
||||
@ -26366,7 +25997,7 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
|
||||
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
||||
# "foo.exe" is OK but "foo" is an error.
|
||||
#
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
||||
# It is also a way to make sure we got the proper file name for the real test later on.
|
||||
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
||||
if test "x$test_shortpath" = x; then
|
||||
@ -26672,7 +26303,7 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
|
||||
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
||||
# "foo.exe" is OK but "foo" is an error.
|
||||
#
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
||||
# It is also a way to make sure we got the proper file name for the real test later on.
|
||||
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
||||
if test "x$test_shortpath" = x; then
|
||||
@ -27031,7 +26662,7 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
|
||||
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
||||
# "foo.exe" is OK but "foo" is an error.
|
||||
#
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
||||
# It is also a way to make sure we got the proper file name for the real test later on.
|
||||
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
||||
if test "x$test_shortpath" = x; then
|
||||
@ -27391,7 +27022,7 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
|
||||
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
||||
# "foo.exe" is OK but "foo" is an error.
|
||||
#
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
||||
# It is also a way to make sure we got the proper file name for the real test later on.
|
||||
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
||||
if test "x$test_shortpath" = x; then
|
||||
@ -27764,7 +27395,7 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
|
||||
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
||||
# "foo.exe" is OK but "foo" is an error.
|
||||
#
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
||||
# It is also a way to make sure we got the proper file name for the real test later on.
|
||||
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
||||
if test "x$test_shortpath" = x; then
|
||||
@ -28135,7 +27766,7 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
|
||||
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
||||
# "foo.exe" is OK but "foo" is an error.
|
||||
#
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
||||
# It is also a way to make sure we got the proper file name for the real test later on.
|
||||
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
||||
if test "x$test_shortpath" = x; then
|
||||
@ -28444,7 +28075,7 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
|
||||
# the same file, most of the time (as in "test -f"). But not when running cygpath -s, then
|
||||
# "foo.exe" is OK but "foo" is an error.
|
||||
#
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file precense.
|
||||
# This test is therefore slightly more accurate than "test -f" to check for file presence.
|
||||
# It is also a way to make sure we got the proper file name for the real test later on.
|
||||
test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
|
||||
if test "x$test_shortpath" = x; then
|
||||
@ -28806,35 +28437,41 @@ done
|
||||
if test "x$OPENJDK_TARGET_OS" = xsolaris; then
|
||||
# Always specify -m flags on Solaris
|
||||
|
||||
# keep track of c/cxx flags that we added outselves...
|
||||
# to prevent emitting warning...
|
||||
TARGET_BITS_FLAG="-m${OPENJDK_TARGET_CPU_BITS}"
|
||||
# When we add flags to the "official" CFLAGS etc, we need to
|
||||
# keep track of these additions in ADDED_CFLAGS etc. These
|
||||
# will later be checked to make sure only controlled additions
|
||||
# have been made to CFLAGS etc.
|
||||
ADDED_CFLAGS=" -m${OPENJDK_TARGET_CPU_BITS}"
|
||||
ADDED_CXXFLAGS=" -m${OPENJDK_TARGET_CPU_BITS}"
|
||||
ADDED_LDFLAGS=" -m${OPENJDK_TARGET_CPU_BITS}"
|
||||
|
||||
CFLAGS="${CFLAGS}${ADDED_CFLAGS}"
|
||||
CXXFLAGS="${CXXFLAGS}${ADDED_CXXFLAGS}"
|
||||
LDFLAGS="${LDFLAGS}${ADDED_LDFLAGS}"
|
||||
|
||||
CFLAGS="${CFLAGS} ${TARGET_BITS_FLAG}"
|
||||
CXXFLAGS="${CXXFLAGS} ${TARGET_BITS_FLAG}"
|
||||
LDFLAGS="${LDFLAGS} ${TARGET_BITS_FLAG}"
|
||||
|
||||
CFLAGS_JDK="${CFLAGS_JDK} ${TARGET_BITS_FLAG}"
|
||||
CXXFLAGS_JDK="${CXXFLAGS_JDK} ${TARGET_BITS_FLAG}"
|
||||
LDFLAGS_JDK="${LDFLAGS_JDK} ${TARGET_BITS_FLAG}"
|
||||
CFLAGS_JDK="${CFLAGS_JDK}${ADDED_CFLAGS}"
|
||||
CXXFLAGS_JDK="${CXXFLAGS_JDK}${ADDED_CXXFLAGS}"
|
||||
LDFLAGS_JDK="${LDFLAGS_JDK}${ADDED_LDFLAGS}"
|
||||
|
||||
elif test "x$COMPILE_TYPE" = xreduced; then
|
||||
if test "x$OPENJDK_TARGET_OS" != xwindows; then
|
||||
# Specify -m if running reduced on other Posix platforms
|
||||
|
||||
# keep track of c/cxx flags that we added outselves...
|
||||
# to prevent emitting warning...
|
||||
TARGET_BITS_FLAG="-m${OPENJDK_TARGET_CPU_BITS}"
|
||||
# When we add flags to the "official" CFLAGS etc, we need to
|
||||
# keep track of these additions in ADDED_CFLAGS etc. These
|
||||
# will later be checked to make sure only controlled additions
|
||||
# have been made to CFLAGS etc.
|
||||
ADDED_CFLAGS=" -m${OPENJDK_TARGET_CPU_BITS}"
|
||||
ADDED_CXXFLAGS=" -m${OPENJDK_TARGET_CPU_BITS}"
|
||||
ADDED_LDFLAGS=" -m${OPENJDK_TARGET_CPU_BITS}"
|
||||
|
||||
CFLAGS="${CFLAGS}${ADDED_CFLAGS}"
|
||||
CXXFLAGS="${CXXFLAGS}${ADDED_CXXFLAGS}"
|
||||
LDFLAGS="${LDFLAGS}${ADDED_LDFLAGS}"
|
||||
|
||||
CFLAGS="${CFLAGS} ${TARGET_BITS_FLAG}"
|
||||
CXXFLAGS="${CXXFLAGS} ${TARGET_BITS_FLAG}"
|
||||
LDFLAGS="${LDFLAGS} ${TARGET_BITS_FLAG}"
|
||||
|
||||
CFLAGS_JDK="${CFLAGS_JDK} ${TARGET_BITS_FLAG}"
|
||||
CXXFLAGS_JDK="${CXXFLAGS_JDK} ${TARGET_BITS_FLAG}"
|
||||
LDFLAGS_JDK="${LDFLAGS_JDK} ${TARGET_BITS_FLAG}"
|
||||
CFLAGS_JDK="${CFLAGS_JDK}${ADDED_CFLAGS}"
|
||||
CXXFLAGS_JDK="${CXXFLAGS_JDK}${ADDED_CXXFLAGS}"
|
||||
LDFLAGS_JDK="${LDFLAGS_JDK}${ADDED_LDFLAGS}"
|
||||
|
||||
fi
|
||||
fi
|
||||
@ -33594,6 +33231,7 @@ fi
|
||||
# We're messing a bit with internal autoconf variables to put the config.status
|
||||
# in the output directory instead of the current directory.
|
||||
CONFIG_STATUS="$OUTPUT_ROOT/config.status"
|
||||
|
||||
# Create the actual output files. Now the main work of configure is done.
|
||||
cat >confcache <<\_ACEOF
|
||||
# This file is a shell script that caches the results of configure
|
||||
@ -34875,6 +34513,11 @@ $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;}
|
||||
fi
|
||||
|
||||
|
||||
# Try to move the config.log file to the output directory.
|
||||
if test -e ./config.log; then
|
||||
$MV -f ./config.log "$OUTPUT_ROOT/config.log" 2> /dev/null
|
||||
fi
|
||||
|
||||
# Make the compare script executable
|
||||
$CHMOD +x $OUTPUT_ROOT/compare.sh
|
||||
|
||||
|
||||
@ -446,7 +446,7 @@ elif test "x$with_user_release_suffix" != x; then
|
||||
else
|
||||
BUILD_DATE=`date '+%Y_%m_%d_%H_%M'`
|
||||
# Avoid [:alnum:] since it depends on the locale.
|
||||
CLEAN_USERNAME=`echo "$USER" | $TR -d -c 'abcdefghijklmnopqrstuvqxyz0123456789'`
|
||||
CLEAN_USERNAME=`echo "$USER" | $TR -d -c 'abcdefghijklmnopqrstuvqxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'`
|
||||
USER_RELEASE_SUFFIX=`echo "${CLEAN_USERNAME}_${BUILD_DATE}" | $TR 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
|
||||
fi
|
||||
AC_SUBST(USER_RELEASE_SUFFIX)
|
||||
|
||||
@ -60,6 +60,18 @@ AC_DEFUN([PLATFORM_EXTRACT_VARS_FROM_CPU],
|
||||
VAR_CPU_BITS=64
|
||||
VAR_CPU_ENDIAN=big
|
||||
;;
|
||||
s390)
|
||||
VAR_CPU=s390
|
||||
VAR_CPU_ARCH=s390
|
||||
VAR_CPU_BITS=32
|
||||
VAR_CPU_ENDIAN=big
|
||||
;;
|
||||
s390x)
|
||||
VAR_CPU=s390x
|
||||
VAR_CPU_ARCH=s390
|
||||
VAR_CPU_BITS=64
|
||||
VAR_CPU_ENDIAN=big
|
||||
;;
|
||||
sparc)
|
||||
VAR_CPU=sparc
|
||||
VAR_CPU_ARCH=sparc
|
||||
@ -410,18 +422,21 @@ AC_SUBST(OS_VERSION_MICRO)
|
||||
# Add -mX to various FLAGS variables.
|
||||
AC_DEFUN([PLATFORM_SET_COMPILER_TARGET_BITS_FLAGS],
|
||||
[
|
||||
# keep track of c/cxx flags that we added outselves...
|
||||
# to prevent emitting warning...
|
||||
TARGET_BITS_FLAG="-m${OPENJDK_TARGET_CPU_BITS}"
|
||||
AC_SUBST(TARGET_BITS_FLAG)
|
||||
# When we add flags to the "official" CFLAGS etc, we need to
|
||||
# keep track of these additions in ADDED_CFLAGS etc. These
|
||||
# will later be checked to make sure only controlled additions
|
||||
# have been made to CFLAGS etc.
|
||||
ADDED_CFLAGS=" -m${OPENJDK_TARGET_CPU_BITS}"
|
||||
ADDED_CXXFLAGS=" -m${OPENJDK_TARGET_CPU_BITS}"
|
||||
ADDED_LDFLAGS=" -m${OPENJDK_TARGET_CPU_BITS}"
|
||||
|
||||
CFLAGS="${CFLAGS} ${TARGET_BITS_FLAG}"
|
||||
CXXFLAGS="${CXXFLAGS} ${TARGET_BITS_FLAG}"
|
||||
LDFLAGS="${LDFLAGS} ${TARGET_BITS_FLAG}"
|
||||
CFLAGS="${CFLAGS}${ADDED_CFLAGS}"
|
||||
CXXFLAGS="${CXXFLAGS}${ADDED_CXXFLAGS}"
|
||||
LDFLAGS="${LDFLAGS}${ADDED_LDFLAGS}"
|
||||
|
||||
CFLAGS_JDK="${CFLAGS_JDK} ${TARGET_BITS_FLAG}"
|
||||
CXXFLAGS_JDK="${CXXFLAGS_JDK} ${TARGET_BITS_FLAG}"
|
||||
LDFLAGS_JDK="${LDFLAGS_JDK} ${TARGET_BITS_FLAG}"
|
||||
CFLAGS_JDK="${CFLAGS_JDK}${ADDED_CFLAGS}"
|
||||
CXXFLAGS_JDK="${CXXFLAGS_JDK}${ADDED_CXXFLAGS}"
|
||||
LDFLAGS_JDK="${LDFLAGS_JDK}${ADDED_LDFLAGS}"
|
||||
])
|
||||
|
||||
AC_DEFUN_ONCE([PLATFORM_SETUP_OPENJDK_TARGET_BITS],
|
||||
|
||||
@ -101,6 +101,10 @@ if test "x$with_add_source_root" != x; then
|
||||
test -f $with_add_source_root/hotspot/make/Makefile; then
|
||||
AC_MSG_ERROR([Your add source root seems to contain a full hotspot repo! An add source root should only contain additional sources.])
|
||||
fi
|
||||
if test -f $with_add_source_root/nashorn/makefiles/Makefile || \
|
||||
test -f $with_add_source_root/nashorn/make/Makefile; then
|
||||
AC_MSG_ERROR([Your add source root seems to contain a full nashorn repo! An add source root should only contain additional sources.])
|
||||
fi
|
||||
if test -f $with_add_source_root/jdk/makefiles/Makefile || \
|
||||
test -f $with_add_source_root/jdk/make/Makefile; then
|
||||
AC_MSG_ERROR([Your add source root seems to contain a full JDK repo! An add source root should only contain additional sources.])
|
||||
@ -136,6 +140,10 @@ if test "x$with_override_source_root" != x; then
|
||||
test -f $with_override_source_root/hotspot/make/Makefile; then
|
||||
AC_MSG_ERROR([Your override source root seems to contain a full hotspot repo! An override source root should only contain sources that override.])
|
||||
fi
|
||||
if test -f $with_override_source_root/nashorn/makefiles/Makefile || \
|
||||
test -f $with_override_source_root/nashorn/make/Makefile; then
|
||||
AC_MSG_ERROR([Your override source root seems to contain a full nashorn repo! An override source root should only contain sources that override.])
|
||||
fi
|
||||
if test -f $with_override_source_root/jdk/makefiles/Makefile || \
|
||||
test -f $with_override_source_root/jdk/make/Makefile; then
|
||||
AC_MSG_ERROR([Your override source root seems to contain a full JDK repo! An override source root should only contain sources that override.])
|
||||
@ -177,6 +185,9 @@ AC_ARG_WITH(override-jaxws, [AS_HELP_STRING([--with-override-jaxws],
|
||||
AC_ARG_WITH(override-hotspot, [AS_HELP_STRING([--with-override-hotspot],
|
||||
[use this hotspot dir for the build])])
|
||||
|
||||
AC_ARG_WITH(override-nashorn, [AS_HELP_STRING([--with-override-nashorn],
|
||||
[use this nashorn dir for the build])])
|
||||
|
||||
AC_ARG_WITH(override-jdk, [AS_HELP_STRING([--with-override-jdk],
|
||||
[use this jdk dir for the build])])
|
||||
|
||||
@ -241,7 +252,7 @@ if test "x$with_override_nashorn" != x; then
|
||||
cd "$with_override_nashorn"
|
||||
NASHORN_TOPDIR="`pwd`"
|
||||
cd "$CURDIR"
|
||||
if ! test -f $NASHORN_TOPDIR/makefiles/BuildNashorn.gmk; then
|
||||
if ! test -f $NASHORN_TOPDIR/makefiles/Makefile; then
|
||||
AC_MSG_ERROR([You have to override nashorn with a full nashorn repo!])
|
||||
fi
|
||||
AC_MSG_CHECKING([if nashorn should be overridden])
|
||||
|
||||
@ -291,10 +291,6 @@ X_CFLAGS:=@X_CFLAGS@
|
||||
X_LIBS:=@X_LIBS@
|
||||
OPENWIN_HOME:=@OPENWIN_HOME@
|
||||
|
||||
# DirectX SDK
|
||||
DXSDK_LIB_PATH=@DXSDK_LIB_PATH@
|
||||
DXSDK_INCLUDE_PATH=@DXSDK_INCLUDE_PATH@
|
||||
|
||||
# The lowest required version of macosx to enforce compatiblity for
|
||||
MACOSX_VERSION_MIN=@MACOSX_VERSION_MIN@
|
||||
|
||||
@ -304,7 +300,6 @@ MACOSX_VERSION_MIN=@MACOSX_VERSION_MIN@
|
||||
COMPILER_TYPE:=@COMPILER_TYPE@
|
||||
COMPILER_NAME:=@COMPILER_NAME@
|
||||
|
||||
TARGET_BITS_FLAG=@TARGET_BITS_FLAG@
|
||||
COMPILER_SUPPORTS_TARGET_BITS_FLAG=@COMPILER_SUPPORTS_TARGET_BITS_FLAG@
|
||||
|
||||
CC_OUT_OPTION:=@CC_OUT_OPTION@
|
||||
|
||||
@ -176,7 +176,9 @@ AC_DEFUN([TOOLCHAIN_SETUP_PATHS],
|
||||
[
|
||||
if test "x$OPENJDK_TARGET_OS" = "xwindows"; then
|
||||
TOOLCHAIN_SETUP_VISUAL_STUDIO_ENV
|
||||
TOOLCHAIN_SETUP_DXSDK
|
||||
BASIC_DEPRECATED_ARG_WITH([dxsdk])
|
||||
BASIC_DEPRECATED_ARG_WITH([dxsdk-lib])
|
||||
BASIC_DEPRECATED_ARG_WITH([dxsdk-include])
|
||||
fi
|
||||
|
||||
AC_SUBST(MSVCR_DLL)
|
||||
|
||||
@ -277,61 +277,3 @@ AC_DEFUN([TOOLCHAIN_SETUP_VISUAL_STUDIO_ENV],
|
||||
AC_MSG_RESULT([$MSVCR_DLL])
|
||||
BASIC_FIXUP_PATH(MSVCR_DLL)
|
||||
])
|
||||
|
||||
|
||||
# Setup the DXSDK paths
|
||||
AC_DEFUN([TOOLCHAIN_SETUP_DXSDK],
|
||||
[
|
||||
AC_ARG_WITH(dxsdk, [AS_HELP_STRING([--with-dxsdk],
|
||||
[the DirectX SDK (Windows only) @<:@probed@:>@])])
|
||||
AC_ARG_WITH(dxsdk-lib, [AS_HELP_STRING([--with-dxsdk-lib],
|
||||
[the DirectX SDK lib directory (Windows only) @<:@probed@:>@])])
|
||||
AC_ARG_WITH(dxsdk-include, [AS_HELP_STRING([--with-dxsdk-include],
|
||||
[the DirectX SDK include directory (Windows only) @<:@probed@:>@])])
|
||||
|
||||
AC_MSG_CHECKING([for DirectX SDK])
|
||||
|
||||
if test "x$with_dxsdk" != x; then
|
||||
dxsdk_path="$with_dxsdk"
|
||||
elif test "x$DXSDK_DIR" != x; then
|
||||
dxsdk_path="$DXSDK_DIR"
|
||||
elif test -d "C:/DXSDK"; then
|
||||
dxsdk_path="C:/DXSDK"
|
||||
else
|
||||
AC_MSG_ERROR([Could not find the DirectX SDK])
|
||||
fi
|
||||
AC_MSG_RESULT([$dxsdk_path])
|
||||
BASIC_FIXUP_PATH(dxsdk_path)
|
||||
|
||||
AC_MSG_CHECKING([for DirectX SDK lib dir])
|
||||
if test "x$with_dxsdk_lib" != x; then
|
||||
DXSDK_LIB_PATH="$with_dxsdk_lib"
|
||||
elif test "x$OPENJDK_TARGET_CPU" = "xx86_64"; then
|
||||
DXSDK_LIB_PATH="$dxsdk_path/Lib/x64"
|
||||
else
|
||||
DXSDK_LIB_PATH="$dxsdk_path/Lib"
|
||||
fi
|
||||
# dsound.lib is linked to in jsoundds
|
||||
if test ! -f "$DXSDK_LIB_PATH/dsound.lib"; then
|
||||
AC_MSG_ERROR([Invalid DirectX SDK lib dir])
|
||||
fi
|
||||
AC_MSG_RESULT([$DXSDK_LIB_PATH])
|
||||
BASIC_FIXUP_PATH(DXSDK_LIB_PATH)
|
||||
|
||||
AC_MSG_CHECKING([for DirectX SDK include dir])
|
||||
if test "x$with_dxsdk_include" != x; then
|
||||
DXSDK_INCLUDE_PATH="$with_dxsdk_include"
|
||||
else
|
||||
DXSDK_INCLUDE_PATH="$dxsdk_path/Include"
|
||||
fi
|
||||
# dsound.h is included in jsoundds
|
||||
if test ! -f "$DXSDK_INCLUDE_PATH/dsound.h"; then
|
||||
AC_MSG_ERROR([Invalid DirectX SDK lib dir])
|
||||
fi
|
||||
AC_MSG_RESULT([$DXSDK_INCLUDE_PATH])
|
||||
BASIC_FIXUP_PATH(DXSDK_INCLUDE_PATH)
|
||||
|
||||
AC_SUBST(DXSDK_LIB_PATH)
|
||||
AC_SUBST(DXSDK_INCLUDE_PATH)
|
||||
LDFLAGS_JDK="$LDFLAGS_JDK -libpath:$DXSDK_LIB_PATH"
|
||||
])
|
||||
|
||||
@ -47,7 +47,7 @@ python=""
|
||||
bpython=""
|
||||
|
||||
if [ "#!" = "$has_hash_bang" ] ; then
|
||||
python="`head -n 1 ${whichhg} | cut -b 3-`"
|
||||
python="`head -n 1 ${whichhg} | cut -b 3- | sed -e 's/^[ \t]*//;s/[ \t]*$//'`"
|
||||
bpython="`basename "$python"`"
|
||||
fi
|
||||
|
||||
|
||||
@ -227,3 +227,5 @@ a013024b07475782f1fa8e196e950b34b4077663 jdk8-b101
|
||||
49c4a777fdfd648d4c3fffc940fdb97a23108ca8 jdk8-b103
|
||||
d411c60a8c2fe8fdc572af907775e90f7eefd513 jdk8-b104
|
||||
4e38de7c767e34104fa147b5b346d9fe6b731279 jdk8-b105
|
||||
2e3a056c84a71eba78945c18b05397858ffd7ad0 jdk8-b106
|
||||
23fc34133152692b725db4bd617b4c8dfd6ccb05 jdk8-b107
|
||||
|
||||
@ -32,6 +32,7 @@ import java.net.SocketException;
|
||||
import java.net.ServerSocket;
|
||||
import java.nio.channels.SocketChannel;
|
||||
import java.nio.channels.ServerSocketChannel;
|
||||
import java.security.PrivilegedAction;
|
||||
|
||||
import com.sun.corba.se.pept.transport.Acceptor;
|
||||
|
||||
@ -44,6 +45,22 @@ public class DefaultSocketFactoryImpl
|
||||
implements ORBSocketFactory
|
||||
{
|
||||
private ORB orb;
|
||||
private static final boolean keepAlive;
|
||||
|
||||
static {
|
||||
keepAlive = java.security.AccessController.doPrivileged(
|
||||
new PrivilegedAction<Boolean>() {
|
||||
@Override
|
||||
public Boolean run () {
|
||||
String value =
|
||||
System.getProperty("com.sun.CORBA.transport.enableTcpKeepAlive");
|
||||
if (value != null)
|
||||
return new Boolean(!"false".equalsIgnoreCase(value));
|
||||
|
||||
return Boolean.FALSE;
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
public void setORB(ORB orb)
|
||||
{
|
||||
@ -85,6 +102,9 @@ public class DefaultSocketFactoryImpl
|
||||
// Disable Nagle's algorithm (i.e., always send immediately).
|
||||
socket.setTcpNoDelay(true);
|
||||
|
||||
if (keepAlive)
|
||||
socket.setKeepAlive(true);
|
||||
|
||||
return socket;
|
||||
}
|
||||
|
||||
@ -95,6 +115,8 @@ public class DefaultSocketFactoryImpl
|
||||
{
|
||||
// Disable Nagle's algorithm (i.e., always send immediately).
|
||||
socket.setTcpNoDelay(true);
|
||||
if (keepAlive)
|
||||
socket.setKeepAlive(true);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -373,3 +373,7 @@ c4697c1c448416108743b59118b4a2498b339d0c jdk8-b102
|
||||
c1604d5885a6f2adc0bcea2fa142a8f6bafad2f0 hs25-b47
|
||||
acac3bde66b2c22791c257a8d99611d6d08c6713 jdk8-b105
|
||||
18b4798adbc42c6fa16f5ecb7d5cd3ca130754bf hs25-b48
|
||||
aed585cafc0d9655726af6d1e1081d1c94cb3b5c jdk8-b106
|
||||
50794d8ac11c9579b41dec4de23b808fef9f34a1 hs25-b49
|
||||
5b7f90aab3ad25a25b75b7b2bb18d5ae23d8231c jdk8-b107
|
||||
a09fe9d1e016c285307507a5793bc4fa6215e9c9 hs25-b50
|
||||
|
||||
@ -354,9 +354,16 @@ public class InstanceKlass extends Klass {
|
||||
public boolean getIsMarkedDependent() { return isMarkedDependent.getValue(this) != 0; }
|
||||
public long getVtableLen() { return vtableLen.getValue(this); }
|
||||
public long getItableLen() { return itableLen.getValue(this); }
|
||||
public Symbol getGenericSignature() { return getConstants().getSymbolAt(genericSignatureIndex.getValue(this)); }
|
||||
public long majorVersion() { return majorVersion.getValue(this); }
|
||||
public long minorVersion() { return minorVersion.getValue(this); }
|
||||
public Symbol getGenericSignature() {
|
||||
long index = genericSignatureIndex.getValue(this);
|
||||
if (index != 0) {
|
||||
return getConstants().getSymbolAt(index);
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
// "size helper" == instance size in words
|
||||
public long getSizeHelper() {
|
||||
|
||||
@ -129,16 +129,21 @@ ifeq ($(USE_CLANG), true)
|
||||
|
||||
# We only use precompiled headers for the JVM build
|
||||
CFLAGS += $(VM_PCH_FLAG)
|
||||
|
||||
# There are some files which don't like precompiled headers
|
||||
# The following files are build with 'OPT_CFLAGS/NOOPT' (-O0) in the opt build.
|
||||
# But Clang doesn't support a precompiled header which was compiled with -O3
|
||||
# to be used in a compilation unit which uses '-O0'. We could also prepare an
|
||||
# extra '-O0' PCH file for the opt build and use it here, but it's probably
|
||||
# not worth the effort as long as only two files need this special handling.
|
||||
|
||||
# The following files are compiled at various optimization
|
||||
# levels due to optimization issues encountered at the
|
||||
# 'OPT_CFLAGS_DEFAULT' level. The Clang compiler issues a compile
|
||||
# time error if there is an optimization level specification
|
||||
# skew between the PCH file and the C++ file. Especially if the
|
||||
# PCH file is compiled at a higher optimization level than
|
||||
# the C++ file. One solution might be to prepare extra optimization
|
||||
# level specific PCH files for the opt build and use them here, but
|
||||
# it's probably not worth the effort as long as only a few files
|
||||
# need this special handling.
|
||||
PCH_FLAG/loopTransform.o = $(PCH_FLAG/NO_PCH)
|
||||
PCH_FLAG/sharedRuntimeTrig.o = $(PCH_FLAG/NO_PCH)
|
||||
PCH_FLAG/sharedRuntimeTrans.o = $(PCH_FLAG/NO_PCH)
|
||||
PCH_FLAG/unsafe.o = $(PCH_FLAG/NO_PCH)
|
||||
|
||||
endif
|
||||
else # ($(USE_CLANG), true)
|
||||
@ -306,6 +311,7 @@ OPT_CFLAGS/NOOPT=-O0
|
||||
ifeq ($(USE_CLANG), true)
|
||||
ifeq ($(shell expr $(CC_VER_MAJOR) = 4 \& $(CC_VER_MINOR) = 2), 1)
|
||||
OPT_CFLAGS/loopTransform.o += $(OPT_CFLAGS/NOOPT)
|
||||
OPT_CFLAGS/unsafe.o += -O1
|
||||
endif
|
||||
else
|
||||
# 6835796. Problem in GCC 4.3.0 with mulnode.o optimized compilation.
|
||||
|
||||
@ -35,7 +35,7 @@ HOTSPOT_VM_COPYRIGHT=Copyright 2013
|
||||
|
||||
HS_MAJOR_VER=25
|
||||
HS_MINOR_VER=0
|
||||
HS_BUILD_NUMBER=48
|
||||
HS_BUILD_NUMBER=50
|
||||
|
||||
JDK_MAJOR_VER=1
|
||||
JDK_MINOR_VER=8
|
||||
|
||||
@ -82,6 +82,7 @@ for /F %%i in ('sh %HotSpotWorkSpace%/make/windows/get_msc_ver.sh') do set %%i
|
||||
|
||||
echo **************************************************************
|
||||
set ProjectFile=%HotSpotBuildSpace%\jvm.vcproj
|
||||
echo MSC_VER = "%MSC_VER%"
|
||||
if "%MSC_VER%" == "1200" (
|
||||
set ProjectFile=%HotSpotBuildSpace%\jvm.dsp
|
||||
echo Will generate VC6 project {unsupported}
|
||||
@ -96,11 +97,17 @@ if "%MSC_VER%" == "1600" (
|
||||
echo Will generate VC10 {Visual Studio 2010}
|
||||
set ProjectFile=%HotSpotBuildSpace%\jvm.vcxproj
|
||||
) else (
|
||||
if "%MSC_VER%" == "1700" (
|
||||
echo Will generate VC10 {compatible with Visual Studio 2012}
|
||||
echo After opening in VS 2012, click "Update" when prompted.
|
||||
set ProjectFile=%HotSpotBuildSpace%\jvm.vcxproj
|
||||
) else (
|
||||
echo Will generate VC7 project {Visual Studio 2003 .NET}
|
||||
)
|
||||
)
|
||||
)
|
||||
)
|
||||
)
|
||||
echo %ProjectFile%
|
||||
echo **************************************************************
|
||||
|
||||
|
||||
@ -69,6 +69,13 @@ VcVersion=VC9
|
||||
VcVersion=VC10
|
||||
ProjectFile=jvm.vcxproj
|
||||
|
||||
!elseif "$(MSC_VER)" == "1700"
|
||||
# This is VS2012, but it loads VS10 projects just fine (and will
|
||||
# upgrade them automatically to VS2012 format).
|
||||
|
||||
VcVersion=VC10
|
||||
ProjectFile=jvm.vcxproj
|
||||
|
||||
!else
|
||||
|
||||
VcVersion=VC7
|
||||
|
||||
@ -307,7 +307,7 @@ void PatchingStub::emit_code(LIR_Assembler* ce) {
|
||||
assert(a_byte == *start++, "should be the same code");
|
||||
}
|
||||
#endif
|
||||
} else if (_id == load_mirror_id) {
|
||||
} else if (_id == load_mirror_id || _id == load_appendix_id) {
|
||||
// produce a copy of the load mirror instruction for use by the being initialized case
|
||||
#ifdef ASSERT
|
||||
address start = __ pc();
|
||||
@ -384,6 +384,7 @@ void PatchingStub::emit_code(LIR_Assembler* ce) {
|
||||
case access_field_id: target = Runtime1::entry_for(Runtime1::access_field_patching_id); break;
|
||||
case load_klass_id: target = Runtime1::entry_for(Runtime1::load_klass_patching_id); reloc_type = relocInfo::metadata_type; break;
|
||||
case load_mirror_id: target = Runtime1::entry_for(Runtime1::load_mirror_patching_id); reloc_type = relocInfo::oop_type; break;
|
||||
case load_appendix_id: target = Runtime1::entry_for(Runtime1::load_appendix_patching_id); reloc_type = relocInfo::oop_type; break;
|
||||
default: ShouldNotReachHere();
|
||||
}
|
||||
__ bind(call_patch);
|
||||
@ -397,7 +398,7 @@ void PatchingStub::emit_code(LIR_Assembler* ce) {
|
||||
ce->add_call_info_here(_info);
|
||||
__ br(Assembler::always, false, Assembler::pt, _patch_site_entry);
|
||||
__ delayed()->nop();
|
||||
if (_id == load_klass_id || _id == load_mirror_id) {
|
||||
if (_id == load_klass_id || _id == load_mirror_id || _id == load_appendix_id) {
|
||||
CodeSection* cs = __ code_section();
|
||||
address pc = (address)_pc_start;
|
||||
RelocIterator iter(cs, pc, pc + 1);
|
||||
|
||||
@ -520,7 +520,7 @@ void LIR_Assembler::jobject2reg(jobject o, Register reg) {
|
||||
void LIR_Assembler::jobject2reg_with_patching(Register reg, CodeEmitInfo *info) {
|
||||
// Allocate a new index in table to hold the object once it's been patched
|
||||
int oop_index = __ oop_recorder()->allocate_oop_index(NULL);
|
||||
PatchingStub* patch = new PatchingStub(_masm, PatchingStub::load_mirror_id, oop_index);
|
||||
PatchingStub* patch = new PatchingStub(_masm, patching_id(info), oop_index);
|
||||
|
||||
AddressLiteral addrlit(NULL, oop_Relocation::spec(oop_index));
|
||||
assert(addrlit.rspec().type() == relocInfo::oop_type, "must be an oop reloc");
|
||||
|
||||
@ -804,6 +804,12 @@ OopMapSet* Runtime1::generate_code_for(StubID id, StubAssembler* sasm) {
|
||||
}
|
||||
break;
|
||||
|
||||
case load_appendix_patching_id:
|
||||
{ __ set_info("load_appendix_patching", dont_gc_arguments);
|
||||
oop_maps = generate_patching(sasm, CAST_FROM_FN_PTR(address, move_appendix_patching));
|
||||
}
|
||||
break;
|
||||
|
||||
case dtrace_object_alloc_id:
|
||||
{ // O0: object
|
||||
__ set_info("dtrace_object_alloc", dont_gc_arguments);
|
||||
|
||||
@ -57,6 +57,7 @@ define_pd_global(intx, RegisterCostAreaRatio, 12000);
|
||||
define_pd_global(bool, UseTLAB, true);
|
||||
define_pd_global(bool, ResizeTLAB, true);
|
||||
define_pd_global(intx, LoopUnrollLimit, 60); // Design center runs on 1.3.1
|
||||
define_pd_global(intx, MinJumpTableSize, 5);
|
||||
|
||||
// Peephole and CISC spilling both break the graph, and so makes the
|
||||
// scheduler sick.
|
||||
|
||||
@ -402,6 +402,7 @@ void PatchingStub::emit_code(LIR_Assembler* ce) {
|
||||
case access_field_id: target = Runtime1::entry_for(Runtime1::access_field_patching_id); break;
|
||||
case load_klass_id: target = Runtime1::entry_for(Runtime1::load_klass_patching_id); reloc_type = relocInfo::metadata_type; break;
|
||||
case load_mirror_id: target = Runtime1::entry_for(Runtime1::load_mirror_patching_id); reloc_type = relocInfo::oop_type; break;
|
||||
case load_appendix_id: target = Runtime1::entry_for(Runtime1::load_appendix_patching_id); reloc_type = relocInfo::oop_type; break;
|
||||
default: ShouldNotReachHere();
|
||||
}
|
||||
__ bind(call_patch);
|
||||
@ -419,7 +420,7 @@ void PatchingStub::emit_code(LIR_Assembler* ce) {
|
||||
for (int j = __ offset() ; j < jmp_off + 5 ; j++ ) {
|
||||
__ nop();
|
||||
}
|
||||
if (_id == load_klass_id || _id == load_mirror_id) {
|
||||
if (_id == load_klass_id || _id == load_mirror_id || _id == load_appendix_id) {
|
||||
CodeSection* cs = __ code_section();
|
||||
RelocIterator iter(cs, (address)_pc_start, (address)(_pc_start + 1));
|
||||
relocInfo::change_reloc_info_for_address(&iter, (address) _pc_start, reloc_type, relocInfo::none);
|
||||
|
||||
@ -362,7 +362,7 @@ int LIR_Assembler::check_icache() {
|
||||
|
||||
void LIR_Assembler::jobject2reg_with_patching(Register reg, CodeEmitInfo* info) {
|
||||
jobject o = NULL;
|
||||
PatchingStub* patch = new PatchingStub(_masm, PatchingStub::load_mirror_id);
|
||||
PatchingStub* patch = new PatchingStub(_masm, patching_id(info));
|
||||
__ movoop(reg, o);
|
||||
patching_epilog(patch, lir_patch_normal, reg, info);
|
||||
}
|
||||
|
||||
@ -1499,6 +1499,13 @@ OopMapSet* Runtime1::generate_code_for(StubID id, StubAssembler* sasm) {
|
||||
}
|
||||
break;
|
||||
|
||||
case load_appendix_patching_id:
|
||||
{ StubFrame f(sasm, "load_appendix_patching", dont_gc_arguments);
|
||||
// we should set up register map
|
||||
oop_maps = generate_patching(sasm, CAST_FROM_FN_PTR(address, move_appendix_patching));
|
||||
}
|
||||
break;
|
||||
|
||||
case dtrace_object_alloc_id:
|
||||
{ // rax,: object
|
||||
StubFrame f(sasm, "dtrace_object_alloc", dont_gc_arguments);
|
||||
|
||||
@ -30,7 +30,6 @@
|
||||
|
||||
// Sets the default values for platform dependent flags used by the server compiler.
|
||||
// (see c2_globals.hpp). Alpha-sorted.
|
||||
|
||||
define_pd_global(bool, BackgroundCompilation, true);
|
||||
define_pd_global(bool, UseTLAB, true);
|
||||
define_pd_global(bool, ResizeTLAB, true);
|
||||
@ -52,6 +51,7 @@ define_pd_global(intx, OnStackReplacePercentage, 140);
|
||||
define_pd_global(intx, ConditionalMoveLimit, 3);
|
||||
define_pd_global(intx, FLOATPRESSURE, 6);
|
||||
define_pd_global(intx, FreqInlineSize, 325);
|
||||
define_pd_global(intx, MinJumpTableSize, 10);
|
||||
#ifdef AMD64
|
||||
define_pd_global(intx, INTPRESSURE, 13);
|
||||
define_pd_global(intx, InteriorEntryAlignment, 16);
|
||||
|
||||
@ -2767,7 +2767,19 @@ void os::numa_make_global(char *addr, size_t bytes) {
|
||||
Linux::numa_interleave_memory(addr, bytes);
|
||||
}
|
||||
|
||||
// Define for numa_set_bind_policy(int). Setting the argument to 0 will set the
|
||||
// bind policy to MPOL_PREFERRED for the current thread.
|
||||
#define USE_MPOL_PREFERRED 0
|
||||
|
||||
void os::numa_make_local(char *addr, size_t bytes, int lgrp_hint) {
|
||||
// To make NUMA and large pages more robust when both enabled, we need to ease
|
||||
// the requirements on where the memory should be allocated. MPOL_BIND is the
|
||||
// default policy and it will force memory to be allocated on the specified
|
||||
// node. Changing this to MPOL_PREFERRED will prefer to allocate the memory on
|
||||
// the specified node, but will not force it. Using this policy will prevent
|
||||
// getting SIGBUS when trying to allocate large pages on NUMA nodes with no
|
||||
// free large pages.
|
||||
Linux::numa_set_bind_policy(USE_MPOL_PREFERRED);
|
||||
Linux::numa_tonode_memory(addr, bytes, lgrp_hint);
|
||||
}
|
||||
|
||||
@ -2869,6 +2881,8 @@ bool os::Linux::libnuma_init() {
|
||||
libnuma_dlsym(handle, "numa_tonode_memory")));
|
||||
set_numa_interleave_memory(CAST_TO_FN_PTR(numa_interleave_memory_func_t,
|
||||
libnuma_dlsym(handle, "numa_interleave_memory")));
|
||||
set_numa_set_bind_policy(CAST_TO_FN_PTR(numa_set_bind_policy_func_t,
|
||||
libnuma_dlsym(handle, "numa_set_bind_policy")));
|
||||
|
||||
|
||||
if (numa_available() != -1) {
|
||||
@ -2935,6 +2949,7 @@ os::Linux::numa_max_node_func_t os::Linux::_numa_max_node;
|
||||
os::Linux::numa_available_func_t os::Linux::_numa_available;
|
||||
os::Linux::numa_tonode_memory_func_t os::Linux::_numa_tonode_memory;
|
||||
os::Linux::numa_interleave_memory_func_t os::Linux::_numa_interleave_memory;
|
||||
os::Linux::numa_set_bind_policy_func_t os::Linux::_numa_set_bind_policy;
|
||||
unsigned long* os::Linux::_numa_all_nodes;
|
||||
|
||||
bool os::pd_uncommit_memory(char* addr, size_t size) {
|
||||
@ -2943,6 +2958,53 @@ bool os::pd_uncommit_memory(char* addr, size_t size) {
|
||||
return res != (uintptr_t) MAP_FAILED;
|
||||
}
|
||||
|
||||
static
|
||||
address get_stack_commited_bottom(address bottom, size_t size) {
|
||||
address nbot = bottom;
|
||||
address ntop = bottom + size;
|
||||
|
||||
size_t page_sz = os::vm_page_size();
|
||||
unsigned pages = size / page_sz;
|
||||
|
||||
unsigned char vec[1];
|
||||
unsigned imin = 1, imax = pages + 1, imid;
|
||||
int mincore_return_value;
|
||||
|
||||
while (imin < imax) {
|
||||
imid = (imax + imin) / 2;
|
||||
nbot = ntop - (imid * page_sz);
|
||||
|
||||
// Use a trick with mincore to check whether the page is mapped or not.
|
||||
// mincore sets vec to 1 if page resides in memory and to 0 if page
|
||||
// is swapped output but if page we are asking for is unmapped
|
||||
// it returns -1,ENOMEM
|
||||
mincore_return_value = mincore(nbot, page_sz, vec);
|
||||
|
||||
if (mincore_return_value == -1) {
|
||||
// Page is not mapped go up
|
||||
// to find first mapped page
|
||||
if (errno != EAGAIN) {
|
||||
assert(errno == ENOMEM, "Unexpected mincore errno");
|
||||
imax = imid;
|
||||
}
|
||||
} else {
|
||||
// Page is mapped go down
|
||||
// to find first not mapped page
|
||||
imin = imid + 1;
|
||||
}
|
||||
}
|
||||
|
||||
nbot = nbot + page_sz;
|
||||
|
||||
// Adjust stack bottom one page up if last checked page is not mapped
|
||||
if (mincore_return_value == -1) {
|
||||
nbot = nbot + page_sz;
|
||||
}
|
||||
|
||||
return nbot;
|
||||
}
|
||||
|
||||
|
||||
// Linux uses a growable mapping for the stack, and if the mapping for
|
||||
// the stack guard pages is not removed when we detach a thread the
|
||||
// stack cannot grow beyond the pages where the stack guard was
|
||||
@ -2957,59 +3019,37 @@ bool os::pd_uncommit_memory(char* addr, size_t size) {
|
||||
// So, we need to know the extent of the stack mapping when
|
||||
// create_stack_guard_pages() is called.
|
||||
|
||||
// Find the bounds of the stack mapping. Return true for success.
|
||||
//
|
||||
// We only need this for stacks that are growable: at the time of
|
||||
// writing thread stacks don't use growable mappings (i.e. those
|
||||
// creeated with MAP_GROWSDOWN), and aren't marked "[stack]", so this
|
||||
// only applies to the main thread.
|
||||
|
||||
static
|
||||
bool get_stack_bounds(uintptr_t *bottom, uintptr_t *top) {
|
||||
|
||||
char buf[128];
|
||||
int fd, sz;
|
||||
|
||||
if ((fd = ::open("/proc/self/maps", O_RDONLY)) < 0) {
|
||||
return false;
|
||||
}
|
||||
|
||||
const char kw[] = "[stack]";
|
||||
const int kwlen = sizeof(kw)-1;
|
||||
|
||||
// Address part of /proc/self/maps couldn't be more than 128 bytes
|
||||
while ((sz = os::get_line_chars(fd, buf, sizeof(buf))) > 0) {
|
||||
if (sz > kwlen && ::memcmp(buf+sz-kwlen, kw, kwlen) == 0) {
|
||||
// Extract addresses
|
||||
if (sscanf(buf, "%" SCNxPTR "-%" SCNxPTR, bottom, top) == 2) {
|
||||
uintptr_t sp = (uintptr_t) __builtin_frame_address(0);
|
||||
if (sp >= *bottom && sp <= *top) {
|
||||
::close(fd);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
::close(fd);
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
// If the (growable) stack mapping already extends beyond the point
|
||||
// where we're going to put our guard pages, truncate the mapping at
|
||||
// that point by munmap()ping it. This ensures that when we later
|
||||
// munmap() the guard pages we don't leave a hole in the stack
|
||||
// mapping. This only affects the main/initial thread, but guard
|
||||
// against future OS changes
|
||||
// mapping. This only affects the main/initial thread
|
||||
|
||||
bool os::pd_create_stack_guard_pages(char* addr, size_t size) {
|
||||
uintptr_t stack_extent, stack_base;
|
||||
bool chk_bounds = NOT_DEBUG(os::Linux::is_initial_thread()) DEBUG_ONLY(true);
|
||||
if (chk_bounds && get_stack_bounds(&stack_extent, &stack_base)) {
|
||||
assert(os::Linux::is_initial_thread(),
|
||||
"growable stack in non-initial thread");
|
||||
if (stack_extent < (uintptr_t)addr)
|
||||
::munmap((void*)stack_extent, (uintptr_t)addr - stack_extent);
|
||||
|
||||
if (os::Linux::is_initial_thread()) {
|
||||
// As we manually grow stack up to bottom inside create_attached_thread(),
|
||||
// it's likely that os::Linux::initial_thread_stack_bottom is mapped and
|
||||
// we don't need to do anything special.
|
||||
// Check it first, before calling heavy function.
|
||||
uintptr_t stack_extent = (uintptr_t) os::Linux::initial_thread_stack_bottom();
|
||||
unsigned char vec[1];
|
||||
|
||||
if (mincore((address)stack_extent, os::vm_page_size(), vec) == -1) {
|
||||
// Fallback to slow path on all errors, including EAGAIN
|
||||
stack_extent = (uintptr_t) get_stack_commited_bottom(
|
||||
os::Linux::initial_thread_stack_bottom(),
|
||||
(size_t)addr - stack_extent);
|
||||
}
|
||||
|
||||
if (stack_extent < (uintptr_t)addr) {
|
||||
::munmap((void*)stack_extent, (uintptr_t)(addr - stack_extent));
|
||||
}
|
||||
}
|
||||
|
||||
return os::commit_memory(addr, size, !ExecMem);
|
||||
@ -3018,13 +3058,13 @@ bool os::pd_create_stack_guard_pages(char* addr, size_t size) {
|
||||
// If this is a growable mapping, remove the guard pages entirely by
|
||||
// munmap()ping them. If not, just call uncommit_memory(). This only
|
||||
// affects the main/initial thread, but guard against future OS changes
|
||||
// It's safe to always unmap guard pages for initial thread because we
|
||||
// always place it right after end of the mapped region
|
||||
|
||||
bool os::remove_stack_guard_pages(char* addr, size_t size) {
|
||||
uintptr_t stack_extent, stack_base;
|
||||
bool chk_bounds = NOT_DEBUG(os::Linux::is_initial_thread()) DEBUG_ONLY(true);
|
||||
if (chk_bounds && get_stack_bounds(&stack_extent, &stack_base)) {
|
||||
assert(os::Linux::is_initial_thread(),
|
||||
"growable stack in non-initial thread");
|
||||
|
||||
if (os::Linux::is_initial_thread()) {
|
||||
return ::munmap(addr, size) == 0;
|
||||
}
|
||||
|
||||
|
||||
@ -235,6 +235,7 @@ private:
|
||||
typedef int (*numa_available_func_t)(void);
|
||||
typedef int (*numa_tonode_memory_func_t)(void *start, size_t size, int node);
|
||||
typedef void (*numa_interleave_memory_func_t)(void *start, size_t size, unsigned long *nodemask);
|
||||
typedef void (*numa_set_bind_policy_func_t)(int policy);
|
||||
|
||||
static sched_getcpu_func_t _sched_getcpu;
|
||||
static numa_node_to_cpus_func_t _numa_node_to_cpus;
|
||||
@ -242,6 +243,7 @@ private:
|
||||
static numa_available_func_t _numa_available;
|
||||
static numa_tonode_memory_func_t _numa_tonode_memory;
|
||||
static numa_interleave_memory_func_t _numa_interleave_memory;
|
||||
static numa_set_bind_policy_func_t _numa_set_bind_policy;
|
||||
static unsigned long* _numa_all_nodes;
|
||||
|
||||
static void set_sched_getcpu(sched_getcpu_func_t func) { _sched_getcpu = func; }
|
||||
@ -250,6 +252,7 @@ private:
|
||||
static void set_numa_available(numa_available_func_t func) { _numa_available = func; }
|
||||
static void set_numa_tonode_memory(numa_tonode_memory_func_t func) { _numa_tonode_memory = func; }
|
||||
static void set_numa_interleave_memory(numa_interleave_memory_func_t func) { _numa_interleave_memory = func; }
|
||||
static void set_numa_set_bind_policy(numa_set_bind_policy_func_t func) { _numa_set_bind_policy = func; }
|
||||
static void set_numa_all_nodes(unsigned long* ptr) { _numa_all_nodes = ptr; }
|
||||
static int sched_getcpu_syscall(void);
|
||||
public:
|
||||
@ -267,6 +270,11 @@ public:
|
||||
_numa_interleave_memory(start, size, _numa_all_nodes);
|
||||
}
|
||||
}
|
||||
static void numa_set_bind_policy(int policy) {
|
||||
if (_numa_set_bind_policy != NULL) {
|
||||
_numa_set_bind_policy(policy);
|
||||
}
|
||||
}
|
||||
static int get_node_by_cpu(int cpu_id);
|
||||
};
|
||||
|
||||
|
||||
@ -30,6 +30,8 @@
|
||||
#include <unistd.h>
|
||||
#include <sys/resource.h>
|
||||
#include <sys/utsname.h>
|
||||
#include <pthread.h>
|
||||
#include <signal.h>
|
||||
|
||||
|
||||
// Check core dump limit and report possible place where core can be found
|
||||
@ -320,11 +322,17 @@ os::WatcherThreadCrashProtection::WatcherThreadCrashProtection() {
|
||||
* The callback is supposed to provide the method that should be protected.
|
||||
*/
|
||||
bool os::WatcherThreadCrashProtection::call(os::CrashProtectionCallback& cb) {
|
||||
sigset_t saved_sig_mask;
|
||||
|
||||
assert(Thread::current()->is_Watcher_thread(), "Only for WatcherThread");
|
||||
assert(!WatcherThread::watcher_thread()->has_crash_protection(),
|
||||
"crash_protection already set?");
|
||||
|
||||
if (sigsetjmp(_jmpbuf, 1) == 0) {
|
||||
// we cannot rely on sigsetjmp/siglongjmp to save/restore the signal mask
|
||||
// since on at least some systems (OS X) siglongjmp will restore the mask
|
||||
// for the process, not the thread
|
||||
pthread_sigmask(0, NULL, &saved_sig_mask);
|
||||
if (sigsetjmp(_jmpbuf, 0) == 0) {
|
||||
// make sure we can see in the signal handler that we have crash protection
|
||||
// installed
|
||||
WatcherThread::watcher_thread()->set_crash_protection(this);
|
||||
@ -334,6 +342,7 @@ bool os::WatcherThreadCrashProtection::call(os::CrashProtectionCallback& cb) {
|
||||
return true;
|
||||
}
|
||||
// this happens when we siglongjmp() back
|
||||
pthread_sigmask(SIG_SETMASK, &saved_sig_mask, NULL);
|
||||
WatcherThread::watcher_thread()->set_crash_protection(NULL);
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -44,6 +44,6 @@ define_pd_global(uintx,JVMInvokeMethodSlack, 10*K);
|
||||
define_pd_global(intx, CompilerThreadStackSize, 0);
|
||||
|
||||
// Used on 64 bit platforms for UseCompressedOops base address
|
||||
define_pd_global(uintx,HeapBaseMinAddress, 256*M);
|
||||
define_pd_global(uintx,HeapBaseMinAddress, 2*G);
|
||||
|
||||
#endif // OS_CPU_SOLARIS_X86_VM_GLOBALS_SOLARIS_X86_HPP
|
||||
|
||||
@ -106,10 +106,12 @@ public class CallSite {
|
||||
" (" + getMethod().getBytes() + " bytes) " + getReason());
|
||||
}
|
||||
}
|
||||
stream.printf(" (end time: %6.4f", getTimeStamp());
|
||||
if (getEndNodes() > 0) {
|
||||
stream.printf(" (end time: %6.4f nodes: %d live: %d)", getTimeStamp(), getEndNodes(), getEndLiveNodes());
|
||||
stream.printf(" nodes: %d live: %d", getEndNodes(), getEndLiveNodes());
|
||||
}
|
||||
stream.println("");
|
||||
stream.println(")");
|
||||
|
||||
if (getReceiver() != null) {
|
||||
emit(stream, indent + 4);
|
||||
// stream.println("type profile " + method.holder + " -> " + receiver + " (" +
|
||||
|
||||
@ -207,7 +207,12 @@ public class LogParser extends DefaultHandler implements ErrorHandler, Constants
|
||||
}
|
||||
|
||||
String search(Attributes attr, String name) {
|
||||
return search(attr, name, null);
|
||||
String result = attr.getValue(name);
|
||||
if (result != null) {
|
||||
return result;
|
||||
} else {
|
||||
throw new InternalError("can't find " + name);
|
||||
}
|
||||
}
|
||||
|
||||
String search(Attributes attr, String name, String defaultValue) {
|
||||
@ -215,13 +220,7 @@ public class LogParser extends DefaultHandler implements ErrorHandler, Constants
|
||||
if (result != null) {
|
||||
return result;
|
||||
}
|
||||
if (defaultValue != null) {
|
||||
return defaultValue;
|
||||
}
|
||||
for (int i = 0; i < attr.getLength(); i++) {
|
||||
System.out.println(attr.getQName(i) + " " + attr.getValue(attr.getQName(i)));
|
||||
}
|
||||
throw new InternalError("can't find " + name);
|
||||
return defaultValue;
|
||||
}
|
||||
int indent = 0;
|
||||
|
||||
@ -268,17 +267,18 @@ public class LogParser extends DefaultHandler implements ErrorHandler, Constants
|
||||
Phase p = new Phase(search(atts, "name"),
|
||||
Double.parseDouble(search(atts, "stamp")),
|
||||
Integer.parseInt(search(atts, "nodes", "0")),
|
||||
Integer.parseInt(search(atts, "live")));
|
||||
Integer.parseInt(search(atts, "live", "0")));
|
||||
phaseStack.push(p);
|
||||
} else if (qname.equals("phase_done")) {
|
||||
Phase p = phaseStack.pop();
|
||||
if (! p.getId().equals(search(atts, "name"))) {
|
||||
String phaseName = search(atts, "name", null);
|
||||
if (phaseName != null && !p.getId().equals(phaseName)) {
|
||||
System.out.println("phase: " + p.getId());
|
||||
throw new InternalError("phase name mismatch");
|
||||
}
|
||||
p.setEnd(Double.parseDouble(search(atts, "stamp")));
|
||||
p.setEndNodes(Integer.parseInt(search(atts, "nodes", "0")));
|
||||
p.setEndLiveNodes(Integer.parseInt(search(atts, "live")));
|
||||
p.setEndLiveNodes(Integer.parseInt(search(atts, "live", "0")));
|
||||
compile.getPhases().add(p);
|
||||
} else if (qname.equals("task")) {
|
||||
compile = new Compilation(Integer.parseInt(search(atts, "compile_id", "-1")));
|
||||
@ -413,8 +413,8 @@ public class LogParser extends DefaultHandler implements ErrorHandler, Constants
|
||||
}
|
||||
} else if (qname.equals("parse_done")) {
|
||||
CallSite call = scopes.pop();
|
||||
call.setEndNodes(Integer.parseInt(search(atts, "nodes", "1")));
|
||||
call.setEndLiveNodes(Integer.parseInt(search(atts, "live", "1")));
|
||||
call.setEndNodes(Integer.parseInt(search(atts, "nodes", "0")));
|
||||
call.setEndLiveNodes(Integer.parseInt(search(atts, "live", "0")));
|
||||
call.setTimeStamp(Double.parseDouble(search(atts, "stamp")));
|
||||
scopes.push(call);
|
||||
}
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 1998, 2010, Oracle and/or its affiliates. All rights reserved.
|
||||
* Copyright (c) 1998, 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
|
||||
@ -24,7 +24,7 @@
|
||||
|
||||
#include "adlc.hpp"
|
||||
|
||||
void* Chunk::operator new(size_t requested_size, size_t length) {
|
||||
void* Chunk::operator new(size_t requested_size, size_t length) throw() {
|
||||
return CHeapObj::operator new(requested_size + length);
|
||||
}
|
||||
|
||||
@ -163,7 +163,7 @@ bool Arena::contains( const void *ptr ) const {
|
||||
//-----------------------------------------------------------------------------
|
||||
// CHeapObj
|
||||
|
||||
void* CHeapObj::operator new(size_t size){
|
||||
void* CHeapObj::operator new(size_t size) throw() {
|
||||
return (void *) malloc(size);
|
||||
}
|
||||
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 1998, 2010, Oracle and/or its affiliates. All rights reserved.
|
||||
* Copyright (c) 1998, 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
|
||||
@ -42,7 +42,7 @@
|
||||
|
||||
class CHeapObj {
|
||||
public:
|
||||
void* operator new(size_t size);
|
||||
void* operator new(size_t size) throw();
|
||||
void operator delete(void* p);
|
||||
void* new_array(size_t size);
|
||||
};
|
||||
@ -53,7 +53,7 @@ class CHeapObj {
|
||||
|
||||
class ValueObj {
|
||||
public:
|
||||
void* operator new(size_t size);
|
||||
void* operator new(size_t size) throw();
|
||||
void operator delete(void* p);
|
||||
};
|
||||
|
||||
@ -61,7 +61,7 @@ class ValueObj {
|
||||
|
||||
class AllStatic {
|
||||
public:
|
||||
void* operator new(size_t size);
|
||||
void* operator new(size_t size) throw();
|
||||
void operator delete(void* p);
|
||||
};
|
||||
|
||||
@ -70,7 +70,7 @@ class AllStatic {
|
||||
// Linked list of raw memory chunks
|
||||
class Chunk: public CHeapObj {
|
||||
public:
|
||||
void* operator new(size_t size, size_t length);
|
||||
void* operator new(size_t size, size_t length) throw();
|
||||
void operator delete(void* p, size_t length);
|
||||
Chunk(size_t length);
|
||||
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
|
||||
* Copyright (c) 1997, 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
|
||||
@ -485,7 +485,7 @@ int get_legal_text(FileBuff &fbuf, char **legal_text)
|
||||
|
||||
// VS2005 has its own definition, identical to this one.
|
||||
#if !defined(_WIN32) || defined(_WIN64) || _MSC_VER < 1400
|
||||
void *operator new( size_t size, int, const char *, int ) {
|
||||
void *operator new( size_t size, int, const char *, int ) throw() {
|
||||
return ::operator new( size );
|
||||
}
|
||||
#endif
|
||||
|
||||
@ -1095,7 +1095,7 @@ static void check_peepmatch_instruction_sequence(FILE *fp, PeepMatch *pmatch, Pe
|
||||
fprintf(fp, " // Identify previous instruction if inside this block\n");
|
||||
fprintf(fp, " if( ");
|
||||
print_block_index(fp, inst_position);
|
||||
fprintf(fp, " > 0 ) {\n Node *n = block->_nodes.at(");
|
||||
fprintf(fp, " > 0 ) {\n Node *n = block->get_node(");
|
||||
print_block_index(fp, inst_position);
|
||||
fprintf(fp, ");\n inst%d = (n->is_Mach()) ? ", inst_position);
|
||||
fprintf(fp, "n->as_Mach() : NULL;\n }\n");
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
|
||||
* Copyright (c) 1997, 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
|
||||
@ -296,8 +296,8 @@ class CodeBuffer: public StackObj {
|
||||
// CodeBuffers must be allocated on the stack except for a single
|
||||
// special case during expansion which is handled internally. This
|
||||
// is done to guarantee proper cleanup of resources.
|
||||
void* operator new(size_t size) { return ResourceObj::operator new(size); }
|
||||
void operator delete(void* p) { ShouldNotCallThis(); }
|
||||
void* operator new(size_t size) throw() { return ResourceObj::operator new(size); }
|
||||
void operator delete(void* p) { ShouldNotCallThis(); }
|
||||
|
||||
public:
|
||||
typedef int csize_t; // code size type; would be size_t except for history
|
||||
|
||||
@ -364,7 +364,8 @@ class PatchingStub: public CodeStub {
|
||||
enum PatchID {
|
||||
access_field_id,
|
||||
load_klass_id,
|
||||
load_mirror_id
|
||||
load_mirror_id,
|
||||
load_appendix_id
|
||||
};
|
||||
enum constants {
|
||||
patch_info_size = 3
|
||||
@ -417,7 +418,7 @@ class PatchingStub: public CodeStub {
|
||||
}
|
||||
NativeMovRegMem* n_move = nativeMovRegMem_at(pc_start());
|
||||
n_move->set_offset(field_offset);
|
||||
} else if (_id == load_klass_id || _id == load_mirror_id) {
|
||||
} else if (_id == load_klass_id || _id == load_mirror_id || _id == load_appendix_id) {
|
||||
assert(_obj != noreg, "must have register object for load_klass/load_mirror");
|
||||
#ifdef ASSERT
|
||||
// verify that we're pointing at a NativeMovConstReg
|
||||
|
||||
@ -74,16 +74,19 @@ class PhaseTraceTime: public TraceTime {
|
||||
private:
|
||||
JavaThread* _thread;
|
||||
CompileLog* _log;
|
||||
TimerName _timer;
|
||||
|
||||
public:
|
||||
PhaseTraceTime(TimerName timer)
|
||||
: TraceTime("", &timers[timer], CITime || CITimeEach, Verbose), _log(NULL) {
|
||||
: TraceTime("", &timers[timer], CITime || CITimeEach, Verbose),
|
||||
_log(NULL), _timer(timer)
|
||||
{
|
||||
if (Compilation::current() != NULL) {
|
||||
_log = Compilation::current()->log();
|
||||
}
|
||||
|
||||
if (_log != NULL) {
|
||||
_log->begin_head("phase name='%s'", timer_name[timer]);
|
||||
_log->begin_head("phase name='%s'", timer_name[_timer]);
|
||||
_log->stamp();
|
||||
_log->end_head();
|
||||
}
|
||||
@ -91,7 +94,7 @@ class PhaseTraceTime: public TraceTime {
|
||||
|
||||
~PhaseTraceTime() {
|
||||
if (_log != NULL)
|
||||
_log->done("phase");
|
||||
_log->done("phase name='%s'", timer_name[_timer]);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
@ -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
|
||||
@ -279,8 +279,8 @@ class InstructionMark: public StackObj {
|
||||
// Base class for objects allocated by the compiler in the compilation arena
|
||||
class CompilationResourceObj ALLOCATION_SUPER_CLASS_SPEC {
|
||||
public:
|
||||
void* operator new(size_t size) { return Compilation::current()->arena()->Amalloc(size); }
|
||||
void* operator new(size_t size, Arena* arena) {
|
||||
void* operator new(size_t size) throw() { return Compilation::current()->arena()->Amalloc(size); }
|
||||
void* operator new(size_t size, Arena* arena) throw() {
|
||||
return arena->Amalloc(size);
|
||||
}
|
||||
void operator delete(void* p) {} // nothing to do
|
||||
|
||||
@ -1583,7 +1583,7 @@ void GraphBuilder::access_field(Bytecodes::Code code) {
|
||||
ObjectType* obj_type = obj->type()->as_ObjectType();
|
||||
if (obj_type->is_constant() && !PatchALot) {
|
||||
ciObject* const_oop = obj_type->constant_value();
|
||||
if (!const_oop->is_null_object()) {
|
||||
if (!const_oop->is_null_object() && const_oop->is_loaded()) {
|
||||
if (field->is_constant()) {
|
||||
ciConstant field_val = field->constant_value_of(const_oop);
|
||||
BasicType field_type = field_val.basic_type();
|
||||
@ -1667,9 +1667,8 @@ void GraphBuilder::invoke(Bytecodes::Code code) {
|
||||
const Bytecodes::Code bc_raw = stream()->cur_bc_raw();
|
||||
assert(declared_signature != NULL, "cannot be null");
|
||||
|
||||
// FIXME bail out for now
|
||||
if (Bytecodes::has_optional_appendix(bc_raw) && !will_link) {
|
||||
BAILOUT("unlinked call site (FIXME needs patching or recompile support)");
|
||||
if (!C1PatchInvokeDynamic && Bytecodes::has_optional_appendix(bc_raw) && !will_link) {
|
||||
BAILOUT("unlinked call site (C1PatchInvokeDynamic is off)");
|
||||
}
|
||||
|
||||
// we have to make sure the argument size (incl. the receiver)
|
||||
@ -1713,10 +1712,23 @@ void GraphBuilder::invoke(Bytecodes::Code code) {
|
||||
code = target->is_static() ? Bytecodes::_invokestatic : Bytecodes::_invokespecial;
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
if (bc_raw == Bytecodes::_invokehandle) {
|
||||
assert(!will_link, "should come here only for unlinked call");
|
||||
code = Bytecodes::_invokespecial;
|
||||
}
|
||||
}
|
||||
|
||||
// Push appendix argument (MethodType, CallSite, etc.), if one.
|
||||
if (stream()->has_appendix()) {
|
||||
bool patch_for_appendix = false;
|
||||
int patching_appendix_arg = 0;
|
||||
if (C1PatchInvokeDynamic &&
|
||||
(Bytecodes::has_optional_appendix(bc_raw) && (!will_link || PatchALot))) {
|
||||
Value arg = append(new Constant(new ObjectConstant(compilation()->env()->unloaded_ciinstance()), copy_state_before()));
|
||||
apush(arg);
|
||||
patch_for_appendix = true;
|
||||
patching_appendix_arg = (will_link && stream()->has_appendix()) ? 0 : 1;
|
||||
} else if (stream()->has_appendix()) {
|
||||
ciObject* appendix = stream()->get_appendix();
|
||||
Value arg = append(new Constant(new ObjectConstant(appendix)));
|
||||
apush(arg);
|
||||
@ -1732,7 +1744,8 @@ void GraphBuilder::invoke(Bytecodes::Code code) {
|
||||
if (UseCHA && DeoptC1 && klass->is_loaded() && target->is_loaded() &&
|
||||
!(// %%% FIXME: Are both of these relevant?
|
||||
target->is_method_handle_intrinsic() ||
|
||||
target->is_compiled_lambda_form())) {
|
||||
target->is_compiled_lambda_form()) &&
|
||||
!patch_for_appendix) {
|
||||
Value receiver = NULL;
|
||||
ciInstanceKlass* receiver_klass = NULL;
|
||||
bool type_is_exact = false;
|
||||
@ -1850,7 +1863,8 @@ void GraphBuilder::invoke(Bytecodes::Code code) {
|
||||
// check if we could do inlining
|
||||
if (!PatchALot && Inline && klass->is_loaded() &&
|
||||
(klass->is_initialized() || klass->is_interface() && target->holder()->is_initialized())
|
||||
&& target->is_loaded()) {
|
||||
&& target->is_loaded()
|
||||
&& !patch_for_appendix) {
|
||||
// callee is known => check if we have static binding
|
||||
assert(target->is_loaded(), "callee must be known");
|
||||
if (code == Bytecodes::_invokestatic ||
|
||||
@ -1901,7 +1915,7 @@ void GraphBuilder::invoke(Bytecodes::Code code) {
|
||||
code == Bytecodes::_invokespecial ||
|
||||
code == Bytecodes::_invokevirtual ||
|
||||
code == Bytecodes::_invokeinterface;
|
||||
Values* args = state()->pop_arguments(target->arg_size_no_receiver());
|
||||
Values* args = state()->pop_arguments(target->arg_size_no_receiver() + patching_appendix_arg);
|
||||
Value recv = has_receiver ? apop() : NULL;
|
||||
int vtable_index = Method::invalid_vtable_index;
|
||||
|
||||
|
||||
@ -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
|
||||
@ -323,7 +323,7 @@ class Instruction: public CompilationResourceObj {
|
||||
}
|
||||
|
||||
public:
|
||||
void* operator new(size_t size) {
|
||||
void* operator new(size_t size) throw() {
|
||||
Compilation* c = Compilation::current();
|
||||
void* res = c->arena()->Amalloc(size);
|
||||
((Instruction*)res)->_id = c->get_next_id();
|
||||
@ -1611,7 +1611,7 @@ LEAF(BlockBegin, StateSplit)
|
||||
friend class SuxAndWeightAdjuster;
|
||||
|
||||
public:
|
||||
void* operator new(size_t size) {
|
||||
void* operator new(size_t size) throw() {
|
||||
Compilation* c = Compilation::current();
|
||||
void* res = c->arena()->Amalloc(size);
|
||||
((BlockBegin*)res)->_id = c->get_next_id();
|
||||
|
||||
@ -1211,8 +1211,6 @@ class LIR_OpJavaCall: public LIR_OpCall {
|
||||
bool is_invokedynamic() const { return code() == lir_dynamic_call; }
|
||||
bool is_method_handle_invoke() const {
|
||||
return
|
||||
is_invokedynamic() // An invokedynamic is always a MethodHandle call site.
|
||||
||
|
||||
method()->is_compiled_lambda_form() // Java-generated adapter
|
||||
||
|
||||
method()->is_method_handle_intrinsic(); // JVM-generated MH intrinsic
|
||||
|
||||
@ -93,12 +93,23 @@ void LIR_Assembler::patching_epilog(PatchingStub* patch, LIR_PatchCode patch_cod
|
||||
default:
|
||||
ShouldNotReachHere();
|
||||
}
|
||||
} else if (patch->id() == PatchingStub::load_appendix_id) {
|
||||
Bytecodes::Code bc_raw = info->scope()->method()->raw_code_at_bci(info->stack()->bci());
|
||||
assert(Bytecodes::has_optional_appendix(bc_raw), "unexpected appendix resolution");
|
||||
} else {
|
||||
ShouldNotReachHere();
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
PatchingStub::PatchID LIR_Assembler::patching_id(CodeEmitInfo* info) {
|
||||
IRScope* scope = info->scope();
|
||||
Bytecodes::Code bc_raw = scope->method()->raw_code_at_bci(info->stack()->bci());
|
||||
if (Bytecodes::has_optional_appendix(bc_raw)) {
|
||||
return PatchingStub::load_appendix_id;
|
||||
}
|
||||
return PatchingStub::load_mirror_id;
|
||||
}
|
||||
|
||||
//---------------------------------------------------------------
|
||||
|
||||
|
||||
@ -119,6 +119,8 @@ class LIR_Assembler: public CompilationResourceObj {
|
||||
|
||||
void comp_op(LIR_Condition condition, LIR_Opr src, LIR_Opr result, LIR_Op2* op);
|
||||
|
||||
PatchingStub::PatchID patching_id(CodeEmitInfo* info);
|
||||
|
||||
public:
|
||||
LIR_Assembler(Compilation* c);
|
||||
~LIR_Assembler();
|
||||
|
||||
@ -819,6 +819,7 @@ JRT_ENTRY(void, Runtime1::patch_code(JavaThread* thread, Runtime1::StubID stub_i
|
||||
KlassHandle init_klass(THREAD, NULL); // klass needed by load_klass_patching code
|
||||
KlassHandle load_klass(THREAD, NULL); // klass needed by load_klass_patching code
|
||||
Handle mirror(THREAD, NULL); // oop needed by load_mirror_patching code
|
||||
Handle appendix(THREAD, NULL); // oop needed by appendix_patching code
|
||||
bool load_klass_or_mirror_patch_id =
|
||||
(stub_id == Runtime1::load_klass_patching_id || stub_id == Runtime1::load_mirror_patching_id);
|
||||
|
||||
@ -888,10 +889,32 @@ JRT_ENTRY(void, Runtime1::patch_code(JavaThread* thread, Runtime1::StubID stub_i
|
||||
mirror = Handle(THREAD, m);
|
||||
}
|
||||
break;
|
||||
default: Unimplemented();
|
||||
default: fatal("unexpected bytecode for load_klass_or_mirror_patch_id");
|
||||
}
|
||||
// convert to handle
|
||||
load_klass = KlassHandle(THREAD, k);
|
||||
} else if (stub_id == load_appendix_patching_id) {
|
||||
Bytecode_invoke bytecode(caller_method, bci);
|
||||
Bytecodes::Code bc = bytecode.invoke_code();
|
||||
|
||||
CallInfo info;
|
||||
constantPoolHandle pool(thread, caller_method->constants());
|
||||
int index = bytecode.index();
|
||||
LinkResolver::resolve_invoke(info, Handle(), pool, index, bc, CHECK);
|
||||
appendix = info.resolved_appendix();
|
||||
switch (bc) {
|
||||
case Bytecodes::_invokehandle: {
|
||||
int cache_index = ConstantPool::decode_cpcache_index(index, true);
|
||||
assert(cache_index >= 0 && cache_index < pool->cache()->length(), "unexpected cache index");
|
||||
pool->cache()->entry_at(cache_index)->set_method_handle(pool, info);
|
||||
break;
|
||||
}
|
||||
case Bytecodes::_invokedynamic: {
|
||||
pool->invokedynamic_cp_cache_entry_at(index)->set_dynamic_call(pool, info);
|
||||
break;
|
||||
}
|
||||
default: fatal("unexpected bytecode for load_appendix_patching_id");
|
||||
}
|
||||
} else {
|
||||
ShouldNotReachHere();
|
||||
}
|
||||
@ -992,8 +1015,8 @@ JRT_ENTRY(void, Runtime1::patch_code(JavaThread* thread, Runtime1::StubID stub_i
|
||||
n_copy->data() == (intptr_t)Universe::non_oop_word(),
|
||||
"illegal init value");
|
||||
if (stub_id == Runtime1::load_klass_patching_id) {
|
||||
assert(load_klass() != NULL, "klass not set");
|
||||
n_copy->set_data((intx) (load_klass()));
|
||||
assert(load_klass() != NULL, "klass not set");
|
||||
n_copy->set_data((intx) (load_klass()));
|
||||
} else {
|
||||
assert(mirror() != NULL, "klass not set");
|
||||
n_copy->set_data((intx) (mirror()));
|
||||
@ -1002,43 +1025,55 @@ JRT_ENTRY(void, Runtime1::patch_code(JavaThread* thread, Runtime1::StubID stub_i
|
||||
if (TracePatching) {
|
||||
Disassembler::decode(copy_buff, copy_buff + *byte_count, tty);
|
||||
}
|
||||
}
|
||||
} else if (stub_id == Runtime1::load_appendix_patching_id) {
|
||||
NativeMovConstReg* n_copy = nativeMovConstReg_at(copy_buff);
|
||||
assert(n_copy->data() == 0 ||
|
||||
n_copy->data() == (intptr_t)Universe::non_oop_word(),
|
||||
"illegal init value");
|
||||
n_copy->set_data((intx) (appendix()));
|
||||
|
||||
#if defined(SPARC) || defined(PPC)
|
||||
// Update the location in the nmethod with the proper
|
||||
// metadata. When the code was generated, a NULL was stuffed
|
||||
// in the metadata table and that table needs to be update to
|
||||
// have the right value. On intel the value is kept
|
||||
// directly in the instruction instead of in the metadata
|
||||
// table, so set_data above effectively updated the value.
|
||||
nmethod* nm = CodeCache::find_nmethod(instr_pc);
|
||||
assert(nm != NULL, "invalid nmethod_pc");
|
||||
RelocIterator mds(nm, copy_buff, copy_buff + 1);
|
||||
bool found = false;
|
||||
while (mds.next() && !found) {
|
||||
if (mds.type() == relocInfo::oop_type) {
|
||||
assert(stub_id == Runtime1::load_mirror_patching_id, "wrong stub id");
|
||||
oop_Relocation* r = mds.oop_reloc();
|
||||
oop* oop_adr = r->oop_addr();
|
||||
*oop_adr = mirror();
|
||||
r->fix_oop_relocation();
|
||||
found = true;
|
||||
} else if (mds.type() == relocInfo::metadata_type) {
|
||||
assert(stub_id == Runtime1::load_klass_patching_id, "wrong stub id");
|
||||
metadata_Relocation* r = mds.metadata_reloc();
|
||||
Metadata** metadata_adr = r->metadata_addr();
|
||||
*metadata_adr = load_klass();
|
||||
r->fix_metadata_relocation();
|
||||
found = true;
|
||||
}
|
||||
}
|
||||
assert(found, "the metadata must exist!");
|
||||
#endif
|
||||
|
||||
if (TracePatching) {
|
||||
Disassembler::decode(copy_buff, copy_buff + *byte_count, tty);
|
||||
}
|
||||
} else {
|
||||
ShouldNotReachHere();
|
||||
}
|
||||
|
||||
#if defined(SPARC) || defined(PPC)
|
||||
if (load_klass_or_mirror_patch_id ||
|
||||
stub_id == Runtime1::load_appendix_patching_id) {
|
||||
// Update the location in the nmethod with the proper
|
||||
// metadata. When the code was generated, a NULL was stuffed
|
||||
// in the metadata table and that table needs to be update to
|
||||
// have the right value. On intel the value is kept
|
||||
// directly in the instruction instead of in the metadata
|
||||
// table, so set_data above effectively updated the value.
|
||||
nmethod* nm = CodeCache::find_nmethod(instr_pc);
|
||||
assert(nm != NULL, "invalid nmethod_pc");
|
||||
RelocIterator mds(nm, copy_buff, copy_buff + 1);
|
||||
bool found = false;
|
||||
while (mds.next() && !found) {
|
||||
if (mds.type() == relocInfo::oop_type) {
|
||||
assert(stub_id == Runtime1::load_mirror_patching_id ||
|
||||
stub_id == Runtime1::load_appendix_patching_id, "wrong stub id");
|
||||
oop_Relocation* r = mds.oop_reloc();
|
||||
oop* oop_adr = r->oop_addr();
|
||||
*oop_adr = stub_id == Runtime1::load_mirror_patching_id ? mirror() : appendix();
|
||||
r->fix_oop_relocation();
|
||||
found = true;
|
||||
} else if (mds.type() == relocInfo::metadata_type) {
|
||||
assert(stub_id == Runtime1::load_klass_patching_id, "wrong stub id");
|
||||
metadata_Relocation* r = mds.metadata_reloc();
|
||||
Metadata** metadata_adr = r->metadata_addr();
|
||||
*metadata_adr = load_klass();
|
||||
r->fix_metadata_relocation();
|
||||
found = true;
|
||||
}
|
||||
}
|
||||
assert(found, "the metadata must exist!");
|
||||
}
|
||||
#endif
|
||||
if (do_patch) {
|
||||
// replace instructions
|
||||
// first replace the tail, then the call
|
||||
@ -1077,7 +1112,8 @@ JRT_ENTRY(void, Runtime1::patch_code(JavaThread* thread, Runtime1::StubID stub_i
|
||||
ICache::invalidate_range(instr_pc, *byte_count);
|
||||
NativeGeneralJump::replace_mt_safe(instr_pc, copy_buff);
|
||||
|
||||
if (load_klass_or_mirror_patch_id) {
|
||||
if (load_klass_or_mirror_patch_id ||
|
||||
stub_id == Runtime1::load_appendix_patching_id) {
|
||||
relocInfo::relocType rtype =
|
||||
(stub_id == Runtime1::load_klass_patching_id) ?
|
||||
relocInfo::metadata_type :
|
||||
@ -1118,7 +1154,8 @@ JRT_ENTRY(void, Runtime1::patch_code(JavaThread* thread, Runtime1::StubID stub_i
|
||||
|
||||
// If we are patching in a non-perm oop, make sure the nmethod
|
||||
// is on the right list.
|
||||
if (ScavengeRootsInCode && mirror.not_null() && mirror()->is_scavengable()) {
|
||||
if (ScavengeRootsInCode && ((mirror.not_null() && mirror()->is_scavengable()) ||
|
||||
(appendix.not_null() && appendix->is_scavengable()))) {
|
||||
MutexLockerEx ml_code (CodeCache_lock, Mutex::_no_safepoint_check_flag);
|
||||
nmethod* nm = CodeCache::find_nmethod(caller_frame.pc());
|
||||
guarantee(nm != NULL, "only nmethods can contain non-perm oops");
|
||||
@ -1179,6 +1216,24 @@ int Runtime1::move_mirror_patching(JavaThread* thread) {
|
||||
return caller_is_deopted();
|
||||
}
|
||||
|
||||
int Runtime1::move_appendix_patching(JavaThread* thread) {
|
||||
//
|
||||
// NOTE: we are still in Java
|
||||
//
|
||||
Thread* THREAD = thread;
|
||||
debug_only(NoHandleMark nhm;)
|
||||
{
|
||||
// Enter VM mode
|
||||
|
||||
ResetNoHandleMark rnhm;
|
||||
patch_code(thread, load_appendix_patching_id);
|
||||
}
|
||||
// Back in JAVA, use no oops DON'T safepoint
|
||||
|
||||
// Return true if calling code is deoptimized
|
||||
|
||||
return caller_is_deopted();
|
||||
}
|
||||
//
|
||||
// Entry point for compiled code. We want to patch a nmethod.
|
||||
// We don't do a normal VM transition here because we want to
|
||||
|
||||
@ -67,6 +67,7 @@ class StubAssembler;
|
||||
stub(access_field_patching) \
|
||||
stub(load_klass_patching) \
|
||||
stub(load_mirror_patching) \
|
||||
stub(load_appendix_patching) \
|
||||
stub(g1_pre_barrier_slow) \
|
||||
stub(g1_post_barrier_slow) \
|
||||
stub(fpu2long_stub) \
|
||||
@ -160,6 +161,7 @@ class Runtime1: public AllStatic {
|
||||
static int access_field_patching(JavaThread* thread);
|
||||
static int move_klass_patching(JavaThread* thread);
|
||||
static int move_mirror_patching(JavaThread* thread);
|
||||
static int move_appendix_patching(JavaThread* thread);
|
||||
|
||||
static void patch_code(JavaThread* thread, StubID stub_id);
|
||||
|
||||
|
||||
@ -25,4 +25,4 @@
|
||||
#include "precompiled.hpp"
|
||||
#include "c1/c1_globals.hpp"
|
||||
|
||||
C1_FLAGS(MATERIALIZE_DEVELOPER_FLAG, MATERIALIZE_PD_DEVELOPER_FLAG, MATERIALIZE_PRODUCT_FLAG, MATERIALIZE_PD_PRODUCT_FLAG, MATERIALIZE_NOTPRODUCT_FLAG)
|
||||
C1_FLAGS(MATERIALIZE_DEVELOPER_FLAG, MATERIALIZE_PD_DEVELOPER_FLAG, MATERIALIZE_PRODUCT_FLAG, MATERIALIZE_PD_PRODUCT_FLAG, MATERIALIZE_DIAGNOSTIC_FLAG, MATERIALIZE_NOTPRODUCT_FLAG)
|
||||
|
||||
@ -54,7 +54,7 @@
|
||||
//
|
||||
// Defines all global flags used by the client compiler.
|
||||
//
|
||||
#define C1_FLAGS(develop, develop_pd, product, product_pd, notproduct) \
|
||||
#define C1_FLAGS(develop, develop_pd, product, product_pd, diagnostic, notproduct) \
|
||||
\
|
||||
/* Printing */ \
|
||||
notproduct(bool, PrintC1Statistics, false, \
|
||||
@ -333,15 +333,19 @@
|
||||
"Use CHA and exact type results at call sites when updating MDOs")\
|
||||
\
|
||||
product(bool, C1UpdateMethodData, trueInTiered, \
|
||||
"Update MethodData*s in Tier1-generated code") \
|
||||
"Update MethodData*s in Tier1-generated code") \
|
||||
\
|
||||
develop(bool, PrintCFGToFile, false, \
|
||||
"print control flow graph to a separate file during compilation") \
|
||||
\
|
||||
diagnostic(bool, C1PatchInvokeDynamic, true, \
|
||||
"Patch invokedynamic appendix not known at compile time") \
|
||||
\
|
||||
\
|
||||
|
||||
|
||||
// Read default values for c1 globals
|
||||
|
||||
C1_FLAGS(DECLARE_DEVELOPER_FLAG, DECLARE_PD_DEVELOPER_FLAG, DECLARE_PRODUCT_FLAG, DECLARE_PD_PRODUCT_FLAG, DECLARE_NOTPRODUCT_FLAG)
|
||||
C1_FLAGS(DECLARE_DEVELOPER_FLAG, DECLARE_PD_DEVELOPER_FLAG, DECLARE_PRODUCT_FLAG, DECLARE_PD_PRODUCT_FLAG, DECLARE_DIAGNOSTIC_FLAG, DECLARE_NOTPRODUCT_FLAG)
|
||||
|
||||
#endif // SHARE_VM_C1_C1_GLOBALS_HPP
|
||||
|
||||
@ -24,13 +24,92 @@
|
||||
|
||||
#include "precompiled.hpp"
|
||||
#include "ci/ciArray.hpp"
|
||||
#include "ci/ciArrayKlass.hpp"
|
||||
#include "ci/ciConstant.hpp"
|
||||
#include "ci/ciKlass.hpp"
|
||||
#include "ci/ciUtilities.hpp"
|
||||
#include "oops/objArrayOop.hpp"
|
||||
#include "oops/typeArrayOop.hpp"
|
||||
|
||||
// ciArray
|
||||
//
|
||||
// This class represents an arrayOop in the HotSpot virtual
|
||||
// machine.
|
||||
static BasicType fixup_element_type(BasicType bt) {
|
||||
if (bt == T_ARRAY) return T_OBJECT;
|
||||
if (bt == T_BOOLEAN) return T_BYTE;
|
||||
return bt;
|
||||
}
|
||||
|
||||
ciConstant ciArray::element_value_impl(BasicType elembt,
|
||||
arrayOop ary,
|
||||
int index) {
|
||||
if (ary == NULL)
|
||||
return ciConstant();
|
||||
assert(ary->is_array(), "");
|
||||
if (index < 0 || index >= ary->length())
|
||||
return ciConstant();
|
||||
ArrayKlass* ak = (ArrayKlass*) ary->klass();
|
||||
BasicType abt = ak->element_type();
|
||||
if (fixup_element_type(elembt) !=
|
||||
fixup_element_type(abt))
|
||||
return ciConstant();
|
||||
switch (elembt) {
|
||||
case T_ARRAY:
|
||||
case T_OBJECT:
|
||||
{
|
||||
assert(ary->is_objArray(), "");
|
||||
objArrayOop objary = (objArrayOop) ary;
|
||||
oop elem = objary->obj_at(index);
|
||||
ciEnv* env = CURRENT_ENV;
|
||||
ciObject* box = env->get_object(elem);
|
||||
return ciConstant(T_OBJECT, box);
|
||||
}
|
||||
}
|
||||
assert(ary->is_typeArray(), "");
|
||||
typeArrayOop tary = (typeArrayOop) ary;
|
||||
jint value = 0;
|
||||
switch (elembt) {
|
||||
case T_LONG: return ciConstant(tary->long_at(index));
|
||||
case T_FLOAT: return ciConstant(tary->float_at(index));
|
||||
case T_DOUBLE: return ciConstant(tary->double_at(index));
|
||||
default: return ciConstant();
|
||||
case T_BYTE: value = tary->byte_at(index); break;
|
||||
case T_BOOLEAN: value = tary->byte_at(index) & 1; break;
|
||||
case T_SHORT: value = tary->short_at(index); break;
|
||||
case T_CHAR: value = tary->char_at(index); break;
|
||||
case T_INT: value = tary->int_at(index); break;
|
||||
}
|
||||
return ciConstant(elembt, value);
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------
|
||||
// ciArray::element_value
|
||||
//
|
||||
// Current value of an element.
|
||||
// Returns T_ILLEGAL if there is no element at the given index.
|
||||
ciConstant ciArray::element_value(int index) {
|
||||
BasicType elembt = element_basic_type();
|
||||
GUARDED_VM_ENTRY(
|
||||
return element_value_impl(elembt, get_arrayOop(), index);
|
||||
)
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------
|
||||
// ciArray::element_value_by_offset
|
||||
//
|
||||
// Current value of an element at the specified offset.
|
||||
// Returns T_ILLEGAL if there is no element at the given offset.
|
||||
ciConstant ciArray::element_value_by_offset(intptr_t element_offset) {
|
||||
BasicType elembt = element_basic_type();
|
||||
intptr_t shift = exact_log2(type2aelembytes(elembt));
|
||||
intptr_t header = arrayOopDesc::base_offset_in_bytes(elembt);
|
||||
intptr_t index = (element_offset - header) >> shift;
|
||||
intptr_t offset = header + ((intptr_t)index << shift);
|
||||
if (offset != element_offset || index != (jint)index)
|
||||
return ciConstant();
|
||||
return element_value((jint) index);
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------
|
||||
// ciArray::print_impl
|
||||
|
||||
@ -25,6 +25,8 @@
|
||||
#ifndef SHARE_VM_CI_CIARRAY_HPP
|
||||
#define SHARE_VM_CI_CIARRAY_HPP
|
||||
|
||||
#include "ci/ciArrayKlass.hpp"
|
||||
#include "ci/ciConstant.hpp"
|
||||
#include "ci/ciObject.hpp"
|
||||
#include "oops/arrayOop.hpp"
|
||||
#include "oops/objArrayOop.hpp"
|
||||
@ -45,15 +47,30 @@ protected:
|
||||
|
||||
ciArray(ciKlass* klass, int len) : ciObject(klass), _length(len) {}
|
||||
|
||||
arrayOop get_arrayOop() { return (arrayOop)get_oop(); }
|
||||
arrayOop get_arrayOop() const { return (arrayOop)get_oop(); }
|
||||
|
||||
const char* type_string() { return "ciArray"; }
|
||||
|
||||
void print_impl(outputStream* st);
|
||||
|
||||
ciConstant element_value_impl(BasicType elembt, arrayOop ary, int index);
|
||||
|
||||
public:
|
||||
int length() { return _length; }
|
||||
|
||||
// Convenience routines.
|
||||
ciArrayKlass* array_type() { return klass()->as_array_klass(); }
|
||||
ciType* element_type() { return array_type()->element_type(); }
|
||||
BasicType element_basic_type() { return element_type()->basic_type(); }
|
||||
|
||||
// Current value of an element.
|
||||
// Returns T_ILLEGAL if there is no element at the given index.
|
||||
ciConstant element_value(int index);
|
||||
|
||||
// Current value of an element at the specified offset.
|
||||
// Returns T_ILLEGAL if there is no element at the given offset.
|
||||
ciConstant element_value_by_offset(intptr_t element_offset);
|
||||
|
||||
// What kind of ciObject is this?
|
||||
bool is_array() { return true; }
|
||||
bool is_java_object() { return true; }
|
||||
|
||||
@ -41,7 +41,6 @@ private:
|
||||
union {
|
||||
jint _int;
|
||||
jlong _long;
|
||||
jint _long_half[2];
|
||||
jfloat _float;
|
||||
jdouble _double;
|
||||
ciObject* _object;
|
||||
@ -111,6 +110,20 @@ public:
|
||||
return _value._object;
|
||||
}
|
||||
|
||||
bool is_null_or_zero() const {
|
||||
if (!is_java_primitive(basic_type())) {
|
||||
return as_object()->is_null_object();
|
||||
} else if (type2size[basic_type()] == 1) {
|
||||
// treat float bits as int, to avoid comparison with -0 and NaN
|
||||
return (_value._int == 0);
|
||||
} else if (type2size[basic_type()] == 2) {
|
||||
// treat double bits as long, to avoid comparison with -0 and NaN
|
||||
return (_value._long == 0);
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// Debugging output
|
||||
void print();
|
||||
};
|
||||
|
||||
@ -1150,6 +1150,10 @@ void ciEnv::record_out_of_memory_failure() {
|
||||
record_method_not_compilable("out of memory");
|
||||
}
|
||||
|
||||
ciInstance* ciEnv::unloaded_ciinstance() {
|
||||
GUARDED_VM_ENTRY(return _factory->get_unloaded_object_constant();)
|
||||
}
|
||||
|
||||
void ciEnv::dump_replay_data(outputStream* out) {
|
||||
VM_ENTRY_MARK;
|
||||
MutexLocker ml(Compile_lock);
|
||||
|
||||
@ -400,6 +400,7 @@ public:
|
||||
static ciInstanceKlass* unloaded_ciinstance_klass() {
|
||||
return _unloaded_ciinstance_klass;
|
||||
}
|
||||
ciInstance* unloaded_ciinstance();
|
||||
|
||||
ciKlass* find_system_klass(ciSymbol* klass_name);
|
||||
// Note: To find a class from its name string, use ciSymbol::make,
|
||||
|
||||
@ -189,12 +189,14 @@ void ciField::initialize_from(fieldDescriptor* fd) {
|
||||
_holder = CURRENT_ENV->get_instance_klass(fd->field_holder());
|
||||
|
||||
// Check to see if the field is constant.
|
||||
if (_holder->is_initialized() && this->is_final()) {
|
||||
bool is_final = this->is_final();
|
||||
bool is_stable = FoldStableValues && this->is_stable();
|
||||
if (_holder->is_initialized() && (is_final || is_stable)) {
|
||||
if (!this->is_static()) {
|
||||
// A field can be constant if it's a final static field or if
|
||||
// it's a final non-static field of a trusted class (classes in
|
||||
// java.lang.invoke and sun.invoke packages and subpackages).
|
||||
if (trust_final_non_static_fields(_holder)) {
|
||||
if (is_stable || trust_final_non_static_fields(_holder)) {
|
||||
_is_constant = true;
|
||||
return;
|
||||
}
|
||||
@ -227,7 +229,6 @@ void ciField::initialize_from(fieldDescriptor* fd) {
|
||||
|
||||
Handle mirror = k->java_mirror();
|
||||
|
||||
_is_constant = true;
|
||||
switch(type()->basic_type()) {
|
||||
case T_BYTE:
|
||||
_constant_value = ciConstant(type()->basic_type(), mirror->byte_field(_offset));
|
||||
@ -273,6 +274,12 @@ void ciField::initialize_from(fieldDescriptor* fd) {
|
||||
}
|
||||
}
|
||||
}
|
||||
if (is_stable && _constant_value.is_null_or_zero()) {
|
||||
// It is not a constant after all; treat it as uninitialized.
|
||||
_is_constant = false;
|
||||
} else {
|
||||
_is_constant = true;
|
||||
}
|
||||
} else {
|
||||
_is_constant = false;
|
||||
}
|
||||
@ -373,8 +380,11 @@ void ciField::print() {
|
||||
tty->print(" signature=");
|
||||
_signature->print_symbol();
|
||||
tty->print(" offset=%d type=", _offset);
|
||||
if (_type != NULL) _type->print_name();
|
||||
else tty->print("(reference)");
|
||||
if (_type != NULL)
|
||||
_type->print_name();
|
||||
else
|
||||
tty->print("(reference)");
|
||||
tty->print(" flags=%04x", flags().as_int());
|
||||
tty->print(" is_constant=%s", bool_to_str(_is_constant));
|
||||
if (_is_constant && is_static()) {
|
||||
tty->print(" constant_value=");
|
||||
|
||||
@ -139,7 +139,10 @@ public:
|
||||
// non-constant fields. These are java.lang.System.in
|
||||
// and java.lang.System.out. Abomination.
|
||||
//
|
||||
// Note: the check for case 4 is not yet implemented.
|
||||
// A field is also considered constant if it is marked @Stable
|
||||
// and is non-null (or non-zero, if a primitive).
|
||||
// For non-static fields, the null/zero check must be
|
||||
// arranged by the user, as constant_value().is_null_or_zero().
|
||||
bool is_constant() { return _is_constant; }
|
||||
|
||||
// Get the constant value of this field.
|
||||
@ -173,6 +176,7 @@ public:
|
||||
bool is_protected () { return flags().is_protected(); }
|
||||
bool is_static () { return flags().is_static(); }
|
||||
bool is_final () { return flags().is_final(); }
|
||||
bool is_stable () { return flags().is_stable(); }
|
||||
bool is_volatile () { return flags().is_volatile(); }
|
||||
bool is_transient () { return flags().is_transient(); }
|
||||
|
||||
|
||||
@ -59,6 +59,7 @@ public:
|
||||
bool is_interface () const { return (_flags & JVM_ACC_INTERFACE ) != 0; }
|
||||
bool is_abstract () const { return (_flags & JVM_ACC_ABSTRACT ) != 0; }
|
||||
bool is_strict () const { return (_flags & JVM_ACC_STRICT ) != 0; }
|
||||
bool is_stable () const { return (_flags & JVM_ACC_FIELD_STABLE) != 0; }
|
||||
|
||||
// Conversion
|
||||
jint as_int() { return _flags; }
|
||||
|
||||
@ -60,10 +60,10 @@ ciType* ciInstance::java_mirror_type() {
|
||||
//
|
||||
// Constant value of a field.
|
||||
ciConstant ciInstance::field_value(ciField* field) {
|
||||
assert(is_loaded() &&
|
||||
field->holder()->is_loaded() &&
|
||||
klass()->is_subclass_of(field->holder()),
|
||||
"invalid access");
|
||||
assert(is_loaded(), "invalid access - must be loaded");
|
||||
assert(field->holder()->is_loaded(), "invalid access - holder must be loaded");
|
||||
assert(klass()->is_subclass_of(field->holder()), "invalid access - must be subclass");
|
||||
|
||||
VM_ENTRY_MARK;
|
||||
ciConstant result;
|
||||
Handle obj = get_oop();
|
||||
@ -127,6 +127,8 @@ ciConstant ciInstance::field_value(ciField* field) {
|
||||
ciConstant ciInstance::field_value_by_offset(int field_offset) {
|
||||
ciInstanceKlass* ik = klass()->as_instance_klass();
|
||||
ciField* field = ik->get_field_by_offset(field_offset, false);
|
||||
if (field == NULL)
|
||||
return ciConstant(); // T_ILLEGAL
|
||||
return field_value(field);
|
||||
}
|
||||
|
||||
|
||||
@ -177,6 +177,10 @@ class ciMethod : public ciMetadata {
|
||||
address bcp = code() + bci;
|
||||
return Bytecodes::java_code_at(NULL, bcp);
|
||||
}
|
||||
Bytecodes::Code raw_code_at_bci(int bci) {
|
||||
address bcp = code() + bci;
|
||||
return Bytecodes::code_at(NULL, bcp);
|
||||
}
|
||||
BCEscapeAnalyzer *get_bcea();
|
||||
ciMethodBlocks *get_method_blocks();
|
||||
|
||||
|
||||
@ -563,7 +563,10 @@ ciInstance* ciObjectFactory::get_unloaded_method_type_constant(ciSymbol* signatu
|
||||
return get_unloaded_instance(ciEnv::_MethodType_klass->as_instance_klass());
|
||||
}
|
||||
|
||||
|
||||
ciInstance* ciObjectFactory::get_unloaded_object_constant() {
|
||||
if (ciEnv::_Object_klass == NULL) return NULL;
|
||||
return get_unloaded_instance(ciEnv::_Object_klass->as_instance_klass());
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------
|
||||
// ciObjectFactory::get_empty_methodData
|
||||
|
||||
@ -131,6 +131,8 @@ public:
|
||||
ciInstance* get_unloaded_method_type_constant(ciSymbol* signature);
|
||||
|
||||
|
||||
ciInstance* get_unloaded_object_constant();
|
||||
|
||||
// Get the ciMethodData representing the methodData for a method
|
||||
// with none.
|
||||
ciMethodData* get_empty_methodData();
|
||||
|
||||
@ -39,5 +39,10 @@
|
||||
jchar ciTypeArray::char_at(int index) {
|
||||
VM_ENTRY_MARK;
|
||||
assert(index >= 0 && index < length(), "out of range");
|
||||
return get_typeArrayOop()->char_at(index);
|
||||
jchar c = get_typeArrayOop()->char_at(index);
|
||||
#ifdef ASSERT
|
||||
jchar d = element_value(index).as_char();
|
||||
assert(c == d, "");
|
||||
#endif //ASSERT
|
||||
return c;
|
||||
}
|
||||
|
||||
@ -28,7 +28,6 @@
|
||||
#include "classfile/classLoaderData.hpp"
|
||||
#include "classfile/classLoaderData.inline.hpp"
|
||||
#include "classfile/defaultMethods.hpp"
|
||||
#include "classfile/genericSignatures.hpp"
|
||||
#include "classfile/javaClasses.hpp"
|
||||
#include "classfile/symbolTable.hpp"
|
||||
#include "classfile/systemDictionary.hpp"
|
||||
@ -1775,6 +1774,10 @@ ClassFileParser::AnnotationCollector::annotation_index(ClassLoaderData* loader_d
|
||||
if (_location != _in_method) break; // only allow for methods
|
||||
if (!privileged) break; // only allow in privileged code
|
||||
return _method_LambdaForm_Hidden;
|
||||
case vmSymbols::VM_SYMBOL_ENUM_NAME(sun_invoke_Stable_signature):
|
||||
if (_location != _in_field) break; // only allow for fields
|
||||
if (!privileged) break; // only allow in privileged code
|
||||
return _field_Stable;
|
||||
case vmSymbols::VM_SYMBOL_ENUM_NAME(sun_misc_Contended_signature):
|
||||
if (_location != _in_field && _location != _in_class) break; // only allow for fields and classes
|
||||
if (!EnableContended || (RestrictContended && !privileged)) break; // honor privileges
|
||||
@ -1787,6 +1790,8 @@ ClassFileParser::AnnotationCollector::annotation_index(ClassLoaderData* loader_d
|
||||
void ClassFileParser::FieldAnnotationCollector::apply_to(FieldInfo* f) {
|
||||
if (is_contended())
|
||||
f->set_contended_group(contended_group());
|
||||
if (is_stable())
|
||||
f->set_stable(true);
|
||||
}
|
||||
|
||||
ClassFileParser::FieldAnnotationCollector::~FieldAnnotationCollector() {
|
||||
@ -3039,35 +3044,6 @@ AnnotationArray* ClassFileParser::assemble_annotations(u1* runtime_visible_annot
|
||||
return annotations;
|
||||
}
|
||||
|
||||
|
||||
#ifdef ASSERT
|
||||
static void parseAndPrintGenericSignatures(
|
||||
instanceKlassHandle this_klass, TRAPS) {
|
||||
assert(ParseAllGenericSignatures == true, "Shouldn't call otherwise");
|
||||
ResourceMark rm;
|
||||
|
||||
if (this_klass->generic_signature() != NULL) {
|
||||
using namespace generic;
|
||||
ClassDescriptor* spec = ClassDescriptor::parse_generic_signature(this_klass(), CHECK);
|
||||
|
||||
tty->print_cr("Parsing %s", this_klass->generic_signature()->as_C_string());
|
||||
spec->print_on(tty);
|
||||
|
||||
for (int i = 0; i < this_klass->methods()->length(); ++i) {
|
||||
Method* m = this_klass->methods()->at(i);
|
||||
MethodDescriptor* method_spec = MethodDescriptor::parse_generic_signature(m, spec);
|
||||
Symbol* sig = m->generic_signature();
|
||||
if (sig == NULL) {
|
||||
sig = m->signature();
|
||||
}
|
||||
tty->print_cr("Parsing %s", sig->as_C_string());
|
||||
method_spec->print_on(tty);
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif // def ASSERT
|
||||
|
||||
|
||||
instanceKlassHandle ClassFileParser::parse_super_class(int super_class_index,
|
||||
TRAPS) {
|
||||
instanceKlassHandle super_klass;
|
||||
@ -4060,12 +4036,6 @@ instanceKlassHandle ClassFileParser::parseClassFile(Symbol* name,
|
||||
java_lang_Class::create_mirror(this_klass, protection_domain, CHECK_(nullHandle));
|
||||
|
||||
|
||||
#ifdef ASSERT
|
||||
if (ParseAllGenericSignatures) {
|
||||
parseAndPrintGenericSignatures(this_klass, CHECK_(nullHandle));
|
||||
}
|
||||
#endif
|
||||
|
||||
// Generate any default methods - default methods are interface methods
|
||||
// that have a default implementation. This is new with Lambda project.
|
||||
if (has_default_methods && !access_flags.is_interface() &&
|
||||
|
||||
@ -125,6 +125,7 @@ class ClassFileParser VALUE_OBJ_CLASS_SPEC {
|
||||
_method_LambdaForm_Compiled,
|
||||
_method_LambdaForm_Hidden,
|
||||
_sun_misc_Contended,
|
||||
_field_Stable,
|
||||
_annotation_LIMIT
|
||||
};
|
||||
const Location _location;
|
||||
@ -143,14 +144,23 @@ class ClassFileParser VALUE_OBJ_CLASS_SPEC {
|
||||
assert((int)id >= 0 && (int)id < (int)_annotation_LIMIT, "oob");
|
||||
_annotations_present |= nth_bit((int)id);
|
||||
}
|
||||
|
||||
void remove_annotation(ID id) {
|
||||
assert((int)id >= 0 && (int)id < (int)_annotation_LIMIT, "oob");
|
||||
_annotations_present &= ~nth_bit((int)id);
|
||||
}
|
||||
|
||||
// Report if the annotation is present.
|
||||
bool has_any_annotations() { return _annotations_present != 0; }
|
||||
bool has_annotation(ID id) { return (nth_bit((int)id) & _annotations_present) != 0; }
|
||||
bool has_any_annotations() const { return _annotations_present != 0; }
|
||||
bool has_annotation(ID id) const { return (nth_bit((int)id) & _annotations_present) != 0; }
|
||||
|
||||
void set_contended_group(u2 group) { _contended_group = group; }
|
||||
u2 contended_group() { return _contended_group; }
|
||||
u2 contended_group() const { return _contended_group; }
|
||||
|
||||
bool is_contended() { return has_annotation(_sun_misc_Contended); }
|
||||
bool is_contended() const { return has_annotation(_sun_misc_Contended); }
|
||||
|
||||
void set_stable(bool stable) { set_annotation(_field_Stable); }
|
||||
bool is_stable() const { return has_annotation(_field_Stable); }
|
||||
};
|
||||
|
||||
// This class also doubles as a holder for metadata cleanup.
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
|
||||
* Copyright (c) 1997, 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
|
||||
@ -197,7 +197,7 @@ ClassPathDirEntry::ClassPathDirEntry(char* dir) : ClassPathEntry() {
|
||||
}
|
||||
|
||||
|
||||
ClassFileStream* ClassPathDirEntry::open_stream(const char* name) {
|
||||
ClassFileStream* ClassPathDirEntry::open_stream(const char* name, TRAPS) {
|
||||
// construct full path name
|
||||
char path[JVM_MAXPATHLEN];
|
||||
if (jio_snprintf(path, sizeof(path), "%s%s%s", _dir, os::file_separator(), name) == -1) {
|
||||
@ -240,7 +240,7 @@ ClassPathZipEntry::~ClassPathZipEntry() {
|
||||
FREE_C_HEAP_ARRAY(char, _zip_name, mtClass);
|
||||
}
|
||||
|
||||
ClassFileStream* ClassPathZipEntry::open_stream(const char* name) {
|
||||
ClassFileStream* ClassPathZipEntry::open_stream(const char* name, TRAPS) {
|
||||
// enable call to C land
|
||||
JavaThread* thread = JavaThread::current();
|
||||
ThreadToNativeFromVM ttn(thread);
|
||||
@ -284,24 +284,24 @@ void ClassPathZipEntry::contents_do(void f(const char* name, void* context), voi
|
||||
}
|
||||
}
|
||||
|
||||
LazyClassPathEntry::LazyClassPathEntry(char* path, struct stat st) : ClassPathEntry() {
|
||||
LazyClassPathEntry::LazyClassPathEntry(char* path, const struct stat* st) : ClassPathEntry() {
|
||||
_path = strdup(path);
|
||||
_st = st;
|
||||
_st = *st;
|
||||
_meta_index = NULL;
|
||||
_resolved_entry = NULL;
|
||||
_has_error = false;
|
||||
}
|
||||
|
||||
bool LazyClassPathEntry::is_jar_file() {
|
||||
return ((_st.st_mode & S_IFREG) == S_IFREG);
|
||||
}
|
||||
|
||||
ClassPathEntry* LazyClassPathEntry::resolve_entry() {
|
||||
ClassPathEntry* LazyClassPathEntry::resolve_entry(TRAPS) {
|
||||
if (_resolved_entry != NULL) {
|
||||
return (ClassPathEntry*) _resolved_entry;
|
||||
}
|
||||
ClassPathEntry* new_entry = NULL;
|
||||
ClassLoader::create_class_path_entry(_path, _st, &new_entry, false);
|
||||
assert(new_entry != NULL, "earlier code should have caught this");
|
||||
new_entry = ClassLoader::create_class_path_entry(_path, &_st, false, CHECK_NULL);
|
||||
{
|
||||
ThreadCritical tc;
|
||||
if (_resolved_entry == NULL) {
|
||||
@ -314,12 +314,21 @@ ClassPathEntry* LazyClassPathEntry::resolve_entry() {
|
||||
return (ClassPathEntry*) _resolved_entry;
|
||||
}
|
||||
|
||||
ClassFileStream* LazyClassPathEntry::open_stream(const char* name) {
|
||||
ClassFileStream* LazyClassPathEntry::open_stream(const char* name, TRAPS) {
|
||||
if (_meta_index != NULL &&
|
||||
!_meta_index->may_contain(name)) {
|
||||
return NULL;
|
||||
}
|
||||
return resolve_entry()->open_stream(name);
|
||||
if (_has_error) {
|
||||
return NULL;
|
||||
}
|
||||
ClassPathEntry* cpe = resolve_entry(THREAD);
|
||||
if (cpe == NULL) {
|
||||
_has_error = true;
|
||||
return NULL;
|
||||
} else {
|
||||
return cpe->open_stream(name, THREAD);
|
||||
}
|
||||
}
|
||||
|
||||
bool LazyClassPathEntry::is_lazy() {
|
||||
@ -465,20 +474,19 @@ void ClassLoader::setup_bootstrap_search_path() {
|
||||
}
|
||||
}
|
||||
|
||||
void ClassLoader::create_class_path_entry(char *path, struct stat st, ClassPathEntry **new_entry, bool lazy) {
|
||||
ClassPathEntry* ClassLoader::create_class_path_entry(char *path, const struct stat* st, bool lazy, TRAPS) {
|
||||
JavaThread* thread = JavaThread::current();
|
||||
if (lazy) {
|
||||
*new_entry = new LazyClassPathEntry(path, st);
|
||||
return;
|
||||
return new LazyClassPathEntry(path, st);
|
||||
}
|
||||
if ((st.st_mode & S_IFREG) == S_IFREG) {
|
||||
ClassPathEntry* new_entry = NULL;
|
||||
if ((st->st_mode & S_IFREG) == S_IFREG) {
|
||||
// Regular file, should be a zip file
|
||||
// Canonicalized filename
|
||||
char canonical_path[JVM_MAXPATHLEN];
|
||||
if (!get_canonical_path(path, canonical_path, JVM_MAXPATHLEN)) {
|
||||
// This matches the classic VM
|
||||
EXCEPTION_MARK;
|
||||
THROW_MSG(vmSymbols::java_io_IOException(), "Bad pathname");
|
||||
THROW_MSG_(vmSymbols::java_io_IOException(), "Bad pathname", NULL);
|
||||
}
|
||||
char* error_msg = NULL;
|
||||
jzfile* zip;
|
||||
@ -489,7 +497,7 @@ void ClassLoader::create_class_path_entry(char *path, struct stat st, ClassPathE
|
||||
zip = (*ZipOpen)(canonical_path, &error_msg);
|
||||
}
|
||||
if (zip != NULL && error_msg == NULL) {
|
||||
*new_entry = new ClassPathZipEntry(zip, path);
|
||||
new_entry = new ClassPathZipEntry(zip, path);
|
||||
if (TraceClassLoading) {
|
||||
tty->print_cr("[Opened %s]", path);
|
||||
}
|
||||
@ -504,16 +512,16 @@ void ClassLoader::create_class_path_entry(char *path, struct stat st, ClassPathE
|
||||
msg = NEW_RESOURCE_ARRAY(char, len); ;
|
||||
jio_snprintf(msg, len - 1, "error in opening JAR file <%s> %s", error_msg, path);
|
||||
}
|
||||
EXCEPTION_MARK;
|
||||
THROW_MSG(vmSymbols::java_lang_ClassNotFoundException(), msg);
|
||||
THROW_MSG_(vmSymbols::java_lang_ClassNotFoundException(), msg, NULL);
|
||||
}
|
||||
} else {
|
||||
// Directory
|
||||
*new_entry = new ClassPathDirEntry(path);
|
||||
new_entry = new ClassPathDirEntry(path);
|
||||
if (TraceClassLoading) {
|
||||
tty->print_cr("[Path %s]", path);
|
||||
}
|
||||
}
|
||||
return new_entry;
|
||||
}
|
||||
|
||||
|
||||
@ -572,13 +580,14 @@ void ClassLoader::add_to_list(ClassPathEntry *new_entry) {
|
||||
}
|
||||
}
|
||||
|
||||
void ClassLoader::update_class_path_entry_list(const char *path,
|
||||
void ClassLoader::update_class_path_entry_list(char *path,
|
||||
bool check_for_duplicates) {
|
||||
struct stat st;
|
||||
if (os::stat((char *)path, &st) == 0) {
|
||||
if (os::stat(path, &st) == 0) {
|
||||
// File or directory found
|
||||
ClassPathEntry* new_entry = NULL;
|
||||
create_class_path_entry((char *)path, st, &new_entry, LazyBootClassLoader);
|
||||
Thread* THREAD = Thread::current();
|
||||
new_entry = create_class_path_entry(path, &st, LazyBootClassLoader, CHECK);
|
||||
// The kernel VM adds dynamically to the end of the classloader path and
|
||||
// doesn't reorder the bootclasspath which would break java.lang.Package
|
||||
// (see PackageInfo).
|
||||
@ -897,7 +906,7 @@ instanceKlassHandle ClassLoader::load_classfile(Symbol* h_name, TRAPS) {
|
||||
PerfClassTraceTime::CLASS_LOAD);
|
||||
ClassPathEntry* e = _first_entry;
|
||||
while (e != NULL) {
|
||||
stream = e->open_stream(name);
|
||||
stream = e->open_stream(name, CHECK_NULL);
|
||||
if (stream != NULL) {
|
||||
break;
|
||||
}
|
||||
@ -1257,11 +1266,16 @@ bool ClassPathZipEntry::is_rt_jar12() {
|
||||
}
|
||||
|
||||
void LazyClassPathEntry::compile_the_world(Handle loader, TRAPS) {
|
||||
resolve_entry()->compile_the_world(loader, CHECK);
|
||||
ClassPathEntry* cpe = resolve_entry(THREAD);
|
||||
if (cpe != NULL) {
|
||||
cpe->compile_the_world(loader, CHECK);
|
||||
}
|
||||
}
|
||||
|
||||
bool LazyClassPathEntry::is_rt_jar() {
|
||||
return resolve_entry()->is_rt_jar();
|
||||
Thread* THREAD = Thread::current();
|
||||
ClassPathEntry* cpe = resolve_entry(THREAD);
|
||||
return (cpe != NULL) ? cpe->is_jar_file() : false;
|
||||
}
|
||||
|
||||
void ClassLoader::compile_the_world() {
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
|
||||
* Copyright (c) 1997, 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
|
||||
@ -63,7 +63,7 @@ class ClassPathEntry: public CHeapObj<mtClass> {
|
||||
ClassPathEntry();
|
||||
// Attempt to locate file_name through this class path entry.
|
||||
// Returns a class file parsing stream if successfull.
|
||||
virtual ClassFileStream* open_stream(const char* name) = 0;
|
||||
virtual ClassFileStream* open_stream(const char* name, TRAPS) = 0;
|
||||
// Debugging
|
||||
NOT_PRODUCT(virtual void compile_the_world(Handle loader, TRAPS) = 0;)
|
||||
NOT_PRODUCT(virtual bool is_rt_jar() = 0;)
|
||||
@ -77,7 +77,7 @@ class ClassPathDirEntry: public ClassPathEntry {
|
||||
bool is_jar_file() { return false; }
|
||||
const char* name() { return _dir; }
|
||||
ClassPathDirEntry(char* dir);
|
||||
ClassFileStream* open_stream(const char* name);
|
||||
ClassFileStream* open_stream(const char* name, TRAPS);
|
||||
// Debugging
|
||||
NOT_PRODUCT(void compile_the_world(Handle loader, TRAPS);)
|
||||
NOT_PRODUCT(bool is_rt_jar();)
|
||||
@ -107,7 +107,7 @@ class ClassPathZipEntry: public ClassPathEntry {
|
||||
const char* name() { return _zip_name; }
|
||||
ClassPathZipEntry(jzfile* zip, const char* zip_name);
|
||||
~ClassPathZipEntry();
|
||||
ClassFileStream* open_stream(const char* name);
|
||||
ClassFileStream* open_stream(const char* name, TRAPS);
|
||||
void contents_do(void f(const char* name, void* context), void* context);
|
||||
// Debugging
|
||||
NOT_PRODUCT(void compile_the_world(Handle loader, TRAPS);)
|
||||
@ -125,13 +125,14 @@ class LazyClassPathEntry: public ClassPathEntry {
|
||||
char* _path; // dir or file
|
||||
struct stat _st;
|
||||
MetaIndex* _meta_index;
|
||||
bool _has_error;
|
||||
volatile ClassPathEntry* _resolved_entry;
|
||||
ClassPathEntry* resolve_entry();
|
||||
ClassPathEntry* resolve_entry(TRAPS);
|
||||
public:
|
||||
bool is_jar_file();
|
||||
const char* name() { return _path; }
|
||||
LazyClassPathEntry(char* path, struct stat st);
|
||||
ClassFileStream* open_stream(const char* name);
|
||||
LazyClassPathEntry(char* path, const struct stat* st);
|
||||
ClassFileStream* open_stream(const char* name, TRAPS);
|
||||
void set_meta_index(MetaIndex* meta_index) { _meta_index = meta_index; }
|
||||
virtual bool is_lazy();
|
||||
// Debugging
|
||||
@ -207,14 +208,15 @@ class ClassLoader: AllStatic {
|
||||
static void setup_meta_index();
|
||||
static void setup_bootstrap_search_path();
|
||||
static void load_zip_library();
|
||||
static void create_class_path_entry(char *path, struct stat st, ClassPathEntry **new_entry, bool lazy);
|
||||
static ClassPathEntry* create_class_path_entry(char *path, const struct stat* st,
|
||||
bool lazy, TRAPS);
|
||||
|
||||
// Canonicalizes path names, so strcmp will work properly. This is mainly
|
||||
// to avoid confusing the zip library
|
||||
static bool get_canonical_path(char* orig, char* out, int len);
|
||||
public:
|
||||
// Used by the kernel jvm.
|
||||
static void update_class_path_entry_list(const char *path,
|
||||
static void update_class_path_entry_list(char *path,
|
||||
bool check_for_duplicates);
|
||||
static void print_bootclasspath();
|
||||
|
||||
|
||||
@ -25,7 +25,6 @@
|
||||
#include "precompiled.hpp"
|
||||
#include "classfile/bytecodeAssembler.hpp"
|
||||
#include "classfile/defaultMethods.hpp"
|
||||
#include "classfile/genericSignatures.hpp"
|
||||
#include "classfile/symbolTable.hpp"
|
||||
#include "memory/allocation.hpp"
|
||||
#include "memory/metadataFactory.hpp"
|
||||
@ -75,14 +74,6 @@ class PseudoScope : public ResourceObj {
|
||||
}
|
||||
};
|
||||
|
||||
class ContextMark : public PseudoScopeMark {
|
||||
private:
|
||||
generic::Context::Mark _mark;
|
||||
public:
|
||||
ContextMark(const generic::Context::Mark& cm) : _mark(cm) {}
|
||||
virtual void destroy() { _mark.destroy(); }
|
||||
};
|
||||
|
||||
#ifndef PRODUCT
|
||||
static void print_slot(outputStream* str, Symbol* name, Symbol* signature) {
|
||||
ResourceMark rm;
|
||||
@ -503,38 +494,6 @@ Symbol* MethodFamily::generate_conflicts_message(GrowableArray<Method*>* methods
|
||||
return SymbolTable::new_symbol(ss.base(), (int)ss.size(), CHECK_NULL);
|
||||
}
|
||||
|
||||
// A generic method family contains a set of all methods that implement a single
|
||||
// language-level method. Because of erasure, these methods may have different
|
||||
// signatures. As members of the set are collected while walking over the
|
||||
// hierarchy, they are tagged with a qualification state. The qualification
|
||||
// state for an erased method is set to disqualified if there exists a path
|
||||
// from the root of hierarchy to the method that contains an interleaving
|
||||
// language-equivalent method defined in an interface.
|
||||
class GenericMethodFamily : public MethodFamily {
|
||||
private:
|
||||
|
||||
generic::MethodDescriptor* _descriptor; // language-level description
|
||||
|
||||
public:
|
||||
|
||||
GenericMethodFamily(generic::MethodDescriptor* canonical_desc)
|
||||
: _descriptor(canonical_desc) {}
|
||||
|
||||
generic::MethodDescriptor* descriptor() const { return _descriptor; }
|
||||
|
||||
bool descriptor_matches(generic::MethodDescriptor* md, generic::Context* ctx) {
|
||||
return descriptor()->covariant_match(md, ctx);
|
||||
}
|
||||
|
||||
#ifndef PRODUCT
|
||||
Symbol* get_generic_sig() const {
|
||||
|
||||
generic::Context ctx(NULL); // empty, as _descriptor already canonicalized
|
||||
TempNewSymbol sig = descriptor()->reify_signature(&ctx, Thread::current());
|
||||
return sig;
|
||||
}
|
||||
#endif // ndef PRODUCT
|
||||
};
|
||||
|
||||
class StateRestorer;
|
||||
|
||||
@ -571,26 +530,6 @@ class StatefulMethodFamily : public ResourceObj {
|
||||
StateRestorer* record_method_and_dq_further(Method* mo);
|
||||
};
|
||||
|
||||
|
||||
// StatefulGenericMethodFamily is a wrapper around GenericMethodFamily that maintains the
|
||||
// qualification state during hierarchy visitation, and applies that state
|
||||
// when adding members to the GenericMethodFamily.
|
||||
class StatefulGenericMethodFamily : public StatefulMethodFamily {
|
||||
|
||||
public:
|
||||
StatefulGenericMethodFamily(generic::MethodDescriptor* md, generic::Context* ctx)
|
||||
: StatefulMethodFamily(new GenericMethodFamily(md->canonicalize(ctx))) {
|
||||
|
||||
}
|
||||
GenericMethodFamily* get_method_family() {
|
||||
return (GenericMethodFamily*)_method_family;
|
||||
}
|
||||
|
||||
bool descriptor_matches(generic::MethodDescriptor* md, generic::Context* ctx) {
|
||||
return get_method_family()->descriptor_matches(md, ctx);
|
||||
}
|
||||
};
|
||||
|
||||
class StateRestorer : public PseudoScopeMark {
|
||||
private:
|
||||
StatefulMethodFamily* _method;
|
||||
@ -616,39 +555,6 @@ StateRestorer* StatefulMethodFamily::record_method_and_dq_further(Method* mo) {
|
||||
return mark;
|
||||
}
|
||||
|
||||
class StatefulGenericMethodFamilies : public ResourceObj {
|
||||
private:
|
||||
GrowableArray<StatefulGenericMethodFamily*> _methods;
|
||||
|
||||
public:
|
||||
StatefulGenericMethodFamily* find_matching(
|
||||
generic::MethodDescriptor* md, generic::Context* ctx) {
|
||||
for (int i = 0; i < _methods.length(); ++i) {
|
||||
StatefulGenericMethodFamily* existing = _methods.at(i);
|
||||
if (existing->descriptor_matches(md, ctx)) {
|
||||
return existing;
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
StatefulGenericMethodFamily* find_matching_or_create(
|
||||
generic::MethodDescriptor* md, generic::Context* ctx) {
|
||||
StatefulGenericMethodFamily* method = find_matching(md, ctx);
|
||||
if (method == NULL) {
|
||||
method = new StatefulGenericMethodFamily(md, ctx);
|
||||
_methods.append(method);
|
||||
}
|
||||
return method;
|
||||
}
|
||||
|
||||
void extract_families_into(GrowableArray<GenericMethodFamily*>* array) {
|
||||
for (int i = 0; i < _methods.length(); ++i) {
|
||||
array->append(_methods.at(i)->get_method_family());
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
// Represents a location corresponding to a vtable slot for methods that
|
||||
// neither the class nor any of it's ancestors provide an implementaion.
|
||||
// Default methods may be present to fill this slot.
|
||||
@ -779,146 +685,11 @@ class FindMethodsByErasedSig : public HierarchyVisitor<FindMethodsByErasedSig> {
|
||||
|
||||
};
|
||||
|
||||
// Iterates over the type hierarchy looking for all methods with a specific
|
||||
// method name. The result of this is a set of method families each of
|
||||
// which is populated with a set of methods that implement the same
|
||||
// language-level signature.
|
||||
class FindMethodsByGenericSig : public HierarchyVisitor<FindMethodsByGenericSig> {
|
||||
private:
|
||||
// Context data
|
||||
Thread* THREAD;
|
||||
generic::DescriptorCache* _cache;
|
||||
Symbol* _method_name;
|
||||
generic::Context* _ctx;
|
||||
StatefulGenericMethodFamilies _families;
|
||||
|
||||
public:
|
||||
|
||||
FindMethodsByGenericSig(generic::DescriptorCache* cache, Symbol* name,
|
||||
generic::Context* ctx, Thread* thread) :
|
||||
_cache(cache), _method_name(name), _ctx(ctx), THREAD(thread) {}
|
||||
|
||||
void get_discovered_families(GrowableArray<GenericMethodFamily*>* methods) {
|
||||
_families.extract_families_into(methods);
|
||||
}
|
||||
|
||||
void* new_node_data(InstanceKlass* cls) { return new PseudoScope(); }
|
||||
void free_node_data(void* node_data) {
|
||||
PseudoScope::cast(node_data)->destroy();
|
||||
}
|
||||
|
||||
bool visit() {
|
||||
PseudoScope* scope = PseudoScope::cast(current_data());
|
||||
InstanceKlass* klass = current_class();
|
||||
InstanceKlass* sub = current_depth() > 0 ? class_at_depth(1) : NULL;
|
||||
|
||||
ContextMark* cm = new ContextMark(_ctx->mark());
|
||||
scope->add_mark(cm); // will restore context when scope is freed
|
||||
|
||||
_ctx->apply_type_arguments(sub, klass, THREAD);
|
||||
|
||||
int start, end = 0;
|
||||
start = klass->find_method_by_name(_method_name, &end);
|
||||
if (start != -1) {
|
||||
for (int i = start; i < end; ++i) {
|
||||
Method* m = klass->methods()->at(i);
|
||||
// This gets the method's parameter list with its generic type
|
||||
// parameters resolved
|
||||
generic::MethodDescriptor* md = _cache->descriptor_for(m, THREAD);
|
||||
|
||||
// Find all methods on this hierarchy that match this method
|
||||
// (name, signature). This class collects other families of this
|
||||
// method name.
|
||||
StatefulGenericMethodFamily* family =
|
||||
_families.find_matching_or_create(md, _ctx);
|
||||
|
||||
if (klass->is_interface()) {
|
||||
// ???
|
||||
StateRestorer* restorer = family->record_method_and_dq_further(m);
|
||||
scope->add_mark(restorer);
|
||||
} else {
|
||||
// This is the rule that methods in classes "win" (bad word) over
|
||||
// methods in interfaces. This works because of single inheritance
|
||||
family->set_target_if_empty(m);
|
||||
}
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
};
|
||||
|
||||
#ifndef PRODUCT
|
||||
static void print_generic_families(
|
||||
GrowableArray<GenericMethodFamily*>* methods, Symbol* match) {
|
||||
streamIndentor si(tty, 4);
|
||||
if (methods->length() == 0) {
|
||||
tty->indent();
|
||||
tty->print_cr("No Logical Method found");
|
||||
}
|
||||
for (int i = 0; i < methods->length(); ++i) {
|
||||
tty->indent();
|
||||
GenericMethodFamily* lm = methods->at(i);
|
||||
if (lm->contains_signature(match)) {
|
||||
tty->print_cr("<Matching>");
|
||||
} else {
|
||||
tty->print_cr("<Non-Matching>");
|
||||
}
|
||||
lm->print_sig_on(tty, lm->get_generic_sig(), 1);
|
||||
}
|
||||
}
|
||||
#endif // ndef PRODUCT
|
||||
|
||||
static void create_overpasses(
|
||||
GrowableArray<EmptyVtableSlot*>* slots, InstanceKlass* klass, TRAPS);
|
||||
|
||||
static void generate_generic_defaults(
|
||||
InstanceKlass* klass, GrowableArray<EmptyVtableSlot*>* empty_slots,
|
||||
EmptyVtableSlot* slot, int current_slot_index, TRAPS) {
|
||||
|
||||
if (slot->is_bound()) {
|
||||
#ifndef PRODUCT
|
||||
if (TraceDefaultMethods) {
|
||||
streamIndentor si(tty, 4);
|
||||
tty->indent().print_cr("Already bound to logical method:");
|
||||
GenericMethodFamily* lm = (GenericMethodFamily*)(slot->get_binding());
|
||||
lm->print_sig_on(tty, lm->get_generic_sig(), 1);
|
||||
}
|
||||
#endif // ndef PRODUCT
|
||||
return; // covered by previous processing
|
||||
}
|
||||
|
||||
generic::DescriptorCache cache;
|
||||
|
||||
generic::Context ctx(&cache);
|
||||
FindMethodsByGenericSig visitor(&cache, slot->name(), &ctx, CHECK);
|
||||
visitor.run(klass);
|
||||
|
||||
GrowableArray<GenericMethodFamily*> discovered_families;
|
||||
visitor.get_discovered_families(&discovered_families);
|
||||
|
||||
#ifndef PRODUCT
|
||||
if (TraceDefaultMethods) {
|
||||
print_generic_families(&discovered_families, slot->signature());
|
||||
}
|
||||
#endif // ndef PRODUCT
|
||||
|
||||
// Find and populate any other slots that match the discovered families
|
||||
for (int j = current_slot_index; j < empty_slots->length(); ++j) {
|
||||
EmptyVtableSlot* open_slot = empty_slots->at(j);
|
||||
|
||||
if (slot->name() == open_slot->name()) {
|
||||
for (int k = 0; k < discovered_families.length(); ++k) {
|
||||
GenericMethodFamily* lm = discovered_families.at(k);
|
||||
|
||||
if (lm->contains_signature(open_slot->signature())) {
|
||||
lm->determine_target(klass, CHECK);
|
||||
open_slot->bind_family(lm);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void generate_erased_defaults(
|
||||
InstanceKlass* klass, GrowableArray<EmptyVtableSlot*>* empty_slots,
|
||||
EmptyVtableSlot* slot, TRAPS) {
|
||||
@ -943,21 +714,14 @@ static void merge_in_new_methods(InstanceKlass* klass,
|
||||
//
|
||||
// First if finds any name/signature slots that need any implementation (either
|
||||
// because they are miranda or a superclass's implementation is an overpass
|
||||
// itself). For each slot, iterate over the hierarchy, using generic signature
|
||||
// information to partition any methods that match the name into method families
|
||||
// where each family contains methods whose signatures are equivalent at the
|
||||
// language level (i.e., their reified parameters match and return values are
|
||||
// covariant). Check those sets to see if they contain a signature that matches
|
||||
// the slot we're looking at (if we're lucky, there might be other empty slots
|
||||
// that we can fill using the same analysis).
|
||||
// itself). For each slot, iterate over the hierarchy, to see if they contain a
|
||||
// signature that matches the slot we are looking at.
|
||||
//
|
||||
// For each slot filled, we generate an overpass method that either calls the
|
||||
// unique default method candidate using invokespecial, or throws an exception
|
||||
// (in the case of no default method candidates, or more than one valid
|
||||
// candidate). These methods are then added to the class's method list. If
|
||||
// the method set we're using contains methods (qualified or not) with a
|
||||
// different runtime signature than the method we're creating, then we have to
|
||||
// create bridges with those signatures too.
|
||||
// candidate). These methods are then added to the class's method list.
|
||||
// The JVM does not create bridges nor handle generic signatures here.
|
||||
void DefaultMethods::generate_default_methods(
|
||||
InstanceKlass* klass, GrowableArray<Method*>* mirandas, TRAPS) {
|
||||
|
||||
@ -997,11 +761,7 @@ void DefaultMethods::generate_default_methods(
|
||||
}
|
||||
#endif // ndef PRODUCT
|
||||
|
||||
if (ParseGenericDefaults) {
|
||||
generate_generic_defaults(klass, empty_slots, slot, i, CHECK);
|
||||
} else {
|
||||
generate_erased_defaults(klass, empty_slots, slot, CHECK);
|
||||
}
|
||||
generate_erased_defaults(klass, empty_slots, slot, CHECK);
|
||||
}
|
||||
#ifndef PRODUCT
|
||||
if (TraceDefaultMethods) {
|
||||
@ -1019,13 +779,13 @@ void DefaultMethods::generate_default_methods(
|
||||
}
|
||||
|
||||
/**
|
||||
* Generic analysis was used upon interface '_target' and found a unique
|
||||
* default method candidate with generic signature '_method_desc'. This
|
||||
* Interface inheritance rules were used to find a unique default method
|
||||
* candidate for the resolved class. This
|
||||
* method is only viable if it would also be in the set of default method
|
||||
* candidates if we ran a full analysis on the current class.
|
||||
*
|
||||
* The only reason that the method would not be in the set of candidates for
|
||||
* the current class is if that there's another covariantly matching method
|
||||
* the current class is if that there's another matching method
|
||||
* which is "more specific" than the found method -- i.e., one could find a
|
||||
* path in the interface hierarchy in which the matching method appears
|
||||
* before we get to '_target'.
|
||||
@ -1110,49 +870,6 @@ class ErasedShadowChecker : public ShadowChecker {
|
||||
: ShadowChecker(thread, name, holder, target) {}
|
||||
};
|
||||
|
||||
class GenericShadowChecker : public ShadowChecker {
|
||||
private:
|
||||
generic::DescriptorCache* _cache;
|
||||
generic::MethodDescriptor* _method_desc;
|
||||
|
||||
bool path_has_shadow() {
|
||||
generic::Context ctx(_cache);
|
||||
|
||||
for (int i = current_depth() - 1; i > 0; --i) {
|
||||
InstanceKlass* ik = class_at_depth(i);
|
||||
InstanceKlass* sub = class_at_depth(i + 1);
|
||||
ctx.apply_type_arguments(sub, ik, THREAD);
|
||||
|
||||
if (ik->is_interface()) {
|
||||
int end;
|
||||
int start = ik->find_method_by_name(_method_name, &end);
|
||||
if (start != -1) {
|
||||
for (int j = start; j < end; ++j) {
|
||||
Method* mo = ik->methods()->at(j);
|
||||
generic::MethodDescriptor* md = _cache->descriptor_for(mo, THREAD);
|
||||
if (_method_desc->covariant_match(md, &ctx)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
public:
|
||||
|
||||
GenericShadowChecker(generic::DescriptorCache* cache, Thread* thread,
|
||||
Symbol* name, InstanceKlass* holder, generic::MethodDescriptor* desc,
|
||||
InstanceKlass* target)
|
||||
: ShadowChecker(thread, name, holder, target) {
|
||||
_cache = cache;
|
||||
_method_desc = desc;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
// Find the unique qualified candidate from the perspective of the super_class
|
||||
// which is the resolved_klass, which must be an immediate superinterface
|
||||
// of klass
|
||||
@ -1166,103 +883,48 @@ Method* find_erased_super_default(InstanceKlass* current_class, InstanceKlass* s
|
||||
|
||||
if (family != NULL) {
|
||||
family->determine_target(current_class, CHECK_NULL); // get target from current_class
|
||||
}
|
||||
|
||||
if (family->has_target()) {
|
||||
Method* target = family->get_selected_target();
|
||||
InstanceKlass* holder = InstanceKlass::cast(target->method_holder());
|
||||
if (family->has_target()) {
|
||||
Method* target = family->get_selected_target();
|
||||
InstanceKlass* holder = InstanceKlass::cast(target->method_holder());
|
||||
|
||||
// Verify that the identified method is valid from the context of
|
||||
// the current class, which is the caller class for invokespecial
|
||||
// link resolution, i.e. ensure there it is not shadowed.
|
||||
// You can use invokespecial to disambiguate interface methods, but
|
||||
// you can not use it to skip over an interface method that would shadow it.
|
||||
ErasedShadowChecker checker(THREAD, target->name(), holder, super_class);
|
||||
checker.run(current_class);
|
||||
// Verify that the identified method is valid from the context of
|
||||
// the current class, which is the caller class for invokespecial
|
||||
// link resolution, i.e. ensure there it is not shadowed.
|
||||
// You can use invokespecial to disambiguate interface methods, but
|
||||
// you can not use it to skip over an interface method that would shadow it.
|
||||
ErasedShadowChecker checker(THREAD, target->name(), holder, super_class);
|
||||
checker.run(current_class);
|
||||
|
||||
if (checker.found_shadow()) {
|
||||
if (checker.found_shadow()) {
|
||||
#ifndef PRODUCT
|
||||
if (TraceDefaultMethods) {
|
||||
tty->print_cr(" Only candidate found was shadowed.");
|
||||
}
|
||||
if (TraceDefaultMethods) {
|
||||
tty->print_cr(" Only candidate found was shadowed.");
|
||||
}
|
||||
#endif // ndef PRODUCT
|
||||
THROW_MSG_(vmSymbols::java_lang_AbstractMethodError(),
|
||||
"Accessible default method not found", NULL);
|
||||
THROW_MSG_(vmSymbols::java_lang_AbstractMethodError(),
|
||||
"Accessible default method not found", NULL);
|
||||
} else {
|
||||
#ifndef PRODUCT
|
||||
if (TraceDefaultMethods) {
|
||||
family->print_sig_on(tty, target->signature(), 1);
|
||||
}
|
||||
#endif // ndef PRODUCT
|
||||
return target;
|
||||
}
|
||||
} else {
|
||||
#ifndef PRODUCT
|
||||
if (TraceDefaultMethods) {
|
||||
family->print_sig_on(tty, target->signature(), 1);
|
||||
}
|
||||
#endif // ndef PRODUCT
|
||||
return target;
|
||||
}
|
||||
assert(family->throws_exception(), "must have target or throw");
|
||||
THROW_MSG_(vmSymbols::java_lang_AbstractMethodError(),
|
||||
family->get_exception_message()->as_C_string(), NULL);
|
||||
}
|
||||
} else {
|
||||
assert(family->throws_exception(), "must have target or throw");
|
||||
THROW_MSG_(vmSymbols::java_lang_AbstractMethodError(),
|
||||
family->get_exception_message()->as_C_string(), NULL);
|
||||
// no method found
|
||||
ResourceMark rm(THREAD);
|
||||
THROW_MSG_(vmSymbols::java_lang_NoSuchMethodError(),
|
||||
Method::name_and_sig_as_C_string(current_class,
|
||||
method_name, sig), NULL);
|
||||
}
|
||||
}
|
||||
|
||||
// super_class is assumed to be the direct super of current_class
|
||||
Method* find_generic_super_default( InstanceKlass* current_class,
|
||||
InstanceKlass* super_class,
|
||||
Symbol* method_name, Symbol* sig, TRAPS) {
|
||||
generic::DescriptorCache cache;
|
||||
generic::Context ctx(&cache);
|
||||
|
||||
// Prime the initial generic context for current -> super_class
|
||||
ctx.apply_type_arguments(current_class, super_class, CHECK_NULL);
|
||||
|
||||
FindMethodsByGenericSig visitor(&cache, method_name, &ctx, CHECK_NULL);
|
||||
visitor.run(super_class);
|
||||
|
||||
GrowableArray<GenericMethodFamily*> families;
|
||||
visitor.get_discovered_families(&families);
|
||||
|
||||
#ifndef PRODUCT
|
||||
if (TraceDefaultMethods) {
|
||||
print_generic_families(&families, sig);
|
||||
}
|
||||
#endif // ndef PRODUCT
|
||||
|
||||
GenericMethodFamily* selected_family = NULL;
|
||||
|
||||
for (int i = 0; i < families.length(); ++i) {
|
||||
GenericMethodFamily* lm = families.at(i);
|
||||
if (lm->contains_signature(sig)) {
|
||||
lm->determine_target(current_class, CHECK_NULL);
|
||||
selected_family = lm;
|
||||
}
|
||||
}
|
||||
|
||||
if (selected_family->has_target()) {
|
||||
Method* target = selected_family->get_selected_target();
|
||||
InstanceKlass* holder = InstanceKlass::cast(target->method_holder());
|
||||
|
||||
// Verify that the identified method is valid from the context of
|
||||
// the current class
|
||||
GenericShadowChecker checker(&cache, THREAD, target->name(),
|
||||
holder, selected_family->descriptor(), super_class);
|
||||
checker.run(current_class);
|
||||
|
||||
if (checker.found_shadow()) {
|
||||
#ifndef PRODUCT
|
||||
if (TraceDefaultMethods) {
|
||||
tty->print_cr(" Only candidate found was shadowed.");
|
||||
}
|
||||
#endif // ndef PRODUCT
|
||||
THROW_MSG_(vmSymbols::java_lang_AbstractMethodError(),
|
||||
"Accessible default method not found", NULL);
|
||||
} else {
|
||||
return target;
|
||||
}
|
||||
} else {
|
||||
assert(selected_family->throws_exception(), "must have target or throw");
|
||||
THROW_MSG_(vmSymbols::java_lang_AbstractMethodError(),
|
||||
selected_family->get_exception_message()->as_C_string(), NULL);
|
||||
}
|
||||
}
|
||||
|
||||
// This is called during linktime when we find an invokespecial call that
|
||||
// refers to a direct superinterface. It indicates that we should find the
|
||||
// default method in the hierarchy of that superinterface, and if that method
|
||||
@ -1296,13 +958,8 @@ Method* DefaultMethods::find_super_default(
|
||||
assert(super_class->is_interface(), "only call for default methods");
|
||||
|
||||
Method* target = NULL;
|
||||
if (ParseGenericDefaults) {
|
||||
target = find_generic_super_default(current_class, super_class,
|
||||
method_name, sig, CHECK_NULL);
|
||||
} else {
|
||||
target = find_erased_super_default(current_class, super_class,
|
||||
method_name, sig, CHECK_NULL);
|
||||
}
|
||||
target = find_erased_super_default(current_class, super_class,
|
||||
method_name, sig, CHECK_NULL);
|
||||
|
||||
#ifndef PRODUCT
|
||||
if (target != NULL) {
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,467 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
|
||||
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
||||
*
|
||||
* This code is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU General Public License version 2 only, as
|
||||
* published by the Free Software Foundation.
|
||||
*
|
||||
* This code is distributed in the hope that it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
* version 2 for more details (a copy is included in the LICENSE file that
|
||||
* accompanied this code).
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License version
|
||||
* 2 along with this work; if not, write to the Free Software Foundation,
|
||||
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*
|
||||
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
||||
* or visit www.oracle.com if you need additional information or have any
|
||||
* questions.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef SHARE_VM_CLASSFILE_GENERICSIGNATURES_HPP
|
||||
#define SHARE_VM_CLASSFILE_GENERICSIGNATURES_HPP
|
||||
|
||||
#include "classfile/symbolTable.hpp"
|
||||
#include "memory/allocation.hpp"
|
||||
#include "runtime/signature.hpp"
|
||||
#include "utilities/growableArray.hpp"
|
||||
#include "utilities/resourceHash.hpp"
|
||||
|
||||
class stringStream;
|
||||
|
||||
namespace generic {
|
||||
|
||||
class Identifier;
|
||||
class ClassDescriptor;
|
||||
class MethodDescriptor;
|
||||
|
||||
class TypeParameter; // a formal type parameter declared in generic signatures
|
||||
class TypeArgument; // The "type value" passed to fill parameters in supertypes
|
||||
class TypeVariable; // A usage of a type parameter as a value
|
||||
/**
|
||||
* Example:
|
||||
*
|
||||
* <T, V> class Foo extends Bar<String> { int m(V v) {} }
|
||||
* ^^^^^^ ^^^^^^ ^^
|
||||
* type parameters type argument type variable
|
||||
*
|
||||
* Note that a type variable could be passed as an argument too:
|
||||
* <T, V> class Foo extends Bar<T> { int m(V v) {} }
|
||||
* ^^^
|
||||
* type argument's value is a type variable
|
||||
*/
|
||||
|
||||
|
||||
class Type;
|
||||
class ClassType;
|
||||
class ArrayType;
|
||||
class PrimitiveType;
|
||||
class Context;
|
||||
class DescriptorCache;
|
||||
|
||||
class DescriptorStream;
|
||||
|
||||
class Identifier : public ResourceObj {
|
||||
private:
|
||||
Symbol* _sym;
|
||||
int _begin;
|
||||
int _end;
|
||||
|
||||
public:
|
||||
Identifier(Symbol* sym, int begin, int end) :
|
||||
_sym(sym), _begin(begin), _end(end) {}
|
||||
|
||||
bool equals(Identifier* other);
|
||||
bool equals(Symbol* sym);
|
||||
|
||||
#ifndef PRODUCT
|
||||
void print_on(outputStream* str) const;
|
||||
#endif // ndef PRODUCT
|
||||
};
|
||||
|
||||
class Descriptor : public ResourceObj {
|
||||
protected:
|
||||
GrowableArray<TypeParameter*> _type_parameters;
|
||||
ClassDescriptor* _outer_class;
|
||||
|
||||
Descriptor(GrowableArray<TypeParameter*>& params,
|
||||
ClassDescriptor* outer)
|
||||
: _type_parameters(params), _outer_class(outer) {}
|
||||
|
||||
public:
|
||||
|
||||
ClassDescriptor* outer_class() { return _outer_class; }
|
||||
void set_outer_class(ClassDescriptor* sig) { _outer_class = sig; }
|
||||
|
||||
virtual ClassDescriptor* as_class_signature() { return NULL; }
|
||||
virtual MethodDescriptor* as_method_signature() { return NULL; }
|
||||
|
||||
bool is_class_signature() { return as_class_signature() != NULL; }
|
||||
bool is_method_signature() { return as_method_signature() != NULL; }
|
||||
|
||||
GrowableArray<TypeParameter*>& type_parameters() {
|
||||
return _type_parameters;
|
||||
}
|
||||
|
||||
TypeParameter* find_type_parameter(Identifier* id, int* param_depth);
|
||||
|
||||
virtual void bind_variables_to_parameters() = 0;
|
||||
|
||||
#ifndef PRODUCT
|
||||
virtual void print_on(outputStream* str) const = 0;
|
||||
#endif
|
||||
};
|
||||
|
||||
class ClassDescriptor : public Descriptor {
|
||||
private:
|
||||
ClassType* _super;
|
||||
GrowableArray<ClassType*> _interfaces;
|
||||
MethodDescriptor* _outer_method;
|
||||
|
||||
ClassDescriptor(GrowableArray<TypeParameter*>& ftp, ClassType* scs,
|
||||
GrowableArray<ClassType*>& sis, ClassDescriptor* outer_class = NULL,
|
||||
MethodDescriptor* outer_method = NULL)
|
||||
: Descriptor(ftp, outer_class), _super(scs), _interfaces(sis),
|
||||
_outer_method(outer_method) {}
|
||||
|
||||
static u2 get_outer_class_index(InstanceKlass* k, TRAPS);
|
||||
static ClassDescriptor* parse_generic_signature(Klass* k, Symbol* original_name, TRAPS);
|
||||
|
||||
public:
|
||||
|
||||
virtual ClassDescriptor* as_class_signature() { return this; }
|
||||
|
||||
MethodDescriptor* outer_method() { return _outer_method; }
|
||||
void set_outer_method(MethodDescriptor* m) { _outer_method = m; }
|
||||
|
||||
ClassType* super() { return _super; }
|
||||
ClassType* interface_desc(Symbol* sym);
|
||||
|
||||
static ClassDescriptor* parse_generic_signature(Klass* k, TRAPS);
|
||||
static ClassDescriptor* parse_generic_signature(Symbol* sym);
|
||||
|
||||
// For use in superclass chains in positions where this is no generic info
|
||||
static ClassDescriptor* placeholder(InstanceKlass* klass);
|
||||
|
||||
#ifndef PRODUCT
|
||||
void print_on(outputStream* str) const;
|
||||
#endif
|
||||
|
||||
ClassDescriptor* canonicalize(Context* ctx);
|
||||
|
||||
// Linking sets the position index in any contained TypeVariable type
|
||||
// to correspond to the location of that identifier in the formal type
|
||||
// parameters.
|
||||
void bind_variables_to_parameters();
|
||||
};
|
||||
|
||||
class MethodDescriptor : public Descriptor {
|
||||
private:
|
||||
GrowableArray<Type*> _parameters;
|
||||
Type* _return_type;
|
||||
GrowableArray<Type*> _throws;
|
||||
|
||||
MethodDescriptor(GrowableArray<TypeParameter*>& ftp, ClassDescriptor* outer,
|
||||
GrowableArray<Type*>& sigs, Type* rt, GrowableArray<Type*>& throws)
|
||||
: Descriptor(ftp, outer), _parameters(sigs), _return_type(rt),
|
||||
_throws(throws) {}
|
||||
|
||||
public:
|
||||
|
||||
static MethodDescriptor* parse_generic_signature(Method* m, ClassDescriptor* outer);
|
||||
static MethodDescriptor* parse_generic_signature(Symbol* sym, ClassDescriptor* outer);
|
||||
|
||||
MethodDescriptor* as_method_signature() { return this; }
|
||||
|
||||
// Performs generic analysis on the method parameters to determine
|
||||
// if both methods refer to the same argument types.
|
||||
bool covariant_match(MethodDescriptor* other, Context* ctx);
|
||||
|
||||
// Returns a new method descriptor with all generic variables
|
||||
// removed and replaced with whatever is indicated using the Context.
|
||||
MethodDescriptor* canonicalize(Context* ctx);
|
||||
|
||||
void bind_variables_to_parameters();
|
||||
|
||||
#ifndef PRODUCT
|
||||
TempNewSymbol reify_signature(Context* ctx, TRAPS);
|
||||
void print_on(outputStream* str) const;
|
||||
#endif
|
||||
};
|
||||
|
||||
class TypeParameter : public ResourceObj {
|
||||
private:
|
||||
Identifier* _identifier;
|
||||
ClassType* _class_bound;
|
||||
GrowableArray<ClassType*> _interface_bounds;
|
||||
|
||||
// The position is the ordinal location of the parameter within the
|
||||
// formal parameter list (excluding outer classes). It is only set for
|
||||
// formal type parameters that are associated with a class -- method
|
||||
// type parameters are left as -1. When resolving a generic variable to
|
||||
// find the actual type, this index is used to access the generic type
|
||||
// argument in the provided context object.
|
||||
int _position; // Assigned during variable linking
|
||||
|
||||
TypeParameter(Identifier* id, ClassType* class_bound,
|
||||
GrowableArray<ClassType*>& interface_bounds) :
|
||||
_identifier(id), _class_bound(class_bound),
|
||||
_interface_bounds(interface_bounds), _position(-1) {}
|
||||
|
||||
public:
|
||||
static TypeParameter* parse_generic_signature(DescriptorStream* str);
|
||||
|
||||
ClassType* bound();
|
||||
int position() { return _position; }
|
||||
|
||||
void bind_variables_to_parameters(Descriptor* sig, int position);
|
||||
Identifier* identifier() { return _identifier; }
|
||||
|
||||
Type* resolve(Context* ctx, int inner_depth, int ctx_depth);
|
||||
TypeParameter* canonicalize(Context* ctx, int ctx_depth);
|
||||
|
||||
#ifndef PRODUCT
|
||||
void print_on(outputStream* str) const;
|
||||
#endif
|
||||
};
|
||||
|
||||
class Type : public ResourceObj {
|
||||
public:
|
||||
static Type* parse_generic_signature(DescriptorStream* str);
|
||||
|
||||
virtual ClassType* as_class() { return NULL; }
|
||||
virtual TypeVariable* as_variable() { return NULL; }
|
||||
virtual ArrayType* as_array() { return NULL; }
|
||||
virtual PrimitiveType* as_primitive() { return NULL; }
|
||||
|
||||
virtual bool covariant_match(Type* gt, Context* ctx) = 0;
|
||||
virtual Type* canonicalize(Context* ctx, int ctx_depth) = 0;
|
||||
|
||||
virtual void bind_variables_to_parameters(Descriptor* sig) = 0;
|
||||
|
||||
#ifndef PRODUCT
|
||||
virtual void reify_signature(stringStream* ss, Context* ctx) = 0;
|
||||
virtual void print_on(outputStream* str) const = 0;
|
||||
#endif
|
||||
};
|
||||
|
||||
class ClassType : public Type {
|
||||
friend class ClassDescriptor;
|
||||
protected:
|
||||
Identifier* _identifier;
|
||||
GrowableArray<TypeArgument*> _type_arguments;
|
||||
ClassType* _outer_class;
|
||||
|
||||
ClassType(Identifier* identifier,
|
||||
GrowableArray<TypeArgument*>& args,
|
||||
ClassType* outer)
|
||||
: _identifier(identifier), _type_arguments(args), _outer_class(outer) {}
|
||||
|
||||
// Returns true if there are inner classes to read
|
||||
static Identifier* parse_generic_signature_simple(
|
||||
GrowableArray<TypeArgument*>* args,
|
||||
bool* has_inner, DescriptorStream* str);
|
||||
|
||||
static ClassType* parse_generic_signature(ClassType* outer,
|
||||
DescriptorStream* str);
|
||||
static ClassType* from_symbol(Symbol* sym);
|
||||
|
||||
public:
|
||||
ClassType* as_class() { return this; }
|
||||
|
||||
static ClassType* parse_generic_signature(DescriptorStream* str);
|
||||
static ClassType* java_lang_Object();
|
||||
|
||||
Identifier* identifier() { return _identifier; }
|
||||
int type_arguments_length() { return _type_arguments.length(); }
|
||||
TypeArgument* type_argument_at(int i);
|
||||
|
||||
virtual ClassType* outer_class() { return _outer_class; }
|
||||
|
||||
bool covariant_match(Type* gt, Context* ctx);
|
||||
ClassType* canonicalize(Context* ctx, int context_depth);
|
||||
|
||||
void bind_variables_to_parameters(Descriptor* sig);
|
||||
|
||||
#ifndef PRODUCT
|
||||
void reify_signature(stringStream* ss, Context* ctx);
|
||||
void print_on(outputStream* str) const;
|
||||
#endif
|
||||
};
|
||||
|
||||
class TypeVariable : public Type {
|
||||
private:
|
||||
Identifier* _id;
|
||||
TypeParameter* _parameter; // assigned during linking
|
||||
|
||||
// how many steps "out" from inner classes, -1 if method
|
||||
int _inner_depth;
|
||||
|
||||
TypeVariable(Identifier* id)
|
||||
: _id(id), _parameter(NULL), _inner_depth(0) {}
|
||||
|
||||
public:
|
||||
TypeVariable* as_variable() { return this; }
|
||||
|
||||
static TypeVariable* parse_generic_signature(DescriptorStream* str);
|
||||
|
||||
Identifier* identifier() { return _id; }
|
||||
TypeParameter* parameter() { return _parameter; }
|
||||
int inner_depth() { return _inner_depth; }
|
||||
|
||||
void bind_variables_to_parameters(Descriptor* sig);
|
||||
|
||||
Type* resolve(Context* ctx, int ctx_depth);
|
||||
bool covariant_match(Type* gt, Context* ctx);
|
||||
Type* canonicalize(Context* ctx, int ctx_depth);
|
||||
|
||||
#ifndef PRODUCT
|
||||
void reify_signature(stringStream* ss, Context* ctx);
|
||||
void print_on(outputStream* str) const;
|
||||
#endif
|
||||
};
|
||||
|
||||
class ArrayType : public Type {
|
||||
private:
|
||||
Type* _base;
|
||||
|
||||
ArrayType(Type* base) : _base(base) {}
|
||||
|
||||
public:
|
||||
ArrayType* as_array() { return this; }
|
||||
|
||||
static ArrayType* parse_generic_signature(DescriptorStream* str);
|
||||
|
||||
bool covariant_match(Type* gt, Context* ctx);
|
||||
ArrayType* canonicalize(Context* ctx, int ctx_depth);
|
||||
|
||||
void bind_variables_to_parameters(Descriptor* sig);
|
||||
|
||||
#ifndef PRODUCT
|
||||
void reify_signature(stringStream* ss, Context* ctx);
|
||||
void print_on(outputStream* str) const;
|
||||
#endif
|
||||
};
|
||||
|
||||
class PrimitiveType : public Type {
|
||||
friend class Type;
|
||||
private:
|
||||
char _type; // includes V for void
|
||||
|
||||
PrimitiveType(char& type) : _type(type) {}
|
||||
|
||||
public:
|
||||
PrimitiveType* as_primitive() { return this; }
|
||||
|
||||
bool covariant_match(Type* gt, Context* ctx);
|
||||
PrimitiveType* canonicalize(Context* ctx, int ctx_depth);
|
||||
|
||||
void bind_variables_to_parameters(Descriptor* sig);
|
||||
|
||||
#ifndef PRODUCT
|
||||
void reify_signature(stringStream* ss, Context* ctx);
|
||||
void print_on(outputStream* str) const;
|
||||
#endif
|
||||
};
|
||||
|
||||
class TypeArgument : public ResourceObj {
|
||||
private:
|
||||
Type* _lower_bound;
|
||||
Type* _upper_bound; // may be null or == _lower_bound
|
||||
|
||||
TypeArgument(Type* lower_bound, Type* upper_bound)
|
||||
: _lower_bound(lower_bound), _upper_bound(upper_bound) {}
|
||||
|
||||
public:
|
||||
|
||||
static TypeArgument* parse_generic_signature(DescriptorStream* str);
|
||||
|
||||
Type* lower_bound() { return _lower_bound; }
|
||||
Type* upper_bound() { return _upper_bound; }
|
||||
|
||||
void bind_variables_to_parameters(Descriptor* sig);
|
||||
TypeArgument* canonicalize(Context* ctx, int ctx_depth);
|
||||
|
||||
bool covariant_match(TypeArgument* a, Context* ctx);
|
||||
|
||||
#ifndef PRODUCT
|
||||
void print_on(outputStream* str) const;
|
||||
#endif
|
||||
};
|
||||
|
||||
|
||||
class Context : public ResourceObj {
|
||||
private:
|
||||
DescriptorCache* _cache;
|
||||
GrowableArray<ClassType*> _type_arguments;
|
||||
|
||||
void reset_to_mark(int size);
|
||||
|
||||
public:
|
||||
// When this object goes out of scope or 'destroy' is
|
||||
// called, then the application of the type to the
|
||||
// context is wound-back (unless it's been deactivated).
|
||||
class Mark : public StackObj {
|
||||
private:
|
||||
mutable Context* _context;
|
||||
int _marked_size;
|
||||
|
||||
bool is_active() const { return _context != NULL; }
|
||||
void deactivate() const { _context = NULL; }
|
||||
|
||||
public:
|
||||
Mark() : _context(NULL), _marked_size(0) {}
|
||||
Mark(Context* ctx, int sz) : _context(ctx), _marked_size(sz) {}
|
||||
Mark(const Mark& m) : _context(m._context), _marked_size(m._marked_size) {
|
||||
m.deactivate(); // Ownership is transferred
|
||||
}
|
||||
|
||||
Mark& operator=(const Mark& cm) {
|
||||
destroy();
|
||||
_context = cm._context;
|
||||
_marked_size = cm._marked_size;
|
||||
cm.deactivate();
|
||||
return *this;
|
||||
}
|
||||
|
||||
void destroy();
|
||||
~Mark() { destroy(); }
|
||||
};
|
||||
|
||||
Context(DescriptorCache* cache) : _cache(cache) {}
|
||||
|
||||
Mark mark() { return Mark(this, _type_arguments.length()); }
|
||||
void apply_type_arguments(InstanceKlass* current, InstanceKlass* super,TRAPS);
|
||||
|
||||
ClassType* at_depth(int i) const;
|
||||
|
||||
#ifndef PRODUCT
|
||||
void print_on(outputStream* str) const;
|
||||
#endif
|
||||
};
|
||||
|
||||
/**
|
||||
* Contains a cache of descriptors for classes and methods so they can be
|
||||
* looked-up instead of reparsing each time they are needed.
|
||||
*/
|
||||
class DescriptorCache : public ResourceObj {
|
||||
private:
|
||||
ResourceHashtable<InstanceKlass*, ClassDescriptor*> _class_descriptors;
|
||||
ResourceHashtable<Method*, MethodDescriptor*> _method_descriptors;
|
||||
|
||||
public:
|
||||
ClassDescriptor* descriptor_for(InstanceKlass* ikh, TRAPS);
|
||||
|
||||
MethodDescriptor* descriptor_for(Method* mh, ClassDescriptor* cd, TRAPS);
|
||||
// Class descriptor derived from method holder
|
||||
MethodDescriptor* descriptor_for(Method* mh, TRAPS);
|
||||
};
|
||||
|
||||
} // namespace generic
|
||||
|
||||
#endif // SHARE_VM_CLASSFILE_GENERICSIGNATURES_HPP
|
||||
|
||||
@ -188,6 +188,10 @@ bool Verifier::verify(instanceKlassHandle klass, Verifier::Mode mode, bool shoul
|
||||
bool Verifier::is_eligible_for_verification(instanceKlassHandle klass, bool should_verify_class) {
|
||||
Symbol* name = klass->name();
|
||||
Klass* refl_magic_klass = SystemDictionary::reflect_MagicAccessorImpl_klass();
|
||||
Klass* lambda_magic_klass = SystemDictionary::lambda_MagicLambdaImpl_klass();
|
||||
|
||||
bool is_reflect = refl_magic_klass != NULL && klass->is_subtype_of(refl_magic_klass);
|
||||
bool is_lambda = lambda_magic_klass != NULL && klass->is_subtype_of(lambda_magic_klass);
|
||||
|
||||
return (should_verify_for(klass->class_loader(), should_verify_class) &&
|
||||
// return if the class is a bootstrapping class
|
||||
@ -210,9 +214,9 @@ bool Verifier::is_eligible_for_verification(instanceKlassHandle klass, bool shou
|
||||
// sun/reflect/SerializationConstructorAccessor.
|
||||
// NOTE: this is called too early in the bootstrapping process to be
|
||||
// guarded by Universe::is_gte_jdk14x_version()/UseNewReflection.
|
||||
(refl_magic_klass == NULL ||
|
||||
!klass->is_subtype_of(refl_magic_klass) ||
|
||||
VerifyReflectionBytecodes)
|
||||
// Also for lambda generated code, gte jdk8
|
||||
(!is_reflect || VerifyReflectionBytecodes) &&
|
||||
(!is_lambda || VerifyLambdaBytecodes)
|
||||
);
|
||||
}
|
||||
|
||||
@ -2318,9 +2322,6 @@ void ClassVerifier::verify_invoke_instructions(
|
||||
types = 1 << JVM_CONSTANT_InvokeDynamic;
|
||||
break;
|
||||
case Bytecodes::_invokespecial:
|
||||
types = (1 << JVM_CONSTANT_InterfaceMethodref) |
|
||||
(1 << JVM_CONSTANT_Methodref);
|
||||
break;
|
||||
case Bytecodes::_invokestatic:
|
||||
types = (_klass->major_version() < STATIC_METHOD_IN_INTERFACE_MAJOR_VERSION) ?
|
||||
(1 << JVM_CONSTANT_Methodref) :
|
||||
|
||||
@ -270,6 +270,7 @@
|
||||
template(java_lang_invoke_LambdaForm, "java/lang/invoke/LambdaForm") \
|
||||
template(java_lang_invoke_ForceInline_signature, "Ljava/lang/invoke/ForceInline;") \
|
||||
template(java_lang_invoke_DontInline_signature, "Ljava/lang/invoke/DontInline;") \
|
||||
template(sun_invoke_Stable_signature, "Lsun/invoke/Stable;") \
|
||||
template(java_lang_invoke_LambdaForm_Compiled_signature, "Ljava/lang/invoke/LambdaForm$Compiled;") \
|
||||
template(java_lang_invoke_LambdaForm_Hidden_signature, "Ljava/lang/invoke/LambdaForm$Hidden;") \
|
||||
template(java_lang_invoke_MagicLambdaImpl, "java/lang/invoke/MagicLambdaImpl") \
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 1998, 2012, Oracle and/or its affiliates. All rights reserved.
|
||||
* Copyright (c) 1998, 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
|
||||
@ -245,7 +245,7 @@ BufferBlob* BufferBlob::create(const char* name, CodeBuffer* cb) {
|
||||
}
|
||||
|
||||
|
||||
void* BufferBlob::operator new(size_t s, unsigned size) {
|
||||
void* BufferBlob::operator new(size_t s, unsigned size) throw() {
|
||||
void* p = CodeCache::allocate(size);
|
||||
return p;
|
||||
}
|
||||
@ -347,14 +347,14 @@ RuntimeStub* RuntimeStub::new_runtime_stub(const char* stub_name,
|
||||
}
|
||||
|
||||
|
||||
void* RuntimeStub::operator new(size_t s, unsigned size) {
|
||||
void* RuntimeStub::operator new(size_t s, unsigned size) throw() {
|
||||
void* p = CodeCache::allocate(size, true);
|
||||
if (!p) fatal("Initial size of CodeCache is too small");
|
||||
return p;
|
||||
}
|
||||
|
||||
// operator new shared by all singletons:
|
||||
void* SingletonBlob::operator new(size_t s, unsigned size) {
|
||||
void* SingletonBlob::operator new(size_t s, unsigned size) throw() {
|
||||
void* p = CodeCache::allocate(size, true);
|
||||
if (!p) fatal("Initial size of CodeCache is too small");
|
||||
return p;
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 1998, 2012, Oracle and/or its affiliates. All rights reserved.
|
||||
* Copyright (c) 1998, 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
|
||||
@ -209,7 +209,7 @@ class BufferBlob: public CodeBlob {
|
||||
BufferBlob(const char* name, int size);
|
||||
BufferBlob(const char* name, int size, CodeBuffer* cb);
|
||||
|
||||
void* operator new(size_t s, unsigned size);
|
||||
void* operator new(size_t s, unsigned size) throw();
|
||||
|
||||
public:
|
||||
// Creation
|
||||
@ -283,7 +283,7 @@ class RuntimeStub: public CodeBlob {
|
||||
bool caller_must_gc_arguments
|
||||
);
|
||||
|
||||
void* operator new(size_t s, unsigned size);
|
||||
void* operator new(size_t s, unsigned size) throw();
|
||||
|
||||
public:
|
||||
// Creation
|
||||
@ -321,7 +321,7 @@ class SingletonBlob: public CodeBlob {
|
||||
friend class VMStructs;
|
||||
|
||||
protected:
|
||||
void* operator new(size_t s, unsigned size);
|
||||
void* operator new(size_t s, unsigned size) throw();
|
||||
|
||||
public:
|
||||
SingletonBlob(
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 1998, 2012, Oracle and/or its affiliates. All rights reserved.
|
||||
* Copyright (c) 1998, 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
|
||||
@ -38,7 +38,7 @@ class DIR_Chunk {
|
||||
int _length; // number of bytes in the stream
|
||||
int _hash; // hash of stream bytes (for quicker reuse)
|
||||
|
||||
void* operator new(size_t ignore, DebugInformationRecorder* dir) {
|
||||
void* operator new(size_t ignore, DebugInformationRecorder* dir) throw() {
|
||||
assert(ignore == sizeof(DIR_Chunk), "");
|
||||
if (dir->_next_chunk >= dir->_next_chunk_limit) {
|
||||
const int CHUNK = 100;
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
|
||||
* Copyright (c) 1997, 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
|
||||
@ -93,18 +93,21 @@ HS_DTRACE_PROBE_DECL6(hotspot, compiled__method__unload,
|
||||
#endif
|
||||
|
||||
bool nmethod::is_compiled_by_c1() const {
|
||||
if (compiler() == NULL || method() == NULL) return false; // can happen during debug printing
|
||||
if (is_native_method()) return false;
|
||||
if (compiler() == NULL) {
|
||||
return false;
|
||||
}
|
||||
return compiler()->is_c1();
|
||||
}
|
||||
bool nmethod::is_compiled_by_c2() const {
|
||||
if (compiler() == NULL || method() == NULL) return false; // can happen during debug printing
|
||||
if (is_native_method()) return false;
|
||||
if (compiler() == NULL) {
|
||||
return false;
|
||||
}
|
||||
return compiler()->is_c2();
|
||||
}
|
||||
bool nmethod::is_compiled_by_shark() const {
|
||||
if (is_native_method()) return false;
|
||||
assert(compiler() != NULL, "must be");
|
||||
if (compiler() == NULL) {
|
||||
return false;
|
||||
}
|
||||
return compiler()->is_shark();
|
||||
}
|
||||
|
||||
@ -800,7 +803,7 @@ nmethod::nmethod(
|
||||
}
|
||||
#endif // def HAVE_DTRACE_H
|
||||
|
||||
void* nmethod::operator new(size_t size, int nmethod_size) throw () {
|
||||
void* nmethod::operator new(size_t size, int nmethod_size) throw() {
|
||||
// Not critical, may return null if there is too little continuous memory
|
||||
return CodeCache::allocate(nmethod_size);
|
||||
}
|
||||
@ -1401,6 +1404,9 @@ bool nmethod::make_not_entrant_or_zombie(unsigned int state) {
|
||||
// nmethods aren't scanned for GC.
|
||||
_oops_are_stale = true;
|
||||
#endif
|
||||
// the Method may be reclaimed by class unloading now that the
|
||||
// nmethod is in zombie state
|
||||
set_method(NULL);
|
||||
} else {
|
||||
assert(state == not_entrant, "other cases may need to be handled differently");
|
||||
}
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
|
||||
* Copyright (c) 1997, 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
|
||||
@ -265,7 +265,7 @@ class nmethod : public CodeBlob {
|
||||
int comp_level);
|
||||
|
||||
// helper methods
|
||||
void* operator new(size_t size, int nmethod_size);
|
||||
void* operator new(size_t size, int nmethod_size) throw();
|
||||
|
||||
const char* reloc_string_for(u_char* begin, u_char* end);
|
||||
// Returns true if this thread changed the state of the nmethod or
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
|
||||
* Copyright (c) 1997, 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
|
||||
@ -677,7 +677,7 @@ class Relocation VALUE_OBJ_CLASS_SPEC {
|
||||
}
|
||||
|
||||
public:
|
||||
void* operator new(size_t size, const RelocationHolder& holder) {
|
||||
void* operator new(size_t size, const RelocationHolder& holder) throw() {
|
||||
if (size > sizeof(holder._relocbuf)) guarantee_size();
|
||||
assert((void* const *)holder.reloc() == &holder._relocbuf[0], "ptrs must agree");
|
||||
return holder.reloc();
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
|
||||
* Copyright (c) 1997, 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
|
||||
@ -49,7 +49,7 @@ VMReg VtableStub::_receiver_location = VMRegImpl::Bad();
|
||||
static int num_vtable_chunks = 0;
|
||||
|
||||
|
||||
void* VtableStub::operator new(size_t size, int code_size) {
|
||||
void* VtableStub::operator new(size_t size, int code_size) throw() {
|
||||
assert(size == sizeof(VtableStub), "mismatched size");
|
||||
num_vtable_chunks++;
|
||||
// compute real VtableStub size (rounded to nearest word)
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
|
||||
* Copyright (c) 1997, 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
|
||||
@ -46,7 +46,7 @@ class VtableStub {
|
||||
bool _is_vtable_stub; // True if vtable stub, false, is itable stub
|
||||
/* code follows here */ // The vtableStub code
|
||||
|
||||
void* operator new(size_t size, int code_size);
|
||||
void* operator new(size_t size, int code_size) throw();
|
||||
|
||||
VtableStub(bool is_vtable_stub, int index)
|
||||
: _next(NULL), _is_vtable_stub(is_vtable_stub),
|
||||
|
||||
@ -1718,7 +1718,7 @@ static void codecache_print(bool detailed)
|
||||
CodeCache::print_summary(&s, detailed);
|
||||
}
|
||||
ttyLocker ttyl;
|
||||
tty->print_cr(s.as_string());
|
||||
tty->print(s.as_string());
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------
|
||||
|
||||
@ -2493,11 +2493,11 @@ void G1CollectedHeap::register_concurrent_cycle_start(jlong start_time) {
|
||||
|
||||
void G1CollectedHeap::register_concurrent_cycle_end() {
|
||||
if (_concurrent_cycle_started) {
|
||||
_gc_timer_cm->register_gc_end(os::elapsed_counter());
|
||||
|
||||
if (_cm->has_aborted()) {
|
||||
_gc_tracer_cm->report_concurrent_mode_failure();
|
||||
}
|
||||
|
||||
_gc_timer_cm->register_gc_end(os::elapsed_counter());
|
||||
_gc_tracer_cm->report_gc_end(_gc_timer_cm->gc_end(), _gc_timer_cm->time_partitions());
|
||||
|
||||
_concurrent_cycle_started = false;
|
||||
|
||||
@ -168,7 +168,15 @@ G1CollectorPolicy::G1CollectorPolicy() :
|
||||
// Set up the region size and associated fields. Given that the
|
||||
// policy is created before the heap, we have to set this up here,
|
||||
// so it's done as soon as possible.
|
||||
HeapRegion::setup_heap_region_size(Arguments::min_heap_size());
|
||||
|
||||
// It would have been natural to pass initial_heap_byte_size() and
|
||||
// max_heap_byte_size() to setup_heap_region_size() but those have
|
||||
// not been set up at this point since they should be aligned with
|
||||
// the region size. So, there is a circular dependency here. We base
|
||||
// the region size on the heap size, but the heap size should be
|
||||
// aligned with the region size. To get around this we use the
|
||||
// unaligned values for the heap.
|
||||
HeapRegion::setup_heap_region_size(InitialHeapSize, MaxHeapSize);
|
||||
HeapRegionRemSet::setup_remset_size();
|
||||
|
||||
G1ErgoVerbose::initialize();
|
||||
|
||||
@ -149,18 +149,11 @@ void HeapRegionDCTOC::walk_mem_region_with_cl(MemRegion mr,
|
||||
// many regions in the heap (based on the min heap size).
|
||||
#define TARGET_REGION_NUMBER 2048
|
||||
|
||||
void HeapRegion::setup_heap_region_size(uintx min_heap_size) {
|
||||
// region_size in bytes
|
||||
void HeapRegion::setup_heap_region_size(size_t initial_heap_size, size_t max_heap_size) {
|
||||
uintx region_size = G1HeapRegionSize;
|
||||
if (FLAG_IS_DEFAULT(G1HeapRegionSize)) {
|
||||
// We base the automatic calculation on the min heap size. This
|
||||
// can be problematic if the spread between min and max is quite
|
||||
// wide, imagine -Xms128m -Xmx32g. But, if we decided it based on
|
||||
// the max size, the region size might be way too large for the
|
||||
// min size. Either way, some users might have to set the region
|
||||
// size manually for some -Xms / -Xmx combos.
|
||||
|
||||
region_size = MAX2(min_heap_size / TARGET_REGION_NUMBER,
|
||||
size_t average_heap_size = (initial_heap_size + max_heap_size) / 2;
|
||||
region_size = MAX2(average_heap_size / TARGET_REGION_NUMBER,
|
||||
(uintx) MIN_REGION_SIZE);
|
||||
}
|
||||
|
||||
|
||||
@ -361,7 +361,7 @@ class HeapRegion: public G1OffsetTableContigSpace {
|
||||
// CardsPerRegion). All those fields are considered constant
|
||||
// throughout the JVM's execution, therefore they should only be set
|
||||
// up once during initialization time.
|
||||
static void setup_heap_region_size(uintx min_heap_size);
|
||||
static void setup_heap_region_size(size_t initial_heap_size, size_t max_heap_size);
|
||||
|
||||
enum ClaimValues {
|
||||
InitialClaimValue = 0,
|
||||
|
||||
@ -28,6 +28,7 @@
|
||||
#include "gc_implementation/shared/gcTrace.hpp"
|
||||
#include "gc_implementation/shared/gcWhen.hpp"
|
||||
#include "gc_implementation/shared/copyFailedInfo.hpp"
|
||||
#include "runtime/os.hpp"
|
||||
#include "trace/tracing.hpp"
|
||||
#include "trace/traceBackend.hpp"
|
||||
#if INCLUDE_ALL_GCS
|
||||
@ -54,11 +55,12 @@ void GCTracer::send_garbage_collection_event() const {
|
||||
}
|
||||
|
||||
void GCTracer::send_reference_stats_event(ReferenceType type, size_t count) const {
|
||||
EventGCReferenceStatistics e;
|
||||
EventGCReferenceStatistics e(UNTIMED);
|
||||
if (e.should_commit()) {
|
||||
e.set_gcId(_shared_gc_info.id());
|
||||
e.set_type((u1)type);
|
||||
e.set_count(count);
|
||||
e.set_endtime(os::elapsed_counter());
|
||||
e.commit();
|
||||
}
|
||||
}
|
||||
@ -105,20 +107,22 @@ static TraceStructCopyFailed to_trace_struct(const CopyFailedInfo& cf_info) {
|
||||
}
|
||||
|
||||
void YoungGCTracer::send_promotion_failed_event(const PromotionFailedInfo& pf_info) const {
|
||||
EventPromotionFailed e;
|
||||
EventPromotionFailed e(UNTIMED);
|
||||
if (e.should_commit()) {
|
||||
e.set_gcId(_shared_gc_info.id());
|
||||
e.set_data(to_trace_struct(pf_info));
|
||||
e.set_thread(pf_info.thread()->thread_id());
|
||||
e.set_endtime(os::elapsed_counter());
|
||||
e.commit();
|
||||
}
|
||||
}
|
||||
|
||||
// Common to CMS and G1
|
||||
void OldGCTracer::send_concurrent_mode_failure_event() {
|
||||
EventConcurrentModeFailure e;
|
||||
EventConcurrentModeFailure e(UNTIMED);
|
||||
if (e.should_commit()) {
|
||||
e.set_gcId(_shared_gc_info.id());
|
||||
e.set_endtime(os::elapsed_counter());
|
||||
e.commit();
|
||||
}
|
||||
}
|
||||
@ -136,7 +140,7 @@ void G1NewTracer::send_g1_young_gc_event() {
|
||||
}
|
||||
|
||||
void G1NewTracer::send_evacuation_info_event(EvacuationInfo* info) {
|
||||
EventEvacuationInfo e;
|
||||
EventEvacuationInfo e(UNTIMED);
|
||||
if (e.should_commit()) {
|
||||
e.set_gcId(_shared_gc_info.id());
|
||||
e.set_cSetRegions(info->collectionset_regions());
|
||||
@ -147,15 +151,17 @@ void G1NewTracer::send_evacuation_info_event(EvacuationInfo* info) {
|
||||
e.set_allocRegionsUsedAfter(info->alloc_regions_used_before() + info->bytes_copied());
|
||||
e.set_bytesCopied(info->bytes_copied());
|
||||
e.set_regionsFreed(info->regions_freed());
|
||||
e.set_endtime(os::elapsed_counter());
|
||||
e.commit();
|
||||
}
|
||||
}
|
||||
|
||||
void G1NewTracer::send_evacuation_failed_event(const EvacuationFailedInfo& ef_info) const {
|
||||
EventEvacuationFailed e;
|
||||
EventEvacuationFailed e(UNTIMED);
|
||||
if (e.should_commit()) {
|
||||
e.set_gcId(_shared_gc_info.id());
|
||||
e.set_data(to_trace_struct(ef_info));
|
||||
e.set_endtime(os::elapsed_counter());
|
||||
e.commit();
|
||||
}
|
||||
}
|
||||
@ -189,12 +195,13 @@ class GCHeapSummaryEventSender : public GCHeapSummaryVisitor {
|
||||
void visit(const GCHeapSummary* heap_summary) const {
|
||||
const VirtualSpaceSummary& heap_space = heap_summary->heap();
|
||||
|
||||
EventGCHeapSummary e;
|
||||
EventGCHeapSummary e(UNTIMED);
|
||||
if (e.should_commit()) {
|
||||
e.set_gcId(_id);
|
||||
e.set_when((u1)_when);
|
||||
e.set_heapSpace(to_trace_struct(heap_space));
|
||||
e.set_heapUsed(heap_summary->used());
|
||||
e.set_endtime(os::elapsed_counter());
|
||||
e.commit();
|
||||
}
|
||||
}
|
||||
@ -209,7 +216,7 @@ class GCHeapSummaryEventSender : public GCHeapSummaryVisitor {
|
||||
const SpaceSummary& from_space = ps_heap_summary->from();
|
||||
const SpaceSummary& to_space = ps_heap_summary->to();
|
||||
|
||||
EventPSHeapSummary e;
|
||||
EventPSHeapSummary e(UNTIMED);
|
||||
if (e.should_commit()) {
|
||||
e.set_gcId(_id);
|
||||
e.set_when((u1)_when);
|
||||
@ -220,6 +227,7 @@ class GCHeapSummaryEventSender : public GCHeapSummaryVisitor {
|
||||
e.set_edenSpace(to_trace_struct(ps_heap_summary->eden()));
|
||||
e.set_fromSpace(to_trace_struct(ps_heap_summary->from()));
|
||||
e.set_toSpace(to_trace_struct(ps_heap_summary->to()));
|
||||
e.set_endtime(os::elapsed_counter());
|
||||
e.commit();
|
||||
}
|
||||
}
|
||||
@ -241,13 +249,14 @@ static TraceStructMetaspaceSizes to_trace_struct(const MetaspaceSizes& sizes) {
|
||||
}
|
||||
|
||||
void GCTracer::send_meta_space_summary_event(GCWhen::Type when, const MetaspaceSummary& meta_space_summary) const {
|
||||
EventMetaspaceSummary e;
|
||||
EventMetaspaceSummary e(UNTIMED);
|
||||
if (e.should_commit()) {
|
||||
e.set_gcId(_shared_gc_info.id());
|
||||
e.set_when((u1) when);
|
||||
e.set_metaspace(to_trace_struct(meta_space_summary.meta_space()));
|
||||
e.set_dataSpace(to_trace_struct(meta_space_summary.data_space()));
|
||||
e.set_classSpace(to_trace_struct(meta_space_summary.class_space()));
|
||||
e.set_endtime(os::elapsed_counter());
|
||||
e.commit();
|
||||
}
|
||||
}
|
||||
@ -282,8 +291,6 @@ class PhaseSender : public PhaseVisitor {
|
||||
default: /* Ignore sending this phase */ break;
|
||||
}
|
||||
}
|
||||
|
||||
#undef send_phase
|
||||
};
|
||||
|
||||
void GCTracer::send_phase_events(TimePartitions* time_partitions) const {
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 2002, 2012, Oracle and/or its affiliates. All rights reserved.
|
||||
* Copyright (c) 2002, 2013, Oracle and/or its affiliates. All rights reserved.
|
||||
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
||||
*
|
||||
* This code is free software; you can redistribute it and/or modify it
|
||||
@ -144,9 +144,9 @@ class AdaptivePaddedAverage : public AdaptiveWeightedAverage {
|
||||
_padded_avg(0.0), _deviation(0.0), _padding(padding) {}
|
||||
|
||||
// Placement support
|
||||
void* operator new(size_t ignored, void* p) { return p; }
|
||||
void* operator new(size_t ignored, void* p) throw() { return p; }
|
||||
// Allocator
|
||||
void* operator new(size_t size) { return CHeapObj<mtGC>::operator new(size); }
|
||||
void* operator new(size_t size) throw() { return CHeapObj<mtGC>::operator new(size); }
|
||||
|
||||
// Accessor
|
||||
float padded_average() const { return _padded_avg; }
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
|
||||
* Copyright (c) 1997, 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
|
||||
@ -163,8 +163,8 @@ extern void safe_free (const char *file, unsigned line, void *ptr);
|
||||
extern void *safe_calloc (const char *file, unsigned line, unsigned nitems, unsigned size);
|
||||
extern void *safe_realloc(const char *file, unsigned line, void *ptr, unsigned size);
|
||||
extern char *safe_strdup (const char *file, unsigned line, const char *src);
|
||||
inline void *operator new( size_t size ) { return malloc(size); }
|
||||
inline void operator delete( void *ptr ) { free(ptr); }
|
||||
inline void *operator new( size_t size ) throw() { return malloc(size); }
|
||||
inline void operator delete( void *ptr ) { free(ptr); }
|
||||
#endif
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
@ -49,19 +49,19 @@
|
||||
# include "os_bsd.inline.hpp"
|
||||
#endif
|
||||
|
||||
void* StackObj::operator new(size_t size) { ShouldNotCallThis(); return 0; }
|
||||
void StackObj::operator delete(void* p) { ShouldNotCallThis(); }
|
||||
void* StackObj::operator new [](size_t size) { ShouldNotCallThis(); return 0; }
|
||||
void StackObj::operator delete [](void* p) { ShouldNotCallThis(); }
|
||||
void* StackObj::operator new(size_t size) throw() { ShouldNotCallThis(); return 0; }
|
||||
void StackObj::operator delete(void* p) { ShouldNotCallThis(); }
|
||||
void* StackObj::operator new [](size_t size) throw() { ShouldNotCallThis(); return 0; }
|
||||
void StackObj::operator delete [](void* p) { ShouldNotCallThis(); }
|
||||
|
||||
void* _ValueObj::operator new(size_t size) { ShouldNotCallThis(); return 0; }
|
||||
void _ValueObj::operator delete(void* p) { ShouldNotCallThis(); }
|
||||
void* _ValueObj::operator new [](size_t size) { ShouldNotCallThis(); return 0; }
|
||||
void _ValueObj::operator delete [](void* p) { ShouldNotCallThis(); }
|
||||
void* _ValueObj::operator new(size_t size) throw() { ShouldNotCallThis(); return 0; }
|
||||
void _ValueObj::operator delete(void* p) { ShouldNotCallThis(); }
|
||||
void* _ValueObj::operator new [](size_t size) throw() { ShouldNotCallThis(); return 0; }
|
||||
void _ValueObj::operator delete [](void* p) { ShouldNotCallThis(); }
|
||||
|
||||
void* MetaspaceObj::operator new(size_t size, ClassLoaderData* loader_data,
|
||||
size_t word_size, bool read_only,
|
||||
MetaspaceObj::Type type, TRAPS) {
|
||||
MetaspaceObj::Type type, TRAPS) throw() {
|
||||
// Klass has it's own operator new
|
||||
return Metaspace::allocate(loader_data, word_size, read_only,
|
||||
type, CHECK_NULL);
|
||||
@ -80,7 +80,7 @@ void MetaspaceObj::print_address_on(outputStream* st) const {
|
||||
st->print(" {"INTPTR_FORMAT"}", this);
|
||||
}
|
||||
|
||||
void* ResourceObj::operator new(size_t size, allocation_type type, MEMFLAGS flags) {
|
||||
void* ResourceObj::operator new(size_t size, allocation_type type, MEMFLAGS flags) throw() {
|
||||
address res;
|
||||
switch (type) {
|
||||
case C_HEAP:
|
||||
@ -97,12 +97,12 @@ void* ResourceObj::operator new(size_t size, allocation_type type, MEMFLAGS flag
|
||||
return res;
|
||||
}
|
||||
|
||||
void* ResourceObj::operator new [](size_t size, allocation_type type, MEMFLAGS flags) {
|
||||
void* ResourceObj::operator new [](size_t size, allocation_type type, MEMFLAGS flags) throw() {
|
||||
return (address) operator new(size, type, flags);
|
||||
}
|
||||
|
||||
void* ResourceObj::operator new(size_t size, const std::nothrow_t& nothrow_constant,
|
||||
allocation_type type, MEMFLAGS flags) {
|
||||
allocation_type type, MEMFLAGS flags) throw() {
|
||||
//should only call this with std::nothrow, use other operator new() otherwise
|
||||
address res;
|
||||
switch (type) {
|
||||
@ -121,7 +121,7 @@ void* ResourceObj::operator new(size_t size, const std::nothrow_t& nothrow_cons
|
||||
}
|
||||
|
||||
void* ResourceObj::operator new [](size_t size, const std::nothrow_t& nothrow_constant,
|
||||
allocation_type type, MEMFLAGS flags) {
|
||||
allocation_type type, MEMFLAGS flags) throw() {
|
||||
return (address)operator new(size, nothrow_constant, type, flags);
|
||||
}
|
||||
|
||||
@ -370,7 +370,7 @@ class ChunkPoolCleaner : public PeriodicTask {
|
||||
//--------------------------------------------------------------------------------------
|
||||
// Chunk implementation
|
||||
|
||||
void* Chunk::operator new (size_t requested_size, AllocFailType alloc_failmode, size_t length) {
|
||||
void* Chunk::operator new (size_t requested_size, AllocFailType alloc_failmode, size_t length) throw() {
|
||||
// requested_size is equal to sizeof(Chunk) but in order for the arena
|
||||
// allocations to come out aligned as expected the size must be aligned
|
||||
// to expected arena alignment.
|
||||
@ -478,18 +478,18 @@ Arena::~Arena() {
|
||||
NOT_PRODUCT(Atomic::dec(&_instance_count);)
|
||||
}
|
||||
|
||||
void* Arena::operator new(size_t size) {
|
||||
void* Arena::operator new(size_t size) throw() {
|
||||
assert(false, "Use dynamic memory type binding");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void* Arena::operator new (size_t size, const std::nothrow_t& nothrow_constant) {
|
||||
void* Arena::operator new (size_t size, const std::nothrow_t& nothrow_constant) throw() {
|
||||
assert(false, "Use dynamic memory type binding");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// dynamic memory type binding
|
||||
void* Arena::operator new(size_t size, MEMFLAGS flags) {
|
||||
void* Arena::operator new(size_t size, MEMFLAGS flags) throw() {
|
||||
#ifdef ASSERT
|
||||
void* p = (void*)AllocateHeap(size, flags|otArena, CALLER_PC);
|
||||
if (PrintMallocFree) trace_heap_malloc(size, "Arena-new", p);
|
||||
@ -499,7 +499,7 @@ void* Arena::operator new(size_t size, MEMFLAGS flags) {
|
||||
#endif
|
||||
}
|
||||
|
||||
void* Arena::operator new(size_t size, const std::nothrow_t& nothrow_constant, MEMFLAGS flags) {
|
||||
void* Arena::operator new(size_t size, const std::nothrow_t& nothrow_constant, MEMFLAGS flags) throw() {
|
||||
#ifdef ASSERT
|
||||
void* p = os::malloc(size, flags|otArena, CALLER_PC);
|
||||
if (PrintMallocFree) trace_heap_malloc(size, "Arena-new", p);
|
||||
@ -688,22 +688,22 @@ void* Arena::internal_malloc_4(size_t x) {
|
||||
// define ALLOW_OPERATOR_NEW_USAGE for platform on which global operator new allowed.
|
||||
//
|
||||
#ifndef ALLOW_OPERATOR_NEW_USAGE
|
||||
void* operator new(size_t size){
|
||||
void* operator new(size_t size) throw() {
|
||||
assert(false, "Should not call global operator new");
|
||||
return 0;
|
||||
}
|
||||
|
||||
void* operator new [](size_t size){
|
||||
void* operator new [](size_t size) throw() {
|
||||
assert(false, "Should not call global operator new[]");
|
||||
return 0;
|
||||
}
|
||||
|
||||
void* operator new(size_t size, const std::nothrow_t& nothrow_constant){
|
||||
void* operator new(size_t size, const std::nothrow_t& nothrow_constant) throw() {
|
||||
assert(false, "Should not call global operator new");
|
||||
return 0;
|
||||
}
|
||||
|
||||
void* operator new [](size_t size, std::nothrow_t& nothrow_constant){
|
||||
void* operator new [](size_t size, std::nothrow_t& nothrow_constant) throw() {
|
||||
assert(false, "Should not call global operator new[]");
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -204,12 +204,12 @@ const bool NMT_track_callsite = false;
|
||||
|
||||
template <MEMFLAGS F> class CHeapObj ALLOCATION_SUPER_CLASS_SPEC {
|
||||
public:
|
||||
_NOINLINE_ void* operator new(size_t size, address caller_pc = 0);
|
||||
_NOINLINE_ void* operator new(size_t size, address caller_pc = 0) throw();
|
||||
_NOINLINE_ void* operator new (size_t size, const std::nothrow_t& nothrow_constant,
|
||||
address caller_pc = 0);
|
||||
_NOINLINE_ void* operator new [](size_t size, address caller_pc = 0);
|
||||
address caller_pc = 0) throw();
|
||||
_NOINLINE_ void* operator new [](size_t size, address caller_pc = 0) throw();
|
||||
_NOINLINE_ void* operator new [](size_t size, const std::nothrow_t& nothrow_constant,
|
||||
address caller_pc = 0);
|
||||
address caller_pc = 0) throw();
|
||||
void operator delete(void* p);
|
||||
void operator delete [] (void* p);
|
||||
};
|
||||
@ -219,9 +219,9 @@ template <MEMFLAGS F> class CHeapObj ALLOCATION_SUPER_CLASS_SPEC {
|
||||
|
||||
class StackObj ALLOCATION_SUPER_CLASS_SPEC {
|
||||
private:
|
||||
void* operator new(size_t size);
|
||||
void* operator new(size_t size) throw();
|
||||
void operator delete(void* p);
|
||||
void* operator new [](size_t size);
|
||||
void* operator new [](size_t size) throw();
|
||||
void operator delete [](void* p);
|
||||
};
|
||||
|
||||
@ -245,9 +245,9 @@ class StackObj ALLOCATION_SUPER_CLASS_SPEC {
|
||||
//
|
||||
class _ValueObj {
|
||||
private:
|
||||
void* operator new(size_t size);
|
||||
void* operator new(size_t size) throw();
|
||||
void operator delete(void* p);
|
||||
void* operator new [](size_t size);
|
||||
void* operator new [](size_t size) throw();
|
||||
void operator delete [](void* p);
|
||||
};
|
||||
|
||||
@ -316,7 +316,7 @@ class MetaspaceObj {
|
||||
|
||||
void* operator new(size_t size, ClassLoaderData* loader_data,
|
||||
size_t word_size, bool read_only,
|
||||
Type type, Thread* thread);
|
||||
Type type, Thread* thread) throw();
|
||||
// can't use TRAPS from this header file.
|
||||
void operator delete(void* p) { ShouldNotCallThis(); }
|
||||
};
|
||||
@ -339,7 +339,7 @@ class Chunk: CHeapObj<mtChunk> {
|
||||
Chunk* _next; // Next Chunk in list
|
||||
const size_t _len; // Size of this Chunk
|
||||
public:
|
||||
void* operator new(size_t size, AllocFailType alloc_failmode, size_t length);
|
||||
void* operator new(size_t size, AllocFailType alloc_failmode, size_t length) throw();
|
||||
void operator delete(void* p);
|
||||
Chunk(size_t length);
|
||||
|
||||
@ -422,12 +422,12 @@ protected:
|
||||
char* hwm() const { return _hwm; }
|
||||
|
||||
// new operators
|
||||
void* operator new (size_t size);
|
||||
void* operator new (size_t size, const std::nothrow_t& nothrow_constant);
|
||||
void* operator new (size_t size) throw();
|
||||
void* operator new (size_t size, const std::nothrow_t& nothrow_constant) throw();
|
||||
|
||||
// dynamic memory type tagging
|
||||
void* operator new(size_t size, MEMFLAGS flags);
|
||||
void* operator new(size_t size, const std::nothrow_t& nothrow_constant, MEMFLAGS flags);
|
||||
void* operator new(size_t size, MEMFLAGS flags) throw();
|
||||
void* operator new(size_t size, const std::nothrow_t& nothrow_constant, MEMFLAGS flags) throw();
|
||||
void operator delete(void* p);
|
||||
|
||||
// Fast allocate in the arena. Common case is: pointer test + increment.
|
||||
@ -583,44 +583,44 @@ class ResourceObj ALLOCATION_SUPER_CLASS_SPEC {
|
||||
#endif // ASSERT
|
||||
|
||||
public:
|
||||
void* operator new(size_t size, allocation_type type, MEMFLAGS flags);
|
||||
void* operator new [](size_t size, allocation_type type, MEMFLAGS flags);
|
||||
void* operator new(size_t size, allocation_type type, MEMFLAGS flags) throw();
|
||||
void* operator new [](size_t size, allocation_type type, MEMFLAGS flags) throw();
|
||||
void* operator new(size_t size, const std::nothrow_t& nothrow_constant,
|
||||
allocation_type type, MEMFLAGS flags);
|
||||
allocation_type type, MEMFLAGS flags) throw();
|
||||
void* operator new [](size_t size, const std::nothrow_t& nothrow_constant,
|
||||
allocation_type type, MEMFLAGS flags);
|
||||
allocation_type type, MEMFLAGS flags) throw();
|
||||
|
||||
void* operator new(size_t size, Arena *arena) {
|
||||
void* operator new(size_t size, Arena *arena) throw() {
|
||||
address res = (address)arena->Amalloc(size);
|
||||
DEBUG_ONLY(set_allocation_type(res, ARENA);)
|
||||
return res;
|
||||
}
|
||||
|
||||
void* operator new [](size_t size, Arena *arena) {
|
||||
void* operator new [](size_t size, Arena *arena) throw() {
|
||||
address res = (address)arena->Amalloc(size);
|
||||
DEBUG_ONLY(set_allocation_type(res, ARENA);)
|
||||
return res;
|
||||
}
|
||||
|
||||
void* operator new(size_t size) {
|
||||
void* operator new(size_t size) throw() {
|
||||
address res = (address)resource_allocate_bytes(size);
|
||||
DEBUG_ONLY(set_allocation_type(res, RESOURCE_AREA);)
|
||||
return res;
|
||||
}
|
||||
|
||||
void* operator new(size_t size, const std::nothrow_t& nothrow_constant) {
|
||||
void* operator new(size_t size, const std::nothrow_t& nothrow_constant) throw() {
|
||||
address res = (address)resource_allocate_bytes(size, AllocFailStrategy::RETURN_NULL);
|
||||
DEBUG_ONLY(if (res != NULL) set_allocation_type(res, RESOURCE_AREA);)
|
||||
return res;
|
||||
}
|
||||
|
||||
void* operator new [](size_t size) {
|
||||
void* operator new [](size_t size) throw() {
|
||||
address res = (address)resource_allocate_bytes(size);
|
||||
DEBUG_ONLY(set_allocation_type(res, RESOURCE_AREA);)
|
||||
return res;
|
||||
}
|
||||
|
||||
void* operator new [](size_t size, const std::nothrow_t& nothrow_constant) {
|
||||
void* operator new [](size_t size, const std::nothrow_t& nothrow_constant) throw() {
|
||||
address res = (address)resource_allocate_bytes(size, AllocFailStrategy::RETURN_NULL);
|
||||
DEBUG_ONLY(if (res != NULL) set_allocation_type(res, RESOURCE_AREA);)
|
||||
return res;
|
||||
|
||||
@ -85,7 +85,7 @@ inline void FreeHeap(void* p, MEMFLAGS memflags = mtInternal) {
|
||||
|
||||
|
||||
template <MEMFLAGS F> void* CHeapObj<F>::operator new(size_t size,
|
||||
address caller_pc){
|
||||
address caller_pc) throw() {
|
||||
void* p = (void*)AllocateHeap(size, F, (caller_pc != 0 ? caller_pc : CALLER_PC));
|
||||
#ifdef ASSERT
|
||||
if (PrintMallocFree) trace_heap_malloc(size, "CHeapObj-new", p);
|
||||
@ -94,7 +94,7 @@ template <MEMFLAGS F> void* CHeapObj<F>::operator new(size_t size,
|
||||
}
|
||||
|
||||
template <MEMFLAGS F> void* CHeapObj<F>::operator new (size_t size,
|
||||
const std::nothrow_t& nothrow_constant, address caller_pc) {
|
||||
const std::nothrow_t& nothrow_constant, address caller_pc) throw() {
|
||||
void* p = (void*)AllocateHeap(size, F, (caller_pc != 0 ? caller_pc : CALLER_PC),
|
||||
AllocFailStrategy::RETURN_NULL);
|
||||
#ifdef ASSERT
|
||||
@ -104,12 +104,12 @@ template <MEMFLAGS F> void* CHeapObj<F>::operator new (size_t size,
|
||||
}
|
||||
|
||||
template <MEMFLAGS F> void* CHeapObj<F>::operator new [](size_t size,
|
||||
address caller_pc){
|
||||
address caller_pc) throw() {
|
||||
return CHeapObj<F>::operator new(size, caller_pc);
|
||||
}
|
||||
|
||||
template <MEMFLAGS F> void* CHeapObj<F>::operator new [](size_t size,
|
||||
const std::nothrow_t& nothrow_constant, address caller_pc) {
|
||||
const std::nothrow_t& nothrow_constant, address caller_pc) throw() {
|
||||
return CHeapObj<F>::operator new(size, nothrow_constant, caller_pc);
|
||||
}
|
||||
|
||||
|
||||
@ -55,6 +55,7 @@ static void fail(const char *msg, va_list ap) {
|
||||
" shared archive file.\n");
|
||||
jio_vfprintf(defaultStream::error_stream(), msg, ap);
|
||||
jio_fprintf(defaultStream::error_stream(), "\n");
|
||||
// Do not change the text of the below message because some tests check for it.
|
||||
vm_exit_during_initialization("Unable to use shared archive.", NULL);
|
||||
}
|
||||
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved.
|
||||
* Copyright (c) 2000, 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
|
||||
@ -102,11 +102,11 @@ MemRegion MemRegion::minus(const MemRegion mr2) const {
|
||||
return MemRegion();
|
||||
}
|
||||
|
||||
void* MemRegion::operator new(size_t size) {
|
||||
void* MemRegion::operator new(size_t size) throw() {
|
||||
return (address)AllocateHeap(size, mtGC, 0, AllocFailStrategy::RETURN_NULL);
|
||||
}
|
||||
|
||||
void* MemRegion::operator new [](size_t size) {
|
||||
void* MemRegion::operator new [](size_t size) throw() {
|
||||
return (address)AllocateHeap(size, mtGC, 0, AllocFailStrategy::RETURN_NULL);
|
||||
}
|
||||
void MemRegion::operator delete(void* p) {
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 2000, 2012, Oracle and/or its affiliates. All rights reserved.
|
||||
* Copyright (c) 2000, 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
|
||||
@ -94,8 +94,8 @@ public:
|
||||
size_t word_size() const { return _word_size; }
|
||||
|
||||
bool is_empty() const { return word_size() == 0; }
|
||||
void* operator new(size_t size);
|
||||
void* operator new [](size_t size);
|
||||
void* operator new(size_t size) throw();
|
||||
void* operator new [](size_t size) throw();
|
||||
void operator delete(void* p);
|
||||
void operator delete [](void* p);
|
||||
};
|
||||
@ -111,13 +111,13 @@ public:
|
||||
|
||||
class MemRegionClosureRO: public MemRegionClosure {
|
||||
public:
|
||||
void* operator new(size_t size, ResourceObj::allocation_type type, MEMFLAGS flags) {
|
||||
void* operator new(size_t size, ResourceObj::allocation_type type, MEMFLAGS flags) throw() {
|
||||
return ResourceObj::operator new(size, type, flags);
|
||||
}
|
||||
void* operator new(size_t size, Arena *arena) {
|
||||
void* operator new(size_t size, Arena *arena) throw() {
|
||||
return ResourceObj::operator new(size, arena);
|
||||
}
|
||||
void* operator new(size_t size) {
|
||||
void* operator new(size_t size) throw() {
|
||||
return ResourceObj::operator new(size);
|
||||
}
|
||||
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
x
Reference in New Issue
Block a user