1 #
2 # Copyright (c) 2011, 2017, Oracle and/or its affiliates. All rights reserved.
3 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 #
5 # This code is free software; you can redistribute it and/or modify it
6 # under the terms of the GNU General Public License version 2 only, as
7 # published by the Free Software Foundation. Oracle designates this
8 # particular file as subject to the "Classpath" exception as provided
9 # by Oracle in the LICENSE file that accompanied this code.
10 #
11 # This code is distributed in the hope that it will be useful, but WITHOUT
12 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 # version 2 for more details (a copy is included in the LICENSE file that
15 # accompanied this code).
16 #
17 # You should have received a copy of the GNU General Public License version
18 # 2 along with this work; if not, write to the Free Software Foundation,
19 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 #
21 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 # or visit www.oracle.com if you need additional information or have any
23 # questions.
24 #
25
26 ########################################################################
27 # This file handles detection of the Boot JDK. The Boot JDK detection
28 # process has been developed as a response to solve a complex real-world
29 # problem. Initially, it was simple, but it has grown as platform after
30 # platform, idiosyncracy after idiosyncracy has been supported.
31 #
32 # The basic idea is this:
33 # 1) You need an acceptable *) JDK to use as a Boot JDK
34 # 2) There are several ways to locate a JDK, that are mostly platform
35 # dependent **)
36 # 3) You can have multiple JDKs installed
37 # 4) If possible, configure should try to dig out an acceptable JDK
38 # automatically, without having to resort to command-line options
39 #
40 # *) acceptable means e.g. JDK7 for building JDK8, a complete JDK (with
41 # javac) and not a JRE, etc.
42 #
43 # **) On Windows we typically use a well-known path.
44 # On MacOSX we typically use the tool java_home.
45 # On Linux we typically find javac in the $PATH, and then follow a
46 # chain of symlinks that often ends up in a real JDK.
47 #
48 # This leads to the code where we check in different ways to locate a
49 # JDK, and if one is found, check if it is acceptable. If not, we print
50 # our reasons for rejecting it (useful when debugging non-working
51 # configure situations) and continue checking the next one.
52 ########################################################################
53
54 # Execute the check given as argument, and verify the result
55 # If the Boot JDK was previously found, do nothing
56 # $1 A command line (typically autoconf macro) to execute
57 AC_DEFUN([BOOTJDK_DO_CHECK],
58 [
59 if test "x$BOOT_JDK_FOUND" = xno; then
60 # Now execute the test
61 $1
62
63 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
64 if test "x$BOOT_JDK_FOUND" = xmaybe; then
65 # Do we have a bin/java?
66 if test ! -x "$BOOT_JDK/bin/java"; then
67 AC_MSG_NOTICE([Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring])
68 BOOT_JDK_FOUND=no
69 else
70 # Do we have a bin/javac?
71 if test ! -x "$BOOT_JDK/bin/javac"; then
72 AC_MSG_NOTICE([Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring])
73 AC_MSG_NOTICE([(This might be an JRE instead of an JDK)])
74 BOOT_JDK_FOUND=no
75 else
76 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
77 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
78
79 # Extra M4 quote needed to protect [] in grep expression.
80 [FOUND_CORRECT_VERSION=`$ECHO $BOOT_JDK_VERSION | $EGREP '\"10([\.+-].*)?\"|\"9([\.+-].*)?\"'`]
81 if test "x$FOUND_CORRECT_VERSION" = x; then
82 AC_MSG_NOTICE([Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring])
83 AC_MSG_NOTICE([(Your Boot JDK must be version 9 or 10)])
84 BOOT_JDK_FOUND=no
85 else
86 # We're done! :-)
87 BOOT_JDK_FOUND=yes
88 BASIC_FIXUP_PATH(BOOT_JDK)
89 AC_MSG_CHECKING([for Boot JDK])
90 AC_MSG_RESULT([$BOOT_JDK])
91 AC_MSG_CHECKING([Boot JDK version])
92 BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
93 AC_MSG_RESULT([$BOOT_JDK_VERSION])
94 fi # end check jdk version
95 fi # end check javac
96 fi # end check java
97 fi # end check boot jdk found
98 fi
99 ])
100
101 # Test: Is bootjdk explicitly set by command line arguments?
102 AC_DEFUN([BOOTJDK_CHECK_ARGUMENTS],
103 [
104 if test "x$with_boot_jdk" != x; then
105 BOOT_JDK=$with_boot_jdk
106 BOOT_JDK_FOUND=maybe
107 AC_MSG_NOTICE([Found potential Boot JDK using configure arguments])
108 fi
109 ])
110
111 # Test: Is $JAVA_HOME set?
112 AC_DEFUN([BOOTJDK_CHECK_JAVA_HOME],
113 [
114 if test "x$JAVA_HOME" != x; then
115 JAVA_HOME_PROCESSED="$JAVA_HOME"
116 BASIC_FIXUP_PATH(JAVA_HOME_PROCESSED)
117 if test ! -d "$JAVA_HOME_PROCESSED"; then
118 AC_MSG_NOTICE([Your JAVA_HOME points to a non-existing directory!])
119 else
120 # Aha, the user has set a JAVA_HOME
121 # let us use that as the Boot JDK.
122 BOOT_JDK="$JAVA_HOME_PROCESSED"
123 BOOT_JDK_FOUND=maybe
124 AC_MSG_NOTICE([Found potential Boot JDK using JAVA_HOME])
125 fi
126 fi
127 ])
128
129 # Test: Is there a java or javac in the PATH, which is a symlink to the JDK?
130 AC_DEFUN([BOOTJDK_CHECK_JAVA_IN_PATH_IS_SYMLINK],
131 [
132 AC_PATH_PROG(JAVAC_CHECK, javac)
133 AC_PATH_PROG(JAVA_CHECK, java)
134 BINARY="$JAVAC_CHECK"
135 if test "x$JAVAC_CHECK" = x; then
136 BINARY="$JAVA_CHECK"
137 fi
138 if test "x$BINARY" != x; then
139 # So there is a java(c) binary, it might be part of a JDK.
140 # Lets find the JDK/JRE directory by following symbolic links.
141 # Linux/GNU systems often have links from /usr/bin/java to
142 # /etc/alternatives/java to the real JDK binary.
143 BASIC_REMOVE_SYMBOLIC_LINKS(BINARY)
144 BOOT_JDK=`dirname "$BINARY"`
145 BOOT_JDK=`cd "$BOOT_JDK/.."; pwd`
146 if test -x "$BOOT_JDK/bin/javac" && test -x "$BOOT_JDK/bin/java"; then
147 # Looks like we found ourselves an JDK
148 BOOT_JDK_FOUND=maybe
149 AC_MSG_NOTICE([Found potential Boot JDK using java(c) in PATH])
150 fi
151 fi
152 ])
153
154 # Test: Is there a /usr/libexec/java_home? (Typically on MacOSX)
155 # $1: Argument to the java_home binary (optional)
156 AC_DEFUN([BOOTJDK_CHECK_LIBEXEC_JAVA_HOME],
157 [
158 if test -x /usr/libexec/java_home; then
159 BOOT_JDK=`/usr/libexec/java_home $1`
160 BOOT_JDK_FOUND=maybe
161 AC_MSG_NOTICE([Found potential Boot JDK using /usr/libexec/java_home $1])
162 fi
163 ])
164
165 # Test: On MacOS X, can we find a boot jdk using /usr/libexec/java_home?
166 AC_DEFUN([BOOTJDK_CHECK_MACOSX_JAVA_LOCATOR],
167 [
168 if test "x$OPENJDK_TARGET_OS" = xmacosx; then
169 # First check at user selected default
170 BOOTJDK_DO_CHECK([BOOTJDK_CHECK_LIBEXEC_JAVA_HOME()])
171 # If that did not work out (e.g. too old), try explicit versions instead
172 BOOTJDK_DO_CHECK([BOOTJDK_CHECK_LIBEXEC_JAVA_HOME([-v 1.9])])
173 BOOTJDK_DO_CHECK([BOOTJDK_CHECK_LIBEXEC_JAVA_HOME([-v 1.8])])
174 BOOTJDK_DO_CHECK([BOOTJDK_CHECK_LIBEXEC_JAVA_HOME([-v 1.7])])
175 fi
176 ])
177
178 # Look for a jdk in the given path. If there are multiple, try to select the newest.
179 # If found, set BOOT_JDK and BOOT_JDK_FOUND.
180 # $1 = Path to directory containing jdk installations.
181 # $2 = String to append to the found JDK directory to get the proper JDK home
182 AC_DEFUN([BOOTJDK_FIND_BEST_JDK_IN_DIRECTORY],
183 [
184 BOOT_JDK_PREFIX="$1"
185 BOOT_JDK_SUFFIX="$2"
186 ALL_JDKS_FOUND=`$LS "$BOOT_JDK_PREFIX" 2> /dev/null | $SORT -r`
187 if test "x$ALL_JDKS_FOUND" != x; then
188 for JDK_TO_TRY in $ALL_JDKS_FOUND ; do
189 BOOTJDK_DO_CHECK([
190 BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
191 if test -d "$BOOT_JDK"; then
192 BOOT_JDK_FOUND=maybe
193 AC_MSG_NOTICE([Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)])
194 fi
195 ])
196 done
197 fi
198 ])
199
200 # Call BOOTJDK_FIND_BEST_JDK_IN_DIRECTORY, but use the given
201 # environmental variable as base for where to look.
202 # $1 Name of an environmal variable, assumed to point to the Program Files directory.
203 AC_DEFUN([BOOTJDK_FIND_BEST_JDK_IN_WINDOWS_VIRTUAL_DIRECTORY],
204 [
205 if test "x[$]$1" != x; then
206 VIRTUAL_DIR="[$]$1/Java"
207 BASIC_WINDOWS_REWRITE_AS_UNIX_PATH(VIRTUAL_DIR)
208 BOOTJDK_FIND_BEST_JDK_IN_DIRECTORY($VIRTUAL_DIR)
209 fi
210 ])
211
212 # Test: Is there a JDK installed in default, well-known locations?
213 AC_DEFUN([BOOTJDK_CHECK_WELL_KNOWN_LOCATIONS],
214 [
215 if test "x$OPENJDK_TARGET_OS" = xwindows; then
216 BOOTJDK_DO_CHECK([BOOTJDK_FIND_BEST_JDK_IN_WINDOWS_VIRTUAL_DIRECTORY([ProgramW6432])])
217 BOOTJDK_DO_CHECK([BOOTJDK_FIND_BEST_JDK_IN_WINDOWS_VIRTUAL_DIRECTORY([PROGRAMW6432])])
218 BOOTJDK_DO_CHECK([BOOTJDK_FIND_BEST_JDK_IN_WINDOWS_VIRTUAL_DIRECTORY([PROGRAMFILES])])
219 BOOTJDK_DO_CHECK([BOOTJDK_FIND_BEST_JDK_IN_WINDOWS_VIRTUAL_DIRECTORY([ProgramFiles])])
220 BOOTJDK_DO_CHECK([BOOTJDK_FIND_BEST_JDK_IN_DIRECTORY([/cygdrive/c/Program Files/Java])])
221 elif test "x$OPENJDK_TARGET_OS" = xmacosx; then
222 BOOTJDK_DO_CHECK([BOOTJDK_FIND_BEST_JDK_IN_DIRECTORY([/Library/Java/JavaVirtualMachines],[/Contents/Home])])
223 BOOTJDK_DO_CHECK([BOOTJDK_FIND_BEST_JDK_IN_DIRECTORY([/System/Library/Java/JavaVirtualMachines],[/Contents/Home])])
224 elif test "x$OPENJDK_TARGET_OS" = xlinux; then
225 BOOTJDK_DO_CHECK([BOOTJDK_FIND_BEST_JDK_IN_DIRECTORY([/usr/lib/jvm])])
226 fi
227 ])
228
229 # Check that a command-line tool in the Boot JDK is correct
230 # $1 = name of variable to assign
231 # $2 = name of binary
232 AC_DEFUN([BOOTJDK_CHECK_TOOL_IN_BOOTJDK],
233 [
234 # Use user overridden value if available, otherwise locate tool in the Boot JDK.
235 BASIC_SETUP_TOOL($1,
236 [
237 AC_MSG_CHECKING([for $2 in Boot JDK])
238 $1=$BOOT_JDK/bin/$2
239 if test ! -x [$]$1; then
240 AC_MSG_RESULT(not found)
241 AC_MSG_NOTICE([Your Boot JDK seems broken. This might be fixed by explicitly setting --with-boot-jdk])
242 AC_MSG_ERROR([Could not find $2 in the Boot JDK])
243 fi
244 AC_MSG_RESULT(ok)
245 AC_SUBST($1)
246 ])
247 ])
248
249 ###############################################################################
250 #
251 # We need a Boot JDK to bootstrap the build.
252 #
253
254 AC_DEFUN_ONCE([BOOTJDK_SETUP_BOOT_JDK],
255 [
256 BOOT_JDK_FOUND=no
257 AC_ARG_WITH(boot-jdk, [AS_HELP_STRING([--with-boot-jdk],
258 [path to Boot JDK (used to bootstrap build) @<:@probed@:>@])])
259
260 # We look for the Boot JDK through various means, going from more certain to
261 # more of a guess-work. After each test, BOOT_JDK_FOUND is set to "yes" if
262 # we detected something (if so, the path to the jdk is in BOOT_JDK). But we
263 # must check if this is indeed valid; otherwise we'll continue looking.
264
265 # Test: Is bootjdk explicitly set by command line arguments?
266 BOOTJDK_DO_CHECK([BOOTJDK_CHECK_ARGUMENTS])
267 if test "x$with_boot_jdk" != x && test "x$BOOT_JDK_FOUND" = xno; then
268 # Having specified an argument which is incorrect will produce an instant failure;
269 # we should not go on looking
270 AC_MSG_ERROR([The path given by --with-boot-jdk does not contain a valid Boot JDK])
271 fi
272
273 # Test: On MacOS X, can we find a boot jdk using /usr/libexec/java_home?
274 BOOTJDK_DO_CHECK([BOOTJDK_CHECK_MACOSX_JAVA_LOCATOR])
275
276 # Test: Is $JAVA_HOME set?
277 BOOTJDK_DO_CHECK([BOOTJDK_CHECK_JAVA_HOME])
278
279 # Test: Is there a java or javac in the PATH, which is a symlink to the JDK?
280 BOOTJDK_DO_CHECK([BOOTJDK_CHECK_JAVA_IN_PATH_IS_SYMLINK])
281
282 # Test: Is there a JDK installed in default, well-known locations?
283 BOOTJDK_DO_CHECK([BOOTJDK_CHECK_WELL_KNOWN_LOCATIONS])
284
285 # If we haven't found anything yet, we've truly lost. Give up.
286 if test "x$BOOT_JDK_FOUND" = xno; then
287 HELP_MSG_MISSING_DEPENDENCY([openjdk])
288 AC_MSG_NOTICE([Could not find a valid Boot JDK. $HELP_MSG])
289 AC_MSG_NOTICE([This might be fixed by explicitly setting --with-boot-jdk])
290 AC_MSG_ERROR([Cannot continue])
291 fi
292
293 AC_SUBST(BOOT_JDK)
294
295 # Setup tools from the Boot JDK.
296 BOOTJDK_CHECK_TOOL_IN_BOOTJDK(JAVA, java)
297 BOOTJDK_CHECK_TOOL_IN_BOOTJDK(JAVAC, javac)
298 BOOTJDK_CHECK_TOOL_IN_BOOTJDK(JAVADOC, javadoc)
299 BOOTJDK_CHECK_TOOL_IN_BOOTJDK(JAR, jar)
300 BOOTJDK_CHECK_TOOL_IN_BOOTJDK(JARSIGNER, jarsigner)
301
302 # Finally, set some other options...
303
304 # When compiling code to be executed by the Boot JDK, force compatibility with the
305 # oldest supported bootjdk.
306 BOOT_JDK_SOURCETARGET="-source 9 -target 9"
307 AC_SUBST(BOOT_JDK_SOURCETARGET)
308
309 AC_SUBST(JAVAC_FLAGS)
310
311 # Check if the boot jdk is 32 or 64 bit
312 if "$JAVA" -version 2>&1 | $GREP -q "64-Bit"; then
313 BOOT_JDK_BITS="64"
314 else
315 BOOT_JDK_BITS="32"
316 fi
317 AC_MSG_CHECKING([if Boot JDK is 32 or 64 bits])
318 AC_MSG_RESULT([$BOOT_JDK_BITS])
319
320 # Try to enable CDS
321 AC_MSG_CHECKING([for local Boot JDK Class Data Sharing (CDS)])
322 BOOT_JDK_CDS_ARCHIVE=$CONFIGURESUPPORT_OUTPUTDIR/classes.jsa
323 ADD_JVM_ARG_IF_OK([-XX:+UnlockDiagnosticVMOptions -XX:-VerifySharedSpaces -XX:SharedArchiveFile=$BOOT_JDK_CDS_ARCHIVE],boot_jdk_cds_args,[$JAVA])
324
325 if test "x$boot_jdk_cds_args" != x; then
326 # Try creating a CDS archive
327 "$JAVA" $boot_jdk_cds_args -Xshare:dump > /dev/null 2>&1
328 if test $? -eq 0; then
329 BOOTJDK_USE_LOCAL_CDS=true
330 AC_MSG_RESULT([yes, created])
331 else
332 # Generation failed, don't use CDS.
333 BOOTJDK_USE_LOCAL_CDS=false
334 AC_MSG_RESULT([no, creation failed])
335 fi
336 else
337 BOOTJDK_USE_LOCAL_CDS=false
338 AC_MSG_RESULT([no, -XX:SharedArchiveFile not supported])
339 fi
340 ])
341
342 AC_DEFUN_ONCE([BOOTJDK_SETUP_BOOT_JDK_ARGUMENTS],
343 [
344 ##############################################################################
345 #
346 # Specify jvm options for anything that is run with the Boot JDK.
347 # Not all JVM:s accept the same arguments on the command line.
348 #
349 AC_ARG_WITH(boot-jdk-jvmargs, [AS_HELP_STRING([--with-boot-jdk-jvmargs],
350 [specify JVM arguments to be passed to all java invocations of boot JDK, overriding the default values,
351 e.g --with-boot-jdk-jvmargs="-Xmx8G -enableassertions"])])
352
353 AC_MSG_CHECKING([flags for boot jdk java command] )
354
355 # Force en-US environment
356 ADD_JVM_ARG_IF_OK([-Duser.language=en -Duser.country=US],boot_jdk_jvmargs,[$JAVA])
357
358 if test "x$BOOTJDK_USE_LOCAL_CDS" = xtrue; then
359 # Use our own CDS archive
360 ADD_JVM_ARG_IF_OK([$boot_jdk_cds_args -Xshare:auto],boot_jdk_jvmargs,[$JAVA])
361 else
362 # Otherwise optimistically use the system-wide one, if one is present
363 ADD_JVM_ARG_IF_OK([-Xshare:auto],boot_jdk_jvmargs,[$JAVA])
364 fi
365
366 # Apply user provided options.
367 ADD_JVM_ARG_IF_OK([$with_boot_jdk_jvmargs],boot_jdk_jvmargs,[$JAVA])
368
369 AC_MSG_RESULT([$boot_jdk_jvmargs])
370
371 # For now, general JAVA_FLAGS are the same as the boot jdk jvmargs
372 JAVA_FLAGS=$boot_jdk_jvmargs
373 AC_SUBST(JAVA_FLAGS)
374
375 AC_MSG_CHECKING([flags for boot jdk java command for big workloads])
376
377 # Starting amount of heap memory.
378 ADD_JVM_ARG_IF_OK([-Xms64M],boot_jdk_jvmargs_big,[$JAVA])
379 BOOTCYCLE_JVM_ARGS_BIG=-Xms64M
380
381 # Maximum amount of heap memory and stack size.
382 JVM_HEAP_LIMIT_32="1024"
383 # Running a 64 bit JVM allows for and requires a bigger heap
384 JVM_HEAP_LIMIT_64="1600"
385 STACK_SIZE_32=768
386 STACK_SIZE_64=1536
387 JVM_HEAP_LIMIT_GLOBAL=`expr $MEMORY_SIZE / 2`
388 if test "$JVM_HEAP_LIMIT_GLOBAL" -lt "$JVM_HEAP_LIMIT_32"; then
389 JVM_HEAP_LIMIT_32=$JVM_HEAP_LIMIT_GLOBAL
390 fi
391 if test "$JVM_HEAP_LIMIT_GLOBAL" -lt "$JVM_HEAP_LIMIT_64"; then
392 JVM_HEAP_LIMIT_64=$JVM_HEAP_LIMIT_GLOBAL
393 fi
394 if test "$JVM_HEAP_LIMIT_GLOBAL" -lt "512"; then
395 JVM_HEAP_LIMIT_32=512
396 JVM_HEAP_LIMIT_64=512
397 fi
398
399 if test "x$BOOT_JDK_BITS" = "x32"; then
400 STACK_SIZE=$STACK_SIZE_32
401 JVM_MAX_HEAP=$JVM_HEAP_LIMIT_32
402 else
403 STACK_SIZE=$STACK_SIZE_64
404 JVM_MAX_HEAP=$JVM_HEAP_LIMIT_64
405 fi
406 ADD_JVM_ARG_IF_OK([-Xmx${JVM_MAX_HEAP}M],boot_jdk_jvmargs_big,[$JAVA])
407 ADD_JVM_ARG_IF_OK([-XX:ThreadStackSize=$STACK_SIZE],boot_jdk_jvmargs_big,[$JAVA])
408
409 AC_MSG_RESULT([$boot_jdk_jvmargs_big])
410
411 JAVA_FLAGS_BIG=$boot_jdk_jvmargs_big
412 AC_SUBST(JAVA_FLAGS_BIG)
413
414 if test "x$OPENJDK_TARGET_CPU_BITS" = "x32"; then
415 BOOTCYCLE_MAX_HEAP=$JVM_HEAP_LIMIT_32
416 BOOTCYCLE_STACK_SIZE=$STACK_SIZE_32
417 else
418 BOOTCYCLE_MAX_HEAP=$JVM_HEAP_LIMIT_64
419 BOOTCYCLE_STACK_SIZE=$STACK_SIZE_64
420 fi
421 BOOTCYCLE_JVM_ARGS_BIG="$BOOTCYCLE_JVM_ARGS_BIG -Xmx${BOOTCYCLE_MAX_HEAP}M"
422 BOOTCYCLE_JVM_ARGS_BIG="$BOOTCYCLE_JVM_ARGS_BIG -XX:ThreadStackSize=$BOOTCYCLE_STACK_SIZE"
423 AC_MSG_CHECKING([flags for bootcycle boot jdk java command for big workloads])
424 AC_MSG_RESULT([$BOOTCYCLE_JVM_ARGS_BIG])
425 AC_SUBST(BOOTCYCLE_JVM_ARGS_BIG)
426
427 # By default, the main javac compilations use big
428 JAVA_FLAGS_JAVAC="$JAVA_FLAGS_BIG"
429 AC_SUBST(JAVA_FLAGS_JAVAC)
430
431 AC_MSG_CHECKING([flags for boot jdk java command for small workloads])
432
433 # Use serial gc for small short lived tools if possible
434 ADD_JVM_ARG_IF_OK([-XX:+UseSerialGC],boot_jdk_jvmargs_small,[$JAVA])
435 ADD_JVM_ARG_IF_OK([-Xms32M],boot_jdk_jvmargs_small,[$JAVA])
436 ADD_JVM_ARG_IF_OK([-Xmx512M],boot_jdk_jvmargs_small,[$JAVA])
437 ADD_JVM_ARG_IF_OK([-XX:TieredStopAtLevel=1],boot_jdk_jvmargs_small,[$JAVA])
438
439 AC_MSG_RESULT([$boot_jdk_jvmargs_small])
440
441 JAVA_FLAGS_SMALL=$boot_jdk_jvmargs_small
442 AC_SUBST(JAVA_FLAGS_SMALL)
443
444 JAVA_TOOL_FLAGS_SMALL=""
445 for f in $JAVA_FLAGS_SMALL; do
446 JAVA_TOOL_FLAGS_SMALL="$JAVA_TOOL_FLAGS_SMALL -J$f"
447 done
448 AC_SUBST(JAVA_TOOL_FLAGS_SMALL)
449 ])
450
451 # BUILD_JDK: the location of the latest JDK that can run
452 # on the host system and supports the target class file version
453 # generated in this JDK build. This variable should only be
454 # used after the launchers are built.
455 #
456
457 # Execute the check given as argument, and verify the result.
458 # If the JDK was previously found, do nothing.
459 # $1 A command line (typically autoconf macro) to execute
460 AC_DEFUN([BOOTJDK_CHECK_BUILD_JDK],
461 [
462 if test "x$BUILD_JDK_FOUND" = xno; then
463 # Execute the test
464 $1
465
466 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
467 if test "x$BUILD_JDK_FOUND" = xmaybe; then
468 # Do we have a bin/java?
469 if test ! -x "$BUILD_JDK/bin/java"; then
470 AC_MSG_NOTICE([Potential Build JDK found at $BUILD_JDK did not contain bin/java; ignoring])
471 BUILD_JDK_FOUND=no
472 elif test ! -x "$BUILD_JDK/bin/jlink"; then
473 AC_MSG_NOTICE([Potential Build JDK found at $BUILD_JDK did not contain bin/jlink; ignoring])
474 BUILD_JDK_FOUND=no
475 elif test ! -x "$BUILD_JDK/bin/jmod"; then
476 AC_MSG_NOTICE([Potential Build JDK found at $BUILD_JDK did not contain bin/jmod; ignoring])
477 BUILD_JDK_FOUND=no
478 elif test ! -x "$BUILD_JDK/bin/javac"; then
479 # Do we have a bin/javac?
480 AC_MSG_NOTICE([Potential Build JDK found at $BUILD_JDK did not contain bin/javac; ignoring])
481 AC_MSG_NOTICE([(This might be a JRE instead of an JDK)])
482 BUILD_JDK_FOUND=no
483 else
484 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
485 BUILD_JDK_VERSION=`"$BUILD_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
486
487 # Extra M4 quote needed to protect [] in grep expression.
488 [FOUND_CORRECT_VERSION=`echo $BUILD_JDK_VERSION | $EGREP '\"10([\.+-].*)?\"'`]
489 if test "x$FOUND_CORRECT_VERSION" = x; then
490 AC_MSG_NOTICE([Potential Build JDK found at $BUILD_JDK is incorrect JDK version ($BUILD_JDK_VERSION); ignoring])
491 AC_MSG_NOTICE([(Your Build JDK must be version 10)])
492 BUILD_JDK_FOUND=no
493 else
494 # We're done!
495 BUILD_JDK_FOUND=yes
496 BASIC_FIXUP_PATH(BUILD_JDK)
497 AC_MSG_CHECKING([for Build JDK])
498 AC_MSG_RESULT([$BUILD_JDK])
499 AC_MSG_CHECKING([Build JDK version])
500 BUILD_JDK_VERSION=`"$BUILD_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
501 AC_MSG_RESULT([$BUILD_JDK_VERSION])
502 fi # end check jdk version
503 fi # end check java
504 fi # end check build jdk found
505 fi
506 ])
507
508 # By default the BUILD_JDK is the JDK_OUTPUTDIR. If the target architecture
509 # is different than the host system doing the build (e.g. cross-compilation),
510 # a special BUILD_JDK is built as part of the build process. An external
511 # prebuilt BUILD_JDK can also be supplied.
512 AC_DEFUN([BOOTJDK_SETUP_BUILD_JDK],
513 [
514 AC_ARG_WITH(build-jdk, [AS_HELP_STRING([--with-build-jdk],
515 [path to JDK of same version as is being built@<:@the newly built JDK@:>@])])
516
517 CREATE_BUILDJDK=false
518 EXTERNAL_BUILDJDK=false
519 BUILD_JDK_FOUND="no"
520 if test "x$with_build_jdk" != "x"; then
521 BOOTJDK_CHECK_BUILD_JDK([
522 if test "x$with_build_jdk" != x; then
523 BUILD_JDK=$with_build_jdk
524 BUILD_JDK_FOUND=maybe
525 AC_MSG_NOTICE([Found potential Build JDK using configure arguments])
526 fi])
527 EXTERNAL_BUILDJDK=true
528 else
529 if test "x$COMPILE_TYPE" = "xcross"; then
530 BUILD_JDK="\$(BUILDJDK_OUTPUTDIR)/jdk"
531 BUILD_JDK_FOUND=yes
532 CREATE_BUILDJDK=true
533 AC_MSG_CHECKING([for Build JDK])
534 AC_MSG_RESULT([yes, will build it for the host platform])
535 else
536 BUILD_JDK="\$(JDK_OUTPUTDIR)"
537 BUILD_JDK_FOUND=yes
538 AC_MSG_CHECKING([for Build JDK])
539 AC_MSG_RESULT([yes, will use output dir])
540 fi
541 fi
542
543 JMOD="$BUILD_JDK/bin/jmod"
544 JLINK="$BUILD_JDK/bin/jlink"
545 AC_SUBST(JMOD)
546 AC_SUBST(JLINK)
547
548 if test "x$BUILD_JDK_FOUND" != "xyes"; then
549 AC_MSG_CHECKING([for Build JDK])
550 AC_MSG_RESULT([no])
551 AC_MSG_ERROR([Could not find a suitable Build JDK])
552 fi
553
554 AC_SUBST(CREATE_BUILDJDK)
555 AC_SUBST(BUILD_JDK)
556 AC_SUBST(EXTERNAL_BUILDJDK)
557 ])