diff options
author | Jens Rehsack <rehsack@gmail.com> | 2015-12-08 14:52:51 +0100 |
---|---|---|
committer | Maxin B. John <maxin.john@intel.com> | 2015-12-08 17:43:40 +0200 |
commit | bac3b9acee5110390d15d38dacdb1622e31b2238 (patch) | |
tree | 1f39d7b8392576f19f77fb65f470391e2d15c6c1 /recipes-core/openjdk | |
parent | 04d5d0bf414c05ca59618d77f17ff9898aa1c566 (diff) | |
download | meta-java-bac3b9acee5110390d15d38dacdb1622e31b2238.tar.gz |
openjdk-8: add recipes for openjdk-8 and openjre-8
This adds openjdk-8 for native and target builds and allows a stripped
openjre-8 being built as well instead of trying to cherry-pick jre
components from jdk-image.
The recipes allow building openjdk-8 with or without:
* x11
* cups
* alsa/pulseaudio
and let packager enable unlimited-crypto, if desired.
To support certificate based java libraries, cacerts is created based on
ca-certificates from OE-core.
Since there can be only one PROVIDES for virtual/java-native and virtual/javac-native,
move the provides to openjdk-8-native (I think everyone agrees it's a better
choice than ecj-bootstrap-native).
Plus: Applying a fix from openjdk-9 repository which fixes build issues using gcc5
Signed-off-by: Jens Rehsack <sno@netbsd.org>
Signed-off-by: Maxin B. John <maxin.john@intel.com>
Diffstat (limited to 'recipes-core/openjdk')
20 files changed, 4730 insertions, 0 deletions
diff --git a/recipes-core/openjdk/openjdk-8-common.inc b/recipes-core/openjdk/openjdk-8-common.inc new file mode 100644 index 0000000..ad35488 --- /dev/null +++ b/recipes-core/openjdk/openjdk-8-common.inc | |||
@@ -0,0 +1,231 @@ | |||
1 | DESCRIPTION = "Java runtime based upon the OpenJDK Project" | ||
2 | HOMEPAGE = "http://http://openjdk.java.net/" | ||
3 | LICENSE = "GPL-2.0-with-classpath-exception" | ||
4 | |||
5 | LIC_FILES_CHKSUM = "file://LICENSE;md5=7b4baeedfe2d40cb03536573bc2c89b1" | ||
6 | |||
7 | inherit java autotools gettext qemu pkgconfig | ||
8 | |||
9 | AUTOTOOLS_SCRIPT_PATH = "${S}/common/autoconf/" | ||
10 | export AUTOCONF_DIR="${AUTOTOOLS_SCRIPT_PATH}" | ||
11 | |||
12 | FILESPATH =. "${FILE_DIRNAME}/patches-openjdk-8:" | ||
13 | |||
14 | # for weird openjdk-common.inc | ||
15 | S = "${WORKDIR}/${OPENJDK_HG_U}-${OPENJDK_CHANGESET}" | ||
16 | |||
17 | SRC_URI = " \ | ||
18 | ${OPENJDK_URI} \ | ||
19 | ${HOTSPOT_URI} \ | ||
20 | ${CORBA_URI} \ | ||
21 | ${JAXP_URI} \ | ||
22 | ${JAXWS_URI} \ | ||
23 | ${JDK_URI} \ | ||
24 | ${LANGTOOLS_URI} \ | ||
25 | ${NASHORN_URI} \ | ||
26 | file://LICENSE \ | ||
27 | ${PATCHES_URI} \ | ||
28 | " | ||
29 | |||
30 | do_unpack_extract_submodules () { | ||
31 | cd "${S}" | ||
32 | # tar --transform | ||
33 | tar xjf ${WORKDIR}/${CORBA_FILE} --transform "s,-${CORBA_CHANGESET},,g" | ||
34 | tar xjf ${WORKDIR}/${HOTSPOT_FILE} --transform "s,-${HOTSPOT_CHANGESET},,g" | ||
35 | tar xjf ${WORKDIR}/${JAXP_FILE} --transform "s,-${JAXP_CHANGESET},,g" | ||
36 | tar xjf ${WORKDIR}/${JAXWS_FILE} --transform "s,-${JAXWS_CHANGESET},,g" | ||
37 | tar xjf ${WORKDIR}/${JDK_FILE} --transform "s,-${JDK_CHANGESET},,g" | ||
38 | tar xjf ${WORKDIR}/${LANGTOOLS_FILE} --transform "s,-${LANGTOOLS_CHANGESET},,g" | ||
39 | tar xjf ${WORKDIR}/${NASHORN_FILE} --transform "s,-${NASHORN_CHANGESET},,g" | ||
40 | } | ||
41 | |||
42 | def package_config_option_cleanup(d): | ||
43 | distro_x11 = bb.utils.contains('DISTRO_FEATURES', 'x11', True, False, d) | ||
44 | distro_alsa = bb.utils.contains('DISTRO_FEATURES', 'alsa', True, False, d) | ||
45 | distro_pulseaudio = bb.utils.contains('DISTRO_FEATURES', 'pulseaudio', True, False, d) | ||
46 | |||
47 | with_x11 = bb.utils.contains('PACKAGECONFIG', 'x11', True, False, d) | ||
48 | with_cups = bb.utils.contains('PACKAGECONFIG', 'cups', True, False, d) | ||
49 | with_alsa = bb.utils.contains('PACKAGECONFIG', 'alsa', True, False, d) | ||
50 | with_pulseaudio = bb.utils.contains('PACKAGECONFIG', 'pulseaudio', True, False, d) | ||
51 | |||
52 | option_headless = bb.utils.contains('PACKAGECONFIG', 'headless', True, False, d) | ||
53 | option_headful = bb.utils.contains('PACKAGECONFIG', 'headful', True, False, d) | ||
54 | option_soundless = bb.utils.contains('PACKAGECONFIG', 'soundless', True, False, d) | ||
55 | |||
56 | if option_headless and option_headful: | ||
57 | option_headless = False | ||
58 | |||
59 | if option_headful and not with_x11: | ||
60 | with_x11 = True | ||
61 | |||
62 | if option_headful and not with_cups: | ||
63 | with_cups = True | ||
64 | |||
65 | if option_soundless and with_alsa: | ||
66 | with_alsa = False | ||
67 | |||
68 | if option_soundless and with_pulseaudio: | ||
69 | with_pulseaudio = False | ||
70 | |||
71 | if with_x11 and not distro_x11: | ||
72 | with_x11 = False | ||
73 | |||
74 | if with_alsa and not distro_alsa: | ||
75 | with_alsa = False | ||
76 | |||
77 | if with_pulseaudio and not distro_pulseaudio: | ||
78 | with_pulseaudio = False | ||
79 | |||
80 | if option_headful and not with_x11: | ||
81 | option_headful = False | ||
82 | |||
83 | if option_headful and not with_cups: | ||
84 | option_headful = False | ||
85 | |||
86 | if not option_headless and not with_x11: | ||
87 | option_headless = True | ||
88 | |||
89 | if not option_headless and not with_cups: | ||
90 | option_headless = True | ||
91 | |||
92 | if not option_soundless and not with_alsa: | ||
93 | option_soundless = True | ||
94 | |||
95 | if not option_soundless and not with_pulseaudio: | ||
96 | option_soundless = True | ||
97 | |||
98 | options = {'make': [], 'cpp': [], 'env': [], 'configure': ["--disable-ccache"] } | ||
99 | |||
100 | if option_headful: | ||
101 | options['configure'].append("--enable-headful") | ||
102 | |||
103 | if option_headless: | ||
104 | options['configure'].append("--disable-headful") | ||
105 | options['make'].append("BUILD_HEADLESS_ONLY=1") | ||
106 | options['make'].append("BUILD_HEADLESS=true") | ||
107 | options['cpp'].append("-DHEADLESS=true") | ||
108 | |||
109 | if option_soundless: | ||
110 | options['make'].append("BUILD_SOUNDLESS_ONLY=1") | ||
111 | |||
112 | if not with_x11: | ||
113 | options['make'].append("X11_NOT_NEEDED=1") | ||
114 | options['env'].append("X11_NOT_NEEDED=yes") | ||
115 | |||
116 | if not with_cups: | ||
117 | options['make'].append("CUPS_NOT_NEEDED=1") | ||
118 | options['env'].append("CUPS_NOT_NEEDED=yes") | ||
119 | |||
120 | if not with_alsa: | ||
121 | options['make'].append("ALSA_NOT_NEEDED=1") | ||
122 | options['env'].append("ALSA_NOT_NEEDED=yes") | ||
123 | |||
124 | if not with_pulseaudio: | ||
125 | options['make'].append("PULSE_NOT_NEEDED=1") | ||
126 | options['env'].append("PULSE_NOT_NEEDED=yes") | ||
127 | |||
128 | options = [ ' '.join(options['make']), ' '.join(options['cpp']), ' '.join(options['env']), ' '.join(options['configure']) ] | ||
129 | |||
130 | return options | ||
131 | |||
132 | def jdk_make_options(d): | ||
133 | options = package_config_option_cleanup(d) | ||
134 | return options[0] | ||
135 | |||
136 | def jdk_cpp_options(d): | ||
137 | options = package_config_option_cleanup(d) | ||
138 | if not options[1]: | ||
139 | return "" | ||
140 | |||
141 | return " " + options[1] | ||
142 | |||
143 | def jdk_environment_options(d): | ||
144 | options = package_config_option_cleanup(d) | ||
145 | return options[2] | ||
146 | |||
147 | def jdk_configure_options(d): | ||
148 | options = package_config_option_cleanup(d) | ||
149 | return options[3] | ||
150 | |||
151 | do_unpack[postfuncs] += "do_unpack_extract_submodules" | ||
152 | |||
153 | POST_CONFIGURE_CLEAN_X11 = "${@base_contains('PACKAGECONFIG', 'x11', '', 'rm -f jdk/src/solaris/classes/sun/awt/X11/*.java', d)}" | ||
154 | |||
155 | do_patch_openjdk8() { | ||
156 | olddir=`pwd` | ||
157 | cd "${S}" | ||
158 | ${POST_CONFIGURE_CLEAN_X11} | ||
159 | for OJ8P in ${WORKDIR}/openjdk8-*.patch; do | ||
160 | patch -p0 < ${OJ8P} | ||
161 | done | ||
162 | } | ||
163 | |||
164 | do_patch[postfuncs] += "do_patch_openjdk8" | ||
165 | |||
166 | do_configure_prepend() { | ||
167 | export ${@jdk_environment_options(d)} | ||
168 | } | ||
169 | |||
170 | # OpenJDK supports parallel compilation but uses a plain number for this. | ||
171 | # In OE we have PARALLEL_MAKE which is the actual option passed to make, | ||
172 | # e.g. "-j 4". | ||
173 | OPENJDK8_PARALLEL_MAKE := "${PARALLEL_MAKE}" | ||
174 | PARALLEL_MAKE = "" | ||
175 | def get_jdk8_native_jobs(d): | ||
176 | import bb | ||
177 | |||
178 | pm = bb.data.getVar('OPENJDK8_PARALLEL_MAKE', d, 1); | ||
179 | if not pm: | ||
180 | return "1" | ||
181 | |||
182 | pm = pm.split("j"); | ||
183 | if (len(pm) == 2): | ||
184 | return pm[1].strip() | ||
185 | |||
186 | # Whatever found in PARALLEL_MAKE was not suitable. | ||
187 | return "1" | ||
188 | |||
189 | # A function that is needed in the Shark builds. | ||
190 | def get_llvm_configure_arch(d): | ||
191 | import bb; | ||
192 | |||
193 | arch = bb.data.getVar('TRANSLATED_TARGET_ARCH', d, 1) | ||
194 | if arch == "x86-64" or arch == "i486" or arch == "i586" or arch == "i686": | ||
195 | arch = "x86" | ||
196 | elif arch == "arm": | ||
197 | arch = "arm" | ||
198 | elif arch == "mipsel" or arch == "mips": | ||
199 | arch = "mips" | ||
200 | elif arch == "powerpc" or arch == "powerpc64": | ||
201 | arch = "powerpc" | ||
202 | else: | ||
203 | bb.warn("%s does not support %s yet" % (bb.data.getVar('PN', d, 1), arch) ); | ||
204 | |||
205 | return arch | ||
206 | |||
207 | # Provides the target architecture to the configure script. | ||
208 | export LLVM_CONFIGURE_ARCH="${@get_llvm_configure_arch(d)}" | ||
209 | |||
210 | # OpenJDK uses slightly different names for certain arches. We need to know | ||
211 | # this to create some files which are expected by the build. | ||
212 | def get_jdk_arch(d): | ||
213 | import bb | ||
214 | |||
215 | jdk_arch = bb.data.getVar('TRANSLATED_TARGET_ARCH', d, 1) | ||
216 | if jdk_arch == "x86-64": | ||
217 | jdk_arch = "amd64" | ||
218 | elif jdk_arch == "powerpc": | ||
219 | jdk_arch = "ppc" | ||
220 | elif jdk_arch == "powerpc64": | ||
221 | jdk_arch = "ppc64" | ||
222 | elif (jdk_arch == "i486" or jdk_arch == "i586" or jdk_arch == "i686"): | ||
223 | jdk_arch = "i386" | ||
224 | |||
225 | return jdk_arch | ||
226 | |||
227 | JDK_ARCH = "${@get_jdk_arch(d)}" | ||
228 | |||
229 | export DEBUG_BINARIES = "true" | ||
230 | |||
231 | ALTERNATIVE_PRIORITY = "50" | ||
diff --git a/recipes-core/openjdk/openjdk-8-cross.inc b/recipes-core/openjdk/openjdk-8-cross.inc new file mode 100644 index 0000000..20ac194 --- /dev/null +++ b/recipes-core/openjdk/openjdk-8-cross.inc | |||
@@ -0,0 +1,200 @@ | |||
1 | JDKPN = "openjdk-8" | ||
2 | JREPN = "openjre-8" | ||
3 | |||
4 | JDK_HOME = "${libdir_jvm}/${JDKPN}" | ||
5 | JRE_HOME = "${libdir_jvm}/${JREPN}" | ||
6 | |||
7 | DEPENDS = "\ | ||
8 | openjdk-8-native zip-native ant-native libxslt \ | ||
9 | jpeg libpng krb5 libffi fontconfig freetype \ | ||
10 | " | ||
11 | |||
12 | PACKAGECONFIG ??= "" | ||
13 | PACKAGECONFIG[x11] = "--with-x,,libx11 xproto libxt libxext libxrender" | ||
14 | PACKAGECONFIG[cups] = "--with-cups,,cups" | ||
15 | PACKAGECONFIG[alsa] = "--with-alsa,,alsa-lib-native" | ||
16 | |||
17 | PACKAGECONFIG[jce] = "--enable-unlimited-crypto,," | ||
18 | |||
19 | PACKAGECONFIG[zip] = "--with-zlib=system,--with-zlib=bundled,zlib," | ||
20 | PACKAGECONFIG[gif] = "--with-giflib=system,--with-giflib=bundled,giflib," | ||
21 | |||
22 | export WANT_LLVM_RELEASE = "3.5.2" | ||
23 | PACKAGECONFIG[zero] = "--with-jvm-variants=zero,,," | ||
24 | PACKAGECONFIG[shark] = "--with-jvm-variants=zeroshark,,llvm3.5," | ||
25 | |||
26 | require openjdk-8-common.inc | ||
27 | |||
28 | JAVA_HOME[unexport] = "1" | ||
29 | |||
30 | SRC_URI_append = "\ | ||
31 | file://jvm.cfg \ | ||
32 | " | ||
33 | |||
34 | # do not use --wth-extra-cflags, it breaks building demos for jdk | ||
35 | # maybe disabling demos is more reasonable than avoiding --wth-extra-cflags | ||
36 | # needs discussion | ||
37 | EXTRA_OECONF_append = "\ | ||
38 | --with-jobs=${@get_jdk8_native_jobs(d)} \ | ||
39 | \ | ||
40 | --with-sys-root=${STAGING_DIR} \ | ||
41 | --with-tools-dir=${STAGING_DIR_NATIVE} \ | ||
42 | --with-boot-jdk=${STAGING_LIBDIR_NATIVE}/jvm/openjdk-8-native \ | ||
43 | --with-cacerts-file=${STAGING_LIBDIR_NATIVE}/jvm/openjdk-8-native/jre/lib/security/cacerts \ | ||
44 | \ | ||
45 | --disable-precompiled-headers \ | ||
46 | --disable-zip-debug-info \ | ||
47 | \ | ||
48 | ${@jdk_configure_options(d)} \ | ||
49 | " | ||
50 | |||
51 | do_configure_append() { | ||
52 | sed -i -e 's,POST_STRIP_CMD:=.*,POST_STRIP_CMD:=,g' ${B}/spec.gmk | ||
53 | } | ||
54 | |||
55 | export MAKE_VERBOSE = "y" | ||
56 | export MFLAGS="${@jdk_make_options(d)} MAKE_VERBOSE=y QUIETLY= VERBOSE=-s LOG_LEVEL=trace STRIP_POLICY=no_strip" | ||
57 | |||
58 | BUILD_LD="${BUILD_CCLD}" | ||
59 | |||
60 | EXTRA_OEMAKE_append = '\ | ||
61 | OE_CFLAGS="${CFLAGS}" \ | ||
62 | OE_CPPFLAGS="${CPPFLAGS}" \ | ||
63 | OE_CXXFLAGS="${CXXFLAGS}" \ | ||
64 | OE_LDFLAGS="${LDFLAGS}" \ | ||
65 | ${@jdk_make_options(d)} \ | ||
66 | ALT_SDT_H="${STAGING_INCDIR}" \ | ||
67 | ALT_CUPS_HEADERS_PATH="${STAGING_INCDIR}" \ | ||
68 | ALT_FREETYPE_HEADERS_PATH="${STAGING_INCDIR}/freetype2" \ | ||
69 | ALT_FREETYPE_LIB_PATH="${STAGING_LIBDIR}" \ | ||
70 | STRIP_POLICY=no_strip \ | ||
71 | MAKE_VERBOSE=y VERBOSE=-s LOG_LEVEL=trace \ | ||
72 | QUIETLY= \ | ||
73 | images \ | ||
74 | ' | ||
75 | |||
76 | FILES_${JREPN}_append = "\ | ||
77 | ${JRE_HOME}/bin/[a-z]* \ | ||
78 | ${JRE_HOME}/lib/[a-z]* \ | ||
79 | ${JRE_HOME}/LICENSE \ | ||
80 | ${JRE_HOME}/release \ | ||
81 | " | ||
82 | |||
83 | FILES_${JDKPN}_append = "\ | ||
84 | ${JDK_HOME}/bin/[a-z]* \ | ||
85 | ${JDK_HOME}/lib/[a-z]* \ | ||
86 | ${JDK_HOME}/jre/bin/[a-z]* \ | ||
87 | ${JDK_HOME}/jre/lib/[a-z]* \ | ||
88 | ${JDK_HOME}/LICENSE \ | ||
89 | ${JDK_HOME}/jre/LICENSE \ | ||
90 | ${JDK_HOME}/release \ | ||
91 | " | ||
92 | |||
93 | FILES_${JDKPN}-dev_append = "\ | ||
94 | ${JDK_HOME}/include \ | ||
95 | " | ||
96 | |||
97 | FILES_${JDKPN}-dbg_append = "\ | ||
98 | ${JDK_HOME}/bin/.debug/ \ | ||
99 | ${JDK_HOME}/lib/.debug/ \ | ||
100 | ${JDK_HOME}/lib/${JDK_ARCH}/.debug/ \ | ||
101 | ${JDK_HOME}/lib/${JDK_ARCH}/jli/.debug/ \ | ||
102 | ${JDK_HOME}/jre/bin/.debug/ \ | ||
103 | ${JDK_HOME}/jre/lib/.debug/ \ | ||
104 | ${JDK_HOME}/jre/lib/${JDK_ARCH}/.debug/ \ | ||
105 | ${JDK_HOME}/jre/lib/${JDK_ARCH}/jli/.debug/ \ | ||
106 | ${JDK_HOME}/jre/lib/${JDK_ARCH}/native_threads/.debug/ \ | ||
107 | ${JDK_HOME}/jre/lib/${JDK_ARCH}/server/.debug/ \ | ||
108 | ${JDK_HOME}/jre/lib/${JDK_ARCH}/headless/.debug/ \ | ||
109 | ${JDK_HOME}/jre/lib/${JDK_ARCH}/xawt/.debug/ \ | ||
110 | ${JDK_HOME}/jre/lib/${JDK_ARCH}/client/.debug/ \ | ||
111 | " | ||
112 | |||
113 | FILES_${JREPN}-dbg_append = "\ | ||
114 | ${JRE_HOME}/bin/.debug/ \ | ||
115 | ${JRE_HOME}/lib/.debug/ \ | ||
116 | ${JRE_HOME}/lib/${JDK_ARCH}/.debug/ \ | ||
117 | ${JRE_HOME}/lib/${JDK_ARCH}/jli/.debug/ \ | ||
118 | ${JRE_HOME}/lib/${JDK_ARCH}/server/.debug/ \ | ||
119 | " | ||
120 | |||
121 | FILES_${JDKPN}-demo = " ${JDK_HOME}/demo ${JDK_HOME}/sample " | ||
122 | RDEPENDS_${JDKPN}-demo = " ${JDKPN} " | ||
123 | |||
124 | FILES_${JDKPN}-demo-dbg = "\ | ||
125 | ${JDK_HOME}/demo/jvmti/gctest/lib/.debug/ \ | ||
126 | ${JDK_HOME}/demo/jvmti/heapTracker/lib/.debug/ \ | ||
127 | ${JDK_HOME}/demo/jvmti/heapViewer/lib/.debug/ \ | ||
128 | ${JDK_HOME}/demo/jvmti/hprof/lib/.debug/ \ | ||
129 | ${JDK_HOME}/demo/jvmti/minst/lib/.debug/ \ | ||
130 | ${JDK_HOME}/demo/jvmti/mtrace/lib/.debug/ \ | ||
131 | ${JDK_HOME}/demo/jvmti/versionCheck/lib/.debug/ \ | ||
132 | ${JDK_HOME}/demo/jvmti/waiters/lib/.debug/ \ | ||
133 | ${JDK_HOME}/demo/jvmti/compiledMethodLoad/lib/.debug/ \ | ||
134 | " | ||
135 | |||
136 | FILES_${JDKPN}-doc_append = "\ | ||
137 | ${JDK_HOME}/man \ | ||
138 | ${JDK_HOME}/ASSEMBLY_EXCEPTION \ | ||
139 | ${JDK_HOME}/THIRD_PARTY_README \ | ||
140 | ${JDK_HOME}/jre/ASSEMBLY_EXCEPTION \ | ||
141 | ${JDK_HOME}/jre/THIRD_PARTY_README \ | ||
142 | " | ||
143 | FILES_${JREPN}-doc_append = "\ | ||
144 | ${JRE_HOME}/man \ | ||
145 | ${JRE_HOME}/ASSEMBLY_EXCEPTION \ | ||
146 | ${JRE_HOME}/THIRD_PARTY_README \ | ||
147 | " | ||
148 | |||
149 | FILES_${JDKPN}-source = " ${JDK_HOME}/src.zip " | ||
150 | |||
151 | # Even though a vm is a hard dependency it is set as RRECOMMENDS so a single vm can get uninstalled: | ||
152 | # root@beaglebone:~/java# opkg remove openjdk-7-vm-shark | ||
153 | # No packages removed. | ||
154 | # Collected errors: | ||
155 | # * print_dependents_warning: Package openjdk-7-vm-shark is depended upon by packages: | ||
156 | # * print_dependents_warning: openjdk-7-java | ||
157 | # * print_dependents_warning: These might cease to work if package openjdk-7-vm-shark is removed. | ||
158 | #RRECOMMENDS_${JDKPN}-java = "java2-vm" | ||
159 | |||
160 | # There is a symlink to a .so but this one is valid. | ||
161 | INSANE_SKIP_${JDKPN}-common = "dev-so" | ||
162 | |||
163 | FILES_${JDKPN}-doc_append = "${JDK_HOME}/man" | ||
164 | |||
165 | do_compile_append() { | ||
166 | find ${B}/images/j2sdk-image -name "*.jar" -print0 | \ | ||
167 | xargs -0 -n1 ${STAGING_LIBDIR_NATIVE}/jvm/openjdk-8-native/bin/pack200 --repack --effort=9 --segment-limit=-1 --modification-time=latest | ||
168 | find ${B}/images/j2re-image -name "*.jar" -print0 | \ | ||
169 | xargs -0 -n1 ${STAGING_LIBDIR_NATIVE}/jvm/openjdk-8-native/bin/pack200 --repack --effort=9 --segment-limit=-1 --modification-time=latest --strip-debug | ||
170 | } | ||
171 | |||
172 | do_install_jdk() { | ||
173 | rm -rf ${D}${JDK_HOME} | ||
174 | mkdir -p ${D}${JDK_HOME} | ||
175 | cp -rp ${B}/images/j2sdk-image/* ${D}${JDK_HOME} | ||
176 | install -m644 ${WORKDIR}/jvm.cfg ${D}${JDK_HOME}/jre/lib/${JDK_ARCH}/ | ||
177 | find ${D}${JDK_HOME} -name "*.debuginfo" -print0 | xargs -0 rm | ||
178 | } | ||
179 | |||
180 | do_install_jre() { | ||
181 | rm -rf ${D}${JRE_HOME} | ||
182 | mkdir -p ${D}${JRE_HOME} | ||
183 | cp -rp ${B}/images/j2re-image/* ${D}${JRE_HOME} | ||
184 | install -m644 ${WORKDIR}/jvm.cfg ${D}${JRE_HOME}/lib/${JDK_ARCH}/ | ||
185 | find ${D}${JRE_HOME} -name "*.debuginfo" -print0 | xargs -0 rm | ||
186 | } | ||
187 | |||
188 | inherit update-alternatives | ||
189 | |||
190 | ALTERNATIVE_${JDKPN} = "java" | ||
191 | ALTERNATIVE_TARGET_${JDKPN} = "${JDK_HOME}/bin/java" | ||
192 | |||
193 | ALTERNATIVE_${JREPN} = "java" | ||
194 | ALTERNATIVE_TARGET_${JREPN} = "${JRE_HOME}/bin/java" | ||
195 | |||
196 | ALTERNATIVE_${JDKPN}-jdk = "javac" | ||
197 | ALTERNATIVE_TARGET_${JDKPN}-jdk = "${JDK_HOME}/bin/javac" | ||
198 | |||
199 | ALTERNATIVE_LINK_NAME[java] = "${bindir}/java" | ||
200 | ALTERNATIVE_LINK_NAME[javac] = "${bindir}/javac" | ||
diff --git a/recipes-core/openjdk/openjdk-8-native.inc b/recipes-core/openjdk/openjdk-8-native.inc new file mode 100644 index 0000000..7813ec2 --- /dev/null +++ b/recipes-core/openjdk/openjdk-8-native.inc | |||
@@ -0,0 +1,82 @@ | |||
1 | JDK_DIR = "openjdk-8-native" | ||
2 | DEPENDS = "\ | ||
3 | icedtea7-native ant-native \ | ||
4 | libxslt-native attr-native \ | ||
5 | giflib-native jpeg-native libpng-native \ | ||
6 | glib-2.0-native freetype-native fontconfig-native \ | ||
7 | zlib-native zip-native \ | ||
8 | unzip-native make-native \ | ||
9 | ca-certificates-native openssl-native \ | ||
10 | " | ||
11 | |||
12 | PACKAGECONFIG ??= "" | ||
13 | PACKAGECONFIG[x11] = "--with-x,,libx11-native xproto-native libxt-native libxext-native libxrender-native" | ||
14 | PACKAGECONFIG[cups] = "--with-cups,,cups" | ||
15 | PACKAGECONFIG[alsa] = "--with-alsa,,alsa-lib-native" | ||
16 | PACKAGECONFIG[jce] = "--enable-unlimited-crypto,," | ||
17 | |||
18 | # do not use --wth-extra-cflags, it breaks building demos for jdk | ||
19 | # maybe disabling demos is more reasonable than avoiding --wth-extra-cflags | ||
20 | # needs discussion | ||
21 | EXTRA_OECONF_append = "\ | ||
22 | --with-jobs=${@get_jdk8_native_jobs(d)} \ | ||
23 | \ | ||
24 | --with-sys-root=${STAGING_DIR_NATIVE} \ | ||
25 | --with-tools-dir=${STAGING_DIR_NATIVE} \ | ||
26 | --with-boot-jdk=${STAGING_LIBDIR_NATIVE}/jvm/icedtea7-native \ | ||
27 | ${@jdk_configure_options(d)} \ | ||
28 | " | ||
29 | # --with-boot-jdk=${WORKDIR}/fake-jdk | ||
30 | |||
31 | inherit native | ||
32 | |||
33 | require openjdk-8-common.inc | ||
34 | |||
35 | CFLAGS_append = "${@jdk_cpp_options(d)}" | ||
36 | CPPFLAGS_append = "${@jdk_cpp_options(d)}" | ||
37 | CXXFLAGS_append = "${@jdk_cpp_options(d)}" | ||
38 | |||
39 | export MAKE_VERBOSE = "y" | ||
40 | export MFLAGS="${@jdk_make_options(d)} MAKE_VERBOSE=y QUIETLY= VERBOSE=-s LOG_LEVEL=trace" | ||
41 | |||
42 | EXTRA_OEMAKE_append = ' \ | ||
43 | OE_CFLAGS="${CFLAGS}" \ | ||
44 | OE_CPPFLAGS="${CPPFLAGS}" \ | ||
45 | OE_CXXFLAGS="${CXXFLAGS}" \ | ||
46 | OE_LDFLAGS="${LDFLAGS}" \ | ||
47 | ${@jdk_make_options(d)} \ | ||
48 | MAKE_VERBOSE=y VERBOSE=-s LOG_LEVEL=trace \ | ||
49 | QUIETLY= \ | ||
50 | images \ | ||
51 | ' | ||
52 | |||
53 | do_compile_append() { | ||
54 | set -x | ||
55 | mkdir -p ${B}/certs | ||
56 | for pem in $(find ${STAGING_DATADIR}/ca-certificates -name "*.crt") | ||
57 | do | ||
58 | bp=`basename ${pem}` | ||
59 | alias=`echo ${bp} | sed -e 's,\.[^.]*$,,'` | ||
60 | md5a=`echo ${alias} | md5sum | awk '{print $1}'` | ||
61 | der=`echo ${bp} | sed -e 's,crt$,der,'` | ||
62 | openssl x509 -in "${pem}" -inform pem -out "${B}/certs/${md5a}.der" -outform der | ||
63 | ${B}/images/j2sdk-image/bin/keytool -importcert -noprompt -storepass changeit \ | ||
64 | -keystore "${B}/images/j2sdk-image/jre/lib/security/cacerts" \ | ||
65 | -alias "${alias}" -file "${B}/certs/${md5a}.der" | ||
66 | done | ||
67 | set +x | ||
68 | } | ||
69 | |||
70 | do_install() { | ||
71 | rm -rf ${STAGING_LIBDIR_NATIVE}/jvm/${JDK_DIR} | ||
72 | mkdir -p ${STAGING_LIBDIR_NATIVE}/jvm/${JDK_DIR} | ||
73 | cp -rp ${B}/images/j2sdk-image/* ${STAGING_LIBDIR_NATIVE}/jvm/${JDK_DIR} | ||
74 | |||
75 | # clean up the mess from bootstrap | ||
76 | for tool in jar java javac keytool pack200 unpack200 | ||
77 | do | ||
78 | rm -f ${STAGING_BINDIR_NATIVE}/$tool | ||
79 | |||
80 | ln -sf "../lib/jvm/${JDK_DIR}/bin/$tool" ${STAGING_BINDIR_NATIVE}/$tool | ||
81 | done | ||
82 | } | ||
diff --git a/recipes-core/openjdk/openjdk-8-native_72b05.bb b/recipes-core/openjdk/openjdk-8-native_72b05.bb new file mode 100644 index 0000000..6eb40eb --- /dev/null +++ b/recipes-core/openjdk/openjdk-8-native_72b05.bb | |||
@@ -0,0 +1,28 @@ | |||
1 | require openjdk-8-release-72b05.inc | ||
2 | require openjdk-8-native.inc | ||
3 | |||
4 | PROVIDES = "virtual/java-native virtual/javac-native" | ||
5 | |||
6 | inherit update-alternatives | ||
7 | |||
8 | ALTERNATIVE_${PN} = "java javac jar pack200 unpack200 keytool" | ||
9 | ALTERNATIVE_LINK[java] = "${bindir}/java" | ||
10 | ALTERNATIVE_TARGET[java] = "${JDK_HOME}/bin/java" | ||
11 | ALTERNATIVE_PRIORITY[java] = "100" | ||
12 | ALTERNATIVE_LINK[javac] = "${bindir}/javac" | ||
13 | ALTERNATIVE_TARGET[javac] = "${JDK_HOME}/bin/javac" | ||
14 | ALTERNATIVE_PRIORITY[javac] = "100" | ||
15 | ALTERNATIVE_LINK[jar] = "${bindir}/jar" | ||
16 | ALTERNATIVE_TARGET[jar] = "${JDK_HOME}/bin/jar" | ||
17 | ALTERNATIVE_PRIORITY[jar] = "100" | ||
18 | ALTERNATIVE_LINK[pack200] = "${bindir}/pack200" | ||
19 | ALTERNATIVE_TARGET[pack200] = "${JDK_HOME}/bin/pack200" | ||
20 | ALTERNATIVE_PRIORITY[pack200] = "100" | ||
21 | ALTERNATIVE_LINK[unpack200] = "${bindir}/unpack200" | ||
22 | ALTERNATIVE_TARGET[unpack200] = "${JDK_HOME}/bin/unpack200" | ||
23 | ALTERNATIVE_PRIORITY[unpack200] = "100" | ||
24 | ALTERNATIVE_LINK[keytool] = "${bindir}/keytool" | ||
25 | ALTERNATIVE_TARGET[keytool] = "${JDK_HOME}/bin/keytool" | ||
26 | ALTERNATIVE_PRIORITY[keytool] = "100" | ||
27 | |||
28 | # PR = "${INC_PR}.1" | ||
diff --git a/recipes-core/openjdk/openjdk-8-release-72b05.inc b/recipes-core/openjdk/openjdk-8-release-72b05.inc new file mode 100644 index 0000000..4f9580e --- /dev/null +++ b/recipes-core/openjdk/openjdk-8-release-72b05.inc | |||
@@ -0,0 +1,87 @@ | |||
1 | PATCHES_URI="\ | ||
2 | file://remove-shell-variables-from-autoheader.patch;striplevel=0 \ | ||
3 | file://filter-aclocal-copy-too.patch;striplevel=0 \ | ||
4 | file://dont-expect-fqpn-for-make.patch;striplevel=0 \ | ||
5 | file://openjdk8-no-genx11-in-headless.patch;apply=no \ | ||
6 | file://openjdk8-no-unused-deps.patch;apply=no \ | ||
7 | file://openjdk8-find-compiler-fix-env-respect.patch;apply=no \ | ||
8 | file://openjdk8-prevent-debuginfo-in-favour-of-openembedded-package-split.patch;apply=no \ | ||
9 | " | ||
10 | |||
11 | # Name of the directory containing the compiled output | ||
12 | BUILD_DIR = "openjdk.build" | ||
13 | BUILD_DIR_ECJ = "openjdk.build-ecj" | ||
14 | |||
15 | # Force arm mode for now | ||
16 | ARM_INSTRUCTION_SET_armv4t = "ARM" | ||
17 | |||
18 | CORBA_CHANGESET = "7deeb4f70404" | ||
19 | SRC_URI[corba.md5sum] = "544b4963d14fb7155b12dbc56d058649" | ||
20 | SRC_URI[corba.sha256sum] = "a75c31706f634585baf0d0a0b20e321ac634d41d6afb62bd6ffb1f9c0b766d09" | ||
21 | |||
22 | HOTSPOT_CHANGESET = "d7b01fb81aa8" | ||
23 | SRC_URI[hotspot.md5sum] = "9a94802c1179faedf06d65d2f6fcc6c7" | ||
24 | SRC_URI[hotspot.sha256sum] = "5dacf0b9c86aa78061ca87c9ade1708b56deba35e2e559dcf9dbc50d85ba3ace" | ||
25 | |||
26 | JAXP_CHANGESET = "acbcb6682c9b" | ||
27 | SRC_URI[jaxp.md5sum] = "34b6700d03a0e2f13a272b4121536544" | ||
28 | SRC_URI[jaxp.sha256sum] = "b6b60e174c3d980773dd56e0a2e7cacc26b05e401f6a08a1ffef594b6166865a" | ||
29 | |||
30 | JAXWS_CHANGESET = "6aba0f814a15" | ||
31 | SRC_URI[jaxws.md5sum] = "bad8a6e540dca0889d5c0edef47fe6ca" | ||
32 | SRC_URI[jaxws.sha256sum] = "ae57bb090ec2c5338c6f740dbfd20a92f52e60379b764c4bc874464c5955b375" | ||
33 | |||
34 | JDK_CHANGESET = "39baa472e20c" | ||
35 | SRC_URI[jdk.md5sum] = "746e4d38fa3d31a22239d160688ed447" | ||
36 | SRC_URI[jdk.sha256sum] = "e3587fa57eec72c561f0695723649a745966bb2a74803ff8a451b80fd2079f99" | ||
37 | |||
38 | LANGTOOLS_CHANGESET = "10ffafaf5340" | ||
39 | SRC_URI[langtools.md5sum] = "4562acae958cc9b9f68300d5c2e6feb3" | ||
40 | SRC_URI[langtools.sha256sum] = "5d14b666fbc6ee93d60c6a135eb8163a95ca5de96d390894e0c0b59719cf7fe4" | ||
41 | |||
42 | NASHORN_CHANGESET = "9ff5c2181333" | ||
43 | SRC_URI[nashorn.md5sum] = "c6d234d73ab4d95072b7600b731bbfff" | ||
44 | SRC_URI[nashorn.sha256sum] = "f56ee0bc65c8f4954bbec0e777c0158a44dc4b744407991a96f6627be433807d" | ||
45 | |||
46 | OPENJDK_CHANGESET = "e8bed1496ff2" | ||
47 | SRC_URI[openjdk.md5sum] = "182992a90cbe209b34142f934319704b" | ||
48 | SRC_URI[openjdk.sha256sum] = "d835a9adcf766e68d5a73fb36040d9e35b36c0363c883b8f05560c49bb22bf0c" | ||
49 | |||
50 | OPENJDK_HG_U = "jdk8u" | ||
51 | OPENJDK_HG_URL = "http://hg.openjdk.java.net/jdk8u/${OPENJDK_HG_U}" | ||
52 | |||
53 | OPENJDK_FILE = "${OPENJDK_CHANGESET}.tar.bz2" | ||
54 | OPENJDK_URI = "${OPENJDK_HG_URL}/archive/${OPENJDK_FILE};name=openjdk" | ||
55 | |||
56 | HOTSPOT_FILE = "${HOTSPOT_CHANGESET}.tar.bz2" | ||
57 | HOTSPOT_URI = "${OPENJDK_HG_URL}/hotspot/archive/${HOTSPOT_FILE};name=hotspot;unpack=false" | ||
58 | |||
59 | CORBA_FILE = "${CORBA_CHANGESET}.tar.bz2" | ||
60 | CORBA_URI = "${OPENJDK_HG_URL}/corba/archive/${CORBA_FILE};name=corba;unpack=false" | ||
61 | |||
62 | JAXP_FILE = "${JAXP_CHANGESET}.tar.bz2" | ||
63 | JAXP_URI = "${OPENJDK_HG_URL}/jaxp/archive/${JAXP_FILE};name=jaxp;unpack=false" | ||
64 | |||
65 | JAXWS_FILE = "${JAXWS_CHANGESET}.tar.bz2" | ||
66 | JAXWS_URI = "${OPENJDK_HG_URL}/jaxws/archive/${JAXWS_FILE};name=jaxws;unpack=false" | ||
67 | |||
68 | JDK_FILE = "${JDK_CHANGESET}.tar.bz2" | ||
69 | JDK_URI = "${OPENJDK_HG_URL}/jdk/archive/${JDK_FILE};name=jdk;unpack=false" | ||
70 | |||
71 | LANGTOOLS_FILE = "${LANGTOOLS_CHANGESET}.tar.bz2" | ||
72 | LANGTOOLS_URI = "${OPENJDK_HG_URL}/langtools/archive/${LANGTOOLS_FILE};name=langtools;unpack=false" | ||
73 | |||
74 | NASHORN_FILE = "${NASHORN_CHANGESET}.tar.bz2" | ||
75 | NASHORN_URI = "${OPENJDK_HG_URL}/nashorn/archive/${NASHORN_FILE};name=nashorn;unpack=false" | ||
76 | # | ||
77 | #CACAO_VERSION = "e215e36be9fc" | ||
78 | #CACAO_FILE = "${CACAO_VERSION}.tar.gz" | ||
79 | #CACAO_URI = "http://icedtea.wildebeest.org/download/drops/cacao/${CACAO_FILE};name=cacao;unpack=false" | ||
80 | #SRC_URI[cacao.md5sum] = "79f95f0aea4ba04cf2f1a8632ac66d14" | ||
81 | #SRC_URI[cacao.sha256sum] = "4966514c72ee7ed108b882d9b6e65c3adf8a8f9c2dccb029f971b3c8cb4870ab" | ||
82 | # | ||
83 | #JAMVM_VERSION = "ec18fb9e49e62dce16c5094ef1527eed619463aa" | ||
84 | #JAMVM_FILE = "jamvm-${JAMVM_VERSION}.tar.gz" | ||
85 | #JAMVM_URI = "http://icedtea.wildebeest.org/download/drops/jamvm/${JAMVM_FILE};name=jamvm;unpack=false" | ||
86 | #SRC_URI[jamvm.md5sum] = "d50ae193d01a9251e10679c7a2cc6ff1" | ||
87 | #SRC_URI[jamvm.sha256sum] = "31810266666c23822942aac62a78019c2c4589e1c5ee48329cbf42652d4437bc" | ||
diff --git a/recipes-core/openjdk/openjdk-8_72b05.bb b/recipes-core/openjdk/openjdk-8_72b05.bb new file mode 100644 index 0000000..4c8899e --- /dev/null +++ b/recipes-core/openjdk/openjdk-8_72b05.bb | |||
@@ -0,0 +1,36 @@ | |||
1 | require openjdk-8-release-72b05.inc | ||
2 | require openjdk-8-cross.inc | ||
3 | |||
4 | # some patches extracted from http://cr.openjdk.java.net/~rkennke/shark-build-hotspot/webrev.01/hotspot.patch | ||
5 | # reported via http://mail.openjdk.java.net/pipermail/build-dev/2015-January/013972.html | ||
6 | # by Roman Kennke (rkennke at redhat.com) | ||
7 | PATCHES_URI_append = "\ | ||
8 | file://openjdk8-restrict-to-staging-dir.patch;apply=no \ | ||
9 | file://openjdk8-fix-shark-build.patch;apply=no \ | ||
10 | file://openjdk8-fix-shark-stdc++11.patch;apply=no \ | ||
11 | file://openjdk8-use_builtin_frame_address_0_rather_than_returning_address_of_local_variable.patch;apply=no \ | ||
12 | " | ||
13 | |||
14 | do_install() { | ||
15 | do_install_jdk | ||
16 | } | ||
17 | |||
18 | PACKAGES_append = " \ | ||
19 | ${JDKPN}-demo-dbg \ | ||
20 | ${JDKPN}-demo \ | ||
21 | ${JDKPN}-source \ | ||
22 | " | ||
23 | |||
24 | RPROVIDES_${JDKPN} = "java2-vm" | ||
25 | PROVIDES_${JDKPN} = "java2-vm" | ||
26 | RPROVIDES_${JDKPN} = "java2-runtime" | ||
27 | PROVIDES_${JDKPN} = "java2-runtime" | ||
28 | |||
29 | inherit update-alternatives | ||
30 | |||
31 | ALTERNATIVE_${PN} = "java" | ||
32 | ALTERNATIVE_LINK = "${bindir}/java" | ||
33 | ALTERNATIVE_TARGET = "${JDK_HOME}/bin/java" | ||
34 | ALTERNATIVE_PRIORITY = "100" | ||
35 | |||
36 | # PR = "${INC_PR}.1" | ||
diff --git a/recipes-core/openjdk/openjre-8_72b05.bb b/recipes-core/openjdk/openjre-8_72b05.bb new file mode 100644 index 0000000..67eb1d3 --- /dev/null +++ b/recipes-core/openjdk/openjre-8_72b05.bb | |||
@@ -0,0 +1,30 @@ | |||
1 | require openjdk-8-release-72b05.inc | ||
2 | require openjdk-8-cross.inc | ||
3 | |||
4 | # some patches extracted from http://cr.openjdk.java.net/~rkennke/shark-build-hotspot/webrev.01/hotspot.patch | ||
5 | # reported via http://mail.openjdk.java.net/pipermail/build-dev/2015-January/013972.html | ||
6 | # by Roman Kennke (rkennke at redhat.com) | ||
7 | PATCHES_URI_append = "\ | ||
8 | file://openjdk8-restrict-to-staging-dir.patch;apply=no \ | ||
9 | file://openjdk8-fix-shark-build.patch;apply=no \ | ||
10 | file://openjdk8-fix-shark-stdc++11.patch;apply=no \ | ||
11 | file://openjdk8-use_builtin_frame_address_0_rather_than_returning_address_of_local_variable.patch;apply=no \ | ||
12 | " | ||
13 | |||
14 | do_install() { | ||
15 | do_install_jre | ||
16 | } | ||
17 | |||
18 | RPROVIDES_${JREPN} = "java2-vm" | ||
19 | PROVIDES_${JREPN} = "java2-vm" | ||
20 | RPROVIDES_${JREPN} = "java2-runtime" | ||
21 | PROVIDES_${JREPN} = "java2-runtime" | ||
22 | |||
23 | inherit update-alternatives | ||
24 | |||
25 | ALTERNATIVE_${PN} = "java" | ||
26 | ALTERNATIVE_LINK = "${bindir}/java" | ||
27 | ALTERNATIVE_TARGET = "${JRE_HOME}/bin/java" | ||
28 | ALTERNATIVE_PRIORITY = "100" | ||
29 | |||
30 | # PR = "${INC_PR}.1" | ||
diff --git a/recipes-core/openjdk/patches-openjdk-8/LICENSE b/recipes-core/openjdk/patches-openjdk-8/LICENSE new file mode 100644 index 0000000..b40a0f4 --- /dev/null +++ b/recipes-core/openjdk/patches-openjdk-8/LICENSE | |||
@@ -0,0 +1,347 @@ | |||
1 | The GNU General Public License (GPL) | ||
2 | |||
3 | Version 2, June 1991 | ||
4 | |||
5 | Copyright (C) 1989, 1991 Free Software Foundation, Inc. | ||
6 | 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | ||
7 | |||
8 | Everyone is permitted to copy and distribute verbatim copies of this license | ||
9 | document, but changing it is not allowed. | ||
10 | |||
11 | Preamble | ||
12 | |||
13 | The licenses for most software are designed to take away your freedom to share | ||
14 | and change it. By contrast, the GNU General Public License is intended to | ||
15 | guarantee your freedom to share and change free software--to make sure the | ||
16 | software is free for all its users. This General Public License applies to | ||
17 | most of the Free Software Foundation's software and to any other program whose | ||
18 | authors commit to using it. (Some other Free Software Foundation software is | ||
19 | covered by the GNU Library General Public License instead.) You can apply it to | ||
20 | your programs, too. | ||
21 | |||
22 | When we speak of free software, we are referring to freedom, not price. Our | ||
23 | General Public Licenses are designed to make sure that you have the freedom to | ||
24 | distribute copies of free software (and charge for this service if you wish), | ||
25 | that you receive source code or can get it if you want it, that you can change | ||
26 | the software or use pieces of it in new free programs; and that you know you | ||
27 | can do these things. | ||
28 | |||
29 | To protect your rights, we need to make restrictions that forbid anyone to deny | ||
30 | you these rights or to ask you to surrender the rights. These restrictions | ||
31 | translate to certain responsibilities for you if you distribute copies of the | ||
32 | software, or if you modify it. | ||
33 | |||
34 | For example, if you distribute copies of such a program, whether gratis or for | ||
35 | a fee, you must give the recipients all the rights that you have. You must | ||
36 | make sure that they, too, receive or can get the source code. And you must | ||
37 | show them these terms so they know their rights. | ||
38 | |||
39 | We protect your rights with two steps: (1) copyright the software, and (2) | ||
40 | offer you this license which gives you legal permission to copy, distribute | ||
41 | and/or modify the software. | ||
42 | |||
43 | Also, for each author's protection and ours, we want to make certain that | ||
44 | everyone understands that there is no warranty for this free software. If the | ||
45 | software is modified by someone else and passed on, we want its recipients to | ||
46 | know that what they have is not the original, so that any problems introduced | ||
47 | by others will not reflect on the original authors' reputations. | ||
48 | |||
49 | Finally, any free program is threatened constantly by software patents. We | ||
50 | wish to avoid the danger that redistributors of a free program will | ||
51 | individually obtain patent licenses, in effect making the program proprietary. | ||
52 | To prevent this, we have made it clear that any patent must be licensed for | ||
53 | everyone's free use or not licensed at all. | ||
54 | |||
55 | The precise terms and conditions for copying, distribution and modification | ||
56 | follow. | ||
57 | |||
58 | TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION | ||
59 | |||
60 | 0. This License applies to any program or other work which contains a notice | ||
61 | placed by the copyright holder saying it may be distributed under the terms of | ||
62 | this General Public License. The "Program", below, refers to any such program | ||
63 | or work, and a "work based on the Program" means either the Program or any | ||
64 | derivative work under copyright law: that is to say, a work containing the | ||
65 | Program or a portion of it, either verbatim or with modifications and/or | ||
66 | translated into another language. (Hereinafter, translation is included | ||
67 | without limitation in the term "modification".) Each licensee is addressed as | ||
68 | "you". | ||
69 | |||
70 | Activities other than copying, distribution and modification are not covered by | ||
71 | this License; they are outside its scope. The act of running the Program is | ||
72 | not restricted, and the output from the Program is covered only if its contents | ||
73 | constitute a work based on the Program (independent of having been made by | ||
74 | running the Program). Whether that is true depends on what the Program does. | ||
75 | |||
76 | 1. You may copy and distribute verbatim copies of the Program's source code as | ||
77 | you receive it, in any medium, provided that you conspicuously and | ||
78 | appropriately publish on each copy an appropriate copyright notice and | ||
79 | disclaimer of warranty; keep intact all the notices that refer to this License | ||
80 | and to the absence of any warranty; and give any other recipients of the | ||
81 | Program a copy of this License along with the Program. | ||
82 | |||
83 | You may charge a fee for the physical act of transferring a copy, and you may | ||
84 | at your option offer warranty protection in exchange for a fee. | ||
85 | |||
86 | 2. You may modify your copy or copies of the Program or any portion of it, thus | ||
87 | forming a work based on the Program, and copy and distribute such modifications | ||
88 | or work under the terms of Section 1 above, provided that you also meet all of | ||
89 | these conditions: | ||
90 | |||
91 | a) You must cause the modified files to carry prominent notices stating | ||
92 | that you changed the files and the date of any change. | ||
93 | |||
94 | b) You must cause any work that you distribute or publish, that in whole or | ||
95 | in part contains or is derived from the Program or any part thereof, to be | ||
96 | licensed as a whole at no charge to all third parties under the terms of | ||
97 | this License. | ||
98 | |||
99 | c) If the modified program normally reads commands interactively when run, | ||
100 | you must cause it, when started running for such interactive use in the | ||
101 | most ordinary way, to print or display an announcement including an | ||
102 | appropriate copyright notice and a notice that there is no warranty (or | ||
103 | else, saying that you provide a warranty) and that users may redistribute | ||
104 | the program under these conditions, and telling the user how to view a copy | ||
105 | of this License. (Exception: if the Program itself is interactive but does | ||
106 | not normally print such an announcement, your work based on the Program is | ||
107 | not required to print an announcement.) | ||
108 | |||
109 | These requirements apply to the modified work as a whole. If identifiable | ||
110 | sections of that work are not derived from the Program, and can be reasonably | ||
111 | considered independent and separate works in themselves, then this License, and | ||
112 | its terms, do not apply to those sections when you distribute them as separate | ||
113 | works. But when you distribute the same sections as part of a whole which is a | ||
114 | work based on the Program, the distribution of the whole must be on the terms | ||
115 | of this License, whose permissions for other licensees extend to the entire | ||
116 | whole, and thus to each and every part regardless of who wrote it. | ||
117 | |||
118 | Thus, it is not the intent of this section to claim rights or contest your | ||
119 | rights to work written entirely by you; rather, the intent is to exercise the | ||
120 | right to control the distribution of derivative or collective works based on | ||
121 | the Program. | ||
122 | |||
123 | In addition, mere aggregation of another work not based on the Program with the | ||
124 | Program (or with a work based on the Program) on a volume of a storage or | ||
125 | distribution medium does not bring the other work under the scope of this | ||
126 | License. | ||
127 | |||
128 | 3. You may copy and distribute the Program (or a work based on it, under | ||
129 | Section 2) in object code or executable form under the terms of Sections 1 and | ||
130 | 2 above provided that you also do one of the following: | ||
131 | |||
132 | a) Accompany it with the complete corresponding machine-readable source | ||
133 | code, which must be distributed under the terms of Sections 1 and 2 above | ||
134 | on a medium customarily used for software interchange; or, | ||
135 | |||
136 | b) Accompany it with a written offer, valid for at least three years, to | ||
137 | give any third party, for a charge no more than your cost of physically | ||
138 | performing source distribution, a complete machine-readable copy of the | ||
139 | corresponding source code, to be distributed under the terms of Sections 1 | ||
140 | and 2 above on a medium customarily used for software interchange; or, | ||
141 | |||
142 | c) Accompany it with the information you received as to the offer to | ||
143 | distribute corresponding source code. (This alternative is allowed only | ||
144 | for noncommercial distribution and only if you received the program in | ||
145 | object code or executable form with such an offer, in accord with | ||
146 | Subsection b above.) | ||
147 | |||
148 | The source code for a work means the preferred form of the work for making | ||
149 | modifications to it. For an executable work, complete source code means all | ||
150 | the source code for all modules it contains, plus any associated interface | ||
151 | definition files, plus the scripts used to control compilation and installation | ||
152 | of the executable. However, as a special exception, the source code | ||
153 | distributed need not include anything that is normally distributed (in either | ||
154 | source or binary form) with the major components (compiler, kernel, and so on) | ||
155 | of the operating system on which the executable runs, unless that component | ||
156 | itself accompanies the executable. | ||
157 | |||
158 | If distribution of executable or object code is made by offering access to copy | ||
159 | from a designated place, then offering equivalent access to copy the source | ||
160 | code from the same place counts as distribution of the source code, even though | ||
161 | third parties are not compelled to copy the source along with the object code. | ||
162 | |||
163 | 4. You may not copy, modify, sublicense, or distribute the Program except as | ||
164 | expressly provided under this License. Any attempt otherwise to copy, modify, | ||
165 | sublicense or distribute the Program is void, and will automatically terminate | ||
166 | your rights under this License. However, parties who have received copies, or | ||
167 | rights, from you under this License will not have their licenses terminated so | ||
168 | long as such parties remain in full compliance. | ||
169 | |||
170 | 5. You are not required to accept this License, since you have not signed it. | ||
171 | However, nothing else grants you permission to modify or distribute the Program | ||
172 | or its derivative works. These actions are prohibited by law if you do not | ||
173 | accept this License. Therefore, by modifying or distributing the Program (or | ||
174 | any work based on the Program), you indicate your acceptance of this License to | ||
175 | do so, and all its terms and conditions for copying, distributing or modifying | ||
176 | the Program or works based on it. | ||
177 | |||
178 | 6. Each time you redistribute the Program (or any work based on the Program), | ||
179 | the recipient automatically receives a license from the original licensor to | ||
180 | copy, distribute or modify the Program subject to these terms and conditions. | ||
181 | You may not impose any further restrictions on the recipients' exercise of the | ||
182 | rights granted herein. You are not responsible for enforcing compliance by | ||
183 | third parties to this License. | ||
184 | |||
185 | 7. If, as a consequence of a court judgment or allegation of patent | ||
186 | infringement or for any other reason (not limited to patent issues), conditions | ||
187 | are imposed on you (whether by court order, agreement or otherwise) that | ||
188 | contradict the conditions of this License, they do not excuse you from the | ||
189 | conditions of this License. If you cannot distribute so as to satisfy | ||
190 | simultaneously your obligations under this License and any other pertinent | ||
191 | obligations, then as a consequence you may not distribute the Program at all. | ||
192 | For example, if a patent license would not permit royalty-free redistribution | ||
193 | of the Program by all those who receive copies directly or indirectly through | ||
194 | you, then the only way you could satisfy both it and this License would be to | ||
195 | refrain entirely from distribution of the Program. | ||
196 | |||
197 | If any portion of this section is held invalid or unenforceable under any | ||
198 | particular circumstance, the balance of the section is intended to apply and | ||
199 | the section as a whole is intended to apply in other circumstances. | ||
200 | |||
201 | It is not the purpose of this section to induce you to infringe any patents or | ||
202 | other property right claims or to contest validity of any such claims; this | ||
203 | section has the sole purpose of protecting the integrity of the free software | ||
204 | distribution system, which is implemented by public license practices. Many | ||
205 | people have made generous contributions to the wide range of software | ||
206 | distributed through that system in reliance on consistent application of that | ||
207 | system; it is up to the author/donor to decide if he or she is willing to | ||
208 | distribute software through any other system and a licensee cannot impose that | ||
209 | choice. | ||
210 | |||
211 | This section is intended to make thoroughly clear what is believed to be a | ||
212 | consequence of the rest of this License. | ||
213 | |||
214 | 8. If the distribution and/or use of the Program is restricted in certain | ||
215 | countries either by patents or by copyrighted interfaces, the original | ||
216 | copyright holder who places the Program under this License may add an explicit | ||
217 | geographical distribution limitation excluding those countries, so that | ||
218 | distribution is permitted only in or among countries not thus excluded. In | ||
219 | such case, this License incorporates the limitation as if written in the body | ||
220 | of this License. | ||
221 | |||
222 | 9. The Free Software Foundation may publish revised and/or new versions of the | ||
223 | General Public License from time to time. Such new versions will be similar in | ||
224 | spirit to the present version, but may differ in detail to address new problems | ||
225 | or concerns. | ||
226 | |||
227 | Each version is given a distinguishing version number. If the Program | ||
228 | specifies a version number of this License which applies to it and "any later | ||
229 | version", you have the option of following the terms and conditions either of | ||
230 | that version or of any later version published by the Free Software Foundation. | ||
231 | If the Program does not specify a version number of this License, you may | ||
232 | choose any version ever published by the Free Software Foundation. | ||
233 | |||
234 | 10. If you wish to incorporate parts of the Program into other free programs | ||
235 | whose distribution conditions are different, write to the author to ask for | ||
236 | permission. For software which is copyrighted by the Free Software Foundation, | ||
237 | write to the Free Software Foundation; we sometimes make exceptions for this. | ||
238 | Our decision will be guided by the two goals of preserving the free status of | ||
239 | all derivatives of our free software and of promoting the sharing and reuse of | ||
240 | software generally. | ||
241 | |||
242 | NO WARRANTY | ||
243 | |||
244 | 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR | ||
245 | THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE | ||
246 | STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE | ||
247 | PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, | ||
248 | INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND | ||
249 | FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND | ||
250 | PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, | ||
251 | YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. | ||
252 | |||
253 | 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL | ||
254 | ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE | ||
255 | PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY | ||
256 | GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR | ||
257 | INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA | ||
258 | BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A | ||
259 | FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER | ||
260 | OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. | ||
261 | |||
262 | END OF TERMS AND CONDITIONS | ||
263 | |||
264 | How to Apply These Terms to Your New Programs | ||
265 | |||
266 | If you develop a new program, and you want it to be of the greatest possible | ||
267 | use to the public, the best way to achieve this is to make it free software | ||
268 | which everyone can redistribute and change under these terms. | ||
269 | |||
270 | To do so, attach the following notices to the program. It is safest to attach | ||
271 | them to the start of each source file to most effectively convey the exclusion | ||
272 | of warranty; and each file should have at least the "copyright" line and a | ||
273 | pointer to where the full notice is found. | ||
274 | |||
275 | One line to give the program's name and a brief idea of what it does. | ||
276 | |||
277 | Copyright (C) <year> <name of author> | ||
278 | |||
279 | This program is free software; you can redistribute it and/or modify it | ||
280 | under the terms of the GNU General Public License as published by the Free | ||
281 | Software Foundation; either version 2 of the License, or (at your option) | ||
282 | any later version. | ||
283 | |||
284 | This program is distributed in the hope that it will be useful, but WITHOUT | ||
285 | ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | ||
286 | FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for | ||
287 | more details. | ||
288 | |||
289 | You should have received a copy of the GNU General Public License along | ||
290 | with this program; if not, write to the Free Software Foundation, Inc., 59 | ||
291 | Temple Place, Suite 330, Boston, MA 02111-1307 USA | ||
292 | |||
293 | Also add information on how to contact you by electronic and paper mail. | ||
294 | |||
295 | If the program is interactive, make it output a short notice like this when it | ||
296 | starts in an interactive mode: | ||
297 | |||
298 | Gnomovision version 69, Copyright (C) year name of author Gnomovision comes | ||
299 | with ABSOLUTELY NO WARRANTY; for details type 'show w'. This is free | ||
300 | software, and you are welcome to redistribute it under certain conditions; | ||
301 | type 'show c' for details. | ||
302 | |||
303 | The hypothetical commands 'show w' and 'show c' should show the appropriate | ||
304 | parts of the General Public License. Of course, the commands you use may be | ||
305 | called something other than 'show w' and 'show c'; they could even be | ||
306 | mouse-clicks or menu items--whatever suits your program. | ||
307 | |||
308 | You should also get your employer (if you work as a programmer) or your school, | ||
309 | if any, to sign a "copyright disclaimer" for the program, if necessary. Here | ||
310 | is a sample; alter the names: | ||
311 | |||
312 | Yoyodyne, Inc., hereby disclaims all copyright interest in the program | ||
313 | 'Gnomovision' (which makes passes at compilers) written by James Hacker. | ||
314 | |||
315 | signature of Ty Coon, 1 April 1989 | ||
316 | |||
317 | Ty Coon, President of Vice | ||
318 | |||
319 | This General Public License does not permit incorporating your program into | ||
320 | proprietary programs. If your program is a subroutine library, you may | ||
321 | consider it more useful to permit linking proprietary applications with the | ||
322 | library. If this is what you want to do, use the GNU Library General Public | ||
323 | License instead of this License. | ||
324 | |||
325 | |||
326 | "CLASSPATH" EXCEPTION TO THE GPL | ||
327 | |||
328 | Certain source files distributed by Oracle America and/or its affiliates are | ||
329 | subject to the following clarification and special exception to the GPL, but | ||
330 | only where Oracle has expressly included in the particular source file's header | ||
331 | the words "Oracle designates this particular file as subject to the "Classpath" | ||
332 | exception as provided by Oracle in the LICENSE file that accompanied this code." | ||
333 | |||
334 | Linking this library statically or dynamically with other modules is making | ||
335 | a combined work based on this library. Thus, the terms and conditions of | ||
336 | the GNU General Public License cover the whole combination. | ||
337 | |||
338 | As a special exception, the copyright holders of this library give you | ||
339 | permission to link this library with independent modules to produce an | ||
340 | executable, regardless of the license terms of these independent modules, | ||
341 | and to copy and distribute the resulting executable under terms of your | ||
342 | choice, provided that you also meet, for each linked independent module, | ||
343 | the terms and conditions of the license of that module. An independent | ||
344 | module is a module which is not derived from or based on this library. If | ||
345 | you modify this library, you may extend this exception to your version of | ||
346 | the library, but you are not obligated to do so. If you do not wish to do | ||
347 | so, delete this exception statement from your version. | ||
diff --git a/recipes-core/openjdk/patches-openjdk-8/dont-expect-fqpn-for-make.patch b/recipes-core/openjdk/patches-openjdk-8/dont-expect-fqpn-for-make.patch new file mode 100644 index 0000000..a8a9c1d --- /dev/null +++ b/recipes-core/openjdk/patches-openjdk-8/dont-expect-fqpn-for-make.patch | |||
@@ -0,0 +1,18 @@ | |||
1 | --- common/autoconf/basics.m4.orig 2015-08-17 19:05:13.122672019 +0200 | ||
2 | +++ common/autoconf/basics.m4 2015-08-17 19:13:01.482673782 +0200 | ||
3 | @@ -549,10 +549,12 @@ | ||
4 | # We need to find a recent version of GNU make. Especially on Solaris, this can be tricky. | ||
5 | if test "x$MAKE" != x; then | ||
6 | # User has supplied a make, test it. | ||
7 | - if test ! -f "$MAKE"; then | ||
8 | - AC_MSG_ERROR([The specified make (by MAKE=$MAKE) is not found.]) | ||
9 | + if test -a `dirname "$MAKE"` = "." -a ! -f "$MAKE"; then | ||
10 | + AC_PATH_PROGS(CHECK_MAKE, $MAKE) | ||
11 | + else | ||
12 | + CHECK_MAKE="${MAKE}" | ||
13 | fi | ||
14 | - BASIC_CHECK_MAKE_VERSION("$MAKE", [user supplied MAKE=$MAKE]) | ||
15 | + BASIC_CHECK_MAKE_VERSION("$CHECK_MAKE", [user supplied MAKE=$MAKE]) | ||
16 | if test "x$FOUND_MAKE" = x; then | ||
17 | AC_MSG_ERROR([The specified make (by MAKE=$MAKE) is not GNU make 3.81 or newer.]) | ||
18 | fi | ||
diff --git a/recipes-core/openjdk/patches-openjdk-8/filter-aclocal-copy-too.patch b/recipes-core/openjdk/patches-openjdk-8/filter-aclocal-copy-too.patch new file mode 100644 index 0000000..4679c9d --- /dev/null +++ b/recipes-core/openjdk/patches-openjdk-8/filter-aclocal-copy-too.patch | |||
@@ -0,0 +1,11 @@ | |||
1 | --- common/autoconf/basics.m4.orig 2015-08-17 18:31:50.598664481 +0200 | ||
2 | +++ common/autoconf/basics.m4 2015-08-17 18:31:57.554664507 +0200 | ||
3 | @@ -442,7 +442,7 @@ | ||
4 | files_present=`$LS $OUTPUT_ROOT` | ||
5 | # Configure has already touched config.log and confdefs.h in the current dir when this check | ||
6 | # is performed. | ||
7 | - filtered_files=`$ECHO "$files_present" | $SED -e 's/config.log//g' -e 's/confdefs.h//g' -e 's/ //g' \ | ||
8 | + filtered_files=`$ECHO "$files_present" | $SED -e 's/config.log//g' -e 's/confdefs.h//g' -e 's,aclocal-copy,,g' -e 's/ //g' \ | ||
9 | | $TR -d '\n'` | ||
10 | if test "x$filtered_files" != x; then | ||
11 | AC_MSG_NOTICE([Current directory is $CURDIR.]) | ||
diff --git a/recipes-core/openjdk/patches-openjdk-8/jvm.cfg b/recipes-core/openjdk/patches-openjdk-8/jvm.cfg new file mode 100644 index 0000000..56eebef --- /dev/null +++ b/recipes-core/openjdk/patches-openjdk-8/jvm.cfg | |||
@@ -0,0 +1,41 @@ | |||
1 | # Copyright 2003 Sun Microsystems, Inc. All Rights Reserved. | ||
2 | # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. | ||
3 | # | ||
4 | # This code is free software; you can redistribute it and/or modify it | ||
5 | # under the terms of the GNU General Public License version 2 only, as | ||
6 | # published by the Free Software Foundation. Sun designates this | ||
7 | # particular file as subject to the "Classpath" exception as provided | ||
8 | # by Sun in the LICENSE file that accompanied this code. | ||
9 | # | ||
10 | # This code is distributed in the hope that it will be useful, but WITHOUT | ||
11 | # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | ||
12 | # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | ||
13 | # version 2 for more details (a copy is included in the LICENSE file that | ||
14 | # accompanied this code). | ||
15 | # | ||
16 | # You should have received a copy of the GNU General Public License version | ||
17 | # 2 along with this work; if not, write to the Free Software Foundation, | ||
18 | # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | ||
19 | # | ||
20 | # Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, | ||
21 | # CA 95054 USA or visit www.sun.com if you need additional information or | ||
22 | # have any questions. | ||
23 | # | ||
24 | # | ||
25 | # List of JVMs that can be used as an option to java, javac, etc. | ||
26 | # Order is important -- first in this list is the default JVM. | ||
27 | # NOTE that this both this file and its format are UNSUPPORTED and | ||
28 | # WILL GO AWAY in a future release. | ||
29 | # | ||
30 | # You may also select a JVM in an arbitrary location with the | ||
31 | # "-XXaltjvm=<jvm_dir>" option, but that too is unsupported | ||
32 | # and may not be available in a future release. | ||
33 | # | ||
34 | -server ERROR | ||
35 | -client IGNORE | ||
36 | -hotspot ERROR | ||
37 | -classic WARN | ||
38 | -native ERROR | ||
39 | -green ERROR | ||
40 | -zero ALIASED_TO -server | ||
41 | -shark ERROR | ||
diff --git a/recipes-core/openjdk/patches-openjdk-8/openjdk8-find-compiler-fix-env-respect.patch b/recipes-core/openjdk/patches-openjdk-8/openjdk8-find-compiler-fix-env-respect.patch new file mode 100644 index 0000000..0750dac --- /dev/null +++ b/recipes-core/openjdk/patches-openjdk-8/openjdk8-find-compiler-fix-env-respect.patch | |||
@@ -0,0 +1,140 @@ | |||
1 | --- common/autoconf/toolchain.m4.orig 2015-08-07 20:52:38.000000000 +0200 | ||
2 | +++ common/autoconf/toolchain.m4 2015-10-27 13:57:19.708566525 +0100 | ||
3 | @@ -27,7 +27,7 @@ | ||
4 | # $2 = human readable name of compiler (C or C++) | ||
5 | AC_DEFUN([TOOLCHAIN_CHECK_COMPILER_VERSION], | ||
6 | [ | ||
7 | - COMPILER=[$]$1 | ||
8 | + COMPILER="[$]$1" | ||
9 | COMPILER_NAME=$2 | ||
10 | |||
11 | if test "x$OPENJDK_TARGET_OS" = xsolaris; then | ||
12 | @@ -123,64 +123,37 @@ | ||
13 | [ | ||
14 | COMPILER_NAME=$2 | ||
15 | |||
16 | - $1= | ||
17 | + FOUND_$1= | ||
18 | + | ||
19 | + if test "x[$]$1" != "x"; then | ||
20 | + FOUND_$1="[$]$1" | ||
21 | + fi | ||
22 | + | ||
23 | # If TOOLS_DIR is set, check for all compiler names in there first | ||
24 | # before checking the rest of the PATH. | ||
25 | - if test -n "$TOOLS_DIR"; then | ||
26 | + if test "x[$]FOUND_$1" = x -a -n "$TOOLS_DIR"; then | ||
27 | PATH_save="$PATH" | ||
28 | PATH="$TOOLS_DIR" | ||
29 | AC_PATH_PROGS(TOOLS_DIR_$1, $3) | ||
30 | - $1=$TOOLS_DIR_$1 | ||
31 | + FOUND_$1=$TOOLS_DIR_$1 | ||
32 | PATH="$PATH_save" | ||
33 | fi | ||
34 | |||
35 | # AC_PATH_PROGS can't be run multiple times with the same variable, | ||
36 | # so create a new name for this run. | ||
37 | - if test "x[$]$1" = x; then | ||
38 | + if test "x[$]FOUND_$1" = x; then | ||
39 | AC_PATH_PROGS(POTENTIAL_$1, $3) | ||
40 | - $1=$POTENTIAL_$1 | ||
41 | + FOUND_$1=$POTENTIAL_$1 | ||
42 | fi | ||
43 | |||
44 | - if test "x[$]$1" = x; then | ||
45 | + if test "x[$]FOUND_$1" = x; then | ||
46 | HELP_MSG_MISSING_DEPENDENCY([devkit]) | ||
47 | AC_MSG_ERROR([Could not find a $COMPILER_NAME compiler. $HELP_MSG]) | ||
48 | fi | ||
49 | - BASIC_FIXUP_EXECUTABLE($1) | ||
50 | - TEST_COMPILER="[$]$1" | ||
51 | - # Don't remove symbolic links on AIX because 'xlc_r' and 'xlC_r' may all be links | ||
52 | - # to 'xlc' but it is crucial that we invoke the compiler with the right name! | ||
53 | - if test "x$OPENJDK_BUILD_OS" != xaix; then | ||
54 | - AC_MSG_CHECKING([resolved symbolic links for $1]) | ||
55 | - BASIC_REMOVE_SYMBOLIC_LINKS(TEST_COMPILER) | ||
56 | - AC_MSG_RESULT([$TEST_COMPILER]) | ||
57 | - fi | ||
58 | - AC_MSG_CHECKING([if $1 is disguised ccache]) | ||
59 | - | ||
60 | - COMPILER_BASENAME=`$BASENAME "$TEST_COMPILER"` | ||
61 | - if test "x$COMPILER_BASENAME" = "xccache"; then | ||
62 | - AC_MSG_RESULT([yes, trying to find proper $COMPILER_NAME compiler]) | ||
63 | - # We /usr/lib/ccache in the path, so cc is a symlink to /usr/bin/ccache. | ||
64 | - # We want to control ccache invocation ourselves, so ignore this cc and try | ||
65 | - # searching again. | ||
66 | - | ||
67 | - # Remove the path to the fake ccache cc from the PATH | ||
68 | - RETRY_COMPILER_SAVED_PATH="$PATH" | ||
69 | - COMPILER_DIRNAME=`$DIRNAME [$]$1` | ||
70 | - PATH="`$ECHO $PATH | $SED -e "s,$COMPILER_DIRNAME,,g" -e "s,::,:,g" -e "s,^:,,g"`" | ||
71 | - | ||
72 | - # Try again looking for our compiler | ||
73 | - AC_CHECK_TOOLS(PROPER_COMPILER_$1, $3) | ||
74 | - BASIC_FIXUP_EXECUTABLE(PROPER_COMPILER_$1) | ||
75 | - PATH="$RETRY_COMPILER_SAVED_PATH" | ||
76 | - | ||
77 | - AC_MSG_CHECKING([for resolved symbolic links for $1]) | ||
78 | - BASIC_REMOVE_SYMBOLIC_LINKS(PROPER_COMPILER_$1) | ||
79 | - AC_MSG_RESULT([$PROPER_COMPILER_$1]) | ||
80 | - $1="$PROPER_COMPILER_$1" | ||
81 | - else | ||
82 | - AC_MSG_RESULT([no, keeping $1]) | ||
83 | - $1="$TEST_COMPILER" | ||
84 | - fi | ||
85 | + BASIC_FIXUP_EXECUTABLE(FOUND_$1) | ||
86 | + TEST_COMPILER="[$]FOUND_$1" | ||
87 | + | ||
88 | + $1="$TEST_COMPILER" | ||
89 | TOOLCHAIN_CHECK_COMPILER_VERSION([$1], [$COMPILER_NAME]) | ||
90 | ]) | ||
91 | |||
92 | @@ -214,12 +187,12 @@ | ||
93 | # otherwise we might pick up cross-compilers which don't use standard naming. | ||
94 | # Otherwise, we'll set the BUILD_tools to the native tools, but that'll have | ||
95 | # to wait until they are properly discovered. | ||
96 | - AC_PATH_PROGS(BUILD_CC, [cl cc gcc]) | ||
97 | - BASIC_FIXUP_EXECUTABLE(BUILD_CC) | ||
98 | - AC_PATH_PROGS(BUILD_CXX, [cl CC g++]) | ||
99 | - BASIC_FIXUP_EXECUTABLE(BUILD_CXX) | ||
100 | - AC_PATH_PROG(BUILD_LD, ld) | ||
101 | - BASIC_FIXUP_EXECUTABLE(BUILD_LD) | ||
102 | + AS_IF([test "x${BUILD_CC}" = "x"], [AC_PATH_PROGS(BUILD_CC, [cl cc gcc]) | ||
103 | + BASIC_FIXUP_EXECUTABLE(BUILD_CC)]) | ||
104 | + AS_IF([test "x${BUILD_CXX}" = "x"], [AC_PATH_PROGS(BUILD_CXX, [cl CC g++]) | ||
105 | + BASIC_FIXUP_EXECUTABLE(BUILD_CXX)]) | ||
106 | + AS_IF([test "x${BUILD_LD}" = "x"], [AC_PATH_PROG(BUILD_LD, ld) | ||
107 | + BASIC_FIXUP_EXECUTABLE(BUILD_LD)]) | ||
108 | fi | ||
109 | AC_SUBST(BUILD_CC) | ||
110 | AC_SUBST(BUILD_CXX) | ||
111 | --- common/autoconf/basics.m4.orig 2015-08-31 15:03:54.942975387 +0200 | ||
112 | +++ common/autoconf/basics.m4 2015-08-31 15:02:25.090975049 +0200 | ||
113 | @@ -171,8 +171,15 @@ | ||
114 | fi | ||
115 | fi | ||
116 | |||
117 | + # First separate the path from the arguments. This will split at the first | ||
118 | + # space. | ||
119 | + complete="[$]$1" | ||
120 | + path="${complete%% *}" | ||
121 | + tmp="$complete EOL" | ||
122 | + arguments="${tmp#* }" | ||
123 | + | ||
124 | if test "x$READLINK" != x; then | ||
125 | - $1=`$READLINK -f [$]$1` | ||
126 | + new_path=`$READLINK -f $path` | ||
127 | else | ||
128 | # Save the current directory for restoring afterwards | ||
129 | STARTDIR=$PWD | ||
130 | @@ -198,8 +205,9 @@ | ||
131 | let COUNTER=COUNTER+1 | ||
132 | done | ||
133 | cd $STARTDIR | ||
134 | - $1=$sym_link_dir/$sym_link_file | ||
135 | + new_path=$sym_link_dir/$sym_link_file | ||
136 | fi | ||
137 | + $1="$new_path ${arguments% *}" | ||
138 | fi | ||
139 | ]) | ||
140 | |||
diff --git a/recipes-core/openjdk/patches-openjdk-8/openjdk8-fix-shark-build.patch b/recipes-core/openjdk/patches-openjdk-8/openjdk8-fix-shark-build.patch new file mode 100644 index 0000000..bc1abbd --- /dev/null +++ b/recipes-core/openjdk/patches-openjdk-8/openjdk8-fix-shark-build.patch | |||
@@ -0,0 +1,453 @@ | |||
1 | --- hotspot/make/Makefile.orig 2015-08-31 19:44:44.459038814 +0200 | ||
2 | +++ hotspot/make/Makefile 2015-08-31 19:44:58.511038867 +0200 | ||
3 | @@ -525,7 +525,7 @@ | ||
4 | # Unix | ||
5 | $(EXPORT_JRE_LIB_ARCH_DIR)/%.$(LIBRARY_SUFFIX): $(SHARK_BUILD_DIR)/%.$(LIBRARY_SUFFIX) | ||
6 | $(install-file) | ||
7 | -$(EXPORT_JRE_LIB_ARCH_DIR)/%.debuginfo): $(SHARK_BUILD_DIR)/%.debuginfo | ||
8 | +$(EXPORT_JRE_LIB_ARCH_DIR)/%.debuginfo: $(SHARK_BUILD_DIR)/%.debuginfo | ||
9 | $(install-file) | ||
10 | $(EXPORT_JRE_LIB_ARCH_DIR)/%.diz: $(SHARK_BUILD_DIR)/%.diz | ||
11 | $(install-file) | ||
12 | --- hotspot/src/share/vm/ci/ciTypeFlow.cpp.orig 2015-08-31 19:45:28.611038980 +0200 | ||
13 | +++ hotspot/src/share/vm/ci/ciTypeFlow.cpp 2015-08-31 19:47:17.539039390 +0200 | ||
14 | @@ -35,7 +35,9 @@ | ||
15 | #include "interpreter/bytecode.hpp" | ||
16 | #include "interpreter/bytecodes.hpp" | ||
17 | #include "memory/allocation.inline.hpp" | ||
18 | -#include "opto/compile.hpp" | ||
19 | +#ifdef COMPILER2 | ||
20 | +#include "opto/compile.hpp" | ||
21 | #include "opto/node.hpp" | ||
22 | +#endif | ||
23 | #include "runtime/deoptimization.hpp" | ||
24 | #include "utilities/growableArray.hpp" | ||
25 | @@ -2647,6 +2649,7 @@ | ||
26 | assert (!blk->has_pre_order(), ""); | ||
27 | blk->set_next_pre_order(); | ||
28 | |||
29 | +#ifdef COMPILER2 | ||
30 | if (_next_pre_order >= (int)Compile::current()->max_node_limit() / 2) { | ||
31 | // Too many basic blocks. Bail out. | ||
32 | // This can happen when try/finally constructs are nested to depth N, | ||
33 | @@ -2656,6 +2659,7 @@ | ||
34 | record_failure("too many basic blocks"); | ||
35 | return; | ||
36 | } | ||
37 | +#endif | ||
38 | if (do_flow) { | ||
39 | flow_block(blk, temp_vector, temp_set); | ||
40 | if (failing()) return; // Watch for bailouts. | ||
41 | --- hotspot/src/share/vm/classfile/systemDictionary.cpp.orig 2015-08-31 19:50:00.367040003 +0200 | ||
42 | +++ hotspot/src/share/vm/classfile/systemDictionary.cpp 2015-08-31 19:51:28.323040334 +0200 | ||
43 | @@ -2276,6 +2276,7 @@ | ||
44 | spe = NULL; | ||
45 | // Must create lots of stuff here, but outside of the SystemDictionary lock. | ||
46 | m = Method::make_method_handle_intrinsic(iid, signature, CHECK_(empty)); | ||
47 | +#ifndef SHARK | ||
48 | if (!Arguments::is_interpreter_only()) { | ||
49 | // Generate a compiled form of the MH intrinsic. | ||
50 | AdapterHandlerLibrary::create_native_wrapper(m); | ||
51 | @@ -2285,6 +2286,7 @@ | ||
52 | "out of space in CodeCache for method handle intrinsic", empty); | ||
53 | } | ||
54 | } | ||
55 | +#endif | ||
56 | // Now grab the lock. We might have to throw away the new method, | ||
57 | // if a racing thread has managed to install one at the same time. | ||
58 | { | ||
59 | @@ -2298,9 +2300,11 @@ | ||
60 | } | ||
61 | |||
62 | assert(spe != NULL && spe->method() != NULL, ""); | ||
63 | +#ifndef SHARK | ||
64 | assert(Arguments::is_interpreter_only() || (spe->method()->has_compiled_code() && | ||
65 | spe->method()->code()->entry_point() == spe->method()->from_compiled_entry()), | ||
66 | "MH intrinsic invariant"); | ||
67 | +#endif | ||
68 | return spe->method(); | ||
69 | } | ||
70 | |||
71 | --- hotspot/src/share/vm/runtime/handles.inline.hpp.orig 2015-08-31 20:01:39.295042634 +0200 | ||
72 | +++ hotspot/src/share/vm/runtime/handles.inline.hpp 2015-08-31 20:04:31.331043282 +0200 | ||
73 | @@ -51,6 +51,12 @@ | ||
74 | } | ||
75 | #endif // ASSERT | ||
76 | |||
77 | +#ifdef SHARK | ||
78 | +#define assert_on_stack(expr) (void)(expr) | ||
79 | +#else | ||
80 | +#define assert_on_stack(expr) assert((expr), "not on stack?") | ||
81 | +#endif | ||
82 | + | ||
83 | // Constructors for metadata handles | ||
84 | #define DEF_METADATA_HANDLE_FN(name, type) \ | ||
85 | inline name##Handle::name##Handle(type* obj) : _value(obj), _thread(NULL) { \ | ||
86 | @@ -79,7 +85,7 @@ | ||
87 | } else { \ | ||
88 | _thread = Thread::current(); \ | ||
89 | } \ | ||
90 | - assert (_thread->is_in_stack((address)this), "not on stack?"); \ | ||
91 | + assert_on_stack (_thread->is_in_stack((address)this)); \ | ||
92 | _thread->metadata_handles()->push((Metadata*)_value); \ | ||
93 | } else { \ | ||
94 | _thread = NULL; \ | ||
95 | --- hotspot/src/cpu/zero/vm/entry_zero.hpp.orig 2015-08-31 20:53:40.743054385 +0200 | ||
96 | +++ hotspot/src/cpu/zero/vm/entry_zero.hpp 2015-08-31 20:53:54.459054436 +0200 | ||
97 | @@ -26,6 +26,10 @@ | ||
98 | #ifndef CPU_ZERO_VM_ENTRY_ZERO_HPP | ||
99 | #define CPU_ZERO_VM_ENTRY_ZERO_HPP | ||
100 | |||
101 | +#include "utilities/globalDefinitions.hpp" | ||
102 | +#include "utilities/exceptions.hpp" | ||
103 | +#include "interpreter/cppInterpreter.hpp" | ||
104 | + | ||
105 | class ZeroEntry { | ||
106 | public: | ||
107 | ZeroEntry() { | ||
108 | --- hotspot/src/share/vm/shark/sharkEntry.hpp.orig 2015-08-31 20:47:13.091052925 +0200 | ||
109 | +++ hotspot/src/share/vm/shark/sharkEntry.hpp 2015-08-31 20:49:42.755053489 +0200 | ||
110 | @@ -27,6 +27,7 @@ | ||
111 | #define SHARE_VM_SHARK_SHARKENTRY_HPP | ||
112 | |||
113 | #include "shark/llvmHeaders.hpp" | ||
114 | +#include "entry_zero.hpp" | ||
115 | |||
116 | class SharkContext; | ||
117 | |||
118 | --- hotspot/src/share/vm/interpreter/cppInterpreterGenerator.hpp.orig 2015-08-31 21:01:14.847056094 +0200 | ||
119 | +++ hotspot/src/share/vm/interpreter/cppInterpreterGenerator.hpp 2015-08-31 21:01:24.459056130 +0200 | ||
120 | @@ -30,6 +30,10 @@ | ||
121 | |||
122 | #ifdef CC_INTERP | ||
123 | |||
124 | +#ifdef TARGET_ARCH_zero | ||
125 | +#include "entry_zero.hpp" | ||
126 | +#endif | ||
127 | + | ||
128 | class CppInterpreterGenerator: public AbstractInterpreterGenerator { | ||
129 | protected: | ||
130 | // shared code sequences | ||
131 | --- hotspot/src/cpu/zero/vm/nativeInst_zero.cpp.orig 2015-08-31 21:07:21.643057475 +0200 | ||
132 | +++ hotspot/src/cpu/zero/vm/nativeInst_zero.cpp 2015-08-31 21:14:49.019059159 +0200 | ||
133 | @@ -26,6 +26,9 @@ | ||
134 | #include "precompiled.hpp" | ||
135 | #include "assembler_zero.inline.hpp" | ||
136 | #include "memory/resourceArea.hpp" | ||
137 | +#ifdef CC_INTERP | ||
138 | +#include "entry_zero.hpp" | ||
139 | +#endif | ||
140 | #include "nativeInst_zero.hpp" | ||
141 | #include "oops/oop.inline.hpp" | ||
142 | #include "runtime/handles.hpp" | ||
143 | --- hotspot/src/share/vm/shark/llvmHeaders.hpp.orig 2015-09-01 14:17:09.793868541 +0200 | ||
144 | +++ hotspot/src/share/vm/shark/llvmHeaders.hpp 2015-09-01 16:20:25.653868618 +0200 | ||
145 | @@ -35,7 +35,11 @@ | ||
146 | #undef DEBUG | ||
147 | #endif | ||
148 | |||
149 | +#if SHARK_LLVM_VERSION <= 34 | ||
150 | #include <llvm/Analysis/Verifier.h> | ||
151 | +#else | ||
152 | +#include <llvm-c/Analysis.h> | ||
153 | +#endif | ||
154 | #include <llvm/ExecutionEngine/ExecutionEngine.h> | ||
155 | |||
156 | // includes specific to each version | ||
157 | --- common/autoconf/libraries.m4.orig 2015-09-01 16:53:51.821868486 +0200 | ||
158 | +++ common/autoconf/libraries.m4 2015-09-01 16:55:27.653868542 +0200 | ||
159 | @@ -847,8 +847,9 @@ | ||
160 | fi | ||
161 | fi | ||
162 | done | ||
163 | - llvm_version=$("${LLVM_CONFIG}" --version | sed 's/\.//; s/svn.*//') | ||
164 | + llvm_version=$("${LLVM_CONFIG}" --version | sed 's/\.//; s/svn.*//; s/\..*$//') | ||
165 | LLVM_CFLAGS="${LLVM_CFLAGS} -DSHARK_LLVM_VERSION=${llvm_version}" | ||
166 | + AS_IF([test $llvm_version -ge 34], [LLVM_CFLAGS="${LLVM_CFLAGS} -std=gnu++11"]) | ||
167 | |||
168 | unset LLVM_LDFLAGS | ||
169 | for flag in $("${LLVM_CONFIG}" --ldflags); do | ||
170 | @@ -862,7 +862,7 @@ | ||
171 | done | ||
172 | |||
173 | unset LLVM_LIBS | ||
174 | - for flag in $("${LLVM_CONFIG}" --libs ${llvm_components}); do | ||
175 | + for flag in $("${LLVM_CONFIG}" --libs --system-libs ${llvm_components}); do | ||
176 | if echo "${flag}" | grep -q '^-l'; then | ||
177 | if test "${LLVM_LIBS}" != ""; then | ||
178 | LLVM_LIBS="${LLVM_LIBS} " | ||
179 | --- hotspot/src/share/vm/shark/sharkIntrinsics.cpp.orig 2015-09-02 16:58:17.000000000 +0200 | ||
180 | +++ hotspot/src/share/vm/shark/sharkIntrinsics.cpp 2015-09-02 17:09:26.000000000 +0200 | ||
181 | @@ -265,7 +265,11 @@ | ||
182 | "addr"); | ||
183 | |||
184 | // Perform the operation | ||
185 | +#if SHARK_LLVM_VERSION <= 34 | ||
186 | Value *result = builder()->CreateAtomicCmpXchg(addr, e, x, llvm::SequentiallyConsistent); | ||
187 | +#else | ||
188 | + Value *result = builder()->CreateAtomicCmpXchg(addr, e, x, llvm::SequentiallyConsistent, llvm::SequentiallyConsistent); | ||
189 | + #endif | ||
190 | // Push the result | ||
191 | state()->push( | ||
192 | SharkValue::create_jint( | ||
193 | --- hotspot/src/share/vm/shark/sharkRuntime.cpp.orig 2015-09-02 17:11:58.000000000 +0200 | ||
194 | +++ hotspot/src/share/vm/shark/sharkRuntime.cpp 2015-09-02 17:12:57.000000000 +0200 | ||
195 | @@ -32,6 +32,7 @@ | ||
196 | #ifdef TARGET_ARCH_zero | ||
197 | # include "stack_zero.inline.hpp" | ||
198 | #endif | ||
199 | +#include "memory/oopFactory.hpp" | ||
200 | |||
201 | using namespace llvm; | ||
202 | |||
203 | --- hotspot/src/share/vm/shark/sharkTopLevelBlock.cpp.orig 2015-09-02 17:23:07.000000000 +0200 | ||
204 | +++ hotspot/src/share/vm/shark/sharkTopLevelBlock.cpp 2015-09-02 17:43:20.000000000 +0200 | ||
205 | @@ -1732,7 +1732,11 @@ | ||
206 | heap_object = builder()->CreateIntToPtr( | ||
207 | old_top, SharkType::oop_type(), "heap_object"); | ||
208 | |||
209 | +#if SHARK_LLVM_VERSION <= 34 | ||
210 | Value *check = builder()->CreateAtomicCmpXchg(top_addr, old_top, new_top, llvm::SequentiallyConsistent); | ||
211 | +#else | ||
212 | + Value *check = builder()->CreateAtomicCmpXchg(top_addr, old_top, new_top, llvm::SequentiallyConsistent, llvm::SequentiallyConsistent); | ||
213 | +#endif | ||
214 | builder()->CreateCondBr( | ||
215 | builder()->CreateICmpEQ(old_top, check), | ||
216 | initialize, retry); | ||
217 | @@ -1933,7 +1937,11 @@ | ||
218 | |||
219 | Value *lock = builder()->CreatePtrToInt( | ||
220 | monitor_header_addr, SharkType::intptr_type()); | ||
221 | +#if SHARK_LLVM_VERSION <= 34 | ||
222 | Value *check = builder()->CreateAtomicCmpXchg(mark_addr, disp, lock, llvm::Acquire); | ||
223 | +#else | ||
224 | + Value *check = builder()->CreateAtomicCmpXchg(mark_addr, disp, lock, llvm::Acquire, llvm::Acquire); | ||
225 | +#endif | ||
226 | builder()->CreateCondBr( | ||
227 | builder()->CreateICmpEQ(disp, check), | ||
228 | acquired_fast, try_recursive); | ||
229 | @@ -2018,7 +2026,11 @@ | ||
230 | PointerType::getUnqual(SharkType::intptr_type()), | ||
231 | "mark_addr"); | ||
232 | |||
233 | +#if SHARK_LLVM_VERSION <= 34 | ||
234 | Value *check = builder()->CreateAtomicCmpXchg(mark_addr, lock, disp, llvm::Release); | ||
235 | +#else | ||
236 | + Value *check = builder()->CreateAtomicCmpXchg(mark_addr, lock, disp, llvm::Release, llvm::Monotonic); | ||
237 | +#endif | ||
238 | builder()->CreateCondBr( | ||
239 | builder()->CreateICmpEQ(lock, check), | ||
240 | released_fast, slow_path); | ||
241 | --- hotspot/src/cpu/zero/vm/interpreter_zero.cpp.orig 2015-09-14 20:13:25.539432044 +0200 | ||
242 | +++ hotspot/src/cpu/zero/vm/interpreter_zero.cpp 2015-09-14 20:13:46.107432122 +0200 | ||
243 | @@ -49,7 +49,7 @@ | ||
244 | #ifdef COMPILER1 | ||
245 | #include "c1/c1_Runtime1.hpp" | ||
246 | #endif | ||
247 | -#ifdef CC_INTERP | ||
248 | +#if defined(CC_INTERP) || defined(SHARK) | ||
249 | #include "interpreter/cppInterpreter.hpp" | ||
250 | #endif | ||
251 | |||
252 | --- hotspot/src/share/vm/shark/sharkCompiler.hpp.orig 2015-08-31 20:08:44.723044236 +0200 | ||
253 | +++ hotspot/src/share/vm/shark/sharkCompiler.hpp 2015-08-31 20:08:59.387044291 +0200 | ||
254 | @@ -40,6 +40,8 @@ | ||
255 | // Creation | ||
256 | SharkCompiler(); | ||
257 | |||
258 | + void init_llvm(); | ||
259 | + | ||
260 | // Name of this compiler | ||
261 | const char *name() { return "shark"; } | ||
262 | |||
263 | --- hotspot/src/share/vm/shark/sharkCompiler.cpp.orig 2015-09-19 12:19:21.000000000 +0200 | ||
264 | +++ hotspot/src/share/vm/shark/sharkCompiler.cpp 2015-09-19 12:27:17.000000000 +0200 | ||
265 | @@ -61,11 +61,25 @@ | ||
266 | : AbstractCompiler() { | ||
267 | // Create the lock to protect the memory manager and execution engine | ||
268 | _execution_engine_lock = new Monitor(Mutex::leaf, "SharkExecutionEngineLock"); | ||
269 | - MutexLocker locker(execution_engine_lock()); | ||
270 | + { | ||
271 | + MutexLocker locker(execution_engine_lock()); | ||
272 | + init_llvm(); | ||
273 | + } | ||
274 | + // All done | ||
275 | + set_state(initialized); | ||
276 | +} | ||
277 | |||
278 | +void SharkCompiler::init_llvm() { | ||
279 | + // with llvm 3.5, Multi-threading can only be enabled/disabled with the | ||
280 | + // compile time define LLVM_ENABLE_THREADS | ||
281 | +#if SHARK_LLVM_VERSION <= 34 | ||
282 | // Make LLVM safe for multithreading | ||
283 | if (!llvm_start_multithreaded()) | ||
284 | fatal("llvm_start_multithreaded() failed"); | ||
285 | +#else | ||
286 | + if (!llvm_is_multithreaded()) | ||
287 | + fatal("llvm_is_multithreaded() tells no multithreading support in llvm"); | ||
288 | +#endif | ||
289 | |||
290 | // Initialize the native target | ||
291 | InitializeNativeTarget(); | ||
292 | @@ -83,7 +97,7 @@ | ||
293 | // Finetune LLVM for the current host CPU. | ||
294 | StringMap<bool> Features; | ||
295 | bool gotCpuFeatures = llvm::sys::getHostCPUFeatures(Features); | ||
296 | - std::string cpu("-mcpu=" + llvm::sys::getHostCPUName()); | ||
297 | + std::string cpu("-mcpu=" + std::string(llvm::sys::getHostCPUName())); | ||
298 | |||
299 | std::vector<const char*> args; | ||
300 | args.push_back(""); // program name | ||
301 | @@ -112,6 +126,9 @@ | ||
302 | builder.setMAttrs(MAttrs); | ||
303 | builder.setJITMemoryManager(memory_manager()); | ||
304 | builder.setEngineKind(EngineKind::JIT); | ||
305 | +#if SHARK_LLVM_VERSION > 34 | ||
306 | + builder.setUseMCJIT(true); | ||
307 | +#endif | ||
308 | builder.setErrorStr(&ErrorMsg); | ||
309 | if (! fnmatch(SharkOptimizationLevel, "None", 0)) { | ||
310 | tty->print_cr("Shark optimization level set to: None"); | ||
311 | @@ -134,9 +151,10 @@ | ||
312 | } | ||
313 | |||
314 | +#if SHARK_LLVM_VERSION > 34 | ||
315 | + _native_context->execution_engine(_execution_engine); | ||
316 | + _normal_context->execution_engine(_execution_engine); | ||
317 | +#endif | ||
318 | execution_engine()->addModule(_native_context->module()); | ||
319 | - | ||
320 | - // All done | ||
321 | - set_state(initialized); | ||
322 | } | ||
323 | |||
324 | void SharkCompiler::initialize() { | ||
325 | @@ -165,7 +179,7 @@ | ||
326 | } | ||
327 | |||
328 | // Create the recorders | ||
329 | - Arena arena; | ||
330 | + Arena arena(mtCompiler); | ||
331 | env->set_oop_recorder(new OopRecorder(&arena)); | ||
332 | OopMapSet oopmaps; | ||
333 | env->set_debug_info(new DebugInformationRecorder(env->oop_recorder())); | ||
334 | @@ -268,7 +282,12 @@ | ||
335 | |||
336 | if (SharkVerifyFunction != NULL) { | ||
337 | if (!fnmatch(SharkVerifyFunction, name, 0)) { | ||
338 | +#if SHARK_LLVM_VERSION <= 34 | ||
339 | verifyFunction(*function); | ||
340 | +#else | ||
341 | + LLVMValueRef F = wrap(function); | ||
342 | + LLVMVerifyFunction(F, LLVMAbortProcessAction); | ||
343 | +#endif | ||
344 | } | ||
345 | } | ||
346 | |||
347 | @@ -298,7 +317,11 @@ | ||
348 | #endif | ||
349 | #endif // !NDEBUG | ||
350 | memory_manager()->set_entry_for_function(function, entry); | ||
351 | +#if SHARK_LLVM_VERSION <= 34 | ||
352 | code = (address) execution_engine()->getPointerToFunction(function); | ||
353 | +#else | ||
354 | + code = (address) execution_engine()->getFunctionAddress(name); | ||
355 | +#endif | ||
356 | } | ||
357 | assert(code != NULL, "code must be != NULL"); | ||
358 | entry->set_entry_point(code); | ||
359 | --- hotspot/src/share/vm/shark/sharkContext.cpp.orig 2015-09-21 11:22:51.707813194 +0200 | ||
360 | +++ hotspot/src/share/vm/shark/sharkContext.cpp 2015-09-21 13:47:56.243845961 +0200 | ||
361 | @@ -34,8 +34,13 @@ | ||
362 | using namespace llvm; | ||
363 | |||
364 | SharkContext::SharkContext(const char* name) | ||
365 | - : LLVMContext(), | ||
366 | - _free_queue(NULL) { | ||
367 | + : LLVMContext() | ||
368 | + , _free_queue(0) | ||
369 | +#if SHARK_LLVM_VERSION > 34 | ||
370 | + , _ee(0) | ||
371 | + , func_mod_map() | ||
372 | +#endif | ||
373 | +{ | ||
374 | // Create a module to build our functions into | ||
375 | _module = new Module(name, *this); | ||
376 | |||
377 | --- hotspot/src/share/vm/shark/sharkContext.hpp.orig 2015-09-21 10:58:37.195807719 +0200 | ||
378 | +++ hotspot/src/share/vm/shark/sharkContext.hpp 2015-09-21 13:50:48.459846609 +0200 | ||
379 | @@ -29,6 +29,8 @@ | ||
380 | #include "shark/llvmHeaders.hpp" | ||
381 | #include "shark/sharkCompiler.hpp" | ||
382 | |||
383 | +#include <map> | ||
384 | + | ||
385 | // The LLVMContext class allows multiple instances of LLVM to operate | ||
386 | // independently of each other in a multithreaded context. We extend | ||
387 | // this here to store things in Shark that are LLVMContext-specific. | ||
388 | @@ -41,12 +43,28 @@ | ||
389 | |||
390 | private: | ||
391 | llvm::Module* _module; | ||
392 | +#if SHARK_LLVM_VERSION > 34 | ||
393 | + llvm::ExecutionEngine *_ee; | ||
394 | + std::map<std::string, llvm::Module *> func_mod_map; | ||
395 | +#endif | ||
396 | |||
397 | public: | ||
398 | llvm::Module* module() const { | ||
399 | return _module; | ||
400 | } | ||
401 | |||
402 | +#if SHARK_LLVM_VERSION > 34 | ||
403 | + llvm::ExecutionEngine *execution_engine(llvm::ExecutionEngine *ee) { | ||
404 | + llvm::ExecutionEngine *oee = _ee; | ||
405 | + _ee = ee; | ||
406 | + return oee; | ||
407 | + } | ||
408 | + | ||
409 | + llvm::ExecutionEngine *execution_engine() const { | ||
410 | + return _ee; | ||
411 | + } | ||
412 | +#endif | ||
413 | + | ||
414 | // Get this thread's SharkContext | ||
415 | public: | ||
416 | static SharkContext& current() { | ||
417 | @@ -55,12 +73,35 @@ | ||
418 | |||
419 | // Module accessors | ||
420 | public: | ||
421 | - void add_function(llvm::Function* function) const { | ||
422 | + void add_function(llvm::Function* function) { | ||
423 | +#if SHARK_LLVM_VERSION <= 34 | ||
424 | module()->getFunctionList().push_back(function); | ||
425 | +#else | ||
426 | + // shark compiles modules, not functions | ||
427 | + std::map<std::string, llvm::Module *>::iterator i = func_mod_map.find(function->getName().str()); | ||
428 | + if(func_mod_map.end() == i) { | ||
429 | + llvm::Module *mod4fun = new llvm::Module(function->getName(), *this); | ||
430 | + func_mod_map.insert(std::pair<std::string, llvm::Module *>(function->getName().str(), mod4fun)); | ||
431 | + mod4fun->getFunctionList().push_back(function); | ||
432 | + _ee->addModule(mod4fun); | ||
433 | + } | ||
434 | +#endif | ||
435 | } | ||
436 | llvm::Constant* get_external(const char* name, | ||
437 | llvm::FunctionType* sig) { | ||
438 | + // XXX see whether we need additional module map, too | ||
439 | +#if SHARK_LLVM_VERSION <= 34 | ||
440 | return module()->getOrInsertFunction(name, sig); | ||
441 | +#else | ||
442 | + // shark compiles modules, not functions | ||
443 | + std::map<std::string, llvm::Module *>::iterator i = func_mod_map.find(name); | ||
444 | + if(func_mod_map.end() == i) { | ||
445 | + llvm::Module *mod4fun = new llvm::Module(name, *this); | ||
446 | + func_mod_map.insert(std::pair<std::string, llvm::Module *>(name, mod4fun)); | ||
447 | + mod4fun->getOrInsertFunction(name, sig); | ||
448 | + _ee->addModule(mod4fun); | ||
449 | + } | ||
450 | +#endif | ||
451 | } | ||
452 | |||
453 | // Basic types | ||
diff --git a/recipes-core/openjdk/patches-openjdk-8/openjdk8-fix-shark-stdc++11.patch b/recipes-core/openjdk/patches-openjdk-8/openjdk8-fix-shark-stdc++11.patch new file mode 100644 index 0000000..a35a1be --- /dev/null +++ b/recipes-core/openjdk/patches-openjdk-8/openjdk8-fix-shark-stdc++11.patch | |||
@@ -0,0 +1,2730 @@ | |||
1 | --- hotspot/src/share/vm/memory/cardTableModRefBS.hpp.orig 2015-09-02 09:45:31.000000000 +0200 | ||
2 | +++ hotspot/src/share/vm/memory/cardTableModRefBS.hpp 2015-09-02 09:46:59.000000000 +0200 | ||
3 | @@ -158,8 +158,8 @@ | ||
4 | // Mapping from address to card marking array entry | ||
5 | jbyte* byte_for(const void* p) const { | ||
6 | assert(_whole_heap.contains(p), | ||
7 | - err_msg("Attempt to access p = "PTR_FORMAT" out of bounds of " | ||
8 | - " card marking array's _whole_heap = ["PTR_FORMAT","PTR_FORMAT")", | ||
9 | + err_msg("Attempt to access p = " PTR_FORMAT " out of bounds of " | ||
10 | + " card marking array's _whole_heap = [" PTR_FORMAT "," PTR_FORMAT ")", | ||
11 | p2i(p), p2i(_whole_heap.start()), p2i(_whole_heap.end()))); | ||
12 | jbyte* result = &byte_map_base[uintptr_t(p) >> card_shift]; | ||
13 | assert(result >= _byte_map && result < _byte_map + _byte_map_size, | ||
14 | @@ -436,8 +436,8 @@ | ||
15 | size_t delta = pointer_delta(p, byte_map_base, sizeof(jbyte)); | ||
16 | HeapWord* result = (HeapWord*) (delta << card_shift); | ||
17 | assert(_whole_heap.contains(result), | ||
18 | - err_msg("Returning result = "PTR_FORMAT" out of bounds of " | ||
19 | - " card marking array's _whole_heap = ["PTR_FORMAT","PTR_FORMAT")", | ||
20 | + err_msg("Returning result = " PTR_FORMAT " out of bounds of " | ||
21 | + " card marking array's _whole_heap = [" PTR_FORMAT "," PTR_FORMAT ")", | ||
22 | p2i(result), p2i(_whole_heap.start()), p2i(_whole_heap.end()))); | ||
23 | return result; | ||
24 | } | ||
25 | @@ -445,8 +445,8 @@ | ||
26 | // Mapping from address to card marking array index. | ||
27 | size_t index_for(void* p) { | ||
28 | assert(_whole_heap.contains(p), | ||
29 | - err_msg("Attempt to access p = "PTR_FORMAT" out of bounds of " | ||
30 | - " card marking array's _whole_heap = ["PTR_FORMAT","PTR_FORMAT")", | ||
31 | + err_msg("Attempt to access p = " PTR_FORMAT " out of bounds of " | ||
32 | + " card marking array's _whole_heap = [" PTR_FORMAT "," PTR_FORMAT ")", | ||
33 | p2i(p), p2i(_whole_heap.start()), p2i(_whole_heap.end()))); | ||
34 | return byte_for(p) - _byte_map; | ||
35 | } | ||
36 | --- hotspot/src/share/vm/memory/generation.hpp.orig 2015-09-02 09:45:31.000000000 +0200 | ||
37 | +++ hotspot/src/share/vm/memory/generation.hpp 2015-09-02 09:47:36.000000000 +0200 | ||
38 | @@ -422,7 +422,7 @@ | ||
39 | // have to guard against non-monotonicity. | ||
40 | NOT_PRODUCT( | ||
41 | if (now < _time_of_last_gc) { | ||
42 | - warning("time warp: "INT64_FORMAT" to "INT64_FORMAT, (int64_t)_time_of_last_gc, (int64_t)now); | ||
43 | + warning("time warp: " INT64_FORMAT " to " INT64_FORMAT, (int64_t)_time_of_last_gc, (int64_t)now); | ||
44 | } | ||
45 | ) | ||
46 | return _time_of_last_gc; | ||
47 | --- hotspot/src/share/vm/memory/threadLocalAllocBuffer.inline.hpp.orig 2015-09-02 09:45:31.000000000 +0200 | ||
48 | +++ hotspot/src/share/vm/memory/threadLocalAllocBuffer.inline.hpp 2015-09-02 09:48:07.000000000 +0200 | ||
49 | @@ -94,10 +94,10 @@ | ||
50 | |||
51 | if (PrintTLAB && Verbose) { | ||
52 | Thread* thrd = myThread(); | ||
53 | - gclog_or_tty->print("TLAB: %s thread: "INTPTR_FORMAT" [id: %2d]" | ||
54 | - " obj: "SIZE_FORMAT | ||
55 | - " free: "SIZE_FORMAT | ||
56 | - " waste: "SIZE_FORMAT"\n", | ||
57 | + gclog_or_tty->print("TLAB: %s thread: " INTPTR_FORMAT " [id: %2d]" | ||
58 | + " obj: " SIZE_FORMAT | ||
59 | + " free: " SIZE_FORMAT | ||
60 | + " waste: " SIZE_FORMAT "\n", | ||
61 | "slow", p2i(thrd), thrd->osthread()->thread_id(), | ||
62 | obj_size, free(), refill_waste_limit()); | ||
63 | } | ||
64 | --- hotspot/src/share/vm/trace/traceStream.hpp.orig 2015-09-02 09:45:31.000000000 +0200 | ||
65 | +++ hotspot/src/share/vm/trace/traceStream.hpp 2015-09-02 09:49:16.000000000 +0200 | ||
66 | @@ -40,31 +40,31 @@ | ||
67 | TraceStream(outputStream& stream): _st(stream) {} | ||
68 | |||
69 | void print_val(const char* label, u1 val) { | ||
70 | - _st.print("%s = "UINT32_FORMAT, label, val); | ||
71 | + _st.print("%s = " UINT32_FORMAT, label, val); | ||
72 | } | ||
73 | |||
74 | void print_val(const char* label, u2 val) { | ||
75 | - _st.print("%s = "UINT32_FORMAT, label, val); | ||
76 | + _st.print("%s = " UINT32_FORMAT, label, val); | ||
77 | } | ||
78 | |||
79 | void print_val(const char* label, s2 val) { | ||
80 | - _st.print("%s = "INT32_FORMAT, label, val); | ||
81 | + _st.print("%s = " INT32_FORMAT, label, val); | ||
82 | } | ||
83 | |||
84 | void print_val(const char* label, u4 val) { | ||
85 | - _st.print("%s = "UINT32_FORMAT, label, val); | ||
86 | + _st.print("%s = " UINT32_FORMAT, label, val); | ||
87 | } | ||
88 | |||
89 | void print_val(const char* label, s4 val) { | ||
90 | - _st.print("%s = "INT32_FORMAT, label, val); | ||
91 | + _st.print("%s = " INT32_FORMAT, label, val); | ||
92 | } | ||
93 | |||
94 | void print_val(const char* label, u8 val) { | ||
95 | - _st.print("%s = "UINT64_FORMAT, label, val); | ||
96 | + _st.print("%s = " UINT64_FORMAT, label, val); | ||
97 | } | ||
98 | |||
99 | void print_val(const char* label, s8 val) { | ||
100 | - _st.print("%s = "INT64_FORMAT, label, (int64_t) val); | ||
101 | + _st.print("%s = " INT64_FORMAT, label, (int64_t) val); | ||
102 | } | ||
103 | |||
104 | void print_val(const char* label, bool val) { | ||
105 | --- hotspot/src/share/vm/gc_implementation/g1/heapRegionManager.inline.hpp.orig 2015-09-02 09:59:23.000000000 +0200 | ||
106 | +++ hotspot/src/share/vm/gc_implementation/g1/heapRegionManager.inline.hpp 2015-09-02 10:04:07.000000000 +0200 | ||
107 | @@ -31,9 +31,9 @@ | ||
108 | |||
109 | inline HeapRegion* HeapRegionManager::addr_to_region(HeapWord* addr) const { | ||
110 | assert(addr < heap_end(), | ||
111 | - err_msg("addr: "PTR_FORMAT" end: "PTR_FORMAT, p2i(addr), p2i(heap_end()))); | ||
112 | + err_msg("addr: " PTR_FORMAT " end: " PTR_FORMAT, p2i(addr), p2i(heap_end()))); | ||
113 | assert(addr >= heap_bottom(), | ||
114 | - err_msg("addr: "PTR_FORMAT" bottom: "PTR_FORMAT, p2i(addr), p2i(heap_bottom()))); | ||
115 | + err_msg("addr: " PTR_FORMAT " bottom: " PTR_FORMAT, p2i(addr), p2i(heap_bottom()))); | ||
116 | |||
117 | HeapRegion* hr = _regions.get_by_address(addr); | ||
118 | return hr; | ||
119 | --- hotspot/src/share/vm/gc_implementation/g1/heapRegion.inline.hpp.orig 2015-09-02 09:59:23.000000000 +0200 | ||
120 | +++ hotspot/src/share/vm/gc_implementation/g1/heapRegion.inline.hpp 2015-09-02 10:03:44.000000000 +0200 | ||
121 | @@ -112,7 +112,7 @@ | ||
122 | |||
123 | assert(ClassUnloadingWithConcurrentMark, | ||
124 | err_msg("All blocks should be objects if G1 Class Unloading isn't used. " | ||
125 | - "HR: ["PTR_FORMAT", "PTR_FORMAT", "PTR_FORMAT") " | ||
126 | + "HR: [" PTR_FORMAT ", " PTR_FORMAT ", " PTR_FORMAT ") " | ||
127 | "addr: " PTR_FORMAT, | ||
128 | p2i(bottom()), p2i(top()), p2i(end()), p2i(addr))); | ||
129 | |||
130 | --- hotspot/src/share/vm/gc_implementation/g1/heapRegion.hpp.orig 2015-09-02 09:59:23.000000000 +0200 | ||
131 | +++ hotspot/src/share/vm/gc_implementation/g1/heapRegion.hpp 2015-09-02 10:03:17.000000000 +0200 | ||
132 | @@ -52,7 +52,7 @@ | ||
133 | class HeapRegionSetBase; | ||
134 | class nmethod; | ||
135 | |||
136 | -#define HR_FORMAT "%u:(%s)["PTR_FORMAT","PTR_FORMAT","PTR_FORMAT"]" | ||
137 | +#define HR_FORMAT "%u:(%s)[" PTR_FORMAT "," PTR_FORMAT "," PTR_FORMAT "]" | ||
138 | #define HR_FORMAT_PARAMS(_hr_) \ | ||
139 | (_hr_)->hrm_index(), \ | ||
140 | (_hr_)->get_short_type_str(), \ | ||
141 | @@ -542,8 +542,8 @@ | ||
142 | void set_containing_set(HeapRegionSetBase* containing_set) { | ||
143 | assert((containing_set == NULL && _containing_set != NULL) || | ||
144 | (containing_set != NULL && _containing_set == NULL), | ||
145 | - err_msg("containing_set: "PTR_FORMAT" " | ||
146 | - "_containing_set: "PTR_FORMAT, | ||
147 | + err_msg("containing_set: " PTR_FORMAT " " | ||
148 | + "_containing_set: " PTR_FORMAT, | ||
149 | p2i(containing_set), p2i(_containing_set))); | ||
150 | |||
151 | _containing_set = containing_set; | ||
152 | --- hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.inline.hpp.orig 2015-09-02 09:59:23.000000000 +0200 | ||
153 | +++ hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.inline.hpp 2015-09-02 10:02:55.000000000 +0200 | ||
154 | @@ -46,7 +46,7 @@ | ||
155 | |||
156 | inline uint G1CollectedHeap::addr_to_region(HeapWord* addr) const { | ||
157 | assert(is_in_reserved(addr), | ||
158 | - err_msg("Cannot calculate region index for address "PTR_FORMAT" that is outside of the heap ["PTR_FORMAT", "PTR_FORMAT")", | ||
159 | + err_msg("Cannot calculate region index for address " PTR_FORMAT " that is outside of the heap [" PTR_FORMAT ", " PTR_FORMAT ")", | ||
160 | p2i(addr), p2i(_reserved.start()), p2i(_reserved.end()))); | ||
161 | return (uint)(pointer_delta(addr, _reserved.start(), sizeof(uint8_t)) >> HeapRegion::LogOfHRGrainBytes); | ||
162 | } | ||
163 | @@ -59,7 +59,7 @@ | ||
164 | inline HeapRegion* G1CollectedHeap::heap_region_containing_raw(const T addr) const { | ||
165 | assert(addr != NULL, "invariant"); | ||
166 | assert(is_in_g1_reserved((const void*) addr), | ||
167 | - err_msg("Address "PTR_FORMAT" is outside of the heap ranging from ["PTR_FORMAT" to "PTR_FORMAT")", | ||
168 | + err_msg("Address " PTR_FORMAT " is outside of the heap ranging from [" PTR_FORMAT " to " PTR_FORMAT ")", | ||
169 | p2i((void*)addr), p2i(g1_reserved().start()), p2i(g1_reserved().end()))); | ||
170 | return _hrm.addr_to_region((HeapWord*) addr); | ||
171 | } | ||
172 | --- hotspot/src/share/vm/gc_implementation/g1/g1BlockOffsetTable.inline.hpp.orig 2015-09-02 09:59:22.000000000 +0200 | ||
173 | +++ hotspot/src/share/vm/gc_implementation/g1/g1BlockOffsetTable.inline.hpp 2015-09-02 10:01:43.000000000 +0200 | ||
174 | @@ -47,15 +47,15 @@ | ||
175 | } | ||
176 | } | ||
177 | |||
178 | -#define check_index(index, msg) \ | ||
179 | - assert((index) < (_reserved.word_size() >> LogN_words), \ | ||
180 | - err_msg("%s - index: "SIZE_FORMAT", _vs.committed_size: "SIZE_FORMAT, \ | ||
181 | - msg, (index), (_reserved.word_size() >> LogN_words))); \ | ||
182 | - assert(G1CollectedHeap::heap()->is_in_exact(address_for_index_raw(index)), \ | ||
183 | - err_msg("Index "SIZE_FORMAT" corresponding to "PTR_FORMAT \ | ||
184 | - " (%u) is not in committed area.", \ | ||
185 | - (index), \ | ||
186 | - p2i(address_for_index_raw(index)), \ | ||
187 | +#define check_index(index, msg) \ | ||
188 | + assert((index) < (_reserved.word_size() >> LogN_words), \ | ||
189 | + err_msg("%s - index: " SIZE_FORMAT ", _vs.committed_size: " SIZE_FORMAT, \ | ||
190 | + msg, (index), (_reserved.word_size() >> LogN_words))); \ | ||
191 | + assert(G1CollectedHeap::heap()->is_in_exact(address_for_index_raw(index)), \ | ||
192 | + err_msg("Index " SIZE_FORMAT " corresponding to " PTR_FORMAT \ | ||
193 | + " (%u) is not in committed area.", \ | ||
194 | + (index), \ | ||
195 | + p2i(address_for_index_raw(index)), \ | ||
196 | G1CollectedHeap::heap()->addr_to_region(address_for_index_raw(index)))); | ||
197 | |||
198 | u_char G1BlockOffsetSharedArray::offset_array(size_t index) const { | ||
199 | --- hotspot/src/share/vm/gc_implementation/g1/g1Allocator.hpp.orig 2015-09-02 09:59:22.000000000 +0200 | ||
200 | +++ hotspot/src/share/vm/gc_implementation/g1/g1Allocator.hpp 2015-09-02 10:00:36.000000000 +0200 | ||
201 | @@ -78,7 +78,7 @@ | ||
202 | |||
203 | void decrease_used(size_t bytes) { | ||
204 | assert(_summary_bytes_used >= bytes, | ||
205 | - err_msg("invariant: _summary_bytes_used: "SIZE_FORMAT" should be >= bytes: "SIZE_FORMAT, | ||
206 | + err_msg("invariant: _summary_bytes_used: " SIZE_FORMAT " should be >= bytes: " SIZE_FORMAT, | ||
207 | _summary_bytes_used, bytes)); | ||
208 | _summary_bytes_used -= bytes; | ||
209 | } | ||
210 | --- hotspot/src/share/vm/gc_implementation/g1/collectionSetChooser.hpp.orig 2015-09-02 09:59:22.000000000 +0200 | ||
211 | +++ hotspot/src/share/vm/gc_implementation/g1/collectionSetChooser.hpp 2015-09-02 10:00:20.000000000 +0200 | ||
212 | @@ -92,7 +92,7 @@ | ||
213 | regions_at_put(_curr_index, NULL); | ||
214 | assert(hr->reclaimable_bytes() <= _remaining_reclaimable_bytes, | ||
215 | err_msg("remaining reclaimable bytes inconsistent " | ||
216 | - "from region: "SIZE_FORMAT" remaining: "SIZE_FORMAT, | ||
217 | + "from region: " SIZE_FORMAT " remaining: " SIZE_FORMAT, | ||
218 | hr->reclaimable_bytes(), _remaining_reclaimable_bytes)); | ||
219 | _remaining_reclaimable_bytes -= hr->reclaimable_bytes(); | ||
220 | _curr_index += 1; | ||
221 | --- hotspot/src/share/vm/compiler/compileBroker.cpp.orig 2015-09-02 10:08:43.000000000 +0200 | ||
222 | +++ hotspot/src/share/vm/compiler/compileBroker.cpp 2015-09-02 10:09:37.000000000 +0200 | ||
223 | @@ -203,7 +203,7 @@ | ||
224 | } | ||
225 | |||
226 | void log_nmethod(JavaThread* thread, nmethod* nm) { | ||
227 | - log(thread, "nmethod %d%s " INTPTR_FORMAT " code ["INTPTR_FORMAT ", " INTPTR_FORMAT "]", | ||
228 | + log(thread, "nmethod %d%s " INTPTR_FORMAT " code [" INTPTR_FORMAT ", " INTPTR_FORMAT "]", | ||
229 | nm->compile_id(), nm->is_osr_method() ? "%" : "", | ||
230 | p2i(nm), p2i(nm->code_begin()), p2i(nm->code_end())); | ||
231 | } | ||
232 | --- hotspot/src/share/vm/gc_implementation/g1/g1ErgoVerbose.hpp.orig 2015-09-02 10:08:44.000000000 +0200 | ||
233 | +++ hotspot/src/share/vm/gc_implementation/g1/g1ErgoVerbose.hpp 2015-09-02 10:09:56.000000000 +0200 | ||
234 | @@ -121,15 +121,15 @@ | ||
235 | // Single parameter format strings | ||
236 | #define ergo_format_str(_name_) ", " _name_ ": %s" | ||
237 | #define ergo_format_region(_name_) ", " _name_ ": %u regions" | ||
238 | -#define ergo_format_byte(_name_) ", " _name_ ": "SIZE_FORMAT" bytes" | ||
239 | +#define ergo_format_byte(_name_) ", " _name_ ": " SIZE_FORMAT " bytes" | ||
240 | #define ergo_format_double(_name_) ", " _name_ ": %1.2f" | ||
241 | #define ergo_format_perc(_name_) ", " _name_ ": %1.2f %%" | ||
242 | #define ergo_format_ms(_name_) ", " _name_ ": %1.2f ms" | ||
243 | -#define ergo_format_size(_name_) ", " _name_ ": "SIZE_FORMAT | ||
244 | +#define ergo_format_size(_name_) ", " _name_ ": " SIZE_FORMAT | ||
245 | |||
246 | // Double parameter format strings | ||
247 | #define ergo_format_byte_perc(_name_) \ | ||
248 | - ", " _name_ ": "SIZE_FORMAT" bytes (%1.2f %%)" | ||
249 | + ", " _name_ ": " SIZE_FORMAT " bytes (%1.2f %%)" | ||
250 | |||
251 | // Generates the format string | ||
252 | #define ergo_format(_extra_format_) \ | ||
253 | --- hotspot/src/share/vm/gc_implementation/g1/concurrentMark.inline.hpp.orig 2015-09-02 10:12:49.000000000 +0200 | ||
254 | +++ hotspot/src/share/vm/gc_implementation/g1/concurrentMark.inline.hpp 2015-09-02 10:21:24.000000000 +0200 | ||
255 | @@ -196,8 +196,8 @@ | ||
256 | assert(_bmStartWord <= (addr) && (addr) < (_bmStartWord + _bmWordSize), \ | ||
257 | "outside underlying space?"); \ | ||
258 | assert(G1CollectedHeap::heap()->is_in_exact(addr), \ | ||
259 | - err_msg("Trying to access not available bitmap "PTR_FORMAT \ | ||
260 | - " corresponding to "PTR_FORMAT" (%u)", \ | ||
261 | + err_msg("Trying to access not available bitmap " PTR_FORMAT \ | ||
262 | + " corresponding to " PTR_FORMAT " (%u)", \ | ||
263 | p2i(this), p2i(addr), G1CollectedHeap::heap()->addr_to_region(addr))); | ||
264 | |||
265 | inline void CMBitMap::mark(HeapWord* addr) { | ||
266 | @@ -270,7 +270,7 @@ | ||
267 | |||
268 | inline void CMTask::deal_with_reference(oop obj) { | ||
269 | if (_cm->verbose_high()) { | ||
270 | - gclog_or_tty->print_cr("[%u] we're dealing with reference = "PTR_FORMAT, | ||
271 | + gclog_or_tty->print_cr("[%u] we're dealing with reference = " PTR_FORMAT, | ||
272 | _worker_id, p2i((void*) obj)); | ||
273 | } | ||
274 | |||
275 | @@ -374,7 +374,7 @@ | ||
276 | // assert that word_size is under an upper bound which is its | ||
277 | // containing region's capacity. | ||
278 | assert(word_size * HeapWordSize <= hr->capacity(), | ||
279 | - err_msg("size: "SIZE_FORMAT" capacity: "SIZE_FORMAT" "HR_FORMAT, | ||
280 | + err_msg("size: " SIZE_FORMAT " capacity: " SIZE_FORMAT " " HR_FORMAT, | ||
281 | word_size * HeapWordSize, hr->capacity(), | ||
282 | HR_FORMAT_PARAMS(hr))); | ||
283 | |||
284 | --- hotspot/src/share/vm/gc_implementation/g1/g1CardCounts.hpp.orig 2015-09-02 10:12:49.000000000 +0200 | ||
285 | +++ hotspot/src/share/vm/gc_implementation/g1/g1CardCounts.hpp 2015-09-02 10:21:38.000000000 +0200 | ||
286 | @@ -91,7 +91,7 @@ | ||
287 | |||
288 | jbyte* card_num_2_ptr(size_t card_num) { | ||
289 | assert(card_num >= 0 && card_num < _reserved_max_card_num, | ||
290 | - err_msg("card num out of range: "SIZE_FORMAT, card_num)); | ||
291 | + err_msg("card num out of range: " SIZE_FORMAT, card_num)); | ||
292 | return (jbyte*) (_ct_bot + card_num); | ||
293 | } | ||
294 | |||
295 | --- hotspot/src/share/vm/gc_implementation/g1/g1OopClosures.inline.hpp.orig 2015-09-02 10:24:04.000000000 +0200 | ||
296 | +++ hotspot/src/share/vm/gc_implementation/g1/g1OopClosures.inline.hpp 2015-09-02 10:24:14.000000000 +0200 | ||
297 | @@ -118,7 +118,7 @@ | ||
298 | oop obj = oopDesc::load_decode_heap_oop(p); | ||
299 | if (_cm->verbose_high()) { | ||
300 | gclog_or_tty->print_cr("[%u] we're looking at location " | ||
301 | - "*"PTR_FORMAT" = "PTR_FORMAT, | ||
302 | + "*" PTR_FORMAT " = " PTR_FORMAT, | ||
303 | _task->worker_id(), p2i(p), p2i((void*) obj)); | ||
304 | } | ||
305 | _task->deal_with_reference(obj); | ||
306 | --- hotspot/src/share/vm/gc_implementation/g1/concurrentMark.cpp.orig 2015-09-06 14:02:06.000000000 +0200 | ||
307 | +++ hotspot/src/share/vm/gc_implementation/g1/concurrentMark.cpp 2015-09-10 12:03:16.130020385 +0200 | ||
308 | @@ -284,7 +284,7 @@ | ||
309 | if (PrintGCDetails && Verbose) { | ||
310 | // Failed to double capacity, continue; | ||
311 | gclog_or_tty->print(" (benign) Failed to expand marking stack capacity from " | ||
312 | - SIZE_FORMAT"K to " SIZE_FORMAT"K", | ||
313 | + SIZE_FORMAT "K to " SIZE_FORMAT "K", | ||
314 | _capacity / K, new_capacity / K); | ||
315 | } | ||
316 | } | ||
317 | @@ -581,7 +581,7 @@ | ||
318 | _verbose_level = verbose_level; | ||
319 | |||
320 | if (verbose_low()) { | ||
321 | - gclog_or_tty->print_cr("[global] init, heap start = "PTR_FORMAT", " | ||
322 | + gclog_or_tty->print_cr("[global] init, heap start = " PTR_FORMAT ", " | ||
323 | "heap end = " INTPTR_FORMAT, p2i(_heap_start), p2i(_heap_end)); | ||
324 | } | ||
325 | |||
326 | @@ -838,7 +838,7 @@ | ||
327 | // in a STW phase. | ||
328 | assert(!concurrent_marking_in_progress(), "invariant"); | ||
329 | assert(out_of_regions(), | ||
330 | - err_msg("only way to get here: _finger: "PTR_FORMAT", _heap_end: "PTR_FORMAT, | ||
331 | + err_msg("only way to get here: _finger: " PTR_FORMAT ", _heap_end: " PTR_FORMAT, | ||
332 | p2i(_finger), p2i(_heap_end))); | ||
333 | } | ||
334 | } | ||
335 | @@ -1453,7 +1453,7 @@ | ||
336 | |||
337 | assert(start <= hr->end() && start <= ntams && ntams <= hr->end(), | ||
338 | err_msg("Preconditions not met - " | ||
339 | - "start: "PTR_FORMAT", ntams: "PTR_FORMAT", end: "PTR_FORMAT, | ||
340 | + "start: " PTR_FORMAT ", ntams: " PTR_FORMAT ", end: " PTR_FORMAT, | ||
341 | p2i(start), p2i(ntams), p2i(hr->end()))); | ||
342 | |||
343 | // Find the first marked object at or after "start". | ||
344 | @@ -1770,10 +1770,10 @@ | ||
345 | } | ||
346 | |||
347 | assert(end_idx <= _card_bm->size(), | ||
348 | - err_msg("oob: end_idx= "SIZE_FORMAT", bitmap size= "SIZE_FORMAT, | ||
349 | + err_msg("oob: end_idx= " SIZE_FORMAT ", bitmap size= " SIZE_FORMAT, | ||
350 | end_idx, _card_bm->size())); | ||
351 | assert(start_idx < _card_bm->size(), | ||
352 | - err_msg("oob: start_idx= "SIZE_FORMAT", bitmap size= "SIZE_FORMAT, | ||
353 | + err_msg("oob: start_idx= " SIZE_FORMAT ", bitmap size= " SIZE_FORMAT, | ||
354 | start_idx, _card_bm->size())); | ||
355 | |||
356 | _cm->set_card_bitmap_range(_card_bm, start_idx, end_idx, true /* is_par */); | ||
357 | @@ -2278,7 +2278,7 @@ | ||
358 | oop obj = oopDesc::load_decode_heap_oop(p); | ||
359 | if (_cm->verbose_high()) { | ||
360 | gclog_or_tty->print_cr("\t[%u] we're looking at location " | ||
361 | - "*"PTR_FORMAT" = "PTR_FORMAT, | ||
362 | + "*" PTR_FORMAT " = " PTR_FORMAT, | ||
363 | _task->worker_id(), p2i(p), p2i((void*) obj)); | ||
364 | } | ||
365 | |||
366 | @@ -2847,7 +2847,7 @@ | ||
367 | } | ||
368 | } | ||
369 | |||
370 | - _out->print_cr(" "PTR_FORMAT": "PTR_FORMAT"%s%s", | ||
371 | + _out->print_cr(" " PTR_FORMAT ": " PTR_FORMAT "%s%s", | ||
372 | p2i(p), p2i((void*) obj), str, str2); | ||
373 | } | ||
374 | }; | ||
375 | @@ -2874,7 +2874,7 @@ | ||
376 | bool print_it = _all || over_tams || marked; | ||
377 | |||
378 | if (print_it) { | ||
379 | - _out->print_cr(" "PTR_FORMAT"%s", | ||
380 | + _out->print_cr(" " PTR_FORMAT "%s", | ||
381 | p2i((void *)o), (over_tams) ? " >" : (marked) ? " M" : ""); | ||
382 | PrintReachableOopClosure oopCl(_out, _vo, _all); | ||
383 | o->oop_iterate_no_header(&oopCl); | ||
384 | @@ -2895,7 +2895,7 @@ | ||
385 | HeapWord* e = hr->end(); | ||
386 | HeapWord* t = hr->top(); | ||
387 | HeapWord* p = _g1h->top_at_mark_start(hr, _vo); | ||
388 | - _out->print_cr("** ["PTR_FORMAT", "PTR_FORMAT"] top: "PTR_FORMAT" " | ||
389 | + _out->print_cr("** [" PTR_FORMAT ", " PTR_FORMAT "] top: " PTR_FORMAT " " | ||
390 | "TAMS: " PTR_FORMAT, p2i(b), p2i(e), p2i(t), p2i(p)); | ||
391 | _out->cr(); | ||
392 | |||
393 | @@ -3019,9 +3019,9 @@ | ||
394 | HeapWord* limit = curr_region->next_top_at_mark_start(); | ||
395 | |||
396 | if (verbose_low()) { | ||
397 | - gclog_or_tty->print_cr("[%u] curr_region = "PTR_FORMAT" " | ||
398 | - "["PTR_FORMAT", "PTR_FORMAT"), " | ||
399 | - "limit = "PTR_FORMAT, | ||
400 | + gclog_or_tty->print_cr("[%u] curr_region = " PTR_FORMAT " " | ||
401 | + "[" PTR_FORMAT ", " PTR_FORMAT "), " | ||
402 | + "limit = " PTR_FORMAT, | ||
403 | worker_id, p2i(curr_region), p2i(bottom), p2i(end), p2i(limit)); | ||
404 | } | ||
405 | |||
406 | @@ -3036,7 +3036,7 @@ | ||
407 | |||
408 | if (limit > bottom) { | ||
409 | if (verbose_low()) { | ||
410 | - gclog_or_tty->print_cr("[%u] region "PTR_FORMAT" is not empty, " | ||
411 | + gclog_or_tty->print_cr("[%u] region " PTR_FORMAT " is not empty, " | ||
412 | "returning it ", worker_id, p2i(curr_region)); | ||
413 | } | ||
414 | return curr_region; | ||
415 | @@ -3044,7 +3044,7 @@ | ||
416 | assert(limit == bottom, | ||
417 | "the region limit should be at bottom"); | ||
418 | if (verbose_low()) { | ||
419 | - gclog_or_tty->print_cr("[%u] region "PTR_FORMAT" is empty, " | ||
420 | + gclog_or_tty->print_cr("[%u] region " PTR_FORMAT " is empty, " | ||
421 | "returning NULL", worker_id, p2i(curr_region)); | ||
422 | } | ||
423 | // we return NULL and the caller should try calling | ||
424 | @@ -3056,13 +3056,13 @@ | ||
425 | if (verbose_low()) { | ||
426 | if (curr_region == NULL) { | ||
427 | gclog_or_tty->print_cr("[%u] found uncommitted region, moving finger, " | ||
428 | - "global finger = "PTR_FORMAT", " | ||
429 | - "our finger = "PTR_FORMAT, | ||
430 | + "global finger = " PTR_FORMAT ", " | ||
431 | + "our finger = " PTR_FORMAT, | ||
432 | worker_id, p2i(_finger), p2i(finger)); | ||
433 | } else { | ||
434 | gclog_or_tty->print_cr("[%u] somebody else moved the finger, " | ||
435 | - "global finger = "PTR_FORMAT", " | ||
436 | - "our finger = "PTR_FORMAT, | ||
437 | + "global finger = " PTR_FORMAT ", " | ||
438 | + "our finger = " PTR_FORMAT, | ||
439 | worker_id, p2i(_finger), p2i(finger)); | ||
440 | } | ||
441 | } | ||
442 | @@ -3098,7 +3098,7 @@ | ||
443 | |||
444 | void do_object_work(oop obj) { | ||
445 | guarantee(!_g1h->obj_in_cs(obj), | ||
446 | - err_msg("obj: "PTR_FORMAT" in CSet, phase: %s, info: %d", | ||
447 | + err_msg("obj: " PTR_FORMAT " in CSet, phase: %s, info: %d", | ||
448 | p2i((void*) obj), phase_str(), _info)); | ||
449 | } | ||
450 | |||
451 | @@ -3159,7 +3159,7 @@ | ||
452 | // here. | ||
453 | HeapRegion* global_hr = _g1h->heap_region_containing_raw(global_finger); | ||
454 | guarantee(global_hr == NULL || global_finger == global_hr->bottom(), | ||
455 | - err_msg("global finger: "PTR_FORMAT" region: "HR_FORMAT, | ||
456 | + err_msg("global finger: " PTR_FORMAT " region: " HR_FORMAT, | ||
457 | p2i(global_finger), HR_FORMAT_PARAMS(global_hr))); | ||
458 | } | ||
459 | |||
460 | @@ -3173,7 +3173,7 @@ | ||
461 | HeapRegion* task_hr = _g1h->heap_region_containing_raw(task_finger); | ||
462 | guarantee(task_hr == NULL || task_finger == task_hr->bottom() || | ||
463 | !task_hr->in_collection_set(), | ||
464 | - err_msg("task finger: "PTR_FORMAT" region: "HR_FORMAT, | ||
465 | + err_msg("task finger: " PTR_FORMAT " region: " HR_FORMAT, | ||
466 | p2i(task_finger), HR_FORMAT_PARAMS(task_hr))); | ||
467 | } | ||
468 | } | ||
469 | @@ -3215,8 +3215,8 @@ | ||
470 | |||
471 | assert(start <= limit && limit <= hr->top() && hr->top() <= hr->end(), | ||
472 | err_msg("Preconditions not met - " | ||
473 | - "start: "PTR_FORMAT", limit: "PTR_FORMAT", " | ||
474 | - "top: "PTR_FORMAT", end: "PTR_FORMAT, | ||
475 | + "start: " PTR_FORMAT ", limit: " PTR_FORMAT ", " | ||
476 | + "top: " PTR_FORMAT ", end: " PTR_FORMAT, | ||
477 | p2i(start), p2i(limit), p2i(hr->top()), p2i(hr->end()))); | ||
478 | |||
479 | assert(hr->next_marked_bytes() == 0, "Precondition"); | ||
480 | @@ -3495,7 +3495,7 @@ | ||
481 | #ifndef PRODUCT | ||
482 | // for debugging purposes | ||
483 | void ConcurrentMark::print_finger() { | ||
484 | - gclog_or_tty->print_cr("heap ["PTR_FORMAT", "PTR_FORMAT"), global finger = "PTR_FORMAT, | ||
485 | + gclog_or_tty->print_cr("heap [" PTR_FORMAT ", " PTR_FORMAT "), global finger = " PTR_FORMAT, | ||
486 | p2i(_heap_start), p2i(_heap_end), p2i(_finger)); | ||
487 | for (uint i = 0; i < _max_worker_id; ++i) { | ||
488 | gclog_or_tty->print(" %u: " PTR_FORMAT, i, p2i(_tasks[i]->finger())); | ||
489 | @@ -3580,7 +3580,7 @@ | ||
490 | "claim_region() should have filtered out continues humongous regions"); | ||
491 | |||
492 | if (_cm->verbose_low()) { | ||
493 | - gclog_or_tty->print_cr("[%u] setting up for region "PTR_FORMAT, | ||
494 | + gclog_or_tty->print_cr("[%u] setting up for region " PTR_FORMAT, | ||
495 | _worker_id, p2i(hr)); | ||
496 | } | ||
497 | |||
498 | @@ -3597,7 +3597,7 @@ | ||
499 | if (limit == bottom) { | ||
500 | if (_cm->verbose_low()) { | ||
501 | gclog_or_tty->print_cr("[%u] found an empty region " | ||
502 | - "["PTR_FORMAT", "PTR_FORMAT")", | ||
503 | + "[" PTR_FORMAT ", " PTR_FORMAT ")", | ||
504 | _worker_id, p2i(bottom), p2i(limit)); | ||
505 | } | ||
506 | // The region was collected underneath our feet. | ||
507 | @@ -3629,7 +3629,7 @@ | ||
508 | void CMTask::giveup_current_region() { | ||
509 | assert(_curr_region != NULL, "invariant"); | ||
510 | if (_cm->verbose_low()) { | ||
511 | - gclog_or_tty->print_cr("[%u] giving up region "PTR_FORMAT, | ||
512 | + gclog_or_tty->print_cr("[%u] giving up region " PTR_FORMAT, | ||
513 | _worker_id, p2i(_curr_region)); | ||
514 | } | ||
515 | clear_region_fields(); | ||
516 | @@ -3751,7 +3751,7 @@ | ||
517 | |||
518 | if (_cm->verbose_medium()) { | ||
519 | gclog_or_tty->print_cr("[%u] regular clock, interval = %1.2lfms, " | ||
520 | - "scanned = "SIZE_FORMAT"%s, refs reached = "SIZE_FORMAT"%s", | ||
521 | + "scanned = " SIZE_FORMAT "%s, refs reached = " SIZE_FORMAT "%s", | ||
522 | _worker_id, last_interval_ms, | ||
523 | _words_scanned, | ||
524 | (_words_scanned >= _words_scanned_limit) ? " (*)" : "", | ||
525 | @@ -3920,7 +3920,7 @@ | ||
526 | statsOnly( ++_local_pops ); | ||
527 | |||
528 | if (_cm->verbose_high()) { | ||
529 | - gclog_or_tty->print_cr("[%u] popped "PTR_FORMAT, _worker_id, | ||
530 | + gclog_or_tty->print_cr("[%u] popped " PTR_FORMAT, _worker_id, | ||
531 | p2i((void*) obj)); | ||
532 | } | ||
533 | |||
534 | @@ -4273,8 +4273,8 @@ | ||
535 | |||
536 | if (_cm->verbose_low()) { | ||
537 | gclog_or_tty->print_cr("[%u] we're scanning part " | ||
538 | - "["PTR_FORMAT", "PTR_FORMAT") " | ||
539 | - "of region "HR_FORMAT, | ||
540 | + "[" PTR_FORMAT ", " PTR_FORMAT ") " | ||
541 | + "of region " HR_FORMAT, | ||
542 | _worker_id, p2i(_finger), p2i(_region_limit), | ||
543 | HR_FORMAT_PARAMS(_curr_region)); | ||
544 | } | ||
545 | @@ -4361,7 +4361,7 @@ | ||
546 | |||
547 | if (_cm->verbose_low()) { | ||
548 | gclog_or_tty->print_cr("[%u] we successfully claimed " | ||
549 | - "region "PTR_FORMAT, | ||
550 | + "region " PTR_FORMAT, | ||
551 | _worker_id, p2i(claimed_region)); | ||
552 | } | ||
553 | |||
554 | @@ -4422,7 +4422,7 @@ | ||
555 | |||
556 | if (_cm->try_stealing(_worker_id, &_hash_seed, obj)) { | ||
557 | if (_cm->verbose_medium()) { | ||
558 | - gclog_or_tty->print_cr("[%u] stolen "PTR_FORMAT" successfully", | ||
559 | + gclog_or_tty->print_cr("[%u] stolen " PTR_FORMAT " successfully", | ||
560 | _worker_id, p2i((void*) obj)); | ||
561 | } | ||
562 | |||
563 | @@ -4630,7 +4630,7 @@ | ||
564 | // identify them easily in a large log file. | ||
565 | #define G1PPRL_LINE_PREFIX "###" | ||
566 | |||
567 | -#define G1PPRL_ADDR_BASE_FORMAT " "PTR_FORMAT"-"PTR_FORMAT | ||
568 | +#define G1PPRL_ADDR_BASE_FORMAT " " PTR_FORMAT "-" PTR_FORMAT | ||
569 | #ifdef _LP64 | ||
570 | #define G1PPRL_ADDR_BASE_H_FORMAT " %37s" | ||
571 | #else // _LP64 | ||
572 | @@ -4640,16 +4640,16 @@ | ||
573 | // For per-region info | ||
574 | #define G1PPRL_TYPE_FORMAT " %-4s" | ||
575 | #define G1PPRL_TYPE_H_FORMAT " %4s" | ||
576 | -#define G1PPRL_BYTE_FORMAT " "SIZE_FORMAT_W(9) | ||
577 | +#define G1PPRL_BYTE_FORMAT " " SIZE_FORMAT_W(9) | ||
578 | #define G1PPRL_BYTE_H_FORMAT " %9s" | ||
579 | #define G1PPRL_DOUBLE_FORMAT " %14.1f" | ||
580 | #define G1PPRL_DOUBLE_H_FORMAT " %14s" | ||
581 | |||
582 | // For summary info | ||
583 | -#define G1PPRL_SUM_ADDR_FORMAT(tag) " "tag":"G1PPRL_ADDR_BASE_FORMAT | ||
584 | -#define G1PPRL_SUM_BYTE_FORMAT(tag) " "tag": "SIZE_FORMAT | ||
585 | -#define G1PPRL_SUM_MB_FORMAT(tag) " "tag": %1.2f MB" | ||
586 | -#define G1PPRL_SUM_MB_PERC_FORMAT(tag) G1PPRL_SUM_MB_FORMAT(tag)" / %1.2f %%" | ||
587 | +#define G1PPRL_SUM_ADDR_FORMAT(tag) " " tag ":" G1PPRL_ADDR_BASE_FORMAT | ||
588 | +#define G1PPRL_SUM_BYTE_FORMAT(tag) " " tag ": " SIZE_FORMAT | ||
589 | +#define G1PPRL_SUM_MB_FORMAT(tag) " " tag ": %1.2f MB" | ||
590 | +#define G1PPRL_SUM_MB_PERC_FORMAT(tag) G1PPRL_SUM_MB_FORMAT(tag) " / %1.2f %%" | ||
591 | |||
592 | G1PrintRegionLivenessInfoClosure:: | ||
593 | G1PrintRegionLivenessInfoClosure(outputStream* out, const char* phase_name) | ||
594 | --- hotspot/src/share/vm/oops/constantPool.cpp.orig 2015-09-02 10:35:07.000000000 +0200 | ||
595 | +++ hotspot/src/share/vm/oops/constantPool.cpp 2015-09-02 10:36:03.000000000 +0200 | ||
596 | @@ -1494,7 +1494,7 @@ | ||
597 | } | ||
598 | case JVM_CONSTANT_Long: { | ||
599 | u8 val = Bytes::get_Java_u8(bytes); | ||
600 | - printf("long "INT64_FORMAT, (int64_t) *(jlong *) &val); | ||
601 | + printf("long " INT64_FORMAT, (int64_t) *(jlong *) &val); | ||
602 | ent_size = 8; | ||
603 | idx++; // Long takes two cpool slots | ||
604 | break; | ||
605 | --- hotspot/src/share/vm/oops/cpCache.cpp.orig 2015-09-02 10:35:13.000000000 +0200 | ||
606 | +++ hotspot/src/share/vm/oops/cpCache.cpp 2015-09-02 10:36:48.000000000 +0200 | ||
607 | @@ -305,7 +305,7 @@ | ||
608 | adapter->size_of_parameters()); | ||
609 | |||
610 | if (TraceInvokeDynamic) { | ||
611 | - tty->print_cr("set_method_handle bc=%d appendix="PTR_FORMAT"%s method_type="PTR_FORMAT"%s method="PTR_FORMAT" ", | ||
612 | + tty->print_cr("set_method_handle bc=%d appendix=" PTR_FORMAT "%s method_type=" PTR_FORMAT "%s method=" PTR_FORMAT " ", | ||
613 | invoke_code, | ||
614 | (void *)appendix(), (has_appendix ? "" : " (unused)"), | ||
615 | (void *)method_type(), (has_method_type ? "" : " (unused)"), | ||
616 | @@ -540,12 +540,12 @@ | ||
617 | // print separator | ||
618 | if (index == 0) st->print_cr(" -------------"); | ||
619 | // print entry | ||
620 | - st->print("%3d ("PTR_FORMAT") ", index, (intptr_t)this); | ||
621 | + st->print("%3d (" PTR_FORMAT ") ", index, (intptr_t)this); | ||
622 | st->print_cr("[%02x|%02x|%5d]", bytecode_2(), bytecode_1(), | ||
623 | constant_pool_index()); | ||
624 | - st->print_cr(" [ "PTR_FORMAT"]", (intptr_t)_f1); | ||
625 | - st->print_cr(" [ "PTR_FORMAT"]", (intptr_t)_f2); | ||
626 | - st->print_cr(" [ "PTR_FORMAT"]", (intptr_t)_flags); | ||
627 | + st->print_cr(" [ " PTR_FORMAT "]", (intptr_t)_f1); | ||
628 | + st->print_cr(" [ " PTR_FORMAT "]", (intptr_t)_f2); | ||
629 | + st->print_cr(" [ " PTR_FORMAT "]", (intptr_t)_flags); | ||
630 | st->print_cr(" -------------"); | ||
631 | } | ||
632 | |||
633 | --- hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp.orig 2015-09-02 10:12:48.000000000 +0200 | ||
634 | +++ hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp 2015-09-02 10:39:26.000000000 +0200 | ||
635 | @@ -838,18 +838,18 @@ | ||
636 | GenCollectedHeap* gch = GenCollectedHeap::heap(); | ||
637 | if (PrintGCDetails) { | ||
638 | if (Verbose) { | ||
639 | - gclog_or_tty->print("[%d %s-%s: "SIZE_FORMAT"("SIZE_FORMAT")]", | ||
640 | + gclog_or_tty->print("[%d %s-%s: " SIZE_FORMAT "(" SIZE_FORMAT ")]", | ||
641 | level(), short_name(), s, used(), capacity()); | ||
642 | } else { | ||
643 | - gclog_or_tty->print("[%d %s-%s: "SIZE_FORMAT"K("SIZE_FORMAT"K)]", | ||
644 | + gclog_or_tty->print("[%d %s-%s: " SIZE_FORMAT "K(" SIZE_FORMAT "K)]", | ||
645 | level(), short_name(), s, used() / K, capacity() / K); | ||
646 | } | ||
647 | } | ||
648 | if (Verbose) { | ||
649 | - gclog_or_tty->print(" "SIZE_FORMAT"("SIZE_FORMAT")", | ||
650 | + gclog_or_tty->print(" " SIZE_FORMAT "(" SIZE_FORMAT ")", | ||
651 | gch->used(), gch->capacity()); | ||
652 | } else { | ||
653 | - gclog_or_tty->print(" "SIZE_FORMAT"K("SIZE_FORMAT"K)", | ||
654 | + gclog_or_tty->print(" " SIZE_FORMAT "K(" SIZE_FORMAT "K)", | ||
655 | gch->used() / K, gch->capacity() / K); | ||
656 | } | ||
657 | } | ||
658 | @@ -879,8 +879,8 @@ | ||
659 | bool res = (available >= av_promo) || (available >= max_promotion_in_bytes); | ||
660 | if (Verbose && PrintGCDetails) { | ||
661 | gclog_or_tty->print_cr( | ||
662 | - "CMS: promo attempt is%s safe: available("SIZE_FORMAT") %s av_promo("SIZE_FORMAT")," | ||
663 | - "max_promo("SIZE_FORMAT")", | ||
664 | + "CMS: promo attempt is%s safe: available(" SIZE_FORMAT ") %s av_promo(" SIZE_FORMAT ")," | ||
665 | + "max_promo(" SIZE_FORMAT ")", | ||
666 | res? "":" not", available, res? ">=":"<", | ||
667 | av_promo, max_promotion_in_bytes); | ||
668 | } | ||
669 | @@ -966,8 +966,8 @@ | ||
670 | desired_free_percentage); | ||
671 | gclog_or_tty->print_cr(" Maximum free fraction %f", | ||
672 | maximum_free_percentage); | ||
673 | - gclog_or_tty->print_cr(" Capactiy "SIZE_FORMAT, capacity()/1000); | ||
674 | - gclog_or_tty->print_cr(" Desired capacity "SIZE_FORMAT, | ||
675 | + gclog_or_tty->print_cr(" Capactiy " SIZE_FORMAT, capacity()/1000); | ||
676 | + gclog_or_tty->print_cr(" Desired capacity " SIZE_FORMAT, | ||
677 | desired_capacity/1000); | ||
678 | int prev_level = level() - 1; | ||
679 | if (prev_level >= 0) { | ||
680 | @@ -975,14 +975,14 @@ | ||
681 | GenCollectedHeap* gch = GenCollectedHeap::heap(); | ||
682 | Generation* prev_gen = gch->_gens[prev_level]; | ||
683 | prev_size = prev_gen->capacity(); | ||
684 | - gclog_or_tty->print_cr(" Younger gen size "SIZE_FORMAT, | ||
685 | + gclog_or_tty->print_cr(" Younger gen size " SIZE_FORMAT, | ||
686 | prev_size/1000); | ||
687 | } | ||
688 | - gclog_or_tty->print_cr(" unsafe_max_alloc_nogc "SIZE_FORMAT, | ||
689 | + gclog_or_tty->print_cr(" unsafe_max_alloc_nogc " SIZE_FORMAT, | ||
690 | unsafe_max_alloc_nogc()/1000); | ||
691 | - gclog_or_tty->print_cr(" contiguous available "SIZE_FORMAT, | ||
692 | + gclog_or_tty->print_cr(" contiguous available " SIZE_FORMAT, | ||
693 | contiguous_available()/1000); | ||
694 | - gclog_or_tty->print_cr(" Expand by "SIZE_FORMAT" (bytes)", | ||
695 | + gclog_or_tty->print_cr(" Expand by " SIZE_FORMAT " (bytes)", | ||
696 | expand_bytes); | ||
697 | } | ||
698 | // safe if expansion fails | ||
699 | @@ -1513,8 +1513,8 @@ | ||
700 | stats().print_on(gclog_or_tty); | ||
701 | gclog_or_tty->print_cr("time_until_cms_gen_full %3.7f", | ||
702 | stats().time_until_cms_gen_full()); | ||
703 | - gclog_or_tty->print_cr("free="SIZE_FORMAT, _cmsGen->free()); | ||
704 | - gclog_or_tty->print_cr("contiguous_available="SIZE_FORMAT, | ||
705 | + gclog_or_tty->print_cr("free=" SIZE_FORMAT, _cmsGen->free()); | ||
706 | + gclog_or_tty->print_cr("contiguous_available=" SIZE_FORMAT, | ||
707 | _cmsGen->contiguous_available()); | ||
708 | gclog_or_tty->print_cr("promotion_rate=%g", stats().promotion_rate()); | ||
709 | gclog_or_tty->print_cr("cms_allocation_rate=%g", stats().cms_allocation_rate()); | ||
710 | @@ -2792,7 +2792,7 @@ | ||
711 | assert(_numObjectsPromoted == 0, "check"); | ||
712 | assert(_numWordsPromoted == 0, "check"); | ||
713 | if (Verbose && PrintGC) { | ||
714 | - gclog_or_tty->print("Allocated "SIZE_FORMAT" objects, " | ||
715 | + gclog_or_tty->print("Allocated " SIZE_FORMAT " objects, " | ||
716 | SIZE_FORMAT" bytes concurrently", | ||
717 | _numObjectsAllocated, _numWordsAllocated*sizeof(HeapWord)); | ||
718 | } | ||
719 | @@ -2879,7 +2879,7 @@ | ||
720 | assert(_numObjectsAllocated == 0, "check"); | ||
721 | assert(_numWordsAllocated == 0, "check"); | ||
722 | if (Verbose && PrintGC) { | ||
723 | - gclog_or_tty->print("Promoted "SIZE_FORMAT" objects, " | ||
724 | + gclog_or_tty->print("Promoted " SIZE_FORMAT " objects, " | ||
725 | SIZE_FORMAT" bytes", | ||
726 | _numObjectsPromoted, _numWordsPromoted*sizeof(HeapWord)); | ||
727 | } | ||
728 | @@ -2890,7 +2890,7 @@ | ||
729 | if (PrintGC && Verbose) { | ||
730 | // Call down the chain in contiguous_available needs the freelistLock | ||
731 | // so print this out before releasing the freeListLock. | ||
732 | - gclog_or_tty->print(" Contiguous available "SIZE_FORMAT" bytes ", | ||
733 | + gclog_or_tty->print(" Contiguous available " SIZE_FORMAT " bytes ", | ||
734 | contiguous_available()); | ||
735 | } | ||
736 | } | ||
737 | @@ -2978,7 +2978,7 @@ | ||
738 | HeapWord* addr = _marks->offsetToHeapWord(offset); | ||
739 | if (!_marks->isMarked(addr)) { | ||
740 | oop(addr)->print_on(gclog_or_tty); | ||
741 | - gclog_or_tty->print_cr(" ("INTPTR_FORMAT" should have been marked)", addr); | ||
742 | + gclog_or_tty->print_cr(" (" INTPTR_FORMAT " should have been marked)", addr); | ||
743 | _failed = true; | ||
744 | } | ||
745 | return true; | ||
746 | @@ -5037,7 +5037,7 @@ | ||
747 | |||
748 | SpecializationStats::clear(); | ||
749 | if (PrintGCDetails) { | ||
750 | - gclog_or_tty->print("[YG occupancy: "SIZE_FORMAT" K ("SIZE_FORMAT" K)]", | ||
751 | + gclog_or_tty->print("[YG occupancy: " SIZE_FORMAT " K (" SIZE_FORMAT " K)]", | ||
752 | _young_gen->used() / K, | ||
753 | _young_gen->capacity() / K); | ||
754 | } | ||
755 | @@ -5170,8 +5170,8 @@ | ||
756 | if (ser_ovflw > 0) { | ||
757 | if (PrintCMSStatistics != 0) { | ||
758 | gclog_or_tty->print_cr("Marking stack overflow (benign) " | ||
759 | - "(pmc_pc="SIZE_FORMAT", pmc_rm="SIZE_FORMAT", kac="SIZE_FORMAT | ||
760 | - ", kac_preclean="SIZE_FORMAT")", | ||
761 | + "(pmc_pc=" SIZE_FORMAT ", pmc_rm=" SIZE_FORMAT ", kac=" SIZE_FORMAT | ||
762 | + ", kac_preclean=" SIZE_FORMAT ")", | ||
763 | _ser_pmc_preclean_ovflw, _ser_pmc_remark_ovflw, | ||
764 | _ser_kac_ovflw, _ser_kac_preclean_ovflw); | ||
765 | } | ||
766 | @@ -5184,7 +5184,7 @@ | ||
767 | if (_par_pmc_remark_ovflw > 0 || _par_kac_ovflw > 0) { | ||
768 | if (PrintCMSStatistics != 0) { | ||
769 | gclog_or_tty->print_cr("Work queue overflow (benign) " | ||
770 | - "(pmc_rm="SIZE_FORMAT", kac="SIZE_FORMAT")", | ||
771 | + "(pmc_rm=" SIZE_FORMAT ", kac=" SIZE_FORMAT ")", | ||
772 | _par_pmc_remark_ovflw, _par_kac_ovflw); | ||
773 | } | ||
774 | _par_pmc_remark_ovflw = 0; | ||
775 | @@ -5192,12 +5192,12 @@ | ||
776 | } | ||
777 | if (PrintCMSStatistics != 0) { | ||
778 | if (_markStack._hit_limit > 0) { | ||
779 | - gclog_or_tty->print_cr(" (benign) Hit max stack size limit ("SIZE_FORMAT")", | ||
780 | + gclog_or_tty->print_cr(" (benign) Hit max stack size limit (" SIZE_FORMAT ")", | ||
781 | _markStack._hit_limit); | ||
782 | } | ||
783 | if (_markStack._failed_double > 0) { | ||
784 | - gclog_or_tty->print_cr(" (benign) Failed stack doubling ("SIZE_FORMAT")," | ||
785 | - " current capacity "SIZE_FORMAT, | ||
786 | + gclog_or_tty->print_cr(" (benign) Failed stack doubling (" SIZE_FORMAT ")," | ||
787 | + " current capacity " SIZE_FORMAT, | ||
788 | _markStack._failed_double, | ||
789 | _markStack.capacity()); | ||
790 | } | ||
791 | @@ -5961,7 +5961,7 @@ | ||
792 | &markFromDirtyCardsClosure); | ||
793 | verify_work_stacks_empty(); | ||
794 | if (PrintCMSStatistics != 0) { | ||
795 | - gclog_or_tty->print(" (re-scanned "SIZE_FORMAT" dirty cards in cms gen) ", | ||
796 | + gclog_or_tty->print(" (re-scanned " SIZE_FORMAT " dirty cards in cms gen) ", | ||
797 | markFromDirtyCardsClosure.num_dirty_cards()); | ||
798 | } | ||
799 | } | ||
800 | @@ -6892,7 +6892,7 @@ | ||
801 | } else if (_failed_double++ == 0 && !CMSConcurrentMTEnabled && PrintGCDetails) { | ||
802 | // Failed to double capacity, continue; | ||
803 | // we print a detail message only once per CMS cycle. | ||
804 | - gclog_or_tty->print(" (benign) Failed to expand marking stack from "SIZE_FORMAT"K to " | ||
805 | + gclog_or_tty->print(" (benign) Failed to expand marking stack from " SIZE_FORMAT "K to " | ||
806 | SIZE_FORMAT"K", | ||
807 | _capacity / K, new_capacity / K); | ||
808 | } | ||
809 | @@ -8215,25 +8215,25 @@ | ||
810 | ShouldNotReachHere(); | ||
811 | } | ||
812 | if (Verbose && PrintGC) { | ||
813 | - gclog_or_tty->print("Collected "SIZE_FORMAT" objects, " SIZE_FORMAT " bytes", | ||
814 | + gclog_or_tty->print("Collected " SIZE_FORMAT " objects, " SIZE_FORMAT " bytes", | ||
815 | _numObjectsFreed, _numWordsFreed*sizeof(HeapWord)); | ||
816 | - gclog_or_tty->print_cr("\nLive "SIZE_FORMAT" objects, " | ||
817 | + gclog_or_tty->print_cr("\nLive " SIZE_FORMAT " objects, " | ||
818 | SIZE_FORMAT" bytes " | ||
819 | - "Already free "SIZE_FORMAT" objects, "SIZE_FORMAT" bytes", | ||
820 | + "Already free " SIZE_FORMAT " objects, " SIZE_FORMAT " bytes", | ||
821 | _numObjectsLive, _numWordsLive*sizeof(HeapWord), | ||
822 | _numObjectsAlreadyFree, _numWordsAlreadyFree*sizeof(HeapWord)); | ||
823 | size_t totalBytes = (_numWordsFreed + _numWordsLive + _numWordsAlreadyFree) | ||
824 | * sizeof(HeapWord); | ||
825 | - gclog_or_tty->print_cr("Total sweep: "SIZE_FORMAT" bytes", totalBytes); | ||
826 | + gclog_or_tty->print_cr("Total sweep: " SIZE_FORMAT " bytes", totalBytes); | ||
827 | |||
828 | if (PrintCMSStatistics && CMSVerifyReturnedBytes) { | ||
829 | size_t indexListReturnedBytes = _sp->sumIndexedFreeListArrayReturnedBytes(); | ||
830 | size_t dict_returned_bytes = _sp->dictionary()->sum_dict_returned_bytes(); | ||
831 | size_t returned_bytes = indexListReturnedBytes + dict_returned_bytes; | ||
832 | - gclog_or_tty->print("Returned "SIZE_FORMAT" bytes", returned_bytes); | ||
833 | - gclog_or_tty->print(" Indexed List Returned "SIZE_FORMAT" bytes", | ||
834 | + gclog_or_tty->print("Returned " SIZE_FORMAT " bytes", returned_bytes); | ||
835 | + gclog_or_tty->print(" Indexed List Returned " SIZE_FORMAT " bytes", | ||
836 | indexListReturnedBytes); | ||
837 | - gclog_or_tty->print_cr(" Dictionary Returned "SIZE_FORMAT" bytes", | ||
838 | + gclog_or_tty->print_cr(" Dictionary Returned " SIZE_FORMAT " bytes", | ||
839 | dict_returned_bytes); | ||
840 | } | ||
841 | } | ||
842 | @@ -8312,13 +8312,13 @@ | ||
843 | // coalesced chunk to the appropriate free list. | ||
844 | if (inFreeRange()) { | ||
845 | assert(freeFinger() >= _sp->bottom() && freeFinger() < _limit, | ||
846 | - err_msg("freeFinger() " PTR_FORMAT" is out-of-bounds", freeFinger())); | ||
847 | + err_msg("freeFinger() " PTR_FORMAT " is out-of-bounds", freeFinger())); | ||
848 | flush_cur_free_chunk(freeFinger(), | ||
849 | pointer_delta(addr, freeFinger())); | ||
850 | if (CMSTraceSweeper) { | ||
851 | gclog_or_tty->print("Sweep: last chunk: "); | ||
852 | - gclog_or_tty->print("put_free_blk 0x%x ("SIZE_FORMAT") " | ||
853 | - "[coalesced:"SIZE_FORMAT"]\n", | ||
854 | + gclog_or_tty->print("put_free_blk 0x%x (" SIZE_FORMAT ") " | ||
855 | + "[coalesced:" SIZE_FORMAT "]\n", | ||
856 | freeFinger(), pointer_delta(addr, freeFinger()), | ||
857 | lastFreeRangeCoalesced()); | ||
858 | } | ||
859 | --- hotspot/src/share/vm/classfile/dictionary.hpp.orig 2015-09-02 10:40:01.000000000 +0200 | ||
860 | +++ hotspot/src/share/vm/classfile/dictionary.hpp 2015-09-02 10:40:32.000000000 +0200 | ||
861 | @@ -370,7 +370,7 @@ | ||
862 | |||
863 | void print_on(outputStream* st) const { | ||
864 | symbol()->print_value_on(st); | ||
865 | - st->print("/mode="INTX_FORMAT, symbol_mode()); | ||
866 | + st->print("/mode=" INTX_FORMAT, symbol_mode()); | ||
867 | st->print(" -> "); | ||
868 | bool printed = false; | ||
869 | if (method() != NULL) { | ||
870 | --- hotspot/src/share/vm/compiler/disassembler.cpp.orig 2015-09-02 10:40:09.000000000 +0200 | ||
871 | +++ hotspot/src/share/vm/compiler/disassembler.cpp 2015-09-02 10:41:33.000000000 +0200 | ||
872 | @@ -60,7 +60,7 @@ | ||
873 | Disassembler::decode_func_virtual Disassembler::_decode_instructions_virtual = NULL; | ||
874 | Disassembler::decode_func Disassembler::_decode_instructions = NULL; | ||
875 | |||
876 | -static const char hsdis_library_name[] = "hsdis-"HOTSPOT_LIB_ARCH; | ||
877 | +static const char hsdis_library_name[] = "hsdis-" HOTSPOT_LIB_ARCH; | ||
878 | static const char decode_instructions_virtual_name[] = "decode_instructions_virtual"; | ||
879 | static const char decode_instructions_name[] = "decode_instructions"; | ||
880 | static bool use_new_version = true; | ||
881 | --- hotspot/src/share/vm/code/exceptionHandlerTable.cpp.orig 2015-09-02 10:44:06.000000000 +0200 | ||
882 | +++ hotspot/src/share/vm/code/exceptionHandlerTable.cpp 2015-09-02 10:44:32.000000000 +0200 | ||
883 | @@ -186,7 +186,7 @@ | ||
884 | void ImplicitExceptionTable::print(address base) const { | ||
885 | tty->print("{"); | ||
886 | for( uint i=0; i<len(); i++ ) | ||
887 | - tty->print("< "INTPTR_FORMAT", "INTPTR_FORMAT" > ",base + *adr(i), base + *(adr(i)+1)); | ||
888 | + tty->print("< " INTPTR_FORMAT ", " INTPTR_FORMAT " > ",base + *adr(i), base + *(adr(i)+1)); | ||
889 | tty->print_cr("}"); | ||
890 | } | ||
891 | |||
892 | --- hotspot/src/share/vm/gc_implementation/g1/g1AllocRegion.cpp.orig 2015-09-02 10:47:14.000000000 +0200 | ||
893 | +++ hotspot/src/share/vm/gc_implementation/g1/g1AllocRegion.cpp 2015-09-02 10:47:49.000000000 +0200 | ||
894 | @@ -140,7 +140,7 @@ | ||
895 | } | ||
896 | |||
897 | void G1AllocRegion::fill_in_ext_msg(ar_ext_msg* msg, const char* message) { | ||
898 | - msg->append("[%s] %s c: %u b: %s r: "PTR_FORMAT" u: "SIZE_FORMAT, | ||
899 | + msg->append("[%s] %s c: %u b: %s r: " PTR_FORMAT " u: " SIZE_FORMAT, | ||
900 | _name, message, _count, BOOL_TO_STR(_bot_updates), | ||
901 | p2i(_alloc_region), _used_bytes_before); | ||
902 | } | ||
903 | @@ -217,7 +217,7 @@ | ||
904 | |||
905 | if (G1_ALLOC_REGION_TRACING > 1) { | ||
906 | if (result != NULL) { | ||
907 | - jio_snprintf(rest_buffer, buffer_length, SIZE_FORMAT" "PTR_FORMAT, | ||
908 | + jio_snprintf(rest_buffer, buffer_length, SIZE_FORMAT " " PTR_FORMAT, | ||
909 | word_size, result); | ||
910 | } else if (word_size != 0) { | ||
911 | jio_snprintf(rest_buffer, buffer_length, SIZE_FORMAT, word_size); | ||
912 | --- hotspot/src/share/vm/gc_implementation/g1/g1BlockOffsetTable.cpp.orig 2015-09-02 10:47:14.000000000 +0200 | ||
913 | +++ hotspot/src/share/vm/gc_implementation/g1/g1BlockOffsetTable.cpp 2015-09-02 10:53:32.000000000 +0200 | ||
914 | @@ -385,11 +385,11 @@ | ||
915 | HeapWord* card_addr = _array->address_for_index(card); | ||
916 | HeapWord* block_start = block_start_const(card_addr); | ||
917 | if (block_start != obj_start) { | ||
918 | - gclog_or_tty->print_cr("block start: "PTR_FORMAT" is incorrect - " | ||
919 | - "card index: "SIZE_FORMAT" " | ||
920 | - "card addr: "PTR_FORMAT" BOT entry: %u " | ||
921 | - "obj: "PTR_FORMAT" word size: "SIZE_FORMAT" " | ||
922 | - "cards: ["SIZE_FORMAT","SIZE_FORMAT"]", | ||
923 | + gclog_or_tty->print_cr("block start: " PTR_FORMAT " is incorrect - " | ||
924 | + "card index: " SIZE_FORMAT " " | ||
925 | + "card addr: " PTR_FORMAT " BOT entry: %u " | ||
926 | + "obj: " PTR_FORMAT " word size: " SIZE_FORMAT " " | ||
927 | + "cards: [" SIZE_FORMAT "," SIZE_FORMAT "]", | ||
928 | block_start, card, card_addr, | ||
929 | _array->offset_array(card), | ||
930 | obj_start, word_size, first_card, last_card); | ||
931 | @@ -404,11 +404,11 @@ | ||
932 | G1BlockOffsetArray::print_on(outputStream* out) { | ||
933 | size_t from_index = _array->index_for(_bottom); | ||
934 | size_t to_index = _array->index_for(_end); | ||
935 | - out->print_cr(">> BOT for area ["PTR_FORMAT","PTR_FORMAT") " | ||
936 | - "cards ["SIZE_FORMAT","SIZE_FORMAT")", | ||
937 | + out->print_cr(">> BOT for area [" PTR_FORMAT "," PTR_FORMAT ") " | ||
938 | + "cards [" SIZE_FORMAT "," SIZE_FORMAT ")", | ||
939 | _bottom, _end, from_index, to_index); | ||
940 | for (size_t i = from_index; i < to_index; ++i) { | ||
941 | - out->print_cr(" entry "SIZE_FORMAT_W(8)" | "PTR_FORMAT" : %3u", | ||
942 | + out->print_cr(" entry " SIZE_FORMAT_W(8) " | " PTR_FORMAT " : %3u", | ||
943 | i, _array->address_for_index(i), | ||
944 | (uint) _array->offset_array(i)); | ||
945 | } | ||
946 | @@ -488,7 +488,7 @@ | ||
947 | void | ||
948 | G1BlockOffsetArrayContigSpace::print_on(outputStream* out) { | ||
949 | G1BlockOffsetArray::print_on(out); | ||
950 | - out->print_cr(" next offset threshold: "PTR_FORMAT, _next_offset_threshold); | ||
951 | - out->print_cr(" next offset index: "SIZE_FORMAT, _next_offset_index); | ||
952 | + out->print_cr(" next offset threshold: " PTR_FORMAT, _next_offset_threshold); | ||
953 | + out->print_cr(" next offset index: " SIZE_FORMAT, _next_offset_index); | ||
954 | } | ||
955 | #endif // !PRODUCT | ||
956 | --- hotspot/src/share/vm/gc_implementation/g1/g1CardCounts.cpp.orig 2015-09-02 10:47:15.000000000 +0200 | ||
957 | +++ hotspot/src/share/vm/gc_implementation/g1/g1CardCounts.cpp 2015-09-02 10:54:04.000000000 +0200 | ||
958 | @@ -44,7 +44,7 @@ | ||
959 | void G1CardCounts::clear_range(size_t from_card_num, size_t to_card_num) { | ||
960 | if (has_count_table()) { | ||
961 | assert(from_card_num < to_card_num, | ||
962 | - err_msg("Wrong order? from: " SIZE_FORMAT ", to: "SIZE_FORMAT, | ||
963 | + err_msg("Wrong order? from: " SIZE_FORMAT ", to: " SIZE_FORMAT, | ||
964 | from_card_num, to_card_num)); | ||
965 | Copy::fill_to_bytes(&_card_counts[from_card_num], (to_card_num - from_card_num)); | ||
966 | } | ||
967 | @@ -87,7 +87,7 @@ | ||
968 | if (has_count_table()) { | ||
969 | size_t card_num = ptr_2_card_num(card_ptr); | ||
970 | assert(card_num < _reserved_max_card_num, | ||
971 | - err_msg("Card "SIZE_FORMAT" outside of card counts table (max size "SIZE_FORMAT")", | ||
972 | + err_msg("Card " SIZE_FORMAT " outside of card counts table (max size " SIZE_FORMAT ")", | ||
973 | card_num, _reserved_max_card_num)); | ||
974 | count = (uint) _card_counts[card_num]; | ||
975 | if (count < G1ConcRSHotCardLimit) { | ||
976 | --- hotspot/src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp.orig 2015-09-02 10:57:01.000000000 +0200 | ||
977 | +++ hotspot/src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp 2015-09-02 11:02:01.000000000 +0200 | ||
978 | @@ -199,7 +199,7 @@ | ||
979 | const size_t region_size = HeapRegion::GrainWords; | ||
980 | if (YoungPLABSize > region_size || OldPLABSize > region_size) { | ||
981 | char buffer[128]; | ||
982 | - jio_snprintf(buffer, sizeof(buffer), "%sPLABSize should be at most "SIZE_FORMAT, | ||
983 | + jio_snprintf(buffer, sizeof(buffer), "%sPLABSize should be at most " SIZE_FORMAT, | ||
984 | OldPLABSize > region_size ? "Old" : "Young", region_size); | ||
985 | vm_exit_during_initialization(buffer); | ||
986 | } | ||
987 | @@ -846,7 +846,7 @@ | ||
988 | update_survivors_policy(); | ||
989 | |||
990 | assert(_g1->used() == _g1->recalculate_used(), | ||
991 | - err_msg("sanity, used: "SIZE_FORMAT" recalculate_used: "SIZE_FORMAT, | ||
992 | + err_msg("sanity, used: " SIZE_FORMAT " recalculate_used: " SIZE_FORMAT, | ||
993 | _g1->used(), _g1->recalculate_used())); | ||
994 | |||
995 | double s_w_t_ms = (start_time_sec - _stop_world_start) * 1000.0; | ||
996 | @@ -1231,10 +1231,10 @@ | ||
997 | (_young_list_target_length * HeapRegion::GrainBytes) - survivor_used_bytes_after_gc; | ||
998 | |||
999 | gclog_or_tty->print( | ||
1000 | - " [Eden: "EXT_SIZE_FORMAT"("EXT_SIZE_FORMAT")->"EXT_SIZE_FORMAT"("EXT_SIZE_FORMAT") " | ||
1001 | - "Survivors: "EXT_SIZE_FORMAT"->"EXT_SIZE_FORMAT" " | ||
1002 | - "Heap: "EXT_SIZE_FORMAT"("EXT_SIZE_FORMAT")->" | ||
1003 | - EXT_SIZE_FORMAT"("EXT_SIZE_FORMAT")]", | ||
1004 | + " [Eden: " EXT_SIZE_FORMAT "(" EXT_SIZE_FORMAT ")->" EXT_SIZE_FORMAT "(" EXT_SIZE_FORMAT ") " | ||
1005 | + "Survivors: " EXT_SIZE_FORMAT "->" EXT_SIZE_FORMAT " " | ||
1006 | + "Heap: " EXT_SIZE_FORMAT "(" EXT_SIZE_FORMAT ")->" | ||
1007 | + EXT_SIZE_FORMAT "(" EXT_SIZE_FORMAT ")]", | ||
1008 | EXT_SIZE_PARAMS(_eden_used_bytes_before_gc), | ||
1009 | EXT_SIZE_PARAMS(_eden_capacity_bytes_before_gc), | ||
1010 | EXT_SIZE_PARAMS(eden_used_bytes_after_gc), | ||
1011 | @@ -1863,7 +1863,7 @@ | ||
1012 | while (csr != NULL) { | ||
1013 | HeapRegion* next = csr->next_in_collection_set(); | ||
1014 | assert(csr->in_collection_set(), "bad CS"); | ||
1015 | - st->print_cr(" "HR_FORMAT", P: "PTR_FORMAT "N: "PTR_FORMAT", age: %4d", | ||
1016 | + st->print_cr(" " HR_FORMAT ", P: " PTR_FORMAT "N: " PTR_FORMAT ", age: %4d", | ||
1017 | HR_FORMAT_PARAMS(csr), | ||
1018 | csr->prev_top_at_mark_start(), csr->next_top_at_mark_start(), | ||
1019 | csr->age_in_surv_rate_group_cond()); | ||
1020 | --- hotspot/src/share/vm/gc_implementation/g1/g1GCPhaseTimes.cpp.orig 2015-09-06 14:02:06.000000000 +0200 | ||
1021 | +++ hotspot/src/share/vm/gc_implementation/g1/g1GCPhaseTimes.cpp 2015-09-10 13:33:10.594040691 +0200 | ||
1022 | @@ -330,7 +330,7 @@ | ||
1023 | } | ||
1024 | |||
1025 | void G1GCPhaseTimes::print_stats(int level, const char* str, size_t value) { | ||
1026 | - LineBuffer(level).append_and_print_cr("[%s: "SIZE_FORMAT"]", str, value); | ||
1027 | + LineBuffer(level).append_and_print_cr("[%s: " SIZE_FORMAT "]", str, value); | ||
1028 | } | ||
1029 | |||
1030 | void G1GCPhaseTimes::print_stats(int level, const char* str, double value, uint workers) { | ||
1031 | @@ -450,7 +450,7 @@ | ||
1032 | |||
1033 | if (phase->_thread_work_items != NULL) { | ||
1034 | LineBuffer buf2(phase->_thread_work_items->_indent_level); | ||
1035 | - buf2.append_and_print_cr("[%s: "SIZE_FORMAT"]", phase->_thread_work_items->_title, _phase_times->sum_thread_work_items(phase_id)); | ||
1036 | + buf2.append_and_print_cr("[%s: " SIZE_FORMAT "]", phase->_thread_work_items->_title, _phase_times->sum_thread_work_items(phase_id)); | ||
1037 | } | ||
1038 | } | ||
1039 | |||
1040 | --- hotspot/src/share/vm/gc_implementation/g1/g1HRPrinter.cpp.orig 2015-09-02 10:57:01.000000000 +0200 | ||
1041 | +++ hotspot/src/share/vm/gc_implementation/g1/g1HRPrinter.cpp 2015-09-02 11:03:16.000000000 +0200 | ||
1042 | @@ -84,18 +84,18 @@ | ||
1043 | |||
1044 | if (type_str != NULL) { | ||
1045 | if (top != NULL) { | ||
1046 | - gclog_or_tty->print_cr(G1HR_PREFIX" %s(%s) "PTR_FORMAT" "PTR_FORMAT, | ||
1047 | + gclog_or_tty->print_cr(G1HR_PREFIX" %s(%s) " PTR_FORMAT " " PTR_FORMAT, | ||
1048 | action_str, type_str, bottom, top); | ||
1049 | } else { | ||
1050 | - gclog_or_tty->print_cr(G1HR_PREFIX" %s(%s) "PTR_FORMAT, | ||
1051 | + gclog_or_tty->print_cr(G1HR_PREFIX" %s(%s) " PTR_FORMAT, | ||
1052 | action_str, type_str, bottom); | ||
1053 | } | ||
1054 | } else { | ||
1055 | if (top != NULL) { | ||
1056 | - gclog_or_tty->print_cr(G1HR_PREFIX" %s "PTR_FORMAT" "PTR_FORMAT, | ||
1057 | + gclog_or_tty->print_cr(G1HR_PREFIX" %s " PTR_FORMAT " " PTR_FORMAT, | ||
1058 | action_str, bottom, top); | ||
1059 | } else { | ||
1060 | - gclog_or_tty->print_cr(G1HR_PREFIX" %s "PTR_FORMAT, | ||
1061 | + gclog_or_tty->print_cr(G1HR_PREFIX" %s " PTR_FORMAT, | ||
1062 | action_str, bottom); | ||
1063 | } | ||
1064 | } | ||
1065 | @@ -104,11 +104,11 @@ | ||
1066 | void G1HRPrinter::print(ActionType action, HeapWord* bottom, HeapWord* end) { | ||
1067 | const char* action_str = action_name(action); | ||
1068 | |||
1069 | - gclog_or_tty->print_cr(G1HR_PREFIX" %s ["PTR_FORMAT","PTR_FORMAT"]", | ||
1070 | + gclog_or_tty->print_cr(G1HR_PREFIX" %s [" PTR_FORMAT "," PTR_FORMAT "]", | ||
1071 | action_str, bottom, end); | ||
1072 | } | ||
1073 | |||
1074 | void G1HRPrinter::print(PhaseType phase, size_t phase_num) { | ||
1075 | const char* phase_str = phase_name(phase); | ||
1076 | - gclog_or_tty->print_cr(G1HR_PREFIX" #%s "SIZE_FORMAT, phase_str, phase_num); | ||
1077 | + gclog_or_tty->print_cr(G1HR_PREFIX" #%s " SIZE_FORMAT, phase_str, phase_num); | ||
1078 | } | ||
1079 | --- hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp.orig 2015-09-06 14:02:06.000000000 +0200 | ||
1080 | +++ hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp 2015-09-10 12:46:24.202030127 +0200 | ||
1081 | @@ -230,7 +230,7 @@ | ||
1082 | HeapRegion* last = NULL; | ||
1083 | while (curr != NULL) { | ||
1084 | if (!curr->is_young()) { | ||
1085 | - gclog_or_tty->print_cr("### YOUNG REGION "PTR_FORMAT"-"PTR_FORMAT" " | ||
1086 | + gclog_or_tty->print_cr("### YOUNG REGION " PTR_FORMAT "-" PTR_FORMAT " " | ||
1087 | "incorrectly tagged (y: %d, surv: %d)", | ||
1088 | curr->bottom(), curr->end(), | ||
1089 | curr->is_young(), curr->is_survivor()); | ||
1090 | @@ -359,7 +359,7 @@ | ||
1091 | if (curr == NULL) | ||
1092 | gclog_or_tty->print_cr(" empty"); | ||
1093 | while (curr != NULL) { | ||
1094 | - gclog_or_tty->print_cr(" "HR_FORMAT", P: "PTR_FORMAT ", N: "PTR_FORMAT", age: %4d", | ||
1095 | + gclog_or_tty->print_cr(" " HR_FORMAT ", P: " PTR_FORMAT ", N: " PTR_FORMAT ", age: %4d", | ||
1096 | HR_FORMAT_PARAMS(curr), | ||
1097 | curr->prev_top_at_mark_start(), | ||
1098 | curr->next_top_at_mark_start(), | ||
1099 | @@ -490,7 +490,7 @@ | ||
1100 | gclog_or_tty->print_cr("Log entries = %d, dirty cards = %d.", | ||
1101 | clear.num_processed(), orig_count); | ||
1102 | guarantee(redirty.num_processed() == clear.num_processed(), | ||
1103 | - err_msg("Redirtied "SIZE_FORMAT" cards, bug cleared "SIZE_FORMAT, | ||
1104 | + err_msg("Redirtied " SIZE_FORMAT " cards, bug cleared " SIZE_FORMAT, | ||
1105 | redirty.num_processed(), clear.num_processed())); | ||
1106 | |||
1107 | CountNonCleanMemRegionClosure count3(this); | ||
1108 | @@ -528,7 +528,7 @@ | ||
1109 | HeapRegion* res = _hrm.allocate_free_region(is_old); | ||
1110 | if (G1ConcRegionFreeingVerbose) { | ||
1111 | gclog_or_tty->print_cr("G1ConcRegionFreeing [region alloc] : " | ||
1112 | - "allocated "HR_FORMAT" from secondary_free_list", | ||
1113 | + "allocated " HR_FORMAT " from secondary_free_list", | ||
1114 | HR_FORMAT_PARAMS(res)); | ||
1115 | } | ||
1116 | return res; | ||
1117 | @@ -1597,8 +1597,8 @@ | ||
1118 | // This assert only makes sense here, before we adjust them | ||
1119 | // with respect to the min and max heap size. | ||
1120 | assert(minimum_desired_capacity <= maximum_desired_capacity, | ||
1121 | - err_msg("minimum_desired_capacity = "SIZE_FORMAT", " | ||
1122 | - "maximum_desired_capacity = "SIZE_FORMAT, | ||
1123 | + err_msg("minimum_desired_capacity = " SIZE_FORMAT ", " | ||
1124 | + "maximum_desired_capacity = " SIZE_FORMAT, | ||
1125 | minimum_desired_capacity, maximum_desired_capacity)); | ||
1126 | |||
1127 | // Should not be greater than the heap max size. No need to adjust | ||
1128 | @@ -2256,7 +2256,7 @@ | ||
1129 | virtual bool doHeapRegion(HeapRegion* hr) { | ||
1130 | unsigned region_gc_time_stamp = hr->get_gc_time_stamp(); | ||
1131 | if (_gc_time_stamp != region_gc_time_stamp) { | ||
1132 | - gclog_or_tty->print_cr("Region "HR_FORMAT" has GC time stamp = %d, " | ||
1133 | + gclog_or_tty->print_cr("Region " HR_FORMAT " has GC time stamp = %d, " | ||
1134 | "expected %d", HR_FORMAT_PARAMS(hr), | ||
1135 | region_gc_time_stamp, _gc_time_stamp); | ||
1136 | _failures = true; | ||
1137 | @@ -2678,7 +2678,7 @@ | ||
1138 | } else if (r->continuesHumongous()) { | ||
1139 | if (r->humongous_start_region() != _sh_region) { | ||
1140 | gclog_or_tty->print_cr("Region " HR_FORMAT ", " | ||
1141 | - "HS = "PTR_FORMAT", should be "PTR_FORMAT, | ||
1142 | + "HS = " PTR_FORMAT ", should be " PTR_FORMAT, | ||
1143 | HR_FORMAT_PARAMS(r), | ||
1144 | r->humongous_start_region(), | ||
1145 | _sh_region); | ||
1146 | @@ -2990,10 +2990,10 @@ | ||
1147 | if (!oopDesc::is_null(heap_oop)) { | ||
1148 | oop obj = oopDesc::decode_heap_oop_not_null(heap_oop); | ||
1149 | if (_g1h->is_obj_dead_cond(obj, _vo)) { | ||
1150 | - gclog_or_tty->print_cr("Root location "PTR_FORMAT" " | ||
1151 | - "points to dead obj "PTR_FORMAT, p, (void*) obj); | ||
1152 | + gclog_or_tty->print_cr("Root location " PTR_FORMAT " " | ||
1153 | + "points to dead obj " PTR_FORMAT, p, (void*) obj); | ||
1154 | if (_vo == VerifyOption_G1UseMarkWord) { | ||
1155 | - gclog_or_tty->print_cr(" Mark word: "PTR_FORMAT, (void*)(obj->mark())); | ||
1156 | + gclog_or_tty->print_cr(" Mark word: " PTR_FORMAT, (void*)(obj->mark())); | ||
1157 | } | ||
1158 | obj->print_on(gclog_or_tty); | ||
1159 | _failures = true; | ||
1160 | @@ -3040,9 +3040,9 @@ | ||
1161 | // Verify that the strong code root list for this region | ||
1162 | // contains the nmethod | ||
1163 | if (!hrrs->strong_code_roots_list_contains(_nm)) { | ||
1164 | - gclog_or_tty->print_cr("Code root location "PTR_FORMAT" " | ||
1165 | - "from nmethod "PTR_FORMAT" not in strong " | ||
1166 | - "code roots for region ["PTR_FORMAT","PTR_FORMAT")", | ||
1167 | + gclog_or_tty->print_cr("Code root location " PTR_FORMAT " " | ||
1168 | + "from nmethod " PTR_FORMAT " not in strong " | ||
1169 | + "code roots for region [" PTR_FORMAT "," PTR_FORMAT ")", | ||
1170 | p, _nm, hr->bottom(), hr->end()); | ||
1171 | _failures = true; | ||
1172 | } | ||
1173 | @@ -3172,7 +3172,7 @@ | ||
1174 | if (o != NULL) { | ||
1175 | HeapWord *start = (HeapWord *) o; | ||
1176 | size_t word_sz = o->size(); | ||
1177 | - gclog_or_tty->print("\nPrinting obj "PTR_FORMAT" of size " SIZE_FORMAT | ||
1178 | + gclog_or_tty->print("\nPrinting obj " PTR_FORMAT " of size " SIZE_FORMAT | ||
1179 | " isMarkedPrev %d isMarkedNext %d isAllocSince %d\n", | ||
1180 | (void*) o, word_sz, | ||
1181 | _g1->isMarkedPrev(o), | ||
1182 | @@ -3183,7 +3183,7 @@ | ||
1183 | int *val; | ||
1184 | for (cur = start; cur < end; cur++) { | ||
1185 | val = (int *) cur; | ||
1186 | - gclog_or_tty->print("\t "PTR_FORMAT":"PTR_FORMAT"\n", val, *val); | ||
1187 | + gclog_or_tty->print("\t " PTR_FORMAT ":" PTR_FORMAT "\n", val, *val); | ||
1188 | } | ||
1189 | } | ||
1190 | } | ||
1191 | @@ -3218,9 +3218,9 @@ | ||
1192 | r->object_iterate(¬_dead_yet_cl); | ||
1193 | if (_vo != VerifyOption_G1UseNextMarking) { | ||
1194 | if (r->max_live_bytes() < not_dead_yet_cl.live_bytes()) { | ||
1195 | - gclog_or_tty->print_cr("["PTR_FORMAT","PTR_FORMAT"] " | ||
1196 | - "max_live_bytes "SIZE_FORMAT" " | ||
1197 | - "< calculated "SIZE_FORMAT, | ||
1198 | + gclog_or_tty->print_cr("[" PTR_FORMAT "," PTR_FORMAT "] " | ||
1199 | + "max_live_bytes " SIZE_FORMAT " " | ||
1200 | + "< calculated " SIZE_FORMAT, | ||
1201 | r->bottom(), r->end(), | ||
1202 | r->max_live_bytes(), | ||
1203 | not_dead_yet_cl.live_bytes()); | ||
1204 | @@ -3532,7 +3532,7 @@ | ||
1205 | size_t occupied = hrrs->occupied(); | ||
1206 | _occupied_sum += occupied; | ||
1207 | |||
1208 | - gclog_or_tty->print_cr("Printing RSet for region "HR_FORMAT, | ||
1209 | + gclog_or_tty->print_cr("Printing RSet for region " HR_FORMAT, | ||
1210 | HR_FORMAT_PARAMS(r)); | ||
1211 | if (occupied == 0) { | ||
1212 | gclog_or_tty->print_cr(" RSet is empty"); | ||
1213 | @@ -3551,7 +3551,7 @@ | ||
1214 | } | ||
1215 | |||
1216 | ~PrintRSetsClosure() { | ||
1217 | - gclog_or_tty->print_cr("Occupied Sum: "SIZE_FORMAT, _occupied_sum); | ||
1218 | + gclog_or_tty->print_cr("Occupied Sum: " SIZE_FORMAT, _occupied_sum); | ||
1219 | gclog_or_tty->print_cr("========================================"); | ||
1220 | gclog_or_tty->cr(); | ||
1221 | } | ||
1222 | @@ -4372,7 +4372,7 @@ | ||
1223 | G1CollectedHeap::handle_evacuation_failure_par(G1ParScanThreadState* _par_scan_state, | ||
1224 | oop old) { | ||
1225 | assert(obj_in_cs(old), | ||
1226 | - err_msg("obj: "PTR_FORMAT" should still be in the CSet", | ||
1227 | + err_msg("obj: " PTR_FORMAT " should still be in the CSet", | ||
1228 | (HeapWord*) old)); | ||
1229 | markOop m = old->mark(); | ||
1230 | oop forward_ptr = old->forward_to_atomic(old); | ||
1231 | @@ -4406,7 +4406,7 @@ | ||
1232 | // space for this object (old != forward_ptr) or they beat us in | ||
1233 | // self-forwarding it (old == forward_ptr). | ||
1234 | assert(old == forward_ptr || !obj_in_cs(forward_ptr), | ||
1235 | - err_msg("obj: "PTR_FORMAT" forwarded to: "PTR_FORMAT" " | ||
1236 | + err_msg("obj: " PTR_FORMAT " forwarded to: " PTR_FORMAT " " | ||
1237 | "should not be in the CSet", | ||
1238 | (HeapWord*) old, (HeapWord*) forward_ptr)); | ||
1239 | return forward_ptr; | ||
1240 | @@ -4793,16 +4793,16 @@ | ||
1241 | |||
1242 | ~G1StringSymbolTableUnlinkTask() { | ||
1243 | guarantee(!_process_strings || !_do_in_parallel || StringTable::parallel_claimed_index() >= _initial_string_table_size, | ||
1244 | - err_msg("claim value "INT32_FORMAT" after unlink less than initial string table size "INT32_FORMAT, | ||
1245 | + err_msg("claim value " INT32_FORMAT " after unlink less than initial string table size " INT32_FORMAT, | ||
1246 | StringTable::parallel_claimed_index(), _initial_string_table_size)); | ||
1247 | guarantee(!_process_symbols || !_do_in_parallel || SymbolTable::parallel_claimed_index() >= _initial_symbol_table_size, | ||
1248 | - err_msg("claim value "INT32_FORMAT" after unlink less than initial symbol table size "INT32_FORMAT, | ||
1249 | + err_msg("claim value " INT32_FORMAT " after unlink less than initial symbol table size " INT32_FORMAT, | ||
1250 | SymbolTable::parallel_claimed_index(), _initial_symbol_table_size)); | ||
1251 | |||
1252 | if (G1TraceStringSymbolTableScrubbing) { | ||
1253 | gclog_or_tty->print_cr("Cleaned string and symbol table, " | ||
1254 | - "strings: "SIZE_FORMAT" processed, "SIZE_FORMAT" removed, " | ||
1255 | - "symbols: "SIZE_FORMAT" processed, "SIZE_FORMAT" removed", | ||
1256 | + "strings: " SIZE_FORMAT " processed, " SIZE_FORMAT " removed, " | ||
1257 | + "symbols: " SIZE_FORMAT " processed, " SIZE_FORMAT " removed", | ||
1258 | strings_processed(), strings_removed(), | ||
1259 | symbols_processed(), symbols_removed()); | ||
1260 | } | ||
1261 | @@ -6001,13 +6001,13 @@ | ||
1262 | bool G1CollectedHeap::verify_no_bits_over_tams(const char* bitmap_name, CMBitMapRO* bitmap, | ||
1263 | HeapWord* tams, HeapWord* end) { | ||
1264 | guarantee(tams <= end, | ||
1265 | - err_msg("tams: "PTR_FORMAT" end: "PTR_FORMAT, tams, end)); | ||
1266 | + err_msg("tams: " PTR_FORMAT " end: " PTR_FORMAT, tams, end)); | ||
1267 | HeapWord* result = bitmap->getNextMarkedWordAddress(tams, end); | ||
1268 | if (result < end) { | ||
1269 | gclog_or_tty->cr(); | ||
1270 | - gclog_or_tty->print_cr("## wrong marked address on %s bitmap: "PTR_FORMAT, | ||
1271 | + gclog_or_tty->print_cr("## wrong marked address on %s bitmap: " PTR_FORMAT, | ||
1272 | bitmap_name, result); | ||
1273 | - gclog_or_tty->print_cr("## %s tams: "PTR_FORMAT" end: "PTR_FORMAT, | ||
1274 | + gclog_or_tty->print_cr("## %s tams: " PTR_FORMAT " end: " PTR_FORMAT, | ||
1275 | bitmap_name, tams, end); | ||
1276 | return false; | ||
1277 | } | ||
1278 | @@ -6033,7 +6033,7 @@ | ||
1279 | res_n = verify_no_bits_over_tams("next", next_bitmap, ntams, end); | ||
1280 | } | ||
1281 | if (!res_p || !res_n) { | ||
1282 | - gclog_or_tty->print_cr("#### Bitmap verification failed for "HR_FORMAT, | ||
1283 | + gclog_or_tty->print_cr("#### Bitmap verification failed for " HR_FORMAT, | ||
1284 | HR_FORMAT_PARAMS(hr)); | ||
1285 | gclog_or_tty->print_cr("#### Caller: %s", caller); | ||
1286 | return false; | ||
1287 | @@ -6345,7 +6345,7 @@ | ||
1288 | !r->rem_set()->is_empty()) { | ||
1289 | |||
1290 | if (G1TraceEagerReclaimHumongousObjects) { | ||
1291 | - gclog_or_tty->print_cr("Live humongous region %u size "SIZE_FORMAT" start "PTR_FORMAT" length "UINT32_FORMAT" with remset "SIZE_FORMAT" code roots "SIZE_FORMAT" is marked %d reclaim candidate %d type array %d", | ||
1292 | + gclog_or_tty->print_cr("Live humongous region %u size " SIZE_FORMAT " start " PTR_FORMAT " length " UINT32_FORMAT " with remset " SIZE_FORMAT " code roots " SIZE_FORMAT " is marked %d reclaim candidate %d type array %d", | ||
1293 | region_idx, | ||
1294 | obj->size()*HeapWordSize, | ||
1295 | r->bottom(), | ||
1296 | @@ -6367,7 +6367,7 @@ | ||
1297 | r->bottom())); | ||
1298 | |||
1299 | if (G1TraceEagerReclaimHumongousObjects) { | ||
1300 | - gclog_or_tty->print_cr("Dead humongous region %u size "SIZE_FORMAT" start "PTR_FORMAT" length "UINT32_FORMAT" with remset "SIZE_FORMAT" code roots "SIZE_FORMAT" is marked %d reclaim candidate %d type array %d", | ||
1301 | + gclog_or_tty->print_cr("Dead humongous region %u size " SIZE_FORMAT " start " PTR_FORMAT " length " UINT32_FORMAT " with remset " SIZE_FORMAT " code roots " SIZE_FORMAT " is marked %d reclaim candidate %d type array %d", | ||
1302 | region_idx, | ||
1303 | obj->size()*HeapWordSize, | ||
1304 | r->bottom(), | ||
1305 | @@ -6523,7 +6523,7 @@ | ||
1306 | NoYoungRegionsClosure() : _success(true) { } | ||
1307 | bool doHeapRegion(HeapRegion* r) { | ||
1308 | if (r->is_young()) { | ||
1309 | - gclog_or_tty->print_cr("Region ["PTR_FORMAT", "PTR_FORMAT") tagged as young", | ||
1310 | + gclog_or_tty->print_cr("Region [" PTR_FORMAT ", " PTR_FORMAT ") tagged as young", | ||
1311 | r->bottom(), r->end()); | ||
1312 | _success = false; | ||
1313 | } | ||
1314 | @@ -6652,7 +6652,7 @@ | ||
1315 | } | ||
1316 | assert(_allocator->used_unlocked() == recalculate_used(), | ||
1317 | err_msg("inconsistent _allocator->used_unlocked(), " | ||
1318 | - "value: "SIZE_FORMAT" recalculated: "SIZE_FORMAT, | ||
1319 | + "value: " SIZE_FORMAT " recalculated: " SIZE_FORMAT, | ||
1320 | _allocator->used_unlocked(), recalculate_used())); | ||
1321 | } | ||
1322 | |||
1323 | @@ -6873,8 +6873,8 @@ | ||
1324 | oop obj = oopDesc::decode_heap_oop_not_null(heap_oop); | ||
1325 | HeapRegion* hr = _g1h->heap_region_containing(obj); | ||
1326 | assert(!hr->continuesHumongous(), | ||
1327 | - err_msg("trying to add code root "PTR_FORMAT" in continuation of humongous region "HR_FORMAT | ||
1328 | - " starting at "HR_FORMAT, | ||
1329 | + err_msg("trying to add code root " PTR_FORMAT " in continuation of humongous region " HR_FORMAT | ||
1330 | + " starting at " HR_FORMAT, | ||
1331 | _nm, HR_FORMAT_PARAMS(hr), HR_FORMAT_PARAMS(hr->humongous_start_region()))); | ||
1332 | |||
1333 | // HeapRegion::add_strong_code_root_locked() avoids adding duplicate entries. | ||
1334 | @@ -6900,8 +6900,8 @@ | ||
1335 | oop obj = oopDesc::decode_heap_oop_not_null(heap_oop); | ||
1336 | HeapRegion* hr = _g1h->heap_region_containing(obj); | ||
1337 | assert(!hr->continuesHumongous(), | ||
1338 | - err_msg("trying to remove code root "PTR_FORMAT" in continuation of humongous region "HR_FORMAT | ||
1339 | - " starting at "HR_FORMAT, | ||
1340 | + err_msg("trying to remove code root " PTR_FORMAT " in continuation of humongous region " HR_FORMAT | ||
1341 | + " starting at " HR_FORMAT, | ||
1342 | _nm, HR_FORMAT_PARAMS(hr), HR_FORMAT_PARAMS(hr->humongous_start_region()))); | ||
1343 | |||
1344 | hr->remove_strong_code_root(_nm); | ||
1345 | --- hotspot/src/share/vm/gc_implementation/g1/g1RemSet.cpp.orig 2015-09-02 11:07:35.000000000 +0200 | ||
1346 | +++ hotspot/src/share/vm/gc_implementation/g1/g1RemSet.cpp 2015-09-02 11:08:48.000000000 +0200 | ||
1347 | @@ -475,7 +475,7 @@ | ||
1348 | bool G1RemSet::refine_card(jbyte* card_ptr, uint worker_i, | ||
1349 | bool check_for_refs_into_cset) { | ||
1350 | assert(_g1->is_in_exact(_ct_bs->addr_for(card_ptr)), | ||
1351 | - err_msg("Card at "PTR_FORMAT" index "SIZE_FORMAT" representing heap at "PTR_FORMAT" (%u) must be in committed heap", | ||
1352 | + err_msg("Card at " PTR_FORMAT " index " SIZE_FORMAT " representing heap at " PTR_FORMAT " (%u) must be in committed heap", | ||
1353 | p2i(card_ptr), | ||
1354 | _ct_bs->index_for(_ct_bs->addr_for(card_ptr)), | ||
1355 | _ct_bs->addr_for(card_ptr), | ||
1356 | --- hotspot/src/share/vm/gc_implementation/g1/g1RemSetSummary.cpp.orig 2015-09-02 11:13:52.000000000 +0200 | ||
1357 | +++ hotspot/src/share/vm/gc_implementation/g1/g1RemSetSummary.cpp 2015-09-02 11:15:30.000000000 +0200 | ||
1358 | @@ -187,22 +187,22 @@ | ||
1359 | size_t code_root_elems() const { return _code_root_elems; } | ||
1360 | |||
1361 | void print_rs_mem_info_on(outputStream * out, size_t total) { | ||
1362 | - out->print_cr(" "SIZE_FORMAT_W(8)"K (%5.1f%%) by "SIZE_FORMAT" %s regions", | ||
1363 | + out->print_cr(" " SIZE_FORMAT_W(8) "K (%5.1f%%) by " SIZE_FORMAT " %s regions", | ||
1364 | round_to_K(rs_mem_size()), rs_mem_size_percent_of(total), amount(), _name); | ||
1365 | } | ||
1366 | |||
1367 | void print_cards_occupied_info_on(outputStream * out, size_t total) { | ||
1368 | - out->print_cr(" "SIZE_FORMAT_W(8)" (%5.1f%%) entries by "SIZE_FORMAT" %s regions", | ||
1369 | + out->print_cr(" " SIZE_FORMAT_W(8) " (%5.1f%%) entries by " SIZE_FORMAT " %s regions", | ||
1370 | cards_occupied(), cards_occupied_percent_of(total), amount(), _name); | ||
1371 | } | ||
1372 | |||
1373 | void print_code_root_mem_info_on(outputStream * out, size_t total) { | ||
1374 | - out->print_cr(" "SIZE_FORMAT_W(8)"K (%5.1f%%) by "SIZE_FORMAT" %s regions", | ||
1375 | + out->print_cr(" " SIZE_FORMAT_W(8) "K (%5.1f%%) by " SIZE_FORMAT " %s regions", | ||
1376 | round_to_K(code_root_mem_size()), code_root_mem_size_percent_of(total), amount(), _name); | ||
1377 | } | ||
1378 | |||
1379 | void print_code_root_elems_info_on(outputStream * out, size_t total) { | ||
1380 | - out->print_cr(" "SIZE_FORMAT_W(8)" (%5.1f%%) elements by "SIZE_FORMAT" %s regions", | ||
1381 | + out->print_cr(" " SIZE_FORMAT_W(8) " (%5.1f%%) elements by " SIZE_FORMAT " %s regions", | ||
1382 | code_root_elems(), code_root_elems_percent_of(total), amount(), _name); | ||
1383 | } | ||
1384 | }; | ||
1385 | @@ -280,19 +280,19 @@ | ||
1386 | RegionTypeCounter* counters[] = { &_young, &_humonguous, &_free, &_old, NULL }; | ||
1387 | |||
1388 | out->print_cr("\n Current rem set statistics"); | ||
1389 | - out->print_cr(" Total per region rem sets sizes = "SIZE_FORMAT"K." | ||
1390 | - " Max = "SIZE_FORMAT"K.", | ||
1391 | + out->print_cr(" Total per region rem sets sizes = " SIZE_FORMAT "K." | ||
1392 | + " Max = " SIZE_FORMAT "K.", | ||
1393 | round_to_K(total_rs_mem_sz()), round_to_K(max_rs_mem_sz())); | ||
1394 | for (RegionTypeCounter** current = &counters[0]; *current != NULL; current++) { | ||
1395 | (*current)->print_rs_mem_info_on(out, total_rs_mem_sz()); | ||
1396 | } | ||
1397 | |||
1398 | - out->print_cr(" Static structures = "SIZE_FORMAT"K," | ||
1399 | - " free_lists = "SIZE_FORMAT"K.", | ||
1400 | + out->print_cr(" Static structures = " SIZE_FORMAT "K," | ||
1401 | + " free_lists = " SIZE_FORMAT "K.", | ||
1402 | round_to_K(HeapRegionRemSet::static_mem_size()), | ||
1403 | round_to_K(HeapRegionRemSet::fl_mem_size())); | ||
1404 | |||
1405 | - out->print_cr(" "SIZE_FORMAT" occupied cards represented.", | ||
1406 | + out->print_cr(" " SIZE_FORMAT " occupied cards represented.", | ||
1407 | total_cards_occupied()); | ||
1408 | for (RegionTypeCounter** current = &counters[0]; *current != NULL; current++) { | ||
1409 | (*current)->print_cards_occupied_info_on(out, total_cards_occupied()); | ||
1410 | @@ -301,29 +301,29 @@ | ||
1411 | // Largest sized rem set region statistics | ||
1412 | HeapRegionRemSet* rem_set = max_rs_mem_sz_region()->rem_set(); | ||
1413 | out->print_cr(" Region with largest rem set = "HR_FORMAT", " | ||
1414 | - "size = "SIZE_FORMAT "K, occupied = "SIZE_FORMAT"K.", | ||
1415 | + "size = " SIZE_FORMAT "K, occupied = " SIZE_FORMAT "K.", | ||
1416 | HR_FORMAT_PARAMS(max_rs_mem_sz_region()), | ||
1417 | round_to_K(rem_set->mem_size()), | ||
1418 | round_to_K(rem_set->occupied())); | ||
1419 | |||
1420 | // Strong code root statistics | ||
1421 | HeapRegionRemSet* max_code_root_rem_set = max_code_root_mem_sz_region()->rem_set(); | ||
1422 | - out->print_cr(" Total heap region code root sets sizes = "SIZE_FORMAT"K." | ||
1423 | - " Max = "SIZE_FORMAT"K.", | ||
1424 | + out->print_cr(" Total heap region code root sets sizes = " SIZE_FORMAT "K." | ||
1425 | + " Max = " SIZE_FORMAT "K.", | ||
1426 | round_to_K(total_code_root_mem_sz()), | ||
1427 | round_to_K(max_code_root_rem_set->strong_code_roots_mem_size())); | ||
1428 | for (RegionTypeCounter** current = &counters[0]; *current != NULL; current++) { | ||
1429 | (*current)->print_code_root_mem_info_on(out, total_code_root_mem_sz()); | ||
1430 | } | ||
1431 | |||
1432 | - out->print_cr(" "SIZE_FORMAT" code roots represented.", | ||
1433 | + out->print_cr(" " SIZE_FORMAT " code roots represented.", | ||
1434 | total_code_root_elems()); | ||
1435 | for (RegionTypeCounter** current = &counters[0]; *current != NULL; current++) { | ||
1436 | (*current)->print_code_root_elems_info_on(out, total_code_root_elems()); | ||
1437 | } | ||
1438 | |||
1439 | - out->print_cr(" Region with largest amount of code roots = "HR_FORMAT", " | ||
1440 | - "size = "SIZE_FORMAT "K, num_elems = "SIZE_FORMAT".", | ||
1441 | + out->print_cr(" Region with largest amount of code roots = " HR_FORMAT ", " | ||
1442 | + "size = " SIZE_FORMAT "K, num_elems = " SIZE_FORMAT ".", | ||
1443 | HR_FORMAT_PARAMS(max_code_root_mem_sz_region()), | ||
1444 | round_to_K(max_code_root_rem_set->strong_code_roots_mem_size()), | ||
1445 | round_to_K(max_code_root_rem_set->strong_code_roots_list_length())); | ||
1446 | @@ -332,16 +332,16 @@ | ||
1447 | |||
1448 | void G1RemSetSummary::print_on(outputStream* out) { | ||
1449 | out->print_cr("\n Recent concurrent refinement statistics"); | ||
1450 | - out->print_cr(" Processed "SIZE_FORMAT" cards", | ||
1451 | + out->print_cr(" Processed " SIZE_FORMAT " cards", | ||
1452 | num_concurrent_refined_cards()); | ||
1453 | - out->print_cr(" Of "SIZE_FORMAT" completed buffers:", num_processed_buf_total()); | ||
1454 | - out->print_cr(" "SIZE_FORMAT_W(8)" (%5.1f%%) by concurrent RS threads.", | ||
1455 | + out->print_cr(" Of " SIZE_FORMAT " completed buffers:", num_processed_buf_total()); | ||
1456 | + out->print_cr(" " SIZE_FORMAT_W(8) " (%5.1f%%) by concurrent RS threads.", | ||
1457 | num_processed_buf_total(), | ||
1458 | percent_of(num_processed_buf_rs_threads(), num_processed_buf_total())); | ||
1459 | - out->print_cr(" "SIZE_FORMAT_W(8)" (%5.1f%%) by mutator threads.", | ||
1460 | + out->print_cr(" " SIZE_FORMAT_W(8) " (%5.1f%%) by mutator threads.", | ||
1461 | num_processed_buf_mutator(), | ||
1462 | percent_of(num_processed_buf_mutator(), num_processed_buf_total())); | ||
1463 | - out->print_cr(" Did "SIZE_FORMAT" coarsenings.", num_coarsenings()); | ||
1464 | + out->print_cr(" Did " SIZE_FORMAT " coarsenings.", num_coarsenings()); | ||
1465 | out->print_cr(" Concurrent RS threads times (s)"); | ||
1466 | out->print(" "); | ||
1467 | for (uint i = 0; i < _num_vtimes; i++) { | ||
1468 | --- hotspot/src/share/vm/gc_implementation/g1/g1StringDedupQueue.cpp.orig 2015-09-02 11:13:52.000000000 +0200 | ||
1469 | +++ hotspot/src/share/vm/gc_implementation/g1/g1StringDedupQueue.cpp 2015-09-02 11:15:44.000000000 +0200 | ||
1470 | @@ -151,7 +151,7 @@ | ||
1471 | void G1StringDedupQueue::print_statistics(outputStream* st) { | ||
1472 | st->print_cr( | ||
1473 | " [Queue]\n" | ||
1474 | - " [Dropped: "UINTX_FORMAT"]", _queue->_dropped); | ||
1475 | + " [Dropped: " UINTX_FORMAT "]", _queue->_dropped); | ||
1476 | } | ||
1477 | |||
1478 | void G1StringDedupQueue::verify() { | ||
1479 | --- hotspot/src/share/vm/gc_implementation/g1/g1StringDedupStat.cpp.orig 2015-09-02 11:13:52.000000000 +0200 | ||
1480 | +++ hotspot/src/share/vm/gc_implementation/g1/g1StringDedupStat.cpp 2015-09-02 11:18:07.000000000 +0200 | ||
1481 | @@ -80,8 +80,8 @@ | ||
1482 | st->stamp(PrintGCTimeStamps); | ||
1483 | st->print_cr( | ||
1484 | "[GC concurrent-string-deduplication, " | ||
1485 | - G1_STRDEDUP_BYTES_FORMAT_NS"->"G1_STRDEDUP_BYTES_FORMAT_NS"("G1_STRDEDUP_BYTES_FORMAT_NS"), avg " | ||
1486 | - G1_STRDEDUP_PERCENT_FORMAT_NS", "G1_STRDEDUP_TIME_FORMAT"]", | ||
1487 | + G1_STRDEDUP_BYTES_FORMAT_NS "->" G1_STRDEDUP_BYTES_FORMAT_NS "(" G1_STRDEDUP_BYTES_FORMAT_NS "), avg " | ||
1488 | + G1_STRDEDUP_PERCENT_FORMAT_NS ", " G1_STRDEDUP_TIME_FORMAT "]", | ||
1489 | G1_STRDEDUP_BYTES_PARAM(last_stat._new_bytes), | ||
1490 | G1_STRDEDUP_BYTES_PARAM(last_stat._new_bytes - last_stat._deduped_bytes), | ||
1491 | G1_STRDEDUP_BYTES_PARAM(last_stat._deduped_bytes), | ||
1492 | @@ -135,22 +135,22 @@ | ||
1493 | |||
1494 | if (total) { | ||
1495 | st->print_cr( | ||
1496 | - " [Total Exec: "UINTX_FORMAT"/"G1_STRDEDUP_TIME_FORMAT", Idle: "UINTX_FORMAT"/"G1_STRDEDUP_TIME_FORMAT", Blocked: "UINTX_FORMAT"/"G1_STRDEDUP_TIME_FORMAT"]", | ||
1497 | + " [Total Exec: " UINTX_FORMAT "/" G1_STRDEDUP_TIME_FORMAT ", Idle: " UINTX_FORMAT "/" G1_STRDEDUP_TIME_FORMAT ", Blocked: " UINTX_FORMAT "/" G1_STRDEDUP_TIME_FORMAT "]", | ||
1498 | stat._exec, stat._exec_elapsed, stat._idle, stat._idle_elapsed, stat._block, stat._block_elapsed); | ||
1499 | } else { | ||
1500 | st->print_cr( | ||
1501 | - " [Last Exec: "G1_STRDEDUP_TIME_FORMAT", Idle: "G1_STRDEDUP_TIME_FORMAT", Blocked: "UINTX_FORMAT"/"G1_STRDEDUP_TIME_FORMAT"]", | ||
1502 | + " [Last Exec: " G1_STRDEDUP_TIME_FORMAT ", Idle: " G1_STRDEDUP_TIME_FORMAT ", Blocked: " UINTX_FORMAT "/" G1_STRDEDUP_TIME_FORMAT "]", | ||
1503 | stat._exec_elapsed, stat._idle_elapsed, stat._block, stat._block_elapsed); | ||
1504 | } | ||
1505 | st->print_cr( | ||
1506 | - " [Inspected: "G1_STRDEDUP_OBJECTS_FORMAT"]\n" | ||
1507 | - " [Skipped: "G1_STRDEDUP_OBJECTS_FORMAT"("G1_STRDEDUP_PERCENT_FORMAT")]\n" | ||
1508 | - " [Hashed: "G1_STRDEDUP_OBJECTS_FORMAT"("G1_STRDEDUP_PERCENT_FORMAT")]\n" | ||
1509 | - " [Known: "G1_STRDEDUP_OBJECTS_FORMAT"("G1_STRDEDUP_PERCENT_FORMAT")]\n" | ||
1510 | - " [New: "G1_STRDEDUP_OBJECTS_FORMAT"("G1_STRDEDUP_PERCENT_FORMAT") "G1_STRDEDUP_BYTES_FORMAT"]\n" | ||
1511 | - " [Deduplicated: "G1_STRDEDUP_OBJECTS_FORMAT"("G1_STRDEDUP_PERCENT_FORMAT") "G1_STRDEDUP_BYTES_FORMAT"("G1_STRDEDUP_PERCENT_FORMAT")]\n" | ||
1512 | - " [Young: "G1_STRDEDUP_OBJECTS_FORMAT"("G1_STRDEDUP_PERCENT_FORMAT") "G1_STRDEDUP_BYTES_FORMAT"("G1_STRDEDUP_PERCENT_FORMAT")]\n" | ||
1513 | - " [Old: "G1_STRDEDUP_OBJECTS_FORMAT"("G1_STRDEDUP_PERCENT_FORMAT") "G1_STRDEDUP_BYTES_FORMAT"("G1_STRDEDUP_PERCENT_FORMAT")]", | ||
1514 | + " [Inspected: " G1_STRDEDUP_OBJECTS_FORMAT "]\n" | ||
1515 | + " [Skipped: " G1_STRDEDUP_OBJECTS_FORMAT "(" G1_STRDEDUP_PERCENT_FORMAT ")]\n" | ||
1516 | + " [Hashed: " G1_STRDEDUP_OBJECTS_FORMAT "(" G1_STRDEDUP_PERCENT_FORMAT ")]\n" | ||
1517 | + " [Known: " G1_STRDEDUP_OBJECTS_FORMAT "(" G1_STRDEDUP_PERCENT_FORMAT ")]\n" | ||
1518 | + " [New: " G1_STRDEDUP_OBJECTS_FORMAT "(" G1_STRDEDUP_PERCENT_FORMAT ") " G1_STRDEDUP_BYTES_FORMAT "]\n" | ||
1519 | + " [Deduplicated: " G1_STRDEDUP_OBJECTS_FORMAT "(" G1_STRDEDUP_PERCENT_FORMAT ") " G1_STRDEDUP_BYTES_FORMAT "(" G1_STRDEDUP_PERCENT_FORMAT ")]\n" | ||
1520 | + " [Young: " G1_STRDEDUP_OBJECTS_FORMAT "(" G1_STRDEDUP_PERCENT_FORMAT ") " G1_STRDEDUP_BYTES_FORMAT "(" G1_STRDEDUP_PERCENT_FORMAT ")]\n" | ||
1521 | + " [Old: " G1_STRDEDUP_OBJECTS_FORMAT "(" G1_STRDEDUP_PERCENT_FORMAT ") " G1_STRDEDUP_BYTES_FORMAT "(" G1_STRDEDUP_PERCENT_FORMAT ")]", | ||
1522 | stat._inspected, | ||
1523 | stat._skipped, skipped_percent, | ||
1524 | stat._hashed, hashed_percent, | ||
1525 | --- hotspot/src/share/vm/gc_implementation/g1/g1RemSetSummary.cpp.orig 2015-09-02 12:36:40.000000000 +0200 | ||
1526 | +++ hotspot/src/share/vm/gc_implementation/g1/g1RemSetSummary.cpp 2015-09-02 12:37:19.000000000 +0200 | ||
1527 | @@ -300,7 +300,7 @@ | ||
1528 | |||
1529 | // Largest sized rem set region statistics | ||
1530 | HeapRegionRemSet* rem_set = max_rs_mem_sz_region()->rem_set(); | ||
1531 | - out->print_cr(" Region with largest rem set = "HR_FORMAT", " | ||
1532 | + out->print_cr(" Region with largest rem set = " HR_FORMAT ", " | ||
1533 | "size = " SIZE_FORMAT "K, occupied = " SIZE_FORMAT "K.", | ||
1534 | HR_FORMAT_PARAMS(max_rs_mem_sz_region()), | ||
1535 | round_to_K(rem_set->mem_size()), | ||
1536 | --- hotspot/src/share/vm/gc_implementation/g1/g1StringDedupTable.cpp.orig 2015-09-02 12:36:40.000000000 +0200 | ||
1537 | +++ hotspot/src/share/vm/gc_implementation/g1/g1StringDedupTable.cpp 2015-09-02 12:41:56.000000000 +0200 | ||
1538 | @@ -554,12 +554,12 @@ | ||
1539 | void G1StringDedupTable::print_statistics(outputStream* st) { | ||
1540 | st->print_cr( | ||
1541 | " [Table]\n" | ||
1542 | - " [Memory Usage: "G1_STRDEDUP_BYTES_FORMAT_NS"]\n" | ||
1543 | - " [Size: "SIZE_FORMAT", Min: "SIZE_FORMAT", Max: "SIZE_FORMAT"]\n" | ||
1544 | - " [Entries: "UINTX_FORMAT", Load: "G1_STRDEDUP_PERCENT_FORMAT_NS", Cached: " UINTX_FORMAT ", Added: "UINTX_FORMAT", Removed: "UINTX_FORMAT"]\n" | ||
1545 | - " [Resize Count: "UINTX_FORMAT", Shrink Threshold: "UINTX_FORMAT"("G1_STRDEDUP_PERCENT_FORMAT_NS"), Grow Threshold: "UINTX_FORMAT"("G1_STRDEDUP_PERCENT_FORMAT_NS")]\n" | ||
1546 | - " [Rehash Count: "UINTX_FORMAT", Rehash Threshold: "UINTX_FORMAT", Hash Seed: 0x%x]\n" | ||
1547 | - " [Age Threshold: "UINTX_FORMAT"]", | ||
1548 | + " [Memory Usage: " G1_STRDEDUP_BYTES_FORMAT_NS "]\n" | ||
1549 | + " [Size: " SIZE_FORMAT ", Min: " SIZE_FORMAT ", Max: " SIZE_FORMAT "]\n" | ||
1550 | + " [Entries: " UINTX_FORMAT ", Load: " G1_STRDEDUP_PERCENT_FORMAT_NS ", Cached: " UINTX_FORMAT ", Added: " UINTX_FORMAT ", Removed: " UINTX_FORMAT "]\n" | ||
1551 | + " [Resize Count: " UINTX_FORMAT ", Shrink Threshold: " UINTX_FORMAT "(" G1_STRDEDUP_PERCENT_FORMAT_NS "), Grow Threshold: " UINTX_FORMAT "(" G1_STRDEDUP_PERCENT_FORMAT_NS ")]\n" | ||
1552 | + " [Rehash Count: " UINTX_FORMAT ", Rehash Threshold: " UINTX_FORMAT ", Hash Seed: 0x%x]\n" | ||
1553 | + " [Age Threshold: " UINTX_FORMAT "]", | ||
1554 | G1_STRDEDUP_BYTES_PARAM(_table->_size * sizeof(G1StringDedupEntry*) + (_table->_entries + _entry_cache->size()) * sizeof(G1StringDedupEntry)), | ||
1555 | _table->_size, _min_size, _max_size, | ||
1556 | _table->_entries, (double)_table->_entries / (double)_table->_size * 100.0, _entry_cache->size(), _entries_added, _entries_removed, | ||
1557 | --- hotspot/src/share/vm/memory/genCollectedHeap.cpp.orig 2015-09-02 12:51:37.000000000 +0200 | ||
1558 | +++ hotspot/src/share/vm/memory/genCollectedHeap.cpp 2015-09-02 12:52:12.000000000 +0200 | ||
1559 | @@ -1315,7 +1315,7 @@ | ||
1560 | // back a time later than 'now'. | ||
1561 | jlong retVal = now - tolgc_cl.time(); | ||
1562 | if (retVal < 0) { | ||
1563 | - NOT_PRODUCT(warning("time warp: "INT64_FORMAT, (int64_t) retVal);) | ||
1564 | + NOT_PRODUCT(warning("time warp: " INT64_FORMAT, (int64_t) retVal);) | ||
1565 | return 0; | ||
1566 | } | ||
1567 | return retVal; | ||
1568 | --- hotspot/src/share/vm/memory/generation.cpp.orig 2015-09-02 12:51:38.000000000 +0200 | ||
1569 | +++ hotspot/src/share/vm/memory/generation.cpp 2015-09-02 12:52:33.000000000 +0200 | ||
1570 | @@ -187,7 +187,7 @@ | ||
1571 | bool res = (available >= max_promotion_in_bytes); | ||
1572 | if (PrintGC && Verbose) { | ||
1573 | gclog_or_tty->print_cr( | ||
1574 | - "Generation: promo attempt is%s safe: available("SIZE_FORMAT") %s max_promo("SIZE_FORMAT")", | ||
1575 | + "Generation: promo attempt is%s safe: available(" SIZE_FORMAT ") %s max_promo(" SIZE_FORMAT ")", | ||
1576 | res? "":" not", available, res? ">=":"<", | ||
1577 | max_promotion_in_bytes); | ||
1578 | } | ||
1579 | --- hotspot/src/share/vm/gc_implementation/g1/heapRegion.cpp.orig 2015-09-02 12:57:25.000000000 +0200 | ||
1580 | +++ hotspot/src/share/vm/gc_implementation/g1/heapRegion.cpp 2015-09-02 13:00:29.000000000 +0200 | ||
1581 | @@ -371,7 +371,7 @@ | ||
1582 | bool during_conc_mark, | ||
1583 | size_t marked_bytes) { | ||
1584 | assert(0 <= marked_bytes && marked_bytes <= used(), | ||
1585 | - err_msg("marked: "SIZE_FORMAT" used: "SIZE_FORMAT, | ||
1586 | + err_msg("marked: " SIZE_FORMAT " used: " SIZE_FORMAT, | ||
1587 | marked_bytes, used())); | ||
1588 | _prev_top_at_mark_start = top(); | ||
1589 | _prev_marked_bytes = marked_bytes; | ||
1590 | @@ -559,9 +559,9 @@ | ||
1591 | // Object is in the region. Check that its less than top | ||
1592 | if (_hr->top() <= (HeapWord*)obj) { | ||
1593 | // Object is above top | ||
1594 | - gclog_or_tty->print_cr("Object "PTR_FORMAT" in region " | ||
1595 | - "["PTR_FORMAT", "PTR_FORMAT") is above " | ||
1596 | - "top "PTR_FORMAT, | ||
1597 | + gclog_or_tty->print_cr("Object " PTR_FORMAT " in region " | ||
1598 | + "[" PTR_FORMAT ", " PTR_FORMAT ") is above " | ||
1599 | + "top " PTR_FORMAT, | ||
1600 | (void *)obj, _hr->bottom(), _hr->end(), _hr->top()); | ||
1601 | _failures = true; | ||
1602 | return; | ||
1603 | @@ -595,22 +595,22 @@ | ||
1604 | if (nm != NULL) { | ||
1605 | // Verify that the nemthod is live | ||
1606 | if (!nm->is_alive()) { | ||
1607 | - gclog_or_tty->print_cr("region ["PTR_FORMAT","PTR_FORMAT"] has dead nmethod " | ||
1608 | - PTR_FORMAT" in its strong code roots", | ||
1609 | + gclog_or_tty->print_cr("region [" PTR_FORMAT "," PTR_FORMAT "] has dead nmethod " | ||
1610 | + PTR_FORMAT " in its strong code roots", | ||
1611 | _hr->bottom(), _hr->end(), nm); | ||
1612 | _failures = true; | ||
1613 | } else { | ||
1614 | VerifyStrongCodeRootOopClosure oop_cl(_hr, nm); | ||
1615 | nm->oops_do(&oop_cl); | ||
1616 | if (!oop_cl.has_oops_in_region()) { | ||
1617 | - gclog_or_tty->print_cr("region ["PTR_FORMAT","PTR_FORMAT"] has nmethod " | ||
1618 | - PTR_FORMAT" in its strong code roots " | ||
1619 | + gclog_or_tty->print_cr("region [" PTR_FORMAT "," PTR_FORMAT "] has nmethod " | ||
1620 | + PTR_FORMAT " in its strong code roots " | ||
1621 | "with no pointers into region", | ||
1622 | _hr->bottom(), _hr->end(), nm); | ||
1623 | _failures = true; | ||
1624 | } else if (oop_cl.failures()) { | ||
1625 | - gclog_or_tty->print_cr("region ["PTR_FORMAT","PTR_FORMAT"] has other " | ||
1626 | - "failures for nmethod "PTR_FORMAT, | ||
1627 | + gclog_or_tty->print_cr("region [" PTR_FORMAT "," PTR_FORMAT "] has other " | ||
1628 | + "failures for nmethod " PTR_FORMAT, | ||
1629 | _hr->bottom(), _hr->end(), nm); | ||
1630 | _failures = true; | ||
1631 | } | ||
1632 | @@ -644,8 +644,8 @@ | ||
1633 | // on its strong code root list | ||
1634 | if (is_empty()) { | ||
1635 | if (strong_code_roots_length > 0) { | ||
1636 | - gclog_or_tty->print_cr("region ["PTR_FORMAT","PTR_FORMAT"] is empty " | ||
1637 | - "but has "SIZE_FORMAT" code root entries", | ||
1638 | + gclog_or_tty->print_cr("region [" PTR_FORMAT "," PTR_FORMAT "] is empty " | ||
1639 | + "but has " SIZE_FORMAT " code root entries", | ||
1640 | bottom(), end(), strong_code_roots_length); | ||
1641 | *failures = true; | ||
1642 | } | ||
1643 | @@ -654,8 +654,8 @@ | ||
1644 | |||
1645 | if (continuesHumongous()) { | ||
1646 | if (strong_code_roots_length > 0) { | ||
1647 | - gclog_or_tty->print_cr("region "HR_FORMAT" is a continuation of a humongous " | ||
1648 | - "region but has "SIZE_FORMAT" code root entries", | ||
1649 | + gclog_or_tty->print_cr("region " HR_FORMAT " is a continuation of a humongous " | ||
1650 | + "region but has " SIZE_FORMAT " code root entries", | ||
1651 | HR_FORMAT_PARAMS(this), strong_code_roots_length); | ||
1652 | *failures = true; | ||
1653 | } | ||
1654 | @@ -679,7 +679,7 @@ | ||
1655 | else | ||
1656 | st->print(" "); | ||
1657 | st->print(" TS %5d", _gc_time_stamp); | ||
1658 | - st->print(" PTAMS "PTR_FORMAT" NTAMS "PTR_FORMAT, | ||
1659 | + st->print(" PTAMS " PTR_FORMAT " NTAMS " PTR_FORMAT, | ||
1660 | prev_top_at_mark_start(), next_top_at_mark_start()); | ||
1661 | G1OffsetTableContigSpace::print_on(st); | ||
1662 | } | ||
1663 | @@ -744,25 +744,25 @@ | ||
1664 | } | ||
1665 | if (!_g1h->is_in_closed_subset(obj)) { | ||
1666 | HeapRegion* from = _g1h->heap_region_containing((HeapWord*)p); | ||
1667 | - gclog_or_tty->print_cr("Field "PTR_FORMAT | ||
1668 | - " of live obj "PTR_FORMAT" in region " | ||
1669 | - "["PTR_FORMAT", "PTR_FORMAT")", | ||
1670 | + gclog_or_tty->print_cr("Field " PTR_FORMAT | ||
1671 | + " of live obj " PTR_FORMAT " in region " | ||
1672 | + "[" PTR_FORMAT ", " PTR_FORMAT ")", | ||
1673 | p, (void*) _containing_obj, | ||
1674 | from->bottom(), from->end()); | ||
1675 | print_object(gclog_or_tty, _containing_obj); | ||
1676 | - gclog_or_tty->print_cr("points to obj "PTR_FORMAT" not in the heap", | ||
1677 | + gclog_or_tty->print_cr("points to obj " PTR_FORMAT " not in the heap", | ||
1678 | (void*) obj); | ||
1679 | } else { | ||
1680 | HeapRegion* from = _g1h->heap_region_containing((HeapWord*)p); | ||
1681 | HeapRegion* to = _g1h->heap_region_containing((HeapWord*)obj); | ||
1682 | - gclog_or_tty->print_cr("Field "PTR_FORMAT | ||
1683 | - " of live obj "PTR_FORMAT" in region " | ||
1684 | - "["PTR_FORMAT", "PTR_FORMAT")", | ||
1685 | + gclog_or_tty->print_cr("Field " PTR_FORMAT | ||
1686 | + " of live obj " PTR_FORMAT " in region " | ||
1687 | + "[" PTR_FORMAT ", " PTR_FORMAT ")", | ||
1688 | p, (void*) _containing_obj, | ||
1689 | from->bottom(), from->end()); | ||
1690 | print_object(gclog_or_tty, _containing_obj); | ||
1691 | - gclog_or_tty->print_cr("points to dead obj "PTR_FORMAT" in region " | ||
1692 | - "["PTR_FORMAT", "PTR_FORMAT")", | ||
1693 | + gclog_or_tty->print_cr("points to dead obj " PTR_FORMAT " in region " | ||
1694 | + "[" PTR_FORMAT ", " PTR_FORMAT ")", | ||
1695 | (void*) obj, to->bottom(), to->end()); | ||
1696 | print_object(gclog_or_tty, obj); | ||
1697 | } | ||
1698 | @@ -798,14 +798,14 @@ | ||
1699 | gclog_or_tty->print_cr("----------"); | ||
1700 | } | ||
1701 | gclog_or_tty->print_cr("Missing rem set entry:"); | ||
1702 | - gclog_or_tty->print_cr("Field "PTR_FORMAT" " | ||
1703 | - "of obj "PTR_FORMAT", " | ||
1704 | - "in region "HR_FORMAT, | ||
1705 | + gclog_or_tty->print_cr("Field " PTR_FORMAT " " | ||
1706 | + "of obj " PTR_FORMAT ", " | ||
1707 | + "in region " HR_FORMAT, | ||
1708 | p, (void*) _containing_obj, | ||
1709 | HR_FORMAT_PARAMS(from)); | ||
1710 | _containing_obj->print_on(gclog_or_tty); | ||
1711 | - gclog_or_tty->print_cr("points to obj "PTR_FORMAT" " | ||
1712 | - "in region "HR_FORMAT, | ||
1713 | + gclog_or_tty->print_cr("points to obj " PTR_FORMAT " " | ||
1714 | + "in region " HR_FORMAT, | ||
1715 | (void*) obj, | ||
1716 | HR_FORMAT_PARAMS(to)); | ||
1717 | obj->print_on(gclog_or_tty); | ||
1718 | @@ -842,8 +842,8 @@ | ||
1719 | |||
1720 | if (is_humongous != g1->isHumongous(obj_size) && | ||
1721 | !g1->is_obj_dead(obj, this)) { // Dead objects may have bigger block_size since they span several objects. | ||
1722 | - gclog_or_tty->print_cr("obj "PTR_FORMAT" is of %shumongous size (" | ||
1723 | - SIZE_FORMAT" words) in a %shumongous region", | ||
1724 | + gclog_or_tty->print_cr("obj " PTR_FORMAT " is of %shumongous size (" | ||
1725 | + SIZE_FORMAT " words) in a %shumongous region", | ||
1726 | p, g1->isHumongous(obj_size) ? "" : "non-", | ||
1727 | obj_size, is_humongous ? "" : "non-"); | ||
1728 | *failures = true; | ||
1729 | @@ -866,12 +866,12 @@ | ||
1730 | (vo == VerifyOption_G1UsePrevMarking && | ||
1731 | ClassLoaderDataGraph::unload_list_contains(klass)); | ||
1732 | if (!is_metaspace_object) { | ||
1733 | - gclog_or_tty->print_cr("klass "PTR_FORMAT" of object "PTR_FORMAT" " | ||
1734 | + gclog_or_tty->print_cr("klass " PTR_FORMAT " of object " PTR_FORMAT " " | ||
1735 | "not metadata", klass, (void *)obj); | ||
1736 | *failures = true; | ||
1737 | return; | ||
1738 | } else if (!klass->is_klass()) { | ||
1739 | - gclog_or_tty->print_cr("klass "PTR_FORMAT" of object "PTR_FORMAT" " | ||
1740 | + gclog_or_tty->print_cr("klass " PTR_FORMAT " of object " PTR_FORMAT " " | ||
1741 | "not a klass", klass, (void *)obj); | ||
1742 | *failures = true; | ||
1743 | return; | ||
1744 | @@ -887,7 +887,7 @@ | ||
1745 | } | ||
1746 | } | ||
1747 | } else { | ||
1748 | - gclog_or_tty->print_cr(PTR_FORMAT" no an oop", (void *)obj); | ||
1749 | + gclog_or_tty->print_cr(PTR_FORMAT " no an oop", (void *)obj); | ||
1750 | *failures = true; | ||
1751 | return; | ||
1752 | } | ||
1753 | @@ -897,8 +897,8 @@ | ||
1754 | } | ||
1755 | |||
1756 | if (p != top()) { | ||
1757 | - gclog_or_tty->print_cr("end of last object "PTR_FORMAT" " | ||
1758 | - "does not match top "PTR_FORMAT, p, top()); | ||
1759 | + gclog_or_tty->print_cr("end of last object " PTR_FORMAT " " | ||
1760 | + "does not match top " PTR_FORMAT, p, top()); | ||
1761 | *failures = true; | ||
1762 | return; | ||
1763 | } | ||
1764 | @@ -913,8 +913,8 @@ | ||
1765 | HeapWord* addr_1 = p; | ||
1766 | HeapWord* b_start_1 = _offsets.block_start_const(addr_1); | ||
1767 | if (b_start_1 != p) { | ||
1768 | - gclog_or_tty->print_cr("BOT look up for top: "PTR_FORMAT" " | ||
1769 | - " yielded "PTR_FORMAT", expecting "PTR_FORMAT, | ||
1770 | + gclog_or_tty->print_cr("BOT look up for top: " PTR_FORMAT " " | ||
1771 | + " yielded " PTR_FORMAT ", expecting " PTR_FORMAT, | ||
1772 | addr_1, b_start_1, p); | ||
1773 | *failures = true; | ||
1774 | return; | ||
1775 | @@ -925,8 +925,8 @@ | ||
1776 | if (addr_2 < the_end) { | ||
1777 | HeapWord* b_start_2 = _offsets.block_start_const(addr_2); | ||
1778 | if (b_start_2 != p) { | ||
1779 | - gclog_or_tty->print_cr("BOT look up for top + 1: "PTR_FORMAT" " | ||
1780 | - " yielded "PTR_FORMAT", expecting "PTR_FORMAT, | ||
1781 | + gclog_or_tty->print_cr("BOT look up for top + 1: " PTR_FORMAT " " | ||
1782 | + " yielded " PTR_FORMAT ", expecting " PTR_FORMAT, | ||
1783 | addr_2, b_start_2, p); | ||
1784 | *failures = true; | ||
1785 | return; | ||
1786 | @@ -939,8 +939,8 @@ | ||
1787 | if (addr_3 < the_end) { | ||
1788 | HeapWord* b_start_3 = _offsets.block_start_const(addr_3); | ||
1789 | if (b_start_3 != p) { | ||
1790 | - gclog_or_tty->print_cr("BOT look up for top + diff: "PTR_FORMAT" " | ||
1791 | - " yielded "PTR_FORMAT", expecting "PTR_FORMAT, | ||
1792 | + gclog_or_tty->print_cr("BOT look up for top + diff: " PTR_FORMAT " " | ||
1793 | + " yielded " PTR_FORMAT ", expecting " PTR_FORMAT, | ||
1794 | addr_3, b_start_3, p); | ||
1795 | *failures = true; | ||
1796 | return; | ||
1797 | @@ -951,8 +951,8 @@ | ||
1798 | HeapWord* addr_4 = the_end - 1; | ||
1799 | HeapWord* b_start_4 = _offsets.block_start_const(addr_4); | ||
1800 | if (b_start_4 != p) { | ||
1801 | - gclog_or_tty->print_cr("BOT look up for end - 1: "PTR_FORMAT" " | ||
1802 | - " yielded "PTR_FORMAT", expecting "PTR_FORMAT, | ||
1803 | + gclog_or_tty->print_cr("BOT look up for end - 1: " PTR_FORMAT " " | ||
1804 | + " yielded " PTR_FORMAT ", expecting " PTR_FORMAT, | ||
1805 | addr_4, b_start_4, p); | ||
1806 | *failures = true; | ||
1807 | return; | ||
1808 | @@ -960,8 +960,8 @@ | ||
1809 | } | ||
1810 | |||
1811 | if (is_humongous && object_num > 1) { | ||
1812 | - gclog_or_tty->print_cr("region ["PTR_FORMAT","PTR_FORMAT"] is humongous " | ||
1813 | - "but has "SIZE_FORMAT", objects", | ||
1814 | + gclog_or_tty->print_cr("region [" PTR_FORMAT "," PTR_FORMAT "] is humongous " | ||
1815 | + "but has " SIZE_FORMAT ", objects", | ||
1816 | bottom(), end(), object_num); | ||
1817 | *failures = true; | ||
1818 | return; | ||
1819 | --- hotspot/src/share/vm/gc_implementation/g1/heapRegionManager.cpp.orig 2015-09-02 12:57:25.000000000 +0200 | ||
1820 | +++ hotspot/src/share/vm/gc_implementation/g1/heapRegionManager.cpp 2015-09-02 13:01:10.000000000 +0200 | ||
1821 | @@ -414,7 +414,7 @@ | ||
1822 | HeapRegion* hr = _regions.get_by_index(i); | ||
1823 | guarantee(hr != NULL, err_msg("invariant: i: %u", i)); | ||
1824 | guarantee(!prev_committed || hr->bottom() == prev_end, | ||
1825 | - err_msg("invariant i: %u "HR_FORMAT" prev_end: "PTR_FORMAT, | ||
1826 | + err_msg("invariant i: %u " HR_FORMAT " prev_end: " PTR_FORMAT, | ||
1827 | i, HR_FORMAT_PARAMS(hr), p2i(prev_end))); | ||
1828 | guarantee(hr->hrm_index() == i, | ||
1829 | err_msg("invariant: i: %u hrm_index(): %u", i, hr->hrm_index())); | ||
1830 | --- hotspot/src/share/vm/gc_implementation/g1/heapRegionRemSet.cpp.orig 2015-09-02 12:57:25.000000000 +0200 | ||
1831 | +++ hotspot/src/share/vm/gc_implementation/g1/heapRegionRemSet.cpp 2015-09-02 13:03:44.000000000 +0200 | ||
1832 | @@ -91,7 +91,7 @@ | ||
1833 | // concurrency. | ||
1834 | |||
1835 | if (G1TraceHeapRegionRememberedSet) { | ||
1836 | - gclog_or_tty->print_cr(" PRT::Add_reference_work(" PTR_FORMAT "->" PTR_FORMAT").", | ||
1837 | + gclog_or_tty->print_cr(" PRT::Add_reference_work(" PTR_FORMAT "->" PTR_FORMAT ").", | ||
1838 | from, | ||
1839 | UseCompressedOops | ||
1840 | ? (void *)oopDesc::load_decode_heap_oop((narrowOop*)from) | ||
1841 | @@ -377,7 +377,7 @@ | ||
1842 | |||
1843 | void FromCardCache::invalidate(uint start_idx, size_t new_num_regions) { | ||
1844 | guarantee((size_t)start_idx + new_num_regions <= max_uintx, | ||
1845 | - err_msg("Trying to invalidate beyond maximum region, from %u size "SIZE_FORMAT, | ||
1846 | + err_msg("Trying to invalidate beyond maximum region, from %u size " SIZE_FORMAT, | ||
1847 | start_idx, new_num_regions)); | ||
1848 | for (uint i = 0; i < HeapRegionRemSet::num_par_rem_sets(); i++) { | ||
1849 | uint end_idx = (start_idx + (uint)new_num_regions); | ||
1850 | @@ -392,7 +392,7 @@ | ||
1851 | void FromCardCache::print(outputStream* out) { | ||
1852 | for (uint i = 0; i < HeapRegionRemSet::num_par_rem_sets(); i++) { | ||
1853 | for (uint j = 0; j < _max_regions; j++) { | ||
1854 | - out->print_cr("_from_card_cache["UINT32_FORMAT"]["UINT32_FORMAT"] = "INT32_FORMAT".", | ||
1855 | + out->print_cr("_from_card_cache[" UINT32_FORMAT "][" UINT32_FORMAT "] = " INT32_FORMAT ".", | ||
1856 | i, j, at(i, j)); | ||
1857 | } | ||
1858 | } | ||
1859 | @@ -432,7 +432,7 @@ | ||
1860 | int from_card = (int)(uintptr_t(from) >> CardTableModRefBS::card_shift); | ||
1861 | |||
1862 | if (G1TraceHeapRegionRememberedSet) { | ||
1863 | - gclog_or_tty->print_cr("Table for [" PTR_FORMAT "...): card %d (cache = "INT32_FORMAT")", | ||
1864 | + gclog_or_tty->print_cr("Table for [" PTR_FORMAT "...): card %d (cache = " INT32_FORMAT ")", | ||
1865 | hr()->bottom(), from_card, | ||
1866 | FromCardCache::at((uint)tid, cur_hrm_ind)); | ||
1867 | } | ||
1868 | @@ -637,13 +637,13 @@ | ||
1869 | |||
1870 | assert(_coarse_map.size() == region_bm->size(), "Precondition"); | ||
1871 | if (G1RSScrubVerbose) { | ||
1872 | - gclog_or_tty->print(" Coarse map: before = "SIZE_FORMAT"...", | ||
1873 | + gclog_or_tty->print(" Coarse map: before = " SIZE_FORMAT "...", | ||
1874 | _n_coarse_entries); | ||
1875 | } | ||
1876 | _coarse_map.set_intersection(*region_bm); | ||
1877 | _n_coarse_entries = _coarse_map.count_one_bits(); | ||
1878 | if (G1RSScrubVerbose) { | ||
1879 | - gclog_or_tty->print_cr(" after = "SIZE_FORMAT".", _n_coarse_entries); | ||
1880 | + gclog_or_tty->print_cr(" after = " SIZE_FORMAT ".", _n_coarse_entries); | ||
1881 | } | ||
1882 | |||
1883 | // Now do the fine-grained maps. | ||
1884 | @@ -1027,7 +1027,7 @@ | ||
1885 | |||
1886 | card_index = _cur_region_card_offset + _cur_card_in_prt; | ||
1887 | guarantee(_cur_card_in_prt < HeapRegion::CardsPerRegion, | ||
1888 | - err_msg("Card index "SIZE_FORMAT" must be within the region", _cur_card_in_prt)); | ||
1889 | + err_msg("Card index " SIZE_FORMAT " must be within the region", _cur_card_in_prt)); | ||
1890 | return true; | ||
1891 | } | ||
1892 | |||
1893 | @@ -1196,8 +1196,8 @@ | ||
1894 | |||
1895 | size_t min_prt_size = sizeof(void*) + dummy->bm()->size_in_words() * HeapWordSize; | ||
1896 | assert(dummy->mem_size() > min_prt_size, | ||
1897 | - err_msg("PerRegionTable memory usage is suspiciously small, only has "SIZE_FORMAT" bytes. " | ||
1898 | - "Should be at least "SIZE_FORMAT" bytes.", dummy->mem_size(), min_prt_size)); | ||
1899 | + err_msg("PerRegionTable memory usage is suspiciously small, only has " SIZE_FORMAT " bytes. " | ||
1900 | + "Should be at least " SIZE_FORMAT " bytes.", dummy->mem_size(), min_prt_size)); | ||
1901 | free(dummy); | ||
1902 | guarantee(dummy->mem_size() == fl_mem_size(), "fl_mem_size() does not return the correct element size"); | ||
1903 | // try to reset the state | ||
1904 | --- hotspot/src/share/vm/gc_implementation/g1/heapRegionSet.cpp.orig 2015-09-02 12:57:25.000000000 +0200 | ||
1905 | +++ hotspot/src/share/vm/gc_implementation/g1/heapRegionSet.cpp 2015-09-02 13:04:36.000000000 +0200 | ||
1906 | @@ -32,7 +32,7 @@ | ||
1907 | uint FreeRegionList::_unrealistically_long_length = 0; | ||
1908 | |||
1909 | void HeapRegionSetBase::fill_in_ext_msg(hrs_ext_msg* msg, const char* message) { | ||
1910 | - msg->append("[%s] %s ln: %u cy: "SIZE_FORMAT, | ||
1911 | + msg->append("[%s] %s ln: %u cy: " SIZE_FORMAT, | ||
1912 | name(), message, length(), total_capacity_bytes()); | ||
1913 | fill_in_ext_msg_extra(msg); | ||
1914 | } | ||
1915 | @@ -84,13 +84,13 @@ | ||
1916 | |||
1917 | void HeapRegionSetBase::print_on(outputStream* out, bool print_contents) { | ||
1918 | out->cr(); | ||
1919 | - out->print_cr("Set: %s ("PTR_FORMAT")", name(), this); | ||
1920 | + out->print_cr("Set: %s (" PTR_FORMAT ")", name(), this); | ||
1921 | out->print_cr(" Region Assumptions"); | ||
1922 | out->print_cr(" humongous : %s", BOOL_TO_STR(regions_humongous())); | ||
1923 | out->print_cr(" free : %s", BOOL_TO_STR(regions_free())); | ||
1924 | out->print_cr(" Attributes"); | ||
1925 | out->print_cr(" length : %14u", length()); | ||
1926 | - out->print_cr(" total capacity : "SIZE_FORMAT_W(14)" bytes", | ||
1927 | + out->print_cr(" total capacity : " SIZE_FORMAT_W(14) " bytes", | ||
1928 | total_capacity_bytes()); | ||
1929 | } | ||
1930 | |||
1931 | @@ -106,7 +106,7 @@ | ||
1932 | } | ||
1933 | |||
1934 | void FreeRegionList::fill_in_ext_msg_extra(hrs_ext_msg* msg) { | ||
1935 | - msg->append(" hd: "PTR_FORMAT" tl: "PTR_FORMAT, _head, _tail); | ||
1936 | + msg->append(" hd: " PTR_FORMAT " tl: " PTR_FORMAT, _head, _tail); | ||
1937 | } | ||
1938 | |||
1939 | void FreeRegionList::remove_all() { | ||
1940 | @@ -277,8 +277,8 @@ | ||
1941 | void FreeRegionList::print_on(outputStream* out, bool print_contents) { | ||
1942 | HeapRegionSetBase::print_on(out, print_contents); | ||
1943 | out->print_cr(" Linking"); | ||
1944 | - out->print_cr(" head : "PTR_FORMAT, _head); | ||
1945 | - out->print_cr(" tail : "PTR_FORMAT, _tail); | ||
1946 | + out->print_cr(" head : " PTR_FORMAT, _head); | ||
1947 | + out->print_cr(" tail : " PTR_FORMAT, _tail); | ||
1948 | |||
1949 | if (print_contents) { | ||
1950 | out->print_cr(" Contents"); | ||
1951 | @@ -306,7 +306,7 @@ | ||
1952 | |||
1953 | count++; | ||
1954 | guarantee(count < _unrealistically_long_length, | ||
1955 | - hrs_err_msg("[%s] the calculated length: %u seems very long, is there maybe a cycle? curr: "PTR_FORMAT" prev0: "PTR_FORMAT" " "prev1: "PTR_FORMAT" length: %u", name(), count, curr, prev0, prev1, length())); | ||
1956 | + hrs_err_msg("[%s] the calculated length: %u seems very long, is there maybe a cycle? curr: " PTR_FORMAT " prev0: " PTR_FORMAT " " "prev1: " PTR_FORMAT " length: %u", name(), count, curr, prev0, prev1, length())); | ||
1957 | |||
1958 | if (curr->next() != NULL) { | ||
1959 | guarantee(curr->next()->prev() == curr, "Next or prev pointers messed up"); | ||
1960 | --- hotspot/src/share/vm/gc_implementation/shared/mutableNUMASpace.cpp.orig 2015-09-02 13:07:15.000000000 +0200 | ||
1961 | +++ hotspot/src/share/vm/gc_implementation/shared/mutableNUMASpace.cpp 2015-09-02 13:10:48.000000000 +0200 | ||
1962 | @@ -86,7 +86,7 @@ | ||
1963 | while (words_left_to_fill > 0) { | ||
1964 | size_t words_to_fill = MIN2(words_left_to_fill, CollectedHeap::filler_array_max_size()); | ||
1965 | assert(words_to_fill >= CollectedHeap::min_fill_size(), | ||
1966 | - err_msg("Remaining size ("SIZE_FORMAT ") is too small to fill (based on " SIZE_FORMAT " and " SIZE_FORMAT ")", | ||
1967 | + err_msg("Remaining size (" SIZE_FORMAT ") is too small to fill (based on " SIZE_FORMAT " and " SIZE_FORMAT ")", | ||
1968 | words_to_fill, words_left_to_fill, CollectedHeap::filler_array_max_size())); | ||
1969 | CollectedHeap::fill_with_object((HeapWord*)cur_top, words_to_fill); | ||
1970 | if (!os::numa_has_static_binding()) { | ||
1971 | --- hotspot/src/share/vm/prims/methodHandles.cpp.orig 2015-09-02 13:07:15.000000000 +0200 | ||
1972 | +++ hotspot/src/share/vm/prims/methodHandles.cpp 2015-09-02 13:10:16.000000000 +0200 | ||
1973 | @@ -1300,27 +1300,27 @@ | ||
1974 | |||
1975 | // These are the native methods on java.lang.invoke.MethodHandleNatives. | ||
1976 | static JNINativeMethod MHN_methods[] = { | ||
1977 | - {CC"init", CC"("MEM""OBJ")V", FN_PTR(MHN_init_Mem)}, | ||
1978 | - {CC"expand", CC"("MEM")V", FN_PTR(MHN_expand_Mem)}, | ||
1979 | - {CC"resolve", CC"("MEM""CLS")"MEM, FN_PTR(MHN_resolve_Mem)}, | ||
1980 | - {CC"getConstant", CC"(I)I", FN_PTR(MHN_getConstant)}, | ||
1981 | + {CC "init", CC "(" MEM "" OBJ ")V", FN_PTR(MHN_init_Mem)}, | ||
1982 | + {CC "expand", CC "(" MEM ")V", FN_PTR(MHN_expand_Mem)}, | ||
1983 | + {CC "resolve", CC "(" MEM "" CLS ")" MEM, FN_PTR(MHN_resolve_Mem)}, | ||
1984 | + {CC "getConstant", CC "(I)I", FN_PTR(MHN_getConstant)}, | ||
1985 | // static native int getNamedCon(int which, Object[] name) | ||
1986 | - {CC"getNamedCon", CC"(I["OBJ")I", FN_PTR(MHN_getNamedCon)}, | ||
1987 | + {CC "getNamedCon", CC "(I[" OBJ ")I", FN_PTR(MHN_getNamedCon)}, | ||
1988 | // static native int getMembers(Class<?> defc, String matchName, String matchSig, | ||
1989 | // int matchFlags, Class<?> caller, int skip, MemberName[] results); | ||
1990 | - {CC"getMembers", CC"("CLS""STRG""STRG"I"CLS"I["MEM")I", FN_PTR(MHN_getMembers)}, | ||
1991 | - {CC"objectFieldOffset", CC"("MEM")J", FN_PTR(MHN_objectFieldOffset)}, | ||
1992 | - {CC"setCallSiteTargetNormal", CC"("CS""MH")V", FN_PTR(MHN_setCallSiteTargetNormal)}, | ||
1993 | - {CC"setCallSiteTargetVolatile", CC"("CS""MH")V", FN_PTR(MHN_setCallSiteTargetVolatile)}, | ||
1994 | - {CC"staticFieldOffset", CC"("MEM")J", FN_PTR(MHN_staticFieldOffset)}, | ||
1995 | - {CC"staticFieldBase", CC"("MEM")"OBJ, FN_PTR(MHN_staticFieldBase)}, | ||
1996 | - {CC"getMemberVMInfo", CC"("MEM")"OBJ, FN_PTR(MHN_getMemberVMInfo)} | ||
1997 | + {CC "getMembers", CC "(" CLS "" STRG "" STRG "I" CLS "I[" MEM ")I", FN_PTR(MHN_getMembers)}, | ||
1998 | + {CC "objectFieldOffset", CC "(" MEM ")J", FN_PTR(MHN_objectFieldOffset)}, | ||
1999 | + {CC "setCallSiteTargetNormal", CC "(" CS "" MH ")V", FN_PTR(MHN_setCallSiteTargetNormal)}, | ||
2000 | + {CC "setCallSiteTargetVolatile", CC "(" CS "" MH ")V", FN_PTR(MHN_setCallSiteTargetVolatile)}, | ||
2001 | + {CC "staticFieldOffset", CC "(" MEM ")J", FN_PTR(MHN_staticFieldOffset)}, | ||
2002 | + {CC "staticFieldBase", CC "(" MEM ")" OBJ, FN_PTR(MHN_staticFieldBase)}, | ||
2003 | + {CC "getMemberVMInfo", CC "(" MEM ")" OBJ, FN_PTR(MHN_getMemberVMInfo)} | ||
2004 | }; | ||
2005 | |||
2006 | static JNINativeMethod MH_methods[] = { | ||
2007 | // UnsupportedOperationException throwers | ||
2008 | - {CC"invoke", CC"(["OBJ")"OBJ, FN_PTR(MH_invoke_UOE)}, | ||
2009 | - {CC"invokeExact", CC"(["OBJ")"OBJ, FN_PTR(MH_invokeExact_UOE)} | ||
2010 | + {CC"invoke", CC "([" OBJ ")" OBJ, FN_PTR(MH_invoke_UOE)}, | ||
2011 | + {CC"invokeExact", CC "([" OBJ ")" OBJ, FN_PTR(MH_invokeExact_UOE)} | ||
2012 | }; | ||
2013 | |||
2014 | /** | ||
2015 | --- hotspot/src/share/vm/oops/objArrayKlass.cpp.orig 2015-09-02 13:19:26.000000000 +0200 | ||
2016 | +++ hotspot/src/share/vm/oops/objArrayKlass.cpp 2015-09-02 13:22:11.000000000 +0200 | ||
2017 | @@ -657,7 +657,7 @@ | ||
2018 | if (i > max_objArray_print_length) { | ||
2019 | st->print("..."); break; | ||
2020 | } | ||
2021 | - st->print(" "INTPTR_FORMAT, (intptr_t)(void*)objArrayOop(obj)->obj_at(i)); | ||
2022 | + st->print(" " INTPTR_FORMAT, (intptr_t)(void*)objArrayOop(obj)->obj_at(i)); | ||
2023 | } | ||
2024 | st->print(" }"); | ||
2025 | } | ||
2026 | --- hotspot/src/share/vm/oops/oop.cpp.orig 2015-09-02 13:19:26.000000000 +0200 | ||
2027 | +++ hotspot/src/share/vm/oops/oop.cpp 2015-09-02 13:22:22.000000000 +0200 | ||
2028 | @@ -46,7 +46,7 @@ | ||
2029 | |||
2030 | void oopDesc::print_address_on(outputStream* st) const { | ||
2031 | if (PrintOopAddress) { | ||
2032 | - st->print("{"INTPTR_FORMAT"}", this); | ||
2033 | + st->print("{" INTPTR_FORMAT "}", this); | ||
2034 | } | ||
2035 | } | ||
2036 | |||
2037 | --- hotspot/src/os/posix/vm/os_posix.cpp.orig 2015-09-02 13:32:01.000000000 +0200 | ||
2038 | +++ hotspot/src/os/posix/vm/os_posix.cpp 2015-09-02 13:33:42.000000000 +0200 | ||
2039 | @@ -594,7 +594,7 @@ | ||
2040 | strncpy(buffer, "none", size); | ||
2041 | |||
2042 | const struct { | ||
2043 | - int i; | ||
2044 | + unsigned i; | ||
2045 | const char* s; | ||
2046 | } flaginfo [] = { | ||
2047 | { SA_NOCLDSTOP, "SA_NOCLDSTOP" }, | ||
2048 | --- hotspot/src/share/vm/code/nmethod.cpp.orig 2015-09-02 13:19:26.000000000 +0200 | ||
2049 | +++ hotspot/src/share/vm/code/nmethod.cpp 2015-09-02 13:27:23.000000000 +0200 | ||
2050 | @@ -2303,7 +2303,7 @@ | ||
2051 | void maybe_print(oop* p) { | ||
2052 | if (_print_nm == NULL) return; | ||
2053 | if (!_detected_scavenge_root) _print_nm->print_on(tty, "new scavenge root"); | ||
2054 | - tty->print_cr(""PTR_FORMAT"[offset=%d] detected scavengable oop "PTR_FORMAT" (found at "PTR_FORMAT")", | ||
2055 | + tty->print_cr("" PTR_FORMAT "[offset=%d] detected scavengable oop " PTR_FORMAT " (found at " PTR_FORMAT ")", | ||
2056 | _print_nm, (int)((intptr_t)p - (intptr_t)_print_nm), | ||
2057 | (void *)(*p), (intptr_t)p); | ||
2058 | (*p)->print(); | ||
2059 | @@ -2684,7 +2684,7 @@ | ||
2060 | _nm->print_nmethod(true); | ||
2061 | _ok = false; | ||
2062 | } | ||
2063 | - tty->print_cr("*** non-oop "PTR_FORMAT" found at "PTR_FORMAT" (offset %d)", | ||
2064 | + tty->print_cr("*** non-oop " PTR_FORMAT " found at " PTR_FORMAT " (offset %d)", | ||
2065 | (void *)(*p), (intptr_t)p, (int)((intptr_t)p - (intptr_t)_nm)); | ||
2066 | } | ||
2067 | virtual void do_oop(narrowOop* p) { ShouldNotReachHere(); } | ||
2068 | @@ -2808,7 +2808,7 @@ | ||
2069 | _nm->print_nmethod(true); | ||
2070 | _ok = false; | ||
2071 | } | ||
2072 | - tty->print_cr("*** scavengable oop "PTR_FORMAT" found at "PTR_FORMAT" (offset %d)", | ||
2073 | + tty->print_cr("*** scavengable oop " PTR_FORMAT " found at " PTR_FORMAT " (offset %d)", | ||
2074 | (void *)(*p), (intptr_t)p, (int)((intptr_t)p - (intptr_t)_nm)); | ||
2075 | (*p)->print(); | ||
2076 | } | ||
2077 | @@ -2853,7 +2853,7 @@ | ||
2078 | print_on(tty, NULL); | ||
2079 | |||
2080 | if (WizardMode) { | ||
2081 | - tty->print("((nmethod*) "INTPTR_FORMAT ") ", this); | ||
2082 | + tty->print("((nmethod*) " INTPTR_FORMAT ") ", this); | ||
2083 | tty->print(" for method " INTPTR_FORMAT , (address)method()); | ||
2084 | tty->print(" { "); | ||
2085 | if (is_in_use()) tty->print("in_use "); | ||
2086 | --- hotspot/src/share/vm/gc_implementation/shared/parGCAllocBuffer.cpp.orig 2015-09-02 13:28:16.000000000 +0200 | ||
2087 | +++ hotspot/src/share/vm/gc_implementation/shared/parGCAllocBuffer.cpp 2015-09-02 13:31:09.000000000 +0200 | ||
2088 | @@ -98,10 +98,10 @@ | ||
2089 | if (_allocated == 0) { | ||
2090 | assert(_unused == 0, | ||
2091 | err_msg("Inconsistency in PLAB stats: " | ||
2092 | - "_allocated: "SIZE_FORMAT", " | ||
2093 | - "_wasted: "SIZE_FORMAT", " | ||
2094 | - "_unused: "SIZE_FORMAT", " | ||
2095 | - "_used : "SIZE_FORMAT, | ||
2096 | + "_allocated: " SIZE_FORMAT ", " | ||
2097 | + "_wasted: " SIZE_FORMAT ", " | ||
2098 | + "_unused: " SIZE_FORMAT ", " | ||
2099 | + "_used : " SIZE_FORMAT, | ||
2100 | _allocated, _wasted, _unused, _used)); | ||
2101 | |||
2102 | _allocated = 1; | ||
2103 | --- hotspot/src/share/vm/utilities/ostream.cpp.orig 2015-09-02 13:28:16.000000000 +0200 | ||
2104 | +++ hotspot/src/share/vm/utilities/ostream.cpp 2015-09-02 13:34:57.000000000 +0200 | ||
2105 | @@ -277,7 +277,7 @@ | ||
2106 | size_t limit = (len + 16) / 16 * 16; | ||
2107 | for (size_t i = 0; i < limit; ++i) { | ||
2108 | if (i % 16 == 0) { | ||
2109 | - indent().print(SIZE_FORMAT_HEX_W(07)":", i); | ||
2110 | + indent().print(SIZE_FORMAT_HEX_W(07) ":", i); | ||
2111 | } | ||
2112 | if (i % 2 == 0) { | ||
2113 | print(" "); | ||
2114 | @@ -945,7 +945,7 @@ | ||
2115 | // %%% Should be: jlong time_ms = os::start_time_milliseconds(), if | ||
2116 | // we ever get round to introduce that method on the os class | ||
2117 | xs->head("hotspot_log version='%d %d'" | ||
2118 | - " process='%d' time_ms='"INT64_FORMAT"'", | ||
2119 | + " process='%d' time_ms='" INT64_FORMAT "'", | ||
2120 | LOG_MAJOR_VERSION, LOG_MINOR_VERSION, | ||
2121 | os::current_process_id(), (int64_t)time_ms); | ||
2122 | // Write VM version header immediately. | ||
2123 | --- hotspot/src/share/vm/prims/perf.cpp.orig 2015-09-02 13:36:01.000000000 +0200 | ||
2124 | +++ hotspot/src/share/vm/prims/perf.cpp 2015-09-02 13:37:33.000000000 +0200 | ||
2125 | @@ -290,17 +290,17 @@ | ||
2126 | #define FN_PTR(f) CAST_FROM_FN_PTR(void*, &f) | ||
2127 | #define BB "Ljava/nio/ByteBuffer;" | ||
2128 | #define JLS "Ljava/lang/String;" | ||
2129 | -#define CL_ARGS CC"("JLS"IIJ)"BB | ||
2130 | -#define CBA_ARGS CC"("JLS"II[BI)"BB | ||
2131 | +#define CL_ARGS CC "(" JLS "IIJ)" BB | ||
2132 | +#define CBA_ARGS CC "(" JLS "II[BI)" BB | ||
2133 | |||
2134 | static JNINativeMethod perfmethods[] = { | ||
2135 | |||
2136 | - {CC"attach", CC"("JLS"II)"BB, FN_PTR(Perf_Attach)}, | ||
2137 | - {CC"detach", CC"("BB")V", FN_PTR(Perf_Detach)}, | ||
2138 | - {CC"createLong", CL_ARGS, FN_PTR(Perf_CreateLong)}, | ||
2139 | - {CC"createByteArray", CBA_ARGS, FN_PTR(Perf_CreateByteArray)}, | ||
2140 | - {CC"highResCounter", CC"()J", FN_PTR(Perf_HighResCounter)}, | ||
2141 | - {CC"highResFrequency", CC"()J", FN_PTR(Perf_HighResFrequency)} | ||
2142 | + {CC"attach", CC "(" JLS "II)" BB, FN_PTR(Perf_Attach)}, | ||
2143 | + {CC"detach", CC "(" BB ")V", FN_PTR(Perf_Detach)}, | ||
2144 | + {CC"createLong", CL_ARGS, FN_PTR(Perf_CreateLong)}, | ||
2145 | + {CC"createByteArray", CBA_ARGS, FN_PTR(Perf_CreateByteArray)}, | ||
2146 | + {CC"highResCounter", CC "()J", FN_PTR(Perf_HighResCounter)}, | ||
2147 | + {CC"highResFrequency", CC "()J", FN_PTR(Perf_HighResFrequency)} | ||
2148 | }; | ||
2149 | |||
2150 | #undef CBA_ARGS | ||
2151 | --- hotspot/src/share/vm/gc_implementation/parallelScavenge/psMarkSweep.cpp.orig 2015-09-02 13:39:42.000000000 +0200 | ||
2152 | +++ hotspot/src/share/vm/gc_implementation/parallelScavenge/psMarkSweep.cpp 2015-09-02 13:40:05.000000000 +0200 | ||
2153 | @@ -669,7 +669,7 @@ | ||
2154 | jlong ret_val = now - _time_of_last_gc; | ||
2155 | // XXX See note in genCollectedHeap::millis_since_last_gc(). | ||
2156 | if (ret_val < 0) { | ||
2157 | - NOT_PRODUCT(warning("time warp: "INT64_FORMAT, ret_val);) | ||
2158 | + NOT_PRODUCT(warning("time warp: " INT64_FORMAT, ret_val);) | ||
2159 | return 0; | ||
2160 | } | ||
2161 | return ret_val; | ||
2162 | --- hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp.orig 2015-09-02 13:39:42.000000000 +0200 | ||
2163 | +++ hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp 2015-09-02 13:40:50.000000000 +0200 | ||
2164 | @@ -3292,7 +3292,7 @@ | ||
2165 | jlong ret_val = now - _time_of_last_gc; | ||
2166 | // XXX See note in genCollectedHeap::millis_since_last_gc(). | ||
2167 | if (ret_val < 0) { | ||
2168 | - NOT_PRODUCT(warning("time warp: "INT64_FORMAT, ret_val);) | ||
2169 | + NOT_PRODUCT(warning("time warp: " INT64_FORMAT, ret_val);) | ||
2170 | return 0; | ||
2171 | } | ||
2172 | return ret_val; | ||
2173 | --- hotspot/src/share/vm/memory/referenceProcessor.cpp.orig 2015-09-02 13:42:24.000000000 +0200 | ||
2174 | +++ hotspot/src/share/vm/memory/referenceProcessor.cpp 2015-09-02 13:42:55.000000000 +0200 | ||
2175 | @@ -161,7 +161,7 @@ | ||
2176 | |||
2177 | NOT_PRODUCT( | ||
2178 | if (now < _soft_ref_timestamp_clock) { | ||
2179 | - warning("time warp: "INT64_FORMAT" to "INT64_FORMAT, | ||
2180 | + warning("time warp: " INT64_FORMAT " to " INT64_FORMAT, | ||
2181 | _soft_ref_timestamp_clock, now); | ||
2182 | } | ||
2183 | ) | ||
2184 | --- hotspot/src/share/vm/runtime/safepoint.cpp.orig 2015-09-02 14:51:21.000000000 +0200 | ||
2185 | +++ hotspot/src/share/vm/runtime/safepoint.cpp 2015-09-02 14:52:56.000000000 +0200 | ||
2186 | @@ -983,7 +983,7 @@ | ||
2187 | |||
2188 | case _running: | ||
2189 | default: | ||
2190 | - tty->print_cr("restart thread "INTPTR_FORMAT" with state %d", | ||
2191 | + tty->print_cr("restart thread " INTPTR_FORMAT " with state %d", | ||
2192 | _thread, _type); | ||
2193 | _thread->print(); | ||
2194 | ShouldNotReachHere(); | ||
2195 | @@ -1340,14 +1340,14 @@ | ||
2196 | |||
2197 | for (int index = 0; index < VM_Operation::VMOp_Terminating; index++) { | ||
2198 | if (_safepoint_reasons[index] != 0) { | ||
2199 | - tty->print_cr("%-26s"UINT64_FORMAT_W(10), VM_Operation::name(index), | ||
2200 | + tty->print_cr("%-26s" UINT64_FORMAT_W(10), VM_Operation::name(index), | ||
2201 | _safepoint_reasons[index]); | ||
2202 | } | ||
2203 | } | ||
2204 | |||
2205 | tty->print_cr(UINT64_FORMAT_W(5)" VM operations coalesced during safepoint", | ||
2206 | _coalesced_vmop_count); | ||
2207 | - tty->print_cr("Maximum sync time "INT64_FORMAT_W(5)" ms", | ||
2208 | + tty->print_cr("Maximum sync time " INT64_FORMAT_W(5) " ms", | ||
2209 | _max_sync_time / MICROUNITS); | ||
2210 | tty->print_cr("Maximum vm operation time (except for Exit VM operation) " | ||
2211 | INT64_FORMAT_W(5)" ms", | ||
2212 | --- hotspot/src/share/vm/memory/tenuredGeneration.cpp.orig 2015-09-02 18:11:24.000000000 +0200 | ||
2213 | +++ hotspot/src/share/vm/memory/tenuredGeneration.cpp 2015-09-02 18:11:32.000000000 +0200 | ||
2214 | @@ -292,8 +292,8 @@ | ||
2215 | bool res = (available >= av_promo) || (available >= max_promotion_in_bytes); | ||
2216 | if (PrintGC && Verbose) { | ||
2217 | gclog_or_tty->print_cr( | ||
2218 | - "Tenured: promo attempt is%s safe: available("SIZE_FORMAT") %s av_promo("SIZE_FORMAT")," | ||
2219 | - "max_promo("SIZE_FORMAT")", | ||
2220 | + "Tenured: promo attempt is%s safe: available(" SIZE_FORMAT ") %s av_promo(" SIZE_FORMAT ")," | ||
2221 | + "max_promo(" SIZE_FORMAT ")", | ||
2222 | res? "":" not", available, res? ">=":"<", | ||
2223 | av_promo, max_promotion_in_bytes); | ||
2224 | } | ||
2225 | --- hotspot/src/share/vm/services/threadService.cpp.orig 2015-09-02 18:11:24.000000000 +0200 | ||
2226 | +++ hotspot/src/share/vm/services/threadService.cpp 2015-09-02 18:11:32.000000000 +0200 | ||
2227 | @@ -889,7 +889,7 @@ | ||
2228 | st->print(" waiting to lock monitor " INTPTR_FORMAT, waitingToLockMonitor); | ||
2229 | oop obj = (oop)waitingToLockMonitor->object(); | ||
2230 | if (obj != NULL) { | ||
2231 | - st->print(" (object "INTPTR_FORMAT ", a %s)", (address)obj, | ||
2232 | + st->print(" (object " INTPTR_FORMAT ", a %s)", (address)obj, | ||
2233 | (InstanceKlass::cast(obj->klass()))->external_name()); | ||
2234 | |||
2235 | if (!currentThread->current_pending_monitor_is_from_java()) { | ||
2236 | --- hotspot/src/share/vm/memory/universe.cpp.orig 2015-09-02 18:25:28.000000000 +0200 | ||
2237 | +++ hotspot/src/share/vm/memory/universe.cpp 2015-09-02 18:26:04.000000000 +0200 | ||
2238 | @@ -919,7 +919,7 @@ | ||
2239 | // Reserve the Java heap, which is now the same for all GCs. | ||
2240 | ReservedSpace Universe::reserve_heap(size_t heap_size, size_t alignment) { | ||
2241 | assert(alignment <= Arguments::conservative_max_heap_alignment(), | ||
2242 | - err_msg("actual alignment "SIZE_FORMAT" must be within maximum heap alignment "SIZE_FORMAT, | ||
2243 | + err_msg("actual alignment " SIZE_FORMAT " must be within maximum heap alignment " SIZE_FORMAT, | ||
2244 | alignment, Arguments::conservative_max_heap_alignment())); | ||
2245 | size_t total_reserved = align_size_up(heap_size, alignment); | ||
2246 | assert(!UseCompressedOops || (total_reserved <= (OopEncodingHeapMax - os::vm_page_size())), | ||
2247 | --- hotspot/src/share/vm/prims/unsafe.cpp.orig 2015-09-02 18:25:32.000000000 +0200 | ||
2248 | +++ hotspot/src/share/vm/prims/unsafe.cpp 2015-09-02 18:47:09.000000000 +0200 | ||
2249 | @@ -977,7 +977,7 @@ | ||
2250 | UNSAFE_END | ||
2251 | |||
2252 | |||
2253 | -#define DAC_Args CLS"[B["OBJ | ||
2254 | +#define DAC_Args CLS "[B[" OBJ | ||
2255 | // define a class but do not make it known to the class loader or system dictionary | ||
2256 | // - host_class: supplies context for linkage, access control, protection domain, and class loader | ||
2257 | // - data: bytes of a class file, a raw memory address (length gives the number of bytes) | ||
2258 | @@ -1337,47 +1337,47 @@ | ||
2259 | |||
2260 | #define LANG "Ljava/lang/" | ||
2261 | |||
2262 | -#define OBJ LANG"Object;" | ||
2263 | -#define CLS LANG"Class;" | ||
2264 | -#define CTR LANG"reflect/Constructor;" | ||
2265 | -#define FLD LANG"reflect/Field;" | ||
2266 | -#define MTH LANG"reflect/Method;" | ||
2267 | -#define THR LANG"Throwable;" | ||
2268 | +#define OBJ LANG "Object;" | ||
2269 | +#define CLS LANG "Class;" | ||
2270 | +#define CTR LANG "reflect/Constructor;" | ||
2271 | +#define FLD LANG "reflect/Field;" | ||
2272 | +#define MTH LANG "reflect/Method;" | ||
2273 | +#define THR LANG "Throwable;" | ||
2274 | |||
2275 | -#define DC0_Args LANG"String;[BII" | ||
2276 | -#define DC_Args DC0_Args LANG"ClassLoader;" "Ljava/security/ProtectionDomain;" | ||
2277 | +#define DC0_Args LANG "String;[BII" | ||
2278 | +#define DC_Args DC0_Args LANG "ClassLoader;" "Ljava/security/ProtectionDomain;" | ||
2279 | |||
2280 | #define CC (char*) /*cast a literal from (const char*)*/ | ||
2281 | #define FN_PTR(f) CAST_FROM_FN_PTR(void*, &f) | ||
2282 | |||
2283 | // define deprecated accessors for compabitility with 1.4.0 | ||
2284 | #define DECLARE_GETSETOOP_140(Boolean, Z) \ | ||
2285 | - {CC"get"#Boolean, CC"("OBJ"I)"#Z, FN_PTR(Unsafe_Get##Boolean##140)}, \ | ||
2286 | - {CC"put"#Boolean, CC"("OBJ"I"#Z")V", FN_PTR(Unsafe_Set##Boolean##140)} | ||
2287 | + {CC"get"#Boolean, CC"(" OBJ "I)" #Z, FN_PTR(Unsafe_Get##Boolean##140)}, \ | ||
2288 | + {CC"put"#Boolean, CC"(" OBJ "I" #Z ")V", FN_PTR(Unsafe_Set##Boolean##140)} | ||
2289 | |||
2290 | // Note: In 1.4.1, getObject and kin take both int and long offsets. | ||
2291 | #define DECLARE_GETSETOOP_141(Boolean, Z) \ | ||
2292 | - {CC"get"#Boolean, CC"("OBJ"J)"#Z, FN_PTR(Unsafe_Get##Boolean)}, \ | ||
2293 | - {CC"put"#Boolean, CC"("OBJ"J"#Z")V", FN_PTR(Unsafe_Set##Boolean)} | ||
2294 | + {CC"get"#Boolean, CC"(" OBJ "J)" #Z, FN_PTR(Unsafe_Get##Boolean)}, \ | ||
2295 | + {CC"put"#Boolean, CC"(" OBJ "J" #Z ")V", FN_PTR(Unsafe_Set##Boolean)} | ||
2296 | |||
2297 | // Note: In 1.5.0, there are volatile versions too | ||
2298 | #define DECLARE_GETSETOOP(Boolean, Z) \ | ||
2299 | - {CC"get"#Boolean, CC"("OBJ"J)"#Z, FN_PTR(Unsafe_Get##Boolean)}, \ | ||
2300 | - {CC"put"#Boolean, CC"("OBJ"J"#Z")V", FN_PTR(Unsafe_Set##Boolean)}, \ | ||
2301 | - {CC"get"#Boolean"Volatile", CC"("OBJ"J)"#Z, FN_PTR(Unsafe_Get##Boolean##Volatile)}, \ | ||
2302 | - {CC"put"#Boolean"Volatile", CC"("OBJ"J"#Z")V", FN_PTR(Unsafe_Set##Boolean##Volatile)} | ||
2303 | + {CC"get"#Boolean, CC"(" OBJ "J)" #Z, FN_PTR(Unsafe_Get##Boolean)}, \ | ||
2304 | + {CC"put"#Boolean, CC"(" OBJ "J" #Z ")V", FN_PTR(Unsafe_Set##Boolean)}, \ | ||
2305 | + {CC"get"#Boolean "Volatile", CC"(" OBJ "J)" #Z, FN_PTR(Unsafe_Get##Boolean##Volatile)}, \ | ||
2306 | + {CC"put"#Boolean "Volatile", CC"(" OBJ "J" #Z ")V", FN_PTR(Unsafe_Set##Boolean##Volatile)} | ||
2307 | |||
2308 | |||
2309 | #define DECLARE_GETSETNATIVE(Byte, B) \ | ||
2310 | - {CC"get"#Byte, CC"("ADR")"#B, FN_PTR(Unsafe_GetNative##Byte)}, \ | ||
2311 | - {CC"put"#Byte, CC"("ADR#B")V", FN_PTR(Unsafe_SetNative##Byte)} | ||
2312 | + {CC"get"#Byte, CC"(" ADR ")" #B, FN_PTR(Unsafe_GetNative##Byte)}, \ | ||
2313 | + {CC"put"#Byte, CC"(" ADR #B ")V", FN_PTR(Unsafe_SetNative##Byte)} | ||
2314 | |||
2315 | |||
2316 | |||
2317 | // These are the methods for 1.4.0 | ||
2318 | static JNINativeMethod methods_140[] = { | ||
2319 | - {CC"getObject", CC"("OBJ"I)"OBJ"", FN_PTR(Unsafe_GetObject140)}, | ||
2320 | - {CC"putObject", CC"("OBJ"I"OBJ")V", FN_PTR(Unsafe_SetObject140)}, | ||
2321 | + {CC"getObject", CC"(" OBJ "I)" OBJ "", FN_PTR(Unsafe_GetObject140)}, | ||
2322 | + {CC"putObject", CC"(" OBJ "I" OBJ ")V", FN_PTR(Unsafe_SetObject140)}, | ||
2323 | |||
2324 | DECLARE_GETSETOOP_140(Boolean, Z), | ||
2325 | DECLARE_GETSETOOP_140(Byte, B), | ||
2326 | @@ -1396,33 +1396,33 @@ | ||
2327 | DECLARE_GETSETNATIVE(Float, F), | ||
2328 | DECLARE_GETSETNATIVE(Double, D), | ||
2329 | |||
2330 | - {CC"getAddress", CC"("ADR")"ADR, FN_PTR(Unsafe_GetNativeAddress)}, | ||
2331 | - {CC"putAddress", CC"("ADR""ADR")V", FN_PTR(Unsafe_SetNativeAddress)}, | ||
2332 | + {CC"getAddress", CC"(" ADR ")" ADR, FN_PTR(Unsafe_GetNativeAddress)}, | ||
2333 | + {CC"putAddress", CC"(" ADR "" ADR ")V", FN_PTR(Unsafe_SetNativeAddress)}, | ||
2334 | |||
2335 | - {CC"allocateMemory", CC"(J)"ADR, FN_PTR(Unsafe_AllocateMemory)}, | ||
2336 | - {CC"reallocateMemory", CC"("ADR"J)"ADR, FN_PTR(Unsafe_ReallocateMemory)}, | ||
2337 | - {CC"freeMemory", CC"("ADR")V", FN_PTR(Unsafe_FreeMemory)}, | ||
2338 | - | ||
2339 | - {CC"fieldOffset", CC"("FLD")I", FN_PTR(Unsafe_FieldOffset)}, | ||
2340 | - {CC"staticFieldBase", CC"("CLS")"OBJ, FN_PTR(Unsafe_StaticFieldBaseFromClass)}, | ||
2341 | - {CC"ensureClassInitialized",CC"("CLS")V", FN_PTR(Unsafe_EnsureClassInitialized)}, | ||
2342 | - {CC"arrayBaseOffset", CC"("CLS")I", FN_PTR(Unsafe_ArrayBaseOffset)}, | ||
2343 | - {CC"arrayIndexScale", CC"("CLS")I", FN_PTR(Unsafe_ArrayIndexScale)}, | ||
2344 | + {CC"allocateMemory", CC"(J)" ADR, FN_PTR(Unsafe_AllocateMemory)}, | ||
2345 | + {CC"reallocateMemory", CC"(" ADR "J)" ADR, FN_PTR(Unsafe_ReallocateMemory)}, | ||
2346 | + {CC"freeMemory", CC"(" ADR ")V", FN_PTR(Unsafe_FreeMemory)}, | ||
2347 | + | ||
2348 | + {CC"fieldOffset", CC"(" FLD ")I", FN_PTR(Unsafe_FieldOffset)}, | ||
2349 | + {CC"staticFieldBase", CC"(" CLS ")" OBJ, FN_PTR(Unsafe_StaticFieldBaseFromClass)}, | ||
2350 | + {CC"ensureClassInitialized",CC"(" CLS ")V", FN_PTR(Unsafe_EnsureClassInitialized)}, | ||
2351 | + {CC"arrayBaseOffset", CC"(" CLS ")I", FN_PTR(Unsafe_ArrayBaseOffset)}, | ||
2352 | + {CC"arrayIndexScale", CC"(" CLS ")I", FN_PTR(Unsafe_ArrayIndexScale)}, | ||
2353 | {CC"addressSize", CC"()I", FN_PTR(Unsafe_AddressSize)}, | ||
2354 | {CC"pageSize", CC"()I", FN_PTR(Unsafe_PageSize)}, | ||
2355 | |||
2356 | - {CC"defineClass", CC"("DC0_Args")"CLS, FN_PTR(Unsafe_DefineClass0)}, | ||
2357 | - {CC"defineClass", CC"("DC_Args")"CLS, FN_PTR(Unsafe_DefineClass)}, | ||
2358 | - {CC"allocateInstance", CC"("CLS")"OBJ, FN_PTR(Unsafe_AllocateInstance)}, | ||
2359 | - {CC"monitorEnter", CC"("OBJ")V", FN_PTR(Unsafe_MonitorEnter)}, | ||
2360 | - {CC"monitorExit", CC"("OBJ")V", FN_PTR(Unsafe_MonitorExit)}, | ||
2361 | - {CC"throwException", CC"("THR")V", FN_PTR(Unsafe_ThrowException)} | ||
2362 | + {CC"defineClass", CC"(" DC0_Args ")" CLS, FN_PTR(Unsafe_DefineClass0)}, | ||
2363 | + {CC"defineClass", CC"(" DC_Args ")" CLS, FN_PTR(Unsafe_DefineClass)}, | ||
2364 | + {CC"allocateInstance", CC"(" CLS ")" OBJ, FN_PTR(Unsafe_AllocateInstance)}, | ||
2365 | + {CC"monitorEnter", CC"(" OBJ ")V", FN_PTR(Unsafe_MonitorEnter)}, | ||
2366 | + {CC"monitorExit", CC"(" OBJ ")V", FN_PTR(Unsafe_MonitorExit)}, | ||
2367 | + {CC"throwException", CC"(" THR ")V", FN_PTR(Unsafe_ThrowException)} | ||
2368 | }; | ||
2369 | |||
2370 | // These are the methods prior to the JSR 166 changes in 1.5.0 | ||
2371 | static JNINativeMethod methods_141[] = { | ||
2372 | - {CC"getObject", CC"("OBJ"J)"OBJ"", FN_PTR(Unsafe_GetObject)}, | ||
2373 | - {CC"putObject", CC"("OBJ"J"OBJ")V", FN_PTR(Unsafe_SetObject)}, | ||
2374 | + {CC"getObject", CC"(" OBJ "J)" OBJ "", FN_PTR(Unsafe_GetObject)}, | ||
2375 | + {CC"putObject", CC"(" OBJ "J" OBJ ")V", FN_PTR(Unsafe_SetObject)}, | ||
2376 | |||
2377 | DECLARE_GETSETOOP_141(Boolean, Z), | ||
2378 | DECLARE_GETSETOOP_141(Byte, B), | ||
2379 | @@ -1441,37 +1441,37 @@ | ||
2380 | DECLARE_GETSETNATIVE(Float, F), | ||
2381 | DECLARE_GETSETNATIVE(Double, D), | ||
2382 | |||
2383 | - {CC"getAddress", CC"("ADR")"ADR, FN_PTR(Unsafe_GetNativeAddress)}, | ||
2384 | - {CC"putAddress", CC"("ADR""ADR")V", FN_PTR(Unsafe_SetNativeAddress)}, | ||
2385 | + {CC"getAddress", CC"(" ADR ")" ADR, FN_PTR(Unsafe_GetNativeAddress)}, | ||
2386 | + {CC"putAddress", CC"(" ADR "" ADR ")V", FN_PTR(Unsafe_SetNativeAddress)}, | ||
2387 | |||
2388 | - {CC"allocateMemory", CC"(J)"ADR, FN_PTR(Unsafe_AllocateMemory)}, | ||
2389 | - {CC"reallocateMemory", CC"("ADR"J)"ADR, FN_PTR(Unsafe_ReallocateMemory)}, | ||
2390 | - {CC"freeMemory", CC"("ADR")V", FN_PTR(Unsafe_FreeMemory)}, | ||
2391 | - | ||
2392 | - {CC"objectFieldOffset", CC"("FLD")J", FN_PTR(Unsafe_ObjectFieldOffset)}, | ||
2393 | - {CC"staticFieldOffset", CC"("FLD")J", FN_PTR(Unsafe_StaticFieldOffset)}, | ||
2394 | - {CC"staticFieldBase", CC"("FLD")"OBJ, FN_PTR(Unsafe_StaticFieldBaseFromField)}, | ||
2395 | - {CC"ensureClassInitialized",CC"("CLS")V", FN_PTR(Unsafe_EnsureClassInitialized)}, | ||
2396 | - {CC"arrayBaseOffset", CC"("CLS")I", FN_PTR(Unsafe_ArrayBaseOffset)}, | ||
2397 | - {CC"arrayIndexScale", CC"("CLS")I", FN_PTR(Unsafe_ArrayIndexScale)}, | ||
2398 | + {CC"allocateMemory", CC"(J)" ADR, FN_PTR(Unsafe_AllocateMemory)}, | ||
2399 | + {CC"reallocateMemory", CC"(" ADR "J)" ADR, FN_PTR(Unsafe_ReallocateMemory)}, | ||
2400 | + {CC"freeMemory", CC"(" ADR ")V", FN_PTR(Unsafe_FreeMemory)}, | ||
2401 | + | ||
2402 | + {CC"objectFieldOffset", CC"(" FLD ")J", FN_PTR(Unsafe_ObjectFieldOffset)}, | ||
2403 | + {CC"staticFieldOffset", CC"(" FLD ")J", FN_PTR(Unsafe_StaticFieldOffset)}, | ||
2404 | + {CC"staticFieldBase", CC"(" FLD ")" OBJ, FN_PTR(Unsafe_StaticFieldBaseFromField)}, | ||
2405 | + {CC"ensureClassInitialized",CC"(" CLS ")V", FN_PTR(Unsafe_EnsureClassInitialized)}, | ||
2406 | + {CC"arrayBaseOffset", CC"(" CLS ")I", FN_PTR(Unsafe_ArrayBaseOffset)}, | ||
2407 | + {CC"arrayIndexScale", CC"(" CLS ")I", FN_PTR(Unsafe_ArrayIndexScale)}, | ||
2408 | {CC"addressSize", CC"()I", FN_PTR(Unsafe_AddressSize)}, | ||
2409 | {CC"pageSize", CC"()I", FN_PTR(Unsafe_PageSize)}, | ||
2410 | |||
2411 | - {CC"defineClass", CC"("DC0_Args")"CLS, FN_PTR(Unsafe_DefineClass0)}, | ||
2412 | - {CC"defineClass", CC"("DC_Args")"CLS, FN_PTR(Unsafe_DefineClass)}, | ||
2413 | - {CC"allocateInstance", CC"("CLS")"OBJ, FN_PTR(Unsafe_AllocateInstance)}, | ||
2414 | - {CC"monitorEnter", CC"("OBJ")V", FN_PTR(Unsafe_MonitorEnter)}, | ||
2415 | - {CC"monitorExit", CC"("OBJ")V", FN_PTR(Unsafe_MonitorExit)}, | ||
2416 | - {CC"throwException", CC"("THR")V", FN_PTR(Unsafe_ThrowException)} | ||
2417 | + {CC"defineClass", CC"(" DC0_Args ")" CLS, FN_PTR(Unsafe_DefineClass0)}, | ||
2418 | + {CC"defineClass", CC"(" DC_Args ")" CLS, FN_PTR(Unsafe_DefineClass)}, | ||
2419 | + {CC"allocateInstance", CC"(" CLS ")" OBJ, FN_PTR(Unsafe_AllocateInstance)}, | ||
2420 | + {CC"monitorEnter", CC"(" OBJ ")V", FN_PTR(Unsafe_MonitorEnter)}, | ||
2421 | + {CC"monitorExit", CC"(" OBJ ")V", FN_PTR(Unsafe_MonitorExit)}, | ||
2422 | + {CC"throwException", CC"(" THR ")V", FN_PTR(Unsafe_ThrowException)} | ||
2423 | |||
2424 | }; | ||
2425 | |||
2426 | // These are the methods prior to the JSR 166 changes in 1.6.0 | ||
2427 | static JNINativeMethod methods_15[] = { | ||
2428 | - {CC"getObject", CC"("OBJ"J)"OBJ"", FN_PTR(Unsafe_GetObject)}, | ||
2429 | - {CC"putObject", CC"("OBJ"J"OBJ")V", FN_PTR(Unsafe_SetObject)}, | ||
2430 | - {CC"getObjectVolatile",CC"("OBJ"J)"OBJ"", FN_PTR(Unsafe_GetObjectVolatile)}, | ||
2431 | - {CC"putObjectVolatile",CC"("OBJ"J"OBJ")V", FN_PTR(Unsafe_SetObjectVolatile)}, | ||
2432 | + {CC"getObject", CC"(" OBJ "J)" OBJ "", FN_PTR(Unsafe_GetObject)}, | ||
2433 | + {CC"putObject", CC"(" OBJ "J" OBJ ")V", FN_PTR(Unsafe_SetObject)}, | ||
2434 | + {CC"getObjectVolatile",CC"(" OBJ "J)" OBJ "", FN_PTR(Unsafe_GetObjectVolatile)}, | ||
2435 | + {CC"putObjectVolatile",CC"(" OBJ "J" OBJ ")V", FN_PTR(Unsafe_SetObjectVolatile)}, | ||
2436 | |||
2437 | |||
2438 | DECLARE_GETSETOOP(Boolean, Z), | ||
2439 | @@ -1491,42 +1491,42 @@ | ||
2440 | DECLARE_GETSETNATIVE(Float, F), | ||
2441 | DECLARE_GETSETNATIVE(Double, D), | ||
2442 | |||
2443 | - {CC"getAddress", CC"("ADR")"ADR, FN_PTR(Unsafe_GetNativeAddress)}, | ||
2444 | - {CC"putAddress", CC"("ADR""ADR")V", FN_PTR(Unsafe_SetNativeAddress)}, | ||
2445 | + {CC"getAddress", CC"(" ADR ")" ADR, FN_PTR(Unsafe_GetNativeAddress)}, | ||
2446 | + {CC"putAddress", CC"(" ADR "" ADR ")V", FN_PTR(Unsafe_SetNativeAddress)}, | ||
2447 | |||
2448 | - {CC"allocateMemory", CC"(J)"ADR, FN_PTR(Unsafe_AllocateMemory)}, | ||
2449 | - {CC"reallocateMemory", CC"("ADR"J)"ADR, FN_PTR(Unsafe_ReallocateMemory)}, | ||
2450 | - {CC"freeMemory", CC"("ADR")V", FN_PTR(Unsafe_FreeMemory)}, | ||
2451 | - | ||
2452 | - {CC"objectFieldOffset", CC"("FLD")J", FN_PTR(Unsafe_ObjectFieldOffset)}, | ||
2453 | - {CC"staticFieldOffset", CC"("FLD")J", FN_PTR(Unsafe_StaticFieldOffset)}, | ||
2454 | - {CC"staticFieldBase", CC"("FLD")"OBJ, FN_PTR(Unsafe_StaticFieldBaseFromField)}, | ||
2455 | - {CC"ensureClassInitialized",CC"("CLS")V", FN_PTR(Unsafe_EnsureClassInitialized)}, | ||
2456 | - {CC"arrayBaseOffset", CC"("CLS")I", FN_PTR(Unsafe_ArrayBaseOffset)}, | ||
2457 | - {CC"arrayIndexScale", CC"("CLS")I", FN_PTR(Unsafe_ArrayIndexScale)}, | ||
2458 | + {CC"allocateMemory", CC"(J)" ADR, FN_PTR(Unsafe_AllocateMemory)}, | ||
2459 | + {CC"reallocateMemory", CC"(" ADR "J)" ADR, FN_PTR(Unsafe_ReallocateMemory)}, | ||
2460 | + {CC"freeMemory", CC"(" ADR ")V", FN_PTR(Unsafe_FreeMemory)}, | ||
2461 | + | ||
2462 | + {CC"objectFieldOffset", CC"(" FLD ")J", FN_PTR(Unsafe_ObjectFieldOffset)}, | ||
2463 | + {CC"staticFieldOffset", CC"(" FLD ")J", FN_PTR(Unsafe_StaticFieldOffset)}, | ||
2464 | + {CC"staticFieldBase", CC"(" FLD ")" OBJ, FN_PTR(Unsafe_StaticFieldBaseFromField)}, | ||
2465 | + {CC"ensureClassInitialized",CC"(" CLS ")V", FN_PTR(Unsafe_EnsureClassInitialized)}, | ||
2466 | + {CC"arrayBaseOffset", CC"(" CLS ")I", FN_PTR(Unsafe_ArrayBaseOffset)}, | ||
2467 | + {CC"arrayIndexScale", CC"(" CLS ")I", FN_PTR(Unsafe_ArrayIndexScale)}, | ||
2468 | {CC"addressSize", CC"()I", FN_PTR(Unsafe_AddressSize)}, | ||
2469 | {CC"pageSize", CC"()I", FN_PTR(Unsafe_PageSize)}, | ||
2470 | |||
2471 | - {CC"defineClass", CC"("DC0_Args")"CLS, FN_PTR(Unsafe_DefineClass0)}, | ||
2472 | - {CC"defineClass", CC"("DC_Args")"CLS, FN_PTR(Unsafe_DefineClass)}, | ||
2473 | - {CC"allocateInstance", CC"("CLS")"OBJ, FN_PTR(Unsafe_AllocateInstance)}, | ||
2474 | - {CC"monitorEnter", CC"("OBJ")V", FN_PTR(Unsafe_MonitorEnter)}, | ||
2475 | - {CC"monitorExit", CC"("OBJ")V", FN_PTR(Unsafe_MonitorExit)}, | ||
2476 | - {CC"throwException", CC"("THR")V", FN_PTR(Unsafe_ThrowException)}, | ||
2477 | - {CC"compareAndSwapObject", CC"("OBJ"J"OBJ""OBJ")Z", FN_PTR(Unsafe_CompareAndSwapObject)}, | ||
2478 | - {CC"compareAndSwapInt", CC"("OBJ"J""I""I"")Z", FN_PTR(Unsafe_CompareAndSwapInt)}, | ||
2479 | - {CC"compareAndSwapLong", CC"("OBJ"J""J""J"")Z", FN_PTR(Unsafe_CompareAndSwapLong)}, | ||
2480 | + {CC"defineClass", CC"(" DC0_Args ")" CLS, FN_PTR(Unsafe_DefineClass0)}, | ||
2481 | + {CC"defineClass", CC"(" DC_Args ")" CLS, FN_PTR(Unsafe_DefineClass)}, | ||
2482 | + {CC"allocateInstance", CC"(" CLS ")" OBJ, FN_PTR(Unsafe_AllocateInstance)}, | ||
2483 | + {CC"monitorEnter", CC"(" OBJ ")V", FN_PTR(Unsafe_MonitorEnter)}, | ||
2484 | + {CC"monitorExit", CC"(" OBJ ")V", FN_PTR(Unsafe_MonitorExit)}, | ||
2485 | + {CC"throwException", CC"(" THR ")V", FN_PTR(Unsafe_ThrowException)}, | ||
2486 | + {CC"compareAndSwapObject", CC"(" OBJ "J" OBJ "" OBJ ")Z", FN_PTR(Unsafe_CompareAndSwapObject)}, | ||
2487 | + {CC"compareAndSwapInt", CC"(" OBJ "J""I""I"")Z", FN_PTR(Unsafe_CompareAndSwapInt)}, | ||
2488 | + {CC"compareAndSwapLong", CC"(" OBJ "J""J""J"")Z", FN_PTR(Unsafe_CompareAndSwapLong)}, | ||
2489 | {CC"park", CC"(ZJ)V", FN_PTR(Unsafe_Park)}, | ||
2490 | - {CC"unpark", CC"("OBJ")V", FN_PTR(Unsafe_Unpark)} | ||
2491 | + {CC"unpark", CC"(" OBJ ")V", FN_PTR(Unsafe_Unpark)} | ||
2492 | |||
2493 | }; | ||
2494 | |||
2495 | // These are the methods for 1.6.0 and 1.7.0 | ||
2496 | static JNINativeMethod methods_16[] = { | ||
2497 | - {CC"getObject", CC"("OBJ"J)"OBJ"", FN_PTR(Unsafe_GetObject)}, | ||
2498 | - {CC"putObject", CC"("OBJ"J"OBJ")V", FN_PTR(Unsafe_SetObject)}, | ||
2499 | - {CC"getObjectVolatile",CC"("OBJ"J)"OBJ"", FN_PTR(Unsafe_GetObjectVolatile)}, | ||
2500 | - {CC"putObjectVolatile",CC"("OBJ"J"OBJ")V", FN_PTR(Unsafe_SetObjectVolatile)}, | ||
2501 | + {CC"getObject", CC"(" OBJ "J)" OBJ "", FN_PTR(Unsafe_GetObject)}, | ||
2502 | + {CC"putObject", CC"(" OBJ "J" OBJ ")V", FN_PTR(Unsafe_SetObject)}, | ||
2503 | + {CC"getObjectVolatile",CC"(" OBJ "J)" OBJ "", FN_PTR(Unsafe_GetObjectVolatile)}, | ||
2504 | + {CC"putObjectVolatile",CC"(" OBJ "J" OBJ ")V", FN_PTR(Unsafe_SetObjectVolatile)}, | ||
2505 | |||
2506 | DECLARE_GETSETOOP(Boolean, Z), | ||
2507 | DECLARE_GETSETOOP(Byte, B), | ||
2508 | @@ -1545,45 +1545,45 @@ | ||
2509 | DECLARE_GETSETNATIVE(Float, F), | ||
2510 | DECLARE_GETSETNATIVE(Double, D), | ||
2511 | |||
2512 | - {CC"getAddress", CC"("ADR")"ADR, FN_PTR(Unsafe_GetNativeAddress)}, | ||
2513 | - {CC"putAddress", CC"("ADR""ADR")V", FN_PTR(Unsafe_SetNativeAddress)}, | ||
2514 | + {CC"getAddress", CC"(" ADR ")" ADR, FN_PTR(Unsafe_GetNativeAddress)}, | ||
2515 | + {CC"putAddress", CC"(" ADR "" ADR ")V", FN_PTR(Unsafe_SetNativeAddress)}, | ||
2516 | |||
2517 | - {CC"allocateMemory", CC"(J)"ADR, FN_PTR(Unsafe_AllocateMemory)}, | ||
2518 | - {CC"reallocateMemory", CC"("ADR"J)"ADR, FN_PTR(Unsafe_ReallocateMemory)}, | ||
2519 | - {CC"freeMemory", CC"("ADR")V", FN_PTR(Unsafe_FreeMemory)}, | ||
2520 | - | ||
2521 | - {CC"objectFieldOffset", CC"("FLD")J", FN_PTR(Unsafe_ObjectFieldOffset)}, | ||
2522 | - {CC"staticFieldOffset", CC"("FLD")J", FN_PTR(Unsafe_StaticFieldOffset)}, | ||
2523 | - {CC"staticFieldBase", CC"("FLD")"OBJ, FN_PTR(Unsafe_StaticFieldBaseFromField)}, | ||
2524 | - {CC"ensureClassInitialized",CC"("CLS")V", FN_PTR(Unsafe_EnsureClassInitialized)}, | ||
2525 | - {CC"arrayBaseOffset", CC"("CLS")I", FN_PTR(Unsafe_ArrayBaseOffset)}, | ||
2526 | - {CC"arrayIndexScale", CC"("CLS")I", FN_PTR(Unsafe_ArrayIndexScale)}, | ||
2527 | + {CC"allocateMemory", CC"(J)" ADR, FN_PTR(Unsafe_AllocateMemory)}, | ||
2528 | + {CC"reallocateMemory", CC"(" ADR "J)" ADR, FN_PTR(Unsafe_ReallocateMemory)}, | ||
2529 | + {CC"freeMemory", CC"(" ADR ")V", FN_PTR(Unsafe_FreeMemory)}, | ||
2530 | + | ||
2531 | + {CC"objectFieldOffset", CC"(" FLD ")J", FN_PTR(Unsafe_ObjectFieldOffset)}, | ||
2532 | + {CC"staticFieldOffset", CC"(" FLD ")J", FN_PTR(Unsafe_StaticFieldOffset)}, | ||
2533 | + {CC"staticFieldBase", CC"(" FLD ")" OBJ, FN_PTR(Unsafe_StaticFieldBaseFromField)}, | ||
2534 | + {CC"ensureClassInitialized",CC"(" CLS ")V", FN_PTR(Unsafe_EnsureClassInitialized)}, | ||
2535 | + {CC"arrayBaseOffset", CC"(" CLS ")I", FN_PTR(Unsafe_ArrayBaseOffset)}, | ||
2536 | + {CC"arrayIndexScale", CC"(" CLS ")I", FN_PTR(Unsafe_ArrayIndexScale)}, | ||
2537 | {CC"addressSize", CC"()I", FN_PTR(Unsafe_AddressSize)}, | ||
2538 | {CC"pageSize", CC"()I", FN_PTR(Unsafe_PageSize)}, | ||
2539 | |||
2540 | - {CC"defineClass", CC"("DC0_Args")"CLS, FN_PTR(Unsafe_DefineClass0)}, | ||
2541 | - {CC"defineClass", CC"("DC_Args")"CLS, FN_PTR(Unsafe_DefineClass)}, | ||
2542 | - {CC"allocateInstance", CC"("CLS")"OBJ, FN_PTR(Unsafe_AllocateInstance)}, | ||
2543 | - {CC"monitorEnter", CC"("OBJ")V", FN_PTR(Unsafe_MonitorEnter)}, | ||
2544 | - {CC"monitorExit", CC"("OBJ")V", FN_PTR(Unsafe_MonitorExit)}, | ||
2545 | - {CC"tryMonitorEnter", CC"("OBJ")Z", FN_PTR(Unsafe_TryMonitorEnter)}, | ||
2546 | - {CC"throwException", CC"("THR")V", FN_PTR(Unsafe_ThrowException)}, | ||
2547 | - {CC"compareAndSwapObject", CC"("OBJ"J"OBJ""OBJ")Z", FN_PTR(Unsafe_CompareAndSwapObject)}, | ||
2548 | - {CC"compareAndSwapInt", CC"("OBJ"J""I""I"")Z", FN_PTR(Unsafe_CompareAndSwapInt)}, | ||
2549 | - {CC"compareAndSwapLong", CC"("OBJ"J""J""J"")Z", FN_PTR(Unsafe_CompareAndSwapLong)}, | ||
2550 | - {CC"putOrderedObject", CC"("OBJ"J"OBJ")V", FN_PTR(Unsafe_SetOrderedObject)}, | ||
2551 | - {CC"putOrderedInt", CC"("OBJ"JI)V", FN_PTR(Unsafe_SetOrderedInt)}, | ||
2552 | - {CC"putOrderedLong", CC"("OBJ"JJ)V", FN_PTR(Unsafe_SetOrderedLong)}, | ||
2553 | + {CC"defineClass", CC"(" DC0_Args ")" CLS, FN_PTR(Unsafe_DefineClass0)}, | ||
2554 | + {CC"defineClass", CC"(" DC_Args ")" CLS, FN_PTR(Unsafe_DefineClass)}, | ||
2555 | + {CC"allocateInstance", CC"(" CLS ")" OBJ, FN_PTR(Unsafe_AllocateInstance)}, | ||
2556 | + {CC"monitorEnter", CC"(" OBJ ")V", FN_PTR(Unsafe_MonitorEnter)}, | ||
2557 | + {CC"monitorExit", CC"(" OBJ ")V", FN_PTR(Unsafe_MonitorExit)}, | ||
2558 | + {CC"tryMonitorEnter", CC"(" OBJ ")Z", FN_PTR(Unsafe_TryMonitorEnter)}, | ||
2559 | + {CC"throwException", CC"(" THR ")V", FN_PTR(Unsafe_ThrowException)}, | ||
2560 | + {CC"compareAndSwapObject", CC"(" OBJ "J" OBJ "" OBJ ")Z", FN_PTR(Unsafe_CompareAndSwapObject)}, | ||
2561 | + {CC"compareAndSwapInt", CC"(" OBJ "J""I""I"")Z", FN_PTR(Unsafe_CompareAndSwapInt)}, | ||
2562 | + {CC"compareAndSwapLong", CC"(" OBJ "J""J""J"")Z", FN_PTR(Unsafe_CompareAndSwapLong)}, | ||
2563 | + {CC"putOrderedObject", CC"(" OBJ "J" OBJ ")V", FN_PTR(Unsafe_SetOrderedObject)}, | ||
2564 | + {CC"putOrderedInt", CC"(" OBJ "JI)V", FN_PTR(Unsafe_SetOrderedInt)}, | ||
2565 | + {CC"putOrderedLong", CC"(" OBJ "JJ)V", FN_PTR(Unsafe_SetOrderedLong)}, | ||
2566 | {CC"park", CC"(ZJ)V", FN_PTR(Unsafe_Park)}, | ||
2567 | - {CC"unpark", CC"("OBJ")V", FN_PTR(Unsafe_Unpark)} | ||
2568 | + {CC"unpark", CC"(" OBJ ")V", FN_PTR(Unsafe_Unpark)} | ||
2569 | }; | ||
2570 | |||
2571 | // These are the methods for 1.8.0 | ||
2572 | static JNINativeMethod methods_18[] = { | ||
2573 | - {CC"getObject", CC"("OBJ"J)"OBJ"", FN_PTR(Unsafe_GetObject)}, | ||
2574 | - {CC"putObject", CC"("OBJ"J"OBJ")V", FN_PTR(Unsafe_SetObject)}, | ||
2575 | - {CC"getObjectVolatile",CC"("OBJ"J)"OBJ"", FN_PTR(Unsafe_GetObjectVolatile)}, | ||
2576 | - {CC"putObjectVolatile",CC"("OBJ"J"OBJ")V", FN_PTR(Unsafe_SetObjectVolatile)}, | ||
2577 | + {CC"getObject", CC"(" OBJ "J)" OBJ "", FN_PTR(Unsafe_GetObject)}, | ||
2578 | + {CC"putObject", CC"(" OBJ "J" OBJ ")V", FN_PTR(Unsafe_SetObject)}, | ||
2579 | + {CC"getObjectVolatile",CC"(" OBJ "J)" OBJ "", FN_PTR(Unsafe_GetObjectVolatile)}, | ||
2580 | + {CC"putObjectVolatile",CC"(" OBJ "J" OBJ ")V", FN_PTR(Unsafe_SetObjectVolatile)}, | ||
2581 | |||
2582 | DECLARE_GETSETOOP(Boolean, Z), | ||
2583 | DECLARE_GETSETOOP(Byte, B), | ||
2584 | @@ -1602,36 +1602,36 @@ | ||
2585 | DECLARE_GETSETNATIVE(Float, F), | ||
2586 | DECLARE_GETSETNATIVE(Double, D), | ||
2587 | |||
2588 | - {CC"getAddress", CC"("ADR")"ADR, FN_PTR(Unsafe_GetNativeAddress)}, | ||
2589 | - {CC"putAddress", CC"("ADR""ADR")V", FN_PTR(Unsafe_SetNativeAddress)}, | ||
2590 | + {CC"getAddress", CC"(" ADR ")" ADR, FN_PTR(Unsafe_GetNativeAddress)}, | ||
2591 | + {CC"putAddress", CC"(" ADR "" ADR ")V", FN_PTR(Unsafe_SetNativeAddress)}, | ||
2592 | |||
2593 | - {CC"allocateMemory", CC"(J)"ADR, FN_PTR(Unsafe_AllocateMemory)}, | ||
2594 | - {CC"reallocateMemory", CC"("ADR"J)"ADR, FN_PTR(Unsafe_ReallocateMemory)}, | ||
2595 | - {CC"freeMemory", CC"("ADR")V", FN_PTR(Unsafe_FreeMemory)}, | ||
2596 | - | ||
2597 | - {CC"objectFieldOffset", CC"("FLD")J", FN_PTR(Unsafe_ObjectFieldOffset)}, | ||
2598 | - {CC"staticFieldOffset", CC"("FLD")J", FN_PTR(Unsafe_StaticFieldOffset)}, | ||
2599 | - {CC"staticFieldBase", CC"("FLD")"OBJ, FN_PTR(Unsafe_StaticFieldBaseFromField)}, | ||
2600 | - {CC"ensureClassInitialized",CC"("CLS")V", FN_PTR(Unsafe_EnsureClassInitialized)}, | ||
2601 | - {CC"arrayBaseOffset", CC"("CLS")I", FN_PTR(Unsafe_ArrayBaseOffset)}, | ||
2602 | - {CC"arrayIndexScale", CC"("CLS")I", FN_PTR(Unsafe_ArrayIndexScale)}, | ||
2603 | + {CC"allocateMemory", CC"(J)" ADR, FN_PTR(Unsafe_AllocateMemory)}, | ||
2604 | + {CC"reallocateMemory", CC"(" ADR "J)" ADR, FN_PTR(Unsafe_ReallocateMemory)}, | ||
2605 | + {CC"freeMemory", CC"(" ADR ")V", FN_PTR(Unsafe_FreeMemory)}, | ||
2606 | + | ||
2607 | + {CC"objectFieldOffset", CC"(" FLD ")J", FN_PTR(Unsafe_ObjectFieldOffset)}, | ||
2608 | + {CC"staticFieldOffset", CC"(" FLD ")J", FN_PTR(Unsafe_StaticFieldOffset)}, | ||
2609 | + {CC"staticFieldBase", CC"(" FLD ")" OBJ, FN_PTR(Unsafe_StaticFieldBaseFromField)}, | ||
2610 | + {CC"ensureClassInitialized",CC"(" CLS ")V", FN_PTR(Unsafe_EnsureClassInitialized)}, | ||
2611 | + {CC"arrayBaseOffset", CC"(" CLS ")I", FN_PTR(Unsafe_ArrayBaseOffset)}, | ||
2612 | + {CC"arrayIndexScale", CC"(" CLS ")I", FN_PTR(Unsafe_ArrayIndexScale)}, | ||
2613 | {CC"addressSize", CC"()I", FN_PTR(Unsafe_AddressSize)}, | ||
2614 | {CC"pageSize", CC"()I", FN_PTR(Unsafe_PageSize)}, | ||
2615 | |||
2616 | - {CC"defineClass", CC"("DC_Args")"CLS, FN_PTR(Unsafe_DefineClass)}, | ||
2617 | - {CC"allocateInstance", CC"("CLS")"OBJ, FN_PTR(Unsafe_AllocateInstance)}, | ||
2618 | - {CC"monitorEnter", CC"("OBJ")V", FN_PTR(Unsafe_MonitorEnter)}, | ||
2619 | - {CC"monitorExit", CC"("OBJ")V", FN_PTR(Unsafe_MonitorExit)}, | ||
2620 | - {CC"tryMonitorEnter", CC"("OBJ")Z", FN_PTR(Unsafe_TryMonitorEnter)}, | ||
2621 | - {CC"throwException", CC"("THR")V", FN_PTR(Unsafe_ThrowException)}, | ||
2622 | - {CC"compareAndSwapObject", CC"("OBJ"J"OBJ""OBJ")Z", FN_PTR(Unsafe_CompareAndSwapObject)}, | ||
2623 | - {CC"compareAndSwapInt", CC"("OBJ"J""I""I"")Z", FN_PTR(Unsafe_CompareAndSwapInt)}, | ||
2624 | - {CC"compareAndSwapLong", CC"("OBJ"J""J""J"")Z", FN_PTR(Unsafe_CompareAndSwapLong)}, | ||
2625 | - {CC"putOrderedObject", CC"("OBJ"J"OBJ")V", FN_PTR(Unsafe_SetOrderedObject)}, | ||
2626 | - {CC"putOrderedInt", CC"("OBJ"JI)V", FN_PTR(Unsafe_SetOrderedInt)}, | ||
2627 | - {CC"putOrderedLong", CC"("OBJ"JJ)V", FN_PTR(Unsafe_SetOrderedLong)}, | ||
2628 | + {CC"defineClass", CC"(" DC_Args ")" CLS, FN_PTR(Unsafe_DefineClass)}, | ||
2629 | + {CC"allocateInstance", CC"(" CLS ")" OBJ, FN_PTR(Unsafe_AllocateInstance)}, | ||
2630 | + {CC"monitorEnter", CC"(" OBJ ")V", FN_PTR(Unsafe_MonitorEnter)}, | ||
2631 | + {CC"monitorExit", CC"(" OBJ ")V", FN_PTR(Unsafe_MonitorExit)}, | ||
2632 | + {CC"tryMonitorEnter", CC"(" OBJ ")Z", FN_PTR(Unsafe_TryMonitorEnter)}, | ||
2633 | + {CC"throwException", CC"(" THR ")V", FN_PTR(Unsafe_ThrowException)}, | ||
2634 | + {CC"compareAndSwapObject", CC"(" OBJ "J" OBJ "" OBJ ")Z", FN_PTR(Unsafe_CompareAndSwapObject)}, | ||
2635 | + {CC"compareAndSwapInt", CC"(" OBJ "J""I""I"")Z", FN_PTR(Unsafe_CompareAndSwapInt)}, | ||
2636 | + {CC"compareAndSwapLong", CC"(" OBJ "J""J""J"")Z", FN_PTR(Unsafe_CompareAndSwapLong)}, | ||
2637 | + {CC"putOrderedObject", CC"(" OBJ "J" OBJ ")V", FN_PTR(Unsafe_SetOrderedObject)}, | ||
2638 | + {CC"putOrderedInt", CC"(" OBJ "JI)V", FN_PTR(Unsafe_SetOrderedInt)}, | ||
2639 | + {CC"putOrderedLong", CC"(" OBJ "JJ)V", FN_PTR(Unsafe_SetOrderedLong)}, | ||
2640 | {CC"park", CC"(ZJ)V", FN_PTR(Unsafe_Park)}, | ||
2641 | - {CC"unpark", CC"("OBJ")V", FN_PTR(Unsafe_Unpark)} | ||
2642 | + {CC"unpark", CC"(" OBJ ")V", FN_PTR(Unsafe_Unpark)} | ||
2643 | }; | ||
2644 | |||
2645 | JNINativeMethod loadavg_method[] = { | ||
2646 | @@ -1639,28 +1639,28 @@ | ||
2647 | }; | ||
2648 | |||
2649 | JNINativeMethod prefetch_methods[] = { | ||
2650 | - {CC"prefetchRead", CC"("OBJ"J)V", FN_PTR(Unsafe_PrefetchRead)}, | ||
2651 | - {CC"prefetchWrite", CC"("OBJ"J)V", FN_PTR(Unsafe_PrefetchWrite)}, | ||
2652 | - {CC"prefetchReadStatic", CC"("OBJ"J)V", FN_PTR(Unsafe_PrefetchRead)}, | ||
2653 | - {CC"prefetchWriteStatic",CC"("OBJ"J)V", FN_PTR(Unsafe_PrefetchWrite)} | ||
2654 | + {CC"prefetchRead", CC"(" OBJ "J)V", FN_PTR(Unsafe_PrefetchRead)}, | ||
2655 | + {CC"prefetchWrite", CC"(" OBJ "J)V", FN_PTR(Unsafe_PrefetchWrite)}, | ||
2656 | + {CC"prefetchReadStatic", CC"(" OBJ "J)V", FN_PTR(Unsafe_PrefetchRead)}, | ||
2657 | + {CC"prefetchWriteStatic",CC"(" OBJ "J)V", FN_PTR(Unsafe_PrefetchWrite)} | ||
2658 | }; | ||
2659 | |||
2660 | JNINativeMethod memcopy_methods_17[] = { | ||
2661 | - {CC"copyMemory", CC"("OBJ"J"OBJ"JJ)V", FN_PTR(Unsafe_CopyMemory2)}, | ||
2662 | - {CC"setMemory", CC"("OBJ"JJB)V", FN_PTR(Unsafe_SetMemory2)} | ||
2663 | + {CC"copyMemory", CC"(" OBJ "J" OBJ "JJ)V", FN_PTR(Unsafe_CopyMemory2)}, | ||
2664 | + {CC"setMemory", CC"(" OBJ "JJB)V", FN_PTR(Unsafe_SetMemory2)} | ||
2665 | }; | ||
2666 | |||
2667 | JNINativeMethod memcopy_methods_15[] = { | ||
2668 | - {CC"setMemory", CC"("ADR"JB)V", FN_PTR(Unsafe_SetMemory)}, | ||
2669 | - {CC"copyMemory", CC"("ADR ADR"J)V", FN_PTR(Unsafe_CopyMemory)} | ||
2670 | + {CC"setMemory", CC"(" ADR "JB)V", FN_PTR(Unsafe_SetMemory)}, | ||
2671 | + {CC"copyMemory", CC"(" ADR ADR "J)V", FN_PTR(Unsafe_CopyMemory)} | ||
2672 | }; | ||
2673 | |||
2674 | JNINativeMethod anonk_methods[] = { | ||
2675 | - {CC"defineAnonymousClass", CC"("DAC_Args")"CLS, FN_PTR(Unsafe_DefineAnonymousClass)}, | ||
2676 | + {CC"defineAnonymousClass", CC"(" DAC_Args ")" CLS, FN_PTR(Unsafe_DefineAnonymousClass)}, | ||
2677 | }; | ||
2678 | |||
2679 | JNINativeMethod lform_methods[] = { | ||
2680 | - {CC"shouldBeInitialized",CC"("CLS")Z", FN_PTR(Unsafe_ShouldBeInitialized)}, | ||
2681 | + {CC"shouldBeInitialized",CC"(" CLS ")Z", FN_PTR(Unsafe_ShouldBeInitialized)}, | ||
2682 | }; | ||
2683 | |||
2684 | JNINativeMethod fence_methods[] = { | ||
2685 | --- hotspot/src/share/vm/prims/whitebox.cpp.orig 2015-09-02 18:55:43.000000000 +0200 | ||
2686 | +++ hotspot/src/share/vm/prims/whitebox.cpp 2015-09-02 18:58:04.000000000 +0200 | ||
2687 | @@ -157,8 +157,8 @@ | ||
2688 | |||
2689 | WB_ENTRY(void, WB_PrintHeapSizes(JNIEnv* env, jobject o)) { | ||
2690 | CollectorPolicy * p = Universe::heap()->collector_policy(); | ||
2691 | - gclog_or_tty->print_cr("Minimum heap "SIZE_FORMAT" Initial heap " | ||
2692 | - SIZE_FORMAT" Maximum heap "SIZE_FORMAT" Min alignment "SIZE_FORMAT" Max alignment "SIZE_FORMAT, | ||
2693 | + gclog_or_tty->print_cr("Minimum heap " SIZE_FORMAT " Initial heap " | ||
2694 | + SIZE_FORMAT " Maximum heap " SIZE_FORMAT " Min alignment " SIZE_FORMAT " Max alignment " SIZE_FORMAT, | ||
2695 | p->min_heap_byte_size(), p->initial_heap_byte_size(), p->max_heap_byte_size(), | ||
2696 | p->space_alignment(), p->heap_alignment()); | ||
2697 | } | ||
2698 | @@ -193,8 +193,8 @@ | ||
2699 | Universe::narrow_oop_use_implicit_null_checks() )) { | ||
2700 | tty->print_cr("WB_ReadFromNoaccessArea method is useless:\n " | ||
2701 | "\tUseCompressedOops is %d\n" | ||
2702 | - "\trhs.base() is "PTR_FORMAT"\n" | ||
2703 | - "\tUniverse::narrow_oop_base() is "PTR_FORMAT"\n" | ||
2704 | + "\trhs.base() is " PTR_FORMAT "\n" | ||
2705 | + "\tUniverse::narrow_oop_base() is " PTR_FORMAT "\n" | ||
2706 | "\tUniverse::narrow_oop_use_implicit_null_checks() is %d", | ||
2707 | UseCompressedOops, | ||
2708 | rhs.base(), | ||
2709 | @@ -247,8 +247,8 @@ | ||
2710 | |||
2711 | WB_ENTRY(jint, WB_StressVirtualSpaceResize(JNIEnv* env, jobject o, | ||
2712 | jlong reserved_space_size, jlong magnitude, jlong iterations)) | ||
2713 | - tty->print_cr("reservedSpaceSize="JLONG_FORMAT", magnitude="JLONG_FORMAT", " | ||
2714 | - "iterations="JLONG_FORMAT"\n", reserved_space_size, magnitude, | ||
2715 | + tty->print_cr("reservedSpaceSize=" JLONG_FORMAT ", magnitude=" JLONG_FORMAT ", " | ||
2716 | + "iterations=" JLONG_FORMAT "\n", reserved_space_size, magnitude, | ||
2717 | iterations); | ||
2718 | if (reserved_space_size < 0 || magnitude < 0 || iterations < 0) { | ||
2719 | tty->print_cr("One of variables printed above is negative. Can't proceed.\n"); | ||
2720 | --- hotspot/src/share/vm/oops/markOop.cpp.orig 2015-09-10 13:28:34.918039653 +0200 | ||
2721 | +++ hotspot/src/share/vm/oops/markOop.cpp 2015-09-10 13:29:26.890039849 +0200 | ||
2722 | @@ -49,7 +49,7 @@ | ||
2723 | st->print("monitor=NULL"); | ||
2724 | else { | ||
2725 | BasicLock * bl = (BasicLock *) mon->owner(); | ||
2726 | - st->print("monitor={count="INTPTR_FORMAT",waiters="INTPTR_FORMAT",recursions="INTPTR_FORMAT",owner="INTPTR_FORMAT"}", | ||
2727 | + st->print("monitor={count=" INTPTR_FORMAT ",waiters=" INTPTR_FORMAT ",recursions=" INTPTR_FORMAT ",owner=" INTPTR_FORMAT "}", | ||
2728 | mon->count(), mon->waiters(), mon->recursions(), p2i(bl)); | ||
2729 | } | ||
2730 | } else { | ||
diff --git a/recipes-core/openjdk/patches-openjdk-8/openjdk8-no-genx11-in-headless.patch b/recipes-core/openjdk/patches-openjdk-8/openjdk8-no-genx11-in-headless.patch new file mode 100644 index 0000000..e34305c --- /dev/null +++ b/recipes-core/openjdk/patches-openjdk-8/openjdk8-no-genx11-in-headless.patch | |||
@@ -0,0 +1,17 @@ | |||
1 | --- jdk/make/GenerateSources.gmk.orig 2015-08-24 11:23:34.720648954 +0200 | ||
2 | +++ jdk/make/GenerateSources.gmk 2015-08-24 11:24:41.376649205 +0200 | ||
3 | @@ -73,9 +73,11 @@ | ||
4 | GENSRC += $(GENSRC_OSX_ICONS) | ||
5 | endif | ||
6 | |||
7 | - ifneq ($(OPENJDK_TARGET_OS), macosx) | ||
8 | - include gensrc/GensrcX11Wrappers.gmk | ||
9 | - GENSRC += $(GENSRC_X11WRAPPERS) | ||
10 | + ifndef BUILD_HEADLESS_ONLY | ||
11 | + ifneq ($(OPENJDK_TARGET_OS), macosx) | ||
12 | + include gensrc/GensrcX11Wrappers.gmk | ||
13 | + GENSRC += $(GENSRC_X11WRAPPERS) | ||
14 | + endif | ||
15 | endif | ||
16 | endif | ||
17 | |||
diff --git a/recipes-core/openjdk/patches-openjdk-8/openjdk8-no-unused-deps.patch b/recipes-core/openjdk/patches-openjdk-8/openjdk8-no-unused-deps.patch new file mode 100644 index 0000000..cd42544 --- /dev/null +++ b/recipes-core/openjdk/patches-openjdk-8/openjdk8-no-unused-deps.patch | |||
@@ -0,0 +1,94 @@ | |||
1 | --- jdk/make/lib/Awt2dLibraries.gmk.orig 2015-09-03 15:05:21.429981848 +0200 | ||
2 | +++ jdk/make/lib/Awt2dLibraries.gmk 2015-09-03 15:05:44.705981936 +0200 | ||
3 | @@ -235,6 +235,10 @@ | ||
4 | LIBAWT_DIRS += $(JDK_TOPDIR)/src/aix/porting | ||
5 | endif | ||
6 | |||
7 | +ifdef BUILD_HEADLESS_ONLY | ||
8 | +LIBAWT_CFLAGS += -DHEADLESS=true | ||
9 | +endif | ||
10 | + | ||
11 | LIBAWT_CFLAGS += -D__MEDIALIB_OLD_NAMES -D__USE_J2D_NAMES \ | ||
12 | $(X_CFLAGS) \ | ||
13 | $(foreach dir, $(LIBAWT_DIRS), -I$(dir)) | ||
14 | @@ -1126,17 +1130,28 @@ | ||
15 | -F/System/Library/Frameworks/ApplicationServices.framework/Frameworks | ||
16 | endif | ||
17 | |||
18 | - LIBAWT_HEADLESS_FILES := \ | ||
19 | - awt_Font.c \ | ||
20 | - HeadlessToolkit.c \ | ||
21 | - fontpath.c \ | ||
22 | - VDrawingArea.c \ | ||
23 | + ifndef X11_NOT_NEEDED | ||
24 | + LIBAWT_HEADLESS_X11_FILES := \ | ||
25 | X11Color.c \ | ||
26 | X11Renderer.c \ | ||
27 | X11PMBlitLoops.c \ | ||
28 | X11SurfaceData.c \ | ||
29 | X11FontScaler_md.c \ | ||
30 | X11TextRenderer_md.c \ | ||
31 | + GLXGraphicsConfig.c \ | ||
32 | + GLXSurfaceData.c | ||
33 | + endif | ||
34 | + | ||
35 | + ifndef CUPS_NOT_NEEDED | ||
36 | + LIBAWT_HEADLESS_CUPS_FILES := \ | ||
37 | + CUPSfuncs.c | ||
38 | + endif | ||
39 | + | ||
40 | + LIBAWT_HEADLESS_FILES := \ | ||
41 | + awt_Font.c \ | ||
42 | + HeadlessToolkit.c \ | ||
43 | + fontpath.c \ | ||
44 | + VDrawingArea.c \ | ||
45 | OGLBlitLoops.c \ | ||
46 | OGLBufImgOps.c \ | ||
47 | OGLContext.c \ | ||
48 | @@ -1149,10 +1164,9 @@ | ||
49 | OGLSurfaceData.c \ | ||
50 | OGLTextRenderer.c \ | ||
51 | OGLVertexCache.c \ | ||
52 | - GLXGraphicsConfig.c \ | ||
53 | - GLXSurfaceData.c \ | ||
54 | AccelGlyphCache.c \ | ||
55 | - CUPSfuncs.c | ||
56 | + $(LIBAWT_HEADLESS_X11_FILES) \ | ||
57 | + $(LIBAWT_HEADLESS_CUPS_FILES) | ||
58 | |||
59 | LIBAWT_HEADLESS_REORDER := | ||
60 | ifeq ($(OPENJDK_TARGET_OS), solaris) | ||
61 | --- jdk/make/CompileNativeLibraries.gmk.orig 2015-08-24 13:35:55.320678845 +0200 | ||
62 | +++ jdk/make/CompileNativeLibraries.gmk 2015-08-24 13:36:22.776678949 +0200 | ||
63 | @@ -85,7 +85,9 @@ | ||
64 | |||
65 | include lib/Awt2dLibraries.gmk | ||
66 | |||
67 | +ifndef BUILD_SOUNDLESS_ONLY | ||
68 | include lib/SoundLibraries.gmk | ||
69 | +endif | ||
70 | |||
71 | # Include the corresponding custom file, if present. | ||
72 | -include $(CUSTOM_MAKE_DIR)/CompileNativeLibraries.gmk | ||
73 | --- jdk/src/solaris/native/sun/awt/jawt.c.orig 2015-08-24 14:12:29.376687104 +0200 | ||
74 | +++ jdk/src/solaris/native/sun/awt/jawt.c 2015-08-24 14:16:20.420687974 +0200 | ||
75 | @@ -33,7 +33,7 @@ | ||
76 | */ | ||
77 | JNIEXPORT jboolean JNICALL JAWT_GetAWT(JNIEnv* env, JAWT* awt) | ||
78 | { | ||
79 | -#if defined(JAVASE_EMBEDDED) && defined(HEADLESS) | ||
80 | +#if defined(JAVASE_EMBEDDED) || defined(HEADLESS) | ||
81 | /* there are no AWT libs available at all */ | ||
82 | return JNI_FALSE; | ||
83 | #else | ||
84 | --- jdk/src/solaris/native/sun/awt/utility/rect.h.orig 2015-09-03 14:45:40.717977403 +0200 | ||
85 | +++ jdk/src/solaris/native/sun/awt/utility/rect.h 2015-09-03 14:46:46.337977650 +0200 | ||
86 | @@ -28,7 +28,7 @@ | ||
87 | #ifndef _AWT_RECT_H | ||
88 | #define _AWT_RECT_H | ||
89 | |||
90 | -#ifndef MACOSX | ||
91 | +#if !(defined(MACOSX) || defined(HEADLESS)) | ||
92 | #include <X11/Xlib.h> | ||
93 | typedef XRectangle RECT_T; | ||
94 | #else | ||
diff --git a/recipes-core/openjdk/patches-openjdk-8/openjdk8-prevent-debuginfo-in-favour-of-openembedded-package-split.patch b/recipes-core/openjdk/patches-openjdk-8/openjdk8-prevent-debuginfo-in-favour-of-openembedded-package-split.patch new file mode 100644 index 0000000..3a71403 --- /dev/null +++ b/recipes-core/openjdk/patches-openjdk-8/openjdk8-prevent-debuginfo-in-favour-of-openembedded-package-split.patch | |||
@@ -0,0 +1,120 @@ | |||
1 | --- make/common/NativeCompilation.gmk.orig 2015-09-09 17:15:33.869765681 +0200 | ||
2 | +++ make/common/NativeCompilation.gmk 2015-09-09 17:55:26.485774688 +0200 | ||
3 | @@ -434,58 +434,6 @@ | ||
4 | $$($1_OUTPUT_DIR)/% : $$($1_OBJECT_DIR)/% | ||
5 | $(CP) $$< $$@ | ||
6 | endif | ||
7 | - | ||
8 | - ifneq ($(OPENJDK_TARGET_OS), macosx) # OBJCOPY is not used on MacOS X | ||
9 | - ifneq ($(OPENJDK_TARGET_OS), windows) # nor on Windows | ||
10 | - ifeq ($(OPENJDK_TARGET_OS), solaris) | ||
11 | - # gobjcopy crashes on "empty" section headers with the SHF_ALLOC flag set. | ||
12 | - # Use $(FIX_EMPTY_SEC_HDR_FLAGS) to clear the SHF_ALLOC flag (if set) from | ||
13 | - # empty section headers until a fixed $(OBJCOPY) is available. | ||
14 | - # An empty section header has sh_addr == 0 and sh_size == 0. | ||
15 | - # This problem has only been seen on Solaris X64, but we call this tool | ||
16 | - # on all Solaris builds just in case. | ||
17 | - # | ||
18 | - # $(OBJCOPY) --add-gnu-debuglink=... corrupts SUNW_* sections. | ||
19 | - # Use $(ADD_GNU_DEBUGLINK) until a fixed $(OBJCOPY) is available. | ||
20 | - $$($1_OBJECT_DIR)/$$(LIBRARY_PREFIX)$$($1_LIBRARY).debuginfo : $$($1_TARGET) \ | ||
21 | - $(FIX_EMPTY_SEC_HDR_FLAGS) $(ADD_GNU_DEBUGLINK) | ||
22 | - $(RM) $$@ | ||
23 | - $(FIX_EMPTY_SEC_HDR_FLAGS) $(LOG_INFO) $$< | ||
24 | - $(OBJCOPY) --only-keep-debug $$< $$@ | ||
25 | - $(CD) $$(@D) && $(ADD_GNU_DEBUGLINK) $(LOG_INFO) $$(@F) $$< | ||
26 | - else # not solaris | ||
27 | - $$($1_OBJECT_DIR)/$$(LIBRARY_PREFIX)$$($1_LIBRARY).debuginfo : $$($1_TARGET) | ||
28 | - $(RM) $$@ | ||
29 | - $(OBJCOPY) --only-keep-debug $$< $$@ | ||
30 | - $(CD) $$(@D) && $(OBJCOPY) --add-gnu-debuglink=$$(@F) $$< | ||
31 | - endif # Touch to not retrigger rule on rebuild | ||
32 | - $(TOUCH) $$@ | ||
33 | - endif # !windows | ||
34 | - endif # !macosx | ||
35 | - | ||
36 | - ifeq ($(ZIP_DEBUGINFO_FILES), true) | ||
37 | -ifneq ($(OPENJDK_TARGET_OS), macosx) # no MacOS X support yet | ||
38 | - $1 += $$($1_OUTPUT_DIR)/$$(LIBRARY_PREFIX)$$($1_LIBRARY).diz | ||
39 | - | ||
40 | - ifeq ($(OPENJDK_TARGET_OS), windows) | ||
41 | - $$($1_OBJECT_DIR)/$$(LIBRARY_PREFIX)$$($1_LIBRARY).diz : $$($1_TARGET) | ||
42 | - $(CD) $$($1_OBJECT_DIR) \ | ||
43 | - && $(ZIP) -q $$@ $$($1_LIBRARY).map $$($1_LIBRARY).pdb | ||
44 | - else | ||
45 | - $$($1_OBJECT_DIR)/$$(LIBRARY_PREFIX)$$($1_LIBRARY).diz : $$($1_TARGET) \ | ||
46 | - $$($1_OBJECT_DIR)/$$(LIBRARY_PREFIX)$$($1_LIBRARY).debuginfo | ||
47 | - $(CD) $$($1_OBJECT_DIR) \ | ||
48 | - && $(ZIP) -q $$@ $$(LIBRARY_PREFIX)$$($1_LIBRARY).debuginfo | ||
49 | - endif | ||
50 | -endif # no MacOS X support yet | ||
51 | - else | ||
52 | - ifeq ($(OPENJDK_TARGET_OS), windows) | ||
53 | - $1 += $$($1_OUTPUT_DIR)/$$($1_LIBRARY).map \ | ||
54 | - $$($1_OUTPUT_DIR)/$$($1_LIBRARY).pdb | ||
55 | - else ifneq ($(OPENJDK_TARGET_OS), macosx) # MacOS X does not use .debuginfo files | ||
56 | - $1 += $$($1_OUTPUT_DIR)/$$(LIBRARY_PREFIX)$$($1_LIBRARY).debuginfo | ||
57 | - endif | ||
58 | - endif | ||
59 | endif | ||
60 | endif | ||
61 | |||
62 | @@ -518,58 +466,6 @@ | ||
63 | $$($1_OUTPUT_DIR)/% : $$($1_OBJECT_DIR)/% | ||
64 | $(CP) $$< $$@ | ||
65 | endif | ||
66 | - | ||
67 | - ifneq ($(OPENJDK_TARGET_OS), macosx) # OBJCOPY is not used on MacOS X | ||
68 | - ifneq ($(OPENJDK_TARGET_OS), windows) # nor on Windows | ||
69 | - ifeq ($(OPENJDK_TARGET_OS), solaris) | ||
70 | - # gobjcopy crashes on "empty" section headers with the SHF_ALLOC flag set. | ||
71 | - # Use $(FIX_EMPTY_SEC_HDR_FLAGS) to clear the SHF_ALLOC flag (if set) from | ||
72 | - # empty section headers until a fixed $(OBJCOPY) is available. | ||
73 | - # An empty section header has sh_addr == 0 and sh_size == 0. | ||
74 | - # This problem has only been seen on Solaris X64, but we call this tool | ||
75 | - # on all Solaris builds just in case. | ||
76 | - # | ||
77 | - # $(OBJCOPY) --add-gnu-debuglink=... corrupts SUNW_* sections. | ||
78 | - # Use $(ADD_GNU_DEBUGLINK) until a fixed $(OBJCOPY) is available. | ||
79 | - $$($1_OBJECT_DIR)/$$($1_PROGRAM).debuginfo : $$($1_TARGET) \ | ||
80 | - $(FIX_EMPTY_SEC_HDR_FLAGS) $(ADD_GNU_DEBUGLINK) | ||
81 | - $(RM) $$@ | ||
82 | - $(FIX_EMPTY_SEC_HDR_FLAGS) $(LOG_INFO) $$< | ||
83 | - $(OBJCOPY) --only-keep-debug $$< $$@ | ||
84 | - $(CD) $$(@D) && $(ADD_GNU_DEBUGLINK) $(LOG_INFO) $$(@F) $$< | ||
85 | - else # not solaris | ||
86 | - $$($1_OBJECT_DIR)/$$($1_PROGRAM).debuginfo : $$($1_TARGET) | ||
87 | - $(RM) $$@ | ||
88 | - $(OBJCOPY) --only-keep-debug $$< $$@ | ||
89 | - $(CD) $$(@D) && $(OBJCOPY) --add-gnu-debuglink=$$(@F) $$< | ||
90 | - endif | ||
91 | - $(TOUCH) $$@ | ||
92 | - endif # !windows | ||
93 | - endif # !macosx | ||
94 | - | ||
95 | - ifeq ($(ZIP_DEBUGINFO_FILES), true) | ||
96 | -ifneq ($(OPENJDK_TARGET_OS), macosx) # no MacOS X support yet | ||
97 | - $1 += $$($1_OUTPUT_DIR)/$$($1_PROGRAM).diz | ||
98 | - | ||
99 | - ifeq ($(OPENJDK_TARGET_OS), windows) | ||
100 | - $$($1_OBJECT_DIR)/$$($1_PROGRAM).diz : $$($1_TARGET) | ||
101 | - $(CD) $$($1_OBJECT_DIR) \ | ||
102 | - && $(ZIP) -q $$@ $$($1_PROGRAM).map $$($1_PROGRAM).pdb | ||
103 | - else | ||
104 | - $$($1_OBJECT_DIR)/$$(PROGRAM_PREFIX)$$($1_PROGRAM).diz : $$($1_TARGET) \ | ||
105 | - $$($1_OBJECT_DIR)/$$($1_PROGRAM).debuginfo | ||
106 | - $(CD) $$($1_OBJECT_DIR) \ | ||
107 | - && $(ZIP) -q $$@ $$($1_PROGRAM).debuginfo | ||
108 | - endif | ||
109 | -endif # no MacOS X support yet | ||
110 | - else | ||
111 | - ifeq ($(OPENJDK_TARGET_OS), windows) | ||
112 | - $1 += $$($1_OUTPUT_DIR)/$$($1_PROGRAM).map \ | ||
113 | - $$($1_OUTPUT_DIR)/$$($1_PROGRAM).pdb | ||
114 | - else ifneq ($(OPENJDK_TARGET_OS), macosx) # MacOS X does not use .debuginfo files | ||
115 | - $1 += $$($1_OUTPUT_DIR)/$$($1_PROGRAM).debuginfo | ||
116 | - endif | ||
117 | - endif | ||
118 | endif | ||
119 | endif | ||
120 | |||
diff --git a/recipes-core/openjdk/patches-openjdk-8/openjdk8-restrict-to-staging-dir.patch b/recipes-core/openjdk/patches-openjdk-8/openjdk8-restrict-to-staging-dir.patch new file mode 100644 index 0000000..d33dc96 --- /dev/null +++ b/recipes-core/openjdk/patches-openjdk-8/openjdk8-restrict-to-staging-dir.patch | |||
@@ -0,0 +1,11 @@ | |||
1 | --- hotspot/make/linux/makefiles/dtrace.make.orig 2015-09-01 08:00:59.737868760 +0200 | ||
2 | +++ hotspot/make/linux/makefiles/dtrace.make 2015-09-01 08:01:24.049859677 +0200 | ||
3 | @@ -40,7 +40,7 @@ | ||
4 | ifneq ($(ALT_SDT_H),) | ||
5 | SDT_H_FILE = $(ALT_SDT_H) | ||
6 | else | ||
7 | - SDT_H_FILE = /usr/include/sys/sdt.h | ||
8 | + SDT_H_FILE = $(SYS_ROOT)/usr/include/sys/sdt.h | ||
9 | endif | ||
10 | DTRACE_ENABLED = $(shell test -f $(SDT_H_FILE) && echo $(SDT_H_FILE)) | ||
11 | REASON = "$(SDT_H_FILE) not found" | ||
diff --git a/recipes-core/openjdk/patches-openjdk-8/openjdk8-use_builtin_frame_address_0_rather_than_returning_address_of_local_variable.patch b/recipes-core/openjdk/patches-openjdk-8/openjdk8-use_builtin_frame_address_0_rather_than_returning_address_of_local_variable.patch new file mode 100644 index 0000000..f3dc864 --- /dev/null +++ b/recipes-core/openjdk/patches-openjdk-8/openjdk8-use_builtin_frame_address_0_rather_than_returning_address_of_local_variable.patch | |||
@@ -0,0 +1,23 @@ | |||
1 | # HG changeset patch | ||
2 | # User sgehwolf | ||
3 | # Date 1434121785 -3600 | ||
4 | # Node ID 6217fd2c767b467641bf7b41a9c37273e8fa0cbd | ||
5 | # Parent ff0929a59ced0e144201aa05819ae2e47d6f2c61 | ||
6 | 8087120: [GCC5] java.lang.StackOverflowError on Zero JVM initialization on non x86 platforms. | ||
7 | Summary: Use __builtin_frame_address(0) rather than returning address of local variable. | ||
8 | Reviewed-by: dholmes | ||
9 | |||
10 | diff -r ff0929a59ced -r 6217fd2c767b src/os_cpu/linux_zero/vm/os_linux_zero.cpp | ||
11 | --- hotspot/src/os_cpu/linux_zero/vm/os_linux_zero.cpp.orig Thu Jun 11 20:19:26 2015 -0700 | ||
12 | +++ hotspot/src/os_cpu/linux_zero/vm/os_linux_zero.cpp Fri Jun 12 16:09:45 2015 +0100 | ||
13 | @@ -59,8 +59,8 @@ | ||
14 | extern sigjmp_buf* get_jmp_buf_for_continuation(); | ||
15 | |||
16 | address os::current_stack_pointer() { | ||
17 | - address dummy = (address) &dummy; | ||
18 | - return dummy; | ||
19 | + // return the address of the current function | ||
20 | + return (address)__builtin_frame_address(0); | ||
21 | } | ||
22 | |||
23 | frame os::get_sender_for_C_frame(frame* fr) { | ||
diff --git a/recipes-core/openjdk/patches-openjdk-8/remove-shell-variables-from-autoheader.patch b/recipes-core/openjdk/patches-openjdk-8/remove-shell-variables-from-autoheader.patch new file mode 100644 index 0000000..92a9831 --- /dev/null +++ b/recipes-core/openjdk/patches-openjdk-8/remove-shell-variables-from-autoheader.patch | |||
@@ -0,0 +1,31 @@ | |||
1 | --- common/autoconf/basics.m4.orig 2015-08-17 18:02:01.642657746 +0200 | ||
2 | +++ common/autoconf/basics.m4 2015-08-17 18:14:44.046660616 +0200 | ||
3 | @@ -466,21 +466,21 @@ | ||
4 | AC_SUBST(OUTPUT_ROOT, $OUTPUT_ROOT) | ||
5 | |||
6 | # Most of the probed defines are put into config.h | ||
7 | - AC_CONFIG_HEADERS([$OUTPUT_ROOT/config.h:$AUTOCONF_DIR/config.h.in]) | ||
8 | + AC_CONFIG_HEADERS([config.h:config.h.in]) | ||
9 | # The spec.gmk file contains all variables for the make system. | ||
10 | - AC_CONFIG_FILES([$OUTPUT_ROOT/spec.gmk:$AUTOCONF_DIR/spec.gmk.in]) | ||
11 | + AC_CONFIG_FILES([spec.gmk:spec.gmk.in]) | ||
12 | # The hotspot-spec.gmk file contains legacy variables for the hotspot make system. | ||
13 | - AC_CONFIG_FILES([$OUTPUT_ROOT/hotspot-spec.gmk:$AUTOCONF_DIR/hotspot-spec.gmk.in]) | ||
14 | + AC_CONFIG_FILES([hotspot-spec.gmk:hotspot-spec.gmk.in]) | ||
15 | # The bootcycle-spec.gmk file contains support for boot cycle builds. | ||
16 | - AC_CONFIG_FILES([$OUTPUT_ROOT/bootcycle-spec.gmk:$AUTOCONF_DIR/bootcycle-spec.gmk.in]) | ||
17 | + AC_CONFIG_FILES([bootcycle-spec.gmk:bootcycle-spec.gmk.in]) | ||
18 | # The compare.sh is used to compare the build output to other builds. | ||
19 | - AC_CONFIG_FILES([$OUTPUT_ROOT/compare.sh:$AUTOCONF_DIR/compare.sh.in]) | ||
20 | + AC_CONFIG_FILES([compare.sh:compare.sh.in]) | ||
21 | # Spec.sh is currently used by compare-objects.sh | ||
22 | - AC_CONFIG_FILES([$OUTPUT_ROOT/spec.sh:$AUTOCONF_DIR/spec.sh.in]) | ||
23 | + AC_CONFIG_FILES([spec.sh:spec.sh.in]) | ||
24 | # The generated Makefile knows where the spec.gmk is and where the source is. | ||
25 | # You can run make from the OUTPUT_ROOT, or from the top-level Makefile | ||
26 | # which will look for generated configurations | ||
27 | - AC_CONFIG_FILES([$OUTPUT_ROOT/Makefile:$AUTOCONF_DIR/Makefile.in]) | ||
28 | + AC_CONFIG_FILES([Makefile:Makefile.in]) | ||
29 | |||
30 | # Save the arguments given to us | ||
31 | echo "$CONFIGURE_COMMAND_LINE" > $OUTPUT_ROOT/configure-arguments | ||