fuquan/allwinner_a64
1
1
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

upload android base code part3

Browse source
This commit is contained in:
August 2018-08-08 16:48:17 +08:00
parent 71b83c22f1
commit b9e30e05b1
15122 changed files with 2089659 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

68
android/art/dexoptanalyzer/Android.bp Normal file
View file

@ -0,0 +1,68 @@
//
// Copyright (C) 2017 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.
//
cc_defaults {
name: "dexoptanalyzer-defaults",
host_supported: true,
defaults: ["art_defaults"],
srcs: [
"dexoptanalyzer.cc",
],
target: {
android: {
compile_multilib: "prefer32",
},
},
include_dirs: [
"art/cmdline",
],
shared_libs: [
"libbase",
],
}
art_cc_binary {
name: "dexoptanalyzer",
defaults: ["dexoptanalyzer-defaults"],
shared_libs: [
"libart",
],
}
art_cc_binary {
name: "dexoptanalyzerd",
defaults: [
"art_debug_defaults",
"dexoptanalyzer-defaults",
],
shared_libs: [
"libartd",
],
}
art_cc_test {
name: "art_dexoptanalyzer_tests",
defaults: [
"art_gtest_defaults",
],
shared_libs: [
"libbacktrace"
],
srcs: ["dexoptanalyzer_test.cc"],
}

275
android/art/dexoptanalyzer/dexoptanalyzer.cc Normal file
View file

