blob: 93897aa228623d1d6122f0304490501819f4a8a5 [file] [log] [blame]
Brian Carlstrom7940e442013-07-12 13:46:57 -07001/*
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
Ian Rogers700a4022014-05-19 16:49:03 -070021#include <memory>
Vladimir Marko20f85592015-03-19 10:07:02 +000022#include <numeric>
Brian Carlstrom7940e442013-07-12 13:46:57 -070023#include <vector>
24
Mathieu Chartierc7853442015-03-27 14:35:38 -070025#include "art_field-inl.h"
Mathieu Chartiere401d142015-04-22 13:56:20 -070026#include "art_method-inl.h"
Brian Carlstrom7940e442013-07-12 13:46:57 -070027#include "base/logging.h"
28#include "base/unix_file/fd_file.h"
Vladimir Marko3481ba22015-04-13 12:22:36 +010029#include "class_linker-inl.h"
Brian Carlstrom7940e442013-07-12 13:46:57 -070030#include "compiled_method.h"
31#include "dex_file-inl.h"
32#include "driver/compiler_driver.h"
Alex Light53cb16b2014-06-12 11:26:29 -070033#include "elf_file.h"
34#include "elf_utils.h"
Brian Carlstrom7940e442013-07-12 13:46:57 -070035#include "elf_writer.h"
36#include "gc/accounting/card_table-inl.h"
37#include "gc/accounting/heap_bitmap.h"
Mathieu Chartier31e89252013-08-28 11:29:12 -070038#include "gc/accounting/space_bitmap-inl.h"
Brian Carlstrom7940e442013-07-12 13:46:57 -070039#include "gc/heap.h"
40#include "gc/space/large_object_space.h"
41#include "gc/space/space-inl.h"
42#include "globals.h"
43#include "image.h"
44#include "intern_table.h"
Mathieu Chartierc7853442015-03-27 14:35:38 -070045#include "linear_alloc.h"
Mathieu Chartierad2541a2013-10-25 10:05:23 -070046#include "lock_word.h"
Mathieu Chartiere401d142015-04-22 13:56:20 -070047#include "mirror/abstract_method.h"
Brian Carlstrom7940e442013-07-12 13:46:57 -070048#include "mirror/array-inl.h"
49#include "mirror/class-inl.h"
50#include "mirror/class_loader.h"
51#include "mirror/dex_cache-inl.h"
Mathieu Chartiere401d142015-04-22 13:56:20 -070052#include "mirror/method.h"
Brian Carlstrom7940e442013-07-12 13:46:57 -070053#include "mirror/object-inl.h"
54#include "mirror/object_array-inl.h"
Ian Rogersb0fa5dc2014-04-28 16:47:08 -070055#include "mirror/string-inl.h"
Brian Carlstrom7940e442013-07-12 13:46:57 -070056#include "oat.h"
57#include "oat_file.h"
Brian Carlstrom7940e442013-07-12 13:46:57 -070058#include "runtime.h"
59#include "scoped_thread_state_change.h"
Mathieu Chartiereb8167a2014-05-07 15:43:14 -070060#include "handle_scope-inl.h"
Vladimir Marko20f85592015-03-19 10:07:02 +000061#include "utils/dex_cache_arrays_layout-inl.h"
Brian Carlstrom7940e442013-07-12 13:46:57 -070062
Brian Carlstrom3e3d5912013-07-18 00:19:45 -070063using ::art::mirror::Class;
64using ::art::mirror::DexCache;
Brian Carlstrom3e3d5912013-07-18 00:19:45 -070065using ::art::mirror::Object;
66using ::art::mirror::ObjectArray;
67using ::art::mirror::String;
Brian Carlstrom7940e442013-07-12 13:46:57 -070068
69namespace art {
70
Igor Murashkinf5b4c502014-11-14 15:01:59 -080071// Separate objects into multiple bins to optimize dirty memory use.
72static constexpr bool kBinObjects = true;
Mathieu Chartierde486922015-04-15 20:03:16 -070073static constexpr bool kComputeEagerResolvedStrings = false;
Igor Murashkinf5b4c502014-11-14 15:01:59 -080074
Andreas Gampedd9d0552015-03-09 12:57:41 -070075static void CheckNoDexObjectsCallback(Object* obj, void* arg ATTRIBUTE_UNUSED)
Mathieu Chartier90443472015-07-16 20:32:27 -070076 SHARED_REQUIRES(Locks::mutator_lock_) {
Andreas Gampedd9d0552015-03-09 12:57:41 -070077 Class* klass = obj->GetClass();
78 CHECK_NE(PrettyClass(klass), "com.android.dex.Dex");
79}
80
81static void CheckNoDexObjects() {
82 ScopedObjectAccess soa(Thread::Current());
83 Runtime::Current()->GetHeap()->VisitObjects(CheckNoDexObjectsCallback, nullptr);
84}
85
Vladimir Markof4da6752014-08-01 19:04:18 +010086bool ImageWriter::PrepareImageAddressSpace() {
Mathieu Chartier2d721012014-11-10 11:08:06 -080087 target_ptr_size_ = InstructionSetPointerSize(compiler_driver_.GetInstructionSet());
Vladimir Markof4da6752014-08-01 19:04:18 +010088 {
89 Thread::Current()->TransitionFromSuspendedToRunnable();
90 PruneNonImageClasses(); // Remove junk
91 ComputeLazyFieldsForImageClasses(); // Add useful information
Jeff Hao848f70a2014-01-15 13:49:50 -080092
93 // Calling this can in theory fill in some resolved strings. However, in practice it seems to
94 // never resolve any.
95 if (kComputeEagerResolvedStrings) {
96 ComputeEagerResolvedStrings();
97 }
Vladimir Markof4da6752014-08-01 19:04:18 +010098 Thread::Current()->TransitionFromRunnableToSuspended(kNative);
99 }
100 gc::Heap* heap = Runtime::Current()->GetHeap();
101 heap->CollectGarbage(false); // Remove garbage.
102
Andreas Gampedd9d0552015-03-09 12:57:41 -0700103 // Dex caches must not have their dex fields set in the image. These are memory buffers of mapped
104 // dex files.
105 //
106 // We may open them in the unstarted-runtime code for class metadata. Their fields should all be
107 // reset in PruneNonImageClasses and the objects reclaimed in the GC. Make sure that's actually
108 // true.
109 if (kIsDebugBuild) {
110 CheckNoDexObjects();
111 }
112
Vladimir Markof4da6752014-08-01 19:04:18 +0100113 if (kIsDebugBuild) {
114 ScopedObjectAccess soa(Thread::Current());
115 CheckNonImageClassesRemoved();
116 }
117
118 Thread::Current()->TransitionFromSuspendedToRunnable();
119 CalculateNewObjectOffsets();
120 Thread::Current()->TransitionFromRunnableToSuspended(kNative);
121
Mathieu Chartierd39645e2015-06-09 17:50:29 -0700122 // This needs to happen after CalculateNewObjectOffsets since it relies on intern_table_bytes_ and
123 // bin size sums being calculated.
124 if (!AllocMemory()) {
125 return false;
126 }
127
Vladimir Markof4da6752014-08-01 19:04:18 +0100128 return true;
129}
130
Brian Carlstrom7940e442013-07-12 13:46:57 -0700131bool ImageWriter::Write(const std::string& image_filename,
Brian Carlstrom7940e442013-07-12 13:46:57 -0700132 const std::string& oat_filename,
133 const std::string& oat_location) {
134 CHECK(!image_filename.empty());
135
Brian Carlstrom7940e442013-07-12 13:46:57 -0700136 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
Brian Carlstrom7940e442013-07-12 13:46:57 -0700137
Ian Rogers700a4022014-05-19 16:49:03 -0700138 std::unique_ptr<File> oat_file(OS::OpenFileReadWrite(oat_filename.c_str()));
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700139 if (oat_file.get() == nullptr) {
Andreas Gampe88ec7f42014-11-05 10:18:32 -0800140 PLOG(ERROR) << "Failed to open oat file " << oat_filename << " for " << oat_location;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700141 return false;
142 }
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700143 std::string error_msg;
Igor Murashkinb1d8c312015-08-04 11:18:43 -0700144 oat_file_ = OatFile::OpenReadable(oat_file.get(), oat_location, nullptr, &error_msg);
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700145 if (oat_file_ == nullptr) {
Andreas Gampe88ec7f42014-11-05 10:18:32 -0800146 PLOG(ERROR) << "Failed to open writable oat file " << oat_filename << " for " << oat_location
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700147 << ": " << error_msg;
Andreas Gampe0b7fcf92015-03-13 16:54:54 -0700148 oat_file->Erase();
Brian Carlstromc50d8e12013-07-23 22:35:16 -0700149 return false;
150 }
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700151 CHECK_EQ(class_linker->RegisterOatFile(oat_file_), oat_file_);
Brian Carlstrom7940e442013-07-12 13:46:57 -0700152
Ian Rogers848871b2013-08-05 10:56:33 -0700153 interpreter_to_interpreter_bridge_offset_ =
154 oat_file_->GetOatHeader().GetInterpreterToInterpreterBridgeOffset();
155 interpreter_to_compiled_code_bridge_offset_ =
156 oat_file_->GetOatHeader().GetInterpreterToCompiledCodeBridgeOffset();
157
158 jni_dlsym_lookup_offset_ = oat_file_->GetOatHeader().GetJniDlsymLookupOffset();
159
Andreas Gampe2da88232014-02-27 12:26:20 -0800160 quick_generic_jni_trampoline_offset_ =
161 oat_file_->GetOatHeader().GetQuickGenericJniTrampolineOffset();
Jeff Hao88474b42013-10-23 16:24:40 -0700162 quick_imt_conflict_trampoline_offset_ =
163 oat_file_->GetOatHeader().GetQuickImtConflictTrampolineOffset();
Ian Rogers848871b2013-08-05 10:56:33 -0700164 quick_resolution_trampoline_offset_ =
165 oat_file_->GetOatHeader().GetQuickResolutionTrampolineOffset();
166 quick_to_interpreter_bridge_offset_ =
167 oat_file_->GetOatHeader().GetQuickToInterpreterBridgeOffset();
Brian Carlstrom7940e442013-07-12 13:46:57 -0700168
Brian Carlstrom7940e442013-07-12 13:46:57 -0700169 size_t oat_loaded_size = 0;
170 size_t oat_data_offset = 0;
Vladimir Marko3fc99032015-05-13 19:06:30 +0100171 ElfWriter::GetOatElfInformation(oat_file.get(), &oat_loaded_size, &oat_data_offset);
Alex Light53cb16b2014-06-12 11:26:29 -0700172
Vladimir Markof4da6752014-08-01 19:04:18 +0100173 Thread::Current()->TransitionFromSuspendedToRunnable();
Mathieu Chartiere401d142015-04-22 13:56:20 -0700174
Vladimir Markof4da6752014-08-01 19:04:18 +0100175 CreateHeader(oat_loaded_size, oat_data_offset);
Mathieu Chartiere401d142015-04-22 13:56:20 -0700176 CopyAndFixupNativeData();
Mathieu Chartierc7853442015-03-27 14:35:38 -0700177 // TODO: heap validation can't handle these fix up passes.
178 Runtime::Current()->GetHeap()->DisableObjectValidation();
Vladimir Markof4da6752014-08-01 19:04:18 +0100179 CopyAndFixupObjects();
Brian Carlstrom7940e442013-07-12 13:46:57 -0700180 Thread::Current()->TransitionFromRunnableToSuspended(kNative);
181
Vladimir Markof4da6752014-08-01 19:04:18 +0100182 SetOatChecksumFromElfFile(oat_file.get());
183
Andreas Gampe4303ba92014-11-06 01:00:46 -0800184 if (oat_file->FlushCloseOrErase() != 0) {
185 LOG(ERROR) << "Failed to flush and close oat file " << oat_filename << " for " << oat_location;
186 return false;
187 }
188
Ian Rogers700a4022014-05-19 16:49:03 -0700189 std::unique_ptr<File> image_file(OS::CreateEmptyFile(image_filename.c_str()));
Mathieu Chartier31e89252013-08-28 11:29:12 -0700190 ImageHeader* image_header = reinterpret_cast<ImageHeader*>(image_->Begin());
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700191 if (image_file.get() == nullptr) {
Brian Carlstrom7940e442013-07-12 13:46:57 -0700192 LOG(ERROR) << "Failed to open image file " << image_filename;
193 return false;
194 }
195 if (fchmod(image_file->Fd(), 0644) != 0) {
196 PLOG(ERROR) << "Failed to make image file world readable: " << image_filename;
Andreas Gampe4303ba92014-11-06 01:00:46 -0800197 image_file->Erase();
Brian Carlstrom7940e442013-07-12 13:46:57 -0700198 return EXIT_FAILURE;
199 }
Mathieu Chartier31e89252013-08-28 11:29:12 -0700200
Mathieu Chartiere401d142015-04-22 13:56:20 -0700201 // Write out the image + fields + methods.
202 const auto write_count = image_header->GetImageSize();
Mathieu Chartierc7853442015-03-27 14:35:38 -0700203 if (!image_file->WriteFully(image_->Begin(), write_count)) {
Brian Carlstrom7940e442013-07-12 13:46:57 -0700204 PLOG(ERROR) << "Failed to write image file " << image_filename;
Andreas Gampe4303ba92014-11-06 01:00:46 -0800205 image_file->Erase();
Brian Carlstrom7940e442013-07-12 13:46:57 -0700206 return false;
207 }
Mathieu Chartier31e89252013-08-28 11:29:12 -0700208
209 // Write out the image bitmap at the page aligned start of the image end.
Mathieu Chartierd39645e2015-06-09 17:50:29 -0700210 const ImageSection& bitmap_section = image_header->GetImageSection(ImageHeader::kSectionImageBitmap);
Mathieu Chartiere401d142015-04-22 13:56:20 -0700211 CHECK_ALIGNED(bitmap_section.Offset(), kPageSize);
Mathieu Chartier31e89252013-08-28 11:29:12 -0700212 if (!image_file->Write(reinterpret_cast<char*>(image_bitmap_->Begin()),
Mathieu Chartiere401d142015-04-22 13:56:20 -0700213 bitmap_section.Size(), bitmap_section.Offset())) {
Mathieu Chartier31e89252013-08-28 11:29:12 -0700214 PLOG(ERROR) << "Failed to write image file " << image_filename;
Andreas Gampe4303ba92014-11-06 01:00:46 -0800215 image_file->Erase();
Mathieu Chartier31e89252013-08-28 11:29:12 -0700216 return false;
217 }
218
Mathieu Chartiere401d142015-04-22 13:56:20 -0700219 CHECK_EQ(bitmap_section.End(), static_cast<size_t>(image_file->GetLength()));
Andreas Gampe4303ba92014-11-06 01:00:46 -0800220 if (image_file->FlushCloseOrErase() != 0) {
221 PLOG(ERROR) << "Failed to flush and close image file " << image_filename;
222 return false;
223 }
Brian Carlstrom7940e442013-07-12 13:46:57 -0700224 return true;
225}
226
Mathieu Chartierd39645e2015-06-09 17:50:29 -0700227void ImageWriter::SetImageOffset(mirror::Object* object, size_t offset) {
Mathieu Chartier590fee92013-09-13 13:46:47 -0700228 DCHECK(object != nullptr);
229 DCHECK_NE(offset, 0U);
Igor Murashkinf5b4c502014-11-14 15:01:59 -0800230
Igor Murashkinf5b4c502014-11-14 15:01:59 -0800231 // The object is already deflated from when we set the bin slot. Just overwrite the lock word.
Mathieu Chartier4d7f61d2014-04-17 14:43:39 -0700232 object->SetLockWord(LockWord::FromForwardingAddress(offset), false);
Mathieu Chartiere401d142015-04-22 13:56:20 -0700233 DCHECK_EQ(object->GetLockWord(false).ReadBarrierState(), 0u);
Mathieu Chartier590fee92013-09-13 13:46:47 -0700234 DCHECK(IsImageOffsetAssigned(object));
235}
236
Mathieu Chartiere401d142015-04-22 13:56:20 -0700237void ImageWriter::UpdateImageOffset(mirror::Object* obj, uintptr_t offset) {
238 DCHECK(IsImageOffsetAssigned(obj)) << obj << " " << offset;
239 obj->SetLockWord(LockWord::FromForwardingAddress(offset), false);
240 DCHECK_EQ(obj->GetLockWord(false).ReadBarrierState(), 0u);
241}
242
Igor Murashkinf5b4c502014-11-14 15:01:59 -0800243void ImageWriter::AssignImageOffset(mirror::Object* object, ImageWriter::BinSlot bin_slot) {
Mathieu Chartier590fee92013-09-13 13:46:47 -0700244 DCHECK(object != nullptr);
Igor Murashkinf5b4c502014-11-14 15:01:59 -0800245 DCHECK_NE(image_objects_offset_begin_, 0u);
246
Vladimir Markocf36d492015-08-12 19:27:26 +0100247 size_t bin_slot_offset = bin_slot_offsets_[bin_slot.GetBin()];
248 size_t new_offset = bin_slot_offset + bin_slot.GetIndex();
Igor Murashkinf5b4c502014-11-14 15:01:59 -0800249 DCHECK_ALIGNED(new_offset, kObjectAlignment);
250
Mathieu Chartierd39645e2015-06-09 17:50:29 -0700251 SetImageOffset(object, new_offset);
Igor Murashkinf5b4c502014-11-14 15:01:59 -0800252 DCHECK_LT(new_offset, image_end_);
Mathieu Chartier590fee92013-09-13 13:46:47 -0700253}
254
Ian Rogersef7d42f2014-01-06 12:55:46 -0800255bool ImageWriter::IsImageOffsetAssigned(mirror::Object* object) const {
Igor Murashkinf5b4c502014-11-14 15:01:59 -0800256 // Will also return true if the bin slot was assigned since we are reusing the lock word.
Mathieu Chartier590fee92013-09-13 13:46:47 -0700257 DCHECK(object != nullptr);
Mathieu Chartier4d7f61d2014-04-17 14:43:39 -0700258 return object->GetLockWord(false).GetState() == LockWord::kForwardingAddress;
Mathieu Chartier590fee92013-09-13 13:46:47 -0700259}
260
Ian Rogersef7d42f2014-01-06 12:55:46 -0800261size_t ImageWriter::GetImageOffset(mirror::Object* object) const {
Mathieu Chartier590fee92013-09-13 13:46:47 -0700262 DCHECK(object != nullptr);
263 DCHECK(IsImageOffsetAssigned(object));
Mathieu Chartier4d7f61d2014-04-17 14:43:39 -0700264 LockWord lock_word = object->GetLockWord(false);
Mathieu Chartier590fee92013-09-13 13:46:47 -0700265 size_t offset = lock_word.ForwardingAddress();
266 DCHECK_LT(offset, image_end_);
267 return offset;
Mathieu Chartier31e89252013-08-28 11:29:12 -0700268}
269
Igor Murashkinf5b4c502014-11-14 15:01:59 -0800270void ImageWriter::SetImageBinSlot(mirror::Object* object, BinSlot bin_slot) {
271 DCHECK(object != nullptr);
272 DCHECK(!IsImageOffsetAssigned(object));
273 DCHECK(!IsImageBinSlotAssigned(object));
274
275 // Before we stomp over the lock word, save the hash code for later.
276 Monitor::Deflate(Thread::Current(), object);;
277 LockWord lw(object->GetLockWord(false));
278 switch (lw.GetState()) {
279 case LockWord::kFatLocked: {
280 LOG(FATAL) << "Fat locked object " << object << " found during object copy";
281 break;
282 }
283 case LockWord::kThinLocked: {
284 LOG(FATAL) << "Thin locked object " << object << " found during object copy";
285 break;
286 }
287 case LockWord::kUnlocked:
288 // No hash, don't need to save it.
289 break;
290 case LockWord::kHashCode:
Mathieu Chartierd39645e2015-06-09 17:50:29 -0700291 DCHECK(saved_hashcode_map_.find(object) == saved_hashcode_map_.end());
292 saved_hashcode_map_.emplace(object, lw.GetHashCode());
Igor Murashkinf5b4c502014-11-14 15:01:59 -0800293 break;
294 default:
295 LOG(FATAL) << "Unreachable.";
296 UNREACHABLE();
297 }
Mathieu Chartierd39645e2015-06-09 17:50:29 -0700298 object->SetLockWord(LockWord::FromForwardingAddress(bin_slot.Uint32Value()), false);
Mathieu Chartiere401d142015-04-22 13:56:20 -0700299 DCHECK_EQ(object->GetLockWord(false).ReadBarrierState(), 0u);
Igor Murashkinf5b4c502014-11-14 15:01:59 -0800300 DCHECK(IsImageBinSlotAssigned(object));
301}
302
Vladimir Marko20f85592015-03-19 10:07:02 +0000303void ImageWriter::PrepareDexCacheArraySlots() {
304 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
305 ReaderMutexLock mu(Thread::Current(), *class_linker->DexLock());
306 size_t dex_cache_count = class_linker->GetDexCacheCount();
307 uint32_t size = 0u;
308 for (size_t idx = 0; idx < dex_cache_count; ++idx) {
309 DexCache* dex_cache = class_linker->GetDexCache(idx);
310 const DexFile* dex_file = dex_cache->GetDexFile();
311 dex_cache_array_starts_.Put(dex_file, size);
Mathieu Chartierc7853442015-03-27 14:35:38 -0700312 DexCacheArraysLayout layout(target_ptr_size_, dex_file);
Vladimir Marko20f85592015-03-19 10:07:02 +0000313 DCHECK(layout.Valid());
Mathieu Chartierc7853442015-03-27 14:35:38 -0700314 auto types_size = layout.TypesSize(dex_file->NumTypeIds());
315 auto methods_size = layout.MethodsSize(dex_file->NumMethodIds());
316 auto fields_size = layout.FieldsSize(dex_file->NumFieldIds());
317 auto strings_size = layout.StringsSize(dex_file->NumStringIds());
318 dex_cache_array_indexes_.Put(
319 dex_cache->GetResolvedTypes(),
Mathieu Chartiere401d142015-04-22 13:56:20 -0700320 DexCacheArrayLocation {size + layout.TypesOffset(), types_size, kBinRegular});
Mathieu Chartierc7853442015-03-27 14:35:38 -0700321 dex_cache_array_indexes_.Put(
322 dex_cache->GetResolvedMethods(),
Mathieu Chartiere401d142015-04-22 13:56:20 -0700323 DexCacheArrayLocation {size + layout.MethodsOffset(), methods_size, kBinArtMethodClean});
324 AddMethodPointerArray(dex_cache->GetResolvedMethods());
Mathieu Chartierc7853442015-03-27 14:35:38 -0700325 dex_cache_array_indexes_.Put(
326 dex_cache->GetResolvedFields(),
Mathieu Chartiere401d142015-04-22 13:56:20 -0700327 DexCacheArrayLocation {size + layout.FieldsOffset(), fields_size, kBinArtField});
328 pointer_arrays_.emplace(dex_cache->GetResolvedFields(), kBinArtField);
Mathieu Chartierc7853442015-03-27 14:35:38 -0700329 dex_cache_array_indexes_.Put(
330 dex_cache->GetStrings(),
Mathieu Chartiere401d142015-04-22 13:56:20 -0700331 DexCacheArrayLocation {size + layout.StringsOffset(), strings_size, kBinRegular});
Vladimir Marko20f85592015-03-19 10:07:02 +0000332 size += layout.Size();
Mathieu Chartierc7853442015-03-27 14:35:38 -0700333 CHECK_EQ(layout.Size(), types_size + methods_size + fields_size + strings_size);
Vladimir Marko20f85592015-03-19 10:07:02 +0000334 }
335 // Set the slot size early to avoid DCHECK() failures in IsImageBinSlotAssigned()
336 // when AssignImageBinSlot() assigns their indexes out or order.
337 bin_slot_sizes_[kBinDexCacheArray] = size;
338}
339
Mathieu Chartiere401d142015-04-22 13:56:20 -0700340void ImageWriter::AddMethodPointerArray(mirror::PointerArray* arr) {
341 DCHECK(arr != nullptr);
342 if (kIsDebugBuild) {
343 for (size_t i = 0, len = arr->GetLength(); i < len; i++) {
344 auto* method = arr->GetElementPtrSize<ArtMethod*>(i, target_ptr_size_);
345 if (method != nullptr && !method->IsRuntimeMethod()) {
346 auto* klass = method->GetDeclaringClass();
347 CHECK(klass == nullptr || IsImageClass(klass)) << PrettyClass(klass)
348 << " should be an image class";
349 }
350 }
351 }
352 // kBinArtMethodClean picked arbitrarily, just required to differentiate between ArtFields and
353 // ArtMethods.
354 pointer_arrays_.emplace(arr, kBinArtMethodClean);
355}
356
Igor Murashkinf5b4c502014-11-14 15:01:59 -0800357void ImageWriter::AssignImageBinSlot(mirror::Object* object) {
358 DCHECK(object != nullptr);
Jeff Haoc7d11882015-02-03 15:08:39 -0800359 size_t object_size = object->SizeOf();
Igor Murashkinf5b4c502014-11-14 15:01:59 -0800360
361 // The magic happens here. We segregate objects into different bins based
362 // on how likely they are to get dirty at runtime.
363 //
364 // Likely-to-dirty objects get packed together into the same bin so that
365 // at runtime their page dirtiness ratio (how many dirty objects a page has) is
366 // maximized.
367 //
368 // This means more pages will stay either clean or shared dirty (with zygote) and
369 // the app will use less of its own (private) memory.
370 Bin bin = kBinRegular;
Vladimir Marko20f85592015-03-19 10:07:02 +0000371 size_t current_offset = 0u;
Igor Murashkinf5b4c502014-11-14 15:01:59 -0800372
373 if (kBinObjects) {
374 //
375 // Changing the bin of an object is purely a memory-use tuning.
376 // It has no change on runtime correctness.
377 //
378 // Memory analysis has determined that the following types of objects get dirtied
379 // the most:
380 //
Vladimir Marko20f85592015-03-19 10:07:02 +0000381 // * Dex cache arrays are stored in a special bin. The arrays for each dex cache have
382 // a fixed layout which helps improve generated code (using PC-relative addressing),
383 // so we pre-calculate their offsets separately in PrepareDexCacheArraySlots().
384 // Since these arrays are huge, most pages do not overlap other objects and it's not
385 // really important where they are for the clean/dirty separation. Due to their
386 // special PC-relative addressing, we arbitrarily keep them at the beginning.
Igor Murashkinf5b4c502014-11-14 15:01:59 -0800387 // * Class'es which are verified [their clinit runs only at runtime]
388 // - classes in general [because their static fields get overwritten]
389 // - initialized classes with all-final statics are unlikely to be ever dirty,
390 // so bin them separately
391 // * Art Methods that are:
392 // - native [their native entry point is not looked up until runtime]
393 // - have declaring classes that aren't initialized
394 // [their interpreter/quick entry points are trampolines until the class
395 // becomes initialized]
396 //
397 // We also assume the following objects get dirtied either never or extremely rarely:
398 // * Strings (they are immutable)
399 // * Art methods that aren't native and have initialized declared classes
400 //
401 // We assume that "regular" bin objects are highly unlikely to become dirtied,
402 // so packing them together will not result in a noticeably tighter dirty-to-clean ratio.
403 //
404 if (object->IsClass()) {
405 bin = kBinClassVerified;
406 mirror::Class* klass = object->AsClass();
407
Mathieu Chartiere401d142015-04-22 13:56:20 -0700408 // Add non-embedded vtable to the pointer array table if there is one.
409 auto* vtable = klass->GetVTable();
410 if (vtable != nullptr) {
411 AddMethodPointerArray(vtable);
412 }
413 auto* iftable = klass->GetIfTable();
414 if (iftable != nullptr) {
415 for (int32_t i = 0; i < klass->GetIfTableCount(); ++i) {
416 if (iftable->GetMethodArrayCount(i) > 0) {
417 AddMethodPointerArray(iftable->GetMethodArray(i));
418 }
419 }
420 }
421
Igor Murashkinf5b4c502014-11-14 15:01:59 -0800422 if (klass->GetStatus() == Class::kStatusInitialized) {
423 bin = kBinClassInitialized;
424
425 // If the class's static fields are all final, put it into a separate bin
426 // since it's very likely it will stay clean.
427 uint32_t num_static_fields = klass->NumStaticFields();
428 if (num_static_fields == 0) {
429 bin = kBinClassInitializedFinalStatics;
430 } else {
431 // Maybe all the statics are final?
432 bool all_final = true;
433 for (uint32_t i = 0; i < num_static_fields; ++i) {
434 ArtField* field = klass->GetStaticField(i);
435 if (!field->IsFinal()) {
436 all_final = false;
437 break;
438 }
439 }
440
441 if (all_final) {
442 bin = kBinClassInitializedFinalStatics;
443 }
444 }
445 }
Igor Murashkinf5b4c502014-11-14 15:01:59 -0800446 } else if (object->GetClass<kVerifyNone>()->IsStringClass()) {
447 bin = kBinString; // Strings are almost always immutable (except for object header).
Mathieu Chartierc7853442015-03-27 14:35:38 -0700448 } else if (object->IsArrayInstance()) {
449 mirror::Class* klass = object->GetClass<kVerifyNone>();
Mathieu Chartiere401d142015-04-22 13:56:20 -0700450 if (klass->IsObjectArrayClass() || klass->IsIntArrayClass() || klass->IsLongArrayClass()) {
Mathieu Chartierc7853442015-03-27 14:35:38 -0700451 auto it = dex_cache_array_indexes_.find(object);
452 if (it != dex_cache_array_indexes_.end()) {
453 bin = kBinDexCacheArray;
454 // Use prepared offset defined by the DexCacheLayout.
455 current_offset = it->second.offset_;
456 // Override incase of cross compilation.
457 object_size = it->second.length_;
458 } // else bin = kBinRegular
459 }
Igor Murashkinf5b4c502014-11-14 15:01:59 -0800460 } // else bin = kBinRegular
461 }
462
Igor Murashkinf5b4c502014-11-14 15:01:59 -0800463 size_t offset_delta = RoundUp(object_size, kObjectAlignment); // 64-bit alignment
Vladimir Marko20f85592015-03-19 10:07:02 +0000464 if (bin != kBinDexCacheArray) {
Mathieu Chartiere401d142015-04-22 13:56:20 -0700465 DCHECK(dex_cache_array_indexes_.find(object) == dex_cache_array_indexes_.end()) << object;
Vladimir Marko20f85592015-03-19 10:07:02 +0000466 current_offset = bin_slot_sizes_[bin]; // How many bytes the current bin is at (aligned).
467 // Move the current bin size up to accomodate the object we just assigned a bin slot.
468 bin_slot_sizes_[bin] += offset_delta;
469 }
Igor Murashkinf5b4c502014-11-14 15:01:59 -0800470
471 BinSlot new_bin_slot(bin, current_offset);
472 SetImageBinSlot(object, new_bin_slot);
473
474 ++bin_slot_count_[bin];
475
Igor Murashkinf5b4c502014-11-14 15:01:59 -0800476 // Grow the image closer to the end by the object we just assigned.
477 image_end_ += offset_delta;
Igor Murashkinf5b4c502014-11-14 15:01:59 -0800478}
479
Mathieu Chartiere401d142015-04-22 13:56:20 -0700480bool ImageWriter::WillMethodBeDirty(ArtMethod* m) const {
481 if (m->IsNative()) {
482 return true;
483 }
484 mirror::Class* declaring_class = m->GetDeclaringClass();
485 // Initialized is highly unlikely to dirty since there's no entry points to mutate.
486 return declaring_class == nullptr || declaring_class->GetStatus() != Class::kStatusInitialized;
487}
488
Igor Murashkinf5b4c502014-11-14 15:01:59 -0800489bool ImageWriter::IsImageBinSlotAssigned(mirror::Object* object) const {
490 DCHECK(object != nullptr);
491
492 // We always stash the bin slot into a lockword, in the 'forwarding address' state.
493 // If it's in some other state, then we haven't yet assigned an image bin slot.
494 if (object->GetLockWord(false).GetState() != LockWord::kForwardingAddress) {
495 return false;
496 } else if (kIsDebugBuild) {
497 LockWord lock_word = object->GetLockWord(false);
498 size_t offset = lock_word.ForwardingAddress();
499 BinSlot bin_slot(offset);
500 DCHECK_LT(bin_slot.GetIndex(), bin_slot_sizes_[bin_slot.GetBin()])
501 << "bin slot offset should not exceed the size of that bin";
502 }
503 return true;
504}
505
506ImageWriter::BinSlot ImageWriter::GetImageBinSlot(mirror::Object* object) const {
507 DCHECK(object != nullptr);
508 DCHECK(IsImageBinSlotAssigned(object));
509
510 LockWord lock_word = object->GetLockWord(false);
511 size_t offset = lock_word.ForwardingAddress(); // TODO: ForwardingAddress should be uint32_t
512 DCHECK_LE(offset, std::numeric_limits<uint32_t>::max());
513
514 BinSlot bin_slot(static_cast<uint32_t>(offset));
515 DCHECK_LT(bin_slot.GetIndex(), bin_slot_sizes_[bin_slot.GetBin()]);
516
517 return bin_slot;
518}
519
Brian Carlstrom7940e442013-07-12 13:46:57 -0700520bool ImageWriter::AllocMemory() {
Mathieu Chartierd39645e2015-06-09 17:50:29 -0700521 const size_t length = RoundUp(image_objects_offset_begin_ + GetBinSizeSum() + intern_table_bytes_,
522 kPageSize);
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700523 std::string error_msg;
Vladimir Marko5c42c292015-02-25 12:02:49 +0000524 image_.reset(MemMap::MapAnonymous("image writer image", nullptr, length, PROT_READ | PROT_WRITE,
525 false, false, &error_msg));
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700526 if (UNLIKELY(image_.get() == nullptr)) {
527 LOG(ERROR) << "Failed to allocate memory for image file generation: " << error_msg;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700528 return false;
529 }
Mathieu Chartier590fee92013-09-13 13:46:47 -0700530
Mathieu Chartierd39645e2015-06-09 17:50:29 -0700531 // Create the image bitmap, only needs to cover mirror object section which is up to image_end_.
532 CHECK_LE(image_end_, length);
533 image_bitmap_.reset(gc::accounting::ContinuousSpaceBitmap::Create(
534 "image bitmap", image_->Begin(), RoundUp(image_end_, kPageSize)));
Mathieu Chartier590fee92013-09-13 13:46:47 -0700535 if (image_bitmap_.get() == nullptr) {
536 LOG(ERROR) << "Failed to allocate memory for image bitmap";
537 return false;
538 }
Brian Carlstrom7940e442013-07-12 13:46:57 -0700539 return true;
540}
541
Mathieu Chartiere0671ce2015-07-28 17:23:28 -0700542class ComputeLazyFieldsForClassesVisitor : public ClassVisitor {
543 public:
544 bool Visit(Class* c) OVERRIDE SHARED_REQUIRES(Locks::mutator_lock_) {
545 StackHandleScope<1> hs(Thread::Current());
546 mirror::Class::ComputeName(hs.NewHandle(c));
547 return true;
548 }
549};
550
Brian Carlstrom7940e442013-07-12 13:46:57 -0700551void ImageWriter::ComputeLazyFieldsForImageClasses() {
Mathieu Chartier590fee92013-09-13 13:46:47 -0700552 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
Mathieu Chartiere0671ce2015-07-28 17:23:28 -0700553 ComputeLazyFieldsForClassesVisitor visitor;
554 class_linker->VisitClassesWithoutClassesLock(&visitor);
Brian Carlstrom7940e442013-07-12 13:46:57 -0700555}
556
Ian Rogers6a3c1fc2014-10-31 00:33:20 -0700557void ImageWriter::ComputeEagerResolvedStringsCallback(Object* obj, void* arg ATTRIBUTE_UNUSED) {
Brian Carlstrom7940e442013-07-12 13:46:57 -0700558 if (!obj->GetClass()->IsStringClass()) {
559 return;
560 }
Mathieu Chartier590fee92013-09-13 13:46:47 -0700561 mirror::String* string = obj->AsString();
Jeff Hao848f70a2014-01-15 13:49:50 -0800562 const uint16_t* utf16_string = string->GetValue();
Vladimir Markoa48aef42014-12-03 17:53:53 +0000563 size_t utf16_length = static_cast<size_t>(string->GetLength());
Hiroshi Yamauchie9e3e692014-06-24 14:31:37 -0700564 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
565 ReaderMutexLock mu(Thread::Current(), *class_linker->DexLock());
566 size_t dex_cache_count = class_linker->GetDexCacheCount();
567 for (size_t i = 0; i < dex_cache_count; ++i) {
568 DexCache* dex_cache = class_linker->GetDexCache(i);
Brian Carlstrom7940e442013-07-12 13:46:57 -0700569 const DexFile& dex_file = *dex_cache->GetDexFile();
Ian Rogers24c534d2013-11-14 00:15:00 -0800570 const DexFile::StringId* string_id;
Vladimir Markoa48aef42014-12-03 17:53:53 +0000571 if (UNLIKELY(utf16_length == 0)) {
Ian Rogers24c534d2013-11-14 00:15:00 -0800572 string_id = dex_file.FindStringId("");
573 } else {
Vladimir Markoa48aef42014-12-03 17:53:53 +0000574 string_id = dex_file.FindStringId(utf16_string, utf16_length);
Ian Rogers24c534d2013-11-14 00:15:00 -0800575 }
Mathieu Chartier590fee92013-09-13 13:46:47 -0700576 if (string_id != nullptr) {
Brian Carlstrom7940e442013-07-12 13:46:57 -0700577 // This string occurs in this dex file, assign the dex cache entry.
578 uint32_t string_idx = dex_file.GetIndexForStringId(*string_id);
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700579 if (dex_cache->GetResolvedString(string_idx) == nullptr) {
Brian Carlstrom7940e442013-07-12 13:46:57 -0700580 dex_cache->SetResolvedString(string_idx, string);
581 }
582 }
583 }
584}
585
Mathieu Chartierfd04b6f2014-11-14 19:34:18 -0800586void ImageWriter::ComputeEagerResolvedStrings() {
Mathieu Chartier590fee92013-09-13 13:46:47 -0700587 Runtime::Current()->GetHeap()->VisitObjects(ComputeEagerResolvedStringsCallback, this);
Brian Carlstrom7940e442013-07-12 13:46:57 -0700588}
589
Ian Rogersef7d42f2014-01-06 12:55:46 -0800590bool ImageWriter::IsImageClass(Class* klass) {
Mathieu Chartiere401d142015-04-22 13:56:20 -0700591 if (klass == nullptr) {
592 return false;
593 }
Ian Rogers1ff3c982014-08-12 02:30:58 -0700594 std::string temp;
595 return compiler_driver_.IsImageClass(klass->GetDescriptor(&temp));
Brian Carlstrom7940e442013-07-12 13:46:57 -0700596}
597
Mathieu Chartiere0671ce2015-07-28 17:23:28 -0700598class NonImageClassesVisitor : public ClassVisitor {
599 public:
600 explicit NonImageClassesVisitor(ImageWriter* image_writer) : image_writer_(image_writer) {}
601
602 bool Visit(Class* klass) OVERRIDE SHARED_REQUIRES(Locks::mutator_lock_) {
603 if (!image_writer_->IsImageClass(klass)) {
604 std::string temp;
605 non_image_classes_.insert(klass->GetDescriptor(&temp));
606 }
607 return true;
608 }
609
610 std::set<std::string> non_image_classes_;
611 ImageWriter* const image_writer_;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700612};
613
614void ImageWriter::PruneNonImageClasses() {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700615 if (compiler_driver_.GetImageClasses() == nullptr) {
Brian Carlstrom7940e442013-07-12 13:46:57 -0700616 return;
617 }
618 Runtime* runtime = Runtime::Current();
619 ClassLinker* class_linker = runtime->GetClassLinker();
Mathieu Chartiere401d142015-04-22 13:56:20 -0700620 Thread* self = Thread::Current();
Brian Carlstrom7940e442013-07-12 13:46:57 -0700621
622 // Make a list of classes we would like to prune.
Mathieu Chartiere0671ce2015-07-28 17:23:28 -0700623 NonImageClassesVisitor visitor(this);
624 class_linker->VisitClasses(&visitor);
Brian Carlstrom7940e442013-07-12 13:46:57 -0700625
626 // Remove the undesired classes from the class roots.
Mathieu Chartiere0671ce2015-07-28 17:23:28 -0700627 for (const std::string& it : visitor.non_image_classes_) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700628 bool result = class_linker->RemoveClass(it.c_str(), nullptr);
Mathieu Chartierc2e20622014-11-03 11:41:47 -0800629 DCHECK(result);
Brian Carlstrom7940e442013-07-12 13:46:57 -0700630 }
631
632 // Clear references to removed classes from the DexCaches.
Mathieu Chartiere401d142015-04-22 13:56:20 -0700633 const ArtMethod* resolution_method = runtime->GetResolutionMethod();
634 size_t dex_cache_count;
635 {
636 ReaderMutexLock mu(self, *class_linker->DexLock());
637 dex_cache_count = class_linker->GetDexCacheCount();
638 }
Hiroshi Yamauchie9e3e692014-06-24 14:31:37 -0700639 for (size_t idx = 0; idx < dex_cache_count; ++idx) {
Mathieu Chartiere401d142015-04-22 13:56:20 -0700640 DexCache* dex_cache;
641 {
642 ReaderMutexLock mu(self, *class_linker->DexLock());
643 dex_cache = class_linker->GetDexCache(idx);
644 }
Brian Carlstrom7940e442013-07-12 13:46:57 -0700645 for (size_t i = 0; i < dex_cache->NumResolvedTypes(); i++) {
646 Class* klass = dex_cache->GetResolvedType(i);
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700647 if (klass != nullptr && !IsImageClass(klass)) {
648 dex_cache->SetResolvedType(i, nullptr);
Brian Carlstrom7940e442013-07-12 13:46:57 -0700649 }
650 }
Mathieu Chartiere401d142015-04-22 13:56:20 -0700651 auto* resolved_methods = down_cast<mirror::PointerArray*>(dex_cache->GetResolvedMethods());
652 for (size_t i = 0, len = resolved_methods->GetLength(); i < len; i++) {
653 auto* method = resolved_methods->GetElementPtrSize<ArtMethod*>(i, target_ptr_size_);
654 if (method != nullptr) {
655 auto* declaring_class = method->GetDeclaringClass();
656 // Miranda methods may be held live by a class which was not an image class but have a
657 // declaring class which is an image class. Set it to the resolution method to be safe and
658 // prevent dangling pointers.
659 if (method->IsMiranda() || !IsImageClass(declaring_class)) {
660 resolved_methods->SetElementPtrSize(i, resolution_method, target_ptr_size_);
661 } else {
662 // Check that the class is still in the classes table.
663 DCHECK(class_linker->ClassInClassTable(declaring_class)) << "Class "
664 << PrettyClass(declaring_class) << " not in class linker table";
665 }
Brian Carlstrom7940e442013-07-12 13:46:57 -0700666 }
667 }
668 for (size_t i = 0; i < dex_cache->NumResolvedFields(); i++) {
Mathieu Chartiere401d142015-04-22 13:56:20 -0700669 ArtField* field = dex_cache->GetResolvedField(i, target_ptr_size_);
Mathieu Chartierc7853442015-03-27 14:35:38 -0700670 if (field != nullptr && !IsImageClass(field->GetDeclaringClass())) {
Mathieu Chartiere401d142015-04-22 13:56:20 -0700671 dex_cache->SetResolvedField(i, nullptr, target_ptr_size_);
Brian Carlstrom7940e442013-07-12 13:46:57 -0700672 }
673 }
Andreas Gampedd9d0552015-03-09 12:57:41 -0700674 // Clean the dex field. It might have been populated during the initialization phase, but
675 // contains data only valid during a real run.
676 dex_cache->SetFieldObject<false>(mirror::DexCache::DexOffset(), nullptr);
Brian Carlstrom7940e442013-07-12 13:46:57 -0700677 }
Andreas Gampe8ac75952015-06-02 21:01:45 -0700678
679 // Drop the array class cache in the ClassLinker, as these are roots holding those classes live.
680 class_linker->DropFindArrayClassCache();
Brian Carlstrom7940e442013-07-12 13:46:57 -0700681}
682
Mathieu Chartierfd04b6f2014-11-14 19:34:18 -0800683void ImageWriter::CheckNonImageClassesRemoved() {
Mathieu Chartier590fee92013-09-13 13:46:47 -0700684 if (compiler_driver_.GetImageClasses() != nullptr) {
685 gc::Heap* heap = Runtime::Current()->GetHeap();
Mathieu Chartier590fee92013-09-13 13:46:47 -0700686 heap->VisitObjects(CheckNonImageClassesRemovedCallback, this);
Brian Carlstrom7940e442013-07-12 13:46:57 -0700687 }
Brian Carlstrom7940e442013-07-12 13:46:57 -0700688}
689
690void ImageWriter::CheckNonImageClassesRemovedCallback(Object* obj, void* arg) {
691 ImageWriter* image_writer = reinterpret_cast<ImageWriter*>(arg);
Mathieu Chartier590fee92013-09-13 13:46:47 -0700692 if (obj->IsClass()) {
693 Class* klass = obj->AsClass();
694 if (!image_writer->IsImageClass(klass)) {
695 image_writer->DumpImageClasses();
Ian Rogers1ff3c982014-08-12 02:30:58 -0700696 std::string temp;
697 CHECK(image_writer->IsImageClass(klass)) << klass->GetDescriptor(&temp)
Mathieu Chartier590fee92013-09-13 13:46:47 -0700698 << " " << PrettyDescriptor(klass);
699 }
Brian Carlstrom7940e442013-07-12 13:46:57 -0700700 }
701}
702
703void ImageWriter::DumpImageClasses() {
Andreas Gampeb1fcead2015-04-20 18:53:51 -0700704 auto image_classes = compiler_driver_.GetImageClasses();
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700705 CHECK(image_classes != nullptr);
Mathieu Chartier02e25112013-08-14 16:14:24 -0700706 for (const std::string& image_class : *image_classes) {
707 LOG(INFO) << " " << image_class;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700708 }
709}
710
Igor Murashkinf5b4c502014-11-14 15:01:59 -0800711void ImageWriter::CalculateObjectBinSlots(Object* obj) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700712 DCHECK(obj != nullptr);
Brian Carlstrom7940e442013-07-12 13:46:57 -0700713 // if it is a string, we want to intern it if its not interned.
714 if (obj->GetClass()->IsStringClass()) {
715 // we must be an interned string that was forward referenced and already assigned
Igor Murashkinf5b4c502014-11-14 15:01:59 -0800716 if (IsImageBinSlotAssigned(obj)) {
Brian Carlstrom7940e442013-07-12 13:46:57 -0700717 DCHECK_EQ(obj, obj->AsString()->Intern());
718 return;
719 }
Mathieu Chartier14c3bf92015-07-13 14:35:43 -0700720 // InternImageString allows us to intern while holding the heap bitmap lock. This is safe since
721 // we are guaranteed to not have GC during image writing.
Mathieu Chartier90ef3db2015-08-04 15:19:41 -0700722 mirror::String* const interned = Runtime::Current()->GetInternTable()->InternStrongImageString(
Mathieu Chartier14c3bf92015-07-13 14:35:43 -0700723 obj->AsString());
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700724 if (obj != interned) {
Igor Murashkinf5b4c502014-11-14 15:01:59 -0800725 if (!IsImageBinSlotAssigned(interned)) {
Brian Carlstrom7940e442013-07-12 13:46:57 -0700726 // interned obj is after us, allocate its location early
Igor Murashkinf5b4c502014-11-14 15:01:59 -0800727 AssignImageBinSlot(interned);
Brian Carlstrom7940e442013-07-12 13:46:57 -0700728 }
729 // point those looking for this object to the interned version.
Igor Murashkinf5b4c502014-11-14 15:01:59 -0800730 SetImageBinSlot(obj, GetImageBinSlot(interned));
Brian Carlstrom7940e442013-07-12 13:46:57 -0700731 return;
732 }
733 // else (obj == interned), nothing to do but fall through to the normal case
734 }
735
Igor Murashkinf5b4c502014-11-14 15:01:59 -0800736 AssignImageBinSlot(obj);
Brian Carlstrom7940e442013-07-12 13:46:57 -0700737}
738
739ObjectArray<Object>* ImageWriter::CreateImageRoots() const {
740 Runtime* runtime = Runtime::Current();
741 ClassLinker* class_linker = runtime->GetClassLinker();
Brian Carlstrom7940e442013-07-12 13:46:57 -0700742 Thread* self = Thread::Current();
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700743 StackHandleScope<3> hs(self);
744 Handle<Class> object_array_class(hs.NewHandle(
745 class_linker->FindSystemClass(self, "[Ljava/lang/Object;")));
Brian Carlstrom7940e442013-07-12 13:46:57 -0700746
Hiroshi Yamauchie9e3e692014-06-24 14:31:37 -0700747 // build an Object[] of all the DexCaches used in the source_space_.
748 // Since we can't hold the dex lock when allocating the dex_caches
749 // ObjectArray, we lock the dex lock twice, first to get the number
750 // of dex caches first and then lock it again to copy the dex
751 // caches. We check that the number of dex caches does not change.
752 size_t dex_cache_count;
753 {
Mathieu Chartierc7853442015-03-27 14:35:38 -0700754 ReaderMutexLock mu(self, *class_linker->DexLock());
Hiroshi Yamauchie9e3e692014-06-24 14:31:37 -0700755 dex_cache_count = class_linker->GetDexCacheCount();
756 }
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700757 Handle<ObjectArray<Object>> dex_caches(
758 hs.NewHandle(ObjectArray<Object>::Alloc(self, object_array_class.Get(),
Hiroshi Yamauchie9e3e692014-06-24 14:31:37 -0700759 dex_cache_count)));
760 CHECK(dex_caches.Get() != nullptr) << "Failed to allocate a dex cache array.";
761 {
Mathieu Chartierc7853442015-03-27 14:35:38 -0700762 ReaderMutexLock mu(self, *class_linker->DexLock());
Hiroshi Yamauchie9e3e692014-06-24 14:31:37 -0700763 CHECK_EQ(dex_cache_count, class_linker->GetDexCacheCount())
764 << "The number of dex caches changed.";
765 for (size_t i = 0; i < dex_cache_count; ++i) {
766 dex_caches->Set<false>(i, class_linker->GetDexCache(i));
767 }
Brian Carlstrom7940e442013-07-12 13:46:57 -0700768 }
769
770 // build an Object[] of the roots needed to restore the runtime
Mathieu Chartiere401d142015-04-22 13:56:20 -0700771 auto image_roots(hs.NewHandle(
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700772 ObjectArray<Object>::Alloc(self, object_array_class.Get(), ImageHeader::kImageRootsMax)));
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700773 image_roots->Set<false>(ImageHeader::kDexCaches, dex_caches.Get());
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100774 image_roots->Set<false>(ImageHeader::kClassRoots, class_linker->GetClassRoots());
Brian Carlstrom7940e442013-07-12 13:46:57 -0700775 for (int i = 0; i < ImageHeader::kImageRootsMax; i++) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700776 CHECK(image_roots->Get(i) != nullptr);
Brian Carlstrom7940e442013-07-12 13:46:57 -0700777 }
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700778 return image_roots.Get();
Brian Carlstrom7940e442013-07-12 13:46:57 -0700779}
780
Mathieu Chartier590fee92013-09-13 13:46:47 -0700781// Walk instance fields of the given Class. Separate function to allow recursion on the super
782// class.
783void ImageWriter::WalkInstanceFields(mirror::Object* obj, mirror::Class* klass) {
784 // Visit fields of parent classes first.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700785 StackHandleScope<1> hs(Thread::Current());
786 Handle<mirror::Class> h_class(hs.NewHandle(klass));
787 mirror::Class* super = h_class->GetSuperClass();
Mathieu Chartier590fee92013-09-13 13:46:47 -0700788 if (super != nullptr) {
789 WalkInstanceFields(obj, super);
790 }
791 //
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700792 size_t num_reference_fields = h_class->NumReferenceInstanceFields();
Vladimir Marko76649e82014-11-10 18:32:59 +0000793 MemberOffset field_offset = h_class->GetFirstReferenceInstanceFieldOffset();
Mathieu Chartier590fee92013-09-13 13:46:47 -0700794 for (size_t i = 0; i < num_reference_fields; ++i) {
Ian Rogersb0fa5dc2014-04-28 16:47:08 -0700795 mirror::Object* value = obj->GetFieldObject<mirror::Object>(field_offset);
Mathieu Chartier590fee92013-09-13 13:46:47 -0700796 if (value != nullptr) {
797 WalkFieldsInOrder(value);
798 }
Vladimir Marko76649e82014-11-10 18:32:59 +0000799 field_offset = MemberOffset(field_offset.Uint32Value() +
800 sizeof(mirror::HeapReference<mirror::Object>));
Mathieu Chartier590fee92013-09-13 13:46:47 -0700801 }
802}
803
804// For an unvisited object, visit it then all its children found via fields.
805void ImageWriter::WalkFieldsInOrder(mirror::Object* obj) {
Igor Murashkinf5b4c502014-11-14 15:01:59 -0800806 // Use our own visitor routine (instead of GC visitor) to get better locality between
807 // an object and its fields
808 if (!IsImageBinSlotAssigned(obj)) {
Mathieu Chartier590fee92013-09-13 13:46:47 -0700809 // Walk instance fields of all objects
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700810 StackHandleScope<2> hs(Thread::Current());
811 Handle<mirror::Object> h_obj(hs.NewHandle(obj));
812 Handle<mirror::Class> klass(hs.NewHandle(obj->GetClass()));
Mathieu Chartier590fee92013-09-13 13:46:47 -0700813 // visit the object itself.
Igor Murashkinf5b4c502014-11-14 15:01:59 -0800814 CalculateObjectBinSlots(h_obj.Get());
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700815 WalkInstanceFields(h_obj.Get(), klass.Get());
Mathieu Chartier590fee92013-09-13 13:46:47 -0700816 // Walk static fields of a Class.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700817 if (h_obj->IsClass()) {
Mathieu Chartierc7853442015-03-27 14:35:38 -0700818 size_t num_reference_static_fields = klass->NumReferenceStaticFields();
Mathieu Chartiere401d142015-04-22 13:56:20 -0700819 MemberOffset field_offset = klass->GetFirstReferenceStaticFieldOffset(target_ptr_size_);
Mathieu Chartierc7853442015-03-27 14:35:38 -0700820 for (size_t i = 0; i < num_reference_static_fields; ++i) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700821 mirror::Object* value = h_obj->GetFieldObject<mirror::Object>(field_offset);
Mathieu Chartier590fee92013-09-13 13:46:47 -0700822 if (value != nullptr) {
823 WalkFieldsInOrder(value);
824 }
Vladimir Marko76649e82014-11-10 18:32:59 +0000825 field_offset = MemberOffset(field_offset.Uint32Value() +
826 sizeof(mirror::HeapReference<mirror::Object>));
Mathieu Chartier590fee92013-09-13 13:46:47 -0700827 }
Mathieu Chartier54d220e2015-07-30 16:20:06 -0700828 // Visit and assign offsets for fields and field arrays.
Mathieu Chartiere401d142015-04-22 13:56:20 -0700829 auto* as_klass = h_obj->AsClass();
Mathieu Chartier54d220e2015-07-30 16:20:06 -0700830 LengthPrefixedArray<ArtField>* fields[] = {
831 as_klass->GetSFieldsPtr(), as_klass->GetIFieldsPtr(),
832 };
833 for (LengthPrefixedArray<ArtField>* cur_fields : fields) {
834 // Total array length including header.
835 if (cur_fields != nullptr) {
836 const size_t header_size = LengthPrefixedArray<ArtField>::ComputeSize(0);
837 // Forward the entire array at once.
838 auto it = native_object_relocations_.find(cur_fields);
839 CHECK(it == native_object_relocations_.end()) << "Field array " << cur_fields
840 << " already forwarded";
841 size_t& offset = bin_slot_sizes_[kBinArtField];
842 native_object_relocations_.emplace(
843 cur_fields, NativeObjectRelocation {
844 offset, kNativeObjectRelocationTypeArtFieldArray });
845 offset += header_size;
846 // Forward individual fields so that we can quickly find where they belong.
847 for (size_t i = 0, count = cur_fields->Length(); i < count; ++i) {
848 // Need to forward arrays separate of fields.
849 ArtField* field = &cur_fields->At(i);
850 auto it2 = native_object_relocations_.find(field);
851 CHECK(it2 == native_object_relocations_.end()) << "Field at index=" << i
852 << " already assigned " << PrettyField(field) << " static=" << field->IsStatic();
853 native_object_relocations_.emplace(
854 field, NativeObjectRelocation {offset, kNativeObjectRelocationTypeArtField });
855 offset += sizeof(ArtField);
856 }
Mathieu Chartierc7853442015-03-27 14:35:38 -0700857 }
858 }
Mathieu Chartiere401d142015-04-22 13:56:20 -0700859 // Visit and assign offsets for methods.
Mathieu Chartier54d220e2015-07-30 16:20:06 -0700860 LengthPrefixedArray<ArtMethod>* method_arrays[] = {
861 as_klass->GetDirectMethodsPtr(), as_klass->GetVirtualMethodsPtr(),
Mathieu Chartiere401d142015-04-22 13:56:20 -0700862 };
Mathieu Chartier54d220e2015-07-30 16:20:06 -0700863 for (LengthPrefixedArray<ArtMethod>* array : method_arrays) {
864 if (array == nullptr) {
865 continue;
866 }
Mathieu Chartiere401d142015-04-22 13:56:20 -0700867 bool any_dirty = false;
868 size_t count = 0;
Vladimir Marko14632852015-08-17 12:07:23 +0100869 const size_t method_alignment = ArtMethod::Alignment(target_ptr_size_);
870 const size_t method_size = ArtMethod::Size(target_ptr_size_);
Vladimir Markocf36d492015-08-12 19:27:26 +0100871 auto iteration_range =
872 MakeIterationRangeFromLengthPrefixedArray(array, method_size, method_alignment);
Mathieu Chartier54d220e2015-07-30 16:20:06 -0700873 for (auto& m : iteration_range) {
Mathieu Chartiere401d142015-04-22 13:56:20 -0700874 any_dirty = any_dirty || WillMethodBeDirty(&m);
875 ++count;
876 }
Mathieu Chartier54d220e2015-07-30 16:20:06 -0700877 NativeObjectRelocationType type = any_dirty ? kNativeObjectRelocationTypeArtMethodDirty :
878 kNativeObjectRelocationTypeArtMethodClean;
879 Bin bin_type = BinTypeForNativeRelocationType(type);
880 // Forward the entire array at once, but header first.
Vladimir Markocf36d492015-08-12 19:27:26 +0100881 const size_t header_size = LengthPrefixedArray<ArtMethod>::ComputeSize(0,
882 method_size,
883 method_alignment);
Mathieu Chartier54d220e2015-07-30 16:20:06 -0700884 auto it = native_object_relocations_.find(array);
885 CHECK(it == native_object_relocations_.end()) << "Method array " << array
886 << " already forwarded";
887 size_t& offset = bin_slot_sizes_[bin_type];
888 native_object_relocations_.emplace(array, NativeObjectRelocation { offset,
889 any_dirty ? kNativeObjectRelocationTypeArtMethodArrayDirty :
890 kNativeObjectRelocationTypeArtMethodArrayClean });
891 offset += header_size;
892 for (auto& m : iteration_range) {
893 AssignMethodOffset(&m, type);
Mathieu Chartiere401d142015-04-22 13:56:20 -0700894 }
895 (any_dirty ? dirty_methods_ : clean_methods_) += count;
896 }
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700897 } else if (h_obj->IsObjectArray()) {
Mathieu Chartier590fee92013-09-13 13:46:47 -0700898 // Walk elements of an object array.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700899 int32_t length = h_obj->AsObjectArray<mirror::Object>()->GetLength();
Mathieu Chartier590fee92013-09-13 13:46:47 -0700900 for (int32_t i = 0; i < length; i++) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700901 mirror::ObjectArray<mirror::Object>* obj_array = h_obj->AsObjectArray<mirror::Object>();
Mathieu Chartier590fee92013-09-13 13:46:47 -0700902 mirror::Object* value = obj_array->Get(i);
903 if (value != nullptr) {
904 WalkFieldsInOrder(value);
905 }
906 }
907 }
908 }
909}
910
Mathieu Chartier54d220e2015-07-30 16:20:06 -0700911void ImageWriter::AssignMethodOffset(ArtMethod* method, NativeObjectRelocationType type) {
912 auto it = native_object_relocations_.find(method);
913 CHECK(it == native_object_relocations_.end()) << "Method " << method << " already assigned "
Mathieu Chartiere401d142015-04-22 13:56:20 -0700914 << PrettyMethod(method);
Mathieu Chartier54d220e2015-07-30 16:20:06 -0700915 size_t& offset = bin_slot_sizes_[BinTypeForNativeRelocationType(type)];
916 native_object_relocations_.emplace(method, NativeObjectRelocation { offset, type });
Vladimir Marko14632852015-08-17 12:07:23 +0100917 offset += ArtMethod::Size(target_ptr_size_);
Mathieu Chartiere401d142015-04-22 13:56:20 -0700918}
919
Mathieu Chartier590fee92013-09-13 13:46:47 -0700920void ImageWriter::WalkFieldsCallback(mirror::Object* obj, void* arg) {
921 ImageWriter* writer = reinterpret_cast<ImageWriter*>(arg);
922 DCHECK(writer != nullptr);
923 writer->WalkFieldsInOrder(obj);
924}
925
Igor Murashkinf5b4c502014-11-14 15:01:59 -0800926void ImageWriter::UnbinObjectsIntoOffsetCallback(mirror::Object* obj, void* arg) {
927 ImageWriter* writer = reinterpret_cast<ImageWriter*>(arg);
928 DCHECK(writer != nullptr);
929 writer->UnbinObjectsIntoOffset(obj);
930}
931
932void ImageWriter::UnbinObjectsIntoOffset(mirror::Object* obj) {
933 CHECK(obj != nullptr);
934
935 // We know the bin slot, and the total bin sizes for all objects by now,
936 // so calculate the object's final image offset.
937
938 DCHECK(IsImageBinSlotAssigned(obj));
939 BinSlot bin_slot = GetImageBinSlot(obj);
940 // Change the lockword from a bin slot into an offset
941 AssignImageOffset(obj, bin_slot);
942}
943
Vladimir Markof4da6752014-08-01 19:04:18 +0100944void ImageWriter::CalculateNewObjectOffsets() {
Mathieu Chartiere401d142015-04-22 13:56:20 -0700945 Thread* const self = Thread::Current();
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700946 StackHandleScope<1> hs(self);
947 Handle<ObjectArray<Object>> image_roots(hs.NewHandle(CreateImageRoots()));
Brian Carlstrom7940e442013-07-12 13:46:57 -0700948
Mathieu Chartiere401d142015-04-22 13:56:20 -0700949 auto* runtime = Runtime::Current();
950 auto* heap = runtime->GetHeap();
Brian Carlstrom7940e442013-07-12 13:46:57 -0700951 DCHECK_EQ(0U, image_end_);
952
Mathieu Chartier31e89252013-08-28 11:29:12 -0700953 // Leave space for the header, but do not write it yet, we need to
Brian Carlstrom7940e442013-07-12 13:46:57 -0700954 // know where image_roots is going to end up
Igor Murashkinf5b4c502014-11-14 15:01:59 -0800955 image_end_ += RoundUp(sizeof(ImageHeader), kObjectAlignment); // 64-bit-alignment
Brian Carlstrom7940e442013-07-12 13:46:57 -0700956
Hiroshi Yamauchi0c8c3032015-01-16 16:54:35 -0800957 image_objects_offset_begin_ = image_end_;
Vladimir Marko20f85592015-03-19 10:07:02 +0000958 // Prepare bin slots for dex cache arrays.
959 PrepareDexCacheArraySlots();
Hiroshi Yamauchi0c8c3032015-01-16 16:54:35 -0800960 // Clear any pre-existing monitors which may have been in the monitor words, assign bin slots.
961 heap->VisitObjects(WalkFieldsCallback, this);
Mathieu Chartiere401d142015-04-22 13:56:20 -0700962 // Write the image runtime methods.
963 image_methods_[ImageHeader::kResolutionMethod] = runtime->GetResolutionMethod();
964 image_methods_[ImageHeader::kImtConflictMethod] = runtime->GetImtConflictMethod();
965 image_methods_[ImageHeader::kImtUnimplementedMethod] = runtime->GetImtUnimplementedMethod();
966 image_methods_[ImageHeader::kCalleeSaveMethod] = runtime->GetCalleeSaveMethod(Runtime::kSaveAll);
967 image_methods_[ImageHeader::kRefsOnlySaveMethod] =
968 runtime->GetCalleeSaveMethod(Runtime::kRefsOnly);
969 image_methods_[ImageHeader::kRefsAndArgsSaveMethod] =
970 runtime->GetCalleeSaveMethod(Runtime::kRefsAndArgs);
Mathieu Chartier54d220e2015-07-30 16:20:06 -0700971
972 // Add room for fake length prefixed array.
973 const auto image_method_type = kNativeObjectRelocationTypeArtMethodArrayClean;
974 auto it = native_object_relocations_.find(&image_method_array_);
975 CHECK(it == native_object_relocations_.end());
976 size_t& offset = bin_slot_sizes_[BinTypeForNativeRelocationType(image_method_type)];
977 native_object_relocations_.emplace(&image_method_array_,
978 NativeObjectRelocation { offset, image_method_type });
Vladimir Marko14632852015-08-17 12:07:23 +0100979 size_t method_alignment = ArtMethod::Alignment(target_ptr_size_);
Mathieu Chartierc0fe56a2015-08-11 13:01:23 -0700980 const size_t array_size = LengthPrefixedArray<ArtMethod>::ComputeSize(
Vladimir Marko14632852015-08-17 12:07:23 +0100981 0, ArtMethod::Size(target_ptr_size_), method_alignment);
Vladimir Markocf36d492015-08-12 19:27:26 +0100982 CHECK_ALIGNED_PARAM(array_size, method_alignment);
Mathieu Chartierc0fe56a2015-08-11 13:01:23 -0700983 offset += array_size;
Mathieu Chartiere401d142015-04-22 13:56:20 -0700984 for (auto* m : image_methods_) {
985 CHECK(m != nullptr);
986 CHECK(m->IsRuntimeMethod());
Mathieu Chartier54d220e2015-07-30 16:20:06 -0700987 AssignMethodOffset(m, kNativeObjectRelocationTypeArtMethodClean);
Mathieu Chartiere401d142015-04-22 13:56:20 -0700988 }
989
Vladimir Markocf36d492015-08-12 19:27:26 +0100990 // Calculate bin slot offsets.
991 size_t bin_offset = image_objects_offset_begin_;
Vladimir Marko20f85592015-03-19 10:07:02 +0000992 for (size_t i = 0; i != kBinSize; ++i) {
Vladimir Markocf36d492015-08-12 19:27:26 +0100993 bin_slot_offsets_[i] = bin_offset;
994 bin_offset += bin_slot_sizes_[i];
995 if (i == kBinArtField) {
996 static_assert(kBinArtField + 1 == kBinArtMethodClean, "Methods follow fields.");
997 static_assert(alignof(ArtField) == 4u, "ArtField alignment is 4.");
998 DCHECK_ALIGNED(bin_offset, 4u);
999 DCHECK(method_alignment == 4u || method_alignment == 8u);
1000 bin_offset = RoundUp(bin_offset, method_alignment);
1001 }
Vladimir Marko20f85592015-03-19 10:07:02 +00001002 }
Vladimir Markocf36d492015-08-12 19:27:26 +01001003 // NOTE: There may be additional padding between the bin slots and the intern table.
1004
Mathieu Chartierc7853442015-03-27 14:35:38 -07001005 DCHECK_EQ(image_end_, GetBinSizeSum(kBinMirrorCount) + image_objects_offset_begin_);
1006
Hiroshi Yamauchi0c8c3032015-01-16 16:54:35 -08001007 // Transform each object's bin slot into an offset which will be used to do the final copy.
1008 heap->VisitObjects(UnbinObjectsIntoOffsetCallback, this);
Brian Carlstrom7940e442013-07-12 13:46:57 -07001009
Mathieu Chartierc7853442015-03-27 14:35:38 -07001010 DCHECK_EQ(image_end_, GetBinSizeSum(kBinMirrorCount) + image_objects_offset_begin_);
Igor Murashkinf5b4c502014-11-14 15:01:59 -08001011
Vladimir Markof4da6752014-08-01 19:04:18 +01001012 image_roots_address_ = PointerToLowMemUInt32(GetImageAddress(image_roots.Get()));
1013
Mathieu Chartiere401d142015-04-22 13:56:20 -07001014 // Update the native relocations by adding their bin sums.
Mathieu Chartier54d220e2015-07-30 16:20:06 -07001015 for (auto& pair : native_object_relocations_) {
1016 NativeObjectRelocation& relocation = pair.second;
1017 Bin bin_type = BinTypeForNativeRelocationType(relocation.type);
Vladimir Markocf36d492015-08-12 19:27:26 +01001018 relocation.offset += bin_slot_offsets_[bin_type];
Mathieu Chartiere401d142015-04-22 13:56:20 -07001019 }
1020
Mathieu Chartierd39645e2015-06-09 17:50:29 -07001021 // Calculate how big the intern table will be after being serialized.
1022 auto* const intern_table = Runtime::Current()->GetInternTable();
1023 CHECK_EQ(intern_table->WeakSize(), 0u) << " should have strong interned all the strings";
1024 intern_table_bytes_ = intern_table->WriteToMemory(nullptr);
1025
Mathieu Chartiere401d142015-04-22 13:56:20 -07001026 // Note that image_end_ is left at end of used mirror object section.
Vladimir Markof4da6752014-08-01 19:04:18 +01001027}
1028
1029void ImageWriter::CreateHeader(size_t oat_loaded_size, size_t oat_data_offset) {
1030 CHECK_NE(0U, oat_loaded_size);
Ian Rogers13735952014-10-08 12:43:28 -07001031 const uint8_t* oat_file_begin = GetOatFileBegin();
1032 const uint8_t* oat_file_end = oat_file_begin + oat_loaded_size;
Brian Carlstrom7940e442013-07-12 13:46:57 -07001033 oat_data_begin_ = oat_file_begin + oat_data_offset;
Ian Rogers13735952014-10-08 12:43:28 -07001034 const uint8_t* oat_data_end = oat_data_begin_ + oat_file_->Size();
Mathieu Chartiere401d142015-04-22 13:56:20 -07001035
1036 // Create the image sections.
1037 ImageSection sections[ImageHeader::kSectionCount];
1038 // Objects section
1039 auto* objects_section = &sections[ImageHeader::kSectionObjects];
1040 *objects_section = ImageSection(0u, image_end_);
1041 size_t cur_pos = objects_section->End();
1042 // Add field section.
1043 auto* field_section = &sections[ImageHeader::kSectionArtFields];
1044 *field_section = ImageSection(cur_pos, bin_slot_sizes_[kBinArtField]);
Vladimir Markocf36d492015-08-12 19:27:26 +01001045 CHECK_EQ(bin_slot_offsets_[kBinArtField], field_section->Offset());
Mathieu Chartiere401d142015-04-22 13:56:20 -07001046 cur_pos = field_section->End();
Vladimir Markocf36d492015-08-12 19:27:26 +01001047 // Round up to the alignment the required by the method section.
Vladimir Marko14632852015-08-17 12:07:23 +01001048 cur_pos = RoundUp(cur_pos, ArtMethod::Alignment(target_ptr_size_));
Mathieu Chartiere401d142015-04-22 13:56:20 -07001049 // Add method section.
1050 auto* methods_section = &sections[ImageHeader::kSectionArtMethods];
1051 *methods_section = ImageSection(cur_pos, bin_slot_sizes_[kBinArtMethodClean] +
1052 bin_slot_sizes_[kBinArtMethodDirty]);
Vladimir Markocf36d492015-08-12 19:27:26 +01001053 CHECK_EQ(bin_slot_offsets_[kBinArtMethodClean], methods_section->Offset());
Mathieu Chartiere401d142015-04-22 13:56:20 -07001054 cur_pos = methods_section->End();
Nicolas Geoffray7bf2b4f2015-07-08 10:11:59 +00001055 // Round up to the alignment the string table expects. See HashSet::WriteToMemory.
1056 cur_pos = RoundUp(cur_pos, sizeof(uint64_t));
Mathieu Chartierd39645e2015-06-09 17:50:29 -07001057 // Calculate the size of the interned strings.
1058 auto* interned_strings_section = &sections[ImageHeader::kSectionInternedStrings];
1059 *interned_strings_section = ImageSection(cur_pos, intern_table_bytes_);
1060 cur_pos = interned_strings_section->End();
Mathieu Chartiere401d142015-04-22 13:56:20 -07001061 // Finally bitmap section.
Mathieu Chartierc7853442015-03-27 14:35:38 -07001062 const size_t bitmap_bytes = image_bitmap_->Size();
Mathieu Chartiere401d142015-04-22 13:56:20 -07001063 auto* bitmap_section = &sections[ImageHeader::kSectionImageBitmap];
1064 *bitmap_section = ImageSection(RoundUp(cur_pos, kPageSize), RoundUp(bitmap_bytes, kPageSize));
1065 cur_pos = bitmap_section->End();
1066 if (kIsDebugBuild) {
1067 size_t idx = 0;
Mathieu Chartierd39645e2015-06-09 17:50:29 -07001068 for (const ImageSection& section : sections) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07001069 LOG(INFO) << static_cast<ImageHeader::ImageSections>(idx) << " " << section;
1070 ++idx;
1071 }
1072 LOG(INFO) << "Methods: clean=" << clean_methods_ << " dirty=" << dirty_methods_;
1073 }
Mathieu Chartierd39645e2015-06-09 17:50:29 -07001074 const size_t image_end = static_cast<uint32_t>(interned_strings_section->End());
1075 CHECK_EQ(AlignUp(image_begin_ + image_end, kPageSize), oat_file_begin) <<
1076 "Oat file should be right after the image.";
Mathieu Chartiere401d142015-04-22 13:56:20 -07001077 // Create the header.
1078 new (image_->Begin()) ImageHeader(
Mathieu Chartierd39645e2015-06-09 17:50:29 -07001079 PointerToLowMemUInt32(image_begin_), image_end,
1080 sections, image_roots_address_, oat_file_->GetOatHeader().GetChecksum(),
Mathieu Chartiere401d142015-04-22 13:56:20 -07001081 PointerToLowMemUInt32(oat_file_begin), PointerToLowMemUInt32(oat_data_begin_),
1082 PointerToLowMemUInt32(oat_data_end), PointerToLowMemUInt32(oat_file_end), target_ptr_size_,
1083 compile_pic_);
1084}
1085
1086ArtMethod* ImageWriter::GetImageMethodAddress(ArtMethod* method) {
Mathieu Chartier54d220e2015-07-30 16:20:06 -07001087 auto it = native_object_relocations_.find(method);
1088 CHECK(it != native_object_relocations_.end()) << PrettyMethod(method) << " @ " << method;
Mathieu Chartiere401d142015-04-22 13:56:20 -07001089 CHECK_GE(it->second.offset, image_end_) << "ArtMethods should be after Objects";
1090 return reinterpret_cast<ArtMethod*>(image_begin_ + it->second.offset);
Brian Carlstrom7940e442013-07-12 13:46:57 -07001091}
1092
Mathieu Chartierd39645e2015-06-09 17:50:29 -07001093class FixupRootVisitor : public RootVisitor {
1094 public:
1095 explicit FixupRootVisitor(ImageWriter* image_writer) : image_writer_(image_writer) {
1096 }
1097
1098 void VisitRoots(mirror::Object*** roots, size_t count, const RootInfo& info ATTRIBUTE_UNUSED)
Mathieu Chartier90443472015-07-16 20:32:27 -07001099 OVERRIDE SHARED_REQUIRES(Locks::mutator_lock_) {
Mathieu Chartierd39645e2015-06-09 17:50:29 -07001100 for (size_t i = 0; i < count; ++i) {
1101 *roots[i] = ImageAddress(*roots[i]);
1102 }
1103 }
1104
1105 void VisitRoots(mirror::CompressedReference<mirror::Object>** roots, size_t count,
1106 const RootInfo& info ATTRIBUTE_UNUSED)
Mathieu Chartier90443472015-07-16 20:32:27 -07001107 OVERRIDE SHARED_REQUIRES(Locks::mutator_lock_) {
Mathieu Chartierd39645e2015-06-09 17:50:29 -07001108 for (size_t i = 0; i < count; ++i) {
1109 roots[i]->Assign(ImageAddress(roots[i]->AsMirrorPtr()));
1110 }
1111 }
1112
1113 private:
1114 ImageWriter* const image_writer_;
1115
Mathieu Chartier90443472015-07-16 20:32:27 -07001116 mirror::Object* ImageAddress(mirror::Object* obj) SHARED_REQUIRES(Locks::mutator_lock_) {
Mathieu Chartierd39645e2015-06-09 17:50:29 -07001117 const size_t offset = image_writer_->GetImageOffset(obj);
1118 auto* const dest = reinterpret_cast<Object*>(image_writer_->image_begin_ + offset);
1119 VLOG(compiler) << "Update root from " << obj << " to " << dest;
1120 return dest;
1121 }
1122};
1123
Mathieu Chartierc7853442015-03-27 14:35:38 -07001124void ImageWriter::CopyAndFixupNativeData() {
Mathieu Chartiere401d142015-04-22 13:56:20 -07001125 // Copy ArtFields and methods to their locations and update the array for convenience.
Mathieu Chartier54d220e2015-07-30 16:20:06 -07001126 for (auto& pair : native_object_relocations_) {
1127 NativeObjectRelocation& relocation = pair.second;
1128 auto* dest = image_->Begin() + relocation.offset;
1129 DCHECK_GE(dest, image_->Begin() + image_end_);
1130 switch (relocation.type) {
1131 case kNativeObjectRelocationTypeArtField: {
1132 memcpy(dest, pair.first, sizeof(ArtField));
1133 reinterpret_cast<ArtField*>(dest)->SetDeclaringClass(
1134 GetImageAddress(reinterpret_cast<ArtField*>(pair.first)->GetDeclaringClass()));
1135 break;
1136 }
1137 case kNativeObjectRelocationTypeArtMethodClean:
1138 case kNativeObjectRelocationTypeArtMethodDirty: {
1139 CopyAndFixupMethod(reinterpret_cast<ArtMethod*>(pair.first),
1140 reinterpret_cast<ArtMethod*>(dest));
1141 break;
1142 }
1143 // For arrays, copy just the header since the elements will get copied by their corresponding
1144 // relocations.
1145 case kNativeObjectRelocationTypeArtFieldArray: {
1146 memcpy(dest, pair.first, LengthPrefixedArray<ArtField>::ComputeSize(0));
1147 break;
1148 }
1149 case kNativeObjectRelocationTypeArtMethodArrayClean:
1150 case kNativeObjectRelocationTypeArtMethodArrayDirty: {
Vladimir Markocf36d492015-08-12 19:27:26 +01001151 memcpy(dest, pair.first, LengthPrefixedArray<ArtMethod>::ComputeSize(
1152 0,
Vladimir Marko14632852015-08-17 12:07:23 +01001153 ArtMethod::Size(target_ptr_size_),
1154 ArtMethod::Alignment(target_ptr_size_)));
Mathieu Chartier54d220e2015-07-30 16:20:06 -07001155 break;
1156 }
Mathieu Chartiere401d142015-04-22 13:56:20 -07001157 }
1158 }
1159 // Fixup the image method roots.
1160 auto* image_header = reinterpret_cast<ImageHeader*>(image_->Begin());
Mathieu Chartierd39645e2015-06-09 17:50:29 -07001161 const ImageSection& methods_section = image_header->GetMethodsSection();
Mathieu Chartiere401d142015-04-22 13:56:20 -07001162 for (size_t i = 0; i < ImageHeader::kImageMethodsCount; ++i) {
1163 auto* m = image_methods_[i];
1164 CHECK(m != nullptr);
Mathieu Chartier54d220e2015-07-30 16:20:06 -07001165 auto it = native_object_relocations_.find(m);
1166 CHECK(it != native_object_relocations_.end()) << "No fowarding for " << PrettyMethod(m);
1167 NativeObjectRelocation& relocation = it->second;
1168 CHECK(methods_section.Contains(relocation.offset)) << relocation.offset << " not in "
Mathieu Chartiere401d142015-04-22 13:56:20 -07001169 << methods_section;
Mathieu Chartier54d220e2015-07-30 16:20:06 -07001170 CHECK(relocation.IsArtMethodRelocation()) << relocation.type;
Mathieu Chartiere401d142015-04-22 13:56:20 -07001171 auto* dest = reinterpret_cast<ArtMethod*>(image_begin_ + it->second.offset);
1172 image_header->SetImageMethod(static_cast<ImageHeader::ImageMethod>(i), dest);
Mathieu Chartierc7853442015-03-27 14:35:38 -07001173 }
Mathieu Chartierd39645e2015-06-09 17:50:29 -07001174 // Write the intern table into the image.
1175 const ImageSection& intern_table_section = image_header->GetImageSection(
1176 ImageHeader::kSectionInternedStrings);
1177 InternTable* const intern_table = Runtime::Current()->GetInternTable();
1178 uint8_t* const memory_ptr = image_->Begin() + intern_table_section.Offset();
1179 const size_t intern_table_bytes = intern_table->WriteToMemory(memory_ptr);
1180 // Fixup the pointers in the newly written intern table to contain image addresses.
1181 InternTable temp_table;
1182 // Note that we require that ReadFromMemory does not make an internal copy of the elements so that
1183 // the VisitRoots() will update the memory directly rather than the copies.
1184 // This also relies on visit roots not doing any verification which could fail after we update
1185 // the roots to be the image addresses.
1186 temp_table.ReadFromMemory(memory_ptr);
1187 CHECK_EQ(temp_table.Size(), intern_table->Size());
1188 FixupRootVisitor visitor(this);
1189 temp_table.VisitRoots(&visitor, kVisitRootFlagAllRoots);
1190 CHECK_EQ(intern_table_bytes, intern_table_bytes_);
Mathieu Chartierc7853442015-03-27 14:35:38 -07001191}
1192
Mathieu Chartierfd04b6f2014-11-14 19:34:18 -08001193void ImageWriter::CopyAndFixupObjects() {
Brian Carlstrom7940e442013-07-12 13:46:57 -07001194 gc::Heap* heap = Runtime::Current()->GetHeap();
Mathieu Chartier590fee92013-09-13 13:46:47 -07001195 heap->VisitObjects(CopyAndFixupObjectsCallback, this);
1196 // Fix up the object previously had hash codes.
Mathieu Chartierd39645e2015-06-09 17:50:29 -07001197 for (const auto& hash_pair : saved_hashcode_map_) {
Hiroshi Yamauchie15ea082015-02-09 17:11:42 -08001198 Object* obj = hash_pair.first;
Andreas Gampe3b45ef22015-05-26 21:34:09 -07001199 DCHECK_EQ(obj->GetLockWord<kVerifyNone>(false).ReadBarrierState(), 0U);
1200 obj->SetLockWord<kVerifyNone>(LockWord::FromHashCode(hash_pair.second, 0U), false);
Mathieu Chartier590fee92013-09-13 13:46:47 -07001201 }
Mathieu Chartierd39645e2015-06-09 17:50:29 -07001202 saved_hashcode_map_.clear();
Brian Carlstrom7940e442013-07-12 13:46:57 -07001203}
1204
Mathieu Chartier590fee92013-09-13 13:46:47 -07001205void ImageWriter::CopyAndFixupObjectsCallback(Object* obj, void* arg) {
Mathieu Chartier4d7f61d2014-04-17 14:43:39 -07001206 DCHECK(obj != nullptr);
1207 DCHECK(arg != nullptr);
Mathieu Chartierc7853442015-03-27 14:35:38 -07001208 reinterpret_cast<ImageWriter*>(arg)->CopyAndFixupObject(obj);
1209}
1210
Mathieu Chartiere401d142015-04-22 13:56:20 -07001211void ImageWriter::FixupPointerArray(mirror::Object* dst, mirror::PointerArray* arr,
1212 mirror::Class* klass, Bin array_type) {
1213 CHECK(klass->IsArrayClass());
1214 CHECK(arr->IsIntArray() || arr->IsLongArray()) << PrettyClass(klass) << " " << arr;
1215 // Fixup int and long pointers for the ArtMethod or ArtField arrays.
Mathieu Chartierc7853442015-03-27 14:35:38 -07001216 const size_t num_elements = arr->GetLength();
Mathieu Chartiere401d142015-04-22 13:56:20 -07001217 dst->SetClass(GetImageAddress(arr->GetClass()));
1218 auto* dest_array = down_cast<mirror::PointerArray*>(dst);
Mathieu Chartierc7853442015-03-27 14:35:38 -07001219 for (size_t i = 0, count = num_elements; i < count; ++i) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07001220 auto* elem = arr->GetElementPtrSize<void*>(i, target_ptr_size_);
1221 if (elem != nullptr) {
Mathieu Chartier54d220e2015-07-30 16:20:06 -07001222 auto it = native_object_relocations_.find(elem);
1223 if (it == native_object_relocations_.end()) {
Mathieu Chartierc0fe56a2015-08-11 13:01:23 -07001224 if (it->second.IsArtMethodRelocation()) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07001225 auto* method = reinterpret_cast<ArtMethod*>(elem);
1226 LOG(FATAL) << "No relocation entry for ArtMethod " << PrettyMethod(method) << " @ "
1227 << method << " idx=" << i << "/" << num_elements << " with declaring class "
1228 << PrettyClass(method->GetDeclaringClass());
1229 } else {
1230 CHECK_EQ(array_type, kBinArtField);
1231 auto* field = reinterpret_cast<ArtField*>(elem);
1232 LOG(FATAL) << "No relocation entry for ArtField " << PrettyField(field) << " @ "
1233 << field << " idx=" << i << "/" << num_elements << " with declaring class "
1234 << PrettyClass(field->GetDeclaringClass());
1235 }
1236 } else {
1237 elem = image_begin_ + it->second.offset;
1238 }
Mathieu Chartierc7853442015-03-27 14:35:38 -07001239 }
Mathieu Chartiere401d142015-04-22 13:56:20 -07001240 dest_array->SetElementPtrSize<false, true>(i, elem, target_ptr_size_);
Mathieu Chartierc7853442015-03-27 14:35:38 -07001241 }
Mathieu Chartierc7853442015-03-27 14:35:38 -07001242}
1243
1244void ImageWriter::CopyAndFixupObject(Object* obj) {
Mathieu Chartierc7853442015-03-27 14:35:38 -07001245 size_t offset = GetImageOffset(obj);
1246 auto* dst = reinterpret_cast<Object*>(image_->Begin() + offset);
Mathieu Chartierd39645e2015-06-09 17:50:29 -07001247 DCHECK_LT(offset, image_end_);
1248 const auto* src = reinterpret_cast<const uint8_t*>(obj);
Mathieu Chartierc7853442015-03-27 14:35:38 -07001249
Mathieu Chartierd39645e2015-06-09 17:50:29 -07001250 image_bitmap_->Set(dst); // Mark the obj as live.
1251
1252 const size_t n = obj->SizeOf();
Mathieu Chartierc7853442015-03-27 14:35:38 -07001253 DCHECK_LE(offset + n, image_->Size());
Brian Carlstrom7940e442013-07-12 13:46:57 -07001254 memcpy(dst, src, n);
Mathieu Chartierc7853442015-03-27 14:35:38 -07001255
Mathieu Chartierad2541a2013-10-25 10:05:23 -07001256 // Write in a hash code of objects which have inflated monitors or a hash code in their monitor
1257 // word.
Mathieu Chartierd39645e2015-06-09 17:50:29 -07001258 const auto it = saved_hashcode_map_.find(obj);
1259 dst->SetLockWord(it != saved_hashcode_map_.end() ?
1260 LockWord::FromHashCode(it->second, 0u) : LockWord::Default(), false);
Mathieu Chartierc7853442015-03-27 14:35:38 -07001261 FixupObject(obj, dst);
Brian Carlstrom7940e442013-07-12 13:46:57 -07001262}
1263
Igor Murashkinf5b4c502014-11-14 15:01:59 -08001264// Rewrite all the references in the copied object to point to their image address equivalent
Mathieu Chartierb7ea3ac2014-03-24 16:54:46 -07001265class FixupVisitor {
1266 public:
1267 FixupVisitor(ImageWriter* image_writer, Object* copy) : image_writer_(image_writer), copy_(copy) {
1268 }
1269
Mathieu Chartierda7c6502015-07-23 16:01:26 -07001270 // Ignore class roots since we don't have a way to map them to the destination. These are handled
1271 // with other logic.
1272 void VisitRootIfNonNull(mirror::CompressedReference<mirror::Object>* root ATTRIBUTE_UNUSED)
1273 const {}
1274 void VisitRoot(mirror::CompressedReference<mirror::Object>* root ATTRIBUTE_UNUSED) const {}
1275
1276
Mathieu Chartierd39645e2015-06-09 17:50:29 -07001277 void operator()(Object* obj, MemberOffset offset, bool is_static ATTRIBUTE_UNUSED) const
Mathieu Chartier90443472015-07-16 20:32:27 -07001278 REQUIRES(Locks::mutator_lock_, Locks::heap_bitmap_lock_) {
Hiroshi Yamauchi6e83c172014-05-01 21:25:41 -07001279 Object* ref = obj->GetFieldObject<Object, kVerifyNone>(offset);
Mathieu Chartierb7ea3ac2014-03-24 16:54:46 -07001280 // Use SetFieldObjectWithoutWriteBarrier to avoid card marking since we are writing to the
1281 // image.
1282 copy_->SetFieldObjectWithoutWriteBarrier<false, true, kVerifyNone>(
Ian Rogersb0fa5dc2014-04-28 16:47:08 -07001283 offset, image_writer_->GetImageAddress(ref));
Mathieu Chartierb7ea3ac2014-03-24 16:54:46 -07001284 }
1285
1286 // java.lang.ref.Reference visitor.
Mathieu Chartierd39645e2015-06-09 17:50:29 -07001287 void operator()(mirror::Class* klass ATTRIBUTE_UNUSED, mirror::Reference* ref) const
Mathieu Chartierda7c6502015-07-23 16:01:26 -07001288 SHARED_REQUIRES(Locks::mutator_lock_) REQUIRES(Locks::heap_bitmap_lock_) {
Mathieu Chartierb7ea3ac2014-03-24 16:54:46 -07001289 copy_->SetFieldObjectWithoutWriteBarrier<false, true, kVerifyNone>(
Ian Rogersb0fa5dc2014-04-28 16:47:08 -07001290 mirror::Reference::ReferentOffset(), image_writer_->GetImageAddress(ref->GetReferent()));
Mathieu Chartierb7ea3ac2014-03-24 16:54:46 -07001291 }
1292
Mingyao Yang98d1cc82014-05-15 17:02:16 -07001293 protected:
Mathieu Chartierb7ea3ac2014-03-24 16:54:46 -07001294 ImageWriter* const image_writer_;
1295 mirror::Object* const copy_;
1296};
1297
Mingyao Yang98d1cc82014-05-15 17:02:16 -07001298class FixupClassVisitor FINAL : public FixupVisitor {
1299 public:
1300 FixupClassVisitor(ImageWriter* image_writer, Object* copy) : FixupVisitor(image_writer, copy) {
1301 }
1302
Mathieu Chartierc7853442015-03-27 14:35:38 -07001303 void operator()(Object* obj, MemberOffset offset, bool is_static ATTRIBUTE_UNUSED) const
Mathieu Chartier90443472015-07-16 20:32:27 -07001304 REQUIRES(Locks::mutator_lock_, Locks::heap_bitmap_lock_) {
Mingyao Yang98d1cc82014-05-15 17:02:16 -07001305 DCHECK(obj->IsClass());
Igor Murashkinf5b4c502014-11-14 15:01:59 -08001306 FixupVisitor::operator()(obj, offset, /*is_static*/false);
Mingyao Yang98d1cc82014-05-15 17:02:16 -07001307 }
1308
Ian Rogers6a3c1fc2014-10-31 00:33:20 -07001309 void operator()(mirror::Class* klass ATTRIBUTE_UNUSED,
1310 mirror::Reference* ref ATTRIBUTE_UNUSED) const
Mathieu Chartierda7c6502015-07-23 16:01:26 -07001311 SHARED_REQUIRES(Locks::mutator_lock_) REQUIRES(Locks::heap_bitmap_lock_) {
Mingyao Yang98d1cc82014-05-15 17:02:16 -07001312 LOG(FATAL) << "Reference not expected here.";
1313 }
1314};
1315
Mathieu Chartier54d220e2015-07-30 16:20:06 -07001316void* ImageWriter::NativeLocationInImage(void* obj) {
1317 if (obj == nullptr) {
1318 return nullptr;
1319 }
1320 auto it = native_object_relocations_.find(obj);
Mathieu Chartier54d220e2015-07-30 16:20:06 -07001321 CHECK(it != native_object_relocations_.end()) << obj;
Mathieu Chartierc0fe56a2015-08-11 13:01:23 -07001322 const NativeObjectRelocation& relocation = it->second;
Mathieu Chartier54d220e2015-07-30 16:20:06 -07001323 return reinterpret_cast<void*>(image_begin_ + relocation.offset);
1324}
1325
Mathieu Chartierc7853442015-03-27 14:35:38 -07001326void ImageWriter::FixupClass(mirror::Class* orig, mirror::Class* copy) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07001327 // Update the field arrays.
Mathieu Chartier54d220e2015-07-30 16:20:06 -07001328 copy->SetSFieldsPtrUnchecked(reinterpret_cast<LengthPrefixedArray<ArtField>*>(
1329 NativeLocationInImage(orig->GetSFieldsPtr())));
1330 copy->SetIFieldsPtrUnchecked(reinterpret_cast<LengthPrefixedArray<ArtField>*>(
1331 NativeLocationInImage(orig->GetIFieldsPtr())));
1332 // Update direct and virtual method arrays.
1333 copy->SetDirectMethodsPtrUnchecked(reinterpret_cast<LengthPrefixedArray<ArtMethod>*>(
1334 NativeLocationInImage(orig->GetDirectMethodsPtr())));
1335 copy->SetVirtualMethodsPtr(reinterpret_cast<LengthPrefixedArray<ArtMethod>*>(
1336 NativeLocationInImage(orig->GetVirtualMethodsPtr())));
Mathieu Chartiere401d142015-04-22 13:56:20 -07001337 // Fix up embedded tables.
1338 if (orig->ShouldHaveEmbeddedImtAndVTable()) {
1339 for (int32_t i = 0; i < orig->GetEmbeddedVTableLength(); ++i) {
Mathieu Chartier54d220e2015-07-30 16:20:06 -07001340 auto it = native_object_relocations_.find(orig->GetEmbeddedVTableEntry(i, target_ptr_size_));
1341 CHECK(it != native_object_relocations_.end()) << PrettyClass(orig);
Mathieu Chartiere401d142015-04-22 13:56:20 -07001342 copy->SetEmbeddedVTableEntryUnchecked(
1343 i, reinterpret_cast<ArtMethod*>(image_begin_ + it->second.offset), target_ptr_size_);
1344 }
1345 for (size_t i = 0; i < mirror::Class::kImtSize; ++i) {
Mathieu Chartier54d220e2015-07-30 16:20:06 -07001346 auto it = native_object_relocations_.find(orig->GetEmbeddedImTableEntry(i, target_ptr_size_));
1347 CHECK(it != native_object_relocations_.end()) << PrettyClass(orig);
Mathieu Chartiere401d142015-04-22 13:56:20 -07001348 copy->SetEmbeddedImTableEntry(
1349 i, reinterpret_cast<ArtMethod*>(image_begin_ + it->second.offset), target_ptr_size_);
Mathieu Chartierc7853442015-03-27 14:35:38 -07001350 }
1351 }
1352 FixupClassVisitor visitor(this, copy);
Mathieu Chartier059ef3d2015-08-18 13:54:21 -07001353 static_cast<mirror::Object*>(orig)->VisitReferences(visitor, visitor);
Mathieu Chartierc7853442015-03-27 14:35:38 -07001354}
1355
Ian Rogersef7d42f2014-01-06 12:55:46 -08001356void ImageWriter::FixupObject(Object* orig, Object* copy) {
Mathieu Chartierb7ea3ac2014-03-24 16:54:46 -07001357 DCHECK(orig != nullptr);
1358 DCHECK(copy != nullptr);
Hiroshi Yamauchi624468c2014-03-31 15:14:47 -07001359 if (kUseBakerOrBrooksReadBarrier) {
1360 orig->AssertReadBarrierPointer();
1361 if (kUseBrooksReadBarrier) {
1362 // Note the address 'copy' isn't the same as the image address of 'orig'.
1363 copy->SetReadBarrierPointer(GetImageAddress(orig));
1364 DCHECK_EQ(copy->GetReadBarrierPointer(), GetImageAddress(orig));
1365 }
Hiroshi Yamauchi9d04a202014-01-31 13:35:49 -08001366 }
Mathieu Chartiere401d142015-04-22 13:56:20 -07001367 auto* klass = orig->GetClass();
1368 if (klass->IsIntArrayClass() || klass->IsLongArrayClass()) {
1369 // Is this a native dex cache array?
1370 auto it = pointer_arrays_.find(down_cast<mirror::PointerArray*>(orig));
1371 if (it != pointer_arrays_.end()) {
1372 // Should only need to fixup every pointer array exactly once.
1373 FixupPointerArray(copy, down_cast<mirror::PointerArray*>(orig), klass, it->second);
1374 pointer_arrays_.erase(it);
1375 return;
1376 }
1377 CHECK(dex_cache_array_indexes_.find(orig) == dex_cache_array_indexes_.end())
1378 << "Should have been pointer array.";
1379 }
Mathieu Chartierc7853442015-03-27 14:35:38 -07001380 if (orig->IsClass()) {
1381 FixupClass(orig->AsClass<kVerifyNone>(), down_cast<mirror::Class*>(copy));
Mingyao Yang98d1cc82014-05-15 17:02:16 -07001382 } else {
Mathieu Chartiere401d142015-04-22 13:56:20 -07001383 if (klass == mirror::Method::StaticClass() || klass == mirror::Constructor::StaticClass()) {
1384 // Need to go update the ArtMethod.
1385 auto* dest = down_cast<mirror::AbstractMethod*>(copy);
1386 auto* src = down_cast<mirror::AbstractMethod*>(orig);
1387 ArtMethod* src_method = src->GetArtMethod();
Mathieu Chartier54d220e2015-07-30 16:20:06 -07001388 auto it = native_object_relocations_.find(src_method);
1389 CHECK(it != native_object_relocations_.end())
1390 << "Missing relocation for AbstractMethod.artMethod " << PrettyMethod(src_method);
Mathieu Chartiere401d142015-04-22 13:56:20 -07001391 dest->SetArtMethod(
1392 reinterpret_cast<ArtMethod*>(image_begin_ + it->second.offset));
Mathieu Chartier6b069532015-08-05 15:08:12 -07001393 } else if (!klass->IsArrayClass() && klass->IsSubClass(down_cast<mirror::Class*>(
1394 Thread::Current()->DecodeJObject(WellKnownClasses::java_lang_ClassLoader)))) {
1395 // If src is a ClassLoader, set the class table to null so that it gets recreated by the
1396 // ClassLoader.
1397 down_cast<mirror::ClassLoader*>(copy)->SetClassTable(nullptr);
Mathieu Chartiere401d142015-04-22 13:56:20 -07001398 }
Mingyao Yang98d1cc82014-05-15 17:02:16 -07001399 FixupVisitor visitor(this, copy);
Mathieu Chartier059ef3d2015-08-18 13:54:21 -07001400 orig->VisitReferences(visitor, visitor);
Mingyao Yang98d1cc82014-05-15 17:02:16 -07001401 }
Brian Carlstrom7940e442013-07-12 13:46:57 -07001402}
1403
Mathieu Chartiere401d142015-04-22 13:56:20 -07001404const uint8_t* ImageWriter::GetQuickCode(ArtMethod* method, bool* quick_is_interpreted) {
Mingyao Yang98d1cc82014-05-15 17:02:16 -07001405 DCHECK(!method->IsResolutionMethod() && !method->IsImtConflictMethod() &&
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07001406 !method->IsImtUnimplementedMethod() && !method->IsAbstract()) << PrettyMethod(method);
Mingyao Yang98d1cc82014-05-15 17:02:16 -07001407
1408 // Use original code if it exists. Otherwise, set the code pointer to the resolution
1409 // trampoline.
1410
1411 // Quick entrypoint:
Jeff Haoc7d11882015-02-03 15:08:39 -08001412 uint32_t quick_oat_code_offset = PointerToLowMemUInt32(
1413 method->GetEntryPointFromQuickCompiledCodePtrSize(target_ptr_size_));
1414 const uint8_t* quick_code = GetOatAddress(quick_oat_code_offset);
Mingyao Yang98d1cc82014-05-15 17:02:16 -07001415 *quick_is_interpreted = false;
Mathieu Chartiere401d142015-04-22 13:56:20 -07001416 if (quick_code != nullptr && (!method->IsStatic() || method->IsConstructor() ||
1417 method->GetDeclaringClass()->IsInitialized())) {
Mingyao Yang98d1cc82014-05-15 17:02:16 -07001418 // We have code for a non-static or initialized method, just use the code.
Mathieu Chartiere401d142015-04-22 13:56:20 -07001419 DCHECK_GE(quick_code, oat_data_begin_);
Mingyao Yang98d1cc82014-05-15 17:02:16 -07001420 } else if (quick_code == nullptr && method->IsNative() &&
1421 (!method->IsStatic() || method->GetDeclaringClass()->IsInitialized())) {
1422 // Non-static or initialized native method missing compiled code, use generic JNI version.
1423 quick_code = GetOatAddress(quick_generic_jni_trampoline_offset_);
Mathieu Chartiere401d142015-04-22 13:56:20 -07001424 DCHECK_GE(quick_code, oat_data_begin_);
Mingyao Yang98d1cc82014-05-15 17:02:16 -07001425 } else if (quick_code == nullptr && !method->IsNative()) {
1426 // We don't have code at all for a non-native method, use the interpreter.
1427 quick_code = GetOatAddress(quick_to_interpreter_bridge_offset_);
1428 *quick_is_interpreted = true;
Mathieu Chartiere401d142015-04-22 13:56:20 -07001429 DCHECK_GE(quick_code, oat_data_begin_);
Mingyao Yang98d1cc82014-05-15 17:02:16 -07001430 } else {
1431 CHECK(!method->GetDeclaringClass()->IsInitialized());
1432 // We have code for a static method, but need to go through the resolution stub for class
1433 // initialization.
1434 quick_code = GetOatAddress(quick_resolution_trampoline_offset_);
Mathieu Chartiere401d142015-04-22 13:56:20 -07001435 DCHECK_GE(quick_code, oat_data_begin_);
Mingyao Yang98d1cc82014-05-15 17:02:16 -07001436 }
1437 return quick_code;
1438}
1439
Mathieu Chartiere401d142015-04-22 13:56:20 -07001440const uint8_t* ImageWriter::GetQuickEntryPoint(ArtMethod* method) {
Mingyao Yang98d1cc82014-05-15 17:02:16 -07001441 // Calculate the quick entry point following the same logic as FixupMethod() below.
1442 // The resolution method has a special trampoline to call.
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07001443 Runtime* runtime = Runtime::Current();
1444 if (UNLIKELY(method == runtime->GetResolutionMethod())) {
Mingyao Yang98d1cc82014-05-15 17:02:16 -07001445 return GetOatAddress(quick_resolution_trampoline_offset_);
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07001446 } else if (UNLIKELY(method == runtime->GetImtConflictMethod() ||
1447 method == runtime->GetImtUnimplementedMethod())) {
Mingyao Yang98d1cc82014-05-15 17:02:16 -07001448 return GetOatAddress(quick_imt_conflict_trampoline_offset_);
1449 } else {
1450 // We assume all methods have code. If they don't currently then we set them to the use the
1451 // resolution trampoline. Abstract methods never have code and so we need to make sure their
1452 // use results in an AbstractMethodError. We use the interpreter to achieve this.
1453 if (UNLIKELY(method->IsAbstract())) {
1454 return GetOatAddress(quick_to_interpreter_bridge_offset_);
1455 } else {
1456 bool quick_is_interpreted;
1457 return GetQuickCode(method, &quick_is_interpreted);
1458 }
1459 }
1460}
1461
Mathieu Chartiere401d142015-04-22 13:56:20 -07001462void ImageWriter::CopyAndFixupMethod(ArtMethod* orig, ArtMethod* copy) {
Vladimir Marko14632852015-08-17 12:07:23 +01001463 memcpy(copy, orig, ArtMethod::Size(target_ptr_size_));
Mathieu Chartiere401d142015-04-22 13:56:20 -07001464
1465 copy->SetDeclaringClass(GetImageAddress(orig->GetDeclaringClassUnchecked()));
1466 copy->SetDexCacheResolvedMethods(GetImageAddress(orig->GetDexCacheResolvedMethods()));
1467 copy->SetDexCacheResolvedTypes(GetImageAddress(orig->GetDexCacheResolvedTypes()));
1468
Ian Rogers848871b2013-08-05 10:56:33 -07001469 // OatWriter replaces the code_ with an offset value. Here we re-adjust to a pointer relative to
1470 // oat_begin_
Brian Carlstrom7940e442013-07-12 13:46:57 -07001471
Ian Rogers848871b2013-08-05 10:56:33 -07001472 // The resolution method has a special trampoline to call.
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07001473 Runtime* runtime = Runtime::Current();
1474 if (UNLIKELY(orig == runtime->GetResolutionMethod())) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07001475 copy->SetEntryPointFromQuickCompiledCodePtrSize(
Mathieu Chartier2d721012014-11-10 11:08:06 -08001476 GetOatAddress(quick_resolution_trampoline_offset_), target_ptr_size_);
Mathieu Chartier2d2621a2014-10-23 16:48:06 -07001477 } else if (UNLIKELY(orig == runtime->GetImtConflictMethod() ||
1478 orig == runtime->GetImtUnimplementedMethod())) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07001479 copy->SetEntryPointFromQuickCompiledCodePtrSize(
Mathieu Chartier2d721012014-11-10 11:08:06 -08001480 GetOatAddress(quick_imt_conflict_trampoline_offset_), target_ptr_size_);
Mathieu Chartiere401d142015-04-22 13:56:20 -07001481 } else if (UNLIKELY(orig->IsRuntimeMethod())) {
1482 bool found_one = false;
1483 for (size_t i = 0; i < static_cast<size_t>(Runtime::kLastCalleeSaveType); ++i) {
1484 auto idx = static_cast<Runtime::CalleeSaveType>(i);
1485 if (runtime->HasCalleeSaveMethod(idx) && runtime->GetCalleeSaveMethod(idx) == orig) {
1486 found_one = true;
1487 break;
1488 }
1489 }
1490 CHECK(found_one) << "Expected to find callee save method but got " << PrettyMethod(orig);
1491 CHECK(copy->IsRuntimeMethod());
Brian Carlstrom7940e442013-07-12 13:46:57 -07001492 } else {
Ian Rogers848871b2013-08-05 10:56:33 -07001493 // We assume all methods have code. If they don't currently then we set them to the use the
1494 // resolution trampoline. Abstract methods never have code and so we need to make sure their
1495 // use results in an AbstractMethodError. We use the interpreter to achieve this.
1496 if (UNLIKELY(orig->IsAbstract())) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07001497 copy->SetEntryPointFromQuickCompiledCodePtrSize(
Mathieu Chartier2d721012014-11-10 11:08:06 -08001498 GetOatAddress(quick_to_interpreter_bridge_offset_), target_ptr_size_);
Ian Rogers848871b2013-08-05 10:56:33 -07001499 } else {
Mingyao Yang98d1cc82014-05-15 17:02:16 -07001500 bool quick_is_interpreted;
Ian Rogers13735952014-10-08 12:43:28 -07001501 const uint8_t* quick_code = GetQuickCode(orig, &quick_is_interpreted);
Mathieu Chartiere401d142015-04-22 13:56:20 -07001502 copy->SetEntryPointFromQuickCompiledCodePtrSize(quick_code, target_ptr_size_);
Sebastien Hertze1d07812014-05-21 15:44:09 +02001503
Sebastien Hertze1d07812014-05-21 15:44:09 +02001504 // JNI entrypoint:
Ian Rogers848871b2013-08-05 10:56:33 -07001505 if (orig->IsNative()) {
1506 // The native method's pointer is set to a stub to lookup via dlsym.
1507 // Note this is not the code_ pointer, that is handled above.
Mathieu Chartiere401d142015-04-22 13:56:20 -07001508 copy->SetEntryPointFromJniPtrSize(
1509 GetOatAddress(jni_dlsym_lookup_offset_), target_ptr_size_);
Ian Rogers848871b2013-08-05 10:56:33 -07001510 }
1511 }
Brian Carlstrom7940e442013-07-12 13:46:57 -07001512 }
1513}
1514
Alex Lighta59dd802014-07-02 16:28:08 -07001515static OatHeader* GetOatHeaderFromElf(ElfFile* elf) {
Tong Shen62d1ca32014-09-03 17:24:56 -07001516 uint64_t data_sec_offset;
1517 bool has_data_sec = elf->GetSectionOffsetAndSize(".rodata", &data_sec_offset, nullptr);
1518 if (!has_data_sec) {
Alex Lighta59dd802014-07-02 16:28:08 -07001519 return nullptr;
1520 }
Tong Shen62d1ca32014-09-03 17:24:56 -07001521 return reinterpret_cast<OatHeader*>(elf->Begin() + data_sec_offset);
Hiroshi Yamauchibe1ca552014-01-15 11:46:48 -08001522}
1523
Vladimir Markof4da6752014-08-01 19:04:18 +01001524void ImageWriter::SetOatChecksumFromElfFile(File* elf_file) {
Alex Lighta59dd802014-07-02 16:28:08 -07001525 std::string error_msg;
1526 std::unique_ptr<ElfFile> elf(ElfFile::Open(elf_file, PROT_READ|PROT_WRITE,
1527 MAP_SHARED, &error_msg));
1528 if (elf.get() == nullptr) {
Vladimir Markof4da6752014-08-01 19:04:18 +01001529 LOG(FATAL) << "Unable open oat file: " << error_msg;
Alex Lighta59dd802014-07-02 16:28:08 -07001530 return;
Brian Carlstrom7940e442013-07-12 13:46:57 -07001531 }
Alex Lighta59dd802014-07-02 16:28:08 -07001532 OatHeader* oat_header = GetOatHeaderFromElf(elf.get());
1533 CHECK(oat_header != nullptr);
1534 CHECK(oat_header->IsValid());
Brian Carlstrom7940e442013-07-12 13:46:57 -07001535
Brian Carlstrom7940e442013-07-12 13:46:57 -07001536 ImageHeader* image_header = reinterpret_cast<ImageHeader*>(image_->Begin());
Alex Lighta59dd802014-07-02 16:28:08 -07001537 image_header->SetOatChecksum(oat_header->GetChecksum());
Brian Carlstrom7940e442013-07-12 13:46:57 -07001538}
1539
Igor Murashkinf5b4c502014-11-14 15:01:59 -08001540size_t ImageWriter::GetBinSizeSum(ImageWriter::Bin up_to) const {
1541 DCHECK_LE(up_to, kBinSize);
1542 return std::accumulate(&bin_slot_sizes_[0], &bin_slot_sizes_[up_to], /*init*/0);
1543}
1544
1545ImageWriter::BinSlot::BinSlot(uint32_t lockword) : lockword_(lockword) {
1546 // These values may need to get updated if more bins are added to the enum Bin
Mathieu Chartiere401d142015-04-22 13:56:20 -07001547 static_assert(kBinBits == 3, "wrong number of bin bits");
1548 static_assert(kBinShift == 27, "wrong number of shift");
Igor Murashkinf5b4c502014-11-14 15:01:59 -08001549 static_assert(sizeof(BinSlot) == sizeof(LockWord), "BinSlot/LockWord must have equal sizes");
1550
1551 DCHECK_LT(GetBin(), kBinSize);
1552 DCHECK_ALIGNED(GetIndex(), kObjectAlignment);
1553}
1554
1555ImageWriter::BinSlot::BinSlot(Bin bin, uint32_t index)
1556 : BinSlot(index | (static_cast<uint32_t>(bin) << kBinShift)) {
1557 DCHECK_EQ(index, GetIndex());
1558}
1559
1560ImageWriter::Bin ImageWriter::BinSlot::GetBin() const {
1561 return static_cast<Bin>((lockword_ & kBinMask) >> kBinShift);
1562}
1563
1564uint32_t ImageWriter::BinSlot::GetIndex() const {
1565 return lockword_ & ~kBinMask;
1566}
1567
Mathieu Chartierd39645e2015-06-09 17:50:29 -07001568uint8_t* ImageWriter::GetOatFileBegin() const {
1569 DCHECK_GT(intern_table_bytes_, 0u);
1570 return image_begin_ + RoundUp(
1571 image_end_ + bin_slot_sizes_[kBinArtField] + bin_slot_sizes_[kBinArtMethodDirty] +
1572 bin_slot_sizes_[kBinArtMethodClean] + intern_table_bytes_, kPageSize);
1573}
1574
Mathieu Chartier54d220e2015-07-30 16:20:06 -07001575ImageWriter::Bin ImageWriter::BinTypeForNativeRelocationType(NativeObjectRelocationType type) {
1576 switch (type) {
1577 case kNativeObjectRelocationTypeArtField:
1578 case kNativeObjectRelocationTypeArtFieldArray:
1579 return kBinArtField;
1580 case kNativeObjectRelocationTypeArtMethodClean:
1581 case kNativeObjectRelocationTypeArtMethodArrayClean:
1582 return kBinArtMethodClean;
1583 case kNativeObjectRelocationTypeArtMethodDirty:
1584 case kNativeObjectRelocationTypeArtMethodArrayDirty:
1585 return kBinArtMethodDirty;
1586 }
1587 UNREACHABLE();
1588}
1589
Brian Carlstrom7940e442013-07-12 13:46:57 -07001590} // namespace art