1 #
   2 # Copyright (c) 2011, 2016, 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   elif test "x$OPENJDK_TARGET_OS" = xbsd; then
 227     BOOTJDK_DO_CHECK([BOOTJDK_FIND_BEST_JDK_IN_DIRECTORY([/usr/pkg/java])])
 228     BOOTJDK_DO_CHECK([BOOTJDK_FIND_BEST_JDK_IN_DIRECTORY([/usr/local])])
 229   fi
 230 ])
 231 
 232 # Check that a command-line tool in the Boot JDK is correct
 233 # $1 = name of variable to assign
 234 # $2 = name of binary
 235 AC_DEFUN([BOOTJDK_CHECK_TOOL_IN_BOOTJDK],
 236 [
 237   # Use user overridden value if available, otherwise locate tool in the Boot JDK.
 238   BASIC_SETUP_TOOL($1,
 239     [
 240       AC_MSG_CHECKING([for $2 in Boot JDK])
 241       $1=$BOOT_JDK/bin/$2
 242       if test ! -x [$]$1; then
 243         AC_MSG_RESULT(not found)
 244         AC_MSG_NOTICE([Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk])
 245         AC_MSG_ERROR([Could not find $2 in the Boot JDK])
 246       fi
 247       AC_MSG_RESULT(ok)
 248       AC_SUBST($1)
 249     ])
 250 ])
 251 
 252 ###############################################################################
 253 #
 254 # We need a Boot JDK to bootstrap the build.
 255 #
 256 
 257 AC_DEFUN_ONCE([BOOTJDK_SETUP_BOOT_JDK],
 258 [
 259   BOOT_JDK_FOUND=no
 260   AC_ARG_WITH(boot-jdk, [AS_HELP_STRING([--with-boot-jdk],
 261       [path to Boot JDK (used to bootstrap build) @<:@probed@:>@])])
 262 
 263   # We look for the Boot JDK through various means, going from more certain to
 264   # more of a guess-work. After each test, BOOT_JDK_FOUND is set to "yes" if
 265   # we detected something (if so, the path to the jdk is in BOOT_JDK). But we
 266   # must check if this is indeed valid; otherwise we'll continue looking.
 267 
 268   # Test: Is bootjdk explicitely set by command line arguments?
 269   BOOTJDK_DO_CHECK([BOOTJDK_CHECK_ARGUMENTS])
 270   if test "x$with_boot_jdk" != x && test "x$BOOT_JDK_FOUND" = xno; then
 271     # Having specified an argument which is incorrect will produce an instant failure;
 272     # we should not go on looking
 273     AC_MSG_ERROR([The path given by --with-boot-jdk does not contain a valid Boot JDK])
 274   fi
 275 
 276   # Test: On MacOS X, can we find a boot jdk using /usr/libexec/java_home?
 277   BOOTJDK_DO_CHECK([BOOTJDK_CHECK_MACOSX_JAVA_LOCATOR])
 278 
 279   # Test: Is $JAVA_HOME set?
 280   BOOTJDK_DO_CHECK([BOOTJDK_CHECK_JAVA_HOME])
 281 
 282   # Test: Is there a java or javac in the PATH, which is a symlink to the JDK?
 283   BOOTJDK_DO_CHECK([BOOTJDK_CHECK_JAVA_IN_PATH_IS_SYMLINK])
 284 
 285   # Test: Is there a JDK installed in default, well-known locations?
 286   BOOTJDK_DO_CHECK([BOOTJDK_CHECK_WELL_KNOWN_LOCATIONS])
 287 
 288   # If we haven't found anything yet, we've truly lost. Give up.
 289   if test "x$BOOT_JDK_FOUND" = xno; then
 290     HELP_MSG_MISSING_DEPENDENCY([openjdk])
 291     AC_MSG_NOTICE([Could not find a valid Boot JDK. $HELP_MSG])
 292     AC_MSG_NOTICE([This might be fixed by explicitely setting --with-boot-jdk])
 293     AC_MSG_ERROR([Cannot continue])
 294   fi
 295 
 296   AC_SUBST(BOOT_JDK)
 297 
 298   # Setup tools from the Boot JDK.
 299   BOOTJDK_CHECK_TOOL_IN_BOOTJDK(JAVA, java)
 300   BOOTJDK_CHECK_TOOL_IN_BOOTJDK(JAVAC, javac)
 301   BOOTJDK_CHECK_TOOL_IN_BOOTJDK(JAVAH, javah)
 302   BOOTJDK_CHECK_TOOL_IN_BOOTJDK(JAR, jar)
 303   BOOTJDK_CHECK_TOOL_IN_BOOTJDK(JARSIGNER, jarsigner)
 304 
 305   # Finally, set some other options...
 306 
 307   # When compiling code to be executed by the Boot JDK, force jdk8 compatibility.
 308   BOOT_JDK_SOURCETARGET="-source 8 -target 8"
 309   AC_SUBST(BOOT_JDK_SOURCETARGET)
 310   AC_SUBST(JAVAC_FLAGS)
 311 
 312   # Check if the boot jdk is 32 or 64 bit
 313   if "$JAVA" -d64 -version > /dev/null 2>&1; then
 314     BOOT_JDK_BITS="64"
 315   else
 316     BOOT_JDK_BITS="32"
 317   fi
 318   AC_MSG_CHECKING([if Boot JDK is 32 or 64 bits])
 319   AC_MSG_RESULT([$BOOT_JDK_BITS])
 320   AC_SUBST(BOOT_JDK_BITS)
 321 ])
 322 
 323 AC_DEFUN_ONCE([BOOTJDK_SETUP_BOOT_JDK_ARGUMENTS],
 324 [
 325   ##############################################################################
 326   #
 327   # Specify jvm options for anything that is run with the Boot JDK.
 328   # Not all JVM:s accept the same arguments on the command line.
 329   #
 330   AC_ARG_WITH(boot-jdk-jvmargs, [AS_HELP_STRING([--with-boot-jdk-jvmargs],
 331   [specify JVM arguments to be passed to all java invocations of boot JDK, overriding the default values,
 332   e.g --with-boot-jdk-jvmargs="-Xmx8G -enableassertions"])])
 333 
 334   AC_MSG_CHECKING([flags for boot jdk java command] )
 335 
 336   # Disable special log output when a debug build is used as Boot JDK...
 337   ADD_JVM_ARG_IF_OK([-XX:-PrintVMOptions -XX:-UnlockDiagnosticVMOptions -XX:-LogVMOutput],boot_jdk_jvmargs,[$JAVA])
 338 
 339   # Apply user provided options.
 340   ADD_JVM_ARG_IF_OK([$with_boot_jdk_jvmargs],boot_jdk_jvmargs,[$JAVA])
 341 
 342   AC_MSG_RESULT([$boot_jdk_jvmargs])
 343 
 344   # For now, general JAVA_FLAGS are the same as the boot jdk jvmargs
 345   JAVA_FLAGS=$boot_jdk_jvmargs
 346   AC_SUBST(JAVA_FLAGS)
 347 
 348 
 349   AC_MSG_CHECKING([flags for boot jdk java command for big workloads])
 350 
 351   # Starting amount of heap memory.
 352   ADD_JVM_ARG_IF_OK([-Xms64M],boot_jdk_jvmargs_big,[$JAVA])
 353 
 354   # Maximum amount of heap memory.
 355   # Maximum stack size.
 356   JVM_MAX_HEAP=`expr $MEMORY_SIZE / 2`
 357   if test "x$BOOT_JDK_BITS" = "x32"; then
 358     if test "$JVM_MAX_HEAP" -gt "1100"; then
 359       JVM_MAX_HEAP=1100
 360     elif test "$JVM_MAX_HEAP" -lt "512"; then
 361       JVM_MAX_HEAP=512
 362     fi
 363     STACK_SIZE=768
 364   else
 365     # Running a 64 bit JVM allows for and requires a bigger heap
 366     if test "$JVM_MAX_HEAP" -gt "1600"; then
 367       JVM_MAX_HEAP=1600
 368     elif test "$JVM_MAX_HEAP" -lt "512"; then
 369       JVM_MAX_HEAP=512
 370     fi
 371     STACK_SIZE=1536
 372   fi
 373   ADD_JVM_ARG_IF_OK([-Xmx${JVM_MAX_HEAP}M],boot_jdk_jvmargs_big,[$JAVA])
 374   ADD_JVM_ARG_IF_OK([-XX:ThreadStackSize=$STACK_SIZE],boot_jdk_jvmargs_big,[$JAVA])
 375 
 376   AC_MSG_RESULT([$boot_jdk_jvmargs_big])
 377 
 378   JAVA_FLAGS_BIG=$boot_jdk_jvmargs_big
 379   AC_SUBST(JAVA_FLAGS_BIG)
 380 
 381   # By default, the main javac compilations use big
 382   JAVA_FLAGS_JAVAC="$JAVA_FLAGS_BIG"
 383   AC_SUBST(JAVA_FLAGS_JAVAC)
 384 
 385   AC_MSG_CHECKING([flags for boot jdk java command for small workloads])
 386 
 387   # Use serial gc for small short lived tools if possible
 388   ADD_JVM_ARG_IF_OK([-XX:+UseSerialGC],boot_jdk_jvmargs_small,[$JAVA])
 389   ADD_JVM_ARG_IF_OK([-Xms32M],boot_jdk_jvmargs_small,[$JAVA])
 390   ADD_JVM_ARG_IF_OK([-Xmx512M],boot_jdk_jvmargs_small,[$JAVA])
 391 
 392   AC_MSG_RESULT([$boot_jdk_jvmargs_small])
 393 
 394   JAVA_FLAGS_SMALL=$boot_jdk_jvmargs_small
 395   AC_SUBST(JAVA_FLAGS_SMALL)
 396 
 397   JAVA_TOOL_FLAGS_SMALL=""
 398   for f in $JAVA_FLAGS_SMALL; do
 399     JAVA_TOOL_FLAGS_SMALL="$JAVA_TOOL_FLAGS_SMALL -J$f"
 400   done
 401   AC_SUBST(JAVA_TOOL_FLAGS_SMALL)
 402 ])