@ -0,0 +1,275 @@
/*
* Copyright (C) 2017 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.
*/
#include <string>
#include "android-base/stringprintf.h"
#include "android-base/strings.h"
#include "compiler_filter.h"
#include "dex_file.h"
#include "noop_compiler_callbacks.h"
#include "oat_file_assistant.h"
#include "os.h"
#include "runtime.h"
#include "thread-inl.h"
#include "utils.h"
namespace art {
// See OatFileAssistant docs for the meaning of the valid return codes.
enum ReturnCodes {
kNoDexOptNeeded = 0,
kDex2OatFromScratch = 1,
kDex2OatForBootImageOat = 2,
kDex2OatForFilterOat = 3,
kDex2OatForRelocationOat = 4,
kDex2OatForBootImageOdex = 5,
kDex2OatForFilterOdex = 6,
kDex2OatForRelocationOdex = 7,
kErrorInvalidArguments = 101,
kErrorCannotCreateRuntime = 102,
kErrorUnknownDexOptNeeded = 103
};
static int original_argc;
static char** original_argv;
static std::string CommandLine() {
std::vector<std::string> command;
for (int i = 0; i < original_argc; ++i) {
command.push_back(original_argv[i]);
}
return android::base::Join(command, ' ');
}
static void UsageErrorV(const char* fmt, va_list ap) {
std::string error;
android::base::StringAppendV(&error, fmt, ap);
LOG(ERROR) << error;
}
static void UsageError(const char* fmt, ...) {
va_list ap;
va_start(ap, fmt);
UsageErrorV(fmt, ap);
va_end(ap);
}
NO_RETURN static void Usage(const char *fmt, ...) {
va_list ap;
va_start(ap, fmt);
UsageErrorV(fmt, ap);
va_end(ap);
UsageError("Command: %s", CommandLine().c_str());
UsageError(" Performs a dexopt analysis on the given dex file and returns whether or not");
UsageError(" the dex file needs to be dexopted.");
UsageError("Usage: dexoptanalyzer [options]...");
UsageError("");
UsageError(" --dex-file=<filename>: the dex file which should be analyzed.");
UsageError("");
UsageError(" --isa=<string>: the instruction set for which the analysis should be performed.");
UsageError("");
UsageError(" --compiler-filter=<string>: the target compiler filter to be used as reference");
UsageError(" when deciding if the dex file needs to be optimized.");
UsageError("");
UsageError(" --assume-profile-changed: assumes the profile information has changed");
UsageError(" when deciding if the dex file needs to be optimized.");
UsageError("");
UsageError(" --image=<filename>: optional, the image to be used to decide if the associated");
UsageError(" oat file is up to date. Defaults to $ANDROID_ROOT/framework/boot.art.");
UsageError(" Example: --image=/system/framework/boot.art");
UsageError("");
UsageError(" --android-data=<directory>: optional, the directory which should be used as");
UsageError(" android-data. By default ANDROID_DATA env variable is used.");
UsageError("");
UsageError(" --downgrade: optional, if the purpose of dexopt is to downgrade the dex file");
UsageError(" By default, dexopt considers upgrade case.");
UsageError("");
UsageError("Return code:");
UsageError(" To make it easier to integrate with the internal tools this command will make");
UsageError(" available its result (dexoptNeeded) as the exit/return code. i.e. it will not");
UsageError(" return 0 for success and a non zero values for errors as the conventional");
UsageError(" commands. The following return codes are possible:");
UsageError(" kNoDexOptNeeded = 0");
UsageError(" kDex2OatFromScratch = 1");
UsageError(" kDex2OatForBootImageOat = 2");
UsageError(" kDex2OatForFilterOat = 3");
UsageError(" kDex2OatForRelocationOat = 4");
UsageError(" kDex2OatForBootImageOdex = 5");
UsageError(" kDex2OatForFilterOdex = 6");
UsageError(" kDex2OatForRelocationOdex = 7");
UsageError(" kErrorInvalidArguments = 101");
UsageError(" kErrorCannotCreateRuntime = 102");
UsageError(" kErrorUnknownDexOptNeeded = 103");
UsageError("");
exit(kErrorInvalidArguments);
}
class DexoptAnalyzer FINAL {
public:
DexoptAnalyzer() :
assume_profile_changed_(false),
downgrade_(false) {}
void ParseArgs(int argc, char **argv) {
original_argc = argc;
original_argv = argv;
InitLogging(argv, Runtime::Abort);
// Skip over the command name.
argv++;
argc--;
if (argc == 0) {
Usage("No arguments specified");
}
for (int i = 0; i < argc; ++i) {
const StringPiece option(argv[i]);
if (option == "--assume-profile-changed") {
assume_profile_changed_ = true;
} else if (option.starts_with("--dex-file=")) {
dex_file_ = option.substr(strlen("--dex-file=")).ToString();
} else if (option.starts_with("--compiler-filter=")) {
std::string filter_str = option.substr(strlen("--compiler-filter=")).ToString();
if (!CompilerFilter::ParseCompilerFilter(filter_str.c_str(), &compiler_filter_)) {
Usage("Invalid compiler filter '%s'", option.data());
}
} else if (option.starts_with("--isa=")) {
std::string isa_str = option.substr(strlen("--isa=")).ToString();
isa_ = GetInstructionSetFromString(isa_str.c_str());
if (isa_ == kNone) {
Usage("Invalid isa '%s'", option.data());
}
} else if (option.starts_with("--image=")) {
image_ = option.substr(strlen("--image=")).ToString();
} else if (option.starts_with("--android-data=")) {
// Overwrite android-data if needed (oat file assistant relies on a valid directory to
// compute dalvik-cache folder). This is mostly used in tests.
std::string new_android_data = option.substr(strlen("--android-data=")).ToString();
setenv("ANDROID_DATA", new_android_data.c_str(), 1);
} else if (option.starts_with("--downgrade")) {
downgrade_ = true;
} else { Usage("Unknown argument '%s'", option.data()); }
}
if (image_.empty()) {
// If we don't receive the image, try to use the default one.
// Tests may specify a different image (e.g. core image).
std::string error_msg;
image_ = GetDefaultBootImageLocation(&error_msg);
if (image_.empty()) {
LOG(ERROR) << error_msg;
Usage("--image unspecified and ANDROID_ROOT not set or image file does not exist.");
}
}
}
bool CreateRuntime() {
RuntimeOptions options;
// The image could be custom, so make sure we explicitly pass it.
std::string img = "-Ximage:" + image_;
options.push_back(std::make_pair(img.c_str(), nullptr));
// The instruction set of the image should match the instruction set we will test.
const void* isa_opt = reinterpret_cast<const void*>(GetInstructionSetString(isa_));
options.push_back(std::make_pair("imageinstructionset", isa_opt));
// Disable libsigchain. We don't don't need it to evaluate DexOptNeeded status.
options.push_back(std::make_pair("-Xno-sig-chain", nullptr));
// Pretend we are a compiler so that we can re-use the same infrastructure to load a different
// ISA image and minimize the amount of things that get started.
NoopCompilerCallbacks callbacks;
options.push_back(std::make_pair("compilercallbacks", &callbacks));
// Make sure we don't attempt to relocate. The tool should only retrieve the DexOptNeeded
// status and not attempt to relocate the boot image.
options.push_back(std::make_pair("-Xnorelocate", nullptr));
if (!Runtime::Create(options, false)) {
LOG(ERROR) << "Unable to initialize runtime";
return false;
}
// Runtime::Create acquired the mutator_lock_ that is normally given away when we
// Runtime::Start. Give it away now.
Thread::Current()->TransitionFromRunnableToSuspended(kNative);
return true;
}
int GetDexOptNeeded() {
// If the file does not exist there's nothing to do.
// This is a fast path to avoid creating the runtime (b/34385298).
if (!OS::FileExists(dex_file_.c_str())) {
return kNoDexOptNeeded;
}
if (!CreateRuntime()) {
return kErrorCannotCreateRuntime;
}
std::unique_ptr<Runtime> runtime(Runtime::Current());
OatFileAssistant oat_file_assistant(dex_file_.c_str(), isa_, /*load_executable*/ false);
// Always treat elements of the bootclasspath as up-to-date.
// TODO(calin): this check should be in OatFileAssistant.
if (oat_file_assistant.IsInBootClassPath()) {
return kNoDexOptNeeded;
}
// TODO(calin): Pass the class loader context as an argument to dexoptanalyzer. b/62269291.
int dexoptNeeded = oat_file_assistant.GetDexOptNeeded(
compiler_filter_, assume_profile_changed_, downgrade_);
// Convert OatFileAssitant codes to dexoptanalyzer codes.
switch (dexoptNeeded) {
case OatFileAssistant::kNoDexOptNeeded: return kNoDexOptNeeded;
case OatFileAssistant::kDex2OatFromScratch: return kDex2OatFromScratch;
case OatFileAssistant::kDex2OatForBootImage: return kDex2OatForBootImageOat;
case OatFileAssistant::kDex2OatForFilter: return kDex2OatForFilterOat;
case OatFileAssistant::kDex2OatForRelocation: return kDex2OatForRelocationOat;
case -OatFileAssistant::kDex2OatForBootImage: return kDex2OatForBootImageOdex;
case -OatFileAssistant::kDex2OatForFilter: return kDex2OatForFilterOdex;
case -OatFileAssistant::kDex2OatForRelocation: return kDex2OatForRelocationOdex;
default:
LOG(ERROR) << "Unknown dexoptNeeded " << dexoptNeeded;
return kErrorUnknownDexOptNeeded;
}
}
private:
std::string dex_file_;
InstructionSet isa_;
CompilerFilter::Filter compiler_filter_;
bool assume_profile_changed_;
bool downgrade_;
std::string image_;
};
static int dexoptAnalyze(int argc, char** argv) {
DexoptAnalyzer analyzer;
// Parse arguments. Argument mistakes will lead to exit(kErrorInvalidArguments) in UsageError.
analyzer.ParseArgs(argc, argv);
return analyzer.GetDexOptNeeded();
}
} // namespace art
int main(int argc, char **argv) {
return art::dexoptAnalyze(argc, argv);
}

