# Copyright (C) 2011 The Android Open Source Project
|
#
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
# you may not use this file except in compliance with the License.
|
# You may obtain a copy of the License at
|
#
|
# http://www.apache.org/licenses/LICENSE-2.0
|
#
|
# Unless required by applicable law or agreed to in writing, software
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
# See the License for the specific language governing permissions and
|
# limitations under the License.
|
|
# This script is used on host and device. It uses a common subset
|
# shell dialect that should work on the host (e.g. bash), and
|
# Android (e.g. mksh).
|
|
######################################
|
# Functions
|
######################################
|
function find_libdir() {
|
# Get the actual file, $1 is the ART_BINARY_PATH and may be a symbolic link.
|
# Use realpath instead of readlink because Android does not have a readlink.
|
if [[ "$(realpath "$1")" == *dalvikvm64 ]]; then
|
echo "lib64"
|
else
|
echo "lib"
|
fi
|
}
|
|
function usage() {
|
cat 1>&2 <<EOF
|
Usage: art [OPTIONS] [--] [ART_OPTIONS] CLASS
|
|
Supported OPTIONS include:
|
--32 Use the 32-bit Android Runtime.
|
--64 Use the 64-bit Android Runtime.
|
-d Use the debug ART library (libartd.so).
|
--debug Equivalent to -d.
|
--gdb Launch the Android Runtime in gdb.
|
--gdbserver <comms> Launch the Android Runtime in gdbserver using the
|
supplied communication channel.
|
--help Display usage message.
|
--invoke-with <program> Launch the Android Runtime in <program>.
|
--perf Launch the Android Runtime with perf recording.
|
--perf-report Launch the Android Runtime with perf recording with
|
report upon completion.
|
--profile Run with profiling, then run using profile data.
|
--verbose Run script verbosely.
|
--no-clean Don't cleanup oat directories.
|
--no-compile Don't invoke dex2oat before running.
|
--allow-default-jdwp Don't automatically put in -XjdwpProvider:none.
|
You probably do not want this.
|
|
The ART_OPTIONS are passed directly to the Android Runtime.
|
|
Example:
|
art --32 -cp my_classes.dex MainClass
|
|
Common errors:
|
1) Not having core.art available (see $ANDROID_BUILD_TOP/art/Android.mk).
|
eg m -j32 build-art-host
|
2) Not having boot.art available (see $ANDROID_BUILD_TOP/build/make/core/dex_preopt_libart_boot.mk)
|
eg m -j32 out/target/product/generic_x86_64/dex_bootjars/system/framework/x86_64/boot.art
|
EOF
|
}
|
|
function clean_android_data() {
|
if [ "$DELETE_ANDROID_DATA" = "yes" ]; then
|
rm -rf $ANDROID_DATA
|
fi
|
}
|
|
# Given 'VAR1=VAL VAR2=VAL2 ... cmd arg1 arg2 ... argN' run the 'cmd' with the args
|
# with the modified environment {VAR1=VAL,VAL2=,...}.
|
#
|
# Also prints the command to be run if verbose mode is enabled.
|
function verbose_run() {
|
if [ "$VERBOSE" = "yes" ]; then
|
echo "$@"
|
fi
|
|
env "$@"
|
}
|
|
# Parse a colon-separated list into an array (e.g. "foo.dex:bar.dex" -> (foo.dex bar.dex))
|
PARSE_CLASSPATH_RESULT=() # Return value will be here due to shell limitations.
|
parse_classpath() {
|
local cp="$1"
|
local oldifs=$IFS
|
|
local cp_array
|
cp_array=()
|
|
IFS=":"
|
for part in $cp; do
|
cp_array+=("$part")
|
done
|
IFS=$oldifs
|
|
PARSE_CLASSPATH_RESULT=("${cp_array[@]}")
|
}
|
|
# Sets 'PARSE_CLASSPATH_RESULT' to an array of class path dex files.
|
# e.g. (-cp foo/classes.dex:bar/classes.dex) -> (foo/classes.dex bar/classes.dex)
|
find_cp_in_args() {
|
local found="false"
|
local index=0
|
local what
|
|
while [[ $# -gt 0 ]]; do
|
case "$1" in
|
-cp|-classpath)
|
parse_classpath "$2"
|
# Sets 'PARSE_CLASSPATH_RESULT' to an array of class path dex files.
|
# Subsequent parses will overwrite the preceding.
|
shift
|
;;
|
esac
|
shift
|
done
|
}
|
|
# Delete the 'oat' directories relative to the classpath's dex files.
|
# e.g. (foo/classes.dex bar/classes.dex) would delete (foo/oat bar/oat) directories.
|
cleanup_oat_directory() {
|
local classpath
|
classpath=("$@")
|
|
local dirpath
|
|
for path in "${classpath[@]}"; do
|
dirpath="$(dirname "$path")"
|
[[ -d "$dirpath" ]] && verbose_run rm -rf "$dirpath/oat"
|
done
|
}
|
|
# Parse -cp <CP>, -classpath <CP>, and $CLASSPATH to find the dex files.
|
# Each dex file's directory will have an 'oat' file directory, delete it.
|
# Input: Command line arguments to the art script.
|
# e.g. -cp foo/classes.dex:bar/classes.dex would delete (foo/oat bar/oat) directories.
|
cleanup_oat_directory_for_classpath() {
|
if [ "$CLEAN_OAT_FILES" = "yes" ]; then
|
# First try: Use $CLASSPATH environment variable.
|
parse_classpath "$CLASSPATH"
|
# Second try: Look for latest -cp or -classpath arg which will take precedence.
|
find_cp_in_args "$@"
|
|
cleanup_oat_directory "${PARSE_CLASSPATH_RESULT[@]}"
|
fi
|
}
|
|
# Attempt to find $ANDROID_ROOT/framework/<isa>/core.art' without knowing what <isa> is.
|
function check_if_boot_image_file_exists() {
|
local image_location_dir="$1"
|
local image_location_name="$2"
|
|
# Expand image_files to a list of existing image files on the disk.
|
# If no such files exist, it expands to single element 'dir/*/file' with a literal '*'.
|
local image_files
|
image_files=("$image_location_dir"/*/"$image_location_name") # avoid treating "*" as literal.
|
|
# Array always has at least 1 element. Test explicitly whether the file exists.
|
[[ -e "${image_files[0]}" ]]
|
}
|
|
# Automatically find the boot image location. It uses core.art by default.
|
# On a real device, it might only have a boot.art, so use that instead when core.art does not exist.
|
function detect_boot_image_location() {
|
local image_location_dir="$ANDROID_ROOT/framework"
|
local image_location_name="core.art"
|
|
# If there are no existing core.art, try to find boot.art.
|
# If there is no boot.art then leave it as-is, assumes -Ximage is explicitly used.
|
# Otherwise let dalvikvm give the error message about an invalid image file.
|
if ! check_if_boot_image_file_exists "$image_location_dir" "core.art" && \
|
check_if_boot_image_file_exists "$image_location_dir" "boot.art"; then
|
image_location_name="boot.art"
|
fi
|
|
local image_location="$image_location_dir/$image_location_name"
|
echo "$image_location"
|
}
|
|
function run_dex2oat() {
|
local class_loader_context=
|
for dex_file in "${DEX2OAT_CLASSPATH[@]}"
|
do
|
while [ -h "$dex_file" ]; do
|
# On Mac OS, readlink -f doesn't work.
|
dex_file="$(readlink "$dex_file")"
|
done
|
# Create oat file directory.
|
verbose_run mkdir -p $(dirname "$dex_file")/oat/$ISA
|
local oat_file=$(basename "$dex_file")
|
local oat_file=$(dirname "$dex_file")/oat/$ISA/${oat_file%.*}.odex
|
# When running dex2oat use the exact same context as when running dalvikvm.
|
# (see run_art function)
|
verbose_run ANDROID_DATA=$ANDROID_DATA \
|
ANDROID_ROOT=$ANDROID_ROOT \
|
ANDROID_RUNTIME_ROOT=$ANDROID_RUNTIME_ROOT \
|
ANDROID_TZDATA_ROOT=$ANDROID_TZDATA_ROOT \
|
LD_LIBRARY_PATH=$LD_LIBRARY_PATH \
|
PATH=$ANDROID_ROOT/bin:$PATH \
|
LD_USE_LOAD_BIAS=1 \
|
ANDROID_LOG_TAGS=$ANDROID_LOG_TAGS \
|
$DEX2OAT_BINARY_PATH \
|
--runtime-arg -Xnorelocate \
|
--boot-image=$DEX2OAT_BOOT_IMAGE \
|
--instruction-set=$ISA \
|
--class-loader-context="PCL[$class_loader_context]" \
|
"${DEX2OAT_FLAGS[@]}" \
|
--dex-file=$dex_file \
|
--oat-file=$oat_file
|
if [[ -n $class_loader_context ]]; then
|
class_loader_context+=":"
|
fi
|
class_loader_context+="$dex_file"
|
done
|
}
|
|
# Extract the dex2oat flags from the list of arguments.
|
# -Xcompiler-options arguments are stored in DEX2OAT_FLAGS array
|
# -cp argument is split by ':' and stored in DEX2OAT_CLASSPATH
|
# -Ximage argument is stored in DEX2OAT_BOOT_IMAGE
|
# -Xbootclasspath argument is stored in DEX2OAT_BCP
|
# -Xbootclasspath-locations argument is stored in DEX2OAT_BCP_LOCS
|
function extract_dex2oat_flags() {
|
while [ $# -gt 0 ]; do
|
case $1 in
|
-Xcompiler-option)
|
DEX2OAT_FLAGS+=("$2")
|
shift
|
;;
|
-Ximage:*)
|
DEX2OAT_BOOT_IMAGE=$1
|
# Remove '-Ximage:' from the argument.
|
DEX2OAT_BOOT_IMAGE=${DEX2OAT_BOOT_IMAGE##-Ximage:}
|
;;
|
-Xbootclasspath:*)
|
DEX2OAT_BCP=$1
|
# Remove '-Xbootclasspath:' from the argument.
|
DEX2OAT_BCP=${DEX2OAT_BCP##-Xbootclasspath:}
|
;;
|
-Xbootclasspath-locations:*)
|
DEX2OAT_BCP_LOCS=$1
|
# Remove '-Xbootclasspath-locations:' from the argument.
|
DEX2OAT_BCP_LOCS=${DEX2OAT_BCP_LOCS##-Xbootclasspath-locations:}
|
;;
|
-cp)
|
# Reset any previously parsed classpath, just like dalvikvm
|
# only supports one -cp argument.
|
DEX2OAT_CLASSPATH=()
|
# TODO: support -classpath and CLASSPATH
|
local oifs=$IFS
|
IFS=':'
|
for classpath_elem in $2
|
do
|
DEX2OAT_CLASSPATH+=("$classpath_elem")
|
done
|
shift
|
IFS=$oifs
|
;;
|
esac
|
shift
|
done
|
}
|
|
# Runs dalvikvm, returns its exit code.
|
# (Oat directories are cleaned up in between runs)
|
function run_art() {
|
local ret
|
|
# Run dalvikvm.
|
verbose_run ANDROID_DATA="$ANDROID_DATA" \
|
ANDROID_ROOT="$ANDROID_ROOT" \
|
ANDROID_RUNTIME_ROOT="$ANDROID_RUNTIME_ROOT" \
|
ANDROID_TZDATA_ROOT="$ANDROID_TZDATA_ROOT" \
|
LD_LIBRARY_PATH="$LD_LIBRARY_PATH" \
|
PATH="$ANDROID_ROOT/bin:$PATH" \
|
LD_USE_LOAD_BIAS=1 \
|
ANDROID_LOG_TAGS="$ANDROID_LOG_TAGS" \
|
$LAUNCH_WRAPPER $ART_BINARY_PATH $lib \
|
-XXlib:"$LIBART" \
|
-Xnorelocate \
|
-Ximage:"$DEFAULT_IMAGE_LOCATION" \
|
"$@"
|
ret=$?
|
|
# Avoid polluting disk with 'oat' files after dalvikvm has finished.
|
cleanup_oat_directory_for_classpath "$@"
|
|
# Forward exit code of dalvikvm.
|
return $ret
|
}
|
|
######################################
|
# Globals
|
######################################
|
ART_BINARY=dalvikvm
|
DEX2OAT_BINARY=dex2oat
|
DELETE_ANDROID_DATA="no"
|
LAUNCH_WRAPPER=
|
LIBART=libart.so
|
JIT_PROFILE="no"
|
ALLOW_DEFAULT_JDWP="no"
|
VERBOSE="no"
|
CLEAN_OAT_FILES="yes"
|
RUN_DEX2OAT="yes"
|
EXTRA_OPTIONS=()
|
DEX2OAT_FLAGS=()
|
DEX2OAT_CLASSPATH=()
|
|
# Parse arguments
|
while [[ "$1" = "-"* ]]; do
|
case "$1" in
|
--)
|
# No more arguments for this script.
|
shift
|
break
|
;;
|
--32)
|
ART_BINARY=dalvikvm32
|
;;
|
--64)
|
ART_BINARY=dalvikvm64
|
;;
|
-d)
|
;& # Fallthrough
|
--debug)
|
LIBART="libartd.so"
|
DEX2OAT_BINARY=dex2oatd
|
# Expect that debug mode wants all checks.
|
EXTRA_OPTIONS+=(-XX:SlowDebug=true)
|
;;
|
--gdbserver)
|
LAUNCH_WRAPPER="gdbserver $2"
|
shift
|
;;
|
--gdb)
|
LIBART="libartd.so"
|
LAUNCH_WRAPPER="gdb --args"
|
;;
|
--help)
|
usage
|
exit 0
|
;;
|
--invoke-with)
|
LAUNCH_WRAPPER=$2
|
shift
|
;;
|
--perf)
|
PERF="record"
|
;;
|
--perf-report)
|
PERF="report"
|
;;
|
--profile)
|
JIT_PROFILE="yes"
|
;;
|
--verbose)
|
VERBOSE="yes"
|
;;
|
--no-clean)
|
CLEAN_OAT_FILES="no"
|
;;
|
--no-compile)
|
CLEAN_OAT_FILES="no"
|
RUN_DEX2OAT="no"
|
;;
|
--allow-default-jdwp)
|
ALLOW_DEFAULT_JDWP="yes"
|
;;
|
--*)
|
echo "unknown option: $1" 1>&2
|
usage
|
exit 1
|
;;
|
*)
|
break
|
;;
|
esac
|
shift
|
done
|
|
if [ $# -eq 0 ]; then
|
usage
|
exit 1
|
fi
|
|
# Follow all sym links to get the program name.
|
if [[ -n "$BASH_SOURCE" ]]; then
|
PROG_NAME="$BASH_SOURCE"
|
else
|
PROG_NAME="$0"
|
fi
|
while [ -h "$PROG_NAME" ]; do
|
# On Mac OS, readlink -f doesn't work.
|
PROG_NAME="$(readlink "$PROG_NAME")"
|
done
|
|
PROG_DIR="$(cd "${PROG_NAME%/*}" ; pwd -P)"
|
ANDROID_ROOT="$(cd $PROG_DIR/..; pwd -P)"
|
|
# If ANDROID_RUNTIME_ROOT is not set, try to detect whether we are running on
|
# target or host and set that environment variable to the usual default value.
|
if [ -z "$ANDROID_RUNTIME_ROOT" ]; then
|
# This script is used on host and target (device). However, the (expected)
|
# default value `ANDROID_RUNTIME_ROOT` is not the same on host and target:
|
# - on host, `ANDROID_RUNTIME_ROOT` is expected to be "$ANDROID_ROOT/com.android.apex";
|
# - on target, `ANDROID_RUNTIME_ROOT` is expected to be "$ANDROID_ROOT/../apex/com.android.apex".
|
#
|
# We use the presence/absence of the `$ANDROID_ROOT/../apex` directory to
|
# determine whether we are on target or host (this is brittle, but simple).
|
if [ -d "$ANDROID_ROOT/../apex" ]; then
|
# Target case.
|
#
|
# We should be setting `ANDROID_RUNTIME_ROOT` to
|
# "$ANDROID_ROOT/../apex/com.android.runtime" here. However, the Runtime APEX
|
# is not (yet) supported by the ART Buildbot setup (see b/121117762); and yet
|
# ICU code depends on `ANDROID_RUNTIME_ROOT` to find ICU .dat files.
|
#
|
# As a temporary workaround, we:
|
# - make the ART Buildbot build script (art/tools/buildbot-build.sh) also
|
# generate the ICU .dat files in `/system/etc/icu` on device (these files
|
# are normally only put in the Runtime APEX on device);
|
# - set `ANDROID_RUNTIME_ROOT` to `$ANDROID_ROOT` (i.e. "/system") here.
|
#
|
# TODO(b/121117762): Set `ANDROID_RUNTIME_ROOT` to
|
# "$ANDROID_ROOT/../apex/com.android.runtime" when the Runtime APEX is fully
|
# supported on the ART Buildbot and Golem.
|
ANDROID_RUNTIME_ROOT=$ANDROID_ROOT
|
else
|
# Host case.
|
ANDROID_RUNTIME_ROOT="$ANDROID_ROOT/com.android.runtime"
|
fi
|
fi
|
|
# If ANDROID_TZDATA_ROOT is not set point it to somewhere safe. Android code
|
# currently treats the module as optional so it does not require the path exists.
|
if [ -z "$ANDROID_TZDATA_ROOT" ]; then
|
# Safe stubbed location that we don't need to exist.
|
ANDROID_TZDATA_ROOT="$ANDROID_ROOT/com.android.tzdata_doesnotexist"
|
fi
|
|
ART_BINARY_PATH=$ANDROID_ROOT/bin/$ART_BINARY
|
|
if [ ! -x "$ART_BINARY_PATH" ]; then
|
cat 1>&2 <<EOF
|
Android Runtime not found: $ART_BINARY_PATH
|
This script should be in the same directory as the Android Runtime ($ART_BINARY).
|
EOF
|
exit 1
|
fi
|
|
DEX2OAT_BINARY_PATH=$ANDROID_ROOT/bin/$DEX2OAT_BINARY
|
|
if [ ! -x "$DEX2OAT_BINARY_PATH" ]; then
|
echo "Warning: Android Compiler not found: $DEX2OAT_BINARY_PATH"
|
fi
|
|
######################################
|
# Main program
|
######################################
|
|
# If android logging is not explicitly set, only print warnings and errors.
|
if [ -z "$ANDROID_LOG_TAGS" ]; then
|
ANDROID_LOG_TAGS='*:w'
|
fi
|
|
LIBDIR="$(find_libdir $ART_BINARY_PATH)"
|
LD_LIBRARY_PATH=$ANDROID_ROOT/$LIBDIR
|
DEFAULT_IMAGE_LOCATION="$(detect_boot_image_location)"
|
DEX2OAT_BOOT_IMAGE="$DEFAULT_IMAGE_LOCATION"
|
ISA=$(LD_LIBRARY_PATH=$LD_LIBRARY_PATH $ART_BINARY_PATH -showversion | (read art version number isa && echo $isa))
|
|
# Extract the dex2oat flags from the list of arguments.
|
# -Xcompiler-options arguments are stored in DEX2OAT_FLAGS array
|
# -cp argument is split by ':' and stored in DEX2OAT_CLASSPATH
|
# -Ximage argument is stored in DEX2OAT_BOOT_IMAGE
|
extract_dex2oat_flags "$@"
|
|
# If ANDROID_DATA is the system ANDROID_DATA or is not set, use our own,
|
# and ensure we delete it at the end.
|
if [ "$ANDROID_DATA" = "/data" ] || [ "$ANDROID_DATA" = "" ]; then
|
if [[ $PWD != / ]]; then
|
ANDROID_DATA="$PWD/android-data$$"
|
else
|
# Use /data/local/tmp when running this from adb shell, since it starts out in /
|
# by default.
|
ANDROID_DATA="$ANDROID_DATA/local/tmp/android-data$$"
|
fi
|
mkdir -p "$ANDROID_DATA"
|
DELETE_ANDROID_DATA="yes"
|
fi
|
|
if [[ "$DEX2OAT_BCP" = "" && "$DEX2OAT_BCP_LOCS" != "" ]]; then
|
echo "Cannot use -Xbootclasspath-locations without -Xbootclasspath"
|
exit 1
|
fi
|
|
if [[ "$DEX2OAT_BOOT_IMAGE" = *core*.art && "$DEX2OAT_BCP" = "" ]]; then
|
# 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.
|
core_jars_list="core-oj core-libart okhttp bouncycastle apache-xml conscrypt"
|
core_jars_suffix=
|
if [[ -e $ANDROID_ROOT/framework/core-oj-hostdex.jar ]]; then
|
core_jars_suffix=-hostdex
|
core_locations_dir=$ANDROID_ROOT/framework
|
prefix=$PWD/
|
if [[ ${core_locations_dir:0:${#prefix}} = $prefix ]]; then
|
core_locations_dir="${core_locations_dir##$prefix}"
|
fi
|
elif [[ -e $ANDROID_ROOT/framework/core-oj-testdex.jar ]]; then
|
core_jars_suffix=-testdex
|
core_locations_dir=/system/framework
|
fi
|
if [[ $core_jars_suffix != "" ]]; then
|
boot_separator=""
|
for boot_module in ${core_jars_list}; do
|
DEX_FILENAME="$boot_module$core_jars_suffix.jar"
|
DEX2OAT_BCP+="$boot_separator$ANDROID_ROOT/framework/${DEX_FILENAME}"
|
DEX2OAT_BCP_LOCS+="$boot_separator$core_locations_dir/${DEX_FILENAME}"
|
boot_separator=":"
|
done
|
if [ "$VERBOSE" = "yes" ]; then
|
echo "Using predefined -Xbootclasspath for image $DEX2OAT_BOOT_IMAGE:"
|
echo DEX2OAT_BOOT_IMAGE=$DEX2OAT_BOOT_IMAGE
|
echo DEX2OAT_BCP=$DEX2OAT_BCP
|
echo DEX2OAT_BCP_LOCS=$DEX2OAT_BCP_LOCS
|
fi
|
fi
|
fi
|
|
if [ "$DEX2OAT_BCP" != "" ]; then
|
EXTRA_OPTIONS+=("-Xbootclasspath:$DEX2OAT_BCP")
|
DEX2OAT_FLAGS+=("--runtime-arg" "-Xbootclasspath:$DEX2OAT_BCP")
|
if [ "$DEX2OAT_BCP_LOCS" != "" ]; then
|
EXTRA_OPTIONS+=("-Xbootclasspath-locations:$DEX2OAT_BCP_LOCS")
|
DEX2OAT_FLAGS+=("--runtime-arg" \
|
"-Xbootclasspath-locations:$DEX2OAT_BCP_LOCS")
|
fi
|
fi
|
|
if [ "$PERF" != "" ]; then
|
LAUNCH_WRAPPER="perf record -g --call-graph dwarf -F 10000 -o $ANDROID_DATA/perf.data -e cycles:u $LAUNCH_WRAPPER"
|
DEX2OAT_FLAGS+=(--generate-debug-info)
|
fi
|
|
if [ "$ALLOW_DEFAULT_JDWP" = "no" ]; then
|
EXTRA_OPTIONS+=(-XjdwpProvider:none)
|
fi
|
|
# First cleanup any left-over 'oat' files from the last time dalvikvm was run.
|
cleanup_oat_directory_for_classpath "$@"
|
|
# Protect additional arguments in quotes to preserve whitespaces (used by
|
# run-jdwp-test.sh when running on device), '$' (may be used as part of
|
# classpath) and other special characters when evaluated.
|
EXTRA_OPTIONS+=("$@")
|
|
if [ "$JIT_PROFILE" = "yes" ]; then
|
# Create the profile. The runtime expects profiles to be created before
|
# execution.
|
PROFILE_PATH="$ANDROID_DATA/primary.prof"
|
touch "$PROFILE_PATH"
|
|
run_art -Xjitsaveprofilinginfo \
|
-Xps-min-methods-to-save:1 \
|
-Xps-min-classes-to-save:1 \
|
-Xps-min-notification-before-wake:10 \
|
-Xps-profile-path:$PROFILE_PATH \
|
-Xusejit:true \
|
${EXTRA_OPTIONS[@]} \
|
&> "$ANDROID_DATA/profile_gen.log"
|
EXIT_STATUS=$?
|
|
if [ $EXIT_STATUS != 0 ]; then
|
echo "Profile run failed: " >&2
|
cat "$ANDROID_DATA/profile_gen.log" >&2
|
clean_android_data
|
exit $EXIT_STATUS
|
fi
|
|
# Wipe dalvik-cache so that a subsequent run_art must regenerate it.
|
# Leave $ANDROID_DATA intact since it contains our profile file.
|
rm -rf "$ANDROID_DATA/dalvik-cache"
|
|
# Append arguments so next invocation of run_art uses the profile.
|
DEX2OAT_FLAGS+=(--profile-file="$PROFILE_PATH")
|
fi
|
|
if [ -x "$DEX2OAT_BINARY_PATH" ]; then
|
if [ "$RUN_DEX2OAT" = "yes" ]; then
|
# Run dex2oat before launching ART to generate the oat files for the classpath.
|
run_dex2oat
|
fi
|
fi
|
|
# Do not continue if the dex2oat failed.
|
EXIT_STATUS=$?
|
if [ $EXIT_STATUS != 0 ]; then
|
echo "Failed dex2oat invocation" >&2
|
exit $EXIT_STATUS
|
fi
|
|
run_art "${EXTRA_OPTIONS[@]}"
|
EXIT_STATUS=$?
|
|
if [ "$PERF" != "" ]; then
|
if [ "$PERF" = report ]; then
|
perf report -i $ANDROID_DATA/perf.data
|
fi
|
echo "Perf data saved in: $ANDROID_DATA/perf.data"
|
else
|
# Perf output is placed under $ANDROID_DATA so not cleaned when perf options used.
|
clean_android_data
|
fi
|
|
exit $EXIT_STATUS
|
