oat_test.cc revision f5df8974173124faddb8e2b6a331959afdb94fdf 
1/*
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 */
16
17#include "compiler/oat_writer.h"
18#include "compiler/compiler_backend.h"
19#include "mirror/art_method-inl.h"
20#include "mirror/class-inl.h"
21#include "mirror/object_array-inl.h"
22#include "mirror/object-inl.h"
23#include "oat_file.h"
24#include "vector_output_stream.h"
25
26#include "common_test.h"
27
28namespace art {
29
30class OatTest : public CommonTest {
31 protected:
32  static const bool kCompile = false;  // DISABLED_ due to the time to compile libcore
33
34  void CheckMethod(mirror::ArtMethod* method,
35                   const OatFile::OatMethod& oat_method,
36                   const DexFile* dex_file)
37      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
38    const CompiledMethod* compiled_method =
39        compiler_driver_->GetCompiledMethod(MethodReference(dex_file,
40                                                            method->GetDexMethodIndex()));
41
42    if (compiled_method == NULL) {
43      EXPECT_TRUE(oat_method.GetQuickCode() == NULL) << PrettyMethod(method) << " "
44                                                     << oat_method.GetQuickCode();
45      EXPECT_TRUE(oat_method.GetPortableCode() == NULL) << PrettyMethod(method) << " "
46                                                        << oat_method.GetPortableCode();
47      EXPECT_EQ(oat_method.GetFrameSizeInBytes(), 0U);
48      EXPECT_EQ(oat_method.GetCoreSpillMask(), 0U);
49      EXPECT_EQ(oat_method.GetFpSpillMask(), 0U);
50    } else {
51      const void* quick_oat_code = oat_method.GetQuickCode();
52      if (quick_oat_code != nullptr) {
53        EXPECT_EQ(oat_method.GetFrameSizeInBytes(), compiled_method->GetFrameSizeInBytes());
54        EXPECT_EQ(oat_method.GetCoreSpillMask(), compiled_method->GetCoreSpillMask());
55        EXPECT_EQ(oat_method.GetFpSpillMask(), compiled_method->GetFpSpillMask());
56        uintptr_t oat_code_aligned = RoundDown(reinterpret_cast<uintptr_t>(quick_oat_code), 2);
57        quick_oat_code = reinterpret_cast<const void*>(oat_code_aligned);
58        const std::vector<uint8_t>* quick_code = compiled_method->GetQuickCode();
59        EXPECT_TRUE(quick_code != nullptr);
60        size_t code_size = quick_code->size() * sizeof(quick_code[0]);
61        EXPECT_EQ(0, memcmp(quick_oat_code, &quick_code[0], code_size))
62            << PrettyMethod(method) << " " << code_size;
63        CHECK_EQ(0, memcmp(quick_oat_code, &quick_code[0], code_size));
64      } else {
65        const void* portable_oat_code = oat_method.GetPortableCode();
66        EXPECT_TRUE(portable_oat_code != nullptr) << PrettyMethod(method);
67        EXPECT_EQ(oat_method.GetFrameSizeInBytes(), 0U);
68        EXPECT_EQ(oat_method.GetCoreSpillMask(), 0U);
69        EXPECT_EQ(oat_method.GetFpSpillMask(), 0U);
70        uintptr_t oat_code_aligned = RoundDown(reinterpret_cast<uintptr_t>(portable_oat_code), 2);
71        portable_oat_code = reinterpret_cast<const void*>(oat_code_aligned);
72        const std::vector<uint8_t>* portable_code = compiled_method->GetPortableCode();
73        EXPECT_TRUE(portable_code != nullptr);
74        size_t code_size = portable_code->size() * sizeof(portable_code[0]);
75        EXPECT_EQ(0, memcmp(quick_oat_code, &portable_code[0], code_size))
76            << PrettyMethod(method) << " " << code_size;
77        CHECK_EQ(0, memcmp(quick_oat_code, &portable_code[0], code_size));
78      }
79    }
80  }
81};
82
83TEST_F(OatTest, WriteRead) {
84  TimingLogger timings("CommonTest::WriteRead", false, false);
85  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
86
87  // TODO: make selectable.
88  CompilerBackend::Kind compiler_backend = kUsePortableCompiler
89      ? CompilerBackend::kPortable
90      : CompilerBackend::kQuick;
91  InstructionSet insn_set = kIsTargetBuild ? kThumb2 : kX86;
92
93  InstructionSetFeatures insn_features;
94  verification_results_.reset(new VerificationResults);
95  method_inliner_map_.reset(new DexFileToMethodInlinerMap);
96  callbacks_.Reset(verification_results_.get(), method_inliner_map_.get());
97  timer_.reset(new CumulativeLogger("Compilation times"));
98  compiler_driver_.reset(new CompilerDriver(verification_results_.get(),
99                                            method_inliner_map_.get(),
100                                            compiler_backend, insn_set,
101                                            insn_features, false, NULL, 2, true, true,
102                                            timer_.get()));
103  jobject class_loader = NULL;
104  if (kCompile) {
105    TimingLogger timings("OatTest::WriteRead", false, false);
106    compiler_driver_->CompileAll(class_loader, class_linker->GetBootClassPath(), timings);
107  }
108
109  ScopedObjectAccess soa(Thread::Current());
110  ScratchFile tmp;
111  OatWriter oat_writer(class_linker->GetBootClassPath(),
112                       42U,
113                       4096U,
114                       "lue.art",
115                       compiler_driver_.get(),
116                       &timings);
117  bool success = compiler_driver_->WriteElf(GetTestAndroidRoot(),
118                                            !kIsTargetBuild,
119                                            class_linker->GetBootClassPath(),
120                                            oat_writer,
121                                            tmp.GetFile());
122  ASSERT_TRUE(success);
123
124  if (kCompile) {  // OatWriter strips the code, regenerate to compare
125    compiler_driver_->CompileAll(class_loader, class_linker->GetBootClassPath(), timings);
126  }
127  std::string error_msg;
128  UniquePtr<OatFile> oat_file(OatFile::Open(tmp.GetFilename(), tmp.GetFilename(), NULL, false,
129                                            &error_msg));
130  ASSERT_TRUE(oat_file.get() != nullptr) << error_msg;
131  const OatHeader& oat_header = oat_file->GetOatHeader();
132  ASSERT_TRUE(oat_header.IsValid());
133  ASSERT_EQ(1U, oat_header.GetDexFileCount());  // core
134  ASSERT_EQ(42U, oat_header.GetImageFileLocationOatChecksum());
135  ASSERT_EQ(4096U, oat_header.GetImageFileLocationOatDataBegin());
136  ASSERT_EQ("lue.art", oat_header.GetImageFileLocation());
137
138  const DexFile* dex_file = java_lang_dex_file_;
139  uint32_t dex_file_checksum = dex_file->GetLocationChecksum();
140  const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_file->GetLocation().c_str(),
141                                                                    &dex_file_checksum);
142  ASSERT_TRUE(oat_dex_file != nullptr);
143  CHECK_EQ(dex_file->GetLocationChecksum(), oat_dex_file->GetDexFileLocationChecksum());
144  for (size_t i = 0; i < dex_file->NumClassDefs(); i++) {
145    const DexFile::ClassDef& class_def = dex_file->GetClassDef(i);
146    const byte* class_data = dex_file->GetClassData(class_def);
147    size_t num_virtual_methods = 0;
148    if (class_data != NULL) {
149      ClassDataItemIterator it(*dex_file, class_data);
150      num_virtual_methods = it.NumVirtualMethods();
151    }
152    const char* descriptor = dex_file->GetClassDescriptor(class_def);
153    SirtRef<mirror::ClassLoader> loader(Thread::Current(), nullptr);
154    mirror::Class* klass = class_linker->FindClass(descriptor, loader);
155
156    UniquePtr<const OatFile::OatClass> oat_class(oat_dex_file->GetOatClass(i));
157    CHECK_EQ(mirror::Class::Status::kStatusNotReady, oat_class->GetStatus()) << descriptor;
158    CHECK_EQ(kCompile ? OatClassType::kOatClassAllCompiled : OatClassType::kOatClassNoneCompiled,
159             oat_class->GetType()) << descriptor;
160
161    size_t method_index = 0;
162    for (size_t i = 0; i < klass->NumDirectMethods(); i++, method_index++) {
163      CheckMethod(klass->GetDirectMethod(i),
164                  oat_class->GetOatMethod(method_index), dex_file);
165    }
166    for (size_t i = 0; i < num_virtual_methods; i++, method_index++) {
167      CheckMethod(klass->GetVirtualMethod(i),
168                  oat_class->GetOatMethod(method_index), dex_file);
169    }
170  }
171}
172
173TEST_F(OatTest, OatHeaderSizeCheck) {
174  // If this test is failing and you have to update these constants,
175  // it is time to update OatHeader::kOatVersion
176  EXPECT_EQ(76U, sizeof(OatHeader));
177  EXPECT_EQ(28U, sizeof(OatMethodOffsets));
178}
179
180TEST_F(OatTest, OatHeaderIsValid) {
181    InstructionSet instruction_set = kX86;
182    InstructionSetFeatures instruction_set_features;
183    std::vector<const DexFile*> dex_files;
184    uint32_t image_file_location_oat_checksum = 0;
185    uint32_t image_file_location_oat_begin = 0;
186    const std::string image_file_location;
187    OatHeader oat_header(instruction_set,
188                         instruction_set_features,
189                         &dex_files,
190                         image_file_location_oat_checksum,
191                         image_file_location_oat_begin,
192                         image_file_location);
193    ASSERT_TRUE(oat_header.IsValid());
194
195    char* magic = const_cast<char*>(oat_header.GetMagic());
196    strcpy(magic, "");  // bad magic
197    ASSERT_FALSE(oat_header.IsValid());
198    strcpy(magic, "oat\n000");  // bad version
199    ASSERT_FALSE(oat_header.IsValid());
200}
201
202}  // namespace art
203