322
android/art/dexoptanalyzer/dexoptanalyzer_test.cc Normal file
View file

@ -0,0 +1,322 @@
/*
* Copyright (C) 2017 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.
*/
#include <gtest/gtest.h>
#include "arch/instruction_set.h"
#include "compiler_filter.h"
#include "dexopt_test.h"
namespace art {
class DexoptAnalyzerTest : public DexoptTest {
protected:
std::string GetDexoptAnalyzerCmd() {
std::string file_path = GetTestAndroidRoot();
file_path += "/bin/dexoptanalyzer";
if (kIsDebugBuild) {
file_path += "d";
}
EXPECT_TRUE(OS::FileExists(file_path.c_str())) << file_path << " should be a valid file path";
return file_path;
}
int Analyze(const std::string& dex_file,
CompilerFilter::Filter compiler_filter,
bool assume_profile_changed) {
std::string dexoptanalyzer_cmd = GetDexoptAnalyzerCmd();
std::vector<std::string> argv_str;
argv_str.push_back(dexoptanalyzer_cmd);
argv_str.push_back("--dex-file=" + dex_file);
argv_str.push_back("--isa=" + std::string(GetInstructionSetString(kRuntimeISA)));
argv_str.push_back("--compiler-filter=" + CompilerFilter::NameOfFilter(compiler_filter));
if (assume_profile_changed) {
argv_str.push_back("--assume-profile-changed");
}
argv_str.push_back("--image=" + GetImageLocation());
argv_str.push_back("--android-data=" + android_data_);
std::string error;
return ExecAndReturnCode(argv_str, &error);
}
int DexoptanalyzerToOatFileAssistant(int dexoptanalyzerResult) {
switch (dexoptanalyzerResult) {
case 0: return OatFileAssistant::kNoDexOptNeeded;
case 1: return OatFileAssistant::kDex2OatFromScratch;
case 2: return OatFileAssistant::kDex2OatForBootImage;
case 3: return OatFileAssistant::kDex2OatForFilter;
case 4: return OatFileAssistant::kDex2OatForRelocation;
case 5: return -OatFileAssistant::kDex2OatForBootImage;
case 6: return -OatFileAssistant::kDex2OatForFilter;
case 7: return -OatFileAssistant::kDex2OatForRelocation;
default: return dexoptanalyzerResult;
}
}
// Verify that the output of dexoptanalyzer for the given arguments is the same
// as the output of OatFileAssistant::GetDexOptNeeded.
void Verify(const std::string& dex_file,
CompilerFilter::Filter compiler_filter,
bool assume_profile_changed = false,
bool downgrade = false) {
int dexoptanalyzerResult = Analyze(dex_file, compiler_filter, assume_profile_changed);
dexoptanalyzerResult = DexoptanalyzerToOatFileAssistant(dexoptanalyzerResult);
OatFileAssistant oat_file_assistant(dex_file.c_str(), kRuntimeISA, /*load_executable*/ false);
int assistantResult = oat_file_assistant.GetDexOptNeeded(
compiler_filter, assume_profile_changed, downgrade);
EXPECT_EQ(assistantResult, dexoptanalyzerResult);
}
};
// The tests below exercise the same test case from oat_file_assistant_test.cc.
// Case: We have a DEX file, but no OAT file for it.
TEST_F(DexoptAnalyzerTest, DexNoOat) {
std::string dex_location = GetScratchDir() + "/DexNoOat.jar";
Copy(GetDexSrc1(), dex_location);
Verify(dex_location, CompilerFilter::kSpeed);
Verify(dex_location, CompilerFilter::kExtract);
Verify(dex_location, CompilerFilter::kQuicken);
Verify(dex_location, CompilerFilter::kSpeedProfile);
}
// Case: We have a DEX file and up-to-date OAT file for it.
TEST_F(DexoptAnalyzerTest, OatUpToDate) {
std::string dex_location = GetScratchDir() + "/OatUpToDate.jar";
Copy(GetDexSrc1(), dex_location);
GenerateOatForTest(dex_location.c_str(), CompilerFilter::kSpeed);
Verify(dex_location, CompilerFilter::kSpeed);
Verify(dex_location, CompilerFilter::kQuicken);
Verify(dex_location, CompilerFilter::kExtract);
Verify(dex_location, CompilerFilter::kEverything);
}
// Case: We have a DEX file and speed-profile OAT file for it.
TEST_F(DexoptAnalyzerTest, ProfileOatUpToDate) {
std::string dex_location = GetScratchDir() + "/ProfileOatUpToDate.jar";
Copy(GetDexSrc1(), dex_location);
GenerateOatForTest(dex_location.c_str(), CompilerFilter::kSpeedProfile);
Verify(dex_location, CompilerFilter::kSpeedProfile, false);
Verify(dex_location, CompilerFilter::kQuicken, false);
Verify(dex_location, CompilerFilter::kSpeedProfile, true);
Verify(dex_location, CompilerFilter::kQuicken, true);
}
TEST_F(DexoptAnalyzerTest, Downgrade) {
std::string dex_location = GetScratchDir() + "/Downgrade.jar";
Copy(GetDexSrc1(), dex_location);
GenerateOatForTest(dex_location.c_str(), CompilerFilter::kQuicken);
Verify(dex_location, CompilerFilter::kSpeedProfile, false, true);
Verify(dex_location, CompilerFilter::kQuicken, false, true);
Verify(dex_location, CompilerFilter::kVerify, false, true);
}
// Case: We have a MultiDEX file and up-to-date OAT file for it.
TEST_F(DexoptAnalyzerTest, MultiDexOatUpToDate) {
std::string dex_location = GetScratchDir() + "/MultiDexOatUpToDate.jar";
Copy(GetMultiDexSrc1(), dex_location);
GenerateOatForTest(dex_location.c_str(), CompilerFilter::kSpeed);
Verify(dex_location, CompilerFilter::kSpeed, false);
}
// Case: We have a MultiDEX file where the secondary dex file is out of date.
TEST_F(DexoptAnalyzerTest, MultiDexSecondaryOutOfDate) {
std::string dex_location = GetScratchDir() + "/MultiDexSecondaryOutOfDate.jar";
// Compile code for GetMultiDexSrc1.
Copy(GetMultiDexSrc1(), dex_location);
GenerateOatForTest(dex_location.c_str(), CompilerFilter::kSpeed);
// Now overwrite the dex file with GetMultiDexSrc2 so the secondary checksum
// is out of date.
Copy(GetMultiDexSrc2(), dex_location);
Verify(dex_location, CompilerFilter::kSpeed, false);
}
// Case: We have a DEX file and an OAT file out of date with respect to the
// dex checksum.
TEST_F(DexoptAnalyzerTest, OatDexOutOfDate) {
std::string dex_location = GetScratchDir() + "/OatDexOutOfDate.jar";
// We create a dex, generate an oat for it, then overwrite the dex with a
// different dex to make the oat out of date.
Copy(GetDexSrc1(), dex_location);
GenerateOatForTest(dex_location.c_str(), CompilerFilter::kSpeed);
Copy(GetDexSrc2(), dex_location);
Verify(dex_location, CompilerFilter::kExtract);
Verify(dex_location, CompilerFilter::kSpeed);
}
// Case: We have a DEX file and an OAT file out of date with respect to the
// boot image.
TEST_F(DexoptAnalyzerTest, OatImageOutOfDate) {
std::string dex_location = GetScratchDir() + "/OatImageOutOfDate.jar";
Copy(GetDexSrc1(), dex_location);
GenerateOatForTest(dex_location.c_str(),
CompilerFilter::kSpeed,
/*relocate*/true,
/*pic*/false,
/*with_alternate_image*/true);
Verify(dex_location, CompilerFilter::kExtract);
Verify(dex_location, CompilerFilter::kQuicken);
Verify(dex_location, CompilerFilter::kSpeed);
}
// Case: We have a DEX file and a verify-at-runtime OAT file out of date with
// respect to the boot image.
// It shouldn't matter that the OAT file is out of date, because it is
// verify-at-runtime.
TEST_F(DexoptAnalyzerTest, OatVerifyAtRuntimeImageOutOfDate) {
std::string dex_location = GetScratchDir() + "/OatVerifyAtRuntimeImageOutOfDate.jar";
Copy(GetDexSrc1(), dex_location);
GenerateOatForTest(dex_location.c_str(),
CompilerFilter::kExtract,
/*relocate*/true,
/*pic*/false,
/*with_alternate_image*/true);
Verify(dex_location, CompilerFilter::kExtract);
Verify(dex_location, CompilerFilter::kQuicken);
}
// Case: We have a DEX file and an ODEX file, but no OAT file.
TEST_F(DexoptAnalyzerTest, DexOdexNoOat) {
std::string dex_location = GetScratchDir() + "/DexOdexNoOat.jar";
std::string odex_location = GetOdexDir() + "/DexOdexNoOat.odex";
Copy(GetDexSrc1(), dex_location);
GenerateOdexForTest(dex_location, odex_location, CompilerFilter::kSpeed);
Verify(dex_location, CompilerFilter::kExtract);
Verify(dex_location, CompilerFilter::kSpeed);
}
// Case: We have a stripped DEX file and a PIC ODEX file, but no OAT file.
TEST_F(DexoptAnalyzerTest, StrippedDexOdexNoOat) {
std::string dex_location = GetScratchDir() + "/StrippedDexOdexNoOat.jar";
std::string odex_location = GetOdexDir() + "/StrippedDexOdexNoOat.odex";
Copy(GetDexSrc1(), dex_location);
GeneratePicOdexForTest(dex_location, odex_location, CompilerFilter::kSpeed);
// Strip the dex file
Copy(GetStrippedDexSrc1(), dex_location);
Verify(dex_location, CompilerFilter::kSpeed);
}
// Case: We have a stripped DEX file, a PIC ODEX file, and an out-of-date OAT file.
TEST_F(DexoptAnalyzerTest, StrippedDexOdexOat) {
std::string dex_location = GetScratchDir() + "/StrippedDexOdexOat.jar";
std::string odex_location = GetOdexDir() + "/StrippedDexOdexOat.odex";
// Create the oat file from a different dex file so it looks out of date.
Copy(GetDexSrc2(), dex_location);
GenerateOatForTest(dex_location.c_str(), CompilerFilter::kSpeed);
// Create the odex file
Copy(GetDexSrc1(), dex_location);
GeneratePicOdexForTest(dex_location, odex_location, CompilerFilter::kSpeed);
// Strip the dex file.
Copy(GetStrippedDexSrc1(), dex_location);
Verify(dex_location, CompilerFilter::kExtract);
Verify(dex_location, CompilerFilter::kSpeed);
Verify(dex_location, CompilerFilter::kEverything);
}
// Case: We have a stripped (or resource-only) DEX file, no ODEX file and no
// OAT file. Expect: The status is kNoDexOptNeeded.
TEST_F(DexoptAnalyzerTest, ResourceOnlyDex) {
std::string dex_location = GetScratchDir() + "/ResourceOnlyDex.jar";
Copy(GetStrippedDexSrc1(), dex_location);
Verify(dex_location, CompilerFilter::kSpeed);
Verify(dex_location, CompilerFilter::kExtract);
Verify(dex_location, CompilerFilter::kQuicken);
}
// Case: We have a DEX file, an ODEX file and an OAT file, where the ODEX and
// OAT files both have patch delta of 0.
TEST_F(DexoptAnalyzerTest, OdexOatOverlap) {
std::string dex_location = GetScratchDir() + "/OdexOatOverlap.jar";
std::string odex_location = GetOdexDir() + "/OdexOatOverlap.odex";
std::string oat_location = GetOdexDir() + "/OdexOatOverlap.oat";
Copy(GetDexSrc1(), dex_location);
GenerateOdexForTest(dex_location, odex_location, CompilerFilter::kSpeed);
// Create the oat file by copying the odex so they are located in the same
// place in memory.
Copy(odex_location, oat_location);
Verify(dex_location, CompilerFilter::kSpeed);
}
// Case: We have a DEX file and a PIC ODEX file, but no OAT file.
TEST_F(DexoptAnalyzerTest, DexPicOdexNoOat) {
std::string dex_location = GetScratchDir() + "/DexPicOdexNoOat.jar";
std::string odex_location = GetOdexDir() + "/DexPicOdexNoOat.odex";
Copy(GetDexSrc1(), dex_location);
GeneratePicOdexForTest(dex_location, odex_location, CompilerFilter::kSpeed);
Verify(dex_location, CompilerFilter::kSpeed);
Verify(dex_location, CompilerFilter::kEverything);
}
// Case: We have a DEX file and a VerifyAtRuntime ODEX file, but no OAT file..
TEST_F(DexoptAnalyzerTest, DexVerifyAtRuntimeOdexNoOat) {
std::string dex_location = GetScratchDir() + "/DexVerifyAtRuntimeOdexNoOat.jar";
std::string odex_location = GetOdexDir() + "/DexVerifyAtRuntimeOdexNoOat.odex";
Copy(GetDexSrc1(), dex_location);
GenerateOdexForTest(dex_location, odex_location, CompilerFilter::kExtract);
Verify(dex_location, CompilerFilter::kExtract);
Verify(dex_location, CompilerFilter::kSpeed);
}
// Case: Non-standard extension for dex file.
TEST_F(DexoptAnalyzerTest, LongDexExtension) {
std::string dex_location = GetScratchDir() + "/LongDexExtension.jarx";
Copy(GetDexSrc1(), dex_location);
Verify(dex_location, CompilerFilter::kSpeed);
}
// Case: Very short, non-existent Dex location.
TEST_F(DexoptAnalyzerTest, ShortDexLocation) {
std::string dex_location = "/xx";
Verify(dex_location, CompilerFilter::kSpeed);
}
} // namespace art