Mercurial Mercurial > jdk-sandbox / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
common/autoconf/generated-configure.sh
changeset 26131 311b5e288cf5
parent 26130 2ea1262921e0
child 26400 4d6c6f2df610
equal deleted inserted replaced
26130:2ea1262921e0 26131:311b5e288cf5 
   632 CCACHE
 
   632 CCACHE
 
   633 USE_PRECOMPILED_HEADER
 
   633 USE_PRECOMPILED_HEADER
 
   634 SJAVAC_SERVER_DIR
 
   634 SJAVAC_SERVER_DIR
 
   635 ENABLE_SJAVAC
 
   635 ENABLE_SJAVAC
 
   636 SJAVAC_SERVER_JAVA
 
   636 SJAVAC_SERVER_JAVA
 
       
   637 JAVA_TOOL_FLAGS_SMALL
 
       
   638 JAVA_FLAGS_SMALL
 
       
   639 JAVA_FLAGS_BIG
 
       
   640 JAVA_FLAGS
 
   637 JOBS
 
   641 JOBS
 
   638 MEMORY_SIZE
 
   642 MEMORY_SIZE
 
   639 NUM_CORES
 
   643 NUM_CORES
 
   640 ENABLE_INTREE_EC
 
   644 ENABLE_INTREE_EC
 
   641 SALIB_NAME
 
   645 SALIB_NAME
 
   803 HOTSPOT_TOPDIR
 
   807 HOTSPOT_TOPDIR
 
   804 JAXWS_TOPDIR
 
   808 JAXWS_TOPDIR
 
   805 JAXP_TOPDIR
 
   809 JAXP_TOPDIR
 
   806 CORBA_TOPDIR
 
   810 CORBA_TOPDIR
 
   807 LANGTOOLS_TOPDIR
 
   811 LANGTOOLS_TOPDIR
 
   808 JAVA_TOOL_FLAGS_SMALL
 
       
   809 JAVA_FLAGS_SMALL
 
       
   810 JAVA_FLAGS_BIG
 
       
   811 JAVA_FLAGS
 
       
   812 JAVAC_FLAGS
 
   812 JAVAC_FLAGS
 
   813 BOOT_JDK_SOURCETARGET
 
   813 BOOT_JDK_SOURCETARGET
 
   814 JARSIGNER
 
   814 JARSIGNER
 
   815 NATIVE2ASCII
 
   815 NATIVE2ASCII
 
   816 JAR
 
   816 JAR
 
  1062 with_milestone
 
  1062 with_milestone
 
  1063 with_update_version
 
  1063 with_update_version
 
  1064 with_user_release_suffix
 
  1064 with_user_release_suffix
 
  1065 with_build_number
 
  1065 with_build_number
 
  1066 with_boot_jdk
 
  1066 with_boot_jdk
 
  1067 with_boot_jdk_jvmargs
 
       
  1068 with_add_source_root
 
  1067 with_add_source_root
 
  1069 with_override_source_root
 
  1068 with_override_source_root
 
  1070 with_adds_and_overrides
 
  1069 with_adds_and_overrides
 
  1071 with_override_langtools
 
  1070 with_override_langtools
 
  1072 with_override_corba
 
  1071 with_override_corba
 
  1104 with_dxsdk_lib
 
  1103 with_dxsdk_lib
 
  1105 with_dxsdk_include
 
  1104 with_dxsdk_include
 
  1106 with_num_cores
 
  1105 with_num_cores
 
  1107 with_memory_size
 
  1106 with_memory_size
 
  1108 with_jobs
 
  1107 with_jobs
 
       
  1108 with_boot_jdk_jvmargs
 
  1109 with_sjavac_server_java
 
  1109 with_sjavac_server_java
 
  1110 enable_sjavac
 
  1110 enable_sjavac
 
  1111 enable_precompiled_headers
 
  1111 enable_precompiled_headers
 
  1112 enable_ccache
 
  1112 enable_ccache
 
  1113 with_ccache_dir
 
  1113 with_ccache_dir
 
  1902   --with-user-release-suffix
 
  1902   --with-user-release-suffix
 
  1903                           Add a custom string to the version string if build
 
  1903                           Add a custom string to the version string if build
 
  1904                           number is not set.[username_builddateb00]
 
  1904                           number is not set.[username_builddateb00]
 
  1905   --with-build-number     Set build number value for build [b00]
 
  1905   --with-build-number     Set build number value for build [b00]
 
  1906   --with-boot-jdk         path to Boot JDK (used to bootstrap build) [probed]
 
  1906   --with-boot-jdk         path to Boot JDK (used to bootstrap build) [probed]
 
  1907   --with-boot-jdk-jvmargs specify JVM arguments to be passed to all java
 
       
  1908                           invocations of boot JDK, overriding the default
 
       
  1909                           values, e.g --with-boot-jdk-jvmargs="-Xmx8G
 
       
  1910                           -enableassertions"
 
       
  1911   --with-add-source-root  for each and every source directory, look in this
 
  1907   --with-add-source-root  for each and every source directory, look in this
 
  1912                           additional source root for the same directory; if it
 
  1908                           additional source root for the same directory; if it
 
  1913                           exists and have files in it, include it in the build
 
  1909                           exists and have files in it, include it in the build
 
  1914   --with-override-source-root
 
  1910   --with-override-source-root
 
  1915                           for each and every source directory, look in this
 
  1911                           for each and every source directory, look in this
 
  1977                           --with-num-cores=8 [probed]
 
  1973                           --with-num-cores=8 [probed]
 
  1978   --with-memory-size      memory (in MB) available in the build system, e.g.
 
  1974   --with-memory-size      memory (in MB) available in the build system, e.g.
 
  1979                           --with-memory-size=1024 [probed]
 
  1975                           --with-memory-size=1024 [probed]
 
  1980   --with-jobs             number of parallel jobs to let make run [calculated
 
  1976   --with-jobs             number of parallel jobs to let make run [calculated
 
  1981                           based on cores and memory]
 
  1977                           based on cores and memory]
 
       
  1978   --with-boot-jdk-jvmargs specify JVM arguments to be passed to all java
 
       
  1979                           invocations of boot JDK, overriding the default
 
       
  1980                           values, e.g --with-boot-jdk-jvmargs="-Xmx8G
 
       
  1981                           -enableassertions"
 
  1982   --with-sjavac-server-java
 
  1982   --with-sjavac-server-java
 
  1983                           use this java binary for running the sjavac
 
  1983                           use this java binary for running the sjavac
 
  1984                           background server [Boot JDK java]
 
  1984                           background server [Boot JDK java]
 
  1985   --with-ccache-dir       where to store ccache files [~/.ccache]
 
  1985   --with-ccache-dir       where to store ccache files [~/.ccache]
 
  1986 
  1986 
  4319 # definitions. It is replaced with custom functionality when building
 
  4319 # definitions. It is replaced with custom functionality when building
 
  4320 # custom sources.
 
  4320 # custom sources.
 
  4321 #CUSTOM_AUTOCONF_INCLUDE
 
  4321 #CUSTOM_AUTOCONF_INCLUDE
 
  4322 
  4322 
  4323 # Do not change or remove the following line, it is needed for consistency checks:
 
  4323 # Do not change or remove the following line, it is needed for consistency checks:
 
  4324 DATE_WHEN_GENERATED=1409306485
 
  4324 DATE_WHEN_GENERATED=1409311712
 
  4325 
  4325 
  4326 ###############################################################################
 
  4326 ###############################################################################
 
  4327 #
 
  4327 #
 
  4328 # Initialization / Boot-strapping
 
  4328 # Initialization / Boot-strapping
 
  4329 #
 
  4329 #
 
 26318   BOOT_JDK_SOURCETARGET="-source 8 -target 8"
 
 26318   BOOT_JDK_SOURCETARGET="-source 8 -target 8"
 
 26319 
 26319 
 26320 
 26320 
 26321 
 26321 
 26322 
 26322 
 26323   ##############################################################################
 
       
 26324   #
 
       
 26325   # Specify jvm options for anything that is run with the Boot JDK.
 
       
 26326   # Not all JVM:s accept the same arguments on the command line.
 
       
 26327   #
 
       
 26328 
       
 26329 # Check whether --with-boot-jdk-jvmargs was given.
 
       
 26330 if test "${with_boot_jdk_jvmargs+set}" = set; then :
 
       
 26331   withval=$with_boot_jdk_jvmargs;
 
       
 26332 fi
 
       
 26333 
       
 26334 
       
 26335   { $as_echo "$as_me:${as_lineno-$LINENO}: checking flags for boot jdk java command " >&5
 
       
 26336 $as_echo_n "checking flags for boot jdk java command ... " >&6; }
 
       
 26337 
       
 26338   # Disable special log output when a debug build is used as Boot JDK...
 
       
 26339 
       
 26340   $ECHO "Check if jvm arg is ok: -XX:-PrintVMOptions -XX:-UnlockDiagnosticVMOptions -XX:-LogVMOutput" >&5
 
       
 26341   $ECHO "Command: $JAVA -XX:-PrintVMOptions -XX:-UnlockDiagnosticVMOptions -XX:-LogVMOutput -version" >&5
 
       
 26342   OUTPUT=`$JAVA -XX:-PrintVMOptions -XX:-UnlockDiagnosticVMOptions -XX:-LogVMOutput -version 2>&1`
 
       
 26343   FOUND_WARN=`$ECHO "$OUTPUT" | grep -i warn`
 
       
 26344   FOUND_VERSION=`$ECHO $OUTPUT | grep " version \""`
 
       
 26345   if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then
 
       
 26346     boot_jdk_jvmargs="$boot_jdk_jvmargs -XX:-PrintVMOptions -XX:-UnlockDiagnosticVMOptions -XX:-LogVMOutput"
 
       
 26347     JVM_ARG_OK=true
 
       
 26348   else
 
       
 26349     $ECHO "Arg failed:" >&5
 
       
 26350     $ECHO "$OUTPUT" >&5
 
       
 26351     JVM_ARG_OK=false
 
       
 26352   fi
 
       
 26353 
       
 26354 
       
 26355   # Apply user provided options.
 
       
 26356 
       
 26357   $ECHO "Check if jvm arg is ok: $with_boot_jdk_jvmargs" >&5
 
       
 26358   $ECHO "Command: $JAVA $with_boot_jdk_jvmargs -version" >&5
 
       
 26359   OUTPUT=`$JAVA $with_boot_jdk_jvmargs -version 2>&1`
 
       
 26360   FOUND_WARN=`$ECHO "$OUTPUT" | grep -i warn`
 
       
 26361   FOUND_VERSION=`$ECHO $OUTPUT | grep " version \""`
 
       
 26362   if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then
 
       
 26363     boot_jdk_jvmargs="$boot_jdk_jvmargs $with_boot_jdk_jvmargs"
 
       
 26364     JVM_ARG_OK=true
 
       
 26365   else
 
       
 26366     $ECHO "Arg failed:" >&5
 
       
 26367     $ECHO "$OUTPUT" >&5
 
       
 26368     JVM_ARG_OK=false
 
       
 26369   fi
 
       
 26370 
       
 26371 
       
 26372   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $boot_jdk_jvmargs" >&5
 
       
 26373 $as_echo "$boot_jdk_jvmargs" >&6; }
 
       
 26374 
       
 26375   # For now, general JAVA_FLAGS are the same as the boot jdk jvmargs
 
       
 26376   JAVA_FLAGS=$boot_jdk_jvmargs
 
       
 26377 
       
 26378 
       
 26379 
       
 26380   { $as_echo "$as_me:${as_lineno-$LINENO}: checking flags for boot jdk java command for big workloads" >&5
 
       
 26381 $as_echo_n "checking flags for boot jdk java command for big workloads... " >&6; }
 
       
 26382 
       
 26383   # Starting amount of heap memory.
 
       
 26384 
       
 26385   $ECHO "Check if jvm arg is ok: -Xms64M" >&5
 
       
 26386   $ECHO "Command: $JAVA -Xms64M -version" >&5
 
       
 26387   OUTPUT=`$JAVA -Xms64M -version 2>&1`
 
       
 26388   FOUND_WARN=`$ECHO "$OUTPUT" | grep -i warn`
 
       
 26389   FOUND_VERSION=`$ECHO $OUTPUT | grep " version \""`
 
       
 26390   if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then
 
       
 26391     boot_jdk_jvmargs_big="$boot_jdk_jvmargs_big -Xms64M"
 
       
 26392     JVM_ARG_OK=true
 
       
 26393   else
 
       
 26394     $ECHO "Arg failed:" >&5
 
       
 26395     $ECHO "$OUTPUT" >&5
 
       
 26396     JVM_ARG_OK=false
 
       
 26397   fi
 
       
 26398 
       
 26399 
       
 26400   # Maximum amount of heap memory.
 
       
 26401   # Maximum stack size.
 
       
 26402   if test "x$BUILD_NUM_BITS" = x32; then
 
       
 26403     JVM_MAX_HEAP=1100M
 
       
 26404     STACK_SIZE=768
 
       
 26405   else
 
       
 26406     # Running Javac on a JVM on a 64-bit machine, takes more space since 64-bit
 
       
 26407     # pointers are used. Apparently, we need to increase the heap and stack
 
       
 26408     # space for the jvm. More specifically, when running javac to build huge
 
       
 26409     # jdk batch
 
       
 26410     JVM_MAX_HEAP=1600M
 
       
 26411     STACK_SIZE=1536
 
       
 26412   fi
 
       
 26413 
       
 26414   $ECHO "Check if jvm arg is ok: -Xmx$JVM_MAX_HEAP" >&5
 
       
 26415   $ECHO "Command: $JAVA -Xmx$JVM_MAX_HEAP -version" >&5
 
       
 26416   OUTPUT=`$JAVA -Xmx$JVM_MAX_HEAP -version 2>&1`
 
       
 26417   FOUND_WARN=`$ECHO "$OUTPUT" | grep -i warn`
 
       
 26418   FOUND_VERSION=`$ECHO $OUTPUT | grep " version \""`
 
       
 26419   if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then
 
       
 26420     boot_jdk_jvmargs_big="$boot_jdk_jvmargs_big -Xmx$JVM_MAX_HEAP"
 
       
 26421     JVM_ARG_OK=true
 
       
 26422   else
 
       
 26423     $ECHO "Arg failed:" >&5
 
       
 26424     $ECHO "$OUTPUT" >&5
 
       
 26425     JVM_ARG_OK=false
 
       
 26426   fi
 
       
 26427 
       
 26428 
       
 26429   $ECHO "Check if jvm arg is ok: -XX:ThreadStackSize=$STACK_SIZE" >&5
 
       
 26430   $ECHO "Command: $JAVA -XX:ThreadStackSize=$STACK_SIZE -version" >&5
 
       
 26431   OUTPUT=`$JAVA -XX:ThreadStackSize=$STACK_SIZE -version 2>&1`
 
       
 26432   FOUND_WARN=`$ECHO "$OUTPUT" | grep -i warn`
 
       
 26433   FOUND_VERSION=`$ECHO $OUTPUT | grep " version \""`
 
       
 26434   if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then
 
       
 26435     boot_jdk_jvmargs_big="$boot_jdk_jvmargs_big -XX:ThreadStackSize=$STACK_SIZE"
 
       
 26436     JVM_ARG_OK=true
 
       
 26437   else
 
       
 26438     $ECHO "Arg failed:" >&5
 
       
 26439     $ECHO "$OUTPUT" >&5
 
       
 26440     JVM_ARG_OK=false
 
       
 26441   fi
 
       
 26442 
       
 26443 
       
 26444   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $boot_jdk_jvmargs_big" >&5
 
       
 26445 $as_echo "$boot_jdk_jvmargs_big" >&6; }
 
       
 26446 
       
 26447   JAVA_FLAGS_BIG=$boot_jdk_jvmargs_big
 
       
 26448 
       
 26449 
       
 26450 
       
 26451   { $as_echo "$as_me:${as_lineno-$LINENO}: checking flags for boot jdk java command for small workloads" >&5
 
       
 26452 $as_echo_n "checking flags for boot jdk java command for small workloads... " >&6; }
 
       
 26453 
       
 26454   # Use serial gc for small short lived tools if possible
 
       
 26455 
       
 26456   $ECHO "Check if jvm arg is ok: -XX:+UseSerialGC" >&5
 
       
 26457   $ECHO "Command: $JAVA -XX:+UseSerialGC -version" >&5
 
       
 26458   OUTPUT=`$JAVA -XX:+UseSerialGC -version 2>&1`
 
       
 26459   FOUND_WARN=`$ECHO "$OUTPUT" | grep -i warn`
 
       
 26460   FOUND_VERSION=`$ECHO $OUTPUT | grep " version \""`
 
       
 26461   if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then
 
       
 26462     boot_jdk_jvmargs_small="$boot_jdk_jvmargs_small -XX:+UseSerialGC"
 
       
 26463     JVM_ARG_OK=true
 
       
 26464   else
 
       
 26465     $ECHO "Arg failed:" >&5
 
       
 26466     $ECHO "$OUTPUT" >&5
 
       
 26467     JVM_ARG_OK=false
 
       
 26468   fi
 
       
 26469 
       
 26470 
       
 26471   $ECHO "Check if jvm arg is ok: -Xms32M" >&5
 
       
 26472   $ECHO "Command: $JAVA -Xms32M -version" >&5
 
       
 26473   OUTPUT=`$JAVA -Xms32M -version 2>&1`
 
       
 26474   FOUND_WARN=`$ECHO "$OUTPUT" | grep -i warn`
 
       
 26475   FOUND_VERSION=`$ECHO $OUTPUT | grep " version \""`
 
       
 26476   if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then
 
       
 26477     boot_jdk_jvmargs_small="$boot_jdk_jvmargs_small -Xms32M"
 
       
 26478     JVM_ARG_OK=true
 
       
 26479   else
 
       
 26480     $ECHO "Arg failed:" >&5
 
       
 26481     $ECHO "$OUTPUT" >&5
 
       
 26482     JVM_ARG_OK=false
 
       
 26483   fi
 
       
 26484 
       
 26485 
       
 26486   $ECHO "Check if jvm arg is ok: -Xmx512M" >&5
 
       
 26487   $ECHO "Command: $JAVA -Xmx512M -version" >&5
 
       
 26488   OUTPUT=`$JAVA -Xmx512M -version 2>&1`
 
       
 26489   FOUND_WARN=`$ECHO "$OUTPUT" | grep -i warn`
 
       
 26490   FOUND_VERSION=`$ECHO $OUTPUT | grep " version \""`
 
       
 26491   if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then
 
       
 26492     boot_jdk_jvmargs_small="$boot_jdk_jvmargs_small -Xmx512M"
 
       
 26493     JVM_ARG_OK=true
 
       
 26494   else
 
       
 26495     $ECHO "Arg failed:" >&5
 
       
 26496     $ECHO "$OUTPUT" >&5
 
       
 26497     JVM_ARG_OK=false
 
       
 26498   fi
 
       
 26499 
       
 26500 
       
 26501   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $boot_jdk_jvmargs_small" >&5
 
       
 26502 $as_echo "$boot_jdk_jvmargs_small" >&6; }
 
       
 26503 
       
 26504   JAVA_FLAGS_SMALL=$boot_jdk_jvmargs_small
 
       
 26505 
       
 26506 
       
 26507   JAVA_TOOL_FLAGS_SMALL=""
 
       
 26508   for f in $JAVA_FLAGS_SMALL; do
 
       
 26509     JAVA_TOOL_FLAGS_SMALL="$JAVA_TOOL_FLAGS_SMALL -J$f"
 
       
 26510   done
 
       
 26511 
       
 26512 
       
 26513 
       
 26514 ###############################################################################
 
 26323 ###############################################################################
 
 26515 #
 
 26324 #
 
 26516 # Configure the sources to use. We can add or override individual directories.
 
 26325 # Configure the sources to use. We can add or override individual directories.
 
 26517 #
 
 26326 #
 
 26518 ###############################################################################
 
 26327 ###############################################################################
 
 49885 
 49694 
 49886   if test "x$with_jobs" = x; then
 
 49695   if test "x$with_jobs" = x; then
 
 49887     # Number of jobs was not specified, calculate.
 
 49696     # Number of jobs was not specified, calculate.
 
 49888     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for appropriate number of jobs to run in parallel" >&5
 
 49697     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for appropriate number of jobs to run in parallel" >&5
 
 49889 $as_echo_n "checking for appropriate number of jobs to run in parallel... " >&6; }
 
 49698 $as_echo_n "checking for appropriate number of jobs to run in parallel... " >&6; }
 
 49890     # Approximate memory in GB, rounding up a bit.
 
 49699     # Approximate memory in GB.
 
 49891     memory_gb=`expr $MEMORY_SIZE / 1100`
 
 49700     memory_gb=`expr $MEMORY_SIZE / 1024`
 
 49892     # Pick the lowest of memory in gb and number of cores.
 
 49701     # Pick the lowest of memory in gb and number of cores.
 
 49893     if test "$memory_gb" -lt "$NUM_CORES"; then
 
 49702     if test "$memory_gb" -lt "$NUM_CORES"; then
 
 49894       JOBS="$memory_gb"
 
 49703       JOBS="$memory_gb"
 
 49895     else
 
 49704     else
 
 49896       JOBS="$NUM_CORES"
 
 49705       JOBS="$NUM_CORES"
 
 49912     JOBS=$with_jobs
 
 49721     JOBS=$with_jobs
 
 49913   fi
 
 49722   fi
 
 49914 
 49723 
 49915 
 49724 
 49916 
 49725 
       
 49726 # Setup arguments for the boot jdk (after cores and memory have been setup)
 
       
 49727 
       
 49728   ##############################################################################
 
       
 49729   #
 
       
 49730   # Specify jvm options for anything that is run with the Boot JDK.
 
       
 49731   # Not all JVM:s accept the same arguments on the command line.
 
       
 49732   #
 
       
 49733 
       
 49734 # Check whether --with-boot-jdk-jvmargs was given.
 
       
 49735 if test "${with_boot_jdk_jvmargs+set}" = set; then :
 
       
 49736   withval=$with_boot_jdk_jvmargs;
 
       
 49737 fi
 
       
 49738 
       
 49739 
       
 49740   { $as_echo "$as_me:${as_lineno-$LINENO}: checking flags for boot jdk java command " >&5
 
       
 49741 $as_echo_n "checking flags for boot jdk java command ... " >&6; }
 
       
 49742 
       
 49743   # Disable special log output when a debug build is used as Boot JDK...
 
       
 49744 
       
 49745   $ECHO "Check if jvm arg is ok: -XX:-PrintVMOptions -XX:-UnlockDiagnosticVMOptions -XX:-LogVMOutput" >&5
 
       
 49746   $ECHO "Command: $JAVA -XX:-PrintVMOptions -XX:-UnlockDiagnosticVMOptions -XX:-LogVMOutput -version" >&5
 
       
 49747   OUTPUT=`$JAVA -XX:-PrintVMOptions -XX:-UnlockDiagnosticVMOptions -XX:-LogVMOutput -version 2>&1`
 
       
 49748   FOUND_WARN=`$ECHO "$OUTPUT" | grep -i warn`
 
       
 49749   FOUND_VERSION=`$ECHO $OUTPUT | grep " version \""`
 
       
 49750   if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then
 
       
 49751     boot_jdk_jvmargs="$boot_jdk_jvmargs -XX:-PrintVMOptions -XX:-UnlockDiagnosticVMOptions -XX:-LogVMOutput"
 
       
 49752     JVM_ARG_OK=true
 
       
 49753   else
 
       
 49754     $ECHO "Arg failed:" >&5
 
       
 49755     $ECHO "$OUTPUT" >&5
 
       
 49756     JVM_ARG_OK=false
 
       
 49757   fi
 
       
 49758 
       
 49759 
       
 49760   # Apply user provided options.
 
       
 49761 
       
 49762   $ECHO "Check if jvm arg is ok: $with_boot_jdk_jvmargs" >&5
 
       
 49763   $ECHO "Command: $JAVA $with_boot_jdk_jvmargs -version" >&5
 
       
 49764   OUTPUT=`$JAVA $with_boot_jdk_jvmargs -version 2>&1`
 
       
 49765   FOUND_WARN=`$ECHO "$OUTPUT" | grep -i warn`
 
       
 49766   FOUND_VERSION=`$ECHO $OUTPUT | grep " version \""`
 
       
 49767   if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then
 
       
 49768     boot_jdk_jvmargs="$boot_jdk_jvmargs $with_boot_jdk_jvmargs"
 
       
 49769     JVM_ARG_OK=true
 
       
 49770   else
 
       
 49771     $ECHO "Arg failed:" >&5
 
       
 49772     $ECHO "$OUTPUT" >&5
 
       
 49773     JVM_ARG_OK=false
 
       
 49774   fi
 
       
 49775 
       
 49776 
       
 49777   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $boot_jdk_jvmargs" >&5
 
       
 49778 $as_echo "$boot_jdk_jvmargs" >&6; }
 
       
 49779 
       
 49780   # For now, general JAVA_FLAGS are the same as the boot jdk jvmargs
 
       
 49781   JAVA_FLAGS=$boot_jdk_jvmargs
 
       
 49782 
       
 49783 
       
 49784 
       
 49785   { $as_echo "$as_me:${as_lineno-$LINENO}: checking flags for boot jdk java command for big workloads" >&5
 
       
 49786 $as_echo_n "checking flags for boot jdk java command for big workloads... " >&6; }
 
       
 49787 
       
 49788   # Starting amount of heap memory.
 
       
 49789 
       
 49790   $ECHO "Check if jvm arg is ok: -Xms64M" >&5
 
       
 49791   $ECHO "Command: $JAVA -Xms64M -version" >&5
 
       
 49792   OUTPUT=`$JAVA -Xms64M -version 2>&1`
 
       
 49793   FOUND_WARN=`$ECHO "$OUTPUT" | grep -i warn`
 
       
 49794   FOUND_VERSION=`$ECHO $OUTPUT | grep " version \""`
 
       
 49795   if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then
 
       
 49796     boot_jdk_jvmargs_big="$boot_jdk_jvmargs_big -Xms64M"
 
       
 49797     JVM_ARG_OK=true
 
       
 49798   else
 
       
 49799     $ECHO "Arg failed:" >&5
 
       
 49800     $ECHO "$OUTPUT" >&5
 
       
 49801     JVM_ARG_OK=false
 
       
 49802   fi
 
       
 49803 
       
 49804 
       
 49805   # Maximum amount of heap memory.
 
       
 49806   # Maximum stack size.
 
       
 49807   JVM_MAX_HEAP=`expr $MEMORY_SIZE / 2`
 
       
 49808   if test "x$BUILD_NUM_BITS" = x32; then
 
       
 49809     if test "$JVM_MAX_HEAP" -gt "1100"; then
 
       
 49810       JVM_MAX_HEAP=1100
 
       
 49811     elif test "$JVM_MAX_HEAP" -lt "512"; then
 
       
 49812       JVM_MAX_HEAP=512
 
       
 49813     fi
 
       
 49814     STACK_SIZE=768
 
       
 49815   else
 
       
 49816     # Running Javac on a JVM on a 64-bit machine, takes more space since 64-bit
 
       
 49817     # pointers are used. Apparently, we need to increase the heap and stack
 
       
 49818     # space for the jvm. More specifically, when running javac to build huge
 
       
 49819     # jdk batch
 
       
 49820     if test "$JVM_MAX_HEAP" -gt "1600"; then
 
       
 49821       JVM_MAX_HEAP=1600
 
       
 49822     elif test "$JVM_MAX_HEAP" -lt "512"; then
 
       
 49823       JVM_MAX_HEAP=512
 
       
 49824     fi
 
       
 49825     STACK_SIZE=1536
 
       
 49826   fi
 
       
 49827 
       
 49828   $ECHO "Check if jvm arg is ok: -Xmx${JVM_MAX_HEAP}M" >&5
 
       
 49829   $ECHO "Command: $JAVA -Xmx${JVM_MAX_HEAP}M -version" >&5
 
       
 49830   OUTPUT=`$JAVA -Xmx${JVM_MAX_HEAP}M -version 2>&1`
 
       
 49831   FOUND_WARN=`$ECHO "$OUTPUT" | grep -i warn`
 
       
 49832   FOUND_VERSION=`$ECHO $OUTPUT | grep " version \""`
 
       
 49833   if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then
 
       
 49834     boot_jdk_jvmargs_big="$boot_jdk_jvmargs_big -Xmx${JVM_MAX_HEAP}M"
 
       
 49835     JVM_ARG_OK=true
 
       
 49836   else
 
       
 49837     $ECHO "Arg failed:" >&5
 
       
 49838     $ECHO "$OUTPUT" >&5
 
       
 49839     JVM_ARG_OK=false
 
       
 49840   fi
 
       
 49841 
       
 49842 
       
 49843   $ECHO "Check if jvm arg is ok: -XX:ThreadStackSize=$STACK_SIZE" >&5
 
       
 49844   $ECHO "Command: $JAVA -XX:ThreadStackSize=$STACK_SIZE -version" >&5
 
       
 49845   OUTPUT=`$JAVA -XX:ThreadStackSize=$STACK_SIZE -version 2>&1`
 
       
 49846   FOUND_WARN=`$ECHO "$OUTPUT" | grep -i warn`
 
       
 49847   FOUND_VERSION=`$ECHO $OUTPUT | grep " version \""`
 
       
 49848   if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then
 
       
 49849     boot_jdk_jvmargs_big="$boot_jdk_jvmargs_big -XX:ThreadStackSize=$STACK_SIZE"
 
       
 49850     JVM_ARG_OK=true
 
       
 49851   else
 
       
 49852     $ECHO "Arg failed:" >&5
 
       
 49853     $ECHO "$OUTPUT" >&5
 
       
 49854     JVM_ARG_OK=false
 
       
 49855   fi
 
       
 49856 
       
 49857 
       
 49858   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $boot_jdk_jvmargs_big" >&5
 
       
 49859 $as_echo "$boot_jdk_jvmargs_big" >&6; }
 
       
 49860 
       
 49861   JAVA_FLAGS_BIG=$boot_jdk_jvmargs_big
 
       
 49862 
       
 49863 
       
 49864 
       
 49865   { $as_echo "$as_me:${as_lineno-$LINENO}: checking flags for boot jdk java command for small workloads" >&5
 
       
 49866 $as_echo_n "checking flags for boot jdk java command for small workloads... " >&6; }
 
       
 49867 
       
 49868   # Use serial gc for small short lived tools if possible
 
       
 49869 
       
 49870   $ECHO "Check if jvm arg is ok: -XX:+UseSerialGC" >&5
 
       
 49871   $ECHO "Command: $JAVA -XX:+UseSerialGC -version" >&5
 
       
 49872   OUTPUT=`$JAVA -XX:+UseSerialGC -version 2>&1`
 
       
 49873   FOUND_WARN=`$ECHO "$OUTPUT" | grep -i warn`
 
       
 49874   FOUND_VERSION=`$ECHO $OUTPUT | grep " version \""`
 
       
 49875   if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then
 
       
 49876     boot_jdk_jvmargs_small="$boot_jdk_jvmargs_small -XX:+UseSerialGC"
 
       
 49877     JVM_ARG_OK=true
 
       
 49878   else
 
       
 49879     $ECHO "Arg failed:" >&5
 
       
 49880     $ECHO "$OUTPUT" >&5
 
       
 49881     JVM_ARG_OK=false
 
       
 49882   fi
 
       
 49883 
       
 49884 
       
 49885   $ECHO "Check if jvm arg is ok: -Xms32M" >&5
 
       
 49886   $ECHO "Command: $JAVA -Xms32M -version" >&5
 
       
 49887   OUTPUT=`$JAVA -Xms32M -version 2>&1`
 
       
 49888   FOUND_WARN=`$ECHO "$OUTPUT" | grep -i warn`
 
       
 49889   FOUND_VERSION=`$ECHO $OUTPUT | grep " version \""`
 
       
 49890   if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then
 
       
 49891     boot_jdk_jvmargs_small="$boot_jdk_jvmargs_small -Xms32M"
 
       
 49892     JVM_ARG_OK=true
 
       
 49893   else
 
       
 49894     $ECHO "Arg failed:" >&5
 
       
 49895     $ECHO "$OUTPUT" >&5
 
       
 49896     JVM_ARG_OK=false
 
       
 49897   fi
 
       
 49898 
       
 49899 
       
 49900   $ECHO "Check if jvm arg is ok: -Xmx512M" >&5
 
       
 49901   $ECHO "Command: $JAVA -Xmx512M -version" >&5
 
       
 49902   OUTPUT=`$JAVA -Xmx512M -version 2>&1`
 
       
 49903   FOUND_WARN=`$ECHO "$OUTPUT" | grep -i warn`
 
       
 49904   FOUND_VERSION=`$ECHO $OUTPUT | grep " version \""`
 
       
 49905   if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then
 
       
 49906     boot_jdk_jvmargs_small="$boot_jdk_jvmargs_small -Xmx512M"
 
       
 49907     JVM_ARG_OK=true
 
       
 49908   else
 
       
 49909     $ECHO "Arg failed:" >&5
 
       
 49910     $ECHO "$OUTPUT" >&5
 
       
 49911     JVM_ARG_OK=false
 
       
 49912   fi
 
       
 49913 
       
 49914 
       
 49915   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $boot_jdk_jvmargs_small" >&5
 
       
 49916 $as_echo "$boot_jdk_jvmargs_small" >&6; }
 
       
 49917 
       
 49918   JAVA_FLAGS_SMALL=$boot_jdk_jvmargs_small
 
       
 49919 
       
 49920 
       
 49921   JAVA_TOOL_FLAGS_SMALL=""
 
       
 49922   for f in $JAVA_FLAGS_SMALL; do
 
       
 49923     JAVA_TOOL_FLAGS_SMALL="$JAVA_TOOL_FLAGS_SMALL -J$f"
 
       
 49924   done
 
       
 49925 
       
 49926 
       
 49927 
 49917 # Setup smart javac (after cores and memory have been setup)
 
 49928 # Setup smart javac (after cores and memory have been setup)
 
 49918 
 49929 
 49919 
 49930 
 49920 # Check whether --with-sjavac-server-java was given.
 
 49931 # Check whether --with-sjavac-server-java was given.
 
 49921 if test "${with_sjavac_server_java+set}" = set; then :
 
 49932 if test "${with_sjavac_server_java+set}" = set; then :
 
 49928     FOUND_VERSION=`$SJAVAC_SERVER_JAVA -version 2>&1 | grep " version \""`
 
 49939     FOUND_VERSION=`$SJAVAC_SERVER_JAVA -version 2>&1 | grep " version \""`
 
 49929     if test "x$FOUND_VERSION" = x; then
 
 49940     if test "x$FOUND_VERSION" = x; then
 
 49930       as_fn_error $? "Could not execute server java: $SJAVAC_SERVER_JAVA" "$LINENO" 5
 
 49941       as_fn_error $? "Could not execute server java: $SJAVAC_SERVER_JAVA" "$LINENO" 5
 
 49931     fi
 
 49942     fi
 
 49932   else
 
 49943   else
 
 49933     SJAVAC_SERVER_JAVA=""
 
 49944     SJAVAC_SERVER_JAVA="$JAVA"
 
 49934     # Hotspot specific options.
 
 49945   fi
 
 49935 
 49946 
 49936   $ECHO "Check if jvm arg is ok: -verbosegc" >&5
 
 49947 
 49937   $ECHO "Command: $JAVA -verbosegc -version" >&5
 
 49948   if test "$MEMORY_SIZE" -gt "3000"; then
 
 49938   OUTPUT=`$JAVA -verbosegc -version 2>&1`
 
       
 49939   FOUND_WARN=`$ECHO "$OUTPUT" | grep -i warn`
 
       
 49940   FOUND_VERSION=`$ECHO $OUTPUT | grep " version \""`
 
       
 49941   if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then
 
       
 49942     SJAVAC_SERVER_JAVA="$SJAVAC_SERVER_JAVA -verbosegc"
 
       
 49943     JVM_ARG_OK=true
 
       
 49944   else
 
       
 49945     $ECHO "Arg failed:" >&5
 
       
 49946     $ECHO "$OUTPUT" >&5
 
       
 49947     JVM_ARG_OK=false
 
       
 49948   fi
 
       
 49949 
       
 49950     # JRockit specific options.
 
       
 49951 
       
 49952   $ECHO "Check if jvm arg is ok: -Xverbose:gc" >&5
 
       
 49953   $ECHO "Command: $JAVA -Xverbose:gc -version" >&5
 
       
 49954   OUTPUT=`$JAVA -Xverbose:gc -version 2>&1`
 
       
 49955   FOUND_WARN=`$ECHO "$OUTPUT" | grep -i warn`
 
       
 49956   FOUND_VERSION=`$ECHO $OUTPUT | grep " version \""`
 
       
 49957   if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then
 
       
 49958     SJAVAC_SERVER_JAVA="$SJAVAC_SERVER_JAVA -Xverbose:gc"
 
       
 49959     JVM_ARG_OK=true
 
       
 49960   else
 
       
 49961     $ECHO "Arg failed:" >&5
 
       
 49962     $ECHO "$OUTPUT" >&5
 
       
 49963     JVM_ARG_OK=false
 
       
 49964   fi
 
       
 49965 
       
 49966     SJAVAC_SERVER_JAVA="$JAVA $SJAVAC_SERVER_JAVA"
 
       
 49967   fi
 
       
 49968 
       
 49969 
       
 49970   if test "$MEMORY_SIZE" -gt "2500"; then
 
       
 49971 
 49949 
 49972   $ECHO "Check if jvm arg is ok: -d64" >&5
 
 49950   $ECHO "Check if jvm arg is ok: -d64" >&5
 
 49973   $ECHO "Command: $SJAVAC_SERVER_JAVA -d64 -version" >&5
 
 49951   $ECHO "Command: $SJAVAC_SERVER_JAVA -d64 -version" >&5
 
 49974   OUTPUT=`$SJAVAC_SERVER_JAVA -d64 -version 2>&1`
 
 49952   OUTPUT=`$SJAVAC_SERVER_JAVA -d64 -version 2>&1`
 
 49975   FOUND_WARN=`$ECHO "$OUTPUT" | grep -i warn`
 
 49953   FOUND_WARN=`$ECHO "$OUTPUT" | grep -i warn`
 
 49987       JVM_64BIT=true
 
 49965       JVM_64BIT=true
 
 49988       JVM_ARG_OK=false
 
 49966       JVM_ARG_OK=false
 
 49989     fi
 
 49967     fi
 
 49990   fi
 
 49968   fi
 
 49991 
 49969 
       
 49970   MX_VALUE=`expr $MEMORY_SIZE / 2`
 
 49992   if test "$JVM_64BIT" = true; then
 
 49971   if test "$JVM_64BIT" = true; then
 
 49993     if test "$MEMORY_SIZE" -gt "17000"; then
 
 49972     # Set ms lower than mx since more than one instance of the server might
 
 49994 
 49973     # get launched at the same time before they figure out which instance won.
 
 49995   $ECHO "Check if jvm arg is ok: -Xms10G -Xmx10G" >&5
 
 49974     MS_VALUE=512
 
 49996   $ECHO "Command: $SJAVAC_SERVER_JAVA -Xms10G -Xmx10G -version" >&5
 
 49975     if test "$MX_VALUE" -gt "2048"; then
 
 49997   OUTPUT=`$SJAVAC_SERVER_JAVA -Xms10G -Xmx10G -version 2>&1`
 
 49976       MX_VALUE=2048
 
       
 49977     fi
 
       
 49978   else
 
       
 49979     MS_VALUE=256
 
       
 49980     if test "$MX_VALUE" -gt "1500"; then
 
       
 49981       MX_VALUE=1500
 
       
 49982     fi
 
       
 49983   fi
 
       
 49984   if test "$MX_VALUE" -lt "512"; then
 
       
 49985     MX_VALUE=512
 
       
 49986   fi
 
       
 49987 
       
 49988   $ECHO "Check if jvm arg is ok: -Xms${MS_VALUE}M -Xmx${MX_VALUE}M" >&5
 
       
 49989   $ECHO "Command: $SJAVAC_SERVER_JAVA -Xms${MS_VALUE}M -Xmx${MX_VALUE}M -version" >&5
 
       
 49990   OUTPUT=`$SJAVAC_SERVER_JAVA -Xms${MS_VALUE}M -Xmx${MX_VALUE}M -version 2>&1`
 
 49998   FOUND_WARN=`$ECHO "$OUTPUT" | grep -i warn`
 
 49991   FOUND_WARN=`$ECHO "$OUTPUT" | grep -i warn`
 
 49999   FOUND_VERSION=`$ECHO $OUTPUT | grep " version \""`
 
 49992   FOUND_VERSION=`$ECHO $OUTPUT | grep " version \""`
 
 50000   if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then
 
 49993   if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then
 
 50001     SJAVAC_SERVER_JAVA="$SJAVAC_SERVER_JAVA -Xms10G -Xmx10G"
 
 49994     SJAVAC_SERVER_JAVA="$SJAVAC_SERVER_JAVA -Xms${MS_VALUE}M -Xmx${MX_VALUE}M"
 
 50002     JVM_ARG_OK=true
 
 49995     JVM_ARG_OK=true
 
 50003   else
 
 49996   else
 
 50004     $ECHO "Arg failed:" >&5
 
 49997     $ECHO "Arg failed:" >&5
 
 50005     $ECHO "$OUTPUT" >&5
 
 49998     $ECHO "$OUTPUT" >&5
 
 50006     JVM_ARG_OK=false
 
 49999     JVM_ARG_OK=false
 
 50007   fi
 
 50000   fi
 
 50008 
 50001 
 50009     fi
 
 50002 
 50010     if test "$MEMORY_SIZE" -gt "10000" && test "$JVM_ARG_OK" = false; then
 
       
 50011 
       
 50012   $ECHO "Check if jvm arg is ok: -Xms6G -Xmx6G" >&5
 
       
 50013   $ECHO "Command: $SJAVAC_SERVER_JAVA -Xms6G -Xmx6G -version" >&5
 
       
 50014   OUTPUT=`$SJAVAC_SERVER_JAVA -Xms6G -Xmx6G -version 2>&1`
 
       
 50015   FOUND_WARN=`$ECHO "$OUTPUT" | grep -i warn`
 
       
 50016   FOUND_VERSION=`$ECHO $OUTPUT | grep " version \""`
 
       
 50017   if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then
 
       
 50018     SJAVAC_SERVER_JAVA="$SJAVAC_SERVER_JAVA -Xms6G -Xmx6G"
 
       
 50019     JVM_ARG_OK=true
 
       
 50020   else
 
       
 50021     $ECHO "Arg failed:" >&5
 
       
 50022     $ECHO "$OUTPUT" >&5
 
       
 50023     JVM_ARG_OK=false
 
       
 50024   fi
 
       
 50025 
       
 50026     fi
 
       
 50027     if test "$MEMORY_SIZE" -gt "5000" && test "$JVM_ARG_OK" = false; then
 
       
 50028 
       
 50029   $ECHO "Check if jvm arg is ok: -Xms1G -Xmx3G" >&5
 
       
 50030   $ECHO "Command: $SJAVAC_SERVER_JAVA -Xms1G -Xmx3G -version" >&5
 
       
 50031   OUTPUT=`$SJAVAC_SERVER_JAVA -Xms1G -Xmx3G -version 2>&1`
 
       
 50032   FOUND_WARN=`$ECHO "$OUTPUT" | grep -i warn`
 
       
 50033   FOUND_VERSION=`$ECHO $OUTPUT | grep " version \""`
 
       
 50034   if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then
 
       
 50035     SJAVAC_SERVER_JAVA="$SJAVAC_SERVER_JAVA -Xms1G -Xmx3G"
 
       
 50036     JVM_ARG_OK=true
 
       
 50037   else
 
       
 50038     $ECHO "Arg failed:" >&5
 
       
 50039     $ECHO "$OUTPUT" >&5
 
       
 50040     JVM_ARG_OK=false
 
       
 50041   fi
 
       
 50042 
       
 50043     fi
 
       
 50044     if test "$MEMORY_SIZE" -gt "3800" && test "$JVM_ARG_OK" = false; then
 
       
 50045 
       
 50046   $ECHO "Check if jvm arg is ok: -Xms1G -Xmx2500M" >&5
 
       
 50047   $ECHO "Command: $SJAVAC_SERVER_JAVA -Xms1G -Xmx2500M -version" >&5
 
       
 50048   OUTPUT=`$SJAVAC_SERVER_JAVA -Xms1G -Xmx2500M -version 2>&1`
 
       
 50049   FOUND_WARN=`$ECHO "$OUTPUT" | grep -i warn`
 
       
 50050   FOUND_VERSION=`$ECHO $OUTPUT | grep " version \""`
 
       
 50051   if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then
 
       
 50052     SJAVAC_SERVER_JAVA="$SJAVAC_SERVER_JAVA -Xms1G -Xmx2500M"
 
       
 50053     JVM_ARG_OK=true
 
       
 50054   else
 
       
 50055     $ECHO "Arg failed:" >&5
 
       
 50056     $ECHO "$OUTPUT" >&5
 
       
 50057     JVM_ARG_OK=false
 
       
 50058   fi
 
       
 50059 
       
 50060     fi
 
       
 50061   fi
 
       
 50062   if test "$MEMORY_SIZE" -gt "2500" && test "$JVM_ARG_OK" = false; then
 
       
 50063 
       
 50064   $ECHO "Check if jvm arg is ok: -Xms1000M -Xmx1500M" >&5
 
       
 50065   $ECHO "Command: $SJAVAC_SERVER_JAVA -Xms1000M -Xmx1500M -version" >&5
 
       
 50066   OUTPUT=`$SJAVAC_SERVER_JAVA -Xms1000M -Xmx1500M -version 2>&1`
 
       
 50067   FOUND_WARN=`$ECHO "$OUTPUT" | grep -i warn`
 
       
 50068   FOUND_VERSION=`$ECHO $OUTPUT | grep " version \""`
 
       
 50069   if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then
 
       
 50070     SJAVAC_SERVER_JAVA="$SJAVAC_SERVER_JAVA -Xms1000M -Xmx1500M"
 
       
 50071     JVM_ARG_OK=true
 
       
 50072   else
 
       
 50073     $ECHO "Arg failed:" >&5
 
       
 50074     $ECHO "$OUTPUT" >&5
 
       
 50075     JVM_ARG_OK=false
 
       
 50076   fi
 
       
 50077 
       
 50078   fi
 
       
 50079   if test "$MEMORY_SIZE" -gt "1000" && test "$JVM_ARG_OK" = false; then
 
       
 50080 
       
 50081   $ECHO "Check if jvm arg is ok: -Xms400M -Xmx1100M" >&5
 
       
 50082   $ECHO "Command: $SJAVAC_SERVER_JAVA -Xms400M -Xmx1100M -version" >&5
 
       
 50083   OUTPUT=`$SJAVAC_SERVER_JAVA -Xms400M -Xmx1100M -version 2>&1`
 
       
 50084   FOUND_WARN=`$ECHO "$OUTPUT" | grep -i warn`
 
       
 50085   FOUND_VERSION=`$ECHO $OUTPUT | grep " version \""`
 
       
 50086   if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then
 
       
 50087     SJAVAC_SERVER_JAVA="$SJAVAC_SERVER_JAVA -Xms400M -Xmx1100M"
 
       
 50088     JVM_ARG_OK=true
 
       
 50089   else
 
       
 50090     $ECHO "Arg failed:" >&5
 
       
 50091     $ECHO "$OUTPUT" >&5
 
       
 50092     JVM_ARG_OK=false
 
       
 50093   fi
 
       
 50094 
       
 50095   fi
 
       
 50096   if test "$JVM_ARG_OK" = false; then
 
       
 50097 
       
 50098   $ECHO "Check if jvm arg is ok: -Xms256M -Xmx512M" >&5
 
       
 50099   $ECHO "Command: $SJAVAC_SERVER_JAVA -Xms256M -Xmx512M -version" >&5
 
       
 50100   OUTPUT=`$SJAVAC_SERVER_JAVA -Xms256M -Xmx512M -version 2>&1`
 
       
 50101   FOUND_WARN=`$ECHO "$OUTPUT" | grep -i warn`
 
       
 50102   FOUND_VERSION=`$ECHO $OUTPUT | grep " version \""`
 
       
 50103   if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then
 
       
 50104     SJAVAC_SERVER_JAVA="$SJAVAC_SERVER_JAVA -Xms256M -Xmx512M"
 
       
 50105     JVM_ARG_OK=true
 
       
 50106   else
 
       
 50107     $ECHO "Arg failed:" >&5
 
       
 50108     $ECHO "$OUTPUT" >&5
 
       
 50109     JVM_ARG_OK=false
 
       
 50110   fi
 
       
 50111 
       
 50112   fi
 
       
 50113 
       
 50114   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to use sjavac" >&5
 
       
 50115 $as_echo_n "checking whether to use sjavac... " >&6; }
 
       
 50116   # Check whether --enable-sjavac was given.
 
 50003   # Check whether --enable-sjavac was given.
 
 50117 if test "${enable_sjavac+set}" = set; then :
 
 50004 if test "${enable_sjavac+set}" = set; then :
 
 50118   enableval=$enable_sjavac; ENABLE_SJAVAC="${enableval}"
 
 50005   enableval=$enable_sjavac; ENABLE_SJAVAC="${enableval}"
 
 50119 else
 
 50006 else
 
 50120   ENABLE_SJAVAC='no'
 
 50007   ENABLE_SJAVAC='no'
 
 50121 fi
 
 50008 fi
 
 50122 
 50009 
       
 50010   if test "x$JVM_ARG_OK" = "xfalse"; then
 
       
 50011     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Could not set -Xms${MS_VALUE}M -Xmx${MX_VALUE}M, disabling sjavac" >&5
 
       
 50012 $as_echo "$as_me: WARNING: Could not set -Xms${MS_VALUE}M -Xmx${MX_VALUE}M, disabling sjavac" >&2;}
 
       
 50013     ENABLE_SJAVAC=no;
 
       
 50014   fi
 
       
 50015   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to use sjavac" >&5
 
       
 50016 $as_echo_n "checking whether to use sjavac... " >&6; }
 
 50123   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ENABLE_SJAVAC" >&5
 
 50017   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ENABLE_SJAVAC" >&5
 
 50124 $as_echo "$ENABLE_SJAVAC" >&6; }
 
 50018 $as_echo "$ENABLE_SJAVAC" >&6; }
 
 50125 
 50019 
 50126 
 50020 
 50127   if test "x$ENABLE_SJAVAC" = xyes; then
 
 50021   if test "x$ENABLE_SJAVAC" = xyes; then
jdk-sandbox