1 #
2 # Copyright (c) 2011, 2015, 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 '\"9([\.+-].*)?\"|(1\.[89]\.)'`]
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 8 or 9)])
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 explicitely 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 explicitely 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 explicitely 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 explicitely 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(JAVAH, javah)
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 jdk8 compatibility.
305 BOOT_JDK_SOURCETARGET="-source 8 -target 8"
306 AC_SUBST(BOOT_JDK_SOURCETARGET)
307
308 ADD_JVM_ARG_IF_OK([-Xpatch:foo=bar], dummy, [$JAVA])
309 AC_MSG_CHECKING([if Boot JDK supports modules])
310 if test "x$JVM_ARG_OK" = "xtrue"; then
311 AC_MSG_RESULT([yes])
312 BOOT_JDK_MODULAR="true"
313 else
314 AC_MSG_RESULT([no])
315 BOOT_JDK_MODULAR="false"
316 fi
317 AC_SUBST(BOOT_JDK_MODULAR)
318
319 AC_SUBST(JAVAC_FLAGS)
320
321 # Check if the boot jdk is 32 or 64 bit
322 if "$JAVA" -d64 -version > /dev/null 2>&1; then
323 BOOT_JDK_BITS="64"
324 else
325 BOOT_JDK_BITS="32"
326 fi
327 AC_MSG_CHECKING([if Boot JDK is 32 or 64 bits])
328 AC_MSG_RESULT([$BOOT_JDK_BITS])
329 AC_SUBST(BOOT_JDK_BITS)
330 ])
331
332 AC_DEFUN_ONCE([BOOTJDK_SETUP_BOOT_JDK_ARGUMENTS],
333 [
334 ##############################################################################
335 #
336 # Specify jvm options for anything that is run with the Boot JDK.
337 # Not all JVM:s accept the same arguments on the command line.
338 #
339 AC_ARG_WITH(boot-jdk-jvmargs, [AS_HELP_STRING([--with-boot-jdk-jvmargs],
340 [specify JVM arguments to be passed to all java invocations of boot JDK, overriding the default values,
341 e.g --with-boot-jdk-jvmargs="-Xmx8G -enableassertions"])])
342
343 AC_MSG_CHECKING([flags for boot jdk java command] )
344
345 # Disable special log output when a debug build is used as Boot JDK...
346 ADD_JVM_ARG_IF_OK([-XX:-PrintVMOptions -XX:-UnlockDiagnosticVMOptions -XX:-LogVMOutput],boot_jdk_jvmargs,[$JAVA])
347
348 # Force en-US environment
349 ADD_JVM_ARG_IF_OK([-Duser.language=en -Duser.country=US],boot_jdk_jvmargs,[$JAVA])
350
351 # Apply user provided options.
352 ADD_JVM_ARG_IF_OK([$with_boot_jdk_jvmargs],boot_jdk_jvmargs,[$JAVA])
353
354 AC_MSG_RESULT([$boot_jdk_jvmargs])
355
356 # For now, general JAVA_FLAGS are the same as the boot jdk jvmargs
357 JAVA_FLAGS=$boot_jdk_jvmargs
358 AC_SUBST(JAVA_FLAGS)
359
360
361 AC_MSG_CHECKING([flags for boot jdk java command for big workloads])
362
363 # Starting amount of heap memory.
364 ADD_JVM_ARG_IF_OK([-Xms64M],boot_jdk_jvmargs_big,[$JAVA])
365 BOOTCYCLE_JVM_ARGS_BIG=-Xms64M
366
367 # Maximum amount of heap memory and stack size.
368 JVM_HEAP_LIMIT_32="1024"
369 # Running a 64 bit JVM allows for and requires a bigger heap
370 JVM_HEAP_LIMIT_64="1600"
371 STACK_SIZE_32=768
372 STACK_SIZE_64=1536
373 JVM_HEAP_LIMIT_GLOBAL=`expr $MEMORY_SIZE / 2`
374 if test "$JVM_HEAP_LIMIT_GLOBAL" -lt "$JVM_HEAP_LIMIT_32"; then
375 JVM_HEAP_LIMIT_32=$JVM_HEAP_LIMIT_GLOBAL
376 fi
377 if test "$JVM_HEAP_LIMIT_GLOBAL" -lt "$JVM_HEAP_LIMIT_64"; then
378 JVM_HEAP_LIMIT_64=$JVM_HEAP_LIMIT_GLOBAL
379 fi
380 if test "$JVM_HEAP_LIMIT_GLOBAL" -lt "512"; then
381 JVM_HEAP_LIMIT_32=512
382 JVM_HEAP_LIMIT_64=512
383 fi
384
385 if test "x$BOOT_JDK_BITS" = "x32"; then
386 STACK_SIZE=$STACK_SIZE_32
387 JVM_MAX_HEAP=$JVM_HEAP_LIMIT_32
388 else
389 STACK_SIZE=$STACK_SIZE_64
390 JVM_MAX_HEAP=$JVM_HEAP_LIMIT_64
391 fi
392 ADD_JVM_ARG_IF_OK([-Xmx${JVM_MAX_HEAP}M],boot_jdk_jvmargs_big,[$JAVA])
393 ADD_JVM_ARG_IF_OK([-XX:ThreadStackSize=$STACK_SIZE],boot_jdk_jvmargs_big,[$JAVA])
394
395 AC_MSG_RESULT([$boot_jdk_jvmargs_big])
396
397 JAVA_FLAGS_BIG=$boot_jdk_jvmargs_big
398 AC_SUBST(JAVA_FLAGS_BIG)
399
400 if test "x$OPENJDK_TARGET_CPU_BITS" = "x32"; then
401 BOOTCYCLE_MAX_HEAP=$JVM_HEAP_LIMIT_32
402 BOOTCYCLE_STACK_SIZE=$STACK_SIZE_32
403 else
404 BOOTCYCLE_MAX_HEAP=$JVM_HEAP_LIMIT_64
405 BOOTCYCLE_STACK_SIZE=$STACK_SIZE_64
406 fi
407 BOOTCYCLE_JVM_ARGS_BIG="$BOOTCYCLE_JVM_ARGS_BIG -Xmx${BOOTCYCLE_MAX_HEAP}M"
408 BOOTCYCLE_JVM_ARGS_BIG="$BOOTCYCLE_JVM_ARGS_BIG -XX:ThreadStackSize=$BOOTCYCLE_STACK_SIZE"
409 AC_MSG_CHECKING([flags for bootcycle boot jdk java command for big workloads])
410 AC_MSG_RESULT([$BOOTCYCLE_JVM_ARGS_BIG])
411 AC_SUBST(BOOTCYCLE_JVM_ARGS_BIG)
412
413 # By default, the main javac compilations use big
414 JAVA_FLAGS_JAVAC="$JAVA_FLAGS_BIG"
415 AC_SUBST(JAVA_FLAGS_JAVAC)
416
417 AC_MSG_CHECKING([flags for boot jdk java command for small workloads])
418
419 # Use serial gc for small short lived tools if possible
420 ADD_JVM_ARG_IF_OK([-XX:+UseSerialGC],boot_jdk_jvmargs_small,[$JAVA])
421 ADD_JVM_ARG_IF_OK([-Xms32M],boot_jdk_jvmargs_small,[$JAVA])
422 ADD_JVM_ARG_IF_OK([-Xmx512M],boot_jdk_jvmargs_small,[$JAVA])
423 ADD_JVM_ARG_IF_OK([-XX:TieredStopAtLevel=1],boot_jdk_jvmargs_small,[$JAVA])
424
425 AC_MSG_RESULT([$boot_jdk_jvmargs_small])
426
427 JAVA_FLAGS_SMALL=$boot_jdk_jvmargs_small
428 AC_SUBST(JAVA_FLAGS_SMALL)
429
430 JAVA_TOOL_FLAGS_SMALL=""
431 for f in $JAVA_FLAGS_SMALL; do
432 JAVA_TOOL_FLAGS_SMALL="$JAVA_TOOL_FLAGS_SMALL -J$f"
433 done
434 AC_SUBST(JAVA_TOOL_FLAGS_SMALL)
435 ])
436
437 # BUILD_JDK: the location of the latest JDK that can run
438 # on the host system and supports the target class file version
439 # generated in this JDK build. This variable should only be
440 # used after the launchers are built.
441 #
442
443 # Execute the check given as argument, and verify the result.
444 # If the JDK was previously found, do nothing.
445 # $1 A command line (typically autoconf macro) to execute
446 AC_DEFUN([BOOTJDK_CHECK_BUILD_JDK],
447 [
448 if test "x$BUILD_JDK_FOUND" = xno; then
449 # Execute the test
450 $1
451
452 # If previous step claimed to have found a JDK, check it to see if it seems to be valid.
453 if test "x$BUILD_JDK_FOUND" = xmaybe; then
454 # Do we have a bin/java?
455 if test ! -x "$BUILD_JDK/bin/java"; then
456 AC_MSG_NOTICE([Potential Build JDK found at $BUILD_JDK did not contain bin/java; ignoring])
457 BUILD_JDK_FOUND=no
458 elif test ! -x "$BUILD_JDK/bin/jlink"; then
459 AC_MSG_NOTICE([Potential Build JDK found at $BUILD_JDK did not contain bin/jlink; ignoring])
460 BUILD_JDK_FOUND=no
461 elif test ! -x "$BUILD_JDK/bin/jmod"; then
462 AC_MSG_NOTICE([Potential Build JDK found at $BUILD_JDK did not contain bin/jmod; ignoring])
463 BUILD_JDK_FOUND=no
464 elif test ! -x "$BUILD_JDK/bin/javac"; then
465 # Do we have a bin/javac?
466 AC_MSG_NOTICE([Potential Build JDK found at $BUILD_JDK did not contain bin/javac; ignoring])
467 AC_MSG_NOTICE([(This might be a JRE instead of an JDK)])
468 BUILD_JDK_FOUND=no
469 else
470 # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
471 BUILD_JDK_VERSION=`"$BUILD_JDK/bin/java" -version 2>&1 | $HEAD -n 1`
472
473 # Extra M4 quote needed to protect [] in grep expression.
474 [FOUND_CORRECT_VERSION=`echo $BUILD_JDK_VERSION | $EGREP '\"9([\.+-].*)?\"'`]
475 if test "x$FOUND_CORRECT_VERSION" = x; then
476 AC_MSG_NOTICE([Potential Build JDK found at $BUILD_JDK is incorrect JDK version ($BUILD_JDK_VERSION); ignoring])
477 AC_MSG_NOTICE([(Your Build JDK must be version 9)])
478 BUILD_JDK_FOUND=no
479 else
480 # We're done!
481 BUILD_JDK_FOUND=yes
482 BASIC_FIXUP_PATH(BUILD_JDK)
483 AC_MSG_CHECKING([for Build JDK])
484 AC_MSG_RESULT([$BUILD_JDK])
485 AC_MSG_CHECKING([Build JDK version])
486 BUILD_JDK_VERSION=`"$BUILD_JDK/bin/java" -version 2>&1 | $TR '\n\r' ' '`
487 AC_MSG_RESULT([$BUILD_JDK_VERSION])
488 fi # end check jdk version
489 fi # end check java
490 fi # end check build jdk found
491 fi
492 ])
493
494 # By default the BUILD_JDK is the JDK_OUTPUTDIR. If the target architecture
495 # is different than the host system doing the build (e.g. cross-compilation),
496 # a special BUILD_JDK is built as part of the build process. An external
497 # prebuilt BUILD_JDK can also be supplied.
498 AC_DEFUN([BOOTJDK_SETUP_BUILD_JDK],
499 [
500 AC_ARG_WITH(build-jdk, [AS_HELP_STRING([--with-build-jdk],
501 [path to JDK of same version as is being built@<:@the newly built JDK@:>@])])
502
503 CREATE_BUILDJDK=false
504 EXTERNAL_BUILDJDK=false
505 BUILD_JDK_FOUND="no"
506 if test "x$with_build_jdk" != "x"; then
507 BOOTJDK_CHECK_BUILD_JDK([
508 if test "x$with_build_jdk" != x; then
509 BUILD_JDK=$with_build_jdk
510 BUILD_JDK_FOUND=maybe
511 AC_MSG_NOTICE([Found potential Build JDK using configure arguments])
512 fi])
513 EXTERNAL_BUILDJDK=true
514 else
515 if test "x$COMPILE_TYPE" = "xcross"; then
516 BUILD_JDK="\$(BUILDJDK_OUTPUTDIR)/jdk"
517 BUILD_JDK_FOUND=yes
518 CREATE_BUILDJDK=true
519 AC_MSG_CHECKING([for Build JDK])
520 AC_MSG_RESULT([yes, will build it for the host platform])
521 else
522 BUILD_JDK="\$(JDK_OUTPUTDIR)"
523 BUILD_JDK_FOUND=yes
524 AC_MSG_CHECKING([for Build JDK])
525 AC_MSG_RESULT([yes, will use output dir])
526 fi
527 fi
528
529 JMOD="$BUILD_JDK/bin/jmod"
530 JLINK="$BUILD_JDK/bin/jlink"
531 AC_SUBST(JMOD)
532 AC_SUBST(JLINK)
533
534 if test "x$BUILD_JDK_FOUND" != "xyes"; then
535 AC_MSG_CHECKING([for Build JDK])
536 AC_MSG_RESULT([no])
537 AC_MSG_ERROR([Could not find a suitable Build JDK])
538 fi
539
540 AC_SUBST(CREATE_BUILDJDK)
541 AC_SUBST(BUILD_JDK)
542 AC_SUBST(EXTERNAL_BUILDJDK)
543 ])