image.h revision 7b49e6cade09bc65b3b5f22d45fc9d0a7184e4f2
1/* 2 * Copyright (C) 2011 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17#ifndef ART_RUNTIME_IMAGE_H_ 18#define ART_RUNTIME_IMAGE_H_ 19 20#include <string.h> 21 22#include "base/enums.h" 23#include "globals.h" 24#include "mirror/object.h" 25 26namespace art { 27 28class ArtField; 29class ArtMethod; 30 31class ArtMethodVisitor { 32 public: 33 virtual ~ArtMethodVisitor() {} 34 35 virtual void Visit(ArtMethod* method) = 0; 36}; 37 38class ArtFieldVisitor { 39 public: 40 virtual ~ArtFieldVisitor() {} 41 42 virtual void Visit(ArtField* method) = 0; 43}; 44 45class PACKED(4) ImageSection { 46 public: 47 ImageSection() : offset_(0), size_(0) { } 48 ImageSection(uint32_t offset, uint32_t size) : offset_(offset), size_(size) { } 49 ImageSection(const ImageSection& section) = default; 50 ImageSection& operator=(const ImageSection& section) = default; 51 52 uint32_t Offset() const { 53 return offset_; 54 } 55 56 uint32_t Size() const { 57 return size_; 58 } 59 60 uint32_t End() const { 61 return Offset() + Size(); 62 } 63 64 bool Contains(uint64_t offset) const { 65 return offset - offset_ < size_; 66 } 67 68 private: 69 uint32_t offset_; 70 uint32_t size_; 71}; 72 73// header of image files written by ImageWriter, read and validated by Space. 74class PACKED(4) ImageHeader { 75 public: 76 enum StorageMode : uint32_t { 77 kStorageModeUncompressed, 78 kStorageModeLZ4, 79 kStorageModeLZ4HC, 80 kStorageModeCount, // Number of elements in enum. 81 }; 82 static constexpr StorageMode kDefaultStorageMode = kStorageModeUncompressed; 83 84 ImageHeader() 85 : image_begin_(0U), 86 image_size_(0U), 87 oat_checksum_(0U), 88 oat_file_begin_(0U), 89 oat_data_begin_(0U), 90 oat_data_end_(0U), 91 oat_file_end_(0U), 92 boot_image_begin_(0U), 93 boot_image_size_(0U), 94 boot_oat_begin_(0U), 95 boot_oat_size_(0U), 96 patch_delta_(0), 97 image_roots_(0U), 98 pointer_size_(0U), 99 compile_pic_(0), 100 is_pic_(0), 101 storage_mode_(kDefaultStorageMode), 102 data_size_(0) {} 103 104 ImageHeader(uint32_t image_begin, 105 uint32_t image_size, 106 ImageSection* sections, 107 uint32_t image_roots, 108 uint32_t oat_checksum, 109 uint32_t oat_file_begin, 110 uint32_t oat_data_begin, 111 uint32_t oat_data_end, 112 uint32_t oat_file_end, 113 uint32_t boot_image_begin, 114 uint32_t boot_image_size, 115 uint32_t boot_oat_begin, 116 uint32_t boot_oat_size, 117 uint32_t pointer_size, 118 bool compile_pic, 119 bool is_pic, 120 StorageMode storage_mode, 121 size_t data_size); 122 123 bool IsValid() const; 124 const char* GetMagic() const; 125 126 uint8_t* GetImageBegin() const { 127 return reinterpret_cast<uint8_t*>(image_begin_); 128 } 129 130 size_t GetImageSize() const { 131 return static_cast<uint32_t>(image_size_); 132 } 133 134 uint32_t GetOatChecksum() const { 135 return oat_checksum_; 136 } 137 138 void SetOatChecksum(uint32_t oat_checksum) { 139 oat_checksum_ = oat_checksum; 140 } 141 142 // The location that the oat file was expected to be when the image was created. The actual 143 // oat file may be at a different location for application images. 144 uint8_t* GetOatFileBegin() const { 145 return reinterpret_cast<uint8_t*>(oat_file_begin_); 146 } 147 148 uint8_t* GetOatDataBegin() const { 149 return reinterpret_cast<uint8_t*>(oat_data_begin_); 150 } 151 152 uint8_t* GetOatDataEnd() const { 153 return reinterpret_cast<uint8_t*>(oat_data_end_); 154 } 155 156 uint8_t* GetOatFileEnd() const { 157 return reinterpret_cast<uint8_t*>(oat_file_end_); 158 } 159 160 PointerSize GetPointerSize() const; 161 162 uint32_t GetPointerSizeUnchecked() const { 163 return pointer_size_; 164 } 165 166 off_t GetPatchDelta() const { 167 return patch_delta_; 168 } 169 170 static std::string GetOatLocationFromImageLocation(const std::string& image) { 171 return GetLocationFromImageLocation(image, "oat"); 172 } 173 174 static std::string GetVdexLocationFromImageLocation(const std::string& image) { 175 return GetLocationFromImageLocation(image, "vdex"); 176 } 177 178 enum ImageMethod { 179 kResolutionMethod, 180 kImtConflictMethod, 181 kImtUnimplementedMethod, 182 kSaveAllCalleeSavesMethod, 183 kSaveRefsOnlyMethod, 184 kSaveRefsAndArgsMethod, 185 kSaveEverythingMethod, 186 kImageMethodsCount, // Number of elements in enum. 187 }; 188 189 enum ImageRoot { 190 kDexCaches, 191 kClassRoots, 192 kImageRootsMax, 193 }; 194 195 enum ImageSections { 196 kSectionObjects, 197 kSectionArtFields, 198 kSectionArtMethods, 199 kSectionRuntimeMethods, 200 kSectionImTables, 201 kSectionIMTConflictTables, 202 kSectionDexCacheArrays, 203 kSectionInternedStrings, 204 kSectionClassTable, 205 kSectionImageBitmap, 206 kSectionCount, // Number of elements in enum. 207 }; 208 209 ArtMethod* GetImageMethod(ImageMethod index) const; 210 void SetImageMethod(ImageMethod index, ArtMethod* method); 211 212 const ImageSection& GetImageSection(ImageSections index) const; 213 214 const ImageSection& GetMethodsSection() const { 215 return GetImageSection(kSectionArtMethods); 216 } 217 218 const ImageSection& GetRuntimeMethodsSection() const { 219 return GetImageSection(kSectionRuntimeMethods); 220 } 221 222 const ImageSection& GetFieldsSection() const { 223 return GetImageSection(ImageHeader::kSectionArtFields); 224 } 225 226 template <ReadBarrierOption kReadBarrierOption = kWithReadBarrier> 227 mirror::Object* GetImageRoot(ImageRoot image_root) const 228 REQUIRES_SHARED(Locks::mutator_lock_); 229 230 template <ReadBarrierOption kReadBarrierOption = kWithReadBarrier> 231 mirror::ObjectArray<mirror::Object>* GetImageRoots() const 232 REQUIRES_SHARED(Locks::mutator_lock_); 233 234 void RelocateImage(off_t delta); 235 void RelocateImageMethods(off_t delta); 236 void RelocateImageObjects(off_t delta); 237 238 bool CompilePic() const { 239 return compile_pic_ != 0; 240 } 241 242 bool IsPic() const { 243 return is_pic_ != 0; 244 } 245 246 uint32_t GetBootImageBegin() const { 247 return boot_image_begin_; 248 } 249 250 uint32_t GetBootImageSize() const { 251 return boot_image_size_; 252 } 253 254 uint32_t GetBootOatBegin() const { 255 return boot_oat_begin_; 256 } 257 258 uint32_t GetBootOatSize() const { 259 return boot_oat_size_; 260 } 261 262 StorageMode GetStorageMode() const { 263 return storage_mode_; 264 } 265 266 uint64_t GetDataSize() const { 267 return data_size_; 268 } 269 270 bool IsAppImage() const { 271 // App images currently require a boot image, if the size is non zero then it is an app image 272 // header. 273 return boot_image_size_ != 0u; 274 } 275 276 // Visit ArtMethods in the section starting at base. Includes runtime methods. 277 // TODO: Delete base parameter if it is always equal to GetImageBegin. 278 void VisitPackedArtMethods(ArtMethodVisitor* visitor, 279 uint8_t* base, 280 PointerSize pointer_size) const; 281 282 // Visit ArtMethods in the section starting at base. 283 // TODO: Delete base parameter if it is always equal to GetImageBegin. 284 void VisitPackedArtFields(ArtFieldVisitor* visitor, uint8_t* base) const; 285 286 template <typename Visitor> 287 void VisitPackedImTables(const Visitor& visitor, 288 uint8_t* base, 289 PointerSize pointer_size) const; 290 291 template <typename Visitor> 292 void VisitPackedImtConflictTables(const Visitor& visitor, 293 uint8_t* base, 294 PointerSize pointer_size) const; 295 296 private: 297 static const uint8_t kImageMagic[4]; 298 static const uint8_t kImageVersion[4]; 299 300 static std::string GetLocationFromImageLocation(const std::string& image, 301 const std::string& extension) { 302 std::string filename = image; 303 if (filename.length() <= 3) { 304 filename += "." + extension; 305 } else { 306 filename.replace(filename.length() - 3, 3, extension); 307 } 308 return filename; 309 } 310 311 uint8_t magic_[4]; 312 uint8_t version_[4]; 313 314 // Required base address for mapping the image. 315 uint32_t image_begin_; 316 317 // Image size, not page aligned. 318 uint32_t image_size_; 319 320 // Checksum of the oat file we link to for load time sanity check. 321 uint32_t oat_checksum_; 322 323 // Start address for oat file. Will be before oat_data_begin_ for .so files. 324 uint32_t oat_file_begin_; 325 326 // Required oat address expected by image Method::GetCode() pointers. 327 uint32_t oat_data_begin_; 328 329 // End of oat data address range for this image file. 330 uint32_t oat_data_end_; 331 332 // End of oat file address range. will be after oat_data_end_ for 333 // .so files. Used for positioning a following alloc spaces. 334 uint32_t oat_file_end_; 335 336 // Boot image begin and end (app image headers only). 337 uint32_t boot_image_begin_; 338 uint32_t boot_image_size_; 339 340 // Boot oat begin and end (app image headers only). 341 uint32_t boot_oat_begin_; 342 uint32_t boot_oat_size_; 343 344 // TODO: We should probably insert a boot image checksum for app images. 345 346 // The total delta that this image has been patched. 347 int32_t patch_delta_; 348 349 // Absolute address of an Object[] of objects needed to reinitialize from an image. 350 uint32_t image_roots_; 351 352 // Pointer size, this affects the size of the ArtMethods. 353 uint32_t pointer_size_; 354 355 // Boolean (0 or 1) to denote if the image was compiled with --compile-pic option 356 const uint32_t compile_pic_; 357 358 // Boolean (0 or 1) to denote if the image can be mapped at a random address, this only refers to 359 // the .art file. Currently, app oat files do not depend on their app image. There are no pointers 360 // from the app oat code to the app image. 361 const uint32_t is_pic_; 362 363 // Image section sizes/offsets correspond to the uncompressed form. 364 ImageSection sections_[kSectionCount]; 365 366 // Image methods, may be inside of the boot image for app images. 367 uint64_t image_methods_[kImageMethodsCount]; 368 369 // Storage method for the image, the image may be compressed. 370 StorageMode storage_mode_; 371 372 // Data size for the image data excluding the bitmap and the header. For compressed images, this 373 // is the compressed size in the file. 374 uint32_t data_size_; 375 376 friend class ImageWriter; 377}; 378 379std::ostream& operator<<(std::ostream& os, const ImageHeader::ImageMethod& policy); 380std::ostream& operator<<(std::ostream& os, const ImageHeader::ImageRoot& policy); 381std::ostream& operator<<(std::ostream& os, const ImageHeader::ImageSections& section); 382std::ostream& operator<<(std::ostream& os, const ImageSection& section); 383std::ostream& operator<<(std::ostream& os, const ImageHeader::StorageMode& mode); 384 385} // namespace art 386 387#endif // ART_RUNTIME_IMAGE_H_ 388