Elliott Hughes | 2faa5f1 | 2012-01-30 14:42:07 -0800 | [diff] [blame] | 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 | */ |
Brian Carlstrom | 4a289ed | 2011-08-16 17:17:49 -0700 | [diff] [blame] | 16 | |
Brian Carlstrom | fc0e321 | 2013-07-17 14:40:12 -0700 | [diff] [blame] | 17 | #ifndef ART_RUNTIME_IMAGE_H_ |
| 18 | #define ART_RUNTIME_IMAGE_H_ |
Brian Carlstrom | 4a289ed | 2011-08-16 17:17:49 -0700 | [diff] [blame] | 19 | |
| 20 | #include <string.h> |
| 21 | |
Vladimir Marko | 6cfbdbc | 2017-07-25 13:26:39 +0100 | [diff] [blame] | 22 | #include "base/bit_utils.h" |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 23 | #include "base/enums.h" |
Brian Carlstrom | 4a289ed | 2011-08-16 17:17:49 -0700 | [diff] [blame] | 24 | #include "globals.h" |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 25 | #include "mirror/object.h" |
Brian Carlstrom | 4a289ed | 2011-08-16 17:17:49 -0700 | [diff] [blame] | 26 | |
| 27 | namespace art { |
| 28 | |
Mathieu Chartier | 54d220e | 2015-07-30 16:20:06 -0700 | [diff] [blame] | 29 | class ArtField; |
| 30 | class ArtMethod; |
| 31 | |
Vladimir Marko | 7452797 | 2016-11-29 15:57:32 +0000 | [diff] [blame] | 32 | namespace linker { |
| 33 | class ImageWriter; |
| 34 | } // namespace linker |
| 35 | |
David Sehr | a49e053 | 2017-08-25 08:05:29 -0700 | [diff] [blame] | 36 | class ObjectVisitor { |
| 37 | public: |
| 38 | virtual ~ObjectVisitor() {} |
| 39 | |
| 40 | virtual void Visit(mirror::Object* object) = 0; |
| 41 | }; |
| 42 | |
Mathieu Chartier | 54d220e | 2015-07-30 16:20:06 -0700 | [diff] [blame] | 43 | class ArtMethodVisitor { |
| 44 | public: |
| 45 | virtual ~ArtMethodVisitor() {} |
| 46 | |
| 47 | virtual void Visit(ArtMethod* method) = 0; |
| 48 | }; |
| 49 | |
| 50 | class ArtFieldVisitor { |
| 51 | public: |
| 52 | virtual ~ArtFieldVisitor() {} |
| 53 | |
| 54 | virtual void Visit(ArtField* method) = 0; |
| 55 | }; |
| 56 | |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 57 | class PACKED(4) ImageSection { |
| 58 | public: |
| 59 | ImageSection() : offset_(0), size_(0) { } |
| 60 | ImageSection(uint32_t offset, uint32_t size) : offset_(offset), size_(size) { } |
| 61 | ImageSection(const ImageSection& section) = default; |
| 62 | ImageSection& operator=(const ImageSection& section) = default; |
| 63 | |
| 64 | uint32_t Offset() const { |
| 65 | return offset_; |
| 66 | } |
| 67 | |
| 68 | uint32_t Size() const { |
| 69 | return size_; |
| 70 | } |
| 71 | |
| 72 | uint32_t End() const { |
| 73 | return Offset() + Size(); |
| 74 | } |
| 75 | |
| 76 | bool Contains(uint64_t offset) const { |
| 77 | return offset - offset_ < size_; |
| 78 | } |
| 79 | |
| 80 | private: |
| 81 | uint32_t offset_; |
| 82 | uint32_t size_; |
| 83 | }; |
| 84 | |
Brian Carlstrom | 4a289ed | 2011-08-16 17:17:49 -0700 | [diff] [blame] | 85 | // header of image files written by ImageWriter, read and validated by Space. |
Ian Rogers | df1ce91 | 2012-11-27 17:07:11 -0800 | [diff] [blame] | 86 | class PACKED(4) ImageHeader { |
Brian Carlstrom | 4a289ed | 2011-08-16 17:17:49 -0700 | [diff] [blame] | 87 | public: |
Mathieu Chartier | ceb07b3 | 2015-12-10 09:33:21 -0800 | [diff] [blame] | 88 | enum StorageMode : uint32_t { |
| 89 | kStorageModeUncompressed, |
| 90 | kStorageModeLZ4, |
Mathieu Chartier | a6e81ed | 2016-02-25 13:52:10 -0800 | [diff] [blame] | 91 | kStorageModeLZ4HC, |
Mathieu Chartier | ceb07b3 | 2015-12-10 09:33:21 -0800 | [diff] [blame] | 92 | kStorageModeCount, // Number of elements in enum. |
| 93 | }; |
| 94 | static constexpr StorageMode kDefaultStorageMode = kStorageModeUncompressed; |
| 95 | |
Sebastien Hertz | aa50d3a | 2015-08-25 15:25:41 +0200 | [diff] [blame] | 96 | ImageHeader() |
Mathieu Chartier | ceb07b3 | 2015-12-10 09:33:21 -0800 | [diff] [blame] | 97 | : image_begin_(0U), |
| 98 | image_size_(0U), |
| 99 | oat_checksum_(0U), |
| 100 | oat_file_begin_(0U), |
| 101 | oat_data_begin_(0U), |
| 102 | oat_data_end_(0U), |
| 103 | oat_file_end_(0U), |
Mathieu Chartier | fbc3108 | 2016-01-24 11:59:56 -0800 | [diff] [blame] | 104 | boot_image_begin_(0U), |
| 105 | boot_image_size_(0U), |
| 106 | boot_oat_begin_(0U), |
| 107 | boot_oat_size_(0U), |
Mathieu Chartier | ceb07b3 | 2015-12-10 09:33:21 -0800 | [diff] [blame] | 108 | patch_delta_(0), |
| 109 | image_roots_(0U), |
| 110 | pointer_size_(0U), |
| 111 | compile_pic_(0), |
Mathieu Chartier | fbc3108 | 2016-01-24 11:59:56 -0800 | [diff] [blame] | 112 | is_pic_(0), |
Mathieu Chartier | ceb07b3 | 2015-12-10 09:33:21 -0800 | [diff] [blame] | 113 | storage_mode_(kDefaultStorageMode), |
| 114 | data_size_(0) {} |
Brian Carlstrom | 4a289ed | 2011-08-16 17:17:49 -0700 | [diff] [blame] | 115 | |
Ian Rogers | 30fab40 | 2012-01-23 15:43:46 -0800 | [diff] [blame] | 116 | ImageHeader(uint32_t image_begin, |
Mathieu Chartier | 763a31e | 2015-11-16 16:05:55 -0800 | [diff] [blame] | 117 | uint32_t image_size, |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 118 | ImageSection* sections, |
Brian Carlstrom | e24fa61 | 2011-09-29 00:53:55 -0700 | [diff] [blame] | 119 | uint32_t image_roots, |
| 120 | uint32_t oat_checksum, |
Brian Carlstrom | 700c8d3 | 2012-11-05 10:42:02 -0800 | [diff] [blame] | 121 | uint32_t oat_file_begin, |
| 122 | uint32_t oat_data_begin, |
| 123 | uint32_t oat_data_end, |
Igor Murashkin | 4677476 | 2014-10-22 11:37:02 -0700 | [diff] [blame] | 124 | uint32_t oat_file_end, |
Mathieu Chartier | fbc3108 | 2016-01-24 11:59:56 -0800 | [diff] [blame] | 125 | uint32_t boot_image_begin, |
| 126 | uint32_t boot_image_size, |
| 127 | uint32_t boot_oat_begin, |
| 128 | uint32_t boot_oat_size, |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 129 | uint32_t pointer_size, |
Mathieu Chartier | ceb07b3 | 2015-12-10 09:33:21 -0800 | [diff] [blame] | 130 | bool compile_pic, |
Mathieu Chartier | fbc3108 | 2016-01-24 11:59:56 -0800 | [diff] [blame] | 131 | bool is_pic, |
Mathieu Chartier | ceb07b3 | 2015-12-10 09:33:21 -0800 | [diff] [blame] | 132 | StorageMode storage_mode, |
| 133 | size_t data_size); |
Brian Carlstrom | 4a289ed | 2011-08-16 17:17:49 -0700 | [diff] [blame] | 134 | |
Brian Carlstrom | 68708f5 | 2013-09-03 14:15:31 -0700 | [diff] [blame] | 135 | bool IsValid() const; |
| 136 | const char* GetMagic() const; |
Brian Carlstrom | 78128a6 | 2011-09-15 17:21:19 -0700 | [diff] [blame] | 137 | |
Ian Rogers | 1373595 | 2014-10-08 12:43:28 -0700 | [diff] [blame] | 138 | uint8_t* GetImageBegin() const { |
| 139 | return reinterpret_cast<uint8_t*>(image_begin_); |
Brian Carlstrom | e24fa61 | 2011-09-29 00:53:55 -0700 | [diff] [blame] | 140 | } |
| 141 | |
Mathieu Chartier | 31e8925 | 2013-08-28 11:29:12 -0700 | [diff] [blame] | 142 | size_t GetImageSize() const { |
| 143 | return static_cast<uint32_t>(image_size_); |
| 144 | } |
| 145 | |
Brian Carlstrom | e24fa61 | 2011-09-29 00:53:55 -0700 | [diff] [blame] | 146 | uint32_t GetOatChecksum() const { |
| 147 | return oat_checksum_; |
| 148 | } |
| 149 | |
Brian Carlstrom | a85b837 | 2012-10-18 17:00:32 -0700 | [diff] [blame] | 150 | void SetOatChecksum(uint32_t oat_checksum) { |
| 151 | oat_checksum_ = oat_checksum; |
| 152 | } |
| 153 | |
Mathieu Chartier | 5351da0 | 2016-02-17 16:19:53 -0800 | [diff] [blame] | 154 | // The location that the oat file was expected to be when the image was created. The actual |
| 155 | // oat file may be at a different location for application images. |
Ian Rogers | 1373595 | 2014-10-08 12:43:28 -0700 | [diff] [blame] | 156 | uint8_t* GetOatFileBegin() const { |
| 157 | return reinterpret_cast<uint8_t*>(oat_file_begin_); |
Brian Carlstrom | e24fa61 | 2011-09-29 00:53:55 -0700 | [diff] [blame] | 158 | } |
| 159 | |
Ian Rogers | 1373595 | 2014-10-08 12:43:28 -0700 | [diff] [blame] | 160 | uint8_t* GetOatDataBegin() const { |
| 161 | return reinterpret_cast<uint8_t*>(oat_data_begin_); |
Brian Carlstrom | 700c8d3 | 2012-11-05 10:42:02 -0800 | [diff] [blame] | 162 | } |
| 163 | |
Ian Rogers | 1373595 | 2014-10-08 12:43:28 -0700 | [diff] [blame] | 164 | uint8_t* GetOatDataEnd() const { |
| 165 | return reinterpret_cast<uint8_t*>(oat_data_end_); |
Brian Carlstrom | 700c8d3 | 2012-11-05 10:42:02 -0800 | [diff] [blame] | 166 | } |
| 167 | |
Ian Rogers | 1373595 | 2014-10-08 12:43:28 -0700 | [diff] [blame] | 168 | uint8_t* GetOatFileEnd() const { |
| 169 | return reinterpret_cast<uint8_t*>(oat_file_end_); |
Brian Carlstrom | 4a289ed | 2011-08-16 17:17:49 -0700 | [diff] [blame] | 170 | } |
| 171 | |
Andreas Gampe | bda1d60 | 2016-08-29 17:43:45 -0700 | [diff] [blame] | 172 | PointerSize GetPointerSize() const; |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 173 | |
| 174 | uint32_t GetPointerSizeUnchecked() const { |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 175 | return pointer_size_; |
| 176 | } |
| 177 | |
Alex Light | 53cb16b | 2014-06-12 11:26:29 -0700 | [diff] [blame] | 178 | off_t GetPatchDelta() const { |
| 179 | return patch_delta_; |
| 180 | } |
| 181 | |
Nicolas Geoffray | 9583fbc | 2014-02-28 15:21:07 +0000 | [diff] [blame] | 182 | static std::string GetOatLocationFromImageLocation(const std::string& image) { |
David Brazdil | 7b49e6c | 2016-09-01 11:06:18 +0100 | [diff] [blame] | 183 | return GetLocationFromImageLocation(image, "oat"); |
| 184 | } |
| 185 | |
| 186 | static std::string GetVdexLocationFromImageLocation(const std::string& image) { |
| 187 | return GetLocationFromImageLocation(image, "vdex"); |
Nicolas Geoffray | 9583fbc | 2014-02-28 15:21:07 +0000 | [diff] [blame] | 188 | } |
| 189 | |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 190 | enum ImageMethod { |
Ian Rogers | 1984651 | 2012-02-24 11:42:47 -0800 | [diff] [blame] | 191 | kResolutionMethod, |
Jeff Hao | 88474b4 | 2013-10-23 16:24:40 -0700 | [diff] [blame] | 192 | kImtConflictMethod, |
Mathieu Chartier | 2d2621a | 2014-10-23 16:48:06 -0700 | [diff] [blame] | 193 | kImtUnimplementedMethod, |
Vladimir Marko | fd36f1f | 2016-08-03 18:49:58 +0100 | [diff] [blame] | 194 | kSaveAllCalleeSavesMethod, |
| 195 | kSaveRefsOnlyMethod, |
| 196 | kSaveRefsAndArgsMethod, |
Vladimir Marko | 952dbb1 | 2016-07-28 12:01:51 +0100 | [diff] [blame] | 197 | kSaveEverythingMethod, |
Mingyao Yang | 0a87a65 | 2017-04-12 13:43:15 -0700 | [diff] [blame] | 198 | kSaveEverythingMethodForClinit, |
| 199 | kSaveEverythingMethodForSuspendCheck, |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 200 | kImageMethodsCount, // Number of elements in enum. |
| 201 | }; |
| 202 | |
| 203 | enum ImageRoot { |
Brian Carlstrom | 58ae941 | 2011-10-04 00:56:06 -0700 | [diff] [blame] | 204 | kDexCaches, |
Brian Carlstrom | 34f426c | 2011-10-04 12:58:02 -0700 | [diff] [blame] | 205 | kClassRoots, |
Vladimir Marko | eca3eda | 2016-11-09 16:26:44 +0000 | [diff] [blame] | 206 | kClassLoader, // App image only. |
Brian Carlstrom | 1619286 | 2011-09-12 17:50:06 -0700 | [diff] [blame] | 207 | kImageRootsMax, |
| 208 | }; |
| 209 | |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 210 | enum ImageSections { |
| 211 | kSectionObjects, |
| 212 | kSectionArtFields, |
| 213 | kSectionArtMethods, |
Mathieu Chartier | e42888f | 2016-04-14 10:49:19 -0700 | [diff] [blame] | 214 | kSectionRuntimeMethods, |
Artem Udovichenko | a62cb9b | 2016-06-30 09:18:25 +0000 | [diff] [blame] | 215 | kSectionImTables, |
Mathieu Chartier | e42888f | 2016-04-14 10:49:19 -0700 | [diff] [blame] | 216 | kSectionIMTConflictTables, |
Vladimir Marko | 05792b9 | 2015-08-03 11:56:49 +0100 | [diff] [blame] | 217 | kSectionDexCacheArrays, |
Mathieu Chartier | d39645e | 2015-06-09 17:50:29 -0700 | [diff] [blame] | 218 | kSectionInternedStrings, |
Mathieu Chartier | 208a5cb | 2015-12-02 15:44:07 -0800 | [diff] [blame] | 219 | kSectionClassTable, |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 220 | kSectionImageBitmap, |
| 221 | kSectionCount, // Number of elements in enum. |
| 222 | }; |
| 223 | |
Vladimir Marko | eca3eda | 2016-11-09 16:26:44 +0000 | [diff] [blame] | 224 | static size_t NumberOfImageRoots(bool app_image) { |
| 225 | return app_image ? kImageRootsMax : kImageRootsMax - 1u; |
| 226 | } |
| 227 | |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 228 | ArtMethod* GetImageMethod(ImageMethod index) const; |
| 229 | void SetImageMethod(ImageMethod index, ArtMethod* method); |
| 230 | |
Vladimir Marko | cd87c3e | 2017-09-05 13:11:57 +0100 | [diff] [blame] | 231 | const ImageSection& GetImageSection(ImageSections index) const { |
| 232 | DCHECK_LT(static_cast<size_t>(index), kSectionCount); |
| 233 | return sections_[index]; |
| 234 | } |
| 235 | |
| 236 | const ImageSection& GetObjectsSection() const { |
| 237 | return GetImageSection(kSectionObjects); |
| 238 | } |
| 239 | |
| 240 | const ImageSection& GetFieldsSection() const { |
| 241 | return GetImageSection(ImageHeader::kSectionArtFields); |
| 242 | } |
Mathieu Chartier | e42888f | 2016-04-14 10:49:19 -0700 | [diff] [blame] | 243 | |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 244 | const ImageSection& GetMethodsSection() const { |
| 245 | return GetImageSection(kSectionArtMethods); |
| 246 | } |
| 247 | |
Mathieu Chartier | e42888f | 2016-04-14 10:49:19 -0700 | [diff] [blame] | 248 | const ImageSection& GetRuntimeMethodsSection() const { |
| 249 | return GetImageSection(kSectionRuntimeMethods); |
| 250 | } |
| 251 | |
Vladimir Marko | cd87c3e | 2017-09-05 13:11:57 +0100 | [diff] [blame] | 252 | const ImageSection& GetImTablesSection() const { |
| 253 | return GetImageSection(kSectionImTables); |
| 254 | } |
| 255 | |
| 256 | const ImageSection& GetIMTConflictTablesSection() const { |
| 257 | return GetImageSection(kSectionIMTConflictTables); |
| 258 | } |
| 259 | |
| 260 | const ImageSection& GetDexCacheArraysSection() const { |
| 261 | return GetImageSection(kSectionDexCacheArrays); |
| 262 | } |
| 263 | |
| 264 | const ImageSection& GetInternedStringsSection() const { |
| 265 | return GetImageSection(kSectionInternedStrings); |
| 266 | } |
| 267 | |
| 268 | const ImageSection& GetClassTableSection() const { |
| 269 | return GetImageSection(kSectionClassTable); |
| 270 | } |
| 271 | |
| 272 | const ImageSection& GetImageBitmapSection() const { |
| 273 | return GetImageSection(kSectionImageBitmap); |
Mathieu Chartier | e42888f | 2016-04-14 10:49:19 -0700 | [diff] [blame] | 274 | } |
| 275 | |
Mathieu Chartier | 4a26f17 | 2016-01-26 14:26:18 -0800 | [diff] [blame] | 276 | template <ReadBarrierOption kReadBarrierOption = kWithReadBarrier> |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 277 | mirror::Object* GetImageRoot(ImageRoot image_root) const |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 278 | REQUIRES_SHARED(Locks::mutator_lock_); |
Mathieu Chartier | 4a26f17 | 2016-01-26 14:26:18 -0800 | [diff] [blame] | 279 | |
| 280 | template <ReadBarrierOption kReadBarrierOption = kWithReadBarrier> |
Hiroshi Yamauchi | 2cd334a | 2015-01-09 14:03:35 -0800 | [diff] [blame] | 281 | mirror::ObjectArray<mirror::Object>* GetImageRoots() const |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 282 | REQUIRES_SHARED(Locks::mutator_lock_); |
Brian Carlstrom | aded5f7 | 2011-10-07 17:15:04 -0700 | [diff] [blame] | 283 | |
Alex Light | 53cb16b | 2014-06-12 11:26:29 -0700 | [diff] [blame] | 284 | void RelocateImage(off_t delta); |
Mathieu Chartier | fbc3108 | 2016-01-24 11:59:56 -0800 | [diff] [blame] | 285 | void RelocateImageMethods(off_t delta); |
| 286 | void RelocateImageObjects(off_t delta); |
Alex Light | 53cb16b | 2014-06-12 11:26:29 -0700 | [diff] [blame] | 287 | |
Igor Murashkin | 4677476 | 2014-10-22 11:37:02 -0700 | [diff] [blame] | 288 | bool CompilePic() const { |
| 289 | return compile_pic_ != 0; |
| 290 | } |
| 291 | |
Mathieu Chartier | fbc3108 | 2016-01-24 11:59:56 -0800 | [diff] [blame] | 292 | bool IsPic() const { |
| 293 | return is_pic_ != 0; |
| 294 | } |
| 295 | |
| 296 | uint32_t GetBootImageBegin() const { |
| 297 | return boot_image_begin_; |
| 298 | } |
| 299 | |
| 300 | uint32_t GetBootImageSize() const { |
| 301 | return boot_image_size_; |
| 302 | } |
| 303 | |
| 304 | uint32_t GetBootOatBegin() const { |
| 305 | return boot_oat_begin_; |
| 306 | } |
| 307 | |
| 308 | uint32_t GetBootOatSize() const { |
| 309 | return boot_oat_size_; |
| 310 | } |
| 311 | |
Mathieu Chartier | ceb07b3 | 2015-12-10 09:33:21 -0800 | [diff] [blame] | 312 | StorageMode GetStorageMode() const { |
| 313 | return storage_mode_; |
| 314 | } |
| 315 | |
| 316 | uint64_t GetDataSize() const { |
| 317 | return data_size_; |
| 318 | } |
| 319 | |
Mathieu Chartier | fbc3108 | 2016-01-24 11:59:56 -0800 | [diff] [blame] | 320 | bool IsAppImage() const { |
| 321 | // App images currently require a boot image, if the size is non zero then it is an app image |
| 322 | // header. |
| 323 | return boot_image_size_ != 0u; |
| 324 | } |
| 325 | |
Vladimir Marko | 6cfbdbc | 2017-07-25 13:26:39 +0100 | [diff] [blame] | 326 | uint32_t GetBootImageConstantTablesOffset() const { |
| 327 | // Interned strings table and class table for boot image are mmapped read only. |
| 328 | DCHECK(!IsAppImage()); |
| 329 | const ImageSection& interned_strings = GetInternedStringsSection(); |
| 330 | DCHECK_ALIGNED(interned_strings.Offset(), kPageSize); |
| 331 | return interned_strings.Offset(); |
| 332 | } |
| 333 | |
| 334 | uint32_t GetBootImageConstantTablesSize() const { |
| 335 | uint32_t start_offset = GetBootImageConstantTablesOffset(); |
| 336 | const ImageSection& class_table = GetClassTableSection(); |
| 337 | DCHECK_LE(start_offset, class_table.Offset()); |
| 338 | size_t tables_size = class_table.Offset() + class_table.Size() - start_offset; |
| 339 | return RoundUp(tables_size, kPageSize); |
| 340 | } |
| 341 | |
David Sehr | a49e053 | 2017-08-25 08:05:29 -0700 | [diff] [blame] | 342 | // Visit mirror::Objects in the section starting at base. |
| 343 | // TODO: Delete base parameter if it is always equal to GetImageBegin. |
| 344 | void VisitObjects(ObjectVisitor* visitor, |
| 345 | uint8_t* base, |
| 346 | PointerSize pointer_size) const |
| 347 | REQUIRES_SHARED(Locks::mutator_lock_); |
| 348 | |
Mathieu Chartier | e42888f | 2016-04-14 10:49:19 -0700 | [diff] [blame] | 349 | // Visit ArtMethods in the section starting at base. Includes runtime methods. |
| 350 | // TODO: Delete base parameter if it is always equal to GetImageBegin. |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 351 | void VisitPackedArtMethods(ArtMethodVisitor* visitor, |
| 352 | uint8_t* base, |
| 353 | PointerSize pointer_size) const; |
Mathieu Chartier | e42888f | 2016-04-14 10:49:19 -0700 | [diff] [blame] | 354 | |
| 355 | // Visit ArtMethods in the section starting at base. |
| 356 | // TODO: Delete base parameter if it is always equal to GetImageBegin. |
| 357 | void VisitPackedArtFields(ArtFieldVisitor* visitor, uint8_t* base) const; |
| 358 | |
| 359 | template <typename Visitor> |
Artem Udovichenko | a62cb9b | 2016-06-30 09:18:25 +0000 | [diff] [blame] | 360 | void VisitPackedImTables(const Visitor& visitor, |
| 361 | uint8_t* base, |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 362 | PointerSize pointer_size) const; |
Artem Udovichenko | a62cb9b | 2016-06-30 09:18:25 +0000 | [diff] [blame] | 363 | |
| 364 | template <typename Visitor> |
Mathieu Chartier | e42888f | 2016-04-14 10:49:19 -0700 | [diff] [blame] | 365 | void VisitPackedImtConflictTables(const Visitor& visitor, |
| 366 | uint8_t* base, |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 367 | PointerSize pointer_size) const; |
Mathieu Chartier | e42888f | 2016-04-14 10:49:19 -0700 | [diff] [blame] | 368 | |
Alex Light | 53cb16b | 2014-06-12 11:26:29 -0700 | [diff] [blame] | 369 | private: |
Ian Rogers | 1373595 | 2014-10-08 12:43:28 -0700 | [diff] [blame] | 370 | static const uint8_t kImageMagic[4]; |
| 371 | static const uint8_t kImageVersion[4]; |
Brian Carlstrom | 4a289ed | 2011-08-16 17:17:49 -0700 | [diff] [blame] | 372 | |
David Brazdil | 7b49e6c | 2016-09-01 11:06:18 +0100 | [diff] [blame] | 373 | static std::string GetLocationFromImageLocation(const std::string& image, |
| 374 | const std::string& extension) { |
| 375 | std::string filename = image; |
| 376 | if (filename.length() <= 3) { |
| 377 | filename += "." + extension; |
| 378 | } else { |
| 379 | filename.replace(filename.length() - 3, 3, extension); |
| 380 | } |
| 381 | return filename; |
| 382 | } |
| 383 | |
Ian Rogers | 1373595 | 2014-10-08 12:43:28 -0700 | [diff] [blame] | 384 | uint8_t magic_[4]; |
| 385 | uint8_t version_[4]; |
Brian Carlstrom | a663ea5 | 2011-08-19 23:33:41 -0700 | [diff] [blame] | 386 | |
Brian Carlstrom | 700c8d3 | 2012-11-05 10:42:02 -0800 | [diff] [blame] | 387 | // Required base address for mapping the image. |
Ian Rogers | 30fab40 | 2012-01-23 15:43:46 -0800 | [diff] [blame] | 388 | uint32_t image_begin_; |
Brian Carlstrom | e24fa61 | 2011-09-29 00:53:55 -0700 | [diff] [blame] | 389 | |
Mathieu Chartier | 31e8925 | 2013-08-28 11:29:12 -0700 | [diff] [blame] | 390 | // Image size, not page aligned. |
| 391 | uint32_t image_size_; |
| 392 | |
Brian Carlstrom | 700c8d3 | 2012-11-05 10:42:02 -0800 | [diff] [blame] | 393 | // Checksum of the oat file we link to for load time sanity check. |
Brian Carlstrom | e24fa61 | 2011-09-29 00:53:55 -0700 | [diff] [blame] | 394 | uint32_t oat_checksum_; |
| 395 | |
Brian Carlstrom | 700c8d3 | 2012-11-05 10:42:02 -0800 | [diff] [blame] | 396 | // Start address for oat file. Will be before oat_data_begin_ for .so files. |
| 397 | uint32_t oat_file_begin_; |
Brian Carlstrom | e24fa61 | 2011-09-29 00:53:55 -0700 | [diff] [blame] | 398 | |
Brian Carlstrom | 700c8d3 | 2012-11-05 10:42:02 -0800 | [diff] [blame] | 399 | // Required oat address expected by image Method::GetCode() pointers. |
| 400 | uint32_t oat_data_begin_; |
Brian Carlstrom | 1619286 | 2011-09-12 17:50:06 -0700 | [diff] [blame] | 401 | |
Brian Carlstrom | 700c8d3 | 2012-11-05 10:42:02 -0800 | [diff] [blame] | 402 | // End of oat data address range for this image file. |
| 403 | uint32_t oat_data_end_; |
| 404 | |
| 405 | // End of oat file address range. will be after oat_data_end_ for |
| 406 | // .so files. Used for positioning a following alloc spaces. |
| 407 | uint32_t oat_file_end_; |
| 408 | |
Mathieu Chartier | fbc3108 | 2016-01-24 11:59:56 -0800 | [diff] [blame] | 409 | // Boot image begin and end (app image headers only). |
| 410 | uint32_t boot_image_begin_; |
| 411 | uint32_t boot_image_size_; |
| 412 | |
| 413 | // Boot oat begin and end (app image headers only). |
| 414 | uint32_t boot_oat_begin_; |
| 415 | uint32_t boot_oat_size_; |
| 416 | |
| 417 | // TODO: We should probably insert a boot image checksum for app images. |
| 418 | |
Alex Light | 53cb16b | 2014-06-12 11:26:29 -0700 | [diff] [blame] | 419 | // The total delta that this image has been patched. |
| 420 | int32_t patch_delta_; |
| 421 | |
Brian Carlstrom | 700c8d3 | 2012-11-05 10:42:02 -0800 | [diff] [blame] | 422 | // Absolute address of an Object[] of objects needed to reinitialize from an image. |
Brian Carlstrom | 1619286 | 2011-09-12 17:50:06 -0700 | [diff] [blame] | 423 | uint32_t image_roots_; |
| 424 | |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 425 | // Pointer size, this affects the size of the ArtMethods. |
| 426 | uint32_t pointer_size_; |
| 427 | |
Igor Murashkin | 4677476 | 2014-10-22 11:37:02 -0700 | [diff] [blame] | 428 | // Boolean (0 or 1) to denote if the image was compiled with --compile-pic option |
| 429 | const uint32_t compile_pic_; |
| 430 | |
Mathieu Chartier | fbc3108 | 2016-01-24 11:59:56 -0800 | [diff] [blame] | 431 | // Boolean (0 or 1) to denote if the image can be mapped at a random address, this only refers to |
| 432 | // the .art file. Currently, app oat files do not depend on their app image. There are no pointers |
| 433 | // from the app oat code to the app image. |
| 434 | const uint32_t is_pic_; |
| 435 | |
Mathieu Chartier | 67ad20e | 2015-12-09 15:41:09 -0800 | [diff] [blame] | 436 | // Image section sizes/offsets correspond to the uncompressed form. |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 437 | ImageSection sections_[kSectionCount]; |
| 438 | |
Mathieu Chartier | fbc3108 | 2016-01-24 11:59:56 -0800 | [diff] [blame] | 439 | // Image methods, may be inside of the boot image for app images. |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 440 | uint64_t image_methods_[kImageMethodsCount]; |
| 441 | |
Mathieu Chartier | ceb07b3 | 2015-12-10 09:33:21 -0800 | [diff] [blame] | 442 | // Storage method for the image, the image may be compressed. |
| 443 | StorageMode storage_mode_; |
| 444 | |
| 445 | // Data size for the image data excluding the bitmap and the header. For compressed images, this |
| 446 | // is the compressed size in the file. |
| 447 | uint32_t data_size_; |
| 448 | |
Vladimir Marko | 7452797 | 2016-11-29 15:57:32 +0000 | [diff] [blame] | 449 | friend class linker::ImageWriter; |
Brian Carlstrom | 4a289ed | 2011-08-16 17:17:49 -0700 | [diff] [blame] | 450 | }; |
| 451 | |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 452 | std::ostream& operator<<(std::ostream& os, const ImageHeader::ImageMethod& policy); |
| 453 | std::ostream& operator<<(std::ostream& os, const ImageHeader::ImageRoot& policy); |
| 454 | std::ostream& operator<<(std::ostream& os, const ImageHeader::ImageSections& section); |
| 455 | std::ostream& operator<<(std::ostream& os, const ImageSection& section); |
Mathieu Chartier | ceb07b3 | 2015-12-10 09:33:21 -0800 | [diff] [blame] | 456 | std::ostream& operator<<(std::ostream& os, const ImageHeader::StorageMode& mode); |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 457 | |
Brian Carlstrom | 4a289ed | 2011-08-16 17:17:49 -0700 | [diff] [blame] | 458 | } // namespace art |
| 459 | |
Brian Carlstrom | fc0e321 | 2013-07-17 14:40:12 -0700 | [diff] [blame] | 460 | #endif // ART_RUNTIME_IMAGE_H_ |