stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge

Browse Source
This commit is contained in:
Lana Steuck 2012-10-31 09:12:45 -07:00
commit fb8a6d4fcb
76 changed files with 1304 additions and 636 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.hgtags
View File

@ -182,3 +182,4 @@ ffe6bce5a521be40146af2ac03c509b7bac30595 jdk8-b56
479d3302a26d7607ba271d66973e59ebf58825b6 jdk8-b58
3bd874584fc01aae92fbc8827e2bd04d8b6ace04 jdk8-b59
5e3adc681779037a2d33b7be6f75680619085492 jdk8-b60
cdaa6122185f9bf512dcd6600f56bfccc4824e8c jdk8-b61

2
.hgtags-top-repo
View File

@ -182,3 +182,5 @@ b85b44cced2406792cfb9baab1377ff03e7001d8 jdk8-b55
9367024804874faf8e958adeb333682bab1c0c47 jdk8-b58
dae9821589ccd2611bdf7084269b98e819091770 jdk8-b59
e07f499b9dccb529ecf74172cf6ac11a195ec57a jdk8-b60
20ff117b509075c3aec4ee3a57990ecd5db5df9c jdk8-b61
8a3fe0ae06a8cc21347da5a18384b0aa6c2349f5 jdk8-b62

372
README-builds.html
View File

@ -96,7 +96,8 @@
</li>
<li>Windows only:
<ul>
<li>Unix Command Tools (<a href="#cygwin">CYGWIN</a>)</li>
<li>Unix Command Tools (<a href="#cygwin">CYGWIN</a>) <strong>or</strong></li>
<li>Minimalist GNU for Windows (<a href="#msys">MinGW/MSYS</a>)</li>
<li><a href="#dxsdk">DirectX 9.0 SDK</a> </li>
</ul>
</li>
@ -161,7 +162,7 @@
<blockquote>
This file often describes specific requirements for what we call the
"minimum build environments" (MBE) for this
specific release of the JDK,
specific release of the JDK,
Building with the MBE will generate the most compatible
bits that install on, and run correctly on, the most variations
of the same base OS and hardware architecture.
@ -241,16 +242,16 @@
</tbody>
</table>
<p>
These same sources do indeed build on many more systems than the
above older generation systems, again the above is just a minimum.
These same sources do indeed build on many more systems than the
above older generation systems, again the above is just a minimum.
<p>
Compilation problems with newer or different C/C++ compilers is a
common problem.
Similarly, compilation problems related to changes to the
Compilation problems with newer or different C/C++ compilers is a
common problem.
Similarly, compilation problems related to changes to the
<tt>/usr/include</tt> or system header files is also a
common problem with newer or unreleased OS versions.
Please report these types of problems as bugs so that they
can be dealt with accordingly.
common problem with newer or unreleased OS versions.
Please report these types of problems as bugs so that they
can be dealt with accordingly.
</blockquote>
<!-- ------------------------------------------------------ -->
<hr>
@ -266,15 +267,15 @@
<p>
<blockquote>
After installing <a href="http://fedoraproject.org">Fedora</a> 9
you need to install several build dependencies. The simplest
way to do it is to execute the following commands as user
you need to install several build dependencies. The simplest
way to do it is to execute the following commands as user
<tt>root</tt>:
<p/>
<code>yum-builddep java-1.6.0-openjdk</code>
<p/>
<code>yum install gcc gcc-c++</code>
<p/>
In addition, it's necessary to set a few environment variables for the build:
In addition, it's necessary to set a few environment variables for the build:
<p/>
<code>export LANG=C ALT_BOOTDIR=/usr/lib/jvm/java-openjdk</code>
@ -283,15 +284,15 @@
<p>
<blockquote>
After installing <a href="http://fedoraproject.org">Fedora</a> 10
you need to install several build dependencies. The simplest
way to do it is to execute the following commands as user
you need to install several build dependencies. The simplest
way to do it is to execute the following commands as user
<tt>root</tt>:
<p/>
<code>yum-builddep java-1.6.0-openjdk</code>
<p/>
<code>yum install gcc gcc-c++</code>
<p/>
In addition, it's necessary to set a few environment variables for the build:
In addition, it's necessary to set a few environment variables for the build:
<p/>
<code>export LANG=C ALT_BOOTDIR=/usr/lib/jvm/java-openjdk</code>
@ -300,15 +301,15 @@
<p>
<blockquote>
After installing <a href="http://fedoraproject.org">Fedora</a> 11
you need to install several build dependencies. The simplest
way to do it is to execute the following commands as user
you need to install several build dependencies. The simplest
way to do it is to execute the following commands as user
<tt>root</tt>:
<p/>
<code>yum-builddep java-1.6.0-openjdk</code>
<p/>
<code>yum install gcc gcc-c++</code>
<p/>
In addition, it's necessary to set a few environment variables for the build:
In addition, it's necessary to set a few environment variables for the build:
<p/>
<code>export LANG=C ALT_BOOTDIR=/usr/lib/jvm/java-openjdk</code>
@ -360,16 +361,16 @@
<h4>Debian 5.0 (Lenny)</h4>
<p>
<blockquote>
After installing <a href="http://debian.org">Debian</a> 5
you need to install several build dependencies.
The simplest way to install the build dependencies is to
execute the following commands as user <tt>root</tt>:
After installing <a href="http://debian.org">Debian</a> 5
you need to install several build dependencies.
The simplest way to install the build dependencies is to
execute the following commands as user <tt>root</tt>:
<p/>
<code>aptitude build-dep openjdk-6</code>
<p/>
<code>aptitude install openjdk-6-jdk libmotif-dev</code>
<p/>
In addition, it's necessary to set a few environment variables for the build:
In addition, it's necessary to set a few environment variables for the build:
<p/>
<code>export LANG=C ALT_BOOTDIR=/usr/lib/jvm/java-6-openjdk</code>
</blockquote>
@ -380,52 +381,52 @@
<h4>Ubuntu 8.04</h4>
<p>
<blockquote>
After installing <a href="http://ubuntu.org">Ubuntu</a> 8.04
you need to install several build dependencies.
After installing <a href="http://ubuntu.org">Ubuntu</a> 8.04
you need to install several build dependencies.
<p/>
First, you need to enable the universe repository in the
Software Sources application and reload the repository
information. The Software Sources application is available
under the System/Administration menu.
First, you need to enable the universe repository in the
Software Sources application and reload the repository
information. The Software Sources application is available
under the System/Administration menu.
<p/>
The simplest way to install the build dependencies is to
execute the following commands:
The simplest way to install the build dependencies is to
execute the following commands:
<p/>
<code>sudo aptitude build-dep openjdk-6</code>
<p/>
<code>sudo aptitude install openjdk-6-jdk</code>
<p/>
In addition, it's necessary to set a few environment variables for the build:
In addition, it's necessary to set a few environment variables for the build:
<p/>
<code>export LANG=C ALT_BOOTDIR=/usr/lib/jvm/java-6-openjdk</code>
</blockquote>
<h4>Ubuntu 8.10</h4>
<p>
<blockquote>
After installing <a href="http://ubuntu.org">Ubuntu</a> 8.10
you need to install several build dependencies. The simplest
way to do it is to execute the following commands:
After installing <a href="http://ubuntu.org">Ubuntu</a> 8.10
you need to install several build dependencies. The simplest
way to do it is to execute the following commands:
<p/>
<code>sudo aptitude build-dep openjdk-6</code>
<p/>
<code>sudo aptitude install openjdk-6-jdk</code>
<p/>
In addition, it's necessary to set a few environment variables for the build:
In addition, it's necessary to set a few environment variables for the build:
<p/>
<code>export LANG=C ALT_BOOTDIR=/usr/lib/jvm/java-6-openjdk</code>
</blockquote>
<h4>Ubuntu 9.04</h4>
<p>
<blockquote>
After installing <a href="http://ubuntu.org">Ubuntu</a> 9.04
you need to install several build dependencies. The simplest
way to do it is to execute the following commands:
After installing <a href="http://ubuntu.org">Ubuntu</a> 9.04
you need to install several build dependencies. The simplest
way to do it is to execute the following commands:
<p/>
<code>sudo aptitude build-dep openjdk-6</code>
<p/>
<code>sudo aptitude install openjdk-6-jdk</code>
<p/>
In addition, it's necessary to set a few environment variables for the build:
In addition, it's necessary to set a few environment variables for the build:
<p/>
<code>export LANG=C ALT_BOOTDIR=/usr/lib/jvm/java-6-openjdk</code>
</blockquote>
@ -436,20 +437,20 @@
<h4>OpenSUSE 11.1</h4>
<p>
<blockquote>
After installing <a href="http://opensuse.org">OpenSUSE</a> 11.1
you need to install several build dependencies.
The simplest way to install the build dependencies is to
execute the following commands:
After installing <a href="http://opensuse.org">OpenSUSE</a> 11.1
you need to install several build dependencies.
The simplest way to install the build dependencies is to
execute the following commands:
<p/>
<code>sudo zypper source-install -d java-1_6_0-openjdk</code>
<p/>
<code>sudo zypper install make</code>
<p/>
In addition, it is necessary to set a few environment variables for the build:
In addition, it is necessary to set a few environment variables for the build:
<p/>
<code>export LANG=C ALT_BOOTDIR=/usr/lib/jvm/java-1.6.0-openjdk</code>
<p/>
Finally, you need to unset the <code>JAVA_HOME</code> environment variable:
Finally, you need to unset the <code>JAVA_HOME</code> environment variable:
<p/>
<code>export -n JAVA_HOME</code>
</blockquote>
@ -460,14 +461,14 @@
<h4>Mandriva Linux One 2009 Spring</h4>
<p>
<blockquote>
After installing <a href="http://mandriva.org">Mandriva</a> Linux One 2009 Spring
you need to install several build dependencies.
The simplest way to install the build dependencies is to
execute the following commands as user <tt>root</tt>:
After installing <a href="http://mandriva.org">Mandriva</a> Linux One 2009 Spring
you need to install several build dependencies.
The simplest way to install the build dependencies is to
execute the following commands as user <tt>root</tt>:
<p/>
<code>urpmi java-1.6.0-openjdk-devel ant make gcc gcc-c++ freetype-devel zip unzip libcups2-devel libxrender1-devel libalsa2-devel libstc++-static-devel libxtst6-devel libxi-devel</code>
<p/>
In addition, it is necessary to set a few environment variables for the build:
In addition, it is necessary to set a few environment variables for the build:
<p/>
<code>export LANG=C ALT_BOOTDIR=/usr/lib/jvm/java-1.6.0-openjdk</code>
</blockquote>
@ -478,18 +479,18 @@
<h4>OpenSolaris 2009.06</h4>
<p>
<blockquote>
After installing <a href="http://opensolaris.org">OpenSolaris</a> 2009.06
you need to install several build dependencies.
The simplest way to install the build dependencies is to
execute the following commands:
After installing <a href="http://opensolaris.org">OpenSolaris</a> 2009.06
you need to install several build dependencies.
The simplest way to install the build dependencies is to
execute the following commands:
<p/>
<code>pfexec pkg install SUNWgmake SUNWj6dev SUNWant sunstudioexpress SUNWcups SUNWzip SUNWunzip SUNWxwhl SUNWxorg-headers SUNWaudh SUNWfreetype2</code>
<p/>
In addition, it is necessary to set a few environment variables for the build:
In addition, it is necessary to set a few environment variables for the build:
<p/>
<code>export LANG=C ALT_COMPILER_PATH=/opt/SunStudioExpress/bin/ ALT_CUPS_HEADERS_PATH=/usr/include/</code>
<p/>
Finally, you need to make sure that the build process can find the Sun Studio compilers:
Finally, you need to make sure that the build process can find the Sun Studio compilers:
<p/>
<code>export PATH=$PATH:/opt/SunStudioExpress/bin/</code>
</blockquote>
@ -687,31 +688,20 @@
</li>
<li>
<strong>Windows:</strong>
Make sure you start your build inside a bash/sh/ksh shell
and are using a <tt>make.exe</tt> utility built for that
environment (a cygwin <tt>make.exe</tt> is not the same
as a <tt>make.exe</tt> built for something like
<a href="http://www.mkssoftware.com/">MKS</a>).
<br>
<b>WARNING:</b> Watch out on some make 3.81 versions, it may
not work due to a lack of support for MS-DOS drive letter paths
like <tt>C:/</tt> or <tt>C:\</tt>.
<br>
You may be able to use the information at the
<a href="http://developer.mozilla.org/en/docs/Windows_build_prerequisites_using_cygwin#make" target="_blank">
mozilla developer center</a>
on this topic.
<br>
It's hoped that when make 3.82 starts shipping in a future cygwin
release that this MS-DOS path issue will be fixed.
<br>
It may be possible to download the version at
<a href="http://www.cmake.org/files/cygwin/make.exe">
www.cmake.org make.exe</a>.
<br>
It might be necessary for you to build your own GNU make 3.81,
see the <a href="#buildgmake">"Building GNU make"</a> section
in that case.
Make sure you start your build inside a bash/sh/ksh shell and are
using a <tt>make.exe</tt> utility built for that environment.<br/>
<strong>MKS</strong> builds need a native Windows version of GNU make
(see <a href="#buildgmake">Building GNU make</a>).<br/>
<strong>Cygwin</strong> builds need
a make version which was specially compiled for the Cygwin environment
(see <a href="#buildgmake">Building GNU make</a>). <strong>WARNING:</strong>
the OpenJDK build with the make utility provided by Cygwin will <strong>not</strong>
work because it does not support drive letters in paths. Make sure that
your version of make will be found before the Cygwins default make by
setting an appropriate <tt>PATH</tt> environment variable or by removing
Cygwin's make after you built your own make version.<br/>
<strong>MinGW/MSYS</strong> builds can use the default make which
comes with the environment.
</li>
</ul>
<p>
@ -727,7 +717,7 @@
<!-- ------------------------------------------------------ -->
<h4><a name="buildgmake">Building GNU make</a></h4>
<blockquote>
First step is to get the GNU make 3.81 source from
First step is to get the GNU make 3.81 (or newer) source from
<a href="http://ftp.gnu.org/pub/gnu/make/" target="_blank">
ftp.gnu.org/pub/gnu/make/</a>.
Building is a little different depending on the OS and unix toolset
@ -742,12 +732,24 @@
<tt>./configure && gmake CC=gcc</tt>
</li>
<li>
<strong>Windows for CYGWIN:</strong>
<tt>./configure && make</tt>
<strong>Windows for CYGWIN:</strong><br/>
<tt>./configure</tt><br/>
Add the line <tt>#define HAVE_CYGWIN_SHELL 1</tt> to the end of <tt>config.h</tt><br/>
<tt>make</tt><br/>
<br/>
This should produce <tt>make.exe</tt> in the current directory.
</li>
<li>
<strong>Windows for MKS: (CYGWIN is recommended)</strong>
<tt>./configure && make -f Makefile.win32</tt>
<strong>Windows for MKS:</strong><br/>
Edit <tt>config.h.W32</tt> and uncomment the line <tt>#define HAVE_MKS_SHELL 1</tt><br/>
Set the environment for your native compiler (e.g. by calling:<br/>
<tt>"C:\Program Files\Microsoft SDKs\Windows\v7.1\Bin\SetEnv.cmd" /Release /xp /x64)</tt>
<tt>nmake -f NMakefile.win32</tt>
<br/>
This should produce <tt>WinDebug/make.exe</tt> and <tt>WinRel/make.exe</tt>
<br/>
If you get the error: <tt>NMAKE : fatal error U1045: spawn failed : Permission denied</tt>
you have to set the <tt>Read &amp; execute</tt> permission for the file <tt>subproc.bat</tt>.
</li>
</ul>
</blockquote>
@ -894,39 +896,135 @@
<h4><a name="paths">Windows Paths</a></h4>
<blockquote>
<strong>Windows:</strong>
Note that GNU make is a historic utility and is based very
heavily on shell scripting, so it does not tolerate the Windows habit
Note that GNU make, the shell and other Unix-tools required during the build
do not tolerate the Windows habit
of having spaces in pathnames or the use of the <tt>\</tt>characters in pathnames.
Luckily on most Windows systems, you can use <tt>/</tt>instead of \, and
there is always a 'short' pathname without spaces for any path that
contains spaces.
Unfortunately, this short pathname can be somewhat dynamic and the
formula is difficult to explain.
You can use <tt>cygpath</tt> utility to map pathnames with spaces
or the <tt>\</tt>character into the <tt>C:/</tt> style of pathname
(called 'mixed'), e.g.
<tt>cygpath -s -m "<i>path</i>"</tt>.
Luckily on most Windows systems, you can use <tt>/</tt>instead of <tt>\</tt>, and
there is always a short <a href="http://en.wikipedia.org/wiki/8.3_filename">
"8.3" pathname</a> without spaces for any path that contains spaces.
Unfortunately, this short pathname is somewhat dynamic (i.e. dependant on the
other files and directories inside a given directory) and can not be
algorithmicly calculated by only looking at a specific path name.
<p>
The makefiles will try to translate any pathnames supplied
to it into the <tt>C:/</tt> style automatically.
</p>
<p>
Note that use of CYGWIN creates a unique problem with regards to
Special care has to be taken if native Windows applications
like <tt>nmake</tt> or <tt>cl</tt> are called with file arguments processed
by Unix-tools like <tt>make</tt> or <tt>sh</tt>!
</p>
</blockquote>
<!-- ------------------------------------------------------ -->
<h4><a name="paths">Windows build environments</a></h4>
<blockquote>
Building on Windows requires a Unix-like environment, notably a Unix-like shell.
There are several such environments available of which
<a href="http://www.mkssoftware.com/products/tk/ds_tkdev.asp">MKS</a>,
<a href="http://www.cygwin.com/">Cygwin</a> and
<a href="http://www.mingw.org/wiki/MSYS">MinGW/MSYS</a> are currently supported for
the OpenJDK build. One of the differences of these three systems is the way
they handle Windows path names, particularly path names which contain
spaces, backslashes as path separators and possibly drive letters. Depending
on the use case and the specifics of each environment these path problems can
be solved by a combination of quoting whole paths, translating backslashes to
forward slashes, escaping backslashes with additional backslashes and
translating the path names to their <a href="http://en.wikipedia.org/wiki/8.3_filename">
"8.3" version</a>.
<p>
As of this writing (MKS ver. 9.4, Cygwin ver. 1.7.9, MinGW/MSYS 1.0.17),
MKS builds are known to be the fastest Windows builds while MingGW/MSYS
builds are slightly slower (about 10%) than MKS builds and Cygwin builds
require nearly twice the time (about 180%) of MKS builds (e.g. on a
DualCore i7 notebook with 8GB of RAM, HDD and 64-bit Windows 7 operating system
the complete OpenJDK 8 product build takes about 49min with MKS, 54min with
MinGW/MSYS and 88min with Cygwin).
</p>
<p>
Mixing tools from the different Unix emulation environments is not a good
idea and will probably not work!
</p>
<p>
<strong>MKS:</strong> is a commercial product which includes
all the Unix utilities which are required to build the OpenJDK except GNU
make. In pre-OpenJDK times it was the only supported build environment on
Windows. The MKS tools support Windows paths with drive letters and
forward slashes as path separator. Paths in environment variables like (for
example) <tt>PATH</tt> are separated by semicolon '<tt>;</tt>'.
</p>
<p>
Recent versions of MKS provide the <tt>dosname</tt> utility to convert paths
with spaces to short (8.3) path names,e .g.
<tt>dosname -s "<i>path</i>"</tt>.
</p>
<p>
If you are using the MKS environment, you need a native Windows version
of Gnu make <a href="#buildgmake">which you can easily build yourself</a>.
</p>
<p>
<strong>Cygwin:</strong>
is an open source, Linux-like environment which tries to emulate
a complete POSIX layer on Windows. It tries to be smart about path names
and can usually handle all kinds of paths if they are correctly quoted
or escaped although internally it maps drive letters <tt>&lt;drive&gt;:</tt>
to a virtual directory <tt>/cygdrive/&lt;drive&gt;</tt>.
</p>
<p>
You can always use the <tt>cygpath</tt> utility to map pathnames with spaces
or the backslash character into the <tt>C:/</tt> style of pathname
(called 'mixed'), e.g. <tt>cygpath -s -m "<i>path</i>"</tt>.
</p>
<p>
Note that the use of CYGWIN creates a unique problem with regards to
setting <a href="#path"><tt>PATH</tt></a>. Normally on Windows
the <tt>PATH</tt> variable contains directories
separated with the ";" character (Solaris and Linux uses ":").
separated with the ";" character (Solaris and Linux use ":").
With CYGWIN, it uses ":", but that means that paths like "C:/path"
cannot be placed in the CYGWIN version of <tt>PATH</tt> and
instead CYGWIN uses something like <tt>/cygdrive/c/path</tt>
which CYGWIN understands, but only CYGWIN understands.
So be careful with paths on Windows.
</p>
<p>
If you are using the Cygwin environment, you need to
<a href="#buildgmake">compile your own version</a>
of GNU make because the default Cygwin make can not handle drive letters in paths.
</p>
<p>
<strong>MinGW/MSYS:</strong>
MinGW ("Minimalist GNU for Windows") is a collection of free Windows
specific header files and import libraries combined with GNU toolsets that
allow one to produce native Windows programs that do not rely on any
3rd-party C runtime DLLs. MSYS is a supplement to MinGW which allows building
applications and programs which rely on traditional UNIX tools to
be present. Among others this includes tools like <tt>bash</tt> and <tt>make</tt>.
</p>
<p>
Like Cygwin, MinGW/MSYS can handle different types of path formats. They
are internally converted to paths with forward slashes and drive letters
<tt>&lt;drive&gt;:</tt> replaced by a virtual
directory <tt>/&lt;drive&gt;</tt>. Additionally, MSYS automatically
detects binaries compiled for the MSYS environment and feeds them with the
internal, Unix-style path names. If native Windows applications are called
from within MSYS programs their path arguments are automatically converted
back to Windows style path names with drive letters and backslashes as
path separators. This may cause problems for Windows applications which
use forward slashes as parameter separator (e.g. <tt>cl /nologo /I</tt>)
because MSYS may wrongly <a href="http://mingw.org/wiki/Posix_path_conversion">
replace such parameters by drive letters</a>.
</p>
<p>
If you are using the MinGW/MSYS system you can use the default make
version supplied by the environment.
</p>
</blockquote>
<!-- ------------------------------------------------------ -->
<h4><a name="windows_checklist">Basic Windows Check List</a></h4>
<blockquote>
<ol>
<li>
Install the
<a href="#cygwin">CYGWIN product</a>.
Install one of the
<a href="#cygwin">CYGWIN</a>, <a href="#msys">MinGW/MSYS</a> or
<a href="http://www.mkssoftware.com/products/tk/ds_tkdev.asp">MKS</a> environments.
</li>
<li>
Install the
@ -1097,9 +1195,9 @@
<a href="http://www.oracle.com/technetwork/server-storage/solarisstudio/downloads/index.htm" target="_blank">
Sun Studio 12 Update 1 Compilers</a>
(containing version 5.10 of the C and C++ compilers) is required,
including specific patches.
including specific patches.
<p>
The Solaris SPARC patch list is:
The Solaris SPARC patch list is:
<ul>
<li>
118683-05: SunOS 5.10: Patch for profiling libraries and assembler
@ -1286,7 +1384,8 @@
The XRender header file is included with the other X11 header files
in the package <strong>SFWxwinc</strong> on new enough versions of
Solaris and will be installed in
<tt>/usr/X11/include/X11/extensions/Xrender.h</tt>
<tt>/usr/X11/include/X11/extensions/Xrender.h</tt> or
<tt>/usr/openwin/share/include/X11/extensions/Xrender.h</tt>
</p><p>
<strong>Linux:</strong>
XRender header files are required for building the
@ -1456,7 +1555,9 @@
<td>Devel</td>
<td>make</td>
<td>The GNU version of the 'make' utility built for CYGWIN.<br>
<b>NOTE</b>: See <a href="#gmake">the GNU make section</a></td>
<b>NOTE</b>: the Cygwin make can not be used to build the
OpenJDK. You only need it to build your own version of make
(see <a href="#gmake">the GNU make section</a>)</td>
</tr>
<tr>
<td>m4.exe</td>
@ -1521,6 +1622,21 @@
So it's important that the Visual Studio paths in PATH preceed
the CYGWIN path <tt>/usr/bin</tt>.
</blockquote>
<strong> Minimalist GNU for Windows (<a name="msys">MinGW/MSYS</a>)</strong>
<blockquote>
Alternatively, the set of unix command tools for the OpenJDK build on
Windows can be supplied by
<a href="http://www.mingw.org/wiki/MSYS" target="_blank">MinGW/MSYS</a>.
<p>
In addition to the tools which will be installed by default, you have
to manually install the <tt>msys-zip</tt> and <tt>msys-unzip</tt> packages.
This can be easily done with the MinGW command line installer:<br/>
<tt><br/>
mingw-get.exe install msys-zip<br/>
mingw-get.exe install msys-unzip<br/>
</tt>
</p>
</blockquote>
<strong><a name="dxsdk">Microsoft DirectX 9.0 SDK header files and libraries</a></strong>
<blockquote>
Microsoft DirectX 9.0 SDK (Summer 2004)
@ -1781,10 +1897,10 @@
</dd>
<dt><a name="ALT_OPENWIN_HOME"><tt>ALT_OPENWIN_HOME</tt></a></dt>
<dd>
The top-level directory of the libraries and include files for the platform's
graphical programming environment. The default location is platform specific.
For example, on Linux it defaults to <tt>/usr/X11R6/</tt>.
</dd>
The top-level directory of the libraries and include files for the platform's
graphical programming environment. The default location is platform specific.
For example, on Linux it defaults to <tt>/usr/X11R6/</tt>.
</dd>
<dt><strong>Windows specific:</strong></dt>
<dd>
<dl>
@ -1792,9 +1908,9 @@
<dd>
The location of the
Microsoft Windows SDK where some tools will be
located.
The default is whatever WINDOWSSDKDIR is set to
(or WindowsSdkDir) or the path
located.
The default is whatever WINDOWSSDKDIR is set to
(or WindowsSdkDir) or the path
<br>
<tt>c:\Program Files\Microsoft SDKs\Windows\v7.0a</tt>
</dd>
@ -1823,17 +1939,17 @@
is that <a href="#ALT_COMPILER_PATH"><tt>ALT_COMPILER_PATH</tt></a> is set
to point to the cross-compiler and that any cross-compilation specific flags
are passed using <a href="#EXTRA_CFLAGS"><tt>EXTRA_CFLAGS</tt></a>.
The <a href="#ALT_OPENWIN_HOME"><tt>ALT_OPENWIN_HOME</tt></a> variable should
also be set to point to the graphical header files (e.g. X11) provided with
the cross-compiler.
The <a href="#ALT_OPENWIN_HOME"><tt>ALT_OPENWIN_HOME</tt></a> variable should
also be set to point to the graphical header files (e.g. X11) provided with
the cross-compiler.
When cross-compiling we skip execution of any demos etc that may be built, and
also skip binary-file verification.
</dd>
<dt><tt><a name="EXTRA_CFLAGS">EXTRA_CFLAGS</a></tt> </dt>
<dd>
Used to pass cross-compilation options to the cross-compiler.
Used to pass cross-compilation options to the cross-compiler.
These are added to the <tt>CFLAGS</tt> and <tt>CXXFLAGS</tt> variables.
</dd>
</dd>
<dt><tt><a name="USE_ONLY_BOOTDIR_TOOLS">USE_ONLY_BOOTDIR_TOOLS</a></tt> </dt>
<dd>
Used primarily for cross-compilation builds (and always set in that case)
@ -1868,23 +1984,23 @@
<dt><tt><a name="BUILD_HEADLESS_ONLY"></a>BUILD_HEADLESS_ONLY</tt> </dt>
<dd>
Used when the build environment has no graphical capabilities at all. This
excludes building anything that requires graphical libraries to be available.
excludes building anything that requires graphical libraries to be available.
</dd>
<dt><tt><a name="JAVASE_EMBEDDED"></a>JAVASE_EMBEDDED</tt> </dt>
<dd>
Used to indicate this is a build of the Oracle Java SE Embedded product.
This will enable the directives included in the SE-Embedded specific build
files.
Used to indicate this is a build of the Oracle Java SE Embedded product.
This will enable the directives included in the SE-Embedded specific build
files.
</dd>
<dt><tt><a name="LIBZIP_CAN_USE_MMAP">LIBZIP_CAN_USE_MMAP</a></tt> </dt>
<dd>
If set to false, disables the use of mmap by the zip utility. Otherwise,
mmap will be used.
If set to false, disables the use of mmap by the zip utility. Otherwise,
mmap will be used.
</dd>
<dt><tt><a name="COMPRESS_JARS"></a>COMPRESS_JARS</tt> </dt>
<dd>
If set to true, causes certain jar files that would otherwise be built without
compression, to use compression.
If set to true, causes certain jar files that would otherwise be built without
compression, to use compression.
</dd>
</dl>
</dd>

1
corba/.hgtags
View File

@ -182,3 +182,4 @@ f3ab4163ae012965fc8acdfc25ce0fece8d6906d jdk8-b57
18462a19f7bd66d38015f61ea549a5e0c0c889a3 jdk8-b58
d54dc53e223ed9ce7d5f4d2cd02ad9d5def3c2db jdk8-b59
207ef43ba69ead6cbbab415d81834545e4d46747 jdk8-b60
0e08ba7648fb3faa0986cb217887d7c4990977f3 jdk8-b61

22
corba/make/common/shared/Defs-utils.gmk
View File

@ -151,16 +151,26 @@ CD = cd # intrinsic unix command
ifeq ($(PLATFORM),windows)
ifdef USING_CYGWIN
# Intrinsic unix command, with backslash-escaped character interpretation
ECHO = $(UNIXCOMMAND_PATH)echo -e
ZIPEXE = $(UNIXCOMMAND_PATH)zip
UNZIP = $(UNIXCOMMAND_PATH)unzip
ECHO = $(UNIXCOMMAND_PATH)echo -e
ZIPEXE = $(UNIXCOMMAND_PATH)zip
UNZIP = $(UNIXCOMMAND_PATH)unzip
# Some CYGWIN nawk versions require BINMODE=w for proper '\r' interpretation
NAWK = $(UNIXCOMMAND_PATH)awk -v BINMODE=w
else
ZIPEXE = $(UTILS_DEVTOOL_PATH)zip
UNZIP = $(UTILS_DEVTOOL_PATH)unzip
ifdef USING_MSYS
ECHO = $(UTILS_COMMAND_PATH)echo -e
ZIPEXE = $(UTILS_DEVTOOL_PATH)zip
UNZIP = $(UTILS_DEVTOOL_PATH)unzip
NAWK = $(UNIXCOMMAND_PATH)awk
else
ZIPEXE = $(UTILS_DEVTOOL_PATH)zip
UNZIP = $(UTILS_DEVTOOL_PATH)unzip
NAWK = $(UNIXCOMMAND_PATH)awk
endif
endif
# Re-define some utilities
LEX =# override GNU Make intrinsic: no lex on windows
NAWK = $(UNIXCOMMAND_PATH)awk
SHA1SUM = $(UNIXCOMMAND_PATH)openssl sha1
endif
# Linux specific

89
corba/make/common/shared/Defs-windows.gmk
View File

@ -91,6 +91,15 @@ define OptFullPath
$(shell if [ "$1" != "" -a -d "$1" ]; then $(CYGPATH_CMD) "$1"; else echo "$1"; fi)
endef
else
ifdef USING_MSYS
DOSPATH_CMD:=$(shell cd $(JDK_TOPDIR) 2> $(DEV_NULL) && pwd)/make/tools/msys_build_scripts/dospath.sh
define FullPath
$(subst \,/,$(shell $(DOSPATH_CMD) $1))
endef
define OptFullPath
$(shell if [ "$1" != "" -a -d "$1" ]; then (cd $1 && pwd); else echo "$1"; fi)
endef
else
# Temporary until we upgrade to MKS 8.7, MKS pwd returns mixed mode path
define FullPath
$(shell cd $1 2> $(DEV_NULL) && pwd)
@ -99,6 +108,7 @@ define OptFullPath
$(shell if [ "$1" != "" -a -d "$1" ]; then (cd $1 && pwd); else echo "$1"; fi)
endef
endif
endif
# System drive
ifdef SYSTEMDRIVE
@ -112,14 +122,21 @@ _system_drive:=$(call CheckValue,_system_drive,C:)
# UNIXCOMMAND_PATH: path to where the most common Unix commands are.
# NOTE: Must end with / so that it could be empty, allowing PATH usage.
ifndef UNIXCOMMAND_PATH
ifdef ALT_UNIXCOMMAND_PATH
# With cygwin, use this as is; don't use FullPath on it.
ifdef ALT_UNIXCOMMAND_PATH
ifdef USING_CYGWIN
UNIXCOMMAND_PATH :=$(call PrefixPath,$(ALT_UNIXCOMMAND_PATH))
else
xALT_UNIXCOMMAND_PATH :="$(subst \,/,$(ALT_UNIXCOMMAND_PATH))"
fxALT_UNIXCOMMAND_PATH :=$(call FullPath,$(xALT_UNIXCOMMAND_PATH))
UNIXCOMMAND_PATH :=$(call PrefixPath,$(fxALT_UNIXCOMMAND_PATH))
endif
else
ifdef USING_CYGWIN
UNIXCOMMAND_PATH :=$(call PrefixPath,/usr/bin)
else
ifdef USING_CYGWIN
UNIXCOMMAND_PATH :=$(call PrefixPath,/usr/bin)
ifdef USING_MSYS
UNIXCOMMAND_PATH :=$(call PrefixPath,/bin)
else
ifdef ROOTDIR
xROOTDIR :="$(subst \,/,$(ROOTDIR))"
@ -131,41 +148,35 @@ ifndef UNIXCOMMAND_PATH
ifneq ($(_rootdir),)
UNIXCOMMAND_PATH :=$(call PrefixPath,$(_rootdir)/mksnt)
endif
endif
endif
UNIXCOMMAND_PATH:=$(call AltCheckSpaces,UNIXCOMMAND_PATH)
export UNIXCOMMAND_PATH
endif # USING_MSYS
endif # USING_CYGWIN
endif
UNIXCOMMAND_PATH:=$(call AltCheckSpaces,UNIXCOMMAND_PATH)
export UNIXCOMMAND_PATH
# Get version of MKS or CYGWIN
ifdef USING_CYGWIN
ifndef CYGWIN_VER
_CYGWIN_VER :=$(shell $(UNAME))
CYGWIN_VER :=$(call GetVersion,$(_CYGWIN_VER))
export CYGWIN_VER
ifdef USING_MKS
_MKS_VER :=$(shell $(MKSINFO) 2>&1 | $(GREP) Release | $(TAIL) -1 | $(SED) -e 's@.*\(Release.*\)@\1@')
MKS_VER :=$(call GetVersion,$(_MKS_VER))
# At this point, we can re-define FullPath to use DOSNAME_CMD
CHECK_MKS87:=$(call CheckVersions,$(MKS_VER),8.7)
TRY_DOSNAME:=false
ifeq ($(CHECK_MKS87),same)
TRY_DOSNAME:=true
endif
else # MKS
_MKS_VER :=$(shell $(MKSINFO) 2>&1 | $(GREP) Release | $(TAIL) -1 | $(SED) -e 's@.*\(Release.*\)@\1@')
MKS_VER :=$(call GetVersion,$(_MKS_VER))
# At this point, we can re-define FullPath to use DOSNAME_CMD
CHECK_MKS87:=$(call CheckVersions,$(MKS_VER),8.7)
TRY_DOSNAME:=false
ifeq ($(CHECK_MKS87),same)
TRY_DOSNAME:=true
endif
# Newer should be ok
ifeq ($(CHECK_MKS87),newer)
TRY_DOSNAME:=true
endif
ifeq ($(TRY_DOSNAME),true)
ifeq ($(shell $(UNIXCOMMAND_PATH)dosname -s $(_system_drive)/ 2> $(DEV_NULL)),$(_system_drive)/)
_DOSNAME=$(UNIXCOMMAND_PATH)dosname
DOSNAME_CMD:=$(_DOSNAME) -s
# Newer should be ok
ifeq ($(CHECK_MKS87),newer)
TRY_DOSNAME:=true
endif
ifeq ($(TRY_DOSNAME),true)
ifeq ($(shell $(UNIXCOMMAND_PATH)dosname -s $(_system_drive)/ 2> $(DEV_NULL)),$(_system_drive)/)
_DOSNAME=$(UNIXCOMMAND_PATH)dosname
DOSNAME_CMD:=$(_DOSNAME) -s
define FullPath
$(subst //,/,$(shell echo $1 | $(DOSNAME_CMD) 2> $(DEV_NULL)))
endef
endif # test dosname -s
endif # TRY_DOSNAME
endif # test dosname -s
endif # TRY_DOSNAME
endif # MKS
# We try to get references to what we need via the default component
@ -240,6 +251,8 @@ endif
# DEVTOOLS_PATH: for other tools required for building (such as zip, etc.)
# NOTE: Must end with / so that it could be empty, allowing PATH usage.
ifndef DEVTOOLS_PATH
# DEVTOOLS_PATH: for other tools required for building (such as zip, etc.)
# NOTE: Must end with / so that it could be empty, allowing PATH usage.
ifdef ALT_DEVTOOLS_PATH
xALT_DEVTOOLS_PATH :="$(subst \,/,$(ALT_DEVTOOLS_PATH))"
fxALT_DEVTOOLS_PATH :=$(call FullPath,$(xALT_DEVTOOLS_PATH))
@ -248,10 +261,14 @@ ifndef DEVTOOLS_PATH
ifdef USING_CYGWIN
DEVTOOLS_PATH :=$(UNIXCOMMAND_PATH)
else
xDEVTOOLS_PATH :="$(_system_drive)/utils"
fxDEVTOOLS_PATH :=$(call FullPath,$(xDEVTOOLS_PATH))
DEVTOOLS_PATH :=$(call PrefixPath,$(fxDEVTOOLS_PATH))
endif
ifdef USING_MSYS
DEVTOOLS_PATH :=$(UNIXCOMMAND_PATH)
else
xDEVTOOLS_PATH :="$(_system_drive)/utils"
fxDEVTOOLS_PATH :=$(call FullPath,$(xDEVTOOLS_PATH))
DEVTOOLS_PATH :=$(call PrefixPath,$(fxDEVTOOLS_PATH))
endif # USING_MSYS
endif # USING_CYGWIN
endif
DEVTOOLS_PATH:=$(call AltCheckSpaces,DEVTOOLS_PATH)
export DEVTOOLS_PATH

9
corba/make/common/shared/Platform.gmk
View File

@ -65,6 +65,8 @@ PLATFORM_SHARED=done
# REQUIRED_WINDOWS_NAME windows only: basic name of windows
# REQUIRED_WINDOWS_VERSION windows only: specific version of windows
# USING_CYGWIN windows only: true or false
# USING_MSYS windows only: true or false
# USING_MKS windows only: true or false
# WINDOWS_NT_VERSION_STRING windows only: long version name
# REQUIRED_OS_VERSION required OS version, e.g. 5.10, 2.4
# REQUIRED_FREE_SPACE minimum disk space needed for outputdir
@ -327,6 +329,8 @@ endif
# Windows with and without CYGWIN will be slightly different
ifeq ($(SYSTEM_UNAME), Windows_NT)
PLATFORM = windows
USING_MKS = true
export USING_MKS
OS_VERSION := $(shell uname -r)
WINDOWS_NT_VERSION_STRING=Windows_NT
REQUIRED_MKS_VER=6.1
@ -339,6 +343,11 @@ ifneq (,$(findstring CYGWIN,$(SYSTEM_UNAME)))
WINDOWS_NT_VERSION_STRING=CYGWIN_NT
REQUIRED_CYGWIN_VER=4.0
endif
ifneq (,$(findstring MINGW,$(SYSTEM_UNAME)))
PLATFORM = windows
USING_MSYS = true
export USING_MSYS
endif
# Platform settings specific to Windows
ifeq ($(PLATFORM), windows)

2
hotspot/.hgtags
View File

@ -285,3 +285,5 @@ f2e12eb74117c917c0bb264694c02de4a6a15a10 hs25-b03
1cc7a2a11d00832e3d07f81f3744a6883422db7e hs25-b04
3cfd05b2219a29649741a52637696f06acf24a4e jdk8-b60
b261523fe66c40a02968f0aa7e73602491bb3386 hs25-b05
4547dc71db765276e027b0c2780b724bae0a07d3 jdk8-b61
d0337c31c8be7716369b4e7c3bd5f352983c6a06 hs25-b06

2
hotspot/make/hotspot_version
View File

@ -35,7 +35,7 @@ HOTSPOT_VM_COPYRIGHT=Copyright 2012
HS_MAJOR_VER=25
HS_MINOR_VER=0
HS_BUILD_NUMBER=05
HS_BUILD_NUMBER=06
JDK_MAJOR_VER=1
JDK_MINOR_VER=8

2
hotspot/src/share/vm/classfile/classFileParser.cpp
View File

@ -67,7 +67,7 @@
#define JAVA_CLASSFILE_MAGIC 0xCAFEBABE
#define JAVA_MIN_SUPPORTED_VERSION 45
#define JAVA_MAX_SUPPORTED_VERSION 51
#define JAVA_MAX_SUPPORTED_VERSION 52
#define JAVA_MAX_SUPPORTED_MINOR_VERSION 0
// Used for two backward compatibility reasons:

3
hotspot/src/share/vm/classfile/javaClasses.cpp
View File

@ -413,8 +413,7 @@ char* java_lang_String::as_utf8_string(oop java_string, int start, int len) {
}
bool java_lang_String::equals(oop java_string, jchar* chars, int len) {
assert(SharedSkipVerify ||
java_string->klass() == SystemDictionary::String_klass(),
assert(java_string->klass() == SystemDictionary::String_klass(),
"must be java_string");
typeArrayOop value = java_lang_String::value(java_string);
int offset = java_lang_String::offset(java_string);

3
hotspot/src/share/vm/classfile/systemDictionary.cpp
View File

@ -1699,6 +1699,9 @@ void SystemDictionary::always_strong_oops_do(OopClosure* blk) {
blk->do_oop(&_system_loader_lock_obj);
dictionary()->always_strong_oops_do(blk);
// Visit extra methods
invoke_method_table()->oops_do(blk);
}
void SystemDictionary::always_strong_classes_do(KlassClosure* closure) {

14
hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp
View File

@ -2395,7 +2395,7 @@ void CMSCollector::collect_in_foreground(bool clear_all_soft_refs) {
if (VerifyBeforeGC &&
GenCollectedHeap::heap()->total_collections() >= VerifyGCStartAt) {
Universe::verify(true);
Universe::verify();
}
// Snapshot the soft reference policy to be used in this collection cycle.
@ -2419,7 +2419,7 @@ void CMSCollector::collect_in_foreground(bool clear_all_soft_refs) {
if (VerifyDuringGC &&
GenCollectedHeap::heap()->total_collections() >= VerifyGCStartAt) {
gclog_or_tty->print("Verify before initial mark: ");
Universe::verify(true);
Universe::verify();
}
{
bool res = markFromRoots(false);
@ -2431,7 +2431,7 @@ void CMSCollector::collect_in_foreground(bool clear_all_soft_refs) {
if (VerifyDuringGC &&
GenCollectedHeap::heap()->total_collections() >= VerifyGCStartAt) {
gclog_or_tty->print("Verify before re-mark: ");
Universe::verify(true);
Universe::verify();
}
checkpointRootsFinal(false, clear_all_soft_refs,
init_mark_was_synchronous);
@ -2443,7 +2443,7 @@ void CMSCollector::collect_in_foreground(bool clear_all_soft_refs) {
if (VerifyDuringGC &&
GenCollectedHeap::heap()->total_collections() >= VerifyGCStartAt) {
gclog_or_tty->print("Verify before sweep: ");
Universe::verify(true);
Universe::verify();
}
sweep(false);
assert(_collectorState == Resizing, "Incorrect state");
@ -2459,7 +2459,7 @@ void CMSCollector::collect_in_foreground(bool clear_all_soft_refs) {
if (VerifyDuringGC &&
GenCollectedHeap::heap()->total_collections() >= VerifyGCStartAt) {
gclog_or_tty->print("Verify before reset: ");
Universe::verify(true);
Universe::verify();
}
reset(false);
assert(_collectorState == Idling, "Collector state should "
@ -2486,7 +2486,7 @@ void CMSCollector::collect_in_foreground(bool clear_all_soft_refs) {
if (VerifyAfterGC &&
GenCollectedHeap::heap()->total_collections() >= VerifyGCStartAt) {
Universe::verify(true);
Universe::verify();
}
if (TraceCMSState) {
gclog_or_tty->print_cr("CMS Thread " INTPTR_FORMAT
@ -5668,7 +5668,7 @@ void CMSCollector::do_remark_non_parallel() {
if (VerifyDuringGC &&
GenCollectedHeap::heap()->total_collections() >= VerifyGCStartAt) {
HandleMark hm; // Discard invalid handles created during verification
Universe::verify(true);
Universe::verify();
}
{
TraceTime t("root rescan", PrintGCDetails, false, gclog_or_tty);

4
hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/vmCMSOperations.cpp
View File

@ -64,7 +64,7 @@ void VM_CMS_Operation::verify_before_gc() {
FreelistLocker x(_collector);
MutexLockerEx y(_collector->bitMapLock(), Mutex::_no_safepoint_check_flag);
Universe::heap()->prepare_for_verify();
Universe::verify(true);
Universe::verify();
}
}
@ -74,7 +74,7 @@ void VM_CMS_Operation::verify_after_gc() {
HandleMark hm;
FreelistLocker x(_collector);
MutexLockerEx y(_collector->bitMapLock(), Mutex::_no_safepoint_check_flag);
Universe::verify(true);
Universe::verify();
}
}

260
hotspot/src/share/vm/gc_implementation/g1/concurrentMark.cpp
View File

@ -426,11 +426,11 @@ ConcurrentMark::ConcurrentMark(ReservedSpace rs, uint max_regions) :
_markStack(this),
// _finger set in set_non_marking_state
_max_task_num(MAX2((uint)ParallelGCThreads, 1U)),
_max_worker_id(MAX2((uint)ParallelGCThreads, 1U)),
// _active_tasks set in set_non_marking_state
// _tasks set inside the constructor
_task_queues(new CMTaskQueueSet((int) _max_task_num)),
_terminator(ParallelTaskTerminator((int) _max_task_num, _task_queues)),
_task_queues(new CMTaskQueueSet((int) _max_worker_id)),
_terminator(ParallelTaskTerminator((int) _max_worker_id, _task_queues)),
_has_overflown(false),
_concurrent(false),
@ -481,17 +481,17 @@ ConcurrentMark::ConcurrentMark(ReservedSpace rs, uint max_regions) :
_root_regions.init(_g1h, this);
_tasks = NEW_C_HEAP_ARRAY(CMTask*, _max_task_num, mtGC);
_accum_task_vtime = NEW_C_HEAP_ARRAY(double, _max_task_num, mtGC);
_tasks = NEW_C_HEAP_ARRAY(CMTask*, _max_worker_id, mtGC);
_accum_task_vtime = NEW_C_HEAP_ARRAY(double, _max_worker_id, mtGC);
_count_card_bitmaps = NEW_C_HEAP_ARRAY(BitMap, _max_task_num, mtGC);
_count_marked_bytes = NEW_C_HEAP_ARRAY(size_t*, _max_task_num, mtGC);
_count_card_bitmaps = NEW_C_HEAP_ARRAY(BitMap, _max_worker_id, mtGC);
_count_marked_bytes = NEW_C_HEAP_ARRAY(size_t*, _max_worker_id, mtGC);
BitMap::idx_t card_bm_size = _card_bm.size();
// so that the assertion in MarkingTaskQueue::task_queue doesn't fail
_active_tasks = _max_task_num;
for (int i = 0; i < (int) _max_task_num; ++i) {
_active_tasks = _max_worker_id;
for (uint i = 0; i < _max_worker_id; ++i) {
CMTaskQueue* task_queue = new CMTaskQueue();
task_queue->initialize();
_task_queues->register_queue(i, task_queue);
@ -638,7 +638,7 @@ void ConcurrentMark::reset() {
// We do reset all of them, since different phases will use
// different number of active threads. So, it's easiest to have all
// of them ready.
for (int i = 0; i < (int) _max_task_num; ++i) {
for (uint i = 0; i < _max_worker_id; ++i) {
_tasks[i]->reset(_nextMarkBitMap);
}
@ -648,7 +648,7 @@ void ConcurrentMark::reset() {
}
void ConcurrentMark::set_phase(uint active_tasks, bool concurrent) {
assert(active_tasks <= _max_task_num, "we should not have more");
assert(active_tasks <= _max_worker_id, "we should not have more");
_active_tasks = active_tasks;
// Need to update the three data structures below according to the
@ -659,7 +659,7 @@ void ConcurrentMark::set_phase(uint active_tasks, bool concurrent) {
_concurrent = concurrent;
// We propagate this to all tasks, not just the active ones.
for (int i = 0; i < (int) _max_task_num; ++i)
for (uint i = 0; i < _max_worker_id; ++i)
_tasks[i]->set_concurrent(concurrent);
if (concurrent) {
@ -818,9 +818,9 @@ void ConcurrentMark::checkpointRootsInitialPost() {
* doesn't manipulate any data structures afterwards.
*/
void ConcurrentMark::enter_first_sync_barrier(int task_num) {
void ConcurrentMark::enter_first_sync_barrier(uint worker_id) {
if (verbose_low()) {
gclog_or_tty->print_cr("[%d] entering first barrier", task_num);
gclog_or_tty->print_cr("[%u] entering first barrier", worker_id);
}
if (concurrent()) {
@ -834,11 +834,11 @@ void ConcurrentMark::enter_first_sync_barrier(int task_num) {
// more work
if (verbose_low()) {
gclog_or_tty->print_cr("[%d] leaving first barrier", task_num);
gclog_or_tty->print_cr("[%u] leaving first barrier", worker_id);
}
// let task 0 do this
if (task_num == 0) {
// let the task associated with with worker 0 do this
if (worker_id == 0) {
// task 0 is responsible for clearing the global data structures
// We should be here because of an overflow. During STW we should
// not clear the overflow flag since we rely on it being true when
@ -858,9 +858,9 @@ void ConcurrentMark::enter_first_sync_barrier(int task_num) {
// then go into the second barrier
}
void ConcurrentMark::enter_second_sync_barrier(int task_num) {
void ConcurrentMark::enter_second_sync_barrier(uint worker_id) {
if (verbose_low()) {
gclog_or_tty->print_cr("[%d] entering second barrier", task_num);
gclog_or_tty->print_cr("[%u] entering second barrier", worker_id);
}
if (concurrent()) {
@ -873,7 +873,7 @@ void ConcurrentMark::enter_second_sync_barrier(int task_num) {
// at this point everything should be re-initialised and ready to go
if (verbose_low()) {
gclog_or_tty->print_cr("[%d] leaving second barrier", task_num);
gclog_or_tty->print_cr("[%u] leaving second barrier", worker_id);
}
}
@ -1120,8 +1120,8 @@ void ConcurrentMark::checkpointRootsFinal(bool clear_all_soft_refs) {
HandleMark hm; // handle scope
gclog_or_tty->print(" VerifyDuringGC:(before)");
Universe::heap()->prepare_for_verify();
Universe::verify(/* silent */ false,
/* option */ VerifyOption_G1UsePrevMarking);
Universe::verify(/* silent */ false,
/* option */ VerifyOption_G1UsePrevMarking);
}
G1CollectorPolicy* g1p = g1h->g1_policy();
@ -1159,8 +1159,8 @@ void ConcurrentMark::checkpointRootsFinal(bool clear_all_soft_refs) {
HandleMark hm; // handle scope
gclog_or_tty->print(" VerifyDuringGC:(after)");
Universe::heap()->prepare_for_verify();
Universe::verify(/* silent */ false,
/* option */ VerifyOption_G1UseNextMarking);
Universe::verify(/* silent */ false,
/* option */ VerifyOption_G1UseNextMarking);
}
assert(!restart_for_overflow(), "sanity");
}
@ -1811,8 +1811,8 @@ void ConcurrentMark::cleanup() {
HandleMark hm; // handle scope
gclog_or_tty->print(" VerifyDuringGC:(before)");
Universe::heap()->prepare_for_verify();
Universe::verify(/* silent */ false,
/* option */ VerifyOption_G1UsePrevMarking);
Universe::verify(/* silent */ false,
/* option */ VerifyOption_G1UsePrevMarking);
}
G1CollectorPolicy* g1p = G1CollectedHeap::heap()->g1_policy();
@ -1966,8 +1966,8 @@ void ConcurrentMark::cleanup() {
HandleMark hm; // handle scope
gclog_or_tty->print(" VerifyDuringGC:(after)");
Universe::heap()->prepare_for_verify();
Universe::verify(/* silent */ false,
/* option */ VerifyOption_G1UsePrevMarking);
Universe::verify(/* silent */ false,
/* option */ VerifyOption_G1UsePrevMarking);
}
g1h->verify_region_sets_optional();
@ -2113,9 +2113,9 @@ class G1CMParKeepAliveAndDrainClosure: public OopClosure {
if (!_cm->has_overflown()) {
oop obj = oopDesc::load_decode_heap_oop(p);
if (_cm->verbose_high()) {
gclog_or_tty->print_cr("\t[%d] we're looking at location "
gclog_or_tty->print_cr("\t[%u] we're looking at location "
"*"PTR_FORMAT" = "PTR_FORMAT,
_task->task_id(), p, (void*) obj);
_task->worker_id(), p, (void*) obj);
}
_task->deal_with_reference(obj);
@ -2144,7 +2144,7 @@ class G1CMParKeepAliveAndDrainClosure: public OopClosure {
}
} else {
if (_cm->verbose_high()) {
gclog_or_tty->print_cr("\t[%d] CM Overflow", _task->task_id());
gclog_or_tty->print_cr("\t[%u] CM Overflow", _task->worker_id());
}
}
}
@ -2160,8 +2160,8 @@ class G1CMParDrainMarkingStackClosure: public VoidClosure {
void do_void() {
do {
if (_cm->verbose_high()) {
gclog_or_tty->print_cr("\t[%d] Drain: Calling do marking_step",
_task->task_id());
gclog_or_tty->print_cr("\t[%u] Drain: Calling do marking_step",
_task->worker_id());
}
// We call CMTask::do_marking_step() to completely drain the local and
@ -2300,7 +2300,7 @@ void ConcurrentMark::weakRefsWork(bool clear_all_soft_refs) {
// We use the work gang from the G1CollectedHeap and we utilize all
// the worker threads.
uint active_workers = g1h->workers() ? g1h->workers()->active_workers() : 1U;
active_workers = MAX2(MIN2(active_workers, _max_task_num), 1U);
active_workers = MAX2(MIN2(active_workers, _max_worker_id), 1U);
G1CMRefProcTaskExecutor par_task_executor(g1h, this,
g1h->workers(), active_workers);
@ -2619,7 +2619,7 @@ void ConcurrentMark::clearRangeBothBitmaps(MemRegion mr) {
}
HeapRegion*
ConcurrentMark::claim_region(int task_num) {
ConcurrentMark::claim_region(uint worker_id) {
// "checkpoint" the finger
HeapWord* finger = _finger;
@ -2657,10 +2657,10 @@ ConcurrentMark::claim_region(int task_num) {
HeapWord* limit = curr_region->next_top_at_mark_start();
if (verbose_low()) {
gclog_or_tty->print_cr("[%d] curr_region = "PTR_FORMAT" "
gclog_or_tty->print_cr("[%u] curr_region = "PTR_FORMAT" "
"["PTR_FORMAT", "PTR_FORMAT"), "
"limit = "PTR_FORMAT,
task_num, curr_region, bottom, end, limit);
worker_id, curr_region, bottom, end, limit);
}
// Is the gap between reading the finger and doing the CAS too long?
@ -2673,22 +2673,22 @@ ConcurrentMark::claim_region(int task_num) {
assert(_finger >= end, "the finger should have moved forward");
if (verbose_low()) {
gclog_or_tty->print_cr("[%d] we were successful with region = "
PTR_FORMAT, task_num, curr_region);
gclog_or_tty->print_cr("[%u] we were successful with region = "
PTR_FORMAT, worker_id, curr_region);
}
if (limit > bottom) {
if (verbose_low()) {
gclog_or_tty->print_cr("[%d] region "PTR_FORMAT" is not empty, "
"returning it ", task_num, curr_region);
gclog_or_tty->print_cr("[%u] region "PTR_FORMAT" is not empty, "
"returning it ", worker_id, curr_region);
}
return curr_region;
} else {
assert(limit == bottom,
"the region limit should be at bottom");
if (verbose_low()) {
gclog_or_tty->print_cr("[%d] region "PTR_FORMAT" is empty, "
"returning NULL", task_num, curr_region);
gclog_or_tty->print_cr("[%u] region "PTR_FORMAT" is empty, "
"returning NULL", worker_id, curr_region);
}
// we return NULL and the caller should try calling
// claim_region() again.
@ -2697,10 +2697,10 @@ ConcurrentMark::claim_region(int task_num) {
} else {
assert(_finger > finger, "the finger should have moved forward");
if (verbose_low()) {
gclog_or_tty->print_cr("[%d] somebody else moved the finger, "
gclog_or_tty->print_cr("[%u] somebody else moved the finger, "
"global finger = "PTR_FORMAT", "
"our finger = "PTR_FORMAT,
task_num, _finger, finger);
worker_id, _finger, finger);
}
// read it again
@ -2783,7 +2783,7 @@ void ConcurrentMark::verify_no_cset_oops(bool verify_stacks,
_markStack.oops_do(&cl);
// Verify entries on the task queues
for (int i = 0; i < (int) _max_task_num; i += 1) {
for (uint i = 0; i < _max_worker_id; i += 1) {
cl.set_phase(VerifyNoCSetOopsQueues, i);
OopTaskQueue* queue = _task_queues->queue(i);
queue->oops_do(&cl);
@ -2822,7 +2822,7 @@ void ConcurrentMark::verify_no_cset_oops(bool verify_stacks,
}
// Verify the task fingers
assert(parallel_marking_threads() <= _max_task_num, "sanity");
assert(parallel_marking_threads() <= _max_worker_id, "sanity");
for (int i = 0; i < (int) parallel_marking_threads(); i += 1) {
CMTask* task = _tasks[i];
HeapWord* task_finger = task->finger();
@ -2849,7 +2849,7 @@ void ConcurrentMark::clear_marking_state(bool clear_overflow) {
}
_finger = _heap_start;
for (int i = 0; i < (int)_max_task_num; ++i) {
for (uint i = 0; i < _max_worker_id; ++i) {
OopTaskQueue* queue = _task_queues->queue(i);
queue->set_empty();
}
@ -2862,15 +2862,15 @@ class AggregateCountDataHRClosure: public HeapRegionClosure {
ConcurrentMark* _cm;
CardTableModRefBS* _ct_bs;
BitMap* _cm_card_bm;
size_t _max_task_num;
uint _max_worker_id;
public:
AggregateCountDataHRClosure(G1CollectedHeap* g1h,
BitMap* cm_card_bm,
size_t max_task_num) :
uint max_worker_id) :
_g1h(g1h), _cm(g1h->concurrent_mark()),
_ct_bs((CardTableModRefBS*) (g1h->barrier_set())),
_cm_card_bm(cm_card_bm), _max_task_num(max_task_num) { }
_cm_card_bm(cm_card_bm), _max_worker_id(max_worker_id) { }
bool doHeapRegion(HeapRegion* hr) {
if (hr->continuesHumongous()) {
@ -2927,7 +2927,7 @@ class AggregateCountDataHRClosure: public HeapRegionClosure {
uint hrs_index = hr->hrs_index();
size_t marked_bytes = 0;
for (int i = 0; (size_t)i < _max_task_num; i += 1) {
for (uint i = 0; i < _max_worker_id; i += 1) {
size_t* marked_bytes_array = _cm->count_marked_bytes_array_for(i);
BitMap* task_card_bm = _cm->count_card_bitmap_for(i);
@ -2935,7 +2935,7 @@ class AggregateCountDataHRClosure: public HeapRegionClosure {
// add it to the running total for this region.
marked_bytes += marked_bytes_array[hrs_index];
// Now union the bitmaps[0,max_task_num)[start_idx..limit_idx)
// Now union the bitmaps[0,max_worker_id)[start_idx..limit_idx)
// into the global card bitmap.
BitMap::idx_t scan_idx = task_card_bm->get_next_one_offset(start_idx, limit_idx);
@ -2967,22 +2967,22 @@ protected:
G1CollectedHeap* _g1h;
ConcurrentMark* _cm;
BitMap* _cm_card_bm;
size_t _max_task_num;
uint _max_worker_id;
int _active_workers;
public:
G1AggregateCountDataTask(G1CollectedHeap* g1h,
ConcurrentMark* cm,
BitMap* cm_card_bm,
size_t max_task_num,
uint max_worker_id,
int n_workers) :
AbstractGangTask("Count Aggregation"),
_g1h(g1h), _cm(cm), _cm_card_bm(cm_card_bm),
_max_task_num(max_task_num),
_max_worker_id(max_worker_id),
_active_workers(n_workers) { }
void work(uint worker_id) {
AggregateCountDataHRClosure cl(_g1h, _cm_card_bm, _max_task_num);
AggregateCountDataHRClosure cl(_g1h, _cm_card_bm, _max_worker_id);
if (G1CollectedHeap::use_parallel_gc_threads()) {
_g1h->heap_region_par_iterate_chunked(&cl, worker_id,
@ -3001,7 +3001,7 @@ void ConcurrentMark::aggregate_count_data() {
1);
G1AggregateCountDataTask g1_par_agg_task(_g1h, this, &_card_bm,
_max_task_num, n_workers);
_max_worker_id, n_workers);
if (G1CollectedHeap::use_parallel_gc_threads()) {
assert(_g1h->check_heap_region_claim_values(HeapRegion::InitialClaimValue),
@ -3030,9 +3030,9 @@ void ConcurrentMark::clear_all_count_data() {
_region_bm.clear();
uint max_regions = _g1h->max_regions();
assert(_max_task_num != 0, "unitialized");
assert(_max_worker_id > 0, "uninitialized");
for (int i = 0; (size_t) i < _max_task_num; i += 1) {
for (uint i = 0; i < _max_worker_id; i += 1) {
BitMap* task_card_bm = count_card_bitmap_for(i);
size_t* marked_bytes_array = count_marked_bytes_array_for(i);
@ -3062,7 +3062,7 @@ void ConcurrentMark::abort() {
clear_all_count_data();
// Empty mark stack
clear_marking_state();
for (int i = 0; i < (int)_max_task_num; ++i) {
for (uint i = 0; i < _max_worker_id; ++i) {
_tasks[i]->clear_region_fields();
}
_has_aborted = true;
@ -3154,8 +3154,8 @@ bool ConcurrentMark::containing_cards_are_marked(void* start,
void ConcurrentMark::print_finger() {
gclog_or_tty->print_cr("heap ["PTR_FORMAT", "PTR_FORMAT"), global finger = "PTR_FORMAT,
_heap_start, _heap_end, _finger);
for (int i = 0; i < (int) _max_task_num; ++i) {
gclog_or_tty->print(" %d: "PTR_FORMAT, i, _tasks[i]->finger());
for (uint i = 0; i < _max_worker_id; ++i) {
gclog_or_tty->print(" %u: "PTR_FORMAT, i, _tasks[i]->finger());
}
gclog_or_tty->print_cr("");
}
@ -3165,8 +3165,8 @@ void CMTask::scan_object(oop obj) {
assert(_nextMarkBitMap->isMarked((HeapWord*) obj), "invariant");
if (_cm->verbose_high()) {
gclog_or_tty->print_cr("[%d] we're scanning object "PTR_FORMAT,
_task_id, (void*) obj);
gclog_or_tty->print_cr("[%u] we're scanning object "PTR_FORMAT,
_worker_id, (void*) obj);
}
size_t obj_size = obj->size();
@ -3245,8 +3245,8 @@ void CMTask::setup_for_region(HeapRegion* hr) {
"claim_region() should have filtered out continues humongous regions");
if (_cm->verbose_low()) {
gclog_or_tty->print_cr("[%d] setting up for region "PTR_FORMAT,
_task_id, hr);
gclog_or_tty->print_cr("[%u] setting up for region "PTR_FORMAT,
_worker_id, hr);
}
_curr_region = hr;
@ -3261,9 +3261,9 @@ void CMTask::update_region_limit() {
if (limit == bottom) {
if (_cm->verbose_low()) {
gclog_or_tty->print_cr("[%d] found an empty region "
gclog_or_tty->print_cr("[%u] found an empty region "
"["PTR_FORMAT", "PTR_FORMAT")",
_task_id, bottom, limit);
_worker_id, bottom, limit);
}
// The region was collected underneath our feet.
// We set the finger to bottom to ensure that the bitmap
@ -3294,8 +3294,8 @@ void CMTask::update_region_limit() {
void CMTask::giveup_current_region() {
assert(_curr_region != NULL, "invariant");
if (_cm->verbose_low()) {
gclog_or_tty->print_cr("[%d] giving up region "PTR_FORMAT,
_task_id, _curr_region);
gclog_or_tty->print_cr("[%u] giving up region "PTR_FORMAT,
_worker_id, _curr_region);
}
clear_region_fields();
}
@ -3321,7 +3321,7 @@ void CMTask::reset(CMBitMap* nextMarkBitMap) {
guarantee(nextMarkBitMap != NULL, "invariant");
if (_cm->verbose_low()) {
gclog_or_tty->print_cr("[%d] resetting", _task_id);
gclog_or_tty->print_cr("[%u] resetting", _worker_id);
}
_nextMarkBitMap = nextMarkBitMap;
@ -3415,9 +3415,9 @@ void CMTask::regular_clock_call() {
_all_clock_intervals_ms.add(last_interval_ms);
if (_cm->verbose_medium()) {
gclog_or_tty->print_cr("[%d] regular clock, interval = %1.2lfms, "
gclog_or_tty->print_cr("[%u] regular clock, interval = %1.2lfms, "
"scanned = %d%s, refs reached = %d%s",
_task_id, last_interval_ms,
_worker_id, last_interval_ms,
_words_scanned,
(_words_scanned >= _words_scanned_limit) ? " (*)" : "",
_refs_reached,
@ -3449,8 +3449,8 @@ void CMTask::regular_clock_call() {
SATBMarkQueueSet& satb_mq_set = JavaThread::satb_mark_queue_set();
if (!_draining_satb_buffers && satb_mq_set.process_completed_buffers()) {
if (_cm->verbose_low()) {
gclog_or_tty->print_cr("[%d] aborting to deal with pending SATB buffers",
_task_id);
gclog_or_tty->print_cr("[%u] aborting to deal with pending SATB buffers",
_worker_id);
}
// we do need to process SATB buffers, we'll abort and restart
// the marking task to do so
@ -3475,7 +3475,7 @@ void CMTask::decrease_limits() {
// scanning limit so that the clock is called earlier.
if (_cm->verbose_medium()) {
gclog_or_tty->print_cr("[%d] decreasing limits", _task_id);
gclog_or_tty->print_cr("[%u] decreasing limits", _worker_id);
}
_words_scanned_limit = _real_words_scanned_limit -
@ -3503,16 +3503,16 @@ void CMTask::move_entries_to_global_stack() {
if (!_cm->mark_stack_push(buffer, n)) {
if (_cm->verbose_low()) {
gclog_or_tty->print_cr("[%d] aborting due to global stack overflow",
_task_id);
gclog_or_tty->print_cr("[%u] aborting due to global stack overflow",
_worker_id);
}
set_has_aborted();
} else {
// the transfer was successful
if (_cm->verbose_medium()) {
gclog_or_tty->print_cr("[%d] pushed %d entries to the global stack",
_task_id, n);
gclog_or_tty->print_cr("[%u] pushed %d entries to the global stack",
_worker_id, n);
}
statsOnly( int tmp_size = _cm->mark_stack_size();
if (tmp_size > _global_max_size) {
@ -3539,8 +3539,8 @@ void CMTask::get_entries_from_global_stack() {
statsOnly( ++_global_transfers_from; _global_pops += n );
if (_cm->verbose_medium()) {
gclog_or_tty->print_cr("[%d] popped %d entries from the global stack",
_task_id, n);
gclog_or_tty->print_cr("[%u] popped %d entries from the global stack",
_worker_id, n);
}
for (int i = 0; i < n; ++i) {
bool success = _task_queue->push(buffer[i]);
@ -3575,8 +3575,8 @@ void CMTask::drain_local_queue(bool partially) {
if (_task_queue->size() > target_size) {
if (_cm->verbose_high()) {
gclog_or_tty->print_cr("[%d] draining local queue, target size = %d",
_task_id, target_size);
gclog_or_tty->print_cr("[%u] draining local queue, target size = %d",
_worker_id, target_size);
}
oop obj;
@ -3585,7 +3585,7 @@ void CMTask::drain_local_queue(bool partially) {
statsOnly( ++_local_pops );
if (_cm->verbose_high()) {
gclog_or_tty->print_cr("[%d] popped "PTR_FORMAT, _task_id,
gclog_or_tty->print_cr("[%u] popped "PTR_FORMAT, _worker_id,
(void*) obj);
}
@ -3603,8 +3603,8 @@ void CMTask::drain_local_queue(bool partially) {
}
if (_cm->verbose_high()) {
gclog_or_tty->print_cr("[%d] drained local queue, size = %d",
_task_id, _task_queue->size());
gclog_or_tty->print_cr("[%u] drained local queue, size = %d",
_worker_id, _task_queue->size());
}
}
}
@ -3631,8 +3631,8 @@ void CMTask::drain_global_stack(bool partially) {
if (_cm->mark_stack_size() > target_size) {
if (_cm->verbose_low()) {
gclog_or_tty->print_cr("[%d] draining global_stack, target size %d",
_task_id, target_size);
gclog_or_tty->print_cr("[%u] draining global_stack, target size %d",
_worker_id, target_size);
}
while (!has_aborted() && _cm->mark_stack_size() > target_size) {
@ -3641,8 +3641,8 @@ void CMTask::drain_global_stack(bool partially) {
}
if (_cm->verbose_low()) {
gclog_or_tty->print_cr("[%d] drained global stack, size = %d",
_task_id, _cm->mark_stack_size());
gclog_or_tty->print_cr("[%u] drained global stack, size = %d",
_worker_id, _cm->mark_stack_size());
}
}
}
@ -3663,7 +3663,7 @@ void CMTask::drain_satb_buffers() {
CMObjectClosure oc(this);
SATBMarkQueueSet& satb_mq_set = JavaThread::satb_mark_queue_set();
if (G1CollectedHeap::use_parallel_gc_threads()) {
satb_mq_set.set_par_closure(_task_id, &oc);
satb_mq_set.set_par_closure(_worker_id, &oc);
} else {
satb_mq_set.set_closure(&oc);
}
@ -3672,9 +3672,9 @@ void CMTask::drain_satb_buffers() {
// until we run out of buffers or we need to abort.
if (G1CollectedHeap::use_parallel_gc_threads()) {
while (!has_aborted() &&
satb_mq_set.par_apply_closure_to_completed_buffer(_task_id)) {
satb_mq_set.par_apply_closure_to_completed_buffer(_worker_id)) {
if (_cm->verbose_medium()) {
gclog_or_tty->print_cr("[%d] processed an SATB buffer", _task_id);
gclog_or_tty->print_cr("[%u] processed an SATB buffer", _worker_id);
}
statsOnly( ++_satb_buffers_processed );
regular_clock_call();
@ -3683,7 +3683,7 @@ void CMTask::drain_satb_buffers() {
while (!has_aborted() &&
satb_mq_set.apply_closure_to_completed_buffer()) {
if (_cm->verbose_medium()) {
gclog_or_tty->print_cr("[%d] processed an SATB buffer", _task_id);
gclog_or_tty->print_cr("[%u] processed an SATB buffer", _worker_id);
}
statsOnly( ++_satb_buffers_processed );
regular_clock_call();
@ -3693,7 +3693,7 @@ void CMTask::drain_satb_buffers() {
if (!concurrent() && !has_aborted()) {
// We should only do this during remark.
if (G1CollectedHeap::use_parallel_gc_threads()) {
satb_mq_set.par_iterate_closure_all_threads(_task_id);
satb_mq_set.par_iterate_closure_all_threads(_worker_id);
} else {
satb_mq_set.iterate_closure_all_threads();
}
@ -3706,7 +3706,7 @@ void CMTask::drain_satb_buffers() {
satb_mq_set.completed_buffers_num() == 0, "invariant");
if (G1CollectedHeap::use_parallel_gc_threads()) {
satb_mq_set.set_par_closure(_task_id, NULL);
satb_mq_set.set_par_closure(_worker_id, NULL);
} else {
satb_mq_set.set_closure(NULL);
}
@ -3717,8 +3717,8 @@ void CMTask::drain_satb_buffers() {
}
void CMTask::print_stats() {
gclog_or_tty->print_cr("Marking Stats, task = %d, calls = %d",
_task_id, _calls);
gclog_or_tty->print_cr("Marking Stats, task = %u, calls = %d",
_worker_id, _calls);
gclog_or_tty->print_cr(" Elapsed time = %1.2lfms, Termination time = %1.2lfms",
_elapsed_time_ms, _termination_time_ms);
gclog_or_tty->print_cr(" Step Times (cum): num = %d, avg = %1.2lfms, sd = %1.2lfms",
@ -3866,7 +3866,7 @@ void CMTask::do_marking_step(double time_target_ms,
G1CollectorPolicy* g1_policy = _g1h->g1_policy();
assert(_task_queues != NULL, "invariant");
assert(_task_queue != NULL, "invariant");
assert(_task_queues->queue(_task_id) == _task_queue, "invariant");
assert(_task_queues->queue(_worker_id) == _task_queue, "invariant");
assert(!_claimed,
"only one thread should claim this task at any one time");
@ -3898,9 +3898,9 @@ void CMTask::do_marking_step(double time_target_ms,
++_calls;
if (_cm->verbose_low()) {
gclog_or_tty->print_cr("[%d] >>>>>>>>>> START, call = %d, "
gclog_or_tty->print_cr("[%u] >>>>>>>>>> START, call = %d, "
"target = %1.2lfms >>>>>>>>>>",
_task_id, _calls, _time_target_ms);
_worker_id, _calls, _time_target_ms);
}
// Set up the bitmap and oop closures. Anything that uses them is
@ -3948,10 +3948,10 @@ void CMTask::do_marking_step(double time_target_ms,
MemRegion mr = MemRegion(_finger, _region_limit);
if (_cm->verbose_low()) {
gclog_or_tty->print_cr("[%d] we're scanning part "
gclog_or_tty->print_cr("[%u] we're scanning part "
"["PTR_FORMAT", "PTR_FORMAT") "
"of region "PTR_FORMAT,
_task_id, _finger, _region_limit, _curr_region);
_worker_id, _finger, _region_limit, _curr_region);
}
// Let's iterate over the bitmap of the part of the
@ -4007,17 +4007,17 @@ void CMTask::do_marking_step(double time_target_ms,
assert(_finger == NULL, "invariant");
assert(_region_limit == NULL, "invariant");
if (_cm->verbose_low()) {
gclog_or_tty->print_cr("[%d] trying to claim a new region", _task_id);
gclog_or_tty->print_cr("[%u] trying to claim a new region", _worker_id);
}
HeapRegion* claimed_region = _cm->claim_region(_task_id);
HeapRegion* claimed_region = _cm->claim_region(_worker_id);
if (claimed_region != NULL) {
// Yes, we managed to claim one
statsOnly( ++_regions_claimed );
if (_cm->verbose_low()) {
gclog_or_tty->print_cr("[%d] we successfully claimed "
gclog_or_tty->print_cr("[%u] we successfully claimed "
"region "PTR_FORMAT,
_task_id, claimed_region);
_worker_id, claimed_region);
}
setup_for_region(claimed_region);
@ -4044,7 +4044,7 @@ void CMTask::do_marking_step(double time_target_ms,
"at this point we should be out of regions");
if (_cm->verbose_low()) {
gclog_or_tty->print_cr("[%d] all regions claimed", _task_id);
gclog_or_tty->print_cr("[%u] all regions claimed", _worker_id);
}
// Try to reduce the number of available SATB buffers so that
@ -4068,17 +4068,17 @@ void CMTask::do_marking_step(double time_target_ms,
"only way to reach here");
if (_cm->verbose_low()) {
gclog_or_tty->print_cr("[%d] starting to steal", _task_id);
gclog_or_tty->print_cr("[%u] starting to steal", _worker_id);
}
while (!has_aborted()) {
oop obj;
statsOnly( ++_steal_attempts );
if (_cm->try_stealing(_task_id, &_hash_seed, obj)) {
if (_cm->try_stealing(_worker_id, &_hash_seed, obj)) {
if (_cm->verbose_medium()) {
gclog_or_tty->print_cr("[%d] stolen "PTR_FORMAT" successfully",
_task_id, (void*) obj);
gclog_or_tty->print_cr("[%u] stolen "PTR_FORMAT" successfully",
_worker_id, (void*) obj);
}
statsOnly( ++_steals );
@ -4116,7 +4116,7 @@ void CMTask::do_marking_step(double time_target_ms,
assert(_task_queue->size() == 0, "only way to reach here");
if (_cm->verbose_low()) {
gclog_or_tty->print_cr("[%d] starting termination protocol", _task_id);
gclog_or_tty->print_cr("[%u] starting termination protocol", _worker_id);
}
_termination_start_time_ms = os::elapsedVTime() * 1000.0;
@ -4131,7 +4131,7 @@ void CMTask::do_marking_step(double time_target_ms,
if (finished) {
// We're all done.
if (_task_id == 0) {
if (_worker_id == 0) {
// let's allow task 0 to do this
if (concurrent()) {
assert(_cm->concurrent_marking_in_progress(), "invariant");
@ -4153,15 +4153,15 @@ void CMTask::do_marking_step(double time_target_ms,
guarantee(!_cm->mark_stack_overflow(), "only way to reach here");
if (_cm->verbose_low()) {
gclog_or_tty->print_cr("[%d] all tasks terminated", _task_id);
gclog_or_tty->print_cr("[%u] all tasks terminated", _worker_id);
}
} else {
// Apparently there's more work to do. Let's abort this task. It
// will restart it and we can hopefully find more things to do.
if (_cm->verbose_low()) {
gclog_or_tty->print_cr("[%d] apparently there is more work to do",
_task_id);
gclog_or_tty->print_cr("[%u] apparently there is more work to do",
_worker_id);
}
set_has_aborted();
@ -4200,10 +4200,10 @@ void CMTask::do_marking_step(double time_target_ms,
// will achieve this with the use of two barrier sync points.
if (_cm->verbose_low()) {
gclog_or_tty->print_cr("[%d] detected overflow", _task_id);
gclog_or_tty->print_cr("[%u] detected overflow", _worker_id);
}
_cm->enter_first_sync_barrier(_task_id);
_cm->enter_first_sync_barrier(_worker_id);
// When we exit this sync barrier we know that all tasks have
// stopped doing marking work. So, it's now safe to
// re-initialise our data structures. At the end of this method,
@ -4215,39 +4215,39 @@ void CMTask::do_marking_step(double time_target_ms,
clear_region_fields();
// ...and enter the second barrier.
_cm->enter_second_sync_barrier(_task_id);
_cm->enter_second_sync_barrier(_worker_id);
// At this point everything has bee re-initialised and we're
// ready to restart.
}
if (_cm->verbose_low()) {
gclog_or_tty->print_cr("[%d] <<<<<<<<<< ABORTING, target = %1.2lfms, "
gclog_or_tty->print_cr("[%u] <<<<<<<<<< ABORTING, target = %1.2lfms, "
"elapsed = %1.2lfms <<<<<<<<<<",
_task_id, _time_target_ms, elapsed_time_ms);
_worker_id, _time_target_ms, elapsed_time_ms);
if (_cm->has_aborted()) {
gclog_or_tty->print_cr("[%d] ========== MARKING ABORTED ==========",
_task_id);
gclog_or_tty->print_cr("[%u] ========== MARKING ABORTED ==========",
_worker_id);
}
}
} else {
if (_cm->verbose_low()) {
gclog_or_tty->print_cr("[%d] <<<<<<<<<< FINISHED, target = %1.2lfms, "
gclog_or_tty->print_cr("[%u] <<<<<<<<<< FINISHED, target = %1.2lfms, "
"elapsed = %1.2lfms <<<<<<<<<<",
_task_id, _time_target_ms, elapsed_time_ms);
_worker_id, _time_target_ms, elapsed_time_ms);
}
}
_claimed = false;
}
CMTask::CMTask(int task_id,
CMTask::CMTask(uint worker_id,
ConcurrentMark* cm,
size_t* marked_bytes,
BitMap* card_bm,
CMTaskQueue* task_queue,
CMTaskQueueSet* task_queues)
: _g1h(G1CollectedHeap::heap()),
_task_id(task_id), _cm(cm),
_worker_id(worker_id), _cm(cm),
_claimed(false),
_nextMarkBitMap(NULL), _hash_seed(17),
_task_queue(task_queue),

34
hotspot/src/share/vm/gc_implementation/g1/concurrentMark.hpp
View File

@ -399,9 +399,9 @@ protected:
// last claimed region
// marking tasks
uint _max_task_num; // maximum task number
uint _max_worker_id;// maximum worker id
uint _active_tasks; // task num currently active
CMTask** _tasks; // task queue array (max_task_num len)
CMTask** _tasks; // task queue array (max_worker_id len)
CMTaskQueueSet* _task_queues; // task queue set
ParallelTaskTerminator _terminator; // for termination
@ -492,10 +492,10 @@ protected:
ParallelTaskTerminator* terminator() { return &_terminator; }
// It claims the next available region to be scanned by a marking
// task. It might return NULL if the next region is empty or we have
// run out of regions. In the latter case, out_of_regions()
// task/thread. It might return NULL if the next region is empty or
// we have run out of regions. In the latter case, out_of_regions()
// determines whether we've really run out of regions or the task
// should call claim_region() again. This might seem a bit
// should call claim_region() again. This might seem a bit
// awkward. Originally, the code was written so that claim_region()
// either successfully returned with a non-empty region or there
// were no more regions to be claimed. The problem with this was
@ -505,7 +505,7 @@ protected:
// method. So, this way, each task will spend very little time in
// claim_region() and is allowed to call the regular clock method
// frequently.
HeapRegion* claim_region(int task);
HeapRegion* claim_region(uint worker_id);
// It determines whether we've run out of regions to scan.
bool out_of_regions() { return _finger == _heap_end; }
@ -537,8 +537,8 @@ protected:
bool has_aborted() { return _has_aborted; }
// Methods to enter the two overflow sync barriers
void enter_first_sync_barrier(int task_num);
void enter_second_sync_barrier(int task_num);
void enter_first_sync_barrier(uint worker_id);
void enter_second_sync_barrier(uint worker_id);
ForceOverflowSettings* force_overflow_conc() {
return &_force_overflow_conc;
@ -626,14 +626,14 @@ public:
double all_task_accum_vtime() {
double ret = 0.0;
for (int i = 0; i < (int)_max_task_num; ++i)
for (uint i = 0; i < _max_worker_id; ++i)
ret += _accum_task_vtime[i];
return ret;
}
// Attempts to steal an object from the task queues of other tasks
bool try_stealing(int task_num, int* hash_seed, oop& obj) {
return _task_queues->steal(task_num, hash_seed, obj);
bool try_stealing(uint worker_id, int* hash_seed, oop& obj) {
return _task_queues->steal(worker_id, hash_seed, obj);
}
ConcurrentMark(ReservedSpace rs, uint max_regions);
@ -823,7 +823,7 @@ public:
// Returns the card bitmap for a given task or worker id.
BitMap* count_card_bitmap_for(uint worker_id) {
assert(0 <= worker_id && worker_id < _max_task_num, "oob");
assert(0 <= worker_id && worker_id < _max_worker_id, "oob");
assert(_count_card_bitmaps != NULL, "uninitialized");
BitMap* task_card_bm = &_count_card_bitmaps[worker_id];
assert(task_card_bm->size() == _card_bm.size(), "size mismatch");
@ -833,7 +833,7 @@ public:
// Returns the array containing the marked bytes for each region,
// for the given worker or task id.
size_t* count_marked_bytes_array_for(uint worker_id) {
assert(0 <= worker_id && worker_id < _max_task_num, "oob");
assert(0 <= worker_id && worker_id < _max_worker_id, "oob");
assert(_count_marked_bytes != NULL, "uninitialized");
size_t* marked_bytes_array = _count_marked_bytes[worker_id];
assert(marked_bytes_array != NULL, "uninitialized");
@ -939,7 +939,7 @@ private:
global_stack_transfer_size = 16
};
int _task_id;
uint _worker_id;
G1CollectedHeap* _g1h;
ConcurrentMark* _cm;
CMBitMap* _nextMarkBitMap;
@ -1115,8 +1115,8 @@ public:
_elapsed_time_ms = os::elapsedTime() * 1000.0 - _elapsed_time_ms;
}
// returns the task ID
int task_id() { return _task_id; }
// returns the worker ID associated with this task.
uint worker_id() { return _worker_id; }
// From TerminatorTerminator. It determines whether this task should
// exit the termination protocol after it's entered it.
@ -1170,7 +1170,7 @@ public:
_finger = new_finger;
}
CMTask(int task_num, ConcurrentMark *cm,
CMTask(uint worker_id, ConcurrentMark *cm,
size_t* marked_bytes, BitMap* card_bm,
CMTaskQueue* task_queue, CMTaskQueueSet* task_queues);

26
hotspot/src/share/vm/gc_implementation/g1/concurrentMark.inline.hpp
View File

@ -279,7 +279,7 @@ inline void CMTask::push(oop obj) {
assert(_nextMarkBitMap->isMarked(objAddr), "invariant");
if (_cm->verbose_high()) {
gclog_or_tty->print_cr("[%d] pushing "PTR_FORMAT, _task_id, (void*) obj);
gclog_or_tty->print_cr("[%u] pushing "PTR_FORMAT, _worker_id, (void*) obj);
}
if (!_task_queue->push(obj)) {
@ -287,9 +287,9 @@ inline void CMTask::push(oop obj) {
// to the global stack.
if (_cm->verbose_medium()) {
gclog_or_tty->print_cr("[%d] task queue overflow, "
gclog_or_tty->print_cr("[%u] task queue overflow, "
"moving entries to the global stack",
_task_id);
_worker_id);
}
move_entries_to_global_stack();
@ -318,8 +318,8 @@ inline void CMTask::push(oop obj) {
inline void CMTask::deal_with_reference(oop obj) {
if (_cm->verbose_high()) {
gclog_or_tty->print_cr("[%d] we're dealing with reference = "PTR_FORMAT,
_task_id, (void*) obj);
gclog_or_tty->print_cr("[%u] we're dealing with reference = "PTR_FORMAT,
_worker_id, (void*) obj);
}
++_refs_reached;
@ -335,8 +335,8 @@ inline void CMTask::deal_with_reference(oop obj) {
HeapRegion* hr = _g1h->heap_region_containing_raw(obj);
if (!hr->obj_allocated_since_next_marking(obj)) {
if (_cm->verbose_high()) {
gclog_or_tty->print_cr("[%d] "PTR_FORMAT" is not considered marked",
_task_id, (void*) obj);
gclog_or_tty->print_cr("[%u] "PTR_FORMAT" is not considered marked",
_worker_id, (void*) obj);
}
// we need to mark it first
@ -350,8 +350,8 @@ inline void CMTask::deal_with_reference(oop obj) {
if (_finger != NULL && objAddr < _finger) {
if (_cm->verbose_high()) {
gclog_or_tty->print_cr("[%d] below the local finger ("PTR_FORMAT"), "
"pushing it", _task_id, _finger);
gclog_or_tty->print_cr("[%u] below the local finger ("PTR_FORMAT"), "
"pushing it", _worker_id, _finger);
}
push(obj);
} else if (_curr_region != NULL && objAddr < _region_limit) {
@ -367,9 +367,9 @@ inline void CMTask::deal_with_reference(oop obj) {
// correctness problems.
if (_cm->verbose_high()) {
gclog_or_tty->print_cr("[%d] below the global finger "
gclog_or_tty->print_cr("[%u] below the global finger "
"("PTR_FORMAT"), pushing it",
_task_id, global_finger);
_worker_id, global_finger);
}
push(obj);
} else {
@ -382,9 +382,9 @@ inline void CMTask::deal_with_reference(oop obj) {
// see long comment above
if (_cm->verbose_high()) {
gclog_or_tty->print_cr("[%d] below the global finger "
gclog_or_tty->print_cr("[%u] below the global finger "
"("PTR_FORMAT"), pushing it",
_task_id, global_finger);
_worker_id, global_finger);
}
push(obj);
}

1
hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp
View File

@ -3388,6 +3388,7 @@ void G1CollectedHeap::print_on(outputStream* st) const {
st->print("%u survivors (" SIZE_FORMAT "K)", survivor_regions,
(size_t) survivor_regions * HeapRegion::GrainBytes / K);
st->cr();
MetaspaceAux::print_on(st);
}
void G1CollectedHeap::print_extended_on(outputStream* st) const {

4
hotspot/src/share/vm/gc_implementation/g1/g1OopClosures.inline.hpp
View File

@ -111,9 +111,9 @@ inline void G1CMOopClosure::do_oop_nv(T* p) {
oop obj = oopDesc::load_decode_heap_oop(p);
if (_cm->verbose_high()) {
gclog_or_tty->print_cr("[%d] we're looking at location "
gclog_or_tty->print_cr("[%u] we're looking at location "
"*"PTR_FORMAT" = "PTR_FORMAT,
_task->task_id(), p, (void*) obj);
_task->worker_id(), p, (void*) obj);
}
_task->deal_with_reference(obj);
}

4
hotspot/src/share/vm/gc_implementation/parallelScavenge/psMarkSweep.cpp
View File

@ -139,7 +139,7 @@ bool PSMarkSweep::invoke_no_policy(bool clear_all_softrefs) {
if (VerifyBeforeGC && heap->total_collections() >= VerifyGCStartAt) {
HandleMark hm; // Discard invalid handles created during verification
gclog_or_tty->print(" VerifyBeforeGC:");
Universe::verify(true);
Universe::verify();
}
// Verify object start arrays
@ -341,7 +341,7 @@ bool PSMarkSweep::invoke_no_policy(bool clear_all_softrefs) {
if (VerifyAfterGC && heap->total_collections() >= VerifyGCStartAt) {
HandleMark hm; // Discard invalid handles created during verification
gclog_or_tty->print(" VerifyAfterGC:");
Universe::verify(false);
Universe::verify();
}
// Re-verify object start arrays

4
hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp
View File

@ -983,7 +983,7 @@ void PSParallelCompact::pre_compact(PreGCValues* pre_gc_values)
if (VerifyBeforeGC && heap->total_collections() >= VerifyGCStartAt) {
HandleMark hm; // Discard invalid handles created during verification
gclog_or_tty->print(" VerifyBeforeGC:");
Universe::verify(true);
Universe::verify();
}
// Verify object start arrays
@ -2184,7 +2184,7 @@ bool PSParallelCompact::invoke_no_policy(bool maximum_heap_compaction) {
if (VerifyAfterGC && heap->total_collections() >= VerifyGCStartAt) {
HandleMark hm; // Discard invalid handles created during verification
gclog_or_tty->print(" VerifyAfterGC:");
Universe::verify(false);
Universe::verify();
}
// Re-verify object start arrays

4
hotspot/src/share/vm/gc_implementation/parallelScavenge/psScavenge.cpp
View File

@ -315,7 +315,7 @@ bool PSScavenge::invoke_no_policy() {
if (VerifyBeforeGC && heap->total_collections() >= VerifyGCStartAt) {
HandleMark hm; // Discard invalid handles created during verification
gclog_or_tty->print(" VerifyBeforeGC:");
Universe::verify(true);
Universe::verify();
}
{
@ -639,7 +639,7 @@ bool PSScavenge::invoke_no_policy() {
if (VerifyAfterGC && heap->total_collections() >= VerifyGCStartAt) {
HandleMark hm; // Discard invalid handles created during verification
gclog_or_tty->print(" VerifyAfterGC:");
Universe::verify(false);
Universe::verify();
}
heap->print_heap_after_gc();

39
hotspot/src/share/vm/memory/allocation.cpp
View File

@ -92,6 +92,26 @@ void* ResourceObj::operator new(size_t size, allocation_type type, MEMFLAGS flag
return res;
}
void* ResourceObj::operator new(size_t size, const std::nothrow_t& nothrow_constant,
allocation_type type, MEMFLAGS flags) {
//should only call this with std::nothrow, use other operator new() otherwise
address res;
switch (type) {
case C_HEAP:
res = (address)AllocateHeap(size, flags, CALLER_PC, AllocFailStrategy::RETURN_NULL);
DEBUG_ONLY(if (res!= NULL) set_allocation_type(res, C_HEAP);)
break;
case RESOURCE_AREA:
// new(size) sets allocation type RESOURCE_AREA.
res = (address)operator new(size, std::nothrow);
break;
default:
ShouldNotReachHere();
}
return res;
}
void ResourceObj::operator delete(void* p) {
assert(((ResourceObj *)p)->allocated_on_C_heap(),
"delete only allowed for C_HEAP objects");
@ -506,7 +526,7 @@ void Arena::signal_out_of_memory(size_t sz, const char* whence) const {
}
// Grow a new Chunk
void* Arena::grow( size_t x ) {
void* Arena::grow(size_t x, AllocFailType alloc_failmode) {
// Get minimal required size. Either real big, or even bigger for giant objs
size_t len = MAX2(x, (size_t) Chunk::size);
@ -514,7 +534,10 @@ void* Arena::grow( size_t x ) {
_chunk = new (len) Chunk(len);
if (_chunk == NULL) {
signal_out_of_memory(len * Chunk::aligned_overhead_size(), "Arena::grow");
if (alloc_failmode == AllocFailStrategy::EXIT_OOM) {
signal_out_of_memory(len * Chunk::aligned_overhead_size(), "Arena::grow");
}
return NULL;
}
if (k) k->set_next(_chunk); // Append new chunk to end of linked list
else _first = _chunk;
@ -529,13 +552,16 @@ void* Arena::grow( size_t x ) {
// Reallocate storage in Arena.
void *Arena::Arealloc(void* old_ptr, size_t old_size, size_t new_size) {
void *Arena::Arealloc(void* old_ptr, size_t old_size, size_t new_size, AllocFailType alloc_failmode) {
assert(new_size >= 0, "bad size");
if (new_size == 0) return NULL;
#ifdef ASSERT
if (UseMallocOnly) {
// always allocate a new object (otherwise we'll free this one twice)
char* copy = (char*)Amalloc(new_size);
char* copy = (char*)Amalloc(new_size, alloc_failmode);
if (copy == NULL) {
return NULL;
}
size_t n = MIN2(old_size, new_size);
if (n > 0) memcpy(copy, old_ptr, n);
Afree(old_ptr,old_size); // Mostly done to keep stats accurate
@ -561,7 +587,10 @@ void *Arena::Arealloc(void* old_ptr, size_t old_size, size_t new_size) {
}
// Oops, got to relocate guts
void *new_ptr = Amalloc(new_size);
void *new_ptr = Amalloc(new_size, alloc_failmode);
if (new_ptr == NULL) {
return NULL;
}
memcpy( new_ptr, c_old, old_size );
Afree(c_old,old_size); // Mostly done to keep stats accurate
return new_ptr;

42
hotspot/src/share/vm/memory/allocation.hpp
View File

@ -53,6 +53,12 @@
#endif
#endif
class AllocFailStrategy {
public:
enum AllocFailEnum { EXIT_OOM, RETURN_NULL };
};
typedef AllocFailStrategy::AllocFailEnum AllocFailType;
// All classes in the virtual machine must be subclassed
// by one of the following allocation classes:
//
@ -315,7 +321,8 @@ protected:
Chunk *_first; // First chunk
Chunk *_chunk; // current chunk
char *_hwm, *_max; // High water mark and max in current chunk
void* grow(size_t x); // Get a new Chunk of at least size x
// Get a new Chunk of at least size x
void* grow(size_t x, AllocFailType alloc_failmode = AllocFailStrategy::EXIT_OOM);
size_t _size_in_bytes; // Size of arena (used for native memory tracking)
NOT_PRODUCT(static julong _bytes_allocated;) // total #bytes allocated since start
@ -350,14 +357,14 @@ protected:
void operator delete(void* p);
// Fast allocate in the arena. Common case is: pointer test + increment.
void* Amalloc(size_t x) {
void* Amalloc(size_t x, AllocFailType alloc_failmode = AllocFailStrategy::EXIT_OOM) {
assert(is_power_of_2(ARENA_AMALLOC_ALIGNMENT) , "should be a power of 2");
x = ARENA_ALIGN(x);
debug_only(if (UseMallocOnly) return malloc(x);)
check_for_overflow(x, "Arena::Amalloc");
NOT_PRODUCT(inc_bytes_allocated(x);)
if (_hwm + x > _max) {
return grow(x);
return grow(x, alloc_failmode);
} else {
char *old = _hwm;
_hwm += x;
@ -365,13 +372,13 @@ protected:
}
}
// Further assume size is padded out to words
void *Amalloc_4(size_t x) {
void *Amalloc_4(size_t x, AllocFailType alloc_failmode = AllocFailStrategy::EXIT_OOM) {
assert( (x&(sizeof(char*)-1)) == 0, "misaligned size" );
debug_only(if (UseMallocOnly) return malloc(x);)
check_for_overflow(x, "Arena::Amalloc_4");
NOT_PRODUCT(inc_bytes_allocated(x);)
if (_hwm + x > _max) {
return grow(x);
return grow(x, alloc_failmode);
} else {
char *old = _hwm;
_hwm += x;
@ -381,7 +388,7 @@ protected:
// Allocate with 'double' alignment. It is 8 bytes on sparc.
// In other cases Amalloc_D() should be the same as Amalloc_4().
void* Amalloc_D(size_t x) {
void* Amalloc_D(size_t x, AllocFailType alloc_failmode = AllocFailStrategy::EXIT_OOM) {
assert( (x&(sizeof(char*)-1)) == 0, "misaligned size" );
debug_only(if (UseMallocOnly) return malloc(x);)
#if defined(SPARC) && !defined(_LP64)
@ -392,7 +399,7 @@ protected:
check_for_overflow(x, "Arena::Amalloc_D");
NOT_PRODUCT(inc_bytes_allocated(x);)
if (_hwm + x > _max) {
return grow(x); // grow() returns a result aligned >= 8 bytes.
return grow(x, alloc_failmode); // grow() returns a result aligned >= 8 bytes.
} else {
char *old = _hwm;
_hwm += x;
@ -412,7 +419,8 @@ protected:
if (((char*)ptr) + size == _hwm) _hwm = (char*)ptr;
}
void *Arealloc( void *old_ptr, size_t old_size, size_t new_size );
void *Arealloc( void *old_ptr, size_t old_size, size_t new_size,
AllocFailType alloc_failmode = AllocFailStrategy::EXIT_OOM);
// Move contents of this arena into an empty arena
Arena *move_contents(Arena *empty_arena);
@ -458,9 +466,12 @@ private:
//%note allocation_1
extern char* resource_allocate_bytes(size_t size);
extern char* resource_allocate_bytes(Thread* thread, size_t size);
extern char* resource_reallocate_bytes( char *old, size_t old_size, size_t new_size);
extern char* resource_allocate_bytes(size_t size,
AllocFailType alloc_failmode = AllocFailStrategy::EXIT_OOM);
extern char* resource_allocate_bytes(Thread* thread, size_t size,
AllocFailType alloc_failmode = AllocFailStrategy::EXIT_OOM);
extern char* resource_reallocate_bytes( char *old, size_t old_size, size_t new_size,
AllocFailType alloc_failmode = AllocFailStrategy::EXIT_OOM);
extern void resource_free_bytes( char *old, size_t size );
//----------------------------------------------------------------------
@ -496,6 +507,8 @@ class ResourceObj ALLOCATION_SUPER_CLASS_SPEC {
public:
void* operator new(size_t size, allocation_type type, MEMFLAGS flags);
void* operator new(size_t size, const std::nothrow_t& nothrow_constant,
allocation_type type, MEMFLAGS flags);
void* operator new(size_t size, Arena *arena) {
address res = (address)arena->Amalloc(size);
DEBUG_ONLY(set_allocation_type(res, ARENA);)
@ -506,6 +519,13 @@ class ResourceObj ALLOCATION_SUPER_CLASS_SPEC {
DEBUG_ONLY(set_allocation_type(res, RESOURCE_AREA);)
return res;
}
void* operator new(size_t size, const std::nothrow_t& nothrow_constant) {
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 delete(void* p);
};

16
hotspot/src/share/vm/memory/allocation.inline.hpp
View File

@ -48,7 +48,8 @@ inline void inc_stat_counter(volatile julong* dest, julong add_value) {
#endif
// allocate using malloc; will fail if no memory available
inline char* AllocateHeap(size_t size, MEMFLAGS flags, address pc = 0) {
inline char* AllocateHeap(size_t size, MEMFLAGS flags, address pc = 0,
AllocFailType alloc_failmode = AllocFailStrategy::EXIT_OOM) {
if (pc == 0) {
pc = CURRENT_PC;
}
@ -56,16 +57,17 @@ inline char* AllocateHeap(size_t size, MEMFLAGS flags, address pc = 0) {
#ifdef ASSERT
if (PrintMallocFree) trace_heap_malloc(size, "AllocateHeap", p);
#endif
if (p == NULL) vm_exit_out_of_memory(size, "AllocateHeap");
if (p == NULL && alloc_failmode == AllocFailStrategy::EXIT_OOM) vm_exit_out_of_memory(size, "AllocateHeap");
return p;
}
inline char* ReallocateHeap(char *old, size_t size, MEMFLAGS flags) {
inline char* ReallocateHeap(char *old, size_t size, MEMFLAGS flags,
AllocFailType alloc_failmode = AllocFailStrategy::EXIT_OOM) {
char* p = (char*) os::realloc(old, size, flags, CURRENT_PC);
#ifdef ASSERT
if (PrintMallocFree) trace_heap_malloc(size, "ReallocateHeap", p);
#endif
if (p == NULL) vm_exit_out_of_memory(size, "ReallocateHeap");
if (p == NULL && alloc_failmode == AllocFailStrategy::EXIT_OOM) vm_exit_out_of_memory(size, "ReallocateHeap");
return p;
}
@ -91,11 +93,13 @@ 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) {
#ifdef ASSERT
void* p = os::malloc(size, F, (caller_pc != 0 ? caller_pc : CALLER_PC));
void* p = (void*)AllocateHeap(size, F, (caller_pc != 0 ? caller_pc : CALLER_PC),
AllocFailStrategy::RETURN_NULL);
if (PrintMallocFree) trace_heap_malloc(size, "CHeapObj-new", p);
return p;
#else
return os::malloc(size, F, (caller_pc != 0 ? caller_pc : CALLER_PC));
return (void *) AllocateHeap(size, F, (caller_pc != 0 ? caller_pc : CALLER_PC),
AllocFailStrategy::RETURN_NULL);
#endif
}

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

@ -447,7 +447,7 @@ void GenCollectedHeap::do_collection(bool full,
prepared_for_verification = true;
}
gclog_or_tty->print(" VerifyBeforeGC:");
Universe::verify(true);
Universe::verify();
}
COMPILER2_PRESENT(DerivedPointerTable::clear());
@ -519,7 +519,7 @@ void GenCollectedHeap::do_collection(bool full,
total_collections() >= VerifyGCStartAt) {
HandleMark hm; // Discard invalid handles created during verification
gclog_or_tty->print(" VerifyAfterGC:");
Universe::verify(false);
Universe::verify();
}
if (PrintGCDetails) {

12
hotspot/src/share/vm/memory/resourceArea.cpp
View File

@ -45,15 +45,15 @@ debug_only(int ResourceArea::_warned;) // to suppress multiple warnings
// The following routines are declared in allocation.hpp and used everywhere:
// Allocation in thread-local resource area
extern char* resource_allocate_bytes(size_t size) {
return Thread::current()->resource_area()->allocate_bytes(size);
extern char* resource_allocate_bytes(size_t size, AllocFailType alloc_failmode) {
return Thread::current()->resource_area()->allocate_bytes(size, alloc_failmode);
}
extern char* resource_allocate_bytes(Thread* thread, size_t size) {
return thread->resource_area()->allocate_bytes(size);
extern char* resource_allocate_bytes(Thread* thread, size_t size, AllocFailType alloc_failmode) {
return thread->resource_area()->allocate_bytes(size, alloc_failmode);
}
extern char* resource_reallocate_bytes( char *old, size_t old_size, size_t new_size){
return (char*)Thread::current()->resource_area()->Arealloc(old, old_size, new_size);
extern char* resource_reallocate_bytes( char *old, size_t old_size, size_t new_size, AllocFailType alloc_failmode){
return (char*)Thread::current()->resource_area()->Arealloc(old, old_size, new_size, alloc_failmode);
}
extern void resource_free_bytes( char *old, size_t size ) {

4
hotspot/src/share/vm/memory/resourceArea.hpp
View File

@ -68,7 +68,7 @@ public:
debug_only(_nesting = 0;);
}
char* allocate_bytes(size_t size) {
char* allocate_bytes(size_t size, AllocFailType alloc_failmode = AllocFailStrategy::EXIT_OOM) {
#ifdef ASSERT
if (_nesting < 1 && !_warned++)
fatal("memory leak: allocating without ResourceMark");
@ -78,7 +78,7 @@ public:
return (*save = (char*)os::malloc(size, mtThread));
}
#endif
return (char*)Amalloc(size);
return (char*)Amalloc(size, alloc_failmode);
}
debug_only(int nesting() const { return _nesting; });

4
hotspot/src/share/vm/memory/universe.cpp
View File

@ -1268,10 +1268,6 @@ void Universe::print_heap_after_gc(outputStream* st, bool ignore_extended) {
}
void Universe::verify(bool silent, VerifyOption option) {
if (SharedSkipVerify) {
return;
}
// The use of _verify_in_progress is a temporary work around for
// 6320749. Don't bother with a creating a class to set and clear
// it since it is only used in this method and the control flow is

10
hotspot/src/share/vm/memory/universe.hpp
View File

@ -435,8 +435,14 @@ class Universe: AllStatic {
// Debugging
static bool verify_in_progress() { return _verify_in_progress; }
static void verify(bool silent = false,
VerifyOption option = VerifyOption_Default );
static void verify(bool silent, VerifyOption option);
static void verify(bool silent) {
verify(silent, VerifyOption_Default /* option */);
}
static void verify() {
verify(false /* silent */);
}
static int verify_count() { return _verify_count; }
// The default behavior is to call print_on() on gclog_or_tty.
static void print();

7
hotspot/src/share/vm/oops/klass.cpp
View File

@ -356,12 +356,11 @@ void Klass::set_next_sibling(Klass* s) {
}
void Klass::append_to_sibling_list() {
debug_only(if (!SharedSkipVerify) verify();)
debug_only(verify();)
// add ourselves to superklass' subklass list
InstanceKlass* super = superklass();
if (super == NULL) return; // special case: class Object
assert(SharedSkipVerify ||
(!super->is_interface() // interfaces cannot be supers
assert((!super->is_interface() // interfaces cannot be supers
&& (super->superklass() == NULL || !is_interface())),
"an interface can only be a subklass of Object");
Klass* prev_first_subklass = super->subklass_oop();
@ -371,7 +370,7 @@ void Klass::append_to_sibling_list() {
}
// make ourselves the superklass' first subklass
super->set_subklass(this);
debug_only(if (!SharedSkipVerify) verify();)
debug_only(verify();)
}
void Klass::remove_from_sibling_list() {

2
hotspot/src/share/vm/prims/jvmtiTagMap.cpp
View File

@ -1135,7 +1135,7 @@ static jint invoke_primitive_field_callback_for_static_fields
// get offset and field value
int offset = field->field_offset();
address addr = (address)klass + offset;
address addr = (address)klass->java_mirror() + offset;
jvalue value;
copy_to_jvalue(&value, addr, value_type);

4
hotspot/src/share/vm/runtime/globals.hpp
View File

@ -3539,10 +3539,6 @@ class CommandLineFlags {
product(uintx, SharedDummyBlockSize, 0, \
"Size of dummy block used to shift heap addresses (in bytes)") \
\
diagnostic(bool, SharedSkipVerify, false, \
"Skip assert() and verify() which page-in unwanted shared " \
"objects. ") \
\
diagnostic(bool, EnableInvokeDynamic, true, \
"support JSR 292 (method handles, invokedynamic, " \
"anonymous classes") \

2
hotspot/src/share/vm/runtime/handles.cpp
View File

@ -48,7 +48,7 @@
oop* HandleArea::allocate_handle(oop obj) {
assert(_handle_mark_nesting > 1, "memory leak: allocating handle outside HandleMark");
assert(_no_handle_mark_nesting == 0, "allocating handle inside NoHandleMark");
assert(SharedSkipVerify || obj->is_oop(), "sanity check");
assert(obj->is_oop(), "sanity check");
return real_allocate_handle(obj);
}

8
hotspot/src/share/vm/runtime/handles.hpp
View File

@ -110,11 +110,11 @@ class Handle VALUE_OBJ_CLASS_SPEC {
/* Constructors */ \
type##Handle () : Handle() {} \
type##Handle (type##Oop obj) : Handle((oop)obj) { \
assert(SharedSkipVerify || is_null() || ((oop)obj)->is_a(), \
assert(is_null() || ((oop)obj)->is_a(), \
"illegal type"); \
} \
type##Handle (Thread* thread, type##Oop obj) : Handle(thread, (oop)obj) { \
assert(SharedSkipVerify || is_null() || ((oop)obj)->is_a(), "illegal type"); \
assert(is_null() || ((oop)obj)->is_a(), "illegal type"); \
} \
\
/* Operators for ease of use */ \
@ -201,11 +201,11 @@ class instanceKlassHandle : public KlassHandle {
/* Constructors */
instanceKlassHandle () : KlassHandle() {}
instanceKlassHandle (const Klass* k) : KlassHandle(k) {
assert(SharedSkipVerify || k == NULL || k->oop_is_instance(),
assert(k == NULL || k->oop_is_instance(),
"illegal type");
}
instanceKlassHandle (Thread* thread, const Klass* k) : KlassHandle(thread, k) {
assert(SharedSkipVerify || k == NULL || k->oop_is_instance(),
assert(k == NULL || k->oop_is_instance(),
"illegal type");
}
/* Access to klass part */

5
hotspot/src/share/vm/runtime/thread.cpp
View File

@ -177,7 +177,8 @@ void* Thread::allocate(size_t size, bool throw_excpt, MEMFLAGS flags) {
const int alignment = markOopDesc::biased_lock_alignment;
size_t aligned_size = size + (alignment - sizeof(intptr_t));
void* real_malloc_addr = throw_excpt? AllocateHeap(aligned_size, flags, CURRENT_PC)
: os::malloc(aligned_size, flags, CURRENT_PC);
: AllocateHeap(aligned_size, flags, CURRENT_PC,
AllocFailStrategy::RETURN_NULL);
void* aligned_addr = (void*) align_size_up((intptr_t) real_malloc_addr, alignment);
assert(((uintptr_t) aligned_addr + (uintptr_t) size) <=
((uintptr_t) real_malloc_addr + (uintptr_t) aligned_size),
@ -191,7 +192,7 @@ void* Thread::allocate(size_t size, bool throw_excpt, MEMFLAGS flags) {
return aligned_addr;
} else {
return throw_excpt? AllocateHeap(size, flags, CURRENT_PC)
: os::malloc(size, flags, CURRENT_PC);
: AllocateHeap(size, flags, CURRENT_PC, AllocFailStrategy::RETURN_NULL);
}
}

2
hotspot/src/share/vm/runtime/thread.hpp
View File

@ -110,7 +110,7 @@ class Thread: public ThreadShadow {
void* _real_malloc_address;
public:
void* operator new(size_t size) { return allocate(size, true); }
void* operator new(size_t size, std::nothrow_t& nothrow_constant) { return allocate(size, false); }
void* operator new(size_t size, const std::nothrow_t& nothrow_constant) { return allocate(size, false); }
void operator delete(void* p);
protected:

2
hotspot/src/share/vm/utilities/debug.cpp
View File

@ -477,7 +477,7 @@ extern "C" void verify() {
}
// Ensure Eden top is correct before verification
Universe::heap()->prepare_for_verify();
Universe::verify(true);
Universe::verify();
if (!safe) SafepointSynchronize::set_is_not_at_safepoint();
}

89
hotspot/test/runtime/6929067/Test6929067.sh
View File

@ -4,6 +4,7 @@
## @test Test6929067.sh
## @bug 6929067
## @summary Stack guard pages should be removed when thread is detached
## @compile T.java
## @run shell Test6929067.sh
##
@ -33,31 +34,97 @@ case "$OS" in
;;
esac
# Choose arch: i386 or amd64 (test is Linux-specific)
${TESTJAVA}${FS}bin${FS}java ${TESTVMOPTS} -Xinternalversion > vm_version.out 2>&1
# Bitness:
# Cannot simply look at TESTVMOPTS as -d64 is not
# passed if there is only a 64-bit JVM available.
${TESTJAVA}/bin/java ${TESTVMOPTS} -version 2>1 | grep "64-Bit" >/dev/null
grep "64-Bit" vm_version.out > ${NULL}
if [ "$?" = "0" ]
then
ARCH=amd64
COMP_FLAG="-m64"
else
ARCH=i386
COMP_FLAG="-m32"
fi
LD_LIBRARY_PATH=.:${TESTJAVA}/jre/lib/${ARCH}/client:/usr/openwin/lib:/usr/dt/lib:/usr/lib:$LD_LIBRARY_PATH
# Architecture:
# Translate uname output to JVM directory name, but permit testing
# 32-bit x86 on an x64 platform.
ARCH=`uname -m`
case "$ARCH" in
x86_64)
if [ "$COMP_FLAG" = "-m32" ]; then
ARCH=i386
else
ARCH=amd64
fi
;;
ppc64)
if [ "$COMP_FLAG" = "-m32" ]; then
ARCH=ppc
else
ARCH=ppc64
fi
;;
sparc64)
if [ "$COMP_FLAG" = "-m32" ]; then
ARCH=sparc
else
ARCH=sparc64
fi
;;
arm*)
# 32-bit ARM machine: compiler may not recognise -m32
COMP_FLAG=""
ARCH=arm
;;
aarch64)
# 64-bit arm machine, could be testing 32 or 64-bit:
if [ "$COMP_FLAG" = "-m32" ]; then
ARCH=arm
else
ARCH=aarch64
fi
;;
i586)
ARCH=i386
;;
i686)
ARCH=i386
;;
# Assuming other ARCH values need no translation
esac
# VM type: need to know server or client
VMTYPE=client
grep Server vm_version.out > ${NULL}
if [ "$?" = "0" ]
then
VMTYPE=server
fi
LD_LIBRARY_PATH=.:${TESTJAVA}/jre/lib/${ARCH}/${VMTYPE}:/usr/lib:$LD_LIBRARY_PATH
export LD_LIBRARY_PATH
THIS_DIR=`pwd`
cp ${TESTSRC}${FS}invoke.c ${THIS_DIR}
cp ${TESTSRC}${FS}T.java ${THIS_DIR}
cp ${TESTSRC}${FS}invoke.c .
# Copy the result of our @compile action:
cp ${TESTCLASSES}${FS}T.class .
${TESTJAVA}${FS}bin${FS}java ${TESTVMOPTS} -fullversion
${TESTJAVA}${FS}bin${FS}javac T.java
echo "Architecture: ${ARCH}"
echo "Compilation flag: ${COMP_FLAG}"
echo "VM type: ${VMTYPE}"
gcc -DLINUX ${COMP_FLAG} -o invoke \
-I${TESTJAVA}/include -I${TESTJAVA}/include/linux \
-L${TESTJAVA}/jre/lib/${ARCH}/${VMTYPE} \
-ljvm -lpthread invoke.c
gcc -o invoke -I${TESTJAVA}/include -I${TESTJAVA}/include/linux invoke.c ${TESTJAVA}/jre/lib/${ARCH}/client/libjvm.so
./invoke
exit $?

1
jaxp/.hgtags
View File

@ -182,3 +182,4 @@ f19d63b2119a0092f016203981ffef5cc31bc3c5 jdk8-b56
1cb19abb3f7b40bf233b349cd2f51f02d37a9f5b jdk8-b58
af9e8b0f1900b631a8a0fcccff9f1514fe58c808 jdk8-b59
2d1dff5310daaf226421a8c92823cb8afcf35f31 jdk8-b60
6b1db0b41d2f6e2a7b3bdbc8a8db823b47752906 jdk8-b61

1
jaxws/.hgtags
View File

@ -182,3 +182,4 @@ b51b611209f159f94dd2ce3dc2c56daa6d6ac1df jdk8-b57
cac4c393706343df778a13dc6c84cad0f8c237c9 jdk8-b58
ae107401be116f9e384d3a23192f543828e03da5 jdk8-b59
5c5a65ad5291b7cefcdc308f627cf2b195cf2b69 jdk8-b60
97e5e74e2a341d9142ce28043912a3c255e28e03 jdk8-b61

1
jdk/.hgtags
View File

@ -182,3 +182,4 @@ e8569a473cee7f4955bd9e76a9bdf6c6a07ced27 jdk8-b52
d94613ac03d8de375ef60493e2bb76dbd30d875d jdk8-b58
abad1f417bd3df4296631fc943cd3b7f5062c88a jdk8-b59
cec8fa02f15634acd7d02d04b0b2d8c044cdbaaa jdk8-b60
61ddb3fd000a09ab05bff1940b0ac211661e94cf jdk8-b61

8
jdk/make/com/sun/java/pack/Makefile
View File

@ -94,9 +94,9 @@ ifeq ($(PLATFORM), windows)
LDOUTPUT = -Fe
# JDK name required here
RC_FLAGS += /D "JDK_FNAME=$(PGRM).exe" \
/D "JDK_INTERNAL_NAME=$(PGRM)" \
/D "JDK_FTYPE=0x1L"
RC_FLAGS += -D "JDK_FNAME=$(PGRM).exe" \
-D "JDK_INTERNAL_NAME=$(PGRM)" \
-D "JDK_FTYPE=0x1L"
RES = $(OBJDIR)/$(PGRM).res
else
@ -161,7 +161,7 @@ $(UNPACK_EXE): $(UNPACK_EXE_FILES_o) updatefiles winres
$(CP) mapfile-vers-unpack200 $(TEMPDIR)/mapfile-vers
$(LINKER) $(LDDFLAGS) $(sort $(UNPACK_EXE_FILES_o)) $(RES) $(LIBCXX) $(LDOUTPUT)$(TEMPDIR)/unpack200$(EXE_SUFFIX)
ifdef MT
$(MT) /manifest $(OBJDIR)/unpack200$(EXE_SUFFIX).manifest /outputresource:$(TEMPDIR)/unpack200$(EXE_SUFFIX);#1
$(MT) -manifest $(OBJDIR)/unpack200$(EXE_SUFFIX).manifest -outputresource:$(TEMPDIR)/unpack200$(EXE_SUFFIX);#1
endif
$(CP) $(TEMPDIR)/unpack200$(EXE_SUFFIX) $(UNPACK_EXE)
@$(call binary_file_verification,$@)

18
jdk/make/common/Defs-windows.gmk
View File

@ -78,7 +78,7 @@ ifeq ($(COMPILER_VERSION), VS2010)
MS_RUNTIME_LIBRARIES = $(MSVCRNN_DLL)
endif
EXTRA_LFLAGS += /LIBPATH:$(DXSDK_LIB_PATH)
EXTRA_LFLAGS += -LIBPATH:$(DXSDK_LIB_PATH)
# Full Debug Symbols has been enabled on Windows since JDK1.4.1.
# The Full Debug Symbols (FDS) default for VARIANT == OPT builds is
@ -198,7 +198,7 @@ CC_OPT = $(CC_OPT/$(OPTIMIZATION_LEVEL))
# -MTd Use static debug version (better than -MDd, no runtime issues)
# -D_DEBUG Change use of malloc/free/etc to use special debug ones (-MTd)
#
# NOTE: We also will use /D _STATIC_CPPLIB so we don't need msvcpnn.dll
# NOTE: We also will use -D _STATIC_CPPLIB so we don't need msvcpnn.dll
#
# If MS_RUNTIME_STATIC is requested we may have a problem, it is no longer
# supported by VS2010
@ -223,12 +223,12 @@ ifeq ($(MFC_DEBUG), true)
endif
# Always add _STATIC_CPPLIB definition
STATIC_CPPLIB_OPTION = /D _STATIC_CPPLIB
STATIC_CPPLIB_OPTION = -D _STATIC_CPPLIB
# Silence the warning about using _STATIC_CPPLIB
ifneq ($(SHOW_ALL_WARNINGS),true)
# Needed with VS2010 to turn off the deprecated warning.
STATIC_CPPLIB_OPTION += /D _DISABLE_DEPRECATE_STATIC_CPPLIB
STATIC_CPPLIB_OPTION += -D _DISABLE_DEPRECATE_STATIC_CPPLIB
endif
MS_RUNTIME_OPTION += $(STATIC_CPPLIB_OPTION)
@ -242,7 +242,7 @@ ifeq ($(CC_VERSION),msvc)
# -Od Turns off optimization and speeds compilation
# -YX -Fp/.../foobar.pch Use precompiled headers (try someday?)
# -nologo Don't print out startup message
# /D _STATIC_CPPLIB
# -D _STATIC_CPPLIB
# Use static link for the C++ runtime (so msvcpnn.dll not needed)
#
ifeq ($(ENABLE_FULL_DEBUG_SYMBOLS),1)
@ -258,12 +258,12 @@ ifeq ($(CC_VERSION),msvc)
CFLAGS_COMMON += $(MS_RUNTIME_OPTION) $(CFLAGS_$(COMPILER_VERSION))
ifeq ($(ENABLE_FULL_DEBUG_SYMBOLS),1)
LDEBUG = /debug
LDEBUG = -debug
endif
ifeq ($(VTUNE_SUPPORT), true)
OTHER_CFLAGS = -Z7 -Ox
LDEBUG += /pdb:NONE
LDEBUG += -pdb:NONE
endif
# VS2010, always need safe exception handlers, not needed on 64bit
@ -272,7 +272,7 @@ ifeq ($(CC_VERSION),msvc)
endif
# LFLAGS are the flags given to $(LINK) and used to build the actual DLL file
BASELFLAGS = -nologo /opt:REF /incremental:no
BASELFLAGS = -nologo -opt:REF -incremental:no
LFLAGS = $(BASELFLAGS) $(LDEBUG) $(EXTRA_LFLAGS) $(LFLAGS_$(COMPILER_VERSION))
LDDFLAGS += $(LFLAGS_$(COMPILER_VERSION))
@ -404,7 +404,7 @@ else
JDK_UPDATE_VER := 0
endif
RC_FLAGS = /l 0x409 /r
RC_FLAGS = -l 0x409 -r
ifeq ($(VARIANT), OPT)
RC_FLAGS += -d NDEBUG

6
jdk/make/common/Demo.gmk
View File

@ -292,9 +292,9 @@ endif
ifeq ($(PLATFORM),windows)
# JDK name required here
RC_FLAGS += /D "JDK_FNAME=$(LIBRARY).dll" \
/D "JDK_INTERNAL_NAME=$(LIBRARY)" \
/D "JDK_FTYPE=0x2L"
RC_FLAGS += -D "JDK_FNAME=$(LIBRARY).dll" \
-D "JDK_INTERNAL_NAME=$(LIBRARY)" \
-D "JDK_FTYPE=0x2L"
endif
# Native library building

6
jdk/make/common/Library.gmk
View File

@ -206,9 +206,9 @@ endif
@$(ECHO) Created $@
# JDK name required here
RC_FLAGS += /D "JDK_FNAME=$(LIBRARY).dll" \
/D "JDK_INTERNAL_NAME=$(LIBRARY)" \
/D "JDK_FTYPE=0x2L"
RC_FLAGS += -D "JDK_FNAME=$(LIBRARY).dll" \
-D "JDK_INTERNAL_NAME=$(LIBRARY)" \
-D "JDK_FTYPE=0x2L"
$(OBJDIR)/$(LIBRARY).res: $(VERSIONINFO_RESOURCE)
ifndef LOCAL_RESOURCE_FILE

10
jdk/make/common/Program.gmk
View File

@ -157,9 +157,9 @@ $(ACTUAL_PROGRAM):: classes $(INIT)
#
ifeq ($(PLATFORM), windows)
# JDK name required here
RC_FLAGS += /D "JDK_FNAME=$(PROGRAM)$(EXE_SUFFIX)" \
/D "JDK_INTERNAL_NAME=$(PROGRAM)" \
/D "JDK_FTYPE=0x1L"
RC_FLAGS += -D "JDK_FNAME=$(PROGRAM)$(EXE_SUFFIX)" \
-D "JDK_INTERNAL_NAME=$(PROGRAM)" \
-D "JDK_FTYPE=0x1L"
$(OBJDIR)/$(PROGRAM).res: $(VERSIONINFO_RESOURCE)
@$(prep-target)
@ -201,11 +201,11 @@ endif
@$(prep-target)
@set -- $?; \
$(ECHO) Rebuilding $@ because of $$1 $$2 $$3 $$4 $$5 $$6 $${7:+...};
$(LINK) -out:$@ /STACK:$(STACK_SIZE) \
$(LINK) -out:$@ -STACK:$(STACK_SIZE) \
$(MAP_OPTION) $(LFLAGS) $(LDFLAGS) \
@$(OBJDIR)/$(PROGRAM).lcf $(LDLIBS)
ifdef MT
$(MT) /manifest $(OBJDIR)/$(PROGRAM).exe.manifest /outputresource:$@;#1
$(MT) -manifest $(OBJDIR)/$(PROGRAM).exe.manifest /outputresource:$@;#1
endif
@$(call binary_file_verification,$@)
ifeq ($(ENABLE_FULL_DEBUG_SYMBOLS),1)

17
jdk/make/common/Release.gmk
View File

@ -784,11 +784,22 @@ initial-image-jre:: initial-image-jre-setup \
$(RT_JAR) $(RESOURCES_JAR) $(JSSE_JAR) $(JFR_JAR) \
$(BUILDMETAINDEX_JARFILE)
@# Copy in bin directory
ifeq ($(USING_MSYS),true)
# No cpio in MinGW/MSYS
$(CD) $(OUTPUTDIR) && $(TAR) -cf - bin | ($(CD) $(JRE_IMAGE_DIR) && $(TAR) -xpf -)
else
$(CD) $(OUTPUTDIR) && $(FIND) bin -depth | $(CPIO) -pdum $(JRE_IMAGE_DIR)
endif
@# CTE plugin security change require new empty directory lib/applet
$(MKDIR) -p $(JRE_IMAGE_DIR)/lib/applet
@# Copy in lib directory
ifeq ($(USING_MSYS),true)
# No cpio in MinGW/MSYS
$(CD) $(OUTPUTDIR) && $(TAR) -cf - lib | ($(CD) $(JRE_IMAGE_DIR) && $(TAR) -xpf -)
else
$(CD) $(OUTPUTDIR) && $(FIND) lib -depth | $(CPIO) -pdum $(JRE_IMAGE_DIR)
endif
ifeq ($(USING_CYGWIN),true)
$(RM) -rf $(JRE_IMAGE_DIR)/[A-Za-z]:
$(RM) -rf $(OUTPUTDIR)/[A-Za-z]:
@ -919,11 +930,17 @@ endif
# only places from which we copy everything), but because the presence
# of this file causes cygwin's find to bomb out, thus breaking the build
# in "install".
initial-image-jdk-setup:
$(RM) -r $(JDK_IMAGE_DIR)
$(MKDIR) -p $(JDK_IMAGE_DIR)/jre
ifeq ($(USING_MSYS),true)
($(CD) $(JRE_IMAGE_DIR) && $(TAR) -cf - . \
| ($(CD) $(JDK_IMAGE_DIR)/jre && $(TAR) -xpf -))
else
($(CD) $(JRE_IMAGE_DIR) && $(FIND) . -depth -print \
| $(CPIO) -pdum $(JDK_IMAGE_DIR)/jre )
endif
ifeq ($(USING_CYGWIN),true)
$(RM) -rf $(JRE_IMAGE_DIR)/[A-Za-z]:
$(RM) -rf $(JDK_IMAGE_DIR)/jre/[A-Za-z]:

12
jdk/make/common/shared/Defs-utils.gmk
View File

@ -169,15 +169,19 @@ CD = cd # intrinsic unix command
ifeq ($(PLATFORM),windows)
ifdef USING_CYGWIN
# Intrinsic unix command, with backslash-escaped character interpretation
ECHO = $(UNIXCOMMAND_PATH)echo -e
ZIPEXE = $(UNIXCOMMAND_PATH)zip
UNZIP = $(UNIXCOMMAND_PATH)unzip
ECHO = $(UNIXCOMMAND_PATH)echo -e
ZIPEXE = $(UNIXCOMMAND_PATH)zip
UNZIP = $(UNIXCOMMAND_PATH)unzip
# Some CYGWIN nawk versions require BINMODE=w for proper '\r' interpretation
NAWK = $(UNIXCOMMAND_PATH)awk -v BINMODE=w
NAWK = $(UNIXCOMMAND_PATH)awk -v BINMODE=w
else
ZIPEXE = $(UTILS_DEVTOOL_PATH)zip
UNZIP = $(UTILS_DEVTOOL_PATH)unzip
NAWK = $(UNIXCOMMAND_PATH)awk
ifdef USING_MSYS
ECHO = $(UTILS_COMMAND_PATH)echo -e
AR = $(UTILS_DEVTOOL_PATH)ar
endif
endif
# Re-define some utilities
LEX =# override GNU Make intrinsic: no lex on windows

114
jdk/make/common/shared/Defs-windows.gmk
View File

@ -112,6 +112,15 @@ define OptFullPath
$(shell if [ "$1" != "" -a -d "$1" ]; then $(CYGPATH_CMD) "$1" 2> $(DEV_NULL); else echo "$1"; fi)
endef
else
ifdef USING_MSYS
DOSPATH_CMD:=$(shell cd $(JDK_TOPDIR) 2> $(DEV_NULL) && pwd)/make/tools/msys_build_scripts/dospath.sh
define FullPath
$(subst \,/,$(shell $(DOSPATH_CMD) $1))
endef
define OptFullPath
$(shell if [ "$1" != "" -a -d "$1" ]; then (cd $1 && pwd); else echo "$1"; fi)
endef
else
# Temporary until we upgrade to MKS 8.7, MKS pwd returns mixed mode path
define FullPath
$(shell cd $1 2> $(DEV_NULL) && pwd)
@ -120,6 +129,7 @@ define OptFullPath
$(shell if [ "$1" != "" -a -d "$1" ]; then (cd $1 && pwd); else echo "$1"; fi)
endef
endif
endif
# System drive
ifdef SYSTEMDRIVE
@ -146,43 +156,47 @@ else
ifdef USING_CYGWIN
UNIXCOMMAND_PATH :=$(call PrefixPath,/usr/bin)
else
ifdef ROOTDIR
xROOTDIR :="$(subst \,/,$(ROOTDIR))"
_rootdir :=$(call FullPath,$(xROOTDIR))
ifdef USING_MSYS
UNIXCOMMAND_PATH :=$(call PrefixPath,/bin)
else
xROOTDIR :="$(_system_drive)/mksnt"
_rootdir :=$(call FullPath,$(xROOTDIR))
endif
ifneq ($(_rootdir),)
UNIXCOMMAND_PATH :=$(call PrefixPath,$(_rootdir)/mksnt)
endif
endif
ifdef ROOTDIR
xROOTDIR :="$(subst \,/,$(ROOTDIR))"
_rootdir :=$(call FullPath,$(xROOTDIR))
else
xROOTDIR :="$(_system_drive)/mksnt"
_rootdir :=$(call FullPath,$(xROOTDIR))
endif
ifneq ($(_rootdir),)
UNIXCOMMAND_PATH :=$(call PrefixPath,$(_rootdir)/mksnt)
endif
endif # USING_MSYS
endif # USING_CYGWIN
endif
UNIXCOMMAND_PATH:=$(call AltCheckSpaces,UNIXCOMMAND_PATH)
# Get version of MKS or CYGWIN
ifndef USING_CYGWIN
_MKS_VER :=$(shell $(MKSINFO) 2>&1 | $(GREP) Release | $(TAIL) -1 | $(SED) -e 's@.*\(Release.*\)@\1@')
MKS_VER :=$(call GetVersion,$(_MKS_VER))
# At this point, we can re-define FullPath to use DOSNAME_CMD
CHECK_MKS87:=$(call CheckVersions,$(MKS_VER),8.7)
TRY_DOSNAME:=false
ifeq ($(CHECK_MKS87),same)
TRY_DOSNAME:=true
endif
# Newer should be ok
ifeq ($(CHECK_MKS87),newer)
TRY_DOSNAME:=true
endif
ifeq ($(TRY_DOSNAME),true)
ifeq ($(shell $(UNIXCOMMAND_PATH)dosname -s $(_system_drive)/ 2> $(DEV_NULL)),$(_system_drive)/)
_DOSNAME=$(UNIXCOMMAND_PATH)dosname
DOSNAME_CMD:=$(_DOSNAME) -s
ifdef USING_MKS
_MKS_VER :=$(shell $(MKSINFO) 2>&1 | $(GREP) Release | $(TAIL) -1 | $(SED) -e 's@.*\(Release.*\)@\1@')
MKS_VER :=$(call GetVersion,$(_MKS_VER))
# At this point, we can re-define FullPath to use DOSNAME_CMD
CHECK_MKS87:=$(call CheckVersions,$(MKS_VER),8.7)
TRY_DOSNAME:=false
ifeq ($(CHECK_MKS87),same)
TRY_DOSNAME:=true
endif
# Newer should be ok
ifeq ($(CHECK_MKS87),newer)
TRY_DOSNAME:=true
endif
ifeq ($(TRY_DOSNAME),true)
ifeq ($(shell $(UNIXCOMMAND_PATH)dosname -s $(_system_drive)/ 2> $(DEV_NULL)),$(_system_drive)/)
_DOSNAME=$(UNIXCOMMAND_PATH)dosname
DOSNAME_CMD:=$(_DOSNAME) -s
define FullPath
$(subst //,/,$(shell echo $1 | $(DOSNAME_CMD) 2> $(DEV_NULL)))
endef
endif # test dosname -s
endif # TRY_DOSNAME
endif # test dosname -s
endif # TRY_DOSNAME
endif # MKS
# We try to get references to what we need via the default component
@ -440,10 +454,14 @@ else
ifdef USING_CYGWIN
DEVTOOLS_PATH :=$(UNIXCOMMAND_PATH)
else
xDEVTOOLS_PATH :="$(_system_drive)/utils"
fxDEVTOOLS_PATH :=$(call FullPath,$(xDEVTOOLS_PATH))
DEVTOOLS_PATH :=$(call PrefixPath,$(fxDEVTOOLS_PATH))
endif
ifdef USING_MSYS
DEVTOOLS_PATH :=$(UNIXCOMMAND_PATH)
else
xDEVTOOLS_PATH :="$(_system_drive)/utils"
fxDEVTOOLS_PATH :=$(call FullPath,$(xDEVTOOLS_PATH))
DEVTOOLS_PATH :=$(call PrefixPath,$(fxDEVTOOLS_PATH))
endif # USING_MSYS
endif # USING_CYGWIN
endif
DEVTOOLS_PATH:=$(call AltCheckSpaces,DEVTOOLS_PATH)
@ -636,7 +654,7 @@ HOTSPOT_LIB_PATH:=$(call AltCheckValue,HOTSPOT_LIB_PATH)
# Special define for checking the binaries
# All windows dll and exe files should have been built with /NXCOMPAT
# All windows dll and exe files should have been built with -NXCOMPAT
# and be setup for dynamic base addresses.
# In addition, we should not be dependent on certain dll files that
# we do not or cannot redistribute.
@ -648,37 +666,37 @@ else
BANNED_DLLS=msvcp100[.]dll|msvcr100d[.]dll|msvcrtd[.]dll
endif
# Check for /safeseh (only used on 32bit)
# Check for -safeseh (only used on 32bit)
define binary_file_safeseh_verification # binary_file
( \
$(ECHO) "Checking for /SAFESEH usage in: $1" && \
if [ "`$(DUMPBIN) /loadconfig $1 | $(EGREP) -i 'Safe Exception Handler Table'`" = "" ] ; then \
$(ECHO) "Checking for -SAFESEH usage in: $1" && \
if [ "`$(DUMPBIN) -loadconfig $1 | $(EGREP) -i 'Safe Exception Handler Table'`" = "" ] ; then \
$(ECHO) "ERROR: Did not find 'Safe Exception Handler Table' in loadconfig: $1" ; \
$(DUMPBIN) /loadconfig $1 ; \
$(DUMPBIN) -loadconfig $1 ; \
exit 6 ; \
fi ; \
)
endef
# Check for /NXCOMPAT usage
# Check for -NXCOMPAT usage
define binary_file_nxcompat_verification # binary_file
( \
$(ECHO) "Checking for /NXCOMPAT usage in: $1" && \
if [ "`$(DUMPBIN) /headers $1 | $(EGREP) -i 'NX compatible'`" = "" ] ; then \
$(ECHO) "Checking for -NXCOMPAT usage in: $1" && \
if [ "`$(DUMPBIN) -headers $1 | $(EGREP) -i 'NX compatible'`" = "" ] ; then \
$(ECHO) "ERROR: Did not find 'NX compatible' in headers: $1" ; \
$(DUMPBIN) /headers $1 ; \
$(DUMPBIN) -headers $1 ; \
exit 7 ; \
fi ; \
)
endef
# Check for /DYNAMICBASE usage
# Check for -DYNAMICBASE usage
define binary_file_dynamicbase_verification # binary_file
( \
$(ECHO) "Checking for /DYNAMICBASE usage in: $1" && \
if [ "`$(DUMPBIN) /headers $1 | $(EGREP) -i 'Dynamic base'`" = "" ] ; then \
$(ECHO) "Checking for -DYNAMICBASE usage in: $1" && \
if [ "`$(DUMPBIN) -headers $1 | $(EGREP) -i 'Dynamic base'`" = "" ] ; then \
$(ECHO) "ERROR: Did not find 'Dynamic base' in headers: $1" ; \
$(DUMPBIN) /headers $1 ; \
$(DUMPBIN) -headers $1 ; \
exit 8 ; \
fi ; \
)
@ -688,9 +706,9 @@ endef
define binary_file_dll_verification # binary_file
( \
$(ECHO) "Checking for banned dependencies in: $1" && \
if [ "`$(DUMPBIN) /dependents $1 | $(EGREP) -i '$(BANNED_DLLS)'`" != "" ] ; then \
if [ "`$(DUMPBIN) -dependents $1 | $(EGREP) -i '$(BANNED_DLLS)'`" != "" ] ; then \
$(ECHO) "ERROR: Found use of $(BANNED_DLLS)"; \
$(DUMPBIN) /dependents $1 ; \
$(DUMPBIN) -dependents $1 ; \
exit 9 ; \
fi ; \
)

45
jdk/make/common/shared/Platform.gmk
View File

@ -70,6 +70,8 @@ PLATFORM_SHARED=done
# LIBARCH32 solaris only: sparc or i386
# LIBARCH64 solaris only: sparcv9 or amd64
# USING_CYGWIN windows only: true or false
# USING_MSYS windows only: true or false
# USING_MKS windows only: true or false
# ISHIELD_TEMP_MIN windows only: minimum disk space in temp area
# Only run uname once in this make session.
@ -306,6 +308,8 @@ endif
# Windows with and without CYGWIN will be slightly different
ifeq ($(SYSTEM_UNAME), Windows_NT)
PLATFORM = windows
USING_MKS = true
export USING_MKS
endif
ifneq (,$(findstring CYGWIN,$(SYSTEM_UNAME)))
PLATFORM = windows
@ -318,6 +322,11 @@ ifneq (,$(findstring CYGWIN,$(SYSTEM_UNAME)))
export CYGWIN_HOME
endif
endif
ifneq (,$(findstring MINGW,$(SYSTEM_UNAME)))
PLATFORM = windows
USING_MSYS = true
export USING_MSYS
endif
# Platform settings specific to Windows
ifeq ($(PLATFORM), windows)
@ -395,11 +404,12 @@ ifeq ($(PLATFORM), windows)
endif
ARCH_FAMILY = $(ARCH)
# Where is unwanted output to be delivered?
# MKS uses the special file "NUL", cygwin uses the customary unix file.
ifeq ($(USING_CYGWIN),true)
DEV_NULL = /dev/null
else
# MKS uses the special file "NUL"; Cygwin and MinGW/MSYS use the
# customary unix file.
ifeq ($(USING_MKS),true)
DEV_NULL = NUL
else
DEV_NULL = /dev/null
endif
export DEV_NULL
# Classpath separator
@ -440,28 +450,11 @@ ifeq ($(PLATFORM), windows)
_MB_OF_MEMORY := \
$(shell free -m | grep Mem: | awk '{print $$2;}' )
else
# Windows 2000 has the mem utility, but two memory areas
# extended memory is what is beyond 1024M
_B_OF_EXT_MEMORY := \
$(shell mem 2> $(DEV_NULL) | \
grep 'total contiguous extended memory' | awk '{print $$1;}')
ifeq ($(_B_OF_EXT_MEMORY),)
_B_OF_MEMORY := \
$(shell mem 2> $(DEV_NULL) | \
grep 'total conventional memory' | awk '{print $$1;}')
else
_B_OF_MEMORY := \
$(shell expr 1048576 '+' $(_B_OF_EXT_MEMORY) 2> $(DEV_NULL))
endif
ifeq ($(_B_OF_MEMORY),)
# Windows 2003 has the systeminfo utility use it if mem doesn't work
_MB_OF_MEMORY := \
$(shell systeminfo 2> $(DEV_NULL) | \
grep 'Total Physical Memory:' | \
awk '{print $$4;}' | sed -e 's@,@@')
else
_MB_OF_MEMORY := $(shell expr $(_B_OF_MEMORY) '/' 1024 2> $(DEV_NULL))
endif
# Windows XP and higher has the systeminfo utility
_MB_OF_MEMORY := \
$(shell systeminfo 2> $(DEV_NULL) | \
grep 'Total Physical Memory:' | \
awk '{print $$4;}' | sed -e 's@,@@')
endif
ifeq ($(shell expr $(_MB_OF_MEMORY) '+' 0 2> $(DEV_NULL)), $(_MB_OF_MEMORY))
MB_OF_MEMORY := $(_MB_OF_MEMORY)

9
jdk/make/common/shared/Sanity-Settings.gmk
View File

@ -182,8 +182,13 @@ ifeq ($(PLATFORM),windows)
ALL_SETTINGS+=$(call addRequiredVersionSetting,CYGWIN_VER)
ALL_SETTINGS+=$(call addRequiredSetting,CYGPATH_CMD)
else
ALL_SETTINGS+=$(call addRequiredVersionSetting,MKS_VER)
ALL_SETTINGS+=$(call addOptionalSetting,DOSNAME_CMD)
ifdef USING_MSYS
ALL_SETTINGS+=$(call addRequiredSetting,USING_MSYS)
ALL_SETTINGS+=$(call addRequiredSetting,DOSPATH_CMD)
else
ALL_SETTINGS+=$(call addRequiredVersionSetting,MKS_VER)
ALL_SETTINGS+=$(call addOptionalSetting,DOSNAME_CMD)
endif
endif
endif
ifeq ($(PLATFORM),linux)

20
jdk/make/common/shared/Sanity.gmk
View File

@ -395,7 +395,7 @@ endif
ifeq ($(PLATFORM), windows)
MKS_CHECK :=$(call CheckVersions,$(MKS_VER),$(REQUIRED_MKS_VER))
sane-mks:
ifndef USING_CYGWIN
ifdef USING_MKS
ifeq ($(MKS_CHECK),missing)
@$(call OfficialErrorMessage,MKS version,$(MKS_VER),$(REQUIRED_MKS_VER))
endif
@ -905,14 +905,25 @@ sane-unixcommand_path:
"" >> $(ERROR_FILE) ; \
fi
ifeq ($(PLATFORM), windows)
@for utility in cpio ar file m4 ; do \
ifeq ($(USING_MSYS), true)
@for utility in $(AR) $(FILE) $(M4) ; do \
if [ ! -r "`$(WHICH) $${utility}`" ]; then \
$(ECHO) "WARNING: You do not have the utility $${utility} in the \n" \
" directory $(UNIXCOMMAND_PATH). \n" \
" The utilities cpio, ar, file, and m4 are required. \n" \
" The utilities ar, file and m4 are required. \n" \
"" >> $(WARNING_FILE) ; \
fi; \
done
else
@for utility in $(AR) $(CPIO) $(FILE) $(M4) ; do \
if [ ! -r "`$(WHICH) $${utility}`" ]; then \
$(ECHO) "WARNING: You do not have the utility $${utility} in the \n" \
" directory $(UNIXCOMMAND_PATH). \n" \
" The utilities ar, cpio, file and m4 are required. \n" \
"" >> $(WARNING_FILE) ; \
fi; \
done
endif
endif
######################################################
@ -999,7 +1010,8 @@ ifeq ($(PLATFORM), windows)
" This is normally obtained from the WINDOWSSDKDIR." \
"" >> $(ERROR_FILE)
endif
ifeq ($(wildcard $(DUMPBIN)),)
# MinGW/MSYS make 3.81 will not tolerate a path with a quoted substring
ifeq ($(wildcard $(subst ",,$(DUMPBIN))),)
@$(ECHO) "ERROR: Cannot find the DUMPBIN utility from path: $(DUMPBIN)\n" \
" This is normally obtained from the COMPILER_PATH." \
"" >> $(ERROR_FILE)

30
jdk/make/jdk_generic_profile.sh
View File

@ -176,17 +176,38 @@ else
else
windows_arch=i586
fi
repo=`hg root | sed -e 's@\\\\@/@g'`
# We need to check if we are running a CYGWIN shell
if [ "$(uname -a | fgrep Cygwin)" != "" -a -f /bin/cygpath ] ; then
if [ "$(echo ${osname} | fgrep Cygwin)" != "" -a -f /bin/cygpath ] ; then
# For CYGWIN, uname will have "Cygwin" in it, and /bin/cygpath should exist
# Utility to convert to short pathnames without spaces
cygpath="/usr/bin/cygpath -a -m -s"
cygpathp="/usr/bin/cygpath -p"
# Most unix utilities are in the /usr/bin
unixcommand_path="/usr/bin"
# Make the prompt tell you CYGWIN
export PS1="CYGWIN:${COMPUTERNAME}:${USERNAME}[\!] "
elif [ "$(echo ${osname} | fgrep MINGW)" != "" ] ; then
# Utility to convert to short pathnames without spaces
cygpath="${repo}/make/tools/msys_build_scripts/dospath.sh"
if [ ! -f ${cygpath} ] ; then
echo "ERROR: Cannot find cygpath or equivalent on this machine"
exit 1
fi
# Utility to fix a path to MinGW/MSYS format - the equivalent of 'cygpath -p'
for tfile in "${repo}/make/scripts/fixpath.pl" "${repo}/../make/scripts/fixpath.pl"; do
if [ -f ${tfile} ] ; then
cygpathp="/bin/perl ${tfile} -m"
fi
done;
if [ -z "${cygpathp}" ] ; then
echo "ERROR: Cannot find make/scripts/fixpath.pl on this machine"
exit 1
fi
unixcommand_path="/usr/bin"
else
echo "ERROR: Cannot find CYGWIN on this machine"
echo "ERROR: Cannot find CYGWIN or MinGW/MSYS on this machine"
exit 1
fi
if [ "${ALT_UNIXCOMMAND_PATH}" != "" ] ; then
@ -204,17 +225,18 @@ else
else
sys_root=$(${cygpath} "C:/WINNT")
fi
path4sdk="${unixcommand_path};${sys_root}/system32;${sys_root};${sys_root}/System32/Wbem"
if [ ! -d "${sys_root}" ] ; then
echo "WARNING: No system root found at: ${sys_root}"
fi
# Build a : separated path making sure each segment is acceptable to ${osname}
path4sdk="${unixcommand_path}:"`${cygpathp} "${sys_root}/system32;${sys_root};${sys_root}/System32/Wbem"`
# Compiler setup (nasty part)
# NOTE: You can use vcvars32.bat to set PATH, LIB, and INCLUDE.
# NOTE: CYGWIN has a link.exe too, make sure the compilers are first
# Use supplied vsvars.sh
repo=`hg root`
if [ -f "${repo}/make/scripts/vsvars.sh" ] ; then
eval `sh ${repo}/make/scripts/vsvars.sh -v10`
elif [ -f "${repo}/../make/scripts/vsvars.sh" ] ; then

8
jdk/make/tools/freetypecheck/Makefile
View File

@ -37,11 +37,11 @@ ifeq ($(OPENJDK),true)
# Start with CFLAGS (which gets us the required -xarch setting on solaris)
ifeq ($(PLATFORM), windows)
FT_OPTIONS = /nologo /c
FT_OPTIONS = -nologo -c
FREETYPE_DLL = $(FREETYPE_LIB_PATH)/freetype.dll
FT_LD_OPTIONS = $(FREETYPE_LIB_PATH)/freetype.lib
ifdef MT
FT_LD_OPTIONS += /manifest
FT_LD_OPTIONS += -manifest
endif
else
FT_OPTIONS = $(CFLAGS)
@ -72,11 +72,11 @@ $(FT_TEST): freetypecheck.c
$(prep-target)
ifeq ($(PLATFORM), windows)
$(CC) $(FT_OPTIONS) $(CC_OBJECT_OUTPUT_FLAG)$(FT_OBJ) $<
$(LINK) $(FT_LD_OPTIONS) /OUT:$(FT_TEST) $(FT_OBJ)
$(LINK) $(FT_LD_OPTIONS) -OUT:$(FT_TEST) $(FT_OBJ)
$(CP) $(FREETYPE_DLL) $(@D)/
ifdef MT
$(CP) $(MSVCRNN_DLL_PATH)/$(MSVCRNN_DLL) $(@D)/
$(MT) /manifest $(FT_TEST).manifest /outputresource:$(FT_TEST);#1
$(MT) -manifest $(FT_TEST).manifest -outputresource:$(FT_TEST);#1
endif
else
@$(CC) $(FT_OPTIONS) -o $@ $< $(FT_LD_OPTIONS)

42
jdk/make/tools/msys_build_scripts/dospath.sh Normal file
View File

@ -0,0 +1,42 @@
#
# 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. Oracle designates this
# particular file as subject to the "Classpath" exception as provided
# by Oracle in the LICENSE file that accompanied this code.
#
# 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.
#
# A shell script which converts its first argument, which must be an existing
# path name, into a DOS (aka 8.3) path name. If the path is a file, only the
# directory part of the whole path will be converted.
# This shell script executes the Visual Basic helper script 'dospath.vbs'
# which must be located in the same directory as this script itself.
# The Visual Basic script will be invoked trough the "Windows Script Host"
# which is available by default on Windows since Windows 98.
pushd `dirname "$0"` > /dev/null
ABS_PATH=`pwd`
popd > /dev/null
if [ -d "$1" ]; then
echo `cd "$1" && cscript.exe -nologo $ABS_PATH/dospath.vbs`;
elif [ -f "$1" ]; then
DIR=`dirname "$1"`;
echo `cd "$DIR" && cscript.exe -nologo $ABS_PATH/dospath.vbs`\\`basename "$1"`;
fi

34
jdk/make/tools/msys_build_scripts/dospath.vbs Normal file
View File

@ -0,0 +1,34 @@
'
' 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. Oracle designates this
' particular file as subject to the "Classpath" exception as provided
' by Oracle in the LICENSE file that accompanied this code.
'
' 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.
'
'
' Visual Basic Script which returns the DOS (aka 8.3) filename of the current
' directory.
' Only called from 'dospath.sh' during a Windows build under MinGW/MSYS.
'
Set fso=CreateObject("Scripting.FileSystemObject")
Set path = fso.GetFolder(".")
WScript.Echo path.ShortPath

22
jdk/src/share/classes/java/lang/invoke/BoundMethodHandle.java
View File

@ -79,7 +79,7 @@ import com.sun.xml.internal.ws.org.objectweb.asm.Type;
default : throw new InternalError("unexpected xtype: " + xtype);
}
} catch (Throwable t) {
throw new InternalError(t);
throw newInternalError(t);
}
}
@ -97,7 +97,7 @@ import com.sun.xml.internal.ws.org.objectweb.asm.Type;
case 'D': return cloneExtendD(type, form, (double) x);
}
} catch (Throwable t) {
throw new InternalError(t);
throw newInternalError(t);
}
throw new InternalError("unexpected type: " + xtype);
}
@ -115,7 +115,7 @@ import com.sun.xml.internal.ws.org.objectweb.asm.Type;
try {
return clone(srcType, form);
} catch (Throwable t) {
throw new InternalError(t);
throw newInternalError(t);
}
}
@ -124,7 +124,7 @@ import com.sun.xml.internal.ws.org.objectweb.asm.Type;
try {
return clone(newType, form.permuteArguments(1, reorder, basicTypes(newType.parameterList())));
} catch (Throwable t) {
throw new InternalError(t);
throw newInternalError(t);
}
}
@ -166,7 +166,7 @@ import com.sun.xml.internal.ws.org.objectweb.asm.Type;
case 'J': return argJ(i);
}
} catch (Throwable ex) {
throw new InternalError(ex);
throw newInternalError(ex);
}
throw new InternalError("unexpected type: " + speciesData().types+"."+i);
}
@ -192,7 +192,7 @@ import com.sun.xml.internal.ws.org.objectweb.asm.Type;
try {
return (MethodHandle) argL(0);
} catch (Throwable ex) {
throw new InternalError(ex);
throw newInternalError(ex);
}
}
@ -464,7 +464,7 @@ import com.sun.xml.internal.ws.org.objectweb.asm.Type;
}
}
} catch (Throwable e) {
throw new InternalError(e);
throw newInternalError(e);
}
for (SpeciesData d : CACHE.values()) {
@ -748,7 +748,7 @@ import com.sun.xml.internal.ws.org.objectweb.asm.Type;
try {
return LOOKUP.findGetter(cbmhClass, fieldName, fieldType);
} catch (NoSuchFieldException | IllegalAccessException e) {
throw new InternalError(e);
throw newInternalError(e);
}
}
@ -776,7 +776,7 @@ import com.sun.xml.internal.ws.org.objectweb.asm.Type;
Field F_SPECIES_DATA = cbmh.getDeclaredField("SPECIES_DATA");
return (SpeciesData) F_SPECIES_DATA.get(null);
} catch (ReflectiveOperationException ex) {
throw new InternalError(ex);
throw newInternalError(ex);
}
}
@ -802,7 +802,7 @@ import com.sun.xml.internal.ws.org.objectweb.asm.Type;
try {
return linkConstructor(LOOKUP.findConstructor(cbmh, MethodType.fromMethodDescriptorString(makeSignature(types, true), null)));
} catch (NoSuchMethodException | IllegalAccessException | IllegalArgumentException | TypeNotPresentException e) {
throw new InternalError(e);
throw newInternalError(e);
}
}
@ -833,7 +833,7 @@ import com.sun.xml.internal.ws.org.objectweb.asm.Type;
linkerMN = MemberName.getFactory().resolveOrFail(REF_invokeStatic, linkerMN, null, NoSuchMethodException.class);
assert(linkerMN.isStatic());
} catch (ReflectiveOperationException ex) {
throw new InternalError(ex);
throw newInternalError(ex);
}
// extend arguments array
Object[] newArgs = Arrays.copyOf(initName.arguments, initName.arguments.length + 1);

2
jdk/src/share/classes/java/lang/invoke/CallSite.java
View File

@ -222,7 +222,7 @@ public class CallSite {
GET_TARGET = IMPL_LOOKUP.
findVirtual(CallSite.class, "getTarget", MethodType.methodType(MethodHandle.class));
} catch (ReflectiveOperationException e) {
throw new InternalError(e);
throw newInternalError(e);
}
}

6
jdk/src/share/classes/java/lang/invoke/DirectMethodHandle.java
View File

@ -218,7 +218,7 @@ class DirectMethodHandle extends MethodHandle {
try {
linker = IMPL_NAMES.resolveOrFail(REF_invokeStatic, linker, null, NoSuchMethodException.class);
} catch (ReflectiveOperationException ex) {
throw new InternalError(ex);
throw newInternalError(ex);
}
final int DMH_THIS = 0;
final int ARG_BASE = 1;
@ -554,7 +554,7 @@ class DirectMethodHandle extends MethodHandle {
try {
linker = IMPL_NAMES.resolveOrFail(REF_invokeVirtual, linker, null, NoSuchMethodException.class);
} catch (ReflectiveOperationException ex) {
throw new InternalError(ex);
throw newInternalError(ex);
}
// What is the external type of the lambda form?
@ -653,7 +653,7 @@ class DirectMethodHandle extends MethodHandle {
nf.resolve();
}
} catch (ReflectiveOperationException ex) {
throw new InternalError(ex);
throw newInternalError(ex);
}
}
}

6
jdk/src/share/classes/java/lang/invoke/InvokerBytecodeGenerator.java
View File

@ -138,7 +138,7 @@ class InvokerBytecodeGenerator {
DUMP_CLASS_FILES_DIR = dumpDir;
System.out.println("Dumping class files to "+DUMP_CLASS_FILES_DIR+"/...");
} catch (Exception e) {
throw new InternalError(e);
throw newInternalError(e);
}
} else {
DUMP_CLASS_FILES_COUNTERS = null;
@ -162,7 +162,7 @@ class InvokerBytecodeGenerator {
file.close();
return null;
} catch (IOException ex) {
throw new InternalError(ex);
throw newInternalError(ex);
}
}
});
@ -279,7 +279,7 @@ class InvokerBytecodeGenerator {
try {
member = MEMBERNAME_FACTORY.resolveOrFail(REF_invokeStatic, member, HOST_CLASS, ReflectiveOperationException.class);
} catch (ReflectiveOperationException e) {
throw new InternalError(e);
throw newInternalError(e);
}
//System.out.println("resolveInvokerMember => "+member);
return member;

12
jdk/src/share/classes/java/lang/invoke/Invokers.java
View File

@ -27,6 +27,7 @@ package java.lang.invoke;
import java.util.Arrays;
import sun.invoke.empty.Empty;
import static java.lang.invoke.MethodHandleStatics.*;
import static java.lang.invoke.MethodHandleNatives.Constants.*;
import static java.lang.invoke.MethodHandles.Lookup.IMPL_LOOKUP;
import static java.lang.invoke.LambdaForm.*;
@ -128,9 +129,8 @@ class Invokers {
try {
//Lookup.findVirtual(MethodHandle.class, name, type);
return IMPL_LOOKUP.resolveOrFail(REF_invokeVirtual, MethodHandle.class, name, type);
} catch (ReflectiveOperationException ex) {
throw new InternalError("JVM cannot find invoker for "+type, ex);
throw newInternalError("JVM cannot find invoker for "+type, ex);
}
}
@ -176,7 +176,7 @@ class Invokers {
.findVirtual(MethodHandle.class, "asSpreader",
MethodType.methodType(MethodHandle.class, Class.class, int.class));
} catch (ReflectiveOperationException ex) {
throw new InternalError(ex);
throw newInternalError(ex);
}
makeSpreader = MethodHandles.insertArguments(makeSpreader, 1, Object[].class, spreadArgCount);
vaInvoker = MethodHandles.filterArgument(arrayInvoker, 0, makeSpreader);
@ -215,7 +215,7 @@ class Invokers {
.findStatic(CallSite.class, "uninitializedCallSite",
MethodType.methodType(Empty.class));
} catch (ReflectiveOperationException ex) {
throw new InternalError(ex);
throw newInternalError(ex);
}
}
invoker = MethodHandles.explicitCastArguments(invoker, MethodType.methodType(targetType.returnType()));
@ -389,7 +389,7 @@ class Invokers {
form.genericInvoker = gamh;
return gamh;
} catch (Exception ex) {
throw new InternalError("Exception while resolving inexact invoke", ex);
throw newInternalError("Exception while resolving inexact invoke", ex);
}
}
@ -456,7 +456,7 @@ class Invokers {
NF_getCallSiteTarget.resolve();
// bound
} catch (ReflectiveOperationException ex) {
throw new InternalError(ex);
throw newInternalError(ex);
}
}

4
jdk/src/share/classes/java/lang/invoke/LambdaForm.java
View File

@ -457,7 +457,7 @@ class LambdaForm {
isCompiled = true;
return vmentry;
} catch (Error | Exception ex) {
throw new InternalError(this.toString(), ex);
throw newInternalError(this.toString(), ex);
}
}
@ -1547,7 +1547,7 @@ class LambdaForm {
try {
zmem = IMPL_NAMES.resolveOrFail(REF_invokeStatic, zmem, null, NoSuchMethodException.class);
} catch (IllegalAccessException|NoSuchMethodException ex) {
throw new InternalError(ex);
throw newInternalError(ex);
}
NamedFunction zcon = new NamedFunction(zmem);
Name n = new Name(zcon).newIndex(0);

2
jdk/src/share/classes/java/lang/invoke/MemberName.java
View File

@ -558,7 +558,7 @@ import java.util.Objects;
try {
return (MemberName) super.clone();
} catch (CloneNotSupportedException ex) {
throw new InternalError(ex);
throw newInternalError(ex);
}
}

4
jdk/src/share/classes/java/lang/invoke/MethodHandle.java
View File

@ -1372,7 +1372,7 @@ assertEquals("[three, thee, tee]", asListFix.invoke((Object)argv).toString());
NF_reinvokerTarget = new LambdaForm.NamedFunction(MethodHandle.class
.getDeclaredMethod("reinvokerTarget"));
} catch (ReflectiveOperationException ex) {
throw new InternalError(ex);
throw newInternalError(ex);
}
}
@ -1397,7 +1397,7 @@ assertEquals("[three, thee, tee]", asListFix.invoke((Object)argv).toString());
try {
FORM_OFFSET = UNSAFE.objectFieldOffset(MethodHandle.class.getDeclaredField("form"));
} catch (ReflectiveOperationException ex) {
throw new InternalError(ex);
throw newInternalError(ex);
}
}
}

2
jdk/src/share/classes/java/lang/invoke/MethodHandleImpl.java
View File

@ -478,7 +478,7 @@ import static java.lang.invoke.MethodHandles.Lookup.IMPL_LOOKUP;
.getDeclaredMethod("checkSpreadArgument", Object.class, int.class));
NF_checkSpreadArgument.resolve();
} catch (ReflectiveOperationException ex) {
throw new InternalError(ex);
throw newInternalError(ex);
}
}

8
jdk/src/share/classes/java/lang/invoke/MethodHandleStatics.java
View File

@ -93,6 +93,12 @@ import sun.misc.Unsafe;
}
// handy shared exception makers (they simplify the common case code)
/*non-public*/ static InternalError newInternalError(String message, Throwable cause) {
return new InternalError(message, cause);
}
/*non-public*/ static InternalError newInternalError(Throwable cause) {
return new InternalError(cause);
}
/*non-public*/ static RuntimeException newIllegalStateException(String message) {
return new IllegalStateException(message);
}
@ -109,7 +115,7 @@ import sun.misc.Unsafe;
return new IllegalArgumentException(message(message, obj, obj2));
}
/*non-public*/ static Error uncaughtException(Exception ex) {
throw new InternalError("uncaught exception", ex);
throw newInternalError("uncaught exception", ex);
}
static Error NYI() {
throw new AssertionError("NYI");

15
jdk/src/share/classes/sun/invoke/util/ValueConversions.java
View File

@ -475,7 +475,7 @@ public class ValueConversions {
.findStatic(THIS_CLASS, "fillNewTypedArray",
MethodType.methodType(Object[].class, Object[].class, Integer.class, Object[].class));
} catch (NoSuchMethodException | IllegalAccessException ex) {
throw new InternalError("uncaught exception", ex);
throw newInternalError("uncaught exception", ex);
}
}
@ -489,7 +489,7 @@ public class ValueConversions {
COPY_AS_PRIMITIVE_ARRAY = IMPL_LOOKUP.findStatic(THIS_CLASS, "copyAsPrimitiveArray", MethodType.methodType(Object.class, Wrapper.class, Object[].class));
MAKE_LIST = IMPL_LOOKUP.findStatic(THIS_CLASS, "makeList", MethodType.methodType(List.class, Object[].class));
} catch (ReflectiveOperationException ex) {
throw new InternalError("uncaught exception", ex);
throw newInternalError("uncaught exception", ex);
}
}
}
@ -527,9 +527,8 @@ public class ValueConversions {
MethodHandle.class, int.class, MethodHandle.class);
m.setAccessible(true);
mh = IMPL_LOOKUP.unreflect(m);
} catch (ReflectiveOperationException | SecurityException ex) {
throw new InternalError(ex);
throw newInternalError(ex);
}
COLLECT_ARGUMENTS = mh;
}
@ -1209,4 +1208,12 @@ public class ValueConversions {
private static MethodHandle buildVarargsList(int nargs) {
return MethodHandles.filterReturnValue(varargsArray(nargs), LazyStatics.MAKE_LIST);
}
// handy shared exception makers (they simplify the common case code)
private static InternalError newInternalError(String message, Throwable cause) {
return new InternalError(message, cause);
}
private static InternalError newInternalError(Throwable cause) {
return new InternalError(cause);
}
}

5
jdk/test/ProblemList.txt
View File

@ -143,6 +143,11 @@ java/lang/management/MemoryMXBean/CollectionUsageThresholdSerialGC.sh generic-al
java/lang/management/MemoryMXBean/MemoryTest.java generic-all
java/lang/management/MemoryMXBean/MemoryTestAllGC.sh generic-all
# Exclude until hotspot/jdk repos are sync'd w.r.t. JAVA_MAX_SUPPORTED_VERSION
# Needed when hotspot fix 7054345 is present. Remove when the JDK source is
# updated accordingly.
java/lang/System/Versions.java generic-all
############################################################################
# jdk_management

2
jdk/test/java/lang/invoke/BigArityTest.java
View File

@ -70,7 +70,7 @@ public class BigArityTest {
MethodHandles.lookup().unreflect(
BigArityTest.class.getDeclaredMethod("hashArguments", Object[].class));
} catch (ReflectiveOperationException ex) {
throw new InternalError(ex);
throw new Error(ex);
}
}
static MethodHandle MH_hashArguments(int arity) {

6
jdk/test/java/lang/invoke/PrivateInvokeTest.java
View File

@ -145,21 +145,21 @@ public class PrivateInvokeTest {
MH_DEBUG_STRING = DIRECT_INVOKER_LOOKUP
.findVirtual(MethodHandle.class, "debugString", methodType(String.class));
} catch (ReflectiveOperationException ex) {
throw new InternalError(ex);
throw new Error(ex);
}
}
private Object internalMemberName(MethodHandle mh) {
try {
return MH_INTERNAL_MEMBER_NAME.invokeExact(mh);
} catch (Throwable ex) {
throw new InternalError(ex);
throw new Error(ex);
}
}
private String debugString(MethodHandle mh) {
try {
return (String) MH_DEBUG_STRING.invokeExact(mh);
} catch (Throwable ex) {
throw new InternalError(ex);
throw new Error(ex);
}
}
private static MethodHandle directInvoker(int refKind, MethodType mtype) {

1
langtools/.hgtags
View File

@ -182,3 +182,4 @@ e48e7e1f026b82d921433150180799898c088890 jdk8-b55
804a3fbc86e28a4d9e77c30aa0bd4aa68056f23f jdk8-b58
f299927fc31689385f67ab7322c18eb41d8bd71e jdk8-b59
3d2b98ffcb534b0e5be87bb1f9f68d1518ad7729 jdk8-b60
26020b247ad3806dbca33e029ee12e1b191f59f9 jdk8-b61

14
make/jprt.properties
View File

@ -79,20 +79,18 @@ jprt.make.rule.core.test.targets= \
${jprt.my.test.target.set:TESTNAME=jdk_util}, \
${jprt.my.test.target.set:TESTNAME=jdk_io}, \
${jprt.my.test.target.set:TESTNAME=jdk_net}, \
${jprt.my.test.target.set:TESTNAME=jdk_nio1}, \
${jprt.my.test.target.set:TESTNAME=jdk_nio2}, \
${jprt.my.test.target.set:TESTNAME=jdk_nio3}, \
${jprt.my.test.target.set:TESTNAME=jdk_nio}, \
${jprt.my.test.target.set:TESTNAME=jdk_security1}, \
${jprt.my.test.target.set:TESTNAME=jdk_security2}, \
${jprt.my.test.target.set:TESTNAME=jdk_security3}, \
${jprt.my.test.target.set:TESTNAME=jdk_rmi}, \
${jprt.my.test.target.set:TESTNAME=jdk_management1}, \
${jprt.my.test.target.set:TESTNAME=jdk_management2}, \
${jprt.my.test.target.set:TESTNAME=jdk_management}, \
${jprt.my.test.target.set:TESTNAME=jdk_jmx}, \
${jprt.my.test.target.set:TESTNAME=jdk_text}, \
${jprt.my.test.target.set:TESTNAME=jdk_tools1}, \
${jprt.my.test.target.set:TESTNAME=jdk_tools2}, \
${jprt.my.test.target.set:TESTNAME=jdk_tools}, \
${jprt.my.test.target.set:TESTNAME=jdk_jdi}, \
${jprt.my.test.target.set:TESTNAME=jdk_jfr}, \
${jprt.my.test.target.set:TESTNAME=jdk_misc}
${jprt.my.test.target.set:TESTNAME=jdk_other}
# All vm test targets (testset=all)
jprt.vm.all.test.targets= \

169
make/scripts/fixpath.pl Normal file
View File

@ -0,0 +1,169 @@
#!/bin/perl
#
# 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. Oracle designates this
# particular file as subject to the "Classpath" exception as provided
# by Oracle in the LICENSE file that accompanied this code.
#
# 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.
#
# Crunch down the input(s) to Windows short (mangled) form.
# Any elements not actually found in the filesystem will be dropped.
#
# This script needs three modes:
# 1) DOS mode with drive letter followed by : and ; path separator
# 2) Cygwin mode with /cygdrive/<drive letter>/ and : path separator
# 3) MinGW/MSYS mode with /<drive letter>/ and : path separator
use strict;
use warnings;
use Getopt::Std;
sub Usage() {
print ("Usage:\n $0 -d | -c | -m \<PATH\>\n");
print (" -d DOS style (drive letter, :, and ; path separator)\n");
print (" -c Cywgin style (/cygdrive/drive/ and : path separator)\n");
print (" -m MinGW style (/drive/ and : path separator)\n");
exit 1;
}
# Process command line options:
my %opts;
getopts('dcm', \%opts) || Usage();
if (scalar(@ARGV) != 1) {Usage()};
# Translate drive letters such as C:/
# if MSDOS, Win32::GetShortPathName() does the work (see below).
# if Cygwin, use the /cygdrive/c/ form.
# if MinGW, use the /c/ form.
my $path0;
my $sep2;
if (defined ($opts{'d'})) {
#MSDOS
$path0 = '';
$sep2 = ';';
} elsif (defined ($opts{'c'})) {
#Cygwin
$path0 = '/cygdrive';
$sep2 = ':';
} elsif (defined ($opts{'m'})) {
#MinGW/MSYS
$path0 = '';
$sep2 = ':';
} else {
Usage();
}
my $input = $ARGV[0];
my $sep1;
# Is the input ';' separated, or ':' separated, or a simple string?
if (($input =~ tr/;/;/) > 0) {
# One or more ';' implies Windows style path.
$sep1 = ';';
} elsif (($input =~ tr/:/:/) > 1) {
# Two or more ':' implies Cygwin or MinGW/MSYS style path.
$sep1 = ':';
} else {
# Otherwise, this is not a path - take up to the end of string in
# one piece.
$sep1 = '/$/';
}
# Split the input on $sep1 PATH separator and process the pieces.
my @pieces;
for (split($sep1, $input)) {
my $try = $_;
if (($try =~ /^\/cygdrive\/(.)\/(.*)$/) || ($try =~ /^\/(.)\/(.*)$/)) {
# Special case #1: This is a Cygwin /cygrive/<drive letter/ path.
# Special case #2: This is a MinGW/MSYS /<drive letter/ path.
$try = $1.':/'.$2;
} elsif ($try =~ /^\/(.*)$/) {
# Special case #3: check for a Cygwin or MinGW/MSYS form with a
# leading '/' for example '/usr/bin/bash'.
# Look up where this is mounted and rebuild the
# $try string with that information
my $cmd = "df --portability --all --human-readable $try";
my $line = qx ($cmd);
my $status = $?;
if ($status == 0) {
my @lines = split ('\n', $line);
my ($device, $junk, $mountpoint);
# $lines[0] is the df header.
# Example string for split - we want the first and last elements:
# C:\jprt\products\P1\MinGW\msys\1.0 200G 78G 123G 39% /usr
($device, $junk, $junk, $junk, $junk, $mountpoint) = split (/\s+/, $lines[1]);
# Replace $mountpoint with $device/ in the original string
$try =~ s|$mountpoint|$device/|;
} else {
printf ("Error %d from command %s\n%s\n", $status, $cmd, $line);
}
}
my $str = Win32::GetShortPathName($try);
if (!defined($str)){
# Special case #4: If the lookup did not work, loop through
# adding extensions listed in PATHEXT, looking for the first
# match.
for (split(';', $ENV{'PATHEXT'})) {
$str = Win32::GetShortPathName($try.$_);
if (defined($str)) {
last;
}
}
}
if (defined($str)){
if (!defined($opts{'d'})) {
# If not MSDOS, change C: to [/cygdrive]/c/
if ($str =~ /^(\S):(.*)$/) {
my $path1 = $1;
my $path2 = $2;
$str = $path0 . '/' . $path1 . '/' . $path2;
}
}
push (@pieces, $str);
}
}
# If input was a PATH, join the pieces back together with $sep2 path
# separator.
my $result;
if (scalar(@pieces > 1)) {
$result = join ($sep2, @pieces);
} else {
$result = $pieces[0];
}
if (defined ($result)) {
# Change all '\' to '/'
$result =~ s/\\/\//g;
# Remove duplicate '/'
$result =~ s/\/\//\//g;
# Map to lower case
$result =~ tr/A-Z/a-z/;
print ("$result\n");
}

153
make/scripts/vsvars.sh
View File

@ -1,7 +1,7 @@
#!/bin/sh
#
# Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
# Copyright (c) 2009, 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
@ -27,22 +27,6 @@
# variables normally set by the vcvars32.bat or vcvars64.bat file or
# SetEnv.cmd for older SDKs.
# Use cygpath?
isCygwin="`uname -s | grep CYGWIN`"
if [ "${isCygwin}" != "" ] ; then
cygpath="/usr/bin/cygpath"
cygpath_short="${cygpath} -m -s"
cygpath_windows="${cygpath} -w -s"
cygpath_path="${cygpath} -p"
pathsep=':'
else
cygpath="dosname"
cygpath_short="${cygpath} -s"
cygpath_windows="${cygpath} -s"
cygpath_path="echo"
pathsep=';'
fi
########################################################################
# Error functions
msg() # message
@ -60,8 +44,8 @@ warning() # message
}
envpath() # path
{
if [ "${cygpath_short}" != "" -a -d "$1" ] ; then
${cygpath_short} "$1"
if [ "${fixpath}" != "" -a -d "$1" ] ; then
${fixpath} "$1"
else
echo "$1"
fi
@ -72,14 +56,65 @@ envpath() # path
# Defaults settings
debug="false"
verbose="false"
shellStyle="sh"
parentCsh="` ps -p ${PPID} 2> /dev/null | grep csh `"
if [ "${parentCsh}" != "" ] ; then
shellStyle="csh"
fi
set -e
CYGWIN="nodosfilewarning ntsec"
export CYGWIN
# pathsepIn is always ; because the input strings are coming from
# vcvarsxx.bat. This is true under all of MKS, Cygwin, MINGW/msys
pathsepIn=';'
OS="`uname -s`"
case "${OS}" in
CYGWIN*)
pathflag='-c'
devnull=/dev/null
pathsepOut=':'
;;
MINGW*)
pathflag='-m'
devnull=/dev/null
pathsepOut=':'
;;
*)
# MKS?
# Continue using dosname -s
pathflag='-s'
fixpath="dosname ${pathflag}"
fixpath_windows="${fixpath}"
fixpath_path="echo"
devnull=NUL
pathsepOut=';'
;;
esac
case "${OS}" in
CYGWIN*|MINGW*)
t=`dirname ${0}`
wd=`cd ${t} 2> ${devnull} && pwd`
fixpath_script="${wd}/fixpath.pl"
if [ ! -f "${fixpath_script}" ] ; then
error "Does not exist: ${fixpath_script}"
fi
fixpath="perl ${fixpath_script} ${pathflag}"
fixpath_windows="perl ${fixpath_script} -d"
fixpath_path="${fixpath_windows}"
;;
esac
shellStyle="sh"
## As far as I can tell from hg history, this has not worked
## for a long time because PPID is unset. When run under Cygwin
## the script quits due to the 1 return from grep.
##parentCsh="` ps -p ${PPID} 2> ${devnull} | grep csh `"
##if [ "${parentCsh}" != "" ] ; then
## shellStyle="csh"
##fi
# Check environment first
if [ "${PROGRAMFILES}" != "" ] ; then
progfiles=`envpath "${PROGRAMFILES}"`
@ -96,15 +131,19 @@ fi
# Arch data model
if [ "${PROCESSOR_IDENTIFIER}" != "" ] ; then
arch=`echo "${PROCESSOR_IDENTIFIER}" | cut -d' ' -f1`
elif [ "${MACHTYPE}" != "" ] ; then
if [ "`echo ${MACHTYPE} | grep 64`" != "" ] ; then
# Assume this is X64, not IA64
arch="x64"
else
arch="x86"
fi
else
arch="`uname -m`"
if [ "${MACHTYPE}" != "" ] ; then
if [ "`echo ${MACHTYPE} | grep 64`" != "" ] ; then
# Assume this is X64, not IA64
arch="x64"
else
arch="x86"
fi
else
arch="`uname -m`"
fi
PROCESSOR_IDENTIFIER="${arch}"
export PROCESSOR_IDENTIFIER
fi
if [ "${arch}" = "X86" -o \
"${arch}" = "386" -o "${arch}" = "i386" -o \
@ -121,11 +160,11 @@ if [ "${arch}" = "X64" -o \
"${arch}" = "intel64" -o "${arch}" = "Intel64" -o \
"${arch}" = "64" ] ; then
arch="x64"
binarch64="/amd64"
binarch64="\\amd64"
fi
if [ "${arch}" = "IA64" ] ; then
arch="ia64"
binarch64="/ia64"
binarch64="\\ia64"
fi
if [ "${arch}" != "x86" -a "${arch}" != "x64" -a "${arch}" != "ia64" ] ; then
error "No PROCESSOR_IDENTIFIER or MACHTYPE environment variables and uname -m is not helping"
@ -342,25 +381,26 @@ checkPaths() # var path sep
}
# Remove all duplicate entries
removeDeadDups() # string sep
removeDeadDups() # string sepIn sepOut
{
set -e
sep="$2"
sepIn="$2"
sepOut="$3"
pathlist="${tmp}/pathlist"
printf "%s\n" "$1" | \
sed -e 's@\\@/@g' | \
sed -e 's@//@/@g' | \
${awk} -F"${sep}" '{for(i=1;i<=NF;i++){printf "%s\n",$i;}}' \
${awk} -F"${sepIn}" '{for(i=1;i<=NF;i++){printf "%s\n",$i;}}' \
> ${pathlist}
upaths="${tmp}/upaths"
cat ${pathlist} | while read orig; do
p="${orig}"
if [ "${cygpath_short}" != "" ] ; then
if [ "${fixpath}" != "" ] ; then
if [ "${p}" != "" ] ; then
if [ -d "${p}" ] ; then
short=`${cygpath_short} "${p}"`
short=`${fixpath} "${p}"`
if [ "${short}" != "" -a -d "${short}" ] ; then
p=`${cygpath} "${short}"`
p="${short}"
fi
echo "${p}" >> ${upaths}
fi
@ -374,11 +414,11 @@ removeDeadDups() # string sep
if [ "${newpaths}" = "" ] ; then
newpaths="${i}"
else
newpaths="${newpaths}${sep}${i}"
newpaths="${newpaths}${sepOut}${i}"
fi
done
printf "%s\n" "${newpaths}" | \
${awk} -F"${sep}" \
${awk} -F"${sepOut}" \
'{a[$1];printf "%s",$1;for(i=2;i<=NF;i++){if(!($i in a)){a[$i];printf "%s%s",FS,$i;}};printf "\n";}'
}
@ -406,7 +446,7 @@ set VCINSTALLDIR=
set VSINSTALLDIR=
set WindowsSdkDir=
REM Run the vcvars bat file, send all output to stderr
call `${cygpath_windows} ${bdir}`\\${command} > `${cygpath_windows} "${stdout}"`
call `${fixpath_windows} ${bdir}`\\${command} > `${fixpath_windows} "${stdout}"`
REM Echo out env var settings
echo VS_VS71COMNTOOLS="%VS71COMNTOOLS%"
echo export VS_VS71COMNTOOLS
@ -447,9 +487,18 @@ EOF
# Create env file
createEnv() # batfile envfile
{
rm -f ${1}.stdout
cmd.exe /Q /C `${cygpath_short} $1` | \
sed -e 's@\\@/@g' | \
rm -f ${1}.stdout ${1}.temp1 ${1}.temp2
batfile=`${fixpath} ${1}`
cmd.exe -Q -C < "$batfile" 1> ${1}.temp1 2> ${1}.temp2
cat ${1}.temp1 | \
sed -e 's@^Microsoft.*@@' \
-e 's@^.*Copyright.*@@' \
-e 's@^.*>REM.*@@' \
-e 's@^.*>set.*@@' \
-e 's@^.*>echo.*@@' \
-e 's@^.*>call.*@@' \
-e 's@^.*>$@@' \
-e 's@\\@/@g' | \
sed -e 's@//@/@g' > $2
if [ -f "${1}.stdout" ] ; then
cat ${1}.stdout 1>&2
@ -485,7 +534,7 @@ printEnv() # name pname vsname val
#############################################################################
# Get Visual Studio settings
if [ "${cygpath}" != "" ] ; then
if [ "${fixpath}" != "" ] ; then
# Create bat file to run
batfile="${tmp}/vs-to-env.bat"
@ -505,11 +554,11 @@ if [ "${cygpath}" != "" ] ; then
. ${envfile}
# Derive unix style path, save old, and define new (remove dups)
VS_UPATH=`${cygpath_path} "${VS_WPATH}"`
VS_UPATH=`${fixpath_path} "${VS_WPATH}"`
export VS_UPATH
VS_OPATH=`printf "%s" "${PATH}" | sed -e 's@\\\\@/@g'`
export VS_OPATH
VS_PATH=`removeDeadDups "${VS_UPATH}${pathsep}${VS_OPATH}" "${pathsep}"`
VS_PATH=`removeDeadDups "${VS_UPATH}${pathsepIn}${VS_OPATH}" "${pathsepIn}" "${pathsepOut}"`
export VS_PATH
fi
@ -558,11 +607,13 @@ if [ "${verbose}" = "true" ] ; then
checkPaths "Windows PATH" "${VS_WPATH}" ";"
checkPaths LIB "${VS_LIB}" ";"
checkPaths INCLUDE "${VS_INCLUDE}" ";"
checkPaths PATH "${VS_PATH}" "${pathsep}"
checkPaths PATH "${VS_PATH}" "${pathsepIn}"
fi
# Remove all temp files
rm -f -r ${tmp}
if [ "${debug}" != "true" ] ; then
rm -f -r ${tmp}
fi
exit 0

10
test/Makefile
View File

@ -58,9 +58,9 @@ JDK_DEFAULT_TEST_LIST = \
jdk_io \
jdk_lang \
jdk_math \
jdk_misc \
jdk_other \
jdk_net \
jdk_nio1 jdk_nio2 jdk_nio3 \
jdk_nio \
jdk_security1 \
jdk_text \
jdk_util
@ -69,12 +69,14 @@ JDK_DEFAULT_TEST_LIST = \
JDK_NONDEFAULT_TEST_LIST = \
jdk_awt \
jdk_beans2 jdk_beans3 \
jdk_management1 jdk_management2 \
jdk_management \
jdk_jmx \
jdk_security2 jdk_security3 \
jdk_rmi \
jdk_sound \
jdk_swing \
jdk_tools1 jdk_tools2 \
jdk_tools \
jdk_jdi \
jdk_jfr
# All jdk tests