blob: 030451c1cb779ee1f2877e3a561314400cca34cc [file] [log] [blame]
Elliott Hughes2faa5f12012-01-30 14:42:07 -08001/*
2 * Copyright (C) 2011 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
Brian Carlstrome24fa612011-09-29 00:53:55 -070016
Ian Rogersd582fa42014-11-05 23:46:43 -080017#include "arch/instruction_set_features.h"
Mathieu Chartiere401d142015-04-22 13:56:20 -070018#include "art_method-inl.h"
Mathieu Chartier07ddb6f2015-11-05 11:16:34 -080019#include "base/unix_file/fd_file.h"
Andreas Gampe53c913b2014-08-12 23:19:23 -070020#include "class_linker.h"
Brian Carlstroma1ce1fe2014-02-24 23:23:58 -080021#include "common_compiler_test.h"
Vladimir Marko20f85592015-03-19 10:07:02 +000022#include "compiled_method.h"
Ian Rogerse63db272014-07-15 15:36:11 -070023#include "compiler.h"
Mathieu Chartier5bdab122015-01-26 18:30:19 -080024#include "dex/pass_manager.h"
Ian Rogerse63db272014-07-15 15:36:11 -070025#include "dex/quick/dex_file_to_method_inliner_map.h"
26#include "dex/quick_compiler_callbacks.h"
Mathieu Chartier5bdab122015-01-26 18:30:19 -080027#include "dex/verification_results.h"
Vladimir Marko20f85592015-03-19 10:07:02 +000028#include "driver/compiler_driver.h"
29#include "driver/compiler_options.h"
Vladimir Marko7624d252014-05-02 14:40:15 +010030#include "entrypoints/quick/quick_entrypoints.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080031#include "mirror/class-inl.h"
Brian Carlstroma1ce1fe2014-02-24 23:23:58 -080032#include "mirror/object_array-inl.h"
Ian Rogerse63db272014-07-15 15:36:11 -070033#include "mirror/object-inl.h"
Vladimir Marko7624d252014-05-02 14:40:15 +010034#include "oat_file-inl.h"
Ian Rogerse63db272014-07-15 15:36:11 -070035#include "oat_writer.h"
36#include "scoped_thread_state_change.h"
Brian Carlstrom700c8d32012-11-05 10:42:02 -080037#include "vector_output_stream.h"
Brian Carlstrome24fa612011-09-29 00:53:55 -070038
Brian Carlstrome24fa612011-09-29 00:53:55 -070039namespace art {
40
Mathieu Chartier07ddb6f2015-11-05 11:16:34 -080041NO_RETURN static void Usage(const char* fmt, ...) {
42 va_list ap;
43 va_start(ap, fmt);
44 std::string error;
45 StringAppendV(&error, fmt, ap);
46 LOG(FATAL) << error;
47 va_end(ap);
48 UNREACHABLE();
49}
50
Brian Carlstroma1ce1fe2014-02-24 23:23:58 -080051class OatTest : public CommonCompilerTest {
Logan Chieneeb7edf2012-03-09 20:38:39 +080052 protected:
Brian Carlstromba150c32013-08-27 17:31:03 -070053 static const bool kCompile = false; // DISABLED_ due to the time to compile libcore
54
Mathieu Chartiere401d142015-04-22 13:56:20 -070055 void CheckMethod(ArtMethod* method,
Logan Chieneeb7edf2012-03-09 20:38:39 +080056 const OatFile::OatMethod& oat_method,
Richard Uhlerfbef44d2014-12-23 09:48:51 -080057 const DexFile& dex_file)
Mathieu Chartier90443472015-07-16 20:32:27 -070058 SHARED_REQUIRES(Locks::mutator_lock_) {
Logan Chieneeb7edf2012-03-09 20:38:39 +080059 const CompiledMethod* compiled_method =
Richard Uhlerfbef44d2014-12-23 09:48:51 -080060 compiler_driver_->GetCompiledMethod(MethodReference(&dex_file,
Brian Carlstrom51c24672013-07-11 16:00:56 -070061 method->GetDexMethodIndex()));
Logan Chieneeb7edf2012-03-09 20:38:39 +080062
Ian Rogersd4c4d952014-10-16 20:31:53 -070063 if (compiled_method == nullptr) {
64 EXPECT_TRUE(oat_method.GetQuickCode() == nullptr) << PrettyMethod(method) << " "
65 << oat_method.GetQuickCode();
Ian Rogersef7d42f2014-01-06 12:55:46 -080066 EXPECT_EQ(oat_method.GetFrameSizeInBytes(), 0U);
Logan Chieneeb7edf2012-03-09 20:38:39 +080067 EXPECT_EQ(oat_method.GetCoreSpillMask(), 0U);
68 EXPECT_EQ(oat_method.GetFpSpillMask(), 0U);
69 } else {
Ian Rogersef7d42f2014-01-06 12:55:46 -080070 const void* quick_oat_code = oat_method.GetQuickCode();
Elliott Hughes956af0f2014-12-11 14:34:28 -080071 EXPECT_TRUE(quick_oat_code != nullptr) << PrettyMethod(method);
72 EXPECT_EQ(oat_method.GetFrameSizeInBytes(), compiled_method->GetFrameSizeInBytes());
73 EXPECT_EQ(oat_method.GetCoreSpillMask(), compiled_method->GetCoreSpillMask());
74 EXPECT_EQ(oat_method.GetFpSpillMask(), compiled_method->GetFpSpillMask());
75 uintptr_t oat_code_aligned = RoundDown(reinterpret_cast<uintptr_t>(quick_oat_code), 2);
76 quick_oat_code = reinterpret_cast<const void*>(oat_code_aligned);
Vladimir Marko35831e82015-09-11 11:59:18 +010077 ArrayRef<const uint8_t> quick_code = compiled_method->GetQuickCode();
78 EXPECT_FALSE(quick_code.empty());
79 size_t code_size = quick_code.size() * sizeof(quick_code[0]);
Elliott Hughes956af0f2014-12-11 14:34:28 -080080 EXPECT_EQ(0, memcmp(quick_oat_code, &quick_code[0], code_size))
81 << PrettyMethod(method) << " " << code_size;
82 CHECK_EQ(0, memcmp(quick_oat_code, &quick_code[0], code_size));
Logan Chieneeb7edf2012-03-09 20:38:39 +080083 }
84 }
Mathieu Chartier07ddb6f2015-11-05 11:16:34 -080085
86 void SetupCompiler(Compiler::Kind compiler_kind,
87 InstructionSet insn_set,
88 const std::vector<std::string>& compiler_options,
89 /*out*/std::string* error_msg) {
90 ASSERT_TRUE(error_msg != nullptr);
91 insn_features_.reset(InstructionSetFeatures::FromVariant(insn_set, "default", error_msg));
92 ASSERT_TRUE(insn_features_ != nullptr) << error_msg;
93 compiler_options_.reset(new CompilerOptions);
94 for (const std::string& option : compiler_options) {
95 compiler_options_->ParseCompilerOption(option, Usage);
96 }
97 verification_results_.reset(new VerificationResults(compiler_options_.get()));
98 method_inliner_map_.reset(new DexFileToMethodInlinerMap);
99 callbacks_.reset(new QuickCompilerCallbacks(verification_results_.get(),
100 method_inliner_map_.get(),
101 CompilerCallbacks::CallbackMode::kCompileApp));
102 Runtime::Current()->SetCompilerCallbacks(callbacks_.get());
103 timer_.reset(new CumulativeLogger("Compilation times"));
104 compiler_driver_.reset(new CompilerDriver(compiler_options_.get(),
105 verification_results_.get(),
106 method_inliner_map_.get(),
107 compiler_kind,
108 insn_set,
109 insn_features_.get(),
110 false,
111 nullptr,
112 nullptr,
113 nullptr,
114 2,
115 true,
116 true,
117 "",
118 false,
119 timer_.get(),
120 -1,
121 ""));
122 }
123
124 bool WriteElf(File* file,
125 const std::vector<const DexFile*>& dex_files,
126 SafeMap<std::string, std::string>& key_value_store) {
127 TimingLogger timings("WriteElf", false, false);
128 OatWriter oat_writer(dex_files,
129 42U,
130 4096U,
131 0,
132 compiler_driver_.get(),
133 nullptr,
Mathieu Chartierda5b28a2015-11-05 08:03:47 -0800134 /*compiling_boot_image*/false,
Mathieu Chartier07ddb6f2015-11-05 11:16:34 -0800135 &timings,
136 &key_value_store);
137 return compiler_driver_->WriteElf(GetTestAndroidRoot(),
138 !kIsTargetBuild,
139 dex_files,
140 &oat_writer,
141 file);
142 }
143
144 std::unique_ptr<const InstructionSetFeatures> insn_features_;
145 std::unique_ptr<QuickCompilerCallbacks> callbacks_;
Logan Chieneeb7edf2012-03-09 20:38:39 +0800146};
Brian Carlstrome24fa612011-09-29 00:53:55 -0700147
148TEST_F(OatTest, WriteRead) {
Brian Carlstroma1ce1fe2014-02-24 23:23:58 -0800149 TimingLogger timings("OatTest::WriteRead", false, false);
Jesse Wilson254db0f2011-11-16 16:44:11 -0500150 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
Brian Carlstrome24fa612011-09-29 00:53:55 -0700151
Ian Rogersef7d42f2014-01-06 12:55:46 -0800152 // TODO: make selectable.
Elliott Hughes956af0f2014-12-11 14:34:28 -0800153 Compiler::Kind compiler_kind = Compiler::kQuick;
Ian Rogersa073c672013-07-30 17:43:55 -0700154 InstructionSet insn_set = kIsTargetBuild ? kThumb2 : kX86;
Ian Rogers6f3dbba2014-10-14 17:41:57 -0700155 std::string error_msg;
Mathieu Chartier07ddb6f2015-11-05 11:16:34 -0800156 SetupCompiler(compiler_kind, insn_set, std::vector<std::string>(), /*out*/ &error_msg);
157
Ian Rogersd4c4d952014-10-16 20:31:53 -0700158 jobject class_loader = nullptr;
Brian Carlstromba150c32013-08-27 17:31:03 -0700159 if (kCompile) {
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800160 TimingLogger timings2("OatTest::WriteRead", false, false);
Vladimir Markod1eaf0d2015-10-29 12:18:29 +0000161 compiler_driver_->SetDexFilesForOatFile(class_linker->GetBootClassPath());
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800162 compiler_driver_->CompileAll(class_loader, class_linker->GetBootClassPath(), &timings2);
Brian Carlstrome24fa612011-09-29 00:53:55 -0700163 }
164
165 ScratchFile tmp;
Andreas Gampe22f8e5c2014-07-09 11:38:21 -0700166 SafeMap<std::string, std::string> key_value_store;
167 key_value_store.Put(OatHeader::kImageLocationKey, "lue.art");
Mathieu Chartier07ddb6f2015-11-05 11:16:34 -0800168 bool success = WriteElf(tmp.GetFile(), class_linker->GetBootClassPath(), key_value_store);
Brian Carlstromc50d8e12013-07-23 22:35:16 -0700169 ASSERT_TRUE(success);
Brian Carlstrome24fa612011-09-29 00:53:55 -0700170
Brian Carlstromba150c32013-08-27 17:31:03 -0700171 if (kCompile) { // OatWriter strips the code, regenerate to compare
Ian Rogers3d504072014-03-01 09:16:49 -0800172 compiler_driver_->CompileAll(class_loader, class_linker->GetBootClassPath(), &timings);
Brian Carlstrome24fa612011-09-29 00:53:55 -0700173 }
Ian Rogersd4c4d952014-10-16 20:31:53 -0700174 std::unique_ptr<OatFile> oat_file(OatFile::Open(tmp.GetFilename(), tmp.GetFilename(), nullptr,
Igor Murashkinb1d8c312015-08-04 11:18:43 -0700175 nullptr, false, nullptr, &error_msg));
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700176 ASSERT_TRUE(oat_file.get() != nullptr) << error_msg;
Brian Carlstrome24fa612011-09-29 00:53:55 -0700177 const OatHeader& oat_header = oat_file->GetOatHeader();
Brian Carlstromf852fb22012-10-19 11:01:58 -0700178 ASSERT_TRUE(oat_header.IsValid());
Brian Carlstrom919b11c2013-08-30 13:30:36 -0700179 ASSERT_EQ(1U, oat_header.GetDexFileCount()); // core
Brian Carlstrom28db0122012-10-18 16:20:41 -0700180 ASSERT_EQ(42U, oat_header.GetImageFileLocationOatChecksum());
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800181 ASSERT_EQ(4096U, oat_header.GetImageFileLocationOatDataBegin());
Andreas Gampe22f8e5c2014-07-09 11:38:21 -0700182 ASSERT_EQ("lue.art", std::string(oat_header.GetStoreValueByKey(OatHeader::kImageLocationKey)));
Brian Carlstrome24fa612011-09-29 00:53:55 -0700183
Richard Uhlerfbef44d2014-12-23 09:48:51 -0800184 ASSERT_TRUE(java_lang_dex_file_ != nullptr);
185 const DexFile& dex_file = *java_lang_dex_file_;
186 uint32_t dex_file_checksum = dex_file.GetLocationChecksum();
187 const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_file.GetLocation().c_str(),
Brian Carlstrom756ee4e2013-10-03 15:46:12 -0700188 &dex_file_checksum);
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700189 ASSERT_TRUE(oat_dex_file != nullptr);
Richard Uhlerfbef44d2014-12-23 09:48:51 -0800190 CHECK_EQ(dex_file.GetLocationChecksum(), oat_dex_file->GetDexFileLocationChecksum());
Vladimir Markof4da6752014-08-01 19:04:18 +0100191 ScopedObjectAccess soa(Thread::Current());
Mathieu Chartiere401d142015-04-22 13:56:20 -0700192 auto pointer_size = class_linker->GetImagePointerSize();
Richard Uhlerfbef44d2014-12-23 09:48:51 -0800193 for (size_t i = 0; i < dex_file.NumClassDefs(); i++) {
194 const DexFile::ClassDef& class_def = dex_file.GetClassDef(i);
195 const uint8_t* class_data = dex_file.GetClassData(class_def);
Mathieu Chartiere401d142015-04-22 13:56:20 -0700196
Brian Carlstromba150c32013-08-27 17:31:03 -0700197 size_t num_virtual_methods = 0;
Ian Rogersd4c4d952014-10-16 20:31:53 -0700198 if (class_data != nullptr) {
Richard Uhlerfbef44d2014-12-23 09:48:51 -0800199 ClassDataItemIterator it(dex_file, class_data);
Ian Rogers0571d352011-11-03 19:51:38 -0700200 num_virtual_methods = it.NumVirtualMethods();
201 }
Mathieu Chartiere401d142015-04-22 13:56:20 -0700202
Richard Uhlerfbef44d2014-12-23 09:48:51 -0800203 const char* descriptor = dex_file.GetClassDescriptor(class_def);
Mathieu Chartier0cd81352014-05-22 16:48:55 -0700204 mirror::Class* klass = class_linker->FindClass(soa.Self(), descriptor,
205 NullHandle<mirror::ClassLoader>());
Brian Carlstrome24fa612011-09-29 00:53:55 -0700206
Vladimir Markod3c5beb2014-04-11 16:32:51 +0100207 const OatFile::OatClass oat_class = oat_dex_file->GetOatClass(i);
208 CHECK_EQ(mirror::Class::Status::kStatusNotReady, oat_class.GetStatus()) << descriptor;
Brian Carlstromba150c32013-08-27 17:31:03 -0700209 CHECK_EQ(kCompile ? OatClassType::kOatClassAllCompiled : OatClassType::kOatClassNoneCompiled,
Vladimir Markod3c5beb2014-04-11 16:32:51 +0100210 oat_class.GetType()) << descriptor;
Brian Carlstrome24fa612011-09-29 00:53:55 -0700211
212 size_t method_index = 0;
Mathieu Chartiere401d142015-04-22 13:56:20 -0700213 for (auto& m : klass->GetDirectMethods(pointer_size)) {
214 CheckMethod(&m, oat_class.GetOatMethod(method_index), dex_file);
215 ++method_index;
Brian Carlstrome24fa612011-09-29 00:53:55 -0700216 }
Mathieu Chartiere401d142015-04-22 13:56:20 -0700217 size_t visited_virtuals = 0;
218 for (auto& m : klass->GetVirtualMethods(pointer_size)) {
219 if (!m.IsMiranda()) {
220 CheckMethod(&m, oat_class.GetOatMethod(method_index), dex_file);
221 ++method_index;
222 ++visited_virtuals;
223 }
Brian Carlstrome24fa612011-09-29 00:53:55 -0700224 }
Mathieu Chartiere401d142015-04-22 13:56:20 -0700225 EXPECT_EQ(visited_virtuals, num_virtual_methods);
Brian Carlstrome24fa612011-09-29 00:53:55 -0700226 }
227}
228
Brian Carlstrom341df942012-06-27 12:29:22 -0700229TEST_F(OatTest, OatHeaderSizeCheck) {
230 // If this test is failing and you have to update these constants,
231 // it is time to update OatHeader::kOatVersion
Elliott Hughes956af0f2014-12-11 14:34:28 -0800232 EXPECT_EQ(72U, sizeof(OatHeader));
Mathieu Chartier957ca1c2014-11-21 16:51:29 -0800233 EXPECT_EQ(4U, sizeof(OatMethodOffsets));
234 EXPECT_EQ(28U, sizeof(OatQuickMethodHeader));
Roland Levillain0d5a2812015-11-13 10:07:31 +0000235 EXPECT_EQ(114 * GetInstructionSetPointerSize(kRuntimeISA), sizeof(QuickEntryPoints));
Brian Carlstrom341df942012-06-27 12:29:22 -0700236}
237
Brian Carlstromf852fb22012-10-19 11:01:58 -0700238TEST_F(OatTest, OatHeaderIsValid) {
Ian Rogers6f3dbba2014-10-14 17:41:57 -0700239 InstructionSet insn_set = kX86;
240 std::string error_msg;
241 std::unique_ptr<const InstructionSetFeatures> insn_features(
Igor Murashkinb1d8c312015-08-04 11:18:43 -0700242 InstructionSetFeatures::FromVariant(insn_set, "default", &error_msg));
Ian Rogers6f3dbba2014-10-14 17:41:57 -0700243 ASSERT_TRUE(insn_features.get() != nullptr) << error_msg;
Brian Carlstromf852fb22012-10-19 11:01:58 -0700244 std::vector<const DexFile*> dex_files;
245 uint32_t image_file_location_oat_checksum = 0;
246 uint32_t image_file_location_oat_begin = 0;
Ian Rogers6f3dbba2014-10-14 17:41:57 -0700247 std::unique_ptr<OatHeader> oat_header(OatHeader::Create(insn_set,
248 insn_features.get(),
Andreas Gampe928f72b2014-09-09 19:53:48 -0700249 &dex_files,
250 image_file_location_oat_checksum,
251 image_file_location_oat_begin,
252 nullptr));
253 ASSERT_NE(oat_header.get(), nullptr);
Andreas Gampe22f8e5c2014-07-09 11:38:21 -0700254 ASSERT_TRUE(oat_header->IsValid());
Brian Carlstromf852fb22012-10-19 11:01:58 -0700255
Andreas Gampe22f8e5c2014-07-09 11:38:21 -0700256 char* magic = const_cast<char*>(oat_header->GetMagic());
Brian Carlstromf852fb22012-10-19 11:01:58 -0700257 strcpy(magic, ""); // bad magic
Andreas Gampe22f8e5c2014-07-09 11:38:21 -0700258 ASSERT_FALSE(oat_header->IsValid());
Brian Carlstrom7934ac22013-07-26 10:54:15 -0700259 strcpy(magic, "oat\n000"); // bad version
Andreas Gampe22f8e5c2014-07-09 11:38:21 -0700260 ASSERT_FALSE(oat_header->IsValid());
Brian Carlstromf852fb22012-10-19 11:01:58 -0700261}
262
Mathieu Chartier07ddb6f2015-11-05 11:16:34 -0800263TEST_F(OatTest, EmptyTextSection) {
264 TimingLogger timings("OatTest::EmptyTextSection", false, false);
265
266 // TODO: make selectable.
267 Compiler::Kind compiler_kind = Compiler::kQuick;
268 InstructionSet insn_set = kRuntimeISA;
269 if (insn_set == kArm) insn_set = kThumb2;
270 std::string error_msg;
271 std::vector<std::string> compiler_options;
272 compiler_options.push_back("--compiler-filter=verify-at-runtime");
273 SetupCompiler(compiler_kind, insn_set, compiler_options, /*out*/ &error_msg);
274
275 jobject class_loader;
276 {
277 ScopedObjectAccess soa(Thread::Current());
278 class_loader = LoadDex("Main");
279 }
280 ASSERT_TRUE(class_loader != nullptr);
281 std::vector<const DexFile*> dex_files = GetDexFiles(class_loader);
282 ASSERT_TRUE(!dex_files.empty());
283
284 ClassLinker* const class_linker = Runtime::Current()->GetClassLinker();
285 for (const DexFile* dex_file : dex_files) {
286 ScopedObjectAccess soa(Thread::Current());
287 class_linker->RegisterDexFile(
288 *dex_file,
289 class_linker->GetOrCreateAllocatorForClassLoader(
290 soa.Decode<mirror::ClassLoader*>(class_loader)));
291 }
292 compiler_driver_->SetDexFilesForOatFile(dex_files);
293 compiler_driver_->CompileAll(class_loader, dex_files, &timings);
294
295 ScratchFile tmp;
296 SafeMap<std::string, std::string> key_value_store;
297 key_value_store.Put(OatHeader::kImageLocationKey, "test.art");
298 bool success = WriteElf(tmp.GetFile(), dex_files, key_value_store);
299 ASSERT_TRUE(success);
300
301 std::unique_ptr<OatFile> oat_file(OatFile::Open(tmp.GetFilename(),
302 tmp.GetFilename(),
303 nullptr,
304 nullptr,
305 false,
306 nullptr,
307 &error_msg));
308 ASSERT_TRUE(oat_file != nullptr);
309 EXPECT_LT(static_cast<size_t>(oat_file->Size()), static_cast<size_t>(tmp.GetFile()->GetLength()));
310}
311
Brian Carlstrome24fa612011-09-29 00:53:55 -0700312} // namespace art