#!/bin/bash # # Runner for an individual run-test. if [[ -z "$ANDROID_BUILD_TOP" ]]; then echo 'ANDROID_BUILD_TOP environment variable is empty; did you forget to run `lunch`?' exit 1 fi msg() { if [ "$QUIET" = "n" ]; then echo "$@" fi } ANDROID_ROOT="/system" ANDROID_ART_ROOT="/apex/com.android.art" ANDROID_I18N_ROOT="/apex/com.android.i18n" ANDROID_TZDATA_ROOT="/apex/com.android.tzdata" ARCHITECTURES_32="(arm|x86|none)" ARCHITECTURES_64="(arm64|x86_64|none)" ARCHITECTURES_PATTERN="${ARCHITECTURES_32}" GET_DEVICE_ISA_BITNESS_FLAG="--32" BOOT_IMAGE="" CHROOT= COMPILE_FLAGS="" DALVIKVM="dalvikvm32" DEBUGGER="n" WITH_AGENT=() DEBUGGER_AGENT="" WRAP_DEBUGGER_AGENT="n" DEV_MODE="n" DEX2OAT_NDEBUG_BINARY="dex2oat32" DEX2OAT_DEBUG_BINARY="dex2oatd32" EXPERIMENTAL="" FALSE_BIN="false" FLAGS="" ANDROID_FLAGS="" GDB="" GDB_ARGS="" GDBSERVER_DEVICE="gdbserver" GDBSERVER_HOST="gdbserver" HAVE_IMAGE="y" HOST="n" BIONIC="n" CREATE_ANDROID_ROOT="n" USE_ZIPAPEX="n" ZIPAPEX_LOC="" USE_EXTRACTED_ZIPAPEX="n" EXTRACTED_ZIPAPEX_LOC="" INTERPRETER="n" JIT="n" INVOKE_WITH="" IS_JVMTI_TEST="n" ADD_LIBDIR_ARGUMENTS="n" ISA=x86 LIBRARY_DIRECTORY="lib" TEST_DIRECTORY="nativetest" MAIN="" OPTIMIZE="y" PREBUILD="y" QUIET="n" RELOCATE="n" STRIP_DEX="n" SECONDARY_DEX="" TIME_OUT="n" # "n" (disabled), "timeout" (use timeout), "gdb" (use gdb) TIMEOUT_DUMPER=signal_dumper # Values in seconds. TIME_OUT_EXTRA=0 TIME_OUT_VALUE= USE_GDB="n" USE_GDBSERVER="n" GDBSERVER_PORT=":5039" USE_JVM="n" USE_JVMTI="n" VERIFY="y" # y=yes,n=no,s=softfail ZYGOTE="" DEX_VERIFY="" INSTRUCTION_SET_FEATURES="" ARGS="" VDEX_ARGS="" EXTERNAL_LOG_TAGS="n" # if y respect externally set ANDROID_LOG_TAGS. DRY_RUN="n" # if y prepare to run the test but don't run it. TEST_VDEX="n" TEST_DM="n" TEST_IS_NDEBUG="n" APP_IMAGE="y" JVMTI_STRESS="n" JVMTI_STEP_STRESS="n" JVMTI_FIELD_STRESS="n" JVMTI_TRACE_STRESS="n" JVMTI_REDEFINE_STRESS="n" PROFILE="n" RANDOM_PROFILE="n" # The normal dex2oat timeout. DEX2OAT_TIMEOUT="300" # 5 mins # The *hard* timeout where we really start trying to kill the dex2oat. DEX2OAT_RT_TIMEOUT="360" # 6 mins CREATE_RUNNER="n" # if "y", run 'sync' before dalvikvm to make sure all files from # build step (e.g. dex2oat) were finished writing. SYNC_BEFORE_RUN="n" # When running a debug build, we want to run with all checks. ANDROID_FLAGS="${ANDROID_FLAGS} -XX:SlowDebug=true" # The same for dex2oatd, both prebuild and runtime-driven. ANDROID_FLAGS="${ANDROID_FLAGS} -Xcompiler-option --runtime-arg -Xcompiler-option -XX:SlowDebug=true" COMPILER_FLAGS="${COMPILER_FLAGS} --runtime-arg -XX:SlowDebug=true" while true; do if [ "x$1" = "x--quiet" ]; then QUIET="y" shift elif [ "x$1" = "x--dex2oat-rt-timeout" ]; then shift if [ "x$1" = "x" ]; then echo "$0 missing argument to --dex2oat-rt-timeout" 1>&2 exit 1 fi DEX2OAT_RT_TIMEOUT="$1" shift elif [ "x$1" = "x--dex2oat-timeout" ]; then shift if [ "x$1" = "x" ]; then echo "$0 missing argument to --dex2oat-timeout" 1>&2 exit 1 fi DEX2OAT_TIMEOUT="$1" shift elif [ "x$1" = "x--jvmti" ]; then USE_JVMTI="y" IS_JVMTI_TEST="y" shift elif [ "x$1" = "x--add-libdir-argument" ]; then ADD_LIBDIR_ARGUMENTS="y" shift elif [ "x$1" = "x-O" ]; then TEST_IS_NDEBUG="y" shift elif [ "x$1" = "x--lib" ]; then shift if [ "x$1" = "x" ]; then echo "$0 missing argument to --lib" 1>&2 exit 1 fi LIB="$1" shift elif [ "x$1" = "x--gc-stress" ]; then # Give an extra 20 mins if we are gc-stress. TIME_OUT_EXTRA=$((${TIME_OUT_EXTRA} + 1200)) shift elif [ "x$1" = "x--testlib" ]; then shift if [ "x$1" = "x" ]; then echo "$0 missing argument to --testlib" 1>&2 exit 1 fi ARGS="${ARGS} $1" shift elif [ "x$1" = "x--args" ]; then shift if [ "x$1" = "x" ]; then echo "$0 missing argument to --args" 1>&2 exit 1 fi ARGS="${ARGS} $1" shift elif [ "x$1" = "x--compiler-only-option" ]; then shift option="$1" COMPILE_FLAGS="${COMPILE_FLAGS} $option" shift elif [ "x$1" = "x-Xcompiler-option" ]; then shift option="$1" FLAGS="${FLAGS} -Xcompiler-option $option" COMPILE_FLAGS="${COMPILE_FLAGS} $option" shift elif [ "x$1" = "x--create-runner" ]; then CREATE_RUNNER="y" shift elif [ "x$1" = "x--android-runtime-option" ]; then shift option="$1" ANDROID_FLAGS="${ANDROID_FLAGS} $option" shift elif [ "x$1" = "x--runtime-option" ]; then shift option="$1" FLAGS="${FLAGS} $option" if [ "x$option" = "x-Xmethod-trace" ]; then # Method tracing can slow some tests down a lot, in particular # 530-checker-lse2. TIME_OUT_EXTRA=$((${TIME_OUT_EXTRA} + 1200)) fi shift elif [ "x$1" = "x--boot" ]; then shift BOOT_IMAGE="$1" shift elif [ "x$1" = "x--relocate" ]; then RELOCATE="y" shift elif [ "x$1" = "x--no-relocate" ]; then RELOCATE="n" shift elif [ "x$1" = "x--prebuild" ]; then PREBUILD="y" shift elif [ "x$1" = "x--compact-dex-level" ]; then shift COMPILE_FLAGS="${COMPILE_FLAGS} --compact-dex-level=$1" shift elif [ "x$1" = "x--jvmti-redefine-stress" ]; then # APP_IMAGE doesn't really work with jvmti redefine stress USE_JVMTI="y" APP_IMAGE="n" JVMTI_STRESS="y" JVMTI_REDEFINE_STRESS="y" shift elif [ "x$1" = "x--jvmti-step-stress" ]; then USE_JVMTI="y" JVMTI_STRESS="y" JVMTI_STEP_STRESS="y" shift elif [ "x$1" = "x--jvmti-field-stress" ]; then USE_JVMTI="y" JVMTI_STRESS="y" JVMTI_FIELD_STRESS="y" shift elif [ "x$1" = "x--jvmti-trace-stress" ]; then USE_JVMTI="y" JVMTI_STRESS="y" JVMTI_TRACE_STRESS="y" shift elif [ "x$1" = "x--no-app-image" ]; then APP_IMAGE="n" shift elif [ "x$1" = "x--strip-dex" ]; then STRIP_DEX="y" shift elif [ "x$1" = "x--host" ]; then HOST="y" ANDROID_ROOT="${ANDROID_HOST_OUT}" ANDROID_ART_ROOT="${ANDROID_HOST_OUT}/com.android.art" ANDROID_I18N_ROOT="${ANDROID_HOST_OUT}/com.android.i18n" ANDROID_TZDATA_ROOT="${ANDROID_HOST_OUT}/com.android.tzdata" # On host, we default to using the symlink, as the PREFER_32BIT # configuration is the only configuration building a 32bit version of # dex2oat. DEX2OAT_DEBUG_BINARY="dex2oatd" DEX2OAT_NDEBUG_BINARY="dex2oat" shift elif [ "x$1" = "x--bionic" ]; then BIONIC="y" # We need to create an ANDROID_ROOT because currently we cannot create # the frameworks/libcore with linux_bionic so we need to use the normal # host ones which are in a different location. CREATE_ANDROID_ROOT="y" shift elif [ "x$1" = "x--runtime-extracted-zipapex" ]; then shift USE_EXTRACTED_ZIPAPEX="y" EXTRACTED_ZIPAPEX_LOC="$1" shift elif [ "x$1" = "x--runtime-zipapex" ]; then shift USE_ZIPAPEX="y" ZIPAPEX_LOC="$1" # TODO (b/119942078): Currently apex does not support # symlink_preferred_arch so we will not have a dex2oatd to execute and # need to manually provide # dex2oatd64. DEX2OAT_DEBUG_BINARY="dex2oatd64" shift elif [ "x$1" = "x--no-prebuild" ]; then PREBUILD="n" shift elif [ "x$1" = "x--no-image" ]; then HAVE_IMAGE="n" shift elif [ "x$1" = "x--secondary" ]; then SECONDARY_DEX=":$DEX_LOCATION/$TEST_NAME-ex.jar" # Enable cfg-append to make sure we get the dump for both dex files. # (otherwise the runtime compilation of the secondary dex will overwrite # the dump of the first one). FLAGS="${FLAGS} -Xcompiler-option --dump-cfg-append" COMPILE_FLAGS="${COMPILE_FLAGS} --dump-cfg-append" shift elif [ "x$1" = "x--with-agent" ]; then shift USE_JVMTI="y" WITH_AGENT+=("$1") shift elif [ "x$1" = "x--debug-wrap-agent" ]; then WRAP_DEBUGGER_AGENT="y" shift elif [ "x$1" = "x--debug-agent" ]; then shift DEBUGGER="agent" USE_JVMTI="y" DEBUGGER_AGENT="$1" TIME_OUT="n" shift elif [ "x$1" = "x--debug" ]; then USE_JVMTI="y" DEBUGGER="y" TIME_OUT="n" shift elif [ "x$1" = "x--gdbserver-port" ]; then shift GDBSERVER_PORT=$1 shift elif [ "x$1" = "x--gdbserver-bin" ]; then shift GDBSERVER_HOST=$1 GDBSERVER_DEVICE=$1 shift elif [ "x$1" = "x--gdbserver" ]; then USE_GDBSERVER="y" DEV_MODE="y" TIME_OUT="n" shift elif [ "x$1" = "x--gdb" ]; then USE_GDB="y" DEV_MODE="y" TIME_OUT="n" shift elif [ "x$1" = "x--gdb-arg" ]; then shift gdb_arg="$1" GDB_ARGS="${GDB_ARGS} $gdb_arg" shift elif [ "x$1" = "x--zygote" ]; then ZYGOTE="-Xzygote" msg "Spawning from zygote" shift elif [ "x$1" = "x--dev" ]; then DEV_MODE="y" shift elif [ "x$1" = "x--interpreter" ]; then INTERPRETER="y" shift elif [ "x$1" = "x--jit" ]; then JIT="y" shift elif [ "x$1" = "x--baseline" ]; then FLAGS="${FLAGS} -Xcompiler-option --baseline" COMPILE_FLAGS="${COMPILE_FLAGS} --baseline" shift elif [ "x$1" = "x--jvm" ]; then USE_JVM="y" shift elif [ "x$1" = "x--invoke-with" ]; then shift if [ "x$1" = "x" ]; then echo "$0 missing argument to --invoke-with" 1>&2 exit 1 fi if [ "x$INVOKE_WITH" = "x" ]; then INVOKE_WITH="$1" else INVOKE_WITH="$INVOKE_WITH $1" fi shift elif [ "x$1" = "x--no-verify" ]; then VERIFY="n" shift elif [ "x$1" = "x--verify-soft-fail" ]; then VERIFY="s" shift elif [ "x$1" = "x--no-optimize" ]; then OPTIMIZE="n" shift elif [ "x$1" = "x--chroot" ]; then shift CHROOT="$1" shift elif [ "x$1" = "x--android-root" ]; then shift ANDROID_ROOT="$1" shift elif [ "x$1" = "x--android-i18n-root" ]; then shift ANDROID_I18N_ROOT="$1" shift elif [ "x$1" = "x--android-art-root" ]; then shift ANDROID_ART_ROOT="$1" shift elif [ "x$1" = "x--android-tzdata-root" ]; then shift ANDROID_TZDATA_ROOT="$1" shift elif [ "x$1" = "x--instruction-set-features" ]; then shift INSTRUCTION_SET_FEATURES="$1" shift elif [ "x$1" = "x--timeout" ]; then shift TIME_OUT_VALUE="$1" shift elif [ "x$1" = "x--" ]; then shift break elif [ "x$1" = "x--64" ]; then ISA="x86_64" GDBSERVER_DEVICE="gdbserver64" DALVIKVM="dalvikvm64" LIBRARY_DIRECTORY="lib64" TEST_DIRECTORY="nativetest64" ARCHITECTURES_PATTERN="${ARCHITECTURES_64}" GET_DEVICE_ISA_BITNESS_FLAG="--64" DEX2OAT_NDEBUG_BINARY="dex2oat64" DEX2OAT_DEBUG_BINARY="dex2oatd64" shift elif [ "x$1" = "x--experimental" ]; then if [ "$#" -lt 2 ]; then echo "missing --experimental option" 1>&2 exit 1 fi EXPERIMENTAL="$EXPERIMENTAL $2" shift 2 elif [ "x$1" = "x--external-log-tags" ]; then EXTERNAL_LOG_TAGS="y" shift elif [ "x$1" = "x--dry-run" ]; then DRY_RUN="y" shift elif [ "x$1" = "x--vdex" ]; then TEST_VDEX="y" shift elif [ "x$1" = "x--dm" ]; then TEST_DM="y" shift elif [ "x$1" = "x--vdex-filter" ]; then shift option="$1" VDEX_ARGS="${VDEX_ARGS} --compiler-filter=$option" shift elif [ "x$1" = "x--vdex-arg" ]; then shift VDEX_ARGS="${VDEX_ARGS} $1" shift elif [ "x$1" = "x--sync" ]; then SYNC_BEFORE_RUN="y" shift elif [ "x$1" = "x--profile" ]; then PROFILE="y" shift elif [ "x$1" = "x--random-profile" ]; then RANDOM_PROFILE="y" shift elif expr "x$1" : "x--" >/dev/null 2>&1; then echo "unknown $0 option: $1" 1>&2 exit 1 else break fi done # HACK: Force the use of `signal_dumper` on host. if [[ "$HOST" = "y" ]]; then TIME_OUT="timeout" fi # If you change this, update the timeout in testrunner.py as well. if [ -z "$TIME_OUT_VALUE" ] ; then # 10 minutes is the default. TIME_OUT_VALUE=600 # For sanitized builds use a larger base. # TODO: Consider sanitized target builds? if [ "x$SANITIZE_HOST" != "x" ] ; then TIME_OUT_VALUE=1500 # 25 minutes. fi TIME_OUT_VALUE=$((${TIME_OUT_VALUE} + ${TIME_OUT_EXTRA})) fi # Escape hatch for slow hosts or devices. Accept an environment variable as a timeout factor. if [ ! -z "$ART_TIME_OUT_MULTIPLIER" ] ; then TIME_OUT_VALUE=$((${TIME_OUT_VALUE} * ${ART_TIME_OUT_MULTIPLIER})) fi # The DEX_LOCATION with the chroot prefix, if any. CHROOT_DEX_LOCATION="$CHROOT$DEX_LOCATION" # If running on device, determine the ISA of the device. if [ "$HOST" = "n" ]; then ISA=$("$ANDROID_BUILD_TOP/art/test/utils/get-device-isa" "$GET_DEVICE_ISA_BITNESS_FLAG") fi if [ "$USE_JVM" = "n" ]; then FLAGS="${FLAGS} ${ANDROID_FLAGS}" # we don't want to be trying to get adbconnections since the plugin might # not have been built. FLAGS="${FLAGS} -XjdwpProvider:none" for feature in ${EXPERIMENTAL}; do FLAGS="${FLAGS} -Xexperimental:${feature} -Xcompiler-option --runtime-arg -Xcompiler-option -Xexperimental:${feature}" COMPILE_FLAGS="${COMPILE_FLAGS} --runtime-arg -Xexperimental:${feature}" done fi if [ "$CREATE_ANDROID_ROOT" = "y" ]; then ANDROID_ROOT=$DEX_LOCATION/android-root fi if [ "x$1" = "x" ] ; then MAIN="Main" else MAIN="$1" shift fi if [ "$ZYGOTE" = "" ]; then if [ "$OPTIMIZE" = "y" ]; then if [ "$VERIFY" = "y" ]; then DEX_OPTIMIZE="-Xdexopt:verified" else DEX_OPTIMIZE="-Xdexopt:all" fi msg "Performing optimizations" else DEX_OPTIMIZE="-Xdexopt:none" msg "Skipping optimizations" fi if [ "$VERIFY" = "y" ]; then JVM_VERIFY_ARG="-Xverify:all" msg "Performing verification" elif [ "$VERIFY" = "s" ]; then JVM_VERIFY_ARG="Xverify:all" DEX_VERIFY="-Xverify:softfail" msg "Forcing verification to be soft fail" else # VERIFY = "n" DEX_VERIFY="-Xverify:none" JVM_VERIFY_ARG="-Xverify:none" msg "Skipping verification" fi fi msg "------------------------------" if [ "$DEBUGGER" = "y" ]; then # Use this instead for ddms and connect by running 'ddms': # DEBUGGER_OPTS="-XjdwpOptions=server=y,suspend=y -XjdwpProvider:adbconnection" # TODO: add a separate --ddms option? PORT=12345 msg "Waiting for jdb to connect:" if [ "$HOST" = "n" ]; then msg " adb forward tcp:$PORT tcp:$PORT" fi msg " jdb -attach localhost:$PORT" if [ "$USE_JVM" = "n" ]; then # Use the default libjdwp agent. Use --debug-agent to use a custom one. DEBUGGER_OPTS="-agentpath:libjdwp.so=transport=dt_socket,address=$PORT,server=y,suspend=y -XjdwpProvider:internal" else DEBUGGER_OPTS="-agentlib:jdwp=transport=dt_socket,address=$PORT,server=y,suspend=y" fi elif [ "$DEBUGGER" = "agent" ]; then PORT=12345 # TODO Support ddms connection and support target. if [ "$HOST" = "n" ]; then echo "--debug-agent not supported yet for target!" exit 1 fi AGENTPATH=${DEBUGGER_AGENT} if [ "$WRAP_DEBUGGER_AGENT" = "y" ]; then WRAPPROPS="${ANDROID_ROOT}/${LIBRARY_DIRECTORY}/libwrapagentpropertiesd.so" if [ "$TEST_IS_NDEBUG" = "y" ]; then WRAPPROPS="${ANDROID_ROOT}/${LIBRARY_DIRECTORY}/libwrapagentproperties.so" fi AGENTPATH="${WRAPPROPS}=${ANDROID_BUILD_TOP}/art/tools/libjdwp-compat.props,${AGENTPATH}" fi msg "Connect to localhost:$PORT" DEBUGGER_OPTS="-agentpath:${AGENTPATH}=transport=dt_socket,address=$PORT,server=y,suspend=y" fi for agent in "${WITH_AGENT[@]}"; do FLAGS="${FLAGS} -agentpath:${agent}" done if [ "$USE_JVMTI" = "y" ]; then if [ "$USE_JVM" = "n" ]; then plugin=libopenjdkjvmtid.so if [[ "$TEST_IS_NDEBUG" = "y" ]]; then plugin=libopenjdkjvmti.so fi # We used to add flags here that made the runtime debuggable but that is not # needed anymore since the plugin can do it for us now. FLAGS="${FLAGS} -Xplugin:${plugin}" fi fi # Add the libdir to the argv passed to the main function. if [ "$ADD_LIBDIR_ARGUMENTS" = "y" ]; then if [[ "$HOST" = "y" ]]; then ARGS="${ARGS} ${ANDROID_HOST_OUT}/${TEST_DIRECTORY}/" else ARGS="${ARGS} /data/${TEST_DIRECTORY}/art/${ISA}/" fi fi if [ "$IS_JVMTI_TEST" = "y" ]; then agent=libtiagentd.so lib=tiagentd if [[ "$TEST_IS_NDEBUG" = "y" ]]; then agent=libtiagent.so lib=tiagent fi ARGS="${ARGS} ${lib}" if [[ "$USE_JVM" = "y" ]]; then FLAGS="${FLAGS} -agentpath:${ANDROID_HOST_OUT}/nativetest64/${agent}=${TEST_NAME},jvm" else if [[ "$HOST" = "y" ]]; then FLAGS="${FLAGS} -agentpath:${agent}=${TEST_NAME},art" else # The linker configuration used for dalvikvm(64) in the ART APEX # requires us to pass the full path to the agent to the runtime when # running on device. FLAGS="${FLAGS} -agentpath:/data/${TEST_DIRECTORY}/art/${ISA}/${agent}=${TEST_NAME},art" fi fi fi if [[ "$JVMTI_STRESS" = "y" ]]; then agent=libtistressd.so if [[ "$TEST_IS_NDEBUG" = "y" ]]; then agent=libtistress.so fi # Just give it a default start so we can always add ',' to it. agent_args="jvmti-stress" if [[ "$JVMTI_REDEFINE_STRESS" = "y" ]]; then # We really cannot do this on RI so don't both passing it in that case. if [[ "$USE_JVM" = "n" ]]; then agent_args="${agent_args},redefine" fi fi if [[ "$JVMTI_FIELD_STRESS" = "y" ]]; then agent_args="${agent_args},field" fi if [[ "$JVMTI_STEP_STRESS" = "y" ]]; then agent_args="${agent_args},step" fi if [[ "$JVMTI_TRACE_STRESS" = "y" ]]; then agent_args="${agent_args},trace" fi # In the future add onto this; if [[ "$USE_JVM" = "y" ]]; then FLAGS="${FLAGS} -agentpath:${ANDROID_HOST_OUT}/nativetest64/${agent}=${agent_args}" else if [[ "$HOST" = "y" ]]; then FLAGS="${FLAGS} -agentpath:${agent}=${agent_args}" else # The linker configuration used for dalvikvm(64) in the ART APEX # requires us to pass the full path to the agent to the runtime when # running on device. FLAGS="${FLAGS} -agentpath:/data/${TEST_DIRECTORY}/art/${ISA}/${agent}=${agent_args}" fi fi fi if [ "$USE_JVM" = "y" ]; then export LD_LIBRARY_PATH=${ANDROID_HOST_OUT}/lib64 # Some jvmti tests are flaky without -Xint on the RI. if [ "$IS_JVMTI_TEST" = "y" ]; then FLAGS="${FLAGS} -Xint" fi # Xmx is necessary since we don't pass down the ART flags to JVM. # We pass the classes2 path whether it's used (src-multidex) or not. cmdline="${JAVA} ${DEBUGGER_OPTS} ${JVM_VERIFY_ARG} -Xmx256m -classpath classes:classes2 ${FLAGS} $MAIN $@ ${ARGS}" if [ "$DEV_MODE" = "y" ]; then echo $cmdline fi if [ "$CREATE_RUNNER" = "y" ]; then echo "#!/bin/bash" > runit.sh echo "export LD_LIBRARY_PATH=\"$LD_LIBRARY_PATH\"" echo $cmdline "2>&1" >> runit.sh chmod u+x runit.sh echo "Runnable test script written to $PWD/runit.sh" else $cmdline fi exit fi # Note: This must start with the CORE_IMG_JARS in Android.common_path.mk # because that's what we use for compiling the core.art image. # It may contain additional modules from TEST_CORE_JARS. bpath_modules="core-oj core-libart core-icu4j okhttp bouncycastle apache-xml conscrypt" if [ "${HOST}" = "y" ]; then framework="${ANDROID_HOST_OUT}/framework" if [ "${ANDROID_HOST_OUT:0:${#ANDROID_BUILD_TOP}+1}" = "${ANDROID_BUILD_TOP}/" ]; then framework_location="${ANDROID_HOST_OUT:${#ANDROID_BUILD_TOP}+1}/framework" else echo "error: ANDROID_BUILD_TOP/ is not a prefix of ANDROID_HOST_OUT" echo "ANDROID_BUILD_TOP=${ANDROID_BUILD_TOP}" echo "ANDROID_HOST_OUT=${ANDROID_HOST_OUT}" exit fi bpath_suffix="-hostdex" else framework="${ANDROID_ROOT}/framework" framework_location="${ANDROID_ROOT}/framework" bpath_suffix="-testdex" fi bpath="" bpath_locations="" bpath_separator="" for bpath_module in ${bpath_modules}; do bpath+="${bpath_separator}${framework}/${bpath_module}${bpath_suffix}.jar" bpath_locations+="${bpath_separator}${framework_location}/${bpath_module}${bpath_suffix}.jar" bpath_separator=":" done # Pass down the bootclasspath FLAGS="${FLAGS} -Xbootclasspath:${bpath}" FLAGS="${FLAGS} -Xbootclasspath-locations:${bpath_locations}" COMPILE_FLAGS="${COMPILE_FLAGS} --runtime-arg -Xbootclasspath:${bpath}" COMPILE_FLAGS="${COMPILE_FLAGS} --runtime-arg -Xbootclasspath-locations:${bpath_locations}" if [ "$HAVE_IMAGE" = "n" ]; then # Disable image dex2oat - this will forbid the runtime to patch or compile an image. FLAGS="${FLAGS} -Xnoimage-dex2oat" # We'll abuse a second flag here to test different behavior. If --relocate, use the # existing image - relocation will fail as patching is disallowed. If --no-relocate, # pass a non-existent image - compilation will fail as dex2oat is disallowed. if [ "${RELOCATE}" = "y" ] ; then DALVIKVM_BOOT_OPT="-Ximage:${BOOT_IMAGE}" else DALVIKVM_BOOT_OPT="-Ximage:/system/non-existent/core.art" fi else DALVIKVM_BOOT_OPT="-Ximage:${BOOT_IMAGE}" fi if [ "$USE_GDB" = "y" ]; then if [ "$USE_GDBSERVER" = "y" ]; then echo "Cannot pass both --gdb and --gdbserver at the same time!" >&2 exit 1 elif [ "$HOST" = "n" ]; then # We might not have any hostname resolution if we are using a chroot. GDB="$GDBSERVER_DEVICE --no-startup-with-shell 127.0.0.1$GDBSERVER_PORT" else if [ `uname` = "Darwin" ]; then GDB=lldb GDB_ARGS="$GDB_ARGS -- $DALVIKVM" DALVIKVM= else GDB=gdb GDB_ARGS="$GDB_ARGS --args $DALVIKVM" # Enable for Emacs "M-x gdb" support. TODO: allow extra gdb arguments on command line. # gdbargs="--annotate=3 $gdbargs" fi fi elif [ "$USE_GDBSERVER" = "y" ]; then if [ "$HOST" = "n" ]; then # We might not have any hostname resolution if we are using a chroot. GDB="$GDBSERVER_DEVICE --no-startup-with-shell 127.0.0.1$GDBSERVER_PORT" else GDB="$GDBSERVER_HOST $GDBSERVER_PORT" fi fi if [ "$INTERPRETER" = "y" ]; then INT_OPTS="${INT_OPTS} -Xint" if [ "$VERIFY" = "y" ] ; then INT_OPTS="${INT_OPTS} -Xcompiler-option --compiler-filter=quicken" COMPILE_FLAGS="${COMPILE_FLAGS} --compiler-filter=quicken" elif [ "$VERIFY" = "s" ]; then INT_OPTS="${INT_OPTS} -Xcompiler-option --compiler-filter=extract" COMPILE_FLAGS="${COMPILE_FLAGS} --compiler-filter=extract" DEX_VERIFY="${DEX_VERIFY} -Xverify:softfail" else # VERIFY = "n" INT_OPTS="${INT_OPTS} -Xcompiler-option --compiler-filter=assume-verified" COMPILE_FLAGS="${COMPILE_FLAGS} --compiler-filter=assume-verified" DEX_VERIFY="${DEX_VERIFY} -Xverify:none" fi fi if [ "$JIT" = "y" ]; then INT_OPTS="${INT_OPTS} -Xusejit:true" if [ "$VERIFY" = "y" ] ; then INT_OPTS="${INT_OPTS} -Xcompiler-option --compiler-filter=quicken" COMPILE_FLAGS="${COMPILE_FLAGS} --compiler-filter=quicken" else INT_OPTS="${INT_OPTS} -Xcompiler-option --compiler-filter=assume-verified" COMPILE_FLAGS="${COMPILE_FLAGS} --compiler-filter=assume-verified" DEX_VERIFY="${DEX_VERIFY} -Xverify:none" fi else INT_OPTS="${INT_OPTS} -Xusejit:false" fi JNI_OPTS="-Xjnigreflimit:512 -Xcheck:jni" COMPILE_FLAGS="${COMPILE_FLAGS} --runtime-arg -Xnorelocate" if [ "$RELOCATE" = "y" ]; then FLAGS="${FLAGS} -Xrelocate" else FLAGS="$FLAGS -Xnorelocate" fi if [ "$BIONIC" = "y" ]; then # This is the location that soong drops linux_bionic builds. Despite being # called linux_bionic-x86 the build is actually amd64 (x86_64) only. if [ ! -e "$OUT_DIR/soong/host/linux_bionic-x86" ]; then echo "linux_bionic-x86 target doesn't seem to have been built!" >&2 exit 1 fi # Set TIMEOUT_DUMPER manually so it works even with apex's TIMEOUT_DUMPER=$OUT_DIR/soong/host/linux_bionic-x86/bin/signal_dumper fi # Prevent test from silently falling back to interpreter in no-prebuild mode. This happens # when DEX_LOCATION path is too long, because vdex/odex filename is constructed by taking # full path to dex, stripping leading '/', appending '@classes.vdex' and changing every # remaining '/' into '@'. if [ "$HOST" = "y" ]; then max_filename_size=$(getconf NAME_MAX $DEX_LOCATION) else # There is no getconf on device, fallback to standard value. # See NAME_MAX in kernel max_filename_size=255 fi # Compute VDEX_NAME. DEX_LOCATION_STRIPPED="${DEX_LOCATION#/}" VDEX_NAME="${DEX_LOCATION_STRIPPED//\//@}@$TEST_NAME.jar@classes.vdex" if [ ${#VDEX_NAME} -gt $max_filename_size ]; then echo "Dex location path too long:" echo "$VDEX_NAME is ${#VDEX_NAME} character long, and the limit is $max_filename_size." exit 1 fi if [ "$HOST" = "y" ]; then # On host, run binaries (`dex2oat(d)`, `dalvikvm`, `profman`) from the `bin` # directory under the "Android Root" (usually `out/host/linux-x86`). # # TODO(b/130295968): Adjust this if/when ART host artifacts are installed # under the ART root (usually `out/host/linux-x86/com.android.art`). ANDROID_ART_BIN_DIR=$ANDROID_ROOT/bin else # On target, run binaries (`dex2oat(d)`, `dalvikvm`, `profman`) from the ART # APEX's `bin` directory. This means the linker will observe the ART APEX # linker configuration file (`/apex/com.android.art/etc/ld.config.txt`) for # these binaries. ANDROID_ART_BIN_DIR=$ANDROID_ART_ROOT/bin fi profman_cmdline="true" dex2oat_cmdline="true" vdex_cmdline="true" dm_cmdline="true" mkdir_locations="${DEX_LOCATION}/dalvik-cache/$ISA" strip_cmdline="true" sync_cmdline="true" linkroot_cmdline="true" linkroot_overlay_cmdline="true" setupapex_cmdline="true" installapex_cmdline="true" linkdirs() { find "$1" -maxdepth 1 -mindepth 1 -type d | xargs -i ln -sf '{}' "$2" } if [ "$CREATE_ANDROID_ROOT" = "y" ]; then mkdir_locations="${mkdir_locations} ${ANDROID_ROOT}" linkroot_cmdline="linkdirs ${ANDROID_HOST_OUT} ${ANDROID_ROOT}" if [ "${BIONIC}" = "y" ]; then # TODO Make this overlay more generic. linkroot_overlay_cmdline="linkdirs $OUT_DIR/soong/host/linux_bionic-x86 ${ANDROID_ROOT}" fi fi if [ "$USE_ZIPAPEX" = "y" ]; then # TODO Currently this only works for linux_bionic zipapexes because those are # stripped and so small enough that the ulimit doesn't kill us. mkdir_locations="${mkdir_locations} $DEX_LOCATION/zipapex" zip_options="-qq" if [ "$DEV_MODE" = "y" ]; then zip_options="" fi setupapex_cmdline="unzip -o -u ${zip_options} ${ZIPAPEX_LOC} apex_payload.zip -d ${DEX_LOCATION}" installapex_cmdline="unzip -o -u ${zip_options} ${DEX_LOCATION}/apex_payload.zip -d ${DEX_LOCATION}/zipapex" ANDROID_ART_BIN_DIR=$DEX_LOCATION/zipapex/bin elif [ "$USE_EXTRACTED_ZIPAPEX" = "y" ]; then # Just symlink the zipapex binaries ANDROID_ART_BIN_DIR=$DEX_LOCATION/zipapex/bin # Force since some tests manually run this file twice. ln_options="" if [ "$DEV_MODE" = "y" ]; then ln_options="--verbose" fi installapex_cmdline="ln -s -f ${ln_options} ${EXTRACTED_ZIPAPEX_LOC} ${DEX_LOCATION}/zipapex" fi # PROFILE takes precedence over RANDOM_PROFILE, since PROFILE tests require a # specific profile to run properly. if [ "$PROFILE" = "y" ] || [ "$RANDOM_PROFILE" = "y" ]; then profman_cmdline="$ANDROID_ART_BIN_DIR/profman \ --apk=$DEX_LOCATION/$TEST_NAME.jar \ --dex-location=$DEX_LOCATION/$TEST_NAME.jar" if [ -f $DEX_LOCATION/$TEST_NAME-ex.jar ]; then profman_cmdline="${profman_cmdline} \ --apk=$DEX_LOCATION/$TEST_NAME-ex.jar \ --dex-location=$DEX_LOCATION/$TEST_NAME-ex.jar" fi COMPILE_FLAGS="${COMPILE_FLAGS} --profile-file=$DEX_LOCATION/$TEST_NAME.prof" FLAGS="${FLAGS} -Xcompiler-option --profile-file=$DEX_LOCATION/$TEST_NAME.prof" if [ "$PROFILE" = "y" ]; then profman_cmdline="${profman_cmdline} --create-profile-from=$DEX_LOCATION/profile \ --reference-profile-file=$DEX_LOCATION/$TEST_NAME.prof" else profman_cmdline="${profman_cmdline} --generate-test-profile=$DEX_LOCATION/$TEST_NAME.prof \ --generate-test-profile-seed=0" fi fi # Enable mini-debug-info for JIT (if JIT is used). FLAGS="$FLAGS -Xcompiler-option --generate-mini-debug-info" if [ "$PREBUILD" = "y" ]; then mkdir_locations="${mkdir_locations} ${DEX_LOCATION}/oat/$ISA" if [ "$APP_IMAGE" = "y" ]; then # Pick a base that will force the app image to get relocated. app_image="--app-image-file=$DEX_LOCATION/oat/$ISA/$TEST_NAME.art --resolve-startup-const-strings=true" fi dex2oat_binary=${DEX2OAT_DEBUG_BINARY} if [[ "$TEST_IS_NDEBUG" = "y" ]]; then dex2oat_binary=${DEX2OAT_NDEBUG_BINARY} fi dex2oat_cmdline="$INVOKE_WITH $ANDROID_ART_BIN_DIR/$dex2oat_binary \ $COMPILE_FLAGS \ --boot-image=${BOOT_IMAGE} \ --dex-file=$DEX_LOCATION/$TEST_NAME.jar \ --oat-file=$DEX_LOCATION/oat/$ISA/$TEST_NAME.odex \ ${app_image} \ --generate-mini-debug-info \ --instruction-set=$ISA" if [ "x$INSTRUCTION_SET_FEATURES" != "x" ] ; then dex2oat_cmdline="${dex2oat_cmdline} --instruction-set-features=${INSTRUCTION_SET_FEATURES}" fi # Add in a timeout. This is important for testing the compilation/verification time of # pathological cases. # Note: as we don't know how decent targets are (e.g., emulator), only do this on the host for # now. We should try to improve this. # The current value is rather arbitrary. run-tests should compile quickly. # Watchdog timeout is in milliseconds so add 3 '0's to the dex2oat timeout. if [ "$HOST" != "n" ]; then # Use SIGRTMIN+2 to try to dump threads. # Use -k 1m to SIGKILL it a minute later if it hasn't ended. dex2oat_cmdline="timeout -k ${DEX2OAT_TIMEOUT}s -s SIGRTMIN+2 ${DEX2OAT_RT_TIMEOUT}s ${dex2oat_cmdline} --watchdog-timeout=${DEX2OAT_TIMEOUT}000" fi if [ "$PROFILE" = "y" ] || [ "$RANDOM_PROFILE" = "y" ]; then vdex_cmdline="${dex2oat_cmdline} ${VDEX_ARGS} --input-vdex=$DEX_LOCATION/oat/$ISA/$TEST_NAME.vdex --output-vdex=$DEX_LOCATION/oat/$ISA/$TEST_NAME.vdex" elif [ "$TEST_VDEX" = "y" ]; then vdex_cmdline="${dex2oat_cmdline} ${VDEX_ARGS} --input-vdex=$DEX_LOCATION/oat/$ISA/$TEST_NAME.vdex" elif [ "$TEST_DM" = "y" ]; then dex2oat_cmdline="${dex2oat_cmdline} --output-vdex=$DEX_LOCATION/oat/$ISA/primary.vdex" dm_cmdline="zip -qj $DEX_LOCATION/oat/$ISA/$TEST_NAME.dm $DEX_LOCATION/oat/$ISA/primary.vdex" vdex_cmdline="${dex2oat_cmdline} ${VDEX_ARGS} --dump-timings --dm-file=$DEX_LOCATION/oat/$ISA/$TEST_NAME.dm" elif [ "$PROFILE" = "y" ] || [ "$RANDOM_PROFILE" = "y" ]; then vdex_cmdline="${dex2oat_cmdline} --input-vdex=$DEX_LOCATION/oat/$ISA/$TEST_NAME.vdex --output-vdex=$DEX_LOCATION/oat/$ISA/$TEST_NAME.vdex" fi fi if [ "$STRIP_DEX" = "y" ]; then strip_cmdline="zip --quiet --delete $DEX_LOCATION/$TEST_NAME.jar classes.dex" fi if [ "$SYNC_BEFORE_RUN" = "y" ]; then sync_cmdline="sync" fi DALVIKVM_ISA_FEATURES_ARGS="" if [ "x$INSTRUCTION_SET_FEATURES" != "x" ] ; then DALVIKVM_ISA_FEATURES_ARGS="-Xcompiler-option --instruction-set-features=${INSTRUCTION_SET_FEATURES}" fi # java.io.tmpdir can only be set at launch time. TMP_DIR_OPTION="" if [ "$HOST" = "n" ]; then TMP_DIR_OPTION="-Djava.io.tmpdir=/data/local/tmp" fi # The build servers have an ancient version of bash so we cannot use @Q. if [ "$USE_GDBSERVER" == "y" ]; then printf -v QUOTED_DALVIKVM_BOOT_OPT "%q" "$DALVIKVM_BOOT_OPT" else QUOTED_DALVIKVM_BOOT_OPT="$DALVIKVM_BOOT_OPT" fi # We set DumpNativeStackOnSigQuit to false to avoid stressing libunwind. # b/27185632 # b/24664297 dalvikvm_cmdline="$INVOKE_WITH $GDB $ANDROID_ART_BIN_DIR/$DALVIKVM \ $GDB_ARGS \ $FLAGS \ $DEX_VERIFY \ -XXlib:$LIB \ $DEX2OAT \ $DALVIKVM_ISA_FEATURES_ARGS \ $ZYGOTE \ $JNI_OPTS \ $INT_OPTS \ $DEBUGGER_OPTS \ ${QUOTED_DALVIKVM_BOOT_OPT} \ $TMP_DIR_OPTION \ -XX:DumpNativeStackOnSigQuit:false \ -cp $DEX_LOCATION/$TEST_NAME.jar$SECONDARY_DEX $MAIN $ARGS" # Remove whitespace. dex2oat_cmdline=$(echo $dex2oat_cmdline) dalvikvm_cmdline=$(echo $dalvikvm_cmdline) dm_cmdline=$(echo $dm_cmdline) vdex_cmdline=$(echo $vdex_cmdline) profman_cmdline=$(echo $profman_cmdline) # Use an empty ASAN_OPTIONS to enable defaults. # Note: this is required as envsetup right now exports detect_leaks=0. RUN_TEST_ASAN_OPTIONS="" # Multiple shutdown leaks. b/38341789 if [ "x$RUN_TEST_ASAN_OPTIONS" != "x" ] ; then RUN_TEST_ASAN_OPTIONS="${RUN_TEST_ASAN_OPTIONS}:" fi RUN_TEST_ASAN_OPTIONS="${RUN_TEST_ASAN_OPTIONS}detect_leaks=0" # For running, we must turn off logging when dex2oat is missing. Otherwise we use # the same defaults as for prebuilt: everything when --dev, otherwise errors and above only. if [ "$EXTERNAL_LOG_TAGS" = "n" ]; then if [ "$DEV_MODE" = "y" ]; then export ANDROID_LOG_TAGS='*:d' elif [ "$HAVE_IMAGE" = "n" ]; then # All tests would log the error of missing image. Be silent here and only log fatal # events. export ANDROID_LOG_TAGS='*:s' else # We are interested in LOG(ERROR) output. export ANDROID_LOG_TAGS='*:e' fi fi if [ "$HOST" = "n" ]; then adb root > /dev/null adb wait-for-device if [ "$QUIET" = "n" ]; then adb shell rm -rf $CHROOT_DEX_LOCATION adb shell mkdir -p $CHROOT_DEX_LOCATION adb push $TEST_NAME.jar $CHROOT_DEX_LOCATION adb push $TEST_NAME-ex.jar $CHROOT_DEX_LOCATION if [ "$PROFILE" = "y" ] || [ "$RANDOM_PROFILE" = "y" ]; then adb push profile $CHROOT_DEX_LOCATION fi # Copy resource folder if [ -d res ]; then adb push res $CHROOT_DEX_LOCATION fi else adb shell rm -rf $CHROOT_DEX_LOCATION >/dev/null 2>&1 adb shell mkdir -p $CHROOT_DEX_LOCATION >/dev/null 2>&1 adb push $TEST_NAME.jar $CHROOT_DEX_LOCATION >/dev/null 2>&1 adb push $TEST_NAME-ex.jar $CHROOT_DEX_LOCATION >/dev/null 2>&1 if [ "$PROFILE" = "y" ] || [ "$RANDOM_PROFILE" = "y" ]; then adb push profile $CHROOT_DEX_LOCATION >/dev/null 2>&1 fi # Copy resource folder if [ -d res ]; then adb push res $CHROOT_DEX_LOCATION >/dev/null 2>&1 fi fi # Populate LD_LIBRARY_PATH. LD_LIBRARY_PATH= if [ "$ANDROID_ROOT" != "/system" ]; then # Current default installation is dalvikvm 64bits and dex2oat 32bits, # so we can only use LD_LIBRARY_PATH when testing on a local # installation. LD_LIBRARY_PATH="$ANDROID_ROOT/$LIBRARY_DIRECTORY" fi # Needed to access libarttest(d).so and JVMTI agent libraries. LD_LIBRARY_PATH="/data/$TEST_DIRECTORY/art/$ISA:$LD_LIBRARY_PATH" # Needed to access the boot (core) image files. LD_LIBRARY_PATH="/data/art-test/$ISA:$LD_LIBRARY_PATH" # Needed to access the test's Odex files. LD_LIBRARY_PATH="$DEX_LOCATION/oat/$ISA:$LD_LIBRARY_PATH" # Needed to access the test's native libraries (see e.g. 674-hiddenapi, # which generates `libhiddenapitest_*.so` libraries in `$DEX_LOCATION`). LD_LIBRARY_PATH="$DEX_LOCATION:$LD_LIBRARY_PATH" # System libraries needed by libarttestd.so PUBLIC_LIBS=libc++.so:libbacktrace.so:libbase.so:libnativehelper.so if [ "$TEST_IS_NDEBUG" = "y" ]; then PUBLIC_LIBS=$PUBLIC_LIBS:libart.so:libdexfile.so:libprofile.so:libartbase.so else PUBLIC_LIBS=$PUBLIC_LIBS:libartd.so:libdexfiled.so:libprofiled.so:libartbased.so fi # Prepend directories to the path on device. PREPEND_TARGET_PATH=$ANDROID_ART_BIN_DIR if [ "$ANDROID_ROOT" != "/system" ]; then PREPEND_TARGET_PATH="$PREPEND_TARGET_PATH:$ANDROID_ROOT/bin" fi timeout_dumper_cmd= # Check whether signal_dumper is available. if [ "$TIMEOUT_DUMPER" = signal_dumper ] ; then # Chroot? Use as prefix for tests. TIMEOUT_DUMPER_PATH_PREFIX= if [ -n "$CHROOT" ]; then TIMEOUT_DUMPER_PATH_PREFIX="$CHROOT/" fi # Testing APEX? if adb shell "test -x ${TIMEOUT_DUMPER_PATH_PREFIX}/apex/com.android.art/bin/signal_dumper" ; then TIMEOUT_DUMPER="/apex/com.android.art/bin/signal_dumper" # Is it in /system/bin? elif adb shell "test -x ${TIMEOUT_DUMPER_PATH_PREFIX}/system/bin/signal_dumper" ; then TIMEOUT_DUMPER="/system/bin/signal_dumper" else TIMEOUT_DUMPER= fi else TIMEOUT_DUMPER= fi if [ ! -z "$TIMEOUT_DUMPER" ] ; then # Use "-l" to dump to logcat. That is convenience for the build bot crash symbolization. # Use exit code 124 for toybox timeout (b/141007616). timeout_dumper_cmd="${TIMEOUT_DUMPER} -l -s 15 -e 124" fi timeout_prefix= if [ "$TIME_OUT" = "timeout" ]; then # Add timeout command if time out is desired. # # Note: We first send SIGTERM (the timeout default, signal 15) to the signal dumper, which # will induce a full thread dump before killing the process. To ensure any issues in # dumping do not lead to a deadlock, we also use the "-k" option to definitely kill the # child. # Note: Using "--foreground" to not propagate the signal to children, i.e., the runtime. timeout_prefix="timeout --foreground -k 120s ${TIME_OUT_VALUE}s ${timeout_dumper_cmd} $cmdline" fi # Create a script with the command. The command can get longer than the longest # allowed adb command and there is no way to get the exit status from a adb shell # command. Dalvik cache is cleaned before running to make subsequent executions # of the script follow the same runtime path. cmdline="cd $DEX_LOCATION && \ export ASAN_OPTIONS=$RUN_TEST_ASAN_OPTIONS && \ export ANDROID_DATA=$DEX_LOCATION && \ export ANDROID_ADDITIONAL_PUBLIC_LIBRARIES=$PUBLIC_LIBS && \ export DEX_LOCATION=$DEX_LOCATION && \ export ANDROID_ROOT=$ANDROID_ROOT && \ export ANDROID_I18N_ROOT=$ANDROID_I18N_ROOT && \ export ANDROID_ART_ROOT=$ANDROID_ART_ROOT && \ export ANDROID_TZDATA_ROOT=$ANDROID_TZDATA_ROOT && \ export ANDROID_LOG_TAGS=$ANDROID_LOG_TAGS && \ rm -rf ${DEX_LOCATION}/dalvik-cache/ && \ mkdir -p ${mkdir_locations} && \ export LD_LIBRARY_PATH=$LD_LIBRARY_PATH && \ export PATH=$PREPEND_TARGET_PATH:\$PATH && \ $profman_cmdline && \ $dex2oat_cmdline && \ $dm_cmdline && \ $vdex_cmdline && \ $strip_cmdline && \ $sync_cmdline && \ $timeout_prefix $dalvikvm_cmdline" cmdfile=$(tempfile -p "cmd-" -s "-$TEST_NAME") echo "$cmdline" > $cmdfile if [ "$DEV_MODE" = "y" ]; then echo $cmdline if [ "$USE_GDB" = "y" ] || [ "$USE_GDBSERVER" = "y" ]; then echo "Forward ${GDBSERVER_PORT} to local port and connect GDB" fi fi if [ "$QUIET" = "n" ]; then adb push $cmdfile $CHROOT_DEX_LOCATION/cmdline.sh else adb push $cmdfile $CHROOT_DEX_LOCATION/cmdline.sh >/dev/null 2>&1 fi exit_status=0 if [ "$DRY_RUN" != "y" ]; then if [ -n "$CHROOT" ]; then adb shell chroot "$CHROOT" sh $DEX_LOCATION/cmdline.sh else adb shell sh $DEX_LOCATION/cmdline.sh fi exit_status=$? fi rm -f $cmdfile exit $exit_status else # Host run. export ANDROID_PRINTF_LOG=brief export ANDROID_DATA="$DEX_LOCATION" export ANDROID_ROOT="${ANDROID_ROOT}" export ANDROID_I18N_ROOT="${ANDROID_I18N_ROOT}" export ANDROID_ART_ROOT="${ANDROID_ART_ROOT}" export ANDROID_TZDATA_ROOT="${ANDROID_TZDATA_ROOT}" if [ "$USE_ZIPAPEX" = "y" ] || [ "$USE_EXRACTED_ZIPAPEX" = "y" ]; then # Put the zipapex files in front of the ld-library-path export LD_LIBRARY_PATH="${ANDROID_DATA}/zipapex/${LIBRARY_DIRECTORY}:${ANDROID_ROOT}/${TEST_DIRECTORY}" export DYLD_LIBRARY_PATH="${ANDROID_DATA}/zipapex/${LIBRARY_DIRECTORY}:${ANDROID_ROOT}/${TEST_DIRECTORY}" else export LD_LIBRARY_PATH="${ANDROID_ROOT}/${LIBRARY_DIRECTORY}:${ANDROID_ROOT}/${TEST_DIRECTORY}" export DYLD_LIBRARY_PATH="${ANDROID_ROOT}/${LIBRARY_DIRECTORY}:${ANDROID_ROOT}/${TEST_DIRECTORY}" fi export PATH="$PATH:$ANDROID_ART_BIN_DIR" # Temporarily disable address space layout randomization (ASLR). # This is needed on the host so that the linker loads core.oat at the necessary address. export LD_USE_LOAD_BIAS=1 cmdline="$dalvikvm_cmdline" if [ "$TIME_OUT" = "gdb" ]; then if [ `uname` = "Darwin" ]; then # Fall back to timeout on Mac. TIME_OUT="timeout" elif [ "$ISA" = "x86" ]; then # prctl call may fail in 32-bit on an older (3.2) 64-bit Linux kernel. Fall back to timeout. TIME_OUT="timeout" else # Check if gdb is available. gdb --eval-command="quit" > /dev/null 2>&1 if [ $? != 0 ]; then # gdb isn't available. Fall back to timeout. TIME_OUT="timeout" fi fi fi if [ "$TIME_OUT" = "timeout" ]; then # Add timeout command if time out is desired. # # Note: We first send SIGTERM (the timeout default, signal 15) to the signal dumper, which # will induce a full thread dump before killing the process. To ensure any issues in # dumping do not lead to a deadlock, we also use the "-k" option to definitely kill the # child. # Note: Using "--foreground" to not propagate the signal to children, i.e., the runtime. cmdline="timeout --foreground -k 120s ${TIME_OUT_VALUE}s ${TIMEOUT_DUMPER} -s 15 $cmdline" fi if [ "$DEV_MODE" = "y" ]; then for var in ANDROID_PRINTF_LOG ANDROID_DATA ANDROID_ROOT ANDROID_I18N_ROOT ANDROID_TZDATA_ROOT ANDROID_ART_ROOT LD_LIBRARY_PATH DYLD_LIBRARY_PATH PATH LD_USE_LOAD_BIAS; do echo EXPORT $var=${!var} done echo "$(declare -f linkdirs)" echo "mkdir -p ${mkdir_locations} && $setupapex_cmdline && $installapex_cmdline && $linkroot_cmdline && $linkroot_overlay_cmdline && $profman_cmdline && $dex2oat_cmdline && $dm_cmdline && $vdex_cmdline && $strip_cmdline && $sync_cmdline && $cmdline" fi cd $ANDROID_BUILD_TOP # Make sure we delete any existing compiler artifacts. # This enables tests to call the RUN script multiple times in a row # without worrying about interference. rm -rf ${DEX_LOCATION}/oat rm -rf ${DEX_LOCATION}/dalvik-cache/ export ASAN_OPTIONS=$RUN_TEST_ASAN_OPTIONS mkdir -p ${mkdir_locations} || exit 1 $setupapex_cmdline || { echo "zipapex extraction failed." >&2 ; exit 2; } $installapex_cmdline || { echo "zipapex install failed. cmd was: ${installapex_cmdline}." >&2; find ${mkdir_locations} -type f >&2; exit 2; } $linkroot_cmdline || { echo "create symlink android-root failed." >&2 ; exit 2; } $linkroot_overlay_cmdline || { echo "overlay android-root failed." >&2 ; exit 2; } $profman_cmdline || { echo "Profman failed." >&2 ; exit 2; } $dex2oat_cmdline || { echo "Dex2oat failed." >&2 ; exit 2; } $dm_cmdline || { echo "Dex2oat failed." >&2 ; exit 2; } $vdex_cmdline || { echo "Dex2oat failed." >&2 ; exit 2; } $strip_cmdline || { echo "Strip failed." >&2 ; exit 3; } $sync_cmdline || { echo "Sync failed." >&2 ; exit 4; } if [ "$CREATE_RUNNER" = "y" ]; then echo "#!/bin/bash" > ${DEX_LOCATION}/runit.sh for var in ANDROID_PRINTF_LOG ANDROID_DATA ANDROID_ROOT ANDROID_I18N_ROOT ANDROID_TZDATA_ROOT ANDROID_ART_ROOT LD_LIBRARY_PATH DYLD_LIBRARY_PATH PATH LD_USE_LOAD_BIAS; do echo export $var="${!var}" >> ${DEX_LOCATION}/runit.sh done if [ "$DEV_MODE" = "y" ]; then echo $cmdline "2>&1" >> ${DEX_LOCATION}/runit.sh else echo 'STDERR=$(mktemp)' >> ${DEX_LOCATION}/runit.sh echo 'STDOUT=$(mktemp)' >> ${DEX_LOCATION}/runit.sh echo $cmdline '2>${STDERR} >${STDOUT}' >> ${DEX_LOCATION}/runit.sh echo 'if diff ${STDOUT} $ANDROID_DATA/expected.txt; then' >> ${DEX_LOCATION}/runit.sh echo ' rm -f ${STDOUT} ${STDERR}' >> ${DEX_LOCATION}/runit.sh echo ' exit 0' >> ${DEX_LOCATION}/runit.sh echo 'else' >> ${DEX_LOCATION}/runit.sh echo ' echo STDOUT:' >> ${DEX_LOCATION}/runit.sh echo ' cat ${STDOUT}' >> ${DEX_LOCATION}/runit.sh echo ' echo STDERR:' >> ${DEX_LOCATION}/runit.sh echo ' cat ${STDERR}' >> ${DEX_LOCATION}/runit.sh echo ' rm -f ${STDOUT} ${STDERR}' >> ${DEX_LOCATION}/runit.sh echo ' exit 1' >> ${DEX_LOCATION}/runit.sh echo 'fi' >> ${DEX_LOCATION}/runit.sh fi chmod u+x $DEX_LOCATION/runit.sh echo "Runnable test script written to ${DEX_LOCATION}/runit.sh" fi if [ "$DRY_RUN" = "y" ]; then exit 0 fi if [ "$USE_GDB" = "y" ]; then # When running under gdb, we cannot do piping and grepping... $cmdline "$@" elif [ "$USE_GDBSERVER" = "y" ]; then echo "Connect to $GDBSERVER_PORT" # When running under gdb, we cannot do piping and grepping... $cmdline "$@" else if [ "$TIME_OUT" != "gdb" ]; then trap 'kill -INT -$pid' INT $cmdline "$@" 2>&1 & pid=$! wait $pid exit_value=$? # Add extra detail if time out is enabled. if [ $exit_value = 124 ] && [ "$TIME_OUT" = "timeout" ]; then echo -e "\e[91mTEST TIMED OUT!\e[0m" >&2 fi exit $exit_value else # With a thread dump that uses gdb if a timeout. trap 'kill -INT -$pid' INT $cmdline "$@" 2>&1 & pid=$! # Spawn a watcher process. ( sleep $TIME_OUT_VALUE && \ echo "##### Thread dump using gdb on test timeout" && \ ( gdb -q -p $pid --eval-command="info thread" --eval-command="thread apply all bt" \ --eval-command="call exit(124)" --eval-command=quit || \ kill $pid )) 2> /dev/null & watcher=$! wait $pid test_exit_status=$? pkill -P $watcher 2> /dev/null # kill the sleep which will in turn end the watcher as well if [ $test_exit_status = 0 ]; then # The test finished normally. exit 0 else # The test failed or timed out. if [ $test_exit_status = 124 ]; then # The test timed out. echo -e "\e[91mTEST TIMED OUT!\e[0m" >&2 fi exit $test_exit_status fi fi fi fi