image_writer.cc revision b062fdd4cb097fbae69b4bcb479c34d83ecab8ca
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 "image_writer.h" 18 19#include <sys/stat.h> 20 21#include <vector> 22 23#include "class_linker.h" 24#include "class_loader.h" 25#include "compiled_method.h" 26#include "compiler.h" 27#include "dex_cache.h" 28#include "file.h" 29#include "globals.h" 30#include "heap.h" 31#include "image.h" 32#include "intern_table.h" 33#include "logging.h" 34#include "oat_file.h" 35#include "object.h" 36#include "object_utils.h" 37#include "runtime.h" 38#include "space.h" 39#include "UniquePtr.h" 40#include "utils.h" 41 42namespace art { 43 44bool ImageWriter::Write(const std::string& image_filename, 45 uintptr_t image_begin, 46 const std::string& oat_filename, 47 const std::string& oat_location, 48 const Compiler& compiler) { 49 CHECK(!image_filename.empty()); 50 51 CHECK_NE(image_begin, 0U); 52 image_begin_ = reinterpret_cast<byte*>(image_begin); 53 54 Heap* heap = Runtime::Current()->GetHeap(); 55 const Spaces& spaces = heap->GetSpaces(); 56 57 ClassLinker* class_linker = Runtime::Current()->GetClassLinker(); 58 const std::vector<DexCache*>& all_dex_caches = class_linker->GetDexCaches(); 59 for (size_t i = 0; i < all_dex_caches.size(); i++) { 60 DexCache* dex_cache = all_dex_caches[i]; 61 if (InSourceSpace(dex_cache)) { 62 dex_caches_.insert(dex_cache); 63 } 64 } 65 66 oat_file_ = OatFile::Open(oat_filename, oat_location, NULL, 67 OatFile::kRelocNone, true); 68 if (oat_file_ == NULL) { 69 LOG(ERROR) << "Failed to open oat file " << oat_filename; 70 return false; 71 } 72 class_linker->RegisterOatFile(*oat_file_); 73 74 PruneNonImageClasses(); // Remove junk 75 ComputeLazyFieldsForImageClasses(); // Add useful information 76 ComputeEagerResolvedStrings(); 77 heap->CollectGarbage(false); // Remove garbage 78 // Trim size of alloc spaces 79 // TODO: C++0x auto 80 for (Spaces::const_iterator cur = spaces.begin(); cur != spaces.end(); ++cur) { 81 if ((*cur)->IsAllocSpace()) { 82 (*cur)->AsAllocSpace()->Trim(); 83 } 84 } 85 86 if (!AllocMemory()) { 87 return false; 88 } 89#ifndef NDEBUG 90 CheckNonImageClassesRemoved(); 91#endif 92 heap->DisableCardMarking(); 93 CalculateNewObjectOffsets(); 94 CopyAndFixupObjects(); 95 PatchOatCodeAndMethods(compiler); 96 97 UniquePtr<File> file(OS::OpenFile(image_filename.c_str(), true)); 98 if (file.get() == NULL) { 99 LOG(ERROR) << "Failed to open image file " << image_filename; 100 return false; 101 } 102 if (fchmod(file->Fd(), 0644) != 0) { 103 PLOG(ERROR) << "Failed to make image file world readable: " << image_filename; 104 return EXIT_FAILURE; 105 } 106 bool success = file->WriteFully(image_->Begin(), image_end_); 107 if (!success) { 108 PLOG(ERROR) << "Failed to write image file " << image_filename; 109 return false; 110 } 111 return true; 112} 113 114bool ImageWriter::InSourceSpace(const Object* object) const { 115 const Spaces& spaces = Runtime::Current()->GetHeap()->GetSpaces(); 116 // TODO: C++0x auto 117 for (Spaces::const_iterator cur = spaces.begin(); cur != spaces.end(); ++cur) { 118 if ((*cur)->IsAllocSpace() && (*cur)->Contains(object)) { 119 return true; 120 } 121 } 122 return false; 123} 124 125bool ImageWriter::AllocMemory() { 126 typedef std::vector<Space*> SpaceVec; 127 const SpaceVec& spaces = Runtime::Current()->GetHeap()->GetSpaces(); 128 size_t size = 0; 129 for (SpaceVec::const_iterator cur = spaces.begin(); cur != spaces.end(); ++cur) { 130 if ((*cur)->IsAllocSpace()) { 131 size += (*cur)->Size(); 132 } 133 } 134 135 int prot = PROT_READ | PROT_WRITE; 136 size_t length = RoundUp(size, kPageSize); 137 image_.reset(MemMap::MapAnonymous("image-writer-image", NULL, length, prot)); 138 if (image_.get() == NULL) { 139 LOG(ERROR) << "Failed to allocate memory for image file generation"; 140 return false; 141 } 142 return true; 143} 144 145void ImageWriter::ComputeLazyFieldsForImageClasses() { 146 Runtime* runtime = Runtime::Current(); 147 ClassLinker* class_linker = runtime->GetClassLinker(); 148 class_linker->VisitClasses(ComputeLazyFieldsForClassesVisitor, NULL); 149} 150 151bool ImageWriter::ComputeLazyFieldsForClassesVisitor(Class* c, void* /*arg*/) { 152 c->ComputeName(); 153 return true; 154} 155 156void ImageWriter::ComputeEagerResolvedStringsCallback(Object* obj, void* arg) { 157 if (!obj->GetClass()->IsStringClass()) { 158 return; 159 } 160 String* string = obj->AsString(); 161 std::string utf8_string(string->ToModifiedUtf8()); 162 ImageWriter* writer = reinterpret_cast<ImageWriter*>(arg); 163 ClassLinker* linker = Runtime::Current()->GetClassLinker(); 164 typedef Set::const_iterator CacheIt; // TODO: C++0x auto 165 for (CacheIt it = writer->dex_caches_.begin(), end = writer->dex_caches_.end(); it != end; ++it) { 166 DexCache* dex_cache = *it; 167 const DexFile& dex_file = linker->FindDexFile(dex_cache); 168 const DexFile::StringId* string_id = dex_file.FindStringId(utf8_string); 169 if (string_id != NULL) { 170 // This string occurs in this dex file, assign the dex cache entry. 171 uint32_t string_idx = dex_file.GetIndexForStringId(*string_id); 172 if (dex_cache->GetResolvedString(string_idx) == NULL) { 173 dex_cache->SetResolvedString(string_idx, string); 174 } 175 } 176 } 177} 178 179void ImageWriter::ComputeEagerResolvedStrings() { 180 // TODO: Check image spaces only? 181 Runtime::Current()->GetHeap()->GetLiveBitmap()->Walk(ComputeEagerResolvedStringsCallback, this); 182} 183 184bool ImageWriter::IsImageClass(const Class* klass) { 185 if (image_classes_ == NULL) { 186 return true; 187 } 188 while (klass->IsArrayClass()) { 189 klass = klass->GetComponentType(); 190 } 191 if (klass->IsPrimitive()) { 192 return true; 193 } 194 const std::string descriptor(ClassHelper(klass).GetDescriptor()); 195 return image_classes_->find(descriptor) != image_classes_->end(); 196} 197 198 199struct NonImageClasses { 200 ImageWriter* image_writer; 201 std::set<std::string>* non_image_classes; 202}; 203 204void ImageWriter::PruneNonImageClasses() { 205 if (image_classes_ == NULL) { 206 return; 207 } 208 Runtime* runtime = Runtime::Current(); 209 ClassLinker* class_linker = runtime->GetClassLinker(); 210 211 std::set<std::string> non_image_classes; 212 NonImageClasses context; 213 context.image_writer = this; 214 context.non_image_classes = &non_image_classes; 215 class_linker->VisitClasses(NonImageClassesVisitor, &context); 216 217 typedef std::set<std::string>::const_iterator ClassIt; // TODO: C++0x auto 218 for (ClassIt it = non_image_classes.begin(), end = non_image_classes.end(); it != end; ++it) { 219 class_linker->RemoveClass((*it).c_str(), NULL); 220 } 221 222 Method* resolution_method = runtime->GetResolutionMethod(); 223 typedef Set::const_iterator CacheIt; // TODO: C++0x auto 224 for (CacheIt it = dex_caches_.begin(), end = dex_caches_.end(); it != end; ++it) { 225 DexCache* dex_cache = *it; 226 for (size_t i = 0; i < dex_cache->NumResolvedTypes(); i++) { 227 Class* klass = dex_cache->GetResolvedType(i); 228 if (klass != NULL && !IsImageClass(klass)) { 229 dex_cache->SetResolvedType(i, NULL); 230 dex_cache->GetInitializedStaticStorage()->Set(i, NULL); 231 } 232 } 233 for (size_t i = 0; i < dex_cache->NumResolvedMethods(); i++) { 234 Method* method = dex_cache->GetResolvedMethod(i); 235 if (method != NULL && !IsImageClass(method->GetDeclaringClass())) { 236 dex_cache->SetResolvedMethod(i, resolution_method); 237 } 238 } 239 for (size_t i = 0; i < dex_cache->NumResolvedFields(); i++) { 240 Field* field = dex_cache->GetResolvedField(i); 241 if (field != NULL && !IsImageClass(field->GetDeclaringClass())) { 242 dex_cache->SetResolvedField(i, NULL); 243 } 244 } 245 } 246} 247 248bool ImageWriter::NonImageClassesVisitor(Class* klass, void* arg) { 249 NonImageClasses* context = reinterpret_cast<NonImageClasses*>(arg); 250 if (!context->image_writer->IsImageClass(klass)) { 251 context->non_image_classes->insert(ClassHelper(klass).GetDescriptor()); 252 } 253 return true; 254} 255 256void ImageWriter::CheckNonImageClassesRemoved() { 257 if (image_classes_ == NULL) { 258 return; 259 } 260 261 Runtime::Current()->GetHeap()->GetLiveBitmap()->Walk(CheckNonImageClassesRemovedCallback, this); 262} 263 264void ImageWriter::CheckNonImageClassesRemovedCallback(Object* obj, void* arg) { 265 ImageWriter* image_writer = reinterpret_cast<ImageWriter*>(arg); 266 if (!obj->IsClass()) { 267 return; 268 } 269 Class* klass = obj->AsClass(); 270 if (!image_writer->IsImageClass(klass)) { 271 image_writer->DumpImageClasses(); 272 CHECK(image_writer->IsImageClass(klass)) << ClassHelper(klass).GetDescriptor() 273 << " " << PrettyDescriptor(klass); 274 } 275} 276 277void ImageWriter::DumpImageClasses() { 278 typedef std::set<std::string>::const_iterator It; // TODO: C++0x auto 279 for (It it = image_classes_->begin(), end = image_classes_->end(); it != end; ++it) { 280 LOG(INFO) << " " << *it; 281 } 282} 283 284void ImageWriter::CalculateNewObjectOffsetsCallback(Object* obj, void* arg) { 285 DCHECK(obj != NULL); 286 DCHECK(arg != NULL); 287 ImageWriter* image_writer = reinterpret_cast<ImageWriter*>(arg); 288 if (!image_writer->InSourceSpace(obj)) { 289 return; 290 } 291 292 // if it is a string, we want to intern it if its not interned. 293 if (obj->GetClass()->IsStringClass()) { 294 // we must be an interned string that was forward referenced and already assigned 295 if (image_writer->IsImageOffsetAssigned(obj)) { 296 DCHECK_EQ(obj, obj->AsString()->Intern()); 297 return; 298 } 299 SirtRef<String> interned(obj->AsString()->Intern()); 300 if (obj != interned.get()) { 301 if (!image_writer->IsImageOffsetAssigned(interned.get())) { 302 // interned obj is after us, allocate its location early 303 image_writer->AssignImageOffset(interned.get()); 304 } 305 // point those looking for this object to the interned version. 306 image_writer->SetImageOffset(obj, image_writer->GetImageOffset(interned.get())); 307 return; 308 } 309 // else (obj == interned), nothing to do but fall through to the normal case 310 } 311 312 image_writer->AssignImageOffset(obj); 313} 314 315ObjectArray<Object>* ImageWriter::CreateImageRoots() const { 316 Runtime* runtime = Runtime::Current(); 317 ClassLinker* class_linker = runtime->GetClassLinker(); 318 Class* object_array_class = class_linker->FindSystemClass("[Ljava/lang/Object;"); 319 320 // build an Object[] of all the DexCaches used in the source_space_ 321 ObjectArray<Object>* dex_caches = ObjectArray<Object>::Alloc(object_array_class, 322 dex_caches_.size()); 323 int i = 0; 324 typedef Set::const_iterator It; // TODO: C++0x auto 325 for (It it = dex_caches_.begin(), end = dex_caches_.end(); it != end; ++it, ++i) { 326 dex_caches->Set(i, *it); 327 } 328 329 // build an Object[] of the roots needed to restore the runtime 330 SirtRef<ObjectArray<Object> > image_roots( 331 ObjectArray<Object>::Alloc(object_array_class, ImageHeader::kImageRootsMax)); 332 image_roots->Set(ImageHeader::kJniStubArray, runtime->GetJniDlsymLookupStub()); 333 image_roots->Set(ImageHeader::kAbstractMethodErrorStubArray, 334 runtime->GetAbstractMethodErrorStubArray()); 335 image_roots->Set(ImageHeader::kStaticResolutionStubArray, 336 runtime->GetResolutionStubArray(Runtime::kStaticMethod)); 337 image_roots->Set(ImageHeader::kUnknownMethodResolutionStubArray, 338 runtime->GetResolutionStubArray(Runtime::kUnknownMethod)); 339 image_roots->Set(ImageHeader::kResolutionMethod, runtime->GetResolutionMethod()); 340 image_roots->Set(ImageHeader::kCalleeSaveMethod, 341 runtime->GetCalleeSaveMethod(Runtime::kSaveAll)); 342 image_roots->Set(ImageHeader::kRefsOnlySaveMethod, 343 runtime->GetCalleeSaveMethod(Runtime::kRefsOnly)); 344 image_roots->Set(ImageHeader::kRefsAndArgsSaveMethod, 345 runtime->GetCalleeSaveMethod(Runtime::kRefsAndArgs)); 346 image_roots->Set(ImageHeader::kOatLocation, 347 String::AllocFromModifiedUtf8(oat_file_->GetLocation().c_str())); 348 image_roots->Set(ImageHeader::kDexCaches, 349 dex_caches); 350 image_roots->Set(ImageHeader::kClassRoots, 351 class_linker->GetClassRoots()); 352 for (int i = 0; i < ImageHeader::kImageRootsMax; i++) { 353 CHECK(image_roots->Get(i) != NULL); 354 } 355 return image_roots.get(); 356} 357 358void ImageWriter::CalculateNewObjectOffsets() { 359 SirtRef<ObjectArray<Object> > image_roots(CreateImageRoots()); 360 361 Heap* heap = Runtime::Current()->GetHeap(); 362 typedef std::vector<Space*> SpaceVec; 363 const SpaceVec& spaces = heap->GetSpaces(); 364 DCHECK(!spaces.empty()); 365 DCHECK_EQ(0U, image_end_); 366 367 // leave space for the header, but do not write it yet, we need to 368 // know where image_roots is going to end up 369 image_end_ += RoundUp(sizeof(ImageHeader), 8); // 64-bit-alignment 370 371 // TODO: Image spaces only? 372 for (SpaceVec::const_iterator cur = spaces.begin(); cur != spaces.end(); ++cur) { 373 (*cur)->GetLiveBitmap()->InOrderWalk(CalculateNewObjectOffsetsCallback, this); 374 DCHECK_LT(image_end_, image_->Size()); 375 } 376 377 // Note that image_top_ is left at end of used space 378 oat_begin_ = image_begin_ + RoundUp(image_end_, kPageSize); 379 const byte* oat_limit = oat_begin_ + oat_file_->Size(); 380 381 // return to write header at start of image with future location of image_roots 382 ImageHeader image_header(reinterpret_cast<uint32_t>(image_begin_), 383 reinterpret_cast<uint32_t>(GetImageAddress(image_roots.get())), 384 oat_file_->GetOatHeader().GetChecksum(), 385 reinterpret_cast<uint32_t>(oat_begin_), 386 reinterpret_cast<uint32_t>(oat_limit)); 387 memcpy(image_->Begin(), &image_header, sizeof(image_header)); 388} 389 390void ImageWriter::CopyAndFixupObjects() { 391 Heap* heap = Runtime::Current()->GetHeap(); 392 // TODO: heap validation can't handle this fix up pass 393 heap->DisableObjectValidation(); 394 // TODO: Image spaces only? 395 heap->GetLiveBitmap()->Walk(CopyAndFixupObjectsCallback, this); 396} 397 398void ImageWriter::CopyAndFixupObjectsCallback(Object* object, void* arg) { 399 DCHECK(object != NULL); 400 DCHECK(arg != NULL); 401 const Object* obj = object; 402 ImageWriter* image_writer = reinterpret_cast<ImageWriter*>(arg); 403 if (!image_writer->InSourceSpace(object)) { 404 return; 405 } 406 407 // see GetLocalAddress for similar computation 408 size_t offset = image_writer->GetImageOffset(obj); 409 byte* dst = image_writer->image_->Begin() + offset; 410 const byte* src = reinterpret_cast<const byte*>(obj); 411 size_t n = obj->SizeOf(); 412 DCHECK_LT(offset + n, image_writer->image_->Size()); 413 memcpy(dst, src, n); 414 Object* copy = reinterpret_cast<Object*>(dst); 415 copy->monitor_ = 0; // We may have inflated the lock during compilation. 416 image_writer->FixupObject(obj, copy); 417} 418 419void ImageWriter::FixupObject(const Object* orig, Object* copy) { 420 DCHECK(orig != NULL); 421 DCHECK(copy != NULL); 422 copy->SetClass(down_cast<Class*>(GetImageAddress(orig->GetClass()))); 423 // TODO: special case init of pointers to malloc data (or removal of these pointers) 424 if (orig->IsClass()) { 425 FixupClass(orig->AsClass(), down_cast<Class*>(copy)); 426 } else if (orig->IsObjectArray()) { 427 FixupObjectArray(orig->AsObjectArray<Object>(), down_cast<ObjectArray<Object>*>(copy)); 428 } else if (orig->IsMethod()) { 429 FixupMethod(orig->AsMethod(), down_cast<Method*>(copy)); 430 } else { 431 FixupInstanceFields(orig, copy); 432 } 433} 434 435void ImageWriter::FixupClass(const Class* orig, Class* copy) { 436 FixupInstanceFields(orig, copy); 437 FixupStaticFields(orig, copy); 438} 439 440void ImageWriter::FixupMethod(const Method* orig, Method* copy) { 441 FixupInstanceFields(orig, copy); 442 443 // OatWriter replaces the code_ and invoke_stub_ with offset values. 444 // Here we readjust to a pointer relative to oat_begin_ 445 446 // Every type of method can have an invoke stub 447 uint32_t invoke_stub_offset = orig->GetOatInvokeStubOffset(); 448 const byte* invoke_stub = GetOatAddress(invoke_stub_offset); 449 copy->invoke_stub_ = reinterpret_cast<const Method::InvokeStub*>(invoke_stub); 450 451 if (orig->IsAbstract()) { 452 // Abstract methods are pointed to a stub that will throw AbstractMethodError if they are called 453 ByteArray* orig_ame_stub_array_ = Runtime::Current()->GetAbstractMethodErrorStubArray(); 454 ByteArray* copy_ame_stub_array_ = down_cast<ByteArray*>(GetImageAddress(orig_ame_stub_array_)); 455 copy->code_ = copy_ame_stub_array_->GetData(); 456 return; 457 } 458 459 if (orig == Runtime::Current()->GetResolutionMethod()) { 460 // The resolution stub's code points at the unknown resolution trampoline 461 ByteArray* orig_res_stub_array_ = 462 Runtime::Current()->GetResolutionStubArray(Runtime::kUnknownMethod); 463 CHECK(orig->GetCode() == orig_res_stub_array_->GetData()); 464 ByteArray* copy_res_stub_array_ = down_cast<ByteArray*>(GetImageAddress(orig_res_stub_array_)); 465 copy->code_ = copy_res_stub_array_->GetData(); 466 return; 467 } 468 469 // Non-abstract methods typically have code 470 uint32_t code_offset = orig->GetOatCodeOffset(); 471 const byte* code = NULL; 472 if (orig->IsStatic()) { 473 // Static methods may point at the resolution trampoline stub 474 ByteArray* orig_res_stub_array_ = 475 Runtime::Current()->GetResolutionStubArray(Runtime::kStaticMethod); 476 if (reinterpret_cast<int8_t*>(code_offset) == orig_res_stub_array_->GetData()) { 477 ByteArray* copy_res_stub_array_ = down_cast<ByteArray*>(GetImageAddress(orig_res_stub_array_)); 478 code = reinterpret_cast<const byte*>(copy_res_stub_array_->GetData()); 479 } 480 } 481 if (code == NULL) { 482 code = GetOatAddress(code_offset); 483 } 484 copy->code_ = code; 485 486 if (orig->IsNative()) { 487 // The native method's pointer is directed to a stub to lookup via dlsym. 488 // Note this is not the code_ pointer, that is handled above. 489 ByteArray* orig_jni_stub_array_ = Runtime::Current()->GetJniDlsymLookupStub(); 490 ByteArray* copy_jni_stub_array_ = down_cast<ByteArray*>(GetImageAddress(orig_jni_stub_array_)); 491 copy->native_method_ = copy_jni_stub_array_->GetData(); 492 } else { 493 // normal (non-abstract non-native) methods have mapping tables to relocate 494 uint32_t mapping_table_off = orig->GetOatMappingTableOffset(); 495 const byte* mapping_table = GetOatAddress(mapping_table_off); 496 copy->mapping_table_ = reinterpret_cast<const uint32_t*>(mapping_table); 497 498 uint32_t vmap_table_offset = orig->GetOatVmapTableOffset(); 499 const byte* vmap_table = GetOatAddress(vmap_table_offset); 500 copy->vmap_table_ = reinterpret_cast<const uint16_t*>(vmap_table); 501 502 uint32_t gc_map_offset = orig->GetOatGcMapOffset(); 503 const byte* gc_map = GetOatAddress(gc_map_offset); 504 copy->gc_map_ = reinterpret_cast<const uint8_t*>(gc_map); 505 } 506} 507 508void ImageWriter::FixupObjectArray(const ObjectArray<Object>* orig, ObjectArray<Object>* copy) { 509 for (int32_t i = 0; i < orig->GetLength(); ++i) { 510 const Object* element = orig->Get(i); 511 copy->SetWithoutChecks(i, GetImageAddress(element)); 512 } 513} 514 515void ImageWriter::FixupInstanceFields(const Object* orig, Object* copy) { 516 DCHECK(orig != NULL); 517 DCHECK(copy != NULL); 518 Class* klass = orig->GetClass(); 519 DCHECK(klass != NULL); 520 FixupFields(orig, 521 copy, 522 klass->GetReferenceInstanceOffsets(), 523 false); 524} 525 526void ImageWriter::FixupStaticFields(const Class* orig, Class* copy) { 527 DCHECK(orig != NULL); 528 DCHECK(copy != NULL); 529 FixupFields(orig, 530 copy, 531 orig->GetReferenceStaticOffsets(), 532 true); 533} 534 535void ImageWriter::FixupFields(const Object* orig, 536 Object* copy, 537 uint32_t ref_offsets, 538 bool is_static) { 539 if (ref_offsets != CLASS_WALK_SUPER) { 540 // Found a reference offset bitmap. Fixup the specified offsets. 541 while (ref_offsets != 0) { 542 size_t right_shift = CLZ(ref_offsets); 543 MemberOffset byte_offset = CLASS_OFFSET_FROM_CLZ(right_shift); 544 const Object* ref = orig->GetFieldObject<const Object*>(byte_offset, false); 545 copy->SetFieldObject(byte_offset, GetImageAddress(ref), false); 546 ref_offsets &= ~(CLASS_HIGH_BIT >> right_shift); 547 } 548 } else { 549 // There is no reference offset bitmap. In the non-static case, 550 // walk up the class inheritance hierarchy and find reference 551 // offsets the hard way. In the static case, just consider this 552 // class. 553 for (const Class *klass = is_static ? orig->AsClass() : orig->GetClass(); 554 klass != NULL; 555 klass = is_static ? NULL : klass->GetSuperClass()) { 556 size_t num_reference_fields = (is_static 557 ? klass->NumReferenceStaticFields() 558 : klass->NumReferenceInstanceFields()); 559 for (size_t i = 0; i < num_reference_fields; ++i) { 560 Field* field = (is_static 561 ? klass->GetStaticField(i) 562 : klass->GetInstanceField(i)); 563 MemberOffset field_offset = field->GetOffset(); 564 const Object* ref = orig->GetFieldObject<const Object*>(field_offset, false); 565 copy->SetFieldObject(field_offset, GetImageAddress(ref), false); 566 } 567 } 568 } 569} 570 571static Method* GetReferrerMethod(const Compiler::PatchInformation* patch) { 572 ClassLinker* class_linker = Runtime::Current()->GetClassLinker(); 573 Method* method = class_linker->ResolveMethod(patch->GetDexFile(), 574 patch->GetReferrerMethodIdx(), 575 patch->GetDexCache(), 576 NULL, 577 patch->GetReferrerIsDirect()); 578 CHECK(method != NULL) 579 << patch->GetDexFile().GetLocation() << " " << patch->GetReferrerMethodIdx(); 580 CHECK(!method->IsRuntimeMethod()) 581 << patch->GetDexFile().GetLocation() << " " << patch->GetReferrerMethodIdx(); 582 CHECK(patch->GetDexCache()->GetResolvedMethods()->Get(patch->GetReferrerMethodIdx()) == method) 583 << patch->GetDexFile().GetLocation() << " " << patch->GetReferrerMethodIdx() << " " 584 << PrettyMethod(patch->GetDexCache()->GetResolvedMethods()->Get(patch->GetReferrerMethodIdx())) << " " 585 << PrettyMethod(method); 586 return method; 587} 588 589static Method* GetTargetMethod(const Compiler::PatchInformation* patch) { 590 ClassLinker* class_linker = Runtime::Current()->GetClassLinker(); 591 Method* method = class_linker->ResolveMethod(patch->GetDexFile(), 592 patch->GetTargetMethodIdx(), 593 patch->GetDexCache(), 594 NULL, 595 patch->GetTargetIsDirect()); 596 CHECK(method != NULL) 597 << patch->GetDexFile().GetLocation() << " " << patch->GetTargetMethodIdx(); 598 CHECK(!method->IsRuntimeMethod()) 599 << patch->GetDexFile().GetLocation() << " " << patch->GetTargetMethodIdx(); 600 CHECK(patch->GetDexCache()->GetResolvedMethods()->Get(patch->GetTargetMethodIdx()) == method) 601 << patch->GetDexFile().GetLocation() << " " << patch->GetReferrerMethodIdx() << " " 602 << PrettyMethod(patch->GetDexCache()->GetResolvedMethods()->Get(patch->GetTargetMethodIdx())) << " " 603 << PrettyMethod(method); 604 return method; 605} 606 607void ImageWriter::PatchOatCodeAndMethods(const Compiler& compiler) { 608 ClassLinker* class_linker = Runtime::Current()->GetClassLinker(); 609 610 const std::vector<const Compiler::PatchInformation*>& code_to_patch = compiler.GetCodeToPatch(); 611 for (size_t i = 0; i < code_to_patch.size(); i++) { 612 const Compiler::PatchInformation* patch = code_to_patch[i]; 613 Method* target = GetTargetMethod(patch); 614 uint32_t code = reinterpret_cast<uint32_t>(class_linker->GetOatCodeFor(target)); 615 uint32_t code_base = reinterpret_cast<uint32_t>(&oat_file_->GetOatHeader()); 616 uint32_t code_offset = code - code_base; 617 SetPatchLocation(patch, reinterpret_cast<uint32_t>(GetOatAddress(code_offset))); 618 } 619 620 const std::vector<const Compiler::PatchInformation*>& methods_to_patch 621 = compiler.GetMethodsToPatch(); 622 for (size_t i = 0; i < methods_to_patch.size(); i++) { 623 const Compiler::PatchInformation* patch = methods_to_patch[i]; 624 Method* target = GetTargetMethod(patch); 625 SetPatchLocation(patch, reinterpret_cast<uint32_t>(GetImageAddress(target))); 626 } 627} 628 629void ImageWriter::SetPatchLocation(const Compiler::PatchInformation* patch, uint32_t value) { 630 ClassLinker* class_linker = Runtime::Current()->GetClassLinker(); 631 Method* method = GetReferrerMethod(patch); 632 // Goodbye const, we are about to modify some code. 633 void* code = const_cast<void*>(class_linker->GetOatCodeFor(method)); 634 // TODO: make this Thumb2 specific 635 uint8_t* base = reinterpret_cast<uint8_t*>(reinterpret_cast<uint32_t>(code) & ~0x1); 636 uint32_t* patch_location = reinterpret_cast<uint32_t*>(base + patch->GetLiteralOffset()); 637#ifndef NDEBUG 638 const DexFile::MethodId& id = patch->GetDexFile().GetMethodId(patch->GetTargetMethodIdx()); 639 uint32_t expected = reinterpret_cast<uint32_t>(&id); 640 uint32_t actual = *patch_location; 641 CHECK(actual == expected || actual == value) << std::hex 642 << "actual=" << actual 643 << "expected=" << expected 644 << "value=" << value; 645#endif 646 *patch_location = value; 647} 648 649} // namespace art 650