Brian Carlstrom | db4d540 | 2011-08-09 12:18:28 -0700 | [diff] [blame] | 1 | // Copyright 2011 Google Inc. All Rights Reserved. |
| 2 | |
| 3 | #include "image_writer.h" |
| 4 | |
| 5 | #include <sys/mman.h> |
Elliott Hughes | 90a3369 | 2011-08-30 13:27:07 -0700 | [diff] [blame] | 6 | |
Brian Carlstrom | db4d540 | 2011-08-09 12:18:28 -0700 | [diff] [blame] | 7 | #include <vector> |
| 8 | |
Elliott Hughes | 90a3369 | 2011-08-30 13:27:07 -0700 | [diff] [blame] | 9 | #include "UniquePtr.h" |
Brian Carlstrom | a663ea5 | 2011-08-19 23:33:41 -0700 | [diff] [blame] | 10 | #include "class_linker.h" |
Brian Carlstrom | 1f87008 | 2011-08-23 16:02:11 -0700 | [diff] [blame^] | 11 | #include "class_loader.h" |
Elliott Hughes | 90a3369 | 2011-08-30 13:27:07 -0700 | [diff] [blame] | 12 | #include "dex_cache.h" |
Brian Carlstrom | db4d540 | 2011-08-09 12:18:28 -0700 | [diff] [blame] | 13 | #include "file.h" |
| 14 | #include "globals.h" |
| 15 | #include "heap.h" |
Brian Carlstrom | 4a289ed | 2011-08-16 17:17:49 -0700 | [diff] [blame] | 16 | #include "image.h" |
Brian Carlstrom | a663ea5 | 2011-08-19 23:33:41 -0700 | [diff] [blame] | 17 | #include "intern_table.h" |
Brian Carlstrom | db4d540 | 2011-08-09 12:18:28 -0700 | [diff] [blame] | 18 | #include "logging.h" |
| 19 | #include "object.h" |
Brian Carlstrom | 1f87008 | 2011-08-23 16:02:11 -0700 | [diff] [blame^] | 20 | #include "runtime.h" |
Brian Carlstrom | db4d540 | 2011-08-09 12:18:28 -0700 | [diff] [blame] | 21 | #include "space.h" |
| 22 | #include "utils.h" |
| 23 | |
| 24 | namespace art { |
| 25 | |
| 26 | bool ImageWriter::Write(Space* space, const char* filename, byte* image_base) { |
| 27 | image_base_ = image_base; |
| 28 | if (!Init(space)) { |
| 29 | return false; |
| 30 | } |
| 31 | CalculateNewObjectOffsets(); |
| 32 | CopyAndFixupObjects(); |
Elliott Hughes | d8ddfd5 | 2011-08-15 14:32:53 -0700 | [diff] [blame] | 33 | |
Elliott Hughes | 90a3369 | 2011-08-30 13:27:07 -0700 | [diff] [blame] | 34 | UniquePtr<File> file(OS::OpenFile(filename, true)); |
| 35 | if (file.get() == NULL) { |
Brian Carlstrom | db4d540 | 2011-08-09 12:18:28 -0700 | [diff] [blame] | 36 | return false; |
| 37 | } |
Brian Carlstrom | 4e777d4 | 2011-08-15 13:53:52 -0700 | [diff] [blame] | 38 | return file->WriteFully(image_->GetAddress(), image_top_); |
Brian Carlstrom | db4d540 | 2011-08-09 12:18:28 -0700 | [diff] [blame] | 39 | } |
| 40 | |
| 41 | bool ImageWriter::Init(Space* space) { |
| 42 | size_t size = space->Size(); |
| 43 | int prot = PROT_READ | PROT_WRITE; |
Brian Carlstrom | db4d540 | 2011-08-09 12:18:28 -0700 | [diff] [blame] | 44 | size_t length = RoundUp(size, kPageSize); |
Brian Carlstrom | 4a289ed | 2011-08-16 17:17:49 -0700 | [diff] [blame] | 45 | image_.reset(MemMap::Map(length, prot)); |
Elliott Hughes | 90a3369 | 2011-08-30 13:27:07 -0700 | [diff] [blame] | 46 | if (image_.get() == NULL) { |
Brian Carlstrom | db4d540 | 2011-08-09 12:18:28 -0700 | [diff] [blame] | 47 | return false; |
| 48 | } |
| 49 | return true; |
| 50 | } |
| 51 | |
Brian Carlstrom | a663ea5 | 2011-08-19 23:33:41 -0700 | [diff] [blame] | 52 | namespace { |
| 53 | |
| 54 | struct InternTableVisitorState { |
| 55 | int index; |
| 56 | ObjectArray<Object>* interned_array; |
| 57 | }; |
| 58 | |
| 59 | void InternTableVisitor(Object* obj, void* arg) { |
| 60 | InternTableVisitorState* state = reinterpret_cast<InternTableVisitorState*>(arg); |
| 61 | state->interned_array->Set(state->index++, obj); |
| 62 | } |
| 63 | |
| 64 | ObjectArray<Object>* CreateInternedArray() { |
| 65 | // build a Object[] of the interned strings for reinit |
| 66 | // TODO: avoid creating this future garbage |
| 67 | ClassLinker* class_linker = Runtime::Current()->GetClassLinker(); |
| 68 | const InternTable& intern_table = class_linker->GetInternTable(); |
| 69 | size_t size = intern_table.Size(); |
| 70 | CHECK_NE(0U, size); |
| 71 | |
| 72 | Class* object_array_class = class_linker->FindSystemClass("[Ljava/lang/Object;"); |
| 73 | ObjectArray<Object>* interned_array = ObjectArray<Object>::Alloc(object_array_class, size); |
| 74 | |
| 75 | InternTableVisitorState state; |
| 76 | state.index = 0; |
| 77 | state.interned_array = interned_array; |
| 78 | |
| 79 | intern_table.VisitRoots(InternTableVisitor, &state); |
| 80 | |
| 81 | return interned_array; |
| 82 | } |
| 83 | |
| 84 | } // namespace |
| 85 | |
Brian Carlstrom | 4873d46 | 2011-08-21 15:23:39 -0700 | [diff] [blame] | 86 | void ImageWriter::CalculateNewObjectOffsetsCallback(Object* obj, void *arg) { |
Brian Carlstrom | db4d540 | 2011-08-09 12:18:28 -0700 | [diff] [blame] | 87 | DCHECK(obj != NULL); |
| 88 | DCHECK(arg != NULL); |
| 89 | ImageWriter* image_writer = reinterpret_cast<ImageWriter*>(arg); |
Brian Carlstrom | 4e777d4 | 2011-08-15 13:53:52 -0700 | [diff] [blame] | 90 | image_writer->SetImageOffset(obj, image_writer->image_top_); |
Elliott Hughes | 04b63fd | 2011-08-16 09:40:10 -0700 | [diff] [blame] | 91 | image_writer->image_top_ += RoundUp(obj->SizeOf(), 8); // 64-bit alignment |
Brian Carlstrom | 4e777d4 | 2011-08-15 13:53:52 -0700 | [diff] [blame] | 92 | DCHECK_LT(image_writer->image_top_, image_writer->image_->GetLength()); |
| 93 | } |
| 94 | |
| 95 | void ImageWriter::CalculateNewObjectOffsets() { |
Brian Carlstrom | a663ea5 | 2011-08-19 23:33:41 -0700 | [diff] [blame] | 96 | ObjectArray<Object>* interned_array = CreateInternedArray(); |
| 97 | |
Brian Carlstrom | 4e777d4 | 2011-08-15 13:53:52 -0700 | [diff] [blame] | 98 | HeapBitmap* heap_bitmap = Heap::GetLiveBits(); |
| 99 | DCHECK(heap_bitmap != NULL); |
| 100 | DCHECK_EQ(0U, image_top_); |
Brian Carlstrom | a663ea5 | 2011-08-19 23:33:41 -0700 | [diff] [blame] | 101 | |
| 102 | // leave space for the header, but do not write it yet, we need to |
| 103 | // know where interned_array is going to end up |
| 104 | image_top_ += RoundUp(sizeof(ImageHeader), 8); // 64-bit-alignment |
| 105 | |
Brian Carlstrom | 4e777d4 | 2011-08-15 13:53:52 -0700 | [diff] [blame] | 106 | heap_bitmap->Walk(CalculateNewObjectOffsetsCallback, this); |
| 107 | DCHECK_LT(image_top_, image_->GetLength()); |
Brian Carlstrom | a663ea5 | 2011-08-19 23:33:41 -0700 | [diff] [blame] | 108 | |
| 109 | // return to write header at start of image with future location of interned_array |
| 110 | ImageHeader image_header(reinterpret_cast<uint32_t>(image_base_), |
| 111 | reinterpret_cast<uint32_t>(GetImageAddress(interned_array))); |
| 112 | memcpy(image_->GetAddress(), &image_header, sizeof(image_header)); |
| 113 | |
Brian Carlstrom | 4e777d4 | 2011-08-15 13:53:52 -0700 | [diff] [blame] | 114 | // Note that top_ is left at end of used space |
Brian Carlstrom | db4d540 | 2011-08-09 12:18:28 -0700 | [diff] [blame] | 115 | } |
| 116 | |
| 117 | void ImageWriter::CopyAndFixupObjects() { |
| 118 | HeapBitmap* heap_bitmap = Heap::GetLiveBits(); |
| 119 | DCHECK(heap_bitmap != NULL); |
| 120 | heap_bitmap->Walk(CopyAndFixupObjectsCallback, this); |
| 121 | } |
| 122 | |
Brian Carlstrom | 4873d46 | 2011-08-21 15:23:39 -0700 | [diff] [blame] | 123 | void ImageWriter::CopyAndFixupObjectsCallback(Object* object, void *arg) { |
| 124 | DCHECK(object != NULL); |
Brian Carlstrom | db4d540 | 2011-08-09 12:18:28 -0700 | [diff] [blame] | 125 | DCHECK(arg != NULL); |
Brian Carlstrom | 4873d46 | 2011-08-21 15:23:39 -0700 | [diff] [blame] | 126 | const Object* obj = object; |
Brian Carlstrom | db4d540 | 2011-08-09 12:18:28 -0700 | [diff] [blame] | 127 | ImageWriter* image_writer = reinterpret_cast<ImageWriter*>(arg); |
Elliott Hughes | d8ddfd5 | 2011-08-15 14:32:53 -0700 | [diff] [blame] | 128 | |
Brian Carlstrom | db4d540 | 2011-08-09 12:18:28 -0700 | [diff] [blame] | 129 | size_t offset = image_writer->GetImageOffset(obj); |
Brian Carlstrom | 4e777d4 | 2011-08-15 13:53:52 -0700 | [diff] [blame] | 130 | byte* dst = image_writer->image_->GetAddress() + offset; |
Brian Carlstrom | 4873d46 | 2011-08-21 15:23:39 -0700 | [diff] [blame] | 131 | const byte* src = reinterpret_cast<const byte*>(obj); |
Elliott Hughes | 04b63fd | 2011-08-16 09:40:10 -0700 | [diff] [blame] | 132 | size_t n = obj->SizeOf(); |
Brian Carlstrom | 4e777d4 | 2011-08-15 13:53:52 -0700 | [diff] [blame] | 133 | DCHECK_LT(offset + n, image_writer->image_->GetLength()); |
Brian Carlstrom | db4d540 | 2011-08-09 12:18:28 -0700 | [diff] [blame] | 134 | memcpy(dst, src, n); |
| 135 | Object* copy = reinterpret_cast<Object*>(dst); |
| 136 | image_writer->FixupObject(obj, copy); |
| 137 | } |
| 138 | |
Brian Carlstrom | 4873d46 | 2011-08-21 15:23:39 -0700 | [diff] [blame] | 139 | void ImageWriter::FixupObject(const Object* orig, Object* copy) { |
Brian Carlstrom | db4d540 | 2011-08-09 12:18:28 -0700 | [diff] [blame] | 140 | DCHECK(orig != NULL); |
| 141 | DCHECK(copy != NULL); |
| 142 | copy->klass_ = down_cast<Class*>(GetImageAddress(orig->klass_)); |
Brian Carlstrom | 9cff8e1 | 2011-08-18 16:47:29 -0700 | [diff] [blame] | 143 | // TODO: special case init of pointers to malloc data (or removal of these pointers) |
| 144 | if (orig->IsClass()) { |
| 145 | FixupClass(orig->AsClass(), down_cast<Class*>(copy)); |
Brian Carlstrom | a663ea5 | 2011-08-19 23:33:41 -0700 | [diff] [blame] | 146 | } else if (orig->IsMethod()) { |
| 147 | FixupMethod(orig->AsMethod(), down_cast<Method*>(copy)); |
| 148 | } else if (orig->IsField()) { |
| 149 | FixupField(orig->AsField(), down_cast<Field*>(copy)); |
Brian Carlstrom | 9cff8e1 | 2011-08-18 16:47:29 -0700 | [diff] [blame] | 150 | } else if (orig->IsObjectArray()) { |
Brian Carlstrom | db4d540 | 2011-08-09 12:18:28 -0700 | [diff] [blame] | 151 | FixupObjectArray(orig->AsObjectArray<Object>(), down_cast<ObjectArray<Object>*>(copy)); |
| 152 | } else { |
| 153 | FixupInstanceFields(orig, copy); |
| 154 | } |
| 155 | } |
| 156 | |
Brian Carlstrom | 4873d46 | 2011-08-21 15:23:39 -0700 | [diff] [blame] | 157 | void ImageWriter::FixupClass(const Class* orig, Class* copy) { |
Brian Carlstrom | 9cff8e1 | 2011-08-18 16:47:29 -0700 | [diff] [blame] | 158 | FixupInstanceFields(orig, copy); |
| 159 | copy->descriptor_ = down_cast<String*>(GetImageAddress(orig->descriptor_)); |
| 160 | copy->dex_cache_ = down_cast<DexCache*>(GetImageAddress(orig->dex_cache_)); |
| 161 | copy->verify_error_class_ = down_cast<Class*>(GetImageAddress(orig->verify_error_class_)); |
| 162 | copy->component_type_ = down_cast<Class*>(GetImageAddress(orig->component_type_)); |
| 163 | copy->super_class_ = down_cast<Class*>(GetImageAddress(orig->super_class_)); |
| 164 | copy->class_loader_ = down_cast<ClassLoader*>(GetImageAddress(orig->class_loader_)); |
| 165 | copy->interfaces_ = down_cast<ObjectArray<Class>*>(GetImageAddress(orig->interfaces_)); |
| 166 | copy->direct_methods_ = down_cast<ObjectArray<Method>*>(GetImageAddress(orig->direct_methods_)); |
| 167 | copy->virtual_methods_ = down_cast<ObjectArray<Method>*>(GetImageAddress(orig->virtual_methods_)); |
| 168 | copy->vtable_ = down_cast<ObjectArray<Method>*>(GetImageAddress(orig->vtable_)); |
| 169 | // TODO: convert iftable_ to heap allocated storage |
Elliott Hughes | c1674ed | 2011-08-25 18:09:09 -0700 | [diff] [blame] | 170 | // TODO: convert ifvi_pool_ to heap allocated storage |
Brian Carlstrom | 9cff8e1 | 2011-08-18 16:47:29 -0700 | [diff] [blame] | 171 | copy->ifields_ = down_cast<ObjectArray<Field>*>(GetImageAddress(orig->ifields_)); |
Brian Carlstrom | 4873d46 | 2011-08-21 15:23:39 -0700 | [diff] [blame] | 172 | // TODO: convert source_file_ to heap allocated storage |
Brian Carlstrom | 9cff8e1 | 2011-08-18 16:47:29 -0700 | [diff] [blame] | 173 | copy->sfields_ = down_cast<ObjectArray<Field>*>(GetImageAddress(orig->sfields_)); |
Elliott Hughes | c1674ed | 2011-08-25 18:09:09 -0700 | [diff] [blame] | 174 | copy->interfaces_type_idx_ = down_cast<IntArray*>(GetImageAddress(orig->interfaces_type_idx_)); |
Brian Carlstrom | 4873d46 | 2011-08-21 15:23:39 -0700 | [diff] [blame] | 175 | FixupStaticFields(orig, copy); |
Brian Carlstrom | 9cff8e1 | 2011-08-18 16:47:29 -0700 | [diff] [blame] | 176 | } |
| 177 | |
Brian Carlstrom | a663ea5 | 2011-08-19 23:33:41 -0700 | [diff] [blame] | 178 | // TODO: remove this slow path |
Brian Carlstrom | 4873d46 | 2011-08-21 15:23:39 -0700 | [diff] [blame] | 179 | void ImageWriter::FixupMethod(const Method* orig, Method* copy) { |
Brian Carlstrom | a663ea5 | 2011-08-19 23:33:41 -0700 | [diff] [blame] | 180 | FixupInstanceFields(orig, copy); |
| 181 | // TODO: remove need for this by adding "signature" to java.lang.reflect.Method |
| 182 | copy->signature_ = down_cast<String*>(GetImageAddress(orig->signature_)); |
| 183 | DCHECK(copy->signature_ != NULL); |
| 184 | // TODO: convert shorty_ to heap allocated storage |
| 185 | } |
| 186 | |
Brian Carlstrom | 4873d46 | 2011-08-21 15:23:39 -0700 | [diff] [blame] | 187 | void ImageWriter::FixupField(const Field* orig, Field* copy) { |
Brian Carlstrom | a663ea5 | 2011-08-19 23:33:41 -0700 | [diff] [blame] | 188 | FixupInstanceFields(orig, copy); |
| 189 | // TODO: convert descriptor_ to heap allocated storage |
| 190 | } |
| 191 | |
Brian Carlstrom | 4873d46 | 2011-08-21 15:23:39 -0700 | [diff] [blame] | 192 | void ImageWriter::FixupObjectArray(const ObjectArray<Object>* orig, ObjectArray<Object>* copy) { |
Elliott Hughes | d8ddfd5 | 2011-08-15 14:32:53 -0700 | [diff] [blame] | 193 | for (int32_t i = 0; i < orig->GetLength(); ++i) { |
Brian Carlstrom | db4d540 | 2011-08-09 12:18:28 -0700 | [diff] [blame] | 194 | const Object* element = orig->Get(i); |
| 195 | copy->Set(i, GetImageAddress(element)); |
| 196 | } |
| 197 | } |
| 198 | |
Brian Carlstrom | 4873d46 | 2011-08-21 15:23:39 -0700 | [diff] [blame] | 199 | void ImageWriter::FixupInstanceFields(const Object* orig, Object* copy) { |
| 200 | DCHECK(orig != NULL); |
| 201 | DCHECK(copy != NULL); |
| 202 | Class* klass = orig->GetClass(); |
| 203 | DCHECK(klass != NULL); |
| 204 | FixupFields(orig, |
| 205 | copy, |
| 206 | klass->GetReferenceInstanceOffsets(), |
| 207 | false); |
| 208 | } |
| 209 | |
| 210 | void ImageWriter::FixupStaticFields(const Class* orig, Class* copy) { |
| 211 | DCHECK(orig != NULL); |
| 212 | DCHECK(copy != NULL); |
| 213 | FixupFields(orig, |
| 214 | copy, |
| 215 | orig->GetReferenceStaticOffsets(), |
| 216 | true); |
| 217 | } |
| 218 | |
| 219 | void ImageWriter::FixupFields(const Object* orig, |
| 220 | Object* copy, |
| 221 | uint32_t ref_offsets, |
| 222 | bool is_static) { |
Brian Carlstrom | db4d540 | 2011-08-09 12:18:28 -0700 | [diff] [blame] | 223 | if (ref_offsets != CLASS_WALK_SUPER) { |
| 224 | // Found a reference offset bitmap. Fixup the specified offsets. |
| 225 | while (ref_offsets != 0) { |
| 226 | size_t right_shift = CLZ(ref_offsets); |
| 227 | size_t byte_offset = CLASS_OFFSET_FROM_CLZ(right_shift); |
| 228 | const Object* ref = orig->GetFieldObject(byte_offset); |
| 229 | copy->SetFieldObject(byte_offset, GetImageAddress(ref)); |
| 230 | ref_offsets &= ~(CLASS_HIGH_BIT >> right_shift); |
| 231 | } |
| 232 | } else { |
Brian Carlstrom | 4873d46 | 2011-08-21 15:23:39 -0700 | [diff] [blame] | 233 | // There is no reference offset bitmap. In the non-static case, |
| 234 | // walk up the class inheritance hierarchy and find reference |
| 235 | // offsets the hard way. In the static case, just consider this |
| 236 | // class. |
| 237 | for (const Class *klass = is_static ? orig->AsClass() : orig->GetClass(); |
Brian Carlstrom | db4d540 | 2011-08-09 12:18:28 -0700 | [diff] [blame] | 238 | klass != NULL; |
Brian Carlstrom | 4873d46 | 2011-08-21 15:23:39 -0700 | [diff] [blame] | 239 | klass = is_static ? NULL : klass->GetSuperClass()) { |
| 240 | size_t num_reference_fields = (is_static |
| 241 | ? klass->NumReferenceStaticFields() |
| 242 | : klass->NumReferenceInstanceFields()); |
| 243 | for (size_t i = 0; i < num_reference_fields; ++i) { |
| 244 | Field* field = (is_static |
| 245 | ? klass->GetStaticField(i) |
| 246 | : klass->GetInstanceField(i)); |
| 247 | size_t field_offset = field->GetOffset(); |
Brian Carlstrom | db4d540 | 2011-08-09 12:18:28 -0700 | [diff] [blame] | 248 | const Object* ref = orig->GetFieldObject(field_offset); |
| 249 | copy->SetFieldObject(field_offset, GetImageAddress(ref)); |
| 250 | } |
| 251 | } |
| 252 | } |
| 253 | } |
| 254 | |
| 255 | } // namespace